Zum Inhalt springen

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.

  • Regeln eines Spiels in Klassen mit Zustand umsetzen
  • mit Set, EnumSet und EnumMap Regeln 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 herunterladen

Der 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.

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
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());
}
}

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
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.

Das Spiel kennt keine Regeln über Schiffe – das macht die Flotte. Es kennt die Regeln des Ablaufs: Wer darf wann was?

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.

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
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")));
}
}

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.

  1. Ein Schiff: Fülle Schiff aus, bis SchiffTest grün ist.

  2. Eine Flotte: Fülle Flotte aus, bis FlotteTest grün ist. Lies dazu noch einmal die Tabelle mit den Werkzeugen oben.

  3. Das Spiel: Fülle Spiel aus, bis SpielTest grün ist. Halte dich an die Tabelle des Zustandsautomaten.

  4. 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.

Schiff.java
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).

Flotte.java
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 immer amZug = seite.gegner() heißt es amZug = 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 einer Koordinate liefert – 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.

Spiel.java
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 + ")");
}
}
}