Schiffe versenken: Der Kern
Der Kern ist das Herz des Spiels: Hier stehen die Regeln. Wie lang ein Schiff ist, wann es versenkt ist, ob eine Aufstellung gilt, wer dran ist und wer gewinnt. Server und Client übersetzen nur – entschieden wird hier.
Der Kern weiß nichts vom Netz. Deshalb lässt er sich gut testgetrieben bauen: Die Tests stehen fest, und ihr schreibt den Code, der sie grün macht – Stufe für Stufe.
Was du am Ende kannst
Abschnitt betitelt „Was du am Ende kannst“- Regeln eines Spiels in Klassen mit Zustand umsetzen
- mit
Set,EnumSetundEnumMapRegeln kurz und sicher prüfen - die Phasen eines Ablaufs als Zustandsautomaten denken
- gegen vorgegebene Tests arbeiten, bis alle grün sind
Demo-Code: 36-schiffe-kern
⤓ schiffe-kern.zip herunterladenDer fertige Stand aus der Vorführung – zum Nachlesen, Ausprobieren und Weiterbauen.
Entpacke die ZIP-Datei nach C:\dev\intellij. In IntelliJ: File → Open… → den Ordner 36-schiffe-kern wählen → OK → Trust Project. IntelliJ erkennt die pom.xml und lädt die Bibliotheken selbst herunter – das dauert beim ersten Mal einen Moment.
Enthält: pom.xml, Ergebnis.java, Flotte.java, Koordinate.java, Phase.java, Richtung.java, Schiff.java, Schiffstyp.java, Seite.java, Spiel.java, FlotteTest.java, KoordinateTest.java, SchiffTest.java, SpielTest.java
Das Demo-Projekt enthält nur das Package spiel aus dem
Klassenmodell: die fertigen
kleinen Typen – Koordinate, Richtung, Schiffstyp, Ergebnis, Phase,
Seite – und die Gerüste von Schiff, Flotte und Spiel. Dazu drei
Testklassen. Starte sie: 17 von 20 Tests sind rot. Nur die drei für die
Koordinate sind schon grün.
Stufe 1: Ein Schiff
Abschnitt betitelt „Stufe 1: Ein Schiff“Ein Schiff entsteht aus Typ, Anfangsfeld und Richtung. Daraus berechnet es seine Kästchen – so viele, wie der Typ lang ist:
new Schiff(KREUZER, B2, SENKRECHT) new Schiff(ZERSTOERER, C4, WAAGERECHT)
A B C A B C D E 1 . . . 3 . . . . . 2 . ■ . ← B2 = Anfang 4 . . ■ ■ . ← C4, D4 3 . ■ . ← B3 = verschoben(1) 5 . . . . . 4 . ■ . ← B4 = verschoben(2)Die Koordinate hilft dabei: anfang.verschoben(richtung, i) liefert das
Kästchen i Schritte weiter. Ragt das Schiff über den Rand, wirft schon die
Koordinate eine IllegalArgumentException – das Schiff muss sie nur
weiterreichen, am besten mit einer verständlicheren Meldung.
Treffer merkt sich das Schiff in einem Set. Ein Set enthält jedes
Element nur einmal – zweimal dasselbe Kästchen zu treffen, zählt also von selbst
nur einmal. Versenkt ist das Schiff, wenn es so viele Treffer hat, wie es lang
ist.
SchiffTest.java
package de.drv.schiffe.spiel;
import static org.junit.jupiter.api.Assertions.assertEquals;import static org.junit.jupiter.api.Assertions.assertFalse;import static org.junit.jupiter.api.Assertions.assertThrows;import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.List;
import org.junit.jupiter.api.DisplayName;import org.junit.jupiter.api.Test;
/** Stufe 1: ein einzelnes Schiff. */class SchiffTest {
@Test @DisplayName("Stufe 1: Ein waagerechtes Schiff belegt Kästchen nach rechts") void waagerecht() { Schiff zerstoerer = new Schiff(Schiffstyp.ZERSTOERER, Koordinate.von("C4"), Richtung.WAAGERECHT); assertEquals(List.of(Koordinate.von("C4"), Koordinate.von("D4")), zerstoerer.getFelder()); assertEquals(Schiffstyp.ZERSTOERER, zerstoerer.getTyp()); }
@Test @DisplayName("Stufe 1: Ein senkrechtes Schiff belegt Kästchen nach unten – so viele, wie es lang ist") void senkrecht() { Schiff kreuzer = new Schiff(Schiffstyp.KREUZER, Koordinate.von("B2"), Richtung.SENKRECHT); assertEquals(List.of(Koordinate.von("B2"), Koordinate.von("B3"), Koordinate.von("B4")), kreuzer.getFelder()); }
@Test @DisplayName("Stufe 1: Ein Schiff, das über den Rand ragt, gibt es nicht") void ueberDenRand() { assertThrows(IllegalArgumentException.class, () -> new Schiff(Schiffstyp.FLUGZEUGTRAEGER, Koordinate.von("G1"), Richtung.WAAGERECHT)); assertThrows(IllegalArgumentException.class, () -> new Schiff(Schiffstyp.SCHLACHTSCHIFF, Koordinate.von("A8"), Richtung.SENKRECHT)); // Genau bis an den Rand ist erlaubt new Schiff(Schiffstyp.FLUGZEUGTRAEGER, Koordinate.von("F1"), Richtung.WAAGERECHT); }
@Test @DisplayName("Stufe 1: belegt sagt, ob ein Kästchen zum Schiff gehört") void belegt() { Schiff kreuzer = new Schiff(Schiffstyp.KREUZER, Koordinate.von("B2"), Richtung.SENKRECHT); assertTrue(kreuzer.belegt(Koordinate.von("B3"))); assertFalse(kreuzer.belegt(Koordinate.von("C3"))); assertFalse(kreuzer.belegt(Koordinate.von("B5"))); }
@Test @DisplayName("Stufe 1: Erst wenn jedes Kästchen getroffen ist, ist das Schiff versenkt") void versenkt() { Schiff zerstoerer = new Schiff(Schiffstyp.ZERSTOERER, Koordinate.von("C4"), Richtung.WAAGERECHT); assertFalse(zerstoerer.istVersenkt()); zerstoerer.triff(Koordinate.von("C4")); assertFalse(zerstoerer.istVersenkt()); zerstoerer.triff(Koordinate.von("C4")); // derselbe Treffer zählt nur einmal assertFalse(zerstoerer.istVersenkt()); zerstoerer.triff(Koordinate.von("J10")); // gehört nicht zum Schiff – ändert nichts assertFalse(zerstoerer.istVersenkt()); zerstoerer.triff(Koordinate.von("D4")); assertTrue(zerstoerer.istVersenkt()); }
}Stufe 2: Eine Flotte
Abschnitt betitelt „Stufe 2: Eine Flotte“Die Flotte prüft beim Aufstellen zwei Regeln – und dafür gibt es genau passende Werkzeuge:
| Regel | Werkzeug | wie |
|---|---|---|
| Jeder Schiffstyp genau einmal | EnumSet<Schiffstyp> |
Jeden Typ hinzufügen. add liefert false, wenn er schon drin war – doppelt. Am Ende müssen es fünf sein. |
| Keine Überschneidung | Set<Koordinate> |
Jedes Kästchen jedes Schiffs hinzufügen. Liefert add einmal false, überschneiden sich zwei Schiffe. |
Beim Beschießen merkt sich die Flotte jedes beschossene Kästchen – auch
Wasser. Ein zweiter Schuss auf dasselbe Kästchen ist nicht erlaubt: eine
IllegalStateException. Sonst sucht sie das Schiff, das das Kästchen belegt,
und fragt es nach dem Treffer: versenkt oder nicht.
FlotteTest.java
package de.drv.schiffe.spiel;
import static org.junit.jupiter.api.Assertions.assertEquals;import static org.junit.jupiter.api.Assertions.assertFalse;import static org.junit.jupiter.api.Assertions.assertThrows;import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.ArrayList;import java.util.List;
import org.junit.jupiter.api.DisplayName;import org.junit.jupiter.api.Test;
/** Stufe 2: eine ganze Flotte. */class FlotteTest {
/** Alle fünf Schiffe waagerecht ab Spalte A, in den Zeilen 1, 3, 5, 7 und 9. */ static List<Schiff> standardflotte() { List<Schiff> schiffe = new ArrayList<>(); int zeile = 1; for (Schiffstyp typ : Schiffstyp.values()) { schiffe.add(new Schiff(typ, Koordinate.von("A" + zeile), Richtung.WAAGERECHT)); zeile += 2; } return schiffe; }
@Test @DisplayName("Stufe 2: Eine Flotte mit allen fünf Schiffen lässt sich aufstellen") void aufstellen() { new Flotte(standardflotte()); }
@Test @DisplayName("Stufe 2: Jeder Schiffstyp genau einmal – nicht doppelt, keiner fehlt") void jederTypEinmal() { List<Schiff> doppelt = standardflotte(); doppelt.set(4, new Schiff(Schiffstyp.KREUZER, Koordinate.von("A10"), Richtung.WAAGERECHT)); assertThrows(IllegalArgumentException.class, () -> new Flotte(doppelt));
List<Schiff> zuWenig = standardflotte(); zuWenig.remove(0); assertThrows(IllegalArgumentException.class, () -> new Flotte(zuWenig));
assertThrows(IllegalArgumentException.class, () -> new Flotte(List.of())); }
@Test @DisplayName("Stufe 2: Zwei Schiffe dürfen sich nicht überschneiden") void ueberschneidung() { List<Schiff> ueberschnitten = standardflotte(); ueberschnitten.set(4, new Schiff(Schiffstyp.ZERSTOERER, Koordinate.von("A1"), Richtung.SENKRECHT)); assertThrows(IllegalArgumentException.class, () -> new Flotte(ueberschnitten)); }
@Test @DisplayName("Stufe 2: Wasser, Treffer, versenkt") void ergebnisse() { Flotte flotte = new Flotte(standardflotte()); assertEquals(Ergebnis.WASSER, flotte.beschiesse(Koordinate.von("J10"))); assertEquals(Ergebnis.TREFFER, flotte.beschiesse(Koordinate.von("A9"))); // der Zerstörer in Zeile 9 assertEquals(Ergebnis.VERSENKT, flotte.beschiesse(Koordinate.von("B9"))); assertEquals(Ergebnis.TREFFER, flotte.beschiesse(Koordinate.von("E1"))); // der Flugzeugträger }
@Test @DisplayName("Stufe 2: Auf kein Kästchen darf zweimal geschossen werden – auch nicht auf Wasser") void zweimal() { Flotte flotte = new Flotte(standardflotte()); flotte.beschiesse(Koordinate.von("A1")); flotte.beschiesse(Koordinate.von("J10")); assertThrows(IllegalStateException.class, () -> flotte.beschiesse(Koordinate.von("A1"))); assertThrows(IllegalStateException.class, () -> flotte.beschiesse(Koordinate.von("J10"))); }
@Test @DisplayName("Stufe 2: Sind alle 17 Kästchen getroffen, ist die Flotte versenkt") void alleVersenkt() { List<Schiff> schiffe = standardflotte(); Flotte flotte = new Flotte(schiffe); int treffer = 0; for (Schiff schiff : schiffe) { for (Koordinate feld : schiff.getFelder()) { assertFalse(flotte.istVersenkt()); flotte.beschiesse(feld); treffer++; } } assertEquals(17, treffer); assertTrue(flotte.istVersenkt()); }
}Die Methode standardflotte() im Test wird auch vom SpielTest benutzt: fünf
Schiffe, waagerecht ab Spalte A, in jeder zweiten Zeile. Die Zeilen 2, 4, 6, 8 und
10 bleiben leer – praktisch für Schüsse ins Wasser.
Stufe 3: Das Spiel
Abschnitt betitelt „Stufe 3: Das Spiel“Das Spiel kennt keine Regeln über Schiffe – das macht die Flotte. Es kennt
die Regeln des Ablaufs: Wer darf wann was?
Ein Zustandsautomat
Abschnitt betitelt „Ein Zustandsautomat“Ein Spiel ist immer in genau einer Phase. Jede Methode ist nur in bestimmten Phasen erlaubt und kann die Phase wechseln:
new Spiel() │ ▼ ┌───────────────────────┐ │ WARTEN_AUF_GEGNER │ └───────────┬───────────┘ │ gegnerTrittBei() ▼ ┌───────────────────────┐ stelleAuf(EINS, …) │ AUFSTELLEN │ ◀──────────────┐ └───────────┬───────────┘ ───────────────┘ │ stelleAuf(…) – die zweite Flotte ▼ ┌───────────────────────┐ schiesse(…) – Wasser oder Treffer: │ LAEUFT │ ◀──────────────┐ der andere ist dran └───────────┬───────────┘ ───────────────┘ │ schiesse(…) – die letzte gegnerische Flotte versenkt ▼ ┌───────────────────────┐ │ VORBEI │ └───────────────────────┘WARTEN_AUF_GEGNER |
AUFSTELLEN |
LAEUFT |
VORBEI |
|
|---|---|---|---|---|
gegnerTrittBei() |
✓ → AUFSTELLEN |
✗ | ✗ | ✗ |
stelleAuf(seite, …) |
✗ | ✓, je Seite einmal; die zweite → LAEUFT |
✗ | ✗ |
schiesse(seite, …) |
✗ | ✗ | ✓, nur wer dran ist | ✗ |
Jedes ✗ ist eine IllegalStateException. Wer diese Tabelle im Kopf hat, schreibt
jede Methode nach demselben Muster: erst die Phase prüfen, dann handeln, dann
vielleicht die Phase wechseln. Eine kleine Hilfsmethode pruefePhase(erwartet)
spart dabei viele gleiche Zeilen.
Was das Spiel sich merkt
Abschnitt betitelt „Was das Spiel sich merkt“| Feld | Typ | warum |
|---|---|---|
phase |
Phase |
der aktuelle Zustand |
flotten |
EnumMap<Seite, Flotte> |
je Seite eine Flotte – erst nach dem Aufstellen da |
schuesse |
EnumMap<Seite, Map<Koordinate, Ergebnis>> |
je Seite alle Schüsse mit Ergebnis – als LinkedHashMap, damit die Reihenfolge erhalten bleibt |
amZug, gewinner |
Seite |
intern null, solange es keinen gibt – nach außen ein Optional |
schuesseVon(seite) gibt die Map nicht einfach heraus – sonst könnte jemand von
außen Schüsse eintragen. Collections.unmodifiableMap(…) liefert eine Ansicht,
die sich nur lesen lässt.
SpielTest.java
package de.drv.schiffe.spiel;
import static org.junit.jupiter.api.Assertions.assertEquals;import static org.junit.jupiter.api.Assertions.assertThrows;
import java.util.Map;import java.util.Optional;
import org.junit.jupiter.api.DisplayName;import org.junit.jupiter.api.Test;
/** Stufe 3: der Ablauf eines Spiels. */class SpielTest {
private static Flotte flotte() { return new Flotte(FlotteTest.standardflotte()); }
private static Spiel laufendesSpiel() { Spiel spiel = new Spiel(); spiel.gegnerTrittBei(); spiel.stelleAuf(Seite.EINS, flotte()); spiel.stelleAuf(Seite.ZWEI, flotte()); return spiel; }
@Test @DisplayName("Stufe 3: Ein neues Spiel wartet auf den Gegner, niemand ist dran") void neu() { Spiel spiel = new Spiel(); assertEquals(Phase.WARTEN_AUF_GEGNER, spiel.getPhase()); assertEquals(Optional.empty(), spiel.amZug()); assertEquals(Optional.empty(), spiel.gewinner()); assertEquals(Map.of(), spiel.schuesseVon(Seite.EINS)); }
@Test @DisplayName("Stufe 3: Erst beitreten, dann aufstellen – und erst wenn beide aufgestellt haben, beginnt EINS") void phasen() { Spiel spiel = new Spiel(); assertThrows(IllegalStateException.class, () -> spiel.stelleAuf(Seite.EINS, flotte())); spiel.gegnerTrittBei(); assertEquals(Phase.AUFSTELLEN, spiel.getPhase()); spiel.stelleAuf(Seite.EINS, flotte()); assertEquals(Phase.AUFSTELLEN, spiel.getPhase()); assertEquals(Optional.empty(), spiel.amZug()); spiel.stelleAuf(Seite.ZWEI, flotte()); assertEquals(Phase.LAEUFT, spiel.getPhase()); assertEquals(Optional.of(Seite.EINS), spiel.amZug()); }
@Test @DisplayName("Stufe 3: Was in der falschen Phase kommt, wird abgelehnt") void falschePhase() { Spiel spiel = new Spiel(); assertThrows(IllegalStateException.class, () -> spiel.schiesse(Seite.EINS, Koordinate.von("A1"))); spiel.gegnerTrittBei(); assertThrows(IllegalStateException.class, spiel::gegnerTrittBei); // ein dritter Spieler spiel.stelleAuf(Seite.EINS, flotte()); assertThrows(IllegalStateException.class, () -> spiel.stelleAuf(Seite.EINS, flotte())); // noch einmal assertThrows(IllegalStateException.class, () -> spiel.schiesse(Seite.EINS, Koordinate.von("A1"))); }
@Test @DisplayName("Stufe 3: Es wird abwechselnd geschossen – wer nicht dran ist, wird abgelehnt") void abwechselnd() { Spiel spiel = laufendesSpiel(); assertThrows(IllegalStateException.class, () -> spiel.schiesse(Seite.ZWEI, Koordinate.von("A1"))); assertEquals(Ergebnis.TREFFER, spiel.schiesse(Seite.EINS, Koordinate.von("A1"))); assertEquals(Optional.of(Seite.ZWEI), spiel.amZug()); assertThrows(IllegalStateException.class, () -> spiel.schiesse(Seite.EINS, Koordinate.von("A2"))); assertEquals(Ergebnis.WASSER, spiel.schiesse(Seite.ZWEI, Koordinate.von("J10"))); assertEquals(Optional.of(Seite.EINS), spiel.amZug()); }
@Test @DisplayName("Stufe 3: Jede Seite sieht ihre Schüsse mit den Ergebnissen") void schuesse() { Spiel spiel = laufendesSpiel(); spiel.schiesse(Seite.EINS, Koordinate.von("A1")); spiel.schiesse(Seite.ZWEI, Koordinate.von("J10")); spiel.schiesse(Seite.EINS, Koordinate.von("J10")); assertEquals(Map.of(Koordinate.von("A1"), Ergebnis.TREFFER, Koordinate.von("J10"), Ergebnis.WASSER), spiel.schuesseVon(Seite.EINS)); assertEquals(Map.of(Koordinate.von("J10"), Ergebnis.WASSER), spiel.schuesseVon(Seite.ZWEI)); }
@Test @DisplayName("Stufe 3: Wer die gegnerische Flotte versenkt, gewinnt – danach geht nichts mehr") void gewinnen() { Spiel spiel = laufendesSpiel(); int fehlschuesse = 0; for (Schiff schiff : FlotteTest.standardflotte()) { for (Koordinate feld : schiff.getFelder()) { spiel.schiesse(Seite.EINS, feld); if (spiel.getPhase() == Phase.LAEUFT) { // ZWEI schießt nur in die leeren Zeilen 2, 4, 6, 8 und 10 spiel.schiesse(Seite.ZWEI, new Koordinate(fehlschuesse % 10, 1 + 2 * (fehlschuesse / 10))); fehlschuesse++; } } } assertEquals(Phase.VORBEI, spiel.getPhase()); assertEquals(Optional.of(Seite.EINS), spiel.gewinner()); assertEquals(Optional.empty(), spiel.amZug()); assertThrows(IllegalStateException.class, () -> spiel.schiesse(Seite.ZWEI, Koordinate.von("J1"))); }
}Übung: Alle Tests grün
Abschnitt betitelt „Übung: Alle Tests grün“Arbeite im Demo-Projekt 36-schiffe-kern. Lass nach jedem Schritt die Tests
laufen – rechts im Fenster Maven mit test, oder mit dem grünen Dreieck
neben einer Testklasse.
-
Ein Schiff: Fülle
Schiffaus, bisSchiffTestgrün ist. -
Eine Flotte: Fülle
Flotteaus, bisFlotteTestgrün ist. Lies dazu noch einmal die Tabelle mit den Werkzeugen oben. -
Das Spiel: Fülle
Spielaus, bisSpielTestgrün ist. Halte dich an die Tabelle des Zustandsautomaten. -
Für Schnelle – andere Regeln: Viele spielen mit Zusatzregeln. Probiere eine aus – mit einem eigenen Test, bevor du den Code änderst:
- Wer trifft, darf noch einmal. Nach einem Treffer bleibt dieselbe Seite dran – nur nach Wasser wechselt es.
- Schiffe dürfen sich nicht berühren – auch nicht über Eck.
Was musst du dafür außerhalb des Packages
spieländern?
Lösung
getFelder() gibt mit List.copyOf eine Kopie heraus, die sich nicht ändern
lässt – so kann niemand von außen Kästchen hinzufügen. triff prüft erst, ob das
Kästchen zum Schiff gehört. Sonst würde ein Treffer auf J10 den Zerstörer
versenken helfen.
package de.drv.schiffe.spiel;
import java.util.ArrayList;import java.util.HashSet;import java.util.List;import java.util.Set;
/** Ein aufgestelltes Schiff: sein Typ, seine Kästchen und welche davon getroffen sind. */public class Schiff {
private final Schiffstyp typ; private final List<Koordinate> felder = new ArrayList<>(); private final Set<Koordinate> treffer = new HashSet<>();
/** * Ein Schiff dieses Typs, das bei {@code anfang} beginnt und in {@code richtung} liegt. * * @throws IllegalArgumentException wenn es über den Rand hinausragt */ public Schiff(Schiffstyp typ, Koordinate anfang, Richtung richtung) { this.typ = typ; for (int i = 0; i < typ.getLaenge(); i++) { try { felder.add(anfang.verschoben(richtung, i)); } catch (IllegalArgumentException e) { throw new IllegalArgumentException(typ + " ab " + anfang + " ragt über den Rand"); } } }
public Schiffstyp getTyp() { return typ; }
/** Alle Kästchen, die das Schiff belegt – so viele, wie es lang ist. */ public List<Koordinate> getFelder() { return List.copyOf(felder); }
/** Ob das Schiff dieses Kästchen belegt. */ public boolean belegt(Koordinate feld) { return felder.contains(feld); }
/** Vermerkt einen Treffer auf diesem Kästchen. */ public void triff(Koordinate feld) { if (belegt(feld)) { treffer.add(feld); } }
/** Ob alle Kästchen getroffen sind. */ public boolean istVersenkt() { return treffer.size() == felder.size(); }
}Lösung
Die Meldung bei fehlenden Schiffen nennt sie beim Namen:
EnumSet.allOf(…) minus die, die da sind. istVersenkt ist eine einfache
Schleife – mit einem Stream ginge es als
schiffe.stream().allMatch(Schiff::istVersenkt).
package de.drv.schiffe.spiel;
import java.util.EnumSet;import java.util.HashSet;import java.util.List;import java.util.Set;
/** * Die Flotte eines Spielers auf seinem Feld. Sie prüft beim Aufstellen alle Regeln und * beantwortet die Schüsse des Gegners. */public class Flotte {
private final List<Schiff> schiffe; private final Set<Koordinate> beschossen = new HashSet<>();
/** * Stellt die Flotte auf. * * @throws IllegalArgumentException wenn nicht jeder {@link Schiffstyp} genau einmal dabei ist * oder sich zwei Schiffe überschneiden */ public Flotte(List<Schiff> schiffe) { Set<Schiffstyp> typen = EnumSet.noneOf(Schiffstyp.class); Set<Koordinate> belegt = new HashSet<>(); for (Schiff schiff : schiffe) { if (!typen.add(schiff.getTyp())) { throw new IllegalArgumentException(schiff.getTyp() + " ist doppelt"); } for (Koordinate feld : schiff.getFelder()) { if (!belegt.add(feld)) { throw new IllegalArgumentException("Zwei Schiffe überschneiden sich auf " + feld); } } } if (typen.size() != Schiffstyp.values().length) { Set<Schiffstyp> fehlen = EnumSet.allOf(Schiffstyp.class); fehlen.removeAll(typen); throw new IllegalArgumentException("Es fehlen: " + fehlen); } this.schiffe = List.copyOf(schiffe); }
/** * Beantwortet einen Schuss auf dieses Feld. * * @throws IllegalStateException wenn auf dieses Kästchen schon geschossen wurde */ public Ergebnis beschiesse(Koordinate ziel) { if (!beschossen.add(ziel)) { throw new IllegalStateException("Auf " + ziel + " wurde schon geschossen"); } for (Schiff schiff : schiffe) { if (schiff.belegt(ziel)) { schiff.triff(ziel); return schiff.istVersenkt() ? Ergebnis.VERSENKT : Ergebnis.TREFFER; } } return Ergebnis.WASSER; }
/** Ob alle Schiffe versenkt sind. */ public boolean istVersenkt() { for (Schiff schiff : schiffe) { if (!schiff.istVersenkt()) { return false; } } return true; }
}Lösung
Jede öffentliche Methode beginnt mit pruefePhase – das ist die Tabelle des
Zustandsautomaten, Zeile für Zeile.
Zu Stufe 4:
- Wer trifft, darf noch einmal ist eine Zeile in
schiesse: Statt immeramZug = seite.gegner()heißt esamZug = ergebnis == Ergebnis.WASSER ? seite.gegner() : seite; - Nicht berühren gehört in den Konstruktor der
Flotte: Für jedes Kästchen eines Schiffs prüfen, ob eines der acht Nachbarkästchen zu einem anderen Schiff gehört. Dazu braucht man eine Methode, die die Nachbarn einerKoordinateliefert – ohne über den Rand zu gehen.
Außerhalb von spiel ändert sich bei beiden nichts: Server, Client und
Protokoll merken nicht, dass die Regeln andere sind. Nur der Mensch an der Konsole
merkt es – beim Spielen.
package de.drv.schiffe.spiel;
import java.util.Collections;import java.util.EnumMap;import java.util.LinkedHashMap;import java.util.Map;import java.util.Optional;
/** * Ein Spiel zwischen zwei Seiten: seine Phase, wer dran ist, die beiden Flotten und alle Schüsse. * Hier stehen die Regeln des Ablaufs – nichts über Netz, Tokens oder JSON. */public class Spiel {
private Phase phase = Phase.WARTEN_AUF_GEGNER; private final Map<Seite, Flotte> flotten = new EnumMap<>(Seite.class); private final Map<Seite, Map<Koordinate, Ergebnis>> schuesse = new EnumMap<>(Seite.class); private Seite amZug; private Seite gewinner;
/** Ein neues Spiel – Spieler 1 ist da, die Phase ist WARTEN_AUF_GEGNER. */ public Spiel() { for (Seite seite : Seite.values()) { schuesse.put(seite, new LinkedHashMap<>()); // in der Reihenfolge der Schüsse } }
/** Spieler 2 tritt bei, die Phase wird AUFSTELLEN. */ public void gegnerTrittBei() { pruefePhase(Phase.WARTEN_AUF_GEGNER, "Das Spiel hat schon zwei Spieler"); phase = Phase.AUFSTELLEN; }
/** * Eine Seite stellt ihre Flotte auf. Haben beide aufgestellt, beginnt das Spiel – Seite EINS * schießt zuerst. * * @throws IllegalStateException wenn die Phase nicht AUFSTELLEN ist oder schon aufgestellt wurde */ public void stelleAuf(Seite seite, Flotte flotte) { pruefePhase(Phase.AUFSTELLEN, "Aufstellen geht gerade nicht"); if (flotten.containsKey(seite)) { throw new IllegalStateException("Die Flotte ist schon aufgestellt"); } flotten.put(seite, flotte); if (flotten.size() == 2) { phase = Phase.LAEUFT; amZug = Seite.EINS; } }
/** * Eine Seite schießt auf das Feld der anderen. Danach ist die andere Seite dran – oder das * Spiel ist vorbei. * * @throws IllegalStateException wenn das Spiel nicht läuft, die Seite nicht dran ist * oder das Kästchen schon beschossen wurde */ public Ergebnis schiesse(Seite seite, Koordinate ziel) { pruefePhase(Phase.LAEUFT, "Das Spiel läuft nicht"); if (seite != amZug) { throw new IllegalStateException("Du bist nicht dran"); } Flotte gegner = flotten.get(seite.gegner()); Ergebnis ergebnis = gegner.beschiesse(ziel); // wirft, wenn schon beschossen schuesse.get(seite).put(ziel, ergebnis);
if (gegner.istVersenkt()) { phase = Phase.VORBEI; gewinner = seite; amZug = null; } else { amZug = seite.gegner(); } return ergebnis; }
public Phase getPhase() { return phase; }
/** Wer gerade schießen darf – leer, solange das Spiel nicht läuft. */ public Optional<Seite> amZug() { return Optional.ofNullable(amZug); }
/** Die Schüsse, die eine Seite abgegeben hat, mit ihren Ergebnissen. */ public Map<Koordinate, Ergebnis> schuesseVon(Seite seite) { return Collections.unmodifiableMap(schuesse.get(seite)); }
/** Wer gewonnen hat – leer, solange das Spiel nicht vorbei ist. */ public Optional<Seite> gewinner() { return Optional.ofNullable(gewinner); }
private void pruefePhase(Phase erwartet, String meldung) { if (phase != erwartet) { throw new IllegalStateException(meldung + " (Phase " + phase + ")"); } }
}