Zum Inhalt springen

Schiffe versenken: Der Server

Der Server ist der Schiedsrichter: Er kennt beide Flotten, achtet auf die Reihenfolge und beantwortet jeden Schuss. Dabei tut er erstaunlich wenig selbst – die Regeln stehen im Kern, die Spiele führt der Spieldienst. Der Server übersetzt: HTTP hinein, Aufrufe des Dienstes, HTTP hinaus.

  • erklären, was ein Server mit jeder Anfrage tut
  • Anfragen anhand von Methode und Pfad an die richtige Stelle leiten
  • JSON mit Jackson lesen und schreiben
  • Exceptions in die passenden Statuscodes übersetzen
  • einen Server ohne Client testen – mit curl und mit JUnit

Demo-Code: 34-schiffe-server

⤓ schiffe-server.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 34-schiffe-server 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, flotte.json, ClientStart.java, Feldanzeige.java, HttpSpieldienst.java, Konsole.java, AttrappenSpieldienst.java, Aufstellung.java, Beitritt.java, LokalerSpieldienst.java, SpielNichtGefunden.java, Spieldienst.java, Spielstand.java, Nachrichten.java, Protokoll.java, FehlendesToken.java, ServerStart.java, SpielServer.java, Ergebnis.java, Flotte.java, Koordinate.java, Phase.java, Richtung.java, Schiff.java, Schiffstyp.java, Seite.java, Spiel.java, KoordinateTest.java

Das Demo-Projekt enthält das Gerüst aus dem Klassenmodell und dazu:

  • den Rahmen des Servers – Routing, JSON, Fehlerbehandlung und Protokoll der Anfragen sind fertig,
  • einen fertigen Endpunkt, POST /spiele; die anderen vier antworten mit 501 Not Implemented,
  • eine Attrappe des Spieldienstes, damit der Server laufen kann, bevor der echte Kern fertig ist,
  • Jackson 3 in der pom.xml und eine Datei flotte.json zum Ausprobieren.
HTTP-Anfrage
│
▼
1. Routing Methode und Pfad: Welcher Endpunkt ist gemeint? POST /spiele/7f3a/schuesse
2. Lesen Token aus dem Header, Rumpf aus JSON X-Spieler, {"feld":"B7"}
3. Übersetzen Nachricht → fachliche Typen Koordinate.von("B7")
4. Aufrufen den Spieldienst dienst.schiessen(…)
5. Antworten Ergebnis → Nachricht → JSON – oder Fehler → Status {"ergebnis":"TREFFER"}
│
▼
HTTP-Antwort

Jeder Endpunkt hat dieselben fünf Schritte. Nur Schritt 4 ist bei jedem anders – alles andere ist Handwerk, und dieses Handwerk steckt im Rahmen.

SpielServer.java – der Rahmen im Ganzen
SpielServer.java
package de.drv.schiffe.server;
import de.drv.schiffe.dienst.Beitritt;
import de.drv.schiffe.dienst.SpielNichtGefunden;
import de.drv.schiffe.dienst.Spieldienst;
import de.drv.schiffe.protokoll.Nachrichten.BeitrittAntwort;
import de.drv.schiffe.protokoll.Nachrichten.Fehler;
import de.drv.schiffe.protokoll.Protokoll;
import com.sun.net.httpserver.HttpExchange;
import com.sun.net.httpserver.HttpServer;
import tools.jackson.core.JacksonException;
import tools.jackson.databind.json.JsonMapper;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetSocketAddress;
import java.util.concurrent.Executors;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* Übersetzt HTTP in Aufrufe des {@link Spieldienst}es – und die Ergebnisse zurück in HTTP.
*
* <p>Der Rahmen ist fertig: Routing, JSON lesen und schreiben, Fehler in Statuscodes übersetzen,
* jede Anfrage protokollieren. Umgesetzt ist ein Endpunkt, {@code POST /spiele}; die anderen vier
* antworten noch mit {@code 501 Not Implemented}.
*/
public class SpielServer {
// Die Pfade mit einer Spiel-ID – die ID steht in Gruppe 1
private static final Pattern SPIEL = Pattern.compile("/spiele/([^/]+)");
private static final Pattern SPIELER = Pattern.compile("/spiele/([^/]+)/spieler");
private static final Pattern FLOTTE = Pattern.compile("/spiele/([^/]+)/flotte");
private static final Pattern SCHUESSE = Pattern.compile("/spiele/([^/]+)/schuesse");
private final Spieldienst dienst;
private final int port;
private final JsonMapper json = JsonMapper.builder().build();
private HttpServer server;
/** @param port 0 heißt: irgendein freier Port – praktisch für Tests */
public SpielServer(Spieldienst dienst, int port) {
this.dienst = dienst;
this.port = port;
}
public void starte() throws IOException {
server = HttpServer.create(new InetSocketAddress(port), 0);
server.createContext(Protokoll.SPIELE, this::bearbeite);
// Jede Anfrage in einem eigenen virtuellen Thread – mehrere Spieler gleichzeitig
server.setExecutor(Executors.newVirtualThreadPerTaskExecutor());
server.start();
System.out.println("Spiel-Server auf http://localhost:" + getPort());
}
public void stoppe() {
server.stop(0);
}
/** Der tatsächliche Port – auch wenn beim Start 0 angegeben war. */
public int getPort() {
return server.getAddress().getPort();
}
// ----- Eingang: jede Anfrage kommt hier an -------------------------------------------
private void bearbeite(HttpExchange anfrage) {
long start = System.nanoTime();
int status;
try {
status = leiteWeiter(anfrage);
} catch (FehlendesToken e) {
status = fehler(anfrage, 403, e.getMessage());
} catch (SpielNichtGefunden e) {
status = fehler(anfrage, 404, e.getMessage());
} catch (JacksonException e) {
status = fehler(anfrage, 400, "Kein gültiges JSON: " + e.getOriginalMessage());
} catch (IllegalArgumentException e) {
status = fehler(anfrage, 400, e.getMessage());
} catch (IllegalStateException e) {
status = fehler(anfrage, 409, e.getMessage());
} catch (Exception e) {
e.printStackTrace(); // unerwartet – ein Fehler im Server selbst
status = fehler(anfrage, 500, "Interner Fehler");
}
long millis = (System.nanoTime() - start) / 1_000_000;
System.out.printf("%-4s %-40s %d %d ms%n", anfrage.getRequestMethod(), anfrage.getRequestURI(), status, millis);
}
/** Routing: Methode und Pfad bestimmen, welcher Endpunkt zuständig ist. */
private int leiteWeiter(HttpExchange anfrage) throws IOException {
String methode = anfrage.getRequestMethod();
String pfad = anfrage.getRequestURI().getPath();
if (pfad.equals(Protokoll.SPIELE) && methode.equals("POST")) {
return neuesSpiel(anfrage);
}
Matcher spieler = SPIELER.matcher(pfad);
if (spieler.matches() && methode.equals("POST")) {
return nichtUmgesetzt(anfrage); // beitreten
}
Matcher flotte = FLOTTE.matcher(pfad);
if (flotte.matches() && methode.equals("PUT")) {
return nichtUmgesetzt(anfrage); // aufstellen
}
Matcher schuesse = SCHUESSE.matcher(pfad);
if (schuesse.matches() && methode.equals("POST")) {
return nichtUmgesetzt(anfrage); // schießen
}
Matcher spiel = SPIEL.matcher(pfad);
if (spiel.matches() && methode.equals("GET")) {
return nichtUmgesetzt(anfrage); // Stand abfragen
}
return fehler(anfrage, 404, "Unbekannt: " + methode + " " + pfad);
}
// ----- Endpunkte ---------------------------------------------------------------------
/** POST /spiele – legt ein Spiel an; der Aufrufer ist Spieler 1. */
private int neuesSpiel(HttpExchange anfrage) throws IOException {
Beitritt beitritt = dienst.neuesSpiel();
return antworte(anfrage, 201, new BeitrittAntwort(beitritt.spielId(), beitritt.token()));
}
private int nichtUmgesetzt(HttpExchange anfrage) throws IOException {
return fehler(anfrage, 501, "Noch nicht umgesetzt");
}
// ----- Werkzeuge ---------------------------------------------------------------------
/** Das Token aus dem Header X-Spieler – oder eine FehlendesToken-Exception. */
String token(HttpExchange anfrage) {
String token = anfrage.getRequestHeaders().getFirst(Protokoll.TOKEN_HEADER);
if (token == null || token.isBlank()) {
throw new FehlendesToken();
}
return token;
}
/** Liest den Rumpf der Anfrage als JSON in einen Record vom Typ {@code typ}. */
<T> T lies(HttpExchange anfrage, Class<T> typ) throws IOException {
try (InputStream rumpf = anfrage.getRequestBody()) {
return json.readValue(rumpf, typ);
}
}
/** Schreibt eine Nachricht als JSON mit diesem Statuscode und liefert den Statuscode. */
int antworte(HttpExchange anfrage, int status, Object nachricht) throws IOException {
byte[] bytes = json.writeValueAsBytes(nachricht);
anfrage.getResponseHeaders().set("Content-Type", "application/json; charset=utf-8");
anfrage.sendResponseHeaders(status, bytes.length);
try (OutputStream aus = anfrage.getResponseBody()) {
aus.write(bytes);
}
return status;
}
/** Eine Antwort ohne Rumpf, z. B. 204 No Content. */
int antworteOhneRumpf(HttpExchange anfrage, int status) throws IOException {
anfrage.sendResponseHeaders(status, -1); // -1: es kommt kein Rumpf
anfrage.close();
return status;
}
/** Eine Fehlerantwort mit {@code {"fehler": "…"}} – und wenn selbst das nicht klappt, aufgeben. */
private int fehler(HttpExchange anfrage, int status, String meldung) {
try {
return antworte(anfrage, status, new Fehler(meldung));
} catch (IOException e) {
anfrage.close();
return status;
}
}
}

Der HttpServer kennt nur Präfixe: createContext("/spiele", …) nimmt jede Anfrage an, deren Pfad mit /spiele beginnt. Welche genau gemeint ist, muss der Server selbst herausfinden. Dafür eignen sich reguläre Ausdrücke aus dem Kapitel Reguläre Ausdrücke:

SpielServer.java (Ausschnitt)
private static final Pattern SCHUESSE = Pattern.compile("/spiele/([^/]+)/schuesse");
Matcher schuesse = SCHUESSE.matcher(pfad);
if (schuesse.matches() && methode.equals("POST")) {
return schiessen(anfrage, schuesse.group(1)); // group(1) ist die Spiel-ID
}

[^/]+ heißt: ein oder mehrere Zeichen, aber kein Schrägstrich – genau ein Abschnitt des Pfads. In der Gruppe steht danach die Spiel-ID.

Weil matches() den ganzen Pfad prüft, passt /spiele/([^/]+) nicht auf /spiele/7f3a/schuesse – jeder Pfad landet bei genau einem Muster. Und weil zusätzlich die Methode geprüft wird, sind GET /spiele/7f3a und DELETE /spiele/7f3a zwei verschiedene Dinge. Passt nichts, gibt es 404.

Alles über eine Anfrage steckt in einem HttpExchange:

Methode liefert
getRequestMethod() "GET", "POST" …
getRequestURI().getPath() den Pfad, z. B. /spiele/7f3a/schuesse
getRequestHeaders().getFirst("X-Spieler") einen Header – oder null
getRequestBody() den Rumpf als InputStream
getResponseHeaders() die Header der Antwort, zum Setzen
sendResponseHeaders(status, laenge) schickt Statuszeile und Header
getResponseBody() der Rumpf der Antwort als OutputStream

In der pom.xml steht eine einzige neue Abhängigkeit:

<dependency>
<groupId>tools.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>3.2.4</version>
</dependency>

Ein JsonMapper übersetzt in beide Richtungen – Records funktionieren dabei ohne jede Zusatzarbeit, die Namen der Felder werden zu den Namen im JSON:

SpielServer.java (Ausschnitt)
private final JsonMapper json = JsonMapper.builder().build();
/** Liest den Rumpf der Anfrage als JSON in einen Record vom Typ {@code typ}. */
<T> T lies(HttpExchange anfrage, Class<T> typ) throws IOException {
try (InputStream rumpf = anfrage.getRequestBody()) {
return json.readValue(rumpf, typ);
}
}
/** Schreibt eine Nachricht als JSON mit diesem Statuscode und liefert den Statuscode. */
int antworte(HttpExchange anfrage, int status, Object nachricht) throws IOException {
byte[] bytes = json.writeValueAsBytes(nachricht);
anfrage.getResponseHeaders().set("Content-Type", "application/json; charset=utf-8");
anfrage.sendResponseHeaders(status, bytes.length);
try (OutputStream aus = anfrage.getResponseBody()) {
aus.write(bytes);
}
return status;
}
  • lies(anfrage, SchussAnfrage.class) macht aus {"feld":"B7"} ein SchussAnfrage("B7").
  • antworte(anfrage, 200, new SchussAntwort("TREFFER")) macht daraus {"ergebnis":"TREFFER"}.
  • lies ist generisch – <T> aus dem Kapitel Generics: Eine Methode für jeden Typ von Nachricht.
  • Jackson 3 wirft bei kaputtem JSON eine JacksonException. Sie ist ungeprüft – der Rahmen fängt sie zentral und macht eine 400 daraus.

So sieht der fertige Endpunkt im Demo-Projekt aus:

SpielServer.java (Ausschnitt)
/** POST /spiele – legt ein Spiel an; der Aufrufer ist Spieler 1. */
private int neuesSpiel(HttpExchange anfrage) throws IOException {
Beitritt beitritt = dienst.neuesSpiel();
return antworte(anfrage, 201, new BeitrittAntwort(beitritt.spielId(), beitritt.token()));
}

Drei Zeilen: Dienst aufrufen, Ergebnis in eine Nachricht verpacken, antworten. Bei den anderen Endpunkten kommt Schritt 2 und 3 dazu – das Token lesen und die Nachricht in fachliche Typen übersetzen:

Nachricht (Text) fachlicher Typ Übersetzung
"B7" Koordinate Koordinate.von("B7")
"KREUZER" Schiffstyp Schiffstyp.valueOf("KREUZER")
"WAAGERECHT" Richtung Richtung.valueOf("WAAGERECHT")
Ergebnis.TREFFER "TREFFER" ergebnis.name()
Koordinate als Schlüssel einer Map "B7" koordinate.toString()

Ist ein Text ungültig, werfen von und valueOf eine IllegalArgumentException – und der Rahmen macht daraus eine 400. Der Endpunkt muss sich darum nicht kümmern.

Jede Anfrage läuft durch eine Methode mit einem try und mehreren catch:

SpielServer.java (Ausschnitt)
try {
status = leiteWeiter(anfrage);
} catch (FehlendesToken e) {
status = fehler(anfrage, 403, e.getMessage());
} catch (SpielNichtGefunden e) {
status = fehler(anfrage, 404, e.getMessage());
} catch (JacksonException e) {
status = fehler(anfrage, 400, "Kein gültiges JSON: " + e.getOriginalMessage());
} catch (IllegalArgumentException e) {
status = fehler(anfrage, 400, e.getMessage());
} catch (IllegalStateException e) {
status = fehler(anfrage, 409, e.getMessage());
} catch (Exception e) {
e.printStackTrace(); // unerwartet – ein Fehler im Server selbst
status = fehler(anfrage, 500, "Interner Fehler");
}
  • So steht die Übersetzung von Exception in Statuscode an einer Stelle. Kein Endpunkt muss try schreiben.
  • Jeder Fehler kommt als {"fehler": "…"} zurück – mit der Meldung der Exception. Der Client kann sie anzeigen.
  • Der letzte catch fängt alles Unerwartete. Ohne ihn würde der Server bei einer NullPointerException gar nicht antworten – siehe unten. 500 heißt: Der Fehler liegt beim Server, nicht in der Anfrage.

token(anfrage) liest den Header X-Spieler. Fehlt er, wirft der Rahmen eine eigene FehlendesToken-Exception – und daraus wird 403. Ob das Token gültig ist, prüft der Spieldienst: Gehört es nicht zum Spiel, wirft er SpielNichtGefunden.

SpielServer.java (Ausschnitt)
server.setExecutor(Executors.newVirtualThreadPerTaskExecutor());

Ohne diese Zeile bearbeitet der HttpServer alle Anfragen nacheinander in einem einzigen Thread. Mit ihr bekommt jede Anfrage einen eigenen virtuellen Thread – siehe Parallelität. Das heißt aber auch: Anna und Ben können gleichzeitig im Spieldienst sein. Deshalb sind die Methoden des LokalerSpieldienst synchronized.

AttrappenSpieldienst.java
package de.drv.schiffe.dienst;
import de.drv.schiffe.spiel.Ergebnis;
import de.drv.schiffe.spiel.Koordinate;
import de.drv.schiffe.spiel.Phase;
import java.util.List;
import java.util.Map;
/**
* Eine <em>Attrappe</em>: erfüllt den Vertrag {@link Spieldienst}, spielt aber nicht wirklich. Sie
* liefert immer dieselben, festen Antworten.
*
* <p>Wozu? Wer am Server oder am Client arbeitet, kann damit loslegen, bevor der echte Kern fertig
* ist – und sieht sofort, ob Anfragen und Antworten richtig übersetzt werden.
*/
public class AttrappenSpieldienst implements Spieldienst {
private static final String SPIEL = "attrappe";
@Override
public Beitritt neuesSpiel() {
return new Beitritt(SPIEL, "token-eins");
}
@Override
public Beitritt beitreten(String spielId) {
pruefe(spielId);
return new Beitritt(SPIEL, "token-zwei");
}
@Override
public void aufstellen(String spielId, String token, List<Aufstellung> flotte) {
pruefe(spielId);
if (flotte.size() != 5) {
throw new IllegalArgumentException("Eine Flotte hat fünf Schiffe, nicht " + flotte.size());
}
}
@Override
public Spielstand stand(String spielId, String token) {
pruefe(spielId);
return new Spielstand(Phase.LAEUFT, true,
Map.of(Koordinate.von("B7"), Ergebnis.TREFFER),
Map.of(Koordinate.von("D4"), Ergebnis.WASSER),
null);
}
@Override
public Ergebnis schiessen(String spielId, String token, Koordinate ziel) {
pruefe(spielId);
return ziel.equals(Koordinate.von("B7")) ? Ergebnis.TREFFER : Ergebnis.WASSER;
}
private static void pruefe(String spielId) {
if (!SPIEL.equals(spielId)) {
throw new SpielNichtGefunden("Kein Spiel mit der ID " + spielId);
}
}
}

Eine Attrappe erfüllt den Vertrag, spielt aber nicht wirklich: Es gibt nur ein Spiel mit der ID attrappe, und auf B7 ist immer ein Treffer. Das reicht, um den Server zu bauen und zu prüfen, ob er richtig übersetzt – während eine andere Gruppe noch am Kern arbeitet. Gestartet wird der Server dann mit dem Argument attrappe.

  1. Starte ServerStart mit dem Argument attrappe. Auf der Konsole erscheint für jede Anfrage eine Zeile:

    Terminal-Fenster
    Spiel-Server auf http://localhost:8080
    POST /spiele 201 39 ms
    POST /spiele/attrappe/schuesse 501 1 ms
  2. Ein Spiel anlegen:

    PowerShell
    curl.exe -i -X POST http://localhost:8080/spiele
    Terminal-Fenster
    HTTP/1.1 201 Created
    Content-type: application/json; charset=utf-8
    Content-length: 43
    {"spielId":"attrappe","token":"token-eins"}
  3. Die anderen Endpunkte melden sich noch mit 501:

    PowerShell
    curl.exe -X POST -H "X-Spieler: token-eins" -d '{"feld":"B7"}' http://localhost:8080/spiele/attrappe/schuesse
    Terminal-Fenster
    {"fehler":"Noch nicht umgesetzt"}

Mit dem echten Spieldienst (ohne attrappe) und allen Endpunkten – die IDs und Tokens sind bei jedem Spiel andere:

Terminal-Fenster
POST /spiele → 201 {"spielId":"29a4df96-…","token":"4aae9754-…"}
POST /spiele/29a4df96-…/spieler → 201 {"spielId":"29a4df96-…","token":"04350839-…"}
PUT /spiele/…/flotte (Anna) → 204
PUT /spiele/…/flotte (Ben) → 204
POST /spiele/…/schuesse (Ben) B2 → 409 {"fehler":"Du bist nicht dran"}
POST /spiele/…/schuesse (Anna) B2→ 200 {"ergebnis":"TREFFER"}
POST /spiele/…/schuesse (Ben) E5 → 200 {"ergebnis":"WASSER"}
POST /spiele/…/schuesse (Anna) K3→ 400 {"fehler":"Keine Koordinate: K3"}
GET /spiele/… (Anna) → 200 {"phase":"LAEUFT","amZug":true,"eigeneSchuesse":{"B2":"TREFFER"},"gegnerischeSchuesse":{"E5":"WASSER"},"gewonnen":null}
GET /spiele/… ohne Token → 403 {"fehler":"Header X-Spieler fehlt"}

curl ist gut zum Ausprobieren, aber nach jeder Änderung alles von Hand zu wiederholen, ist mühsam. Ein JUnit-Test kann einen echten Server starten und mit dem HttpClient gegen ihn sprechen:

@BeforeEach
void starte() throws IOException {
server = new SpielServer(new LokalerSpieldienst(), 0); // Port 0: irgendein freier
server.starte();
adresse = "http://localhost:" + server.getPort();
}
@AfterEach
void stoppe() {
server.stoppe();
}
  • Port 0 heißt: Das Betriebssystem sucht einen freien Port aus. So kommen sich der Test und ein laufender Server auf 8080 nicht in die Quere.
  • getPort() verrät danach, welcher es geworden ist.
  • @BeforeEach und @AfterEach laufen vor und nach jedem Test – jeder Test bekommt einen frischen Server.

Arbeite im Demo-Projekt 34-schiffe-server. Teste jeden Endpunkt zuerst mit der Attrappe und curl.exe.

  1. Beitreten: POST /spiele/{id}/spieler antwortet mit 201 und einer BeitrittAntwort. Mit der Attrappe: Die ID attrappe liefert token-zwei, jede andere 404.

  2. Schießen: POST /spiele/{id}/schuesse liest das Token und eine SchussAnfrage, übersetzt das Feld in eine Koordinate und antwortet mit einer SchussAntwort. Probiere auch K3, kaputtes JSON und eine Anfrage ohne Token – welcher Statuscode kommt jeweils?

  3. Aufstellen und Stand:

    • PUT /spiele/{id}/flotte liest eine FlotteAnfrage, macht aus jeder SchiffNachricht eine Aufstellung und antwortet mit 204 ohne Rumpf. Zum Ausprobieren liegt flotte.json im Projekt.
    • GET /spiele/{id} übersetzt den Spielstand in eine StandAntwort – die Maps mit Koordinate und Ergebnis werden zu Maps aus Texten.
  4. Für Schnelle: Ein JUnit-Test SpielServerTest, der einen Server auf Port 0 startet und den Ablauf von oben durchspielt: anlegen, beitreten, beide Flotten aufstellen, ein Schuss, Stand abfragen. Und ein zweiter Test für die Fehlercodes 400, 403, 404 und 409. Für einen echten Ablauf braucht es den echten Kern – also den LokalerSpieldienst der Kern-Gruppe oder die Lösung.

Lösung

Die vier neuen Endpunkte folgen alle demselben Muster. Dazu kommen zwei kleine Helfer:

  • pflicht(wert, name) meldet ein fehlendes Feld in der Nachricht als 400 – sonst würde valueOf(null) eine NullPointerException werfen, und daraus würde eine 500.
  • alsText übersetzt die Maps des Spielstands in Maps aus Texten, nach Feld sortiert in einer TreeMap.
SpielServer.java
package de.drv.schiffe.server;
import de.drv.schiffe.dienst.Aufstellung;
import de.drv.schiffe.dienst.Beitritt;
import de.drv.schiffe.dienst.SpielNichtGefunden;
import de.drv.schiffe.dienst.Spieldienst;
import de.drv.schiffe.dienst.Spielstand;
import de.drv.schiffe.protokoll.Nachrichten.BeitrittAntwort;
import de.drv.schiffe.protokoll.Nachrichten.Fehler;
import de.drv.schiffe.protokoll.Nachrichten.FlotteAnfrage;
import de.drv.schiffe.protokoll.Nachrichten.SchiffNachricht;
import de.drv.schiffe.protokoll.Nachrichten.SchussAnfrage;
import de.drv.schiffe.protokoll.Nachrichten.SchussAntwort;
import de.drv.schiffe.protokoll.Nachrichten.StandAntwort;
import de.drv.schiffe.protokoll.Protokoll;
import de.drv.schiffe.spiel.Ergebnis;
import de.drv.schiffe.spiel.Koordinate;
import de.drv.schiffe.spiel.Richtung;
import de.drv.schiffe.spiel.Schiffstyp;
import com.sun.net.httpserver.HttpExchange;
import com.sun.net.httpserver.HttpServer;
import tools.jackson.core.JacksonException;
import tools.jackson.databind.json.JsonMapper;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetSocketAddress;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import java.util.concurrent.Executors;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* Übersetzt HTTP in Aufrufe des {@link Spieldienst}es – und die Ergebnisse zurück in HTTP.
*
* <p>Rahmen: Routing, JSON lesen und schreiben, Fehler in Statuscodes übersetzen, jede Anfrage
* protokollieren. Dazu alle fünf Endpunkte des Protokolls.
*/
public class SpielServer {
// Die Pfade mit einer Spiel-ID – die ID steht in Gruppe 1
private static final Pattern SPIEL = Pattern.compile("/spiele/([^/]+)");
private static final Pattern SPIELER = Pattern.compile("/spiele/([^/]+)/spieler");
private static final Pattern FLOTTE = Pattern.compile("/spiele/([^/]+)/flotte");
private static final Pattern SCHUESSE = Pattern.compile("/spiele/([^/]+)/schuesse");
private final Spieldienst dienst;
private final int port;
private final JsonMapper json = JsonMapper.builder().build();
private HttpServer server;
/** @param port 0 heißt: irgendein freier Port – praktisch für Tests */
public SpielServer(Spieldienst dienst, int port) {
this.dienst = dienst;
this.port = port;
}
public void starte() throws IOException {
server = HttpServer.create(new InetSocketAddress(port), 0);
server.createContext(Protokoll.SPIELE, this::bearbeite);
// Jede Anfrage in einem eigenen virtuellen Thread – mehrere Spieler gleichzeitig
server.setExecutor(Executors.newVirtualThreadPerTaskExecutor());
server.start();
System.out.println("Spiel-Server auf http://localhost:" + getPort());
}
public void stoppe() {
server.stop(0);
}
/** Der tatsächliche Port – auch wenn beim Start 0 angegeben war. */
public int getPort() {
return server.getAddress().getPort();
}
// ----- Eingang: jede Anfrage kommt hier an -------------------------------------------
private void bearbeite(HttpExchange anfrage) {
long start = System.nanoTime();
int status;
try {
status = leiteWeiter(anfrage);
} catch (FehlendesToken e) {
status = fehler(anfrage, 403, e.getMessage());
} catch (SpielNichtGefunden e) {
status = fehler(anfrage, 404, e.getMessage());
} catch (JacksonException e) {
status = fehler(anfrage, 400, "Kein gültiges JSON: " + e.getOriginalMessage());
} catch (IllegalArgumentException e) {
status = fehler(anfrage, 400, e.getMessage());
} catch (IllegalStateException e) {
status = fehler(anfrage, 409, e.getMessage());
} catch (Exception e) {
e.printStackTrace(); // unerwartet – ein Fehler im Server selbst
status = fehler(anfrage, 500, "Interner Fehler");
}
long millis = (System.nanoTime() - start) / 1_000_000;
System.out.printf("%-4s %-40s %d %d ms%n", anfrage.getRequestMethod(), anfrage.getRequestURI(), status, millis);
}
/** Routing: Methode und Pfad bestimmen, welcher Endpunkt zuständig ist. */
private int leiteWeiter(HttpExchange anfrage) throws IOException {
String methode = anfrage.getRequestMethod();
String pfad = anfrage.getRequestURI().getPath();
if (pfad.equals(Protokoll.SPIELE) && methode.equals("POST")) {
return neuesSpiel(anfrage);
}
Matcher spieler = SPIELER.matcher(pfad);
if (spieler.matches() && methode.equals("POST")) {
return beitreten(anfrage, spieler.group(1));
}
Matcher flotte = FLOTTE.matcher(pfad);
if (flotte.matches() && methode.equals("PUT")) {
return aufstellen(anfrage, flotte.group(1));
}
Matcher schuesse = SCHUESSE.matcher(pfad);
if (schuesse.matches() && methode.equals("POST")) {
return schiessen(anfrage, schuesse.group(1));
}
Matcher spiel = SPIEL.matcher(pfad);
if (spiel.matches() && methode.equals("GET")) {
return stand(anfrage, spiel.group(1));
}
return fehler(anfrage, 404, "Unbekannt: " + methode + " " + pfad);
}
// ----- Endpunkte ---------------------------------------------------------------------
/** POST /spiele – legt ein Spiel an; der Aufrufer ist Spieler 1. */
private int neuesSpiel(HttpExchange anfrage) throws IOException {
Beitritt beitritt = dienst.neuesSpiel();
return antworte(anfrage, 201, new BeitrittAntwort(beitritt.spielId(), beitritt.token()));
}
/** POST /spiele/{id}/spieler – tritt als Spieler 2 bei. */
private int beitreten(HttpExchange anfrage, String spielId) throws IOException {
Beitritt beitritt = dienst.beitreten(spielId);
return antworte(anfrage, 201, new BeitrittAntwort(beitritt.spielId(), beitritt.token()));
}
/** PUT /spiele/{id}/flotte – stellt die eigene Flotte auf. */
private int aufstellen(HttpExchange anfrage, String spielId) throws IOException {
String token = token(anfrage);
FlotteAnfrage nachricht = lies(anfrage, FlotteAnfrage.class);
if (nachricht.schiffe() == null) {
throw new IllegalArgumentException("Es fehlt die Liste \"schiffe\"");
}
// Nachricht → fachliche Typen: Texte werden zu Enums und Koordinaten (ungültig: IllegalArgumentException)
List<Aufstellung> flotte = new ArrayList<>();
for (SchiffNachricht schiff : nachricht.schiffe()) {
flotte.add(new Aufstellung(
Schiffstyp.valueOf(pflicht(schiff.typ(), "typ")),
Koordinate.von(schiff.anfang()),
Richtung.valueOf(pflicht(schiff.richtung(), "richtung"))));
}
dienst.aufstellen(spielId, token, flotte);
return antworteOhneRumpf(anfrage, 204);
}
/** POST /spiele/{id}/schuesse – schießt auf das Feld des Gegners. */
private int schiessen(HttpExchange anfrage, String spielId) throws IOException {
String token = token(anfrage);
SchussAnfrage nachricht = lies(anfrage, SchussAnfrage.class);
Ergebnis ergebnis = dienst.schiessen(spielId, token, Koordinate.von(nachricht.feld()));
return antworte(anfrage, 200, new SchussAntwort(ergebnis.name()));
}
/** GET /spiele/{id} – der Stand aus der Sicht dessen, der fragt. */
private int stand(HttpExchange anfrage, String spielId) throws IOException {
Spielstand stand = dienst.stand(spielId, token(anfrage));
return antworte(anfrage, 200, new StandAntwort(
stand.phase().name(),
stand.amZug(),
alsText(stand.eigeneSchuesse()),
alsText(stand.gegnerischeSchuesse()),
stand.gewonnen()));
}
/** Ein Feld, das in der Nachricht stehen muss – fehlt es, ist die Anfrage falsch (400). */
private static String pflicht(String wert, String name) {
if (wert == null) {
throw new IllegalArgumentException("Es fehlt \"" + name + "\"");
}
return wert;
}
/** Fachliche Typen → Nachricht: Koordinaten und Ergebnisse als Texte, nach Feld sortiert. */
private static Map<String, String> alsText(Map<Koordinate, Ergebnis> schuesse) {
Map<String, String> text = new TreeMap<>();
for (Map.Entry<Koordinate, Ergebnis> schuss : schuesse.entrySet()) {
text.put(schuss.getKey().toString(), schuss.getValue().name());
}
return text;
}
// ----- Werkzeuge ---------------------------------------------------------------------
/** Das Token aus dem Header X-Spieler – oder eine FehlendesToken-Exception. */
String token(HttpExchange anfrage) {
String token = anfrage.getRequestHeaders().getFirst(Protokoll.TOKEN_HEADER);
if (token == null || token.isBlank()) {
throw new FehlendesToken();
}
return token;
}
/** Liest den Rumpf der Anfrage als JSON in einen Record vom Typ {@code typ}. */
<T> T lies(HttpExchange anfrage, Class<T> typ) throws IOException {
try (InputStream rumpf = anfrage.getRequestBody()) {
return json.readValue(rumpf, typ);
}
}
/** Schreibt eine Nachricht als JSON mit diesem Statuscode und liefert den Statuscode. */
int antworte(HttpExchange anfrage, int status, Object nachricht) throws IOException {
byte[] bytes = json.writeValueAsBytes(nachricht);
anfrage.getResponseHeaders().set("Content-Type", "application/json; charset=utf-8");
anfrage.sendResponseHeaders(status, bytes.length);
try (OutputStream aus = anfrage.getResponseBody()) {
aus.write(bytes);
}
return status;
}
/** Eine Antwort ohne Rumpf, z. B. 204 No Content. */
int antworteOhneRumpf(HttpExchange anfrage, int status) throws IOException {
anfrage.sendResponseHeaders(status, -1); // -1: es kommt kein Rumpf
anfrage.close();
return status;
}
/** Eine Fehlerantwort mit {@code {"fehler": "…"}} – und wenn selbst das nicht klappt, aufgeben. */
private int fehler(HttpExchange anfrage, int status, String meldung) {
try {
return antworte(anfrage, status, new Fehler(meldung));
} catch (IOException e) {
anfrage.close();
return status;
}
}
}
Lösung

JsonNode ist die Art, wie Jackson JSON liest, wenn es keinen passenden Record gibt: json.readTree(text) liefert einen Baum, get("token").asString() einen Wert daraus. Für Tests ist das bequem.

SpielServerTest.java
package de.drv.schiffe.server;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import de.drv.schiffe.dienst.LokalerSpieldienst;
import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import tools.jackson.databind.JsonNode;
import tools.jackson.databind.json.JsonMapper;
/** Startet einen echten Server auf einem freien Port und spricht HTTP mit ihm. */
class SpielServerTest {
private static final String FLOTTE = """
{"schiffe": [
{"typ": "FLUGZEUGTRAEGER", "anfang": "A1", "richtung": "WAAGERECHT"},
{"typ": "SCHLACHTSCHIFF", "anfang": "A3", "richtung": "WAAGERECHT"},
{"typ": "KREUZER", "anfang": "A5", "richtung": "WAAGERECHT"},
{"typ": "U_BOOT", "anfang": "A7", "richtung": "WAAGERECHT"},
{"typ": "ZERSTOERER", "anfang": "A9", "richtung": "WAAGERECHT"}
]}""";
private final JsonMapper json = JsonMapper.builder().build();
private final HttpClient client = HttpClient.newHttpClient();
private SpielServer server;
private String adresse;
@BeforeEach
void starte() throws IOException {
server = new SpielServer(new LokalerSpieldienst(), 0);
server.starte();
adresse = "http://localhost:" + server.getPort();
}
@AfterEach
void stoppe() {
server.stoppe();
client.close();
}
private HttpResponse<String> sende(String methode, String pfad, String token, String rumpf) throws Exception {
HttpRequest.Builder anfrage = HttpRequest.newBuilder(URI.create(adresse + pfad))
.method(methode, rumpf == null ? HttpRequest.BodyPublishers.noBody() : HttpRequest.BodyPublishers.ofString(rumpf));
if (token != null) {
anfrage.header("X-Spieler", token);
}
return client.send(anfrage.build(), HttpResponse.BodyHandlers.ofString());
}
@Test
@DisplayName("Ein Spiel über HTTP: anlegen, beitreten, aufstellen, schießen, Stand")
void ablauf() throws Exception {
HttpResponse<String> angelegt = sende("POST", "/spiele", null, null);
assertEquals(201, angelegt.statusCode());
JsonNode anna = json.readTree(angelegt.body());
String id = anna.get("spielId").asString();
String annasToken = anna.get("token").asString();
HttpResponse<String> beigetreten = sende("POST", "/spiele/" + id + "/spieler", null, null);
assertEquals(201, beigetreten.statusCode());
String bensToken = json.readTree(beigetreten.body()).get("token").asString();
assertEquals(204, sende("PUT", "/spiele/" + id + "/flotte", annasToken, FLOTTE).statusCode());
assertEquals(204, sende("PUT", "/spiele/" + id + "/flotte", bensToken, FLOTTE).statusCode());
HttpResponse<String> schuss = sende("POST", "/spiele/" + id + "/schuesse", annasToken, "{\"feld\":\"A1\"}");
assertEquals(200, schuss.statusCode());
assertEquals("TREFFER", json.readTree(schuss.body()).get("ergebnis").asString());
JsonNode stand = json.readTree(sende("GET", "/spiele/" + id, bensToken, null).body());
assertEquals("LAEUFT", stand.get("phase").asString());
assertTrue(stand.get("amZug").asBoolean());
assertEquals("TREFFER", stand.get("gegnerischeSchuesse").get("A1").asString());
}
@Test
@DisplayName("Fehler werden zu Statuscodes")
void fehler() throws Exception {
JsonNode anna = json.readTree(sende("POST", "/spiele", null, null).body());
String id = anna.get("spielId").asString();
String token = anna.get("token").asString();
assertEquals(404, sende("GET", "/spiele/gibt-es-nicht", token, null).statusCode());
assertEquals(403, sende("GET", "/spiele/" + id, null, null).statusCode());
assertEquals(404, sende("GET", "/spiele/" + id, "falsches-token", null).statusCode());
assertEquals(409, sende("POST", "/spiele/" + id + "/schuesse", token, "{\"feld\":\"A1\"}").statusCode());
sende("POST", "/spiele/" + id + "/spieler", null, null);
assertEquals(409, sende("POST", "/spiele/" + id + "/spieler", null, null).statusCode());
assertEquals(400, sende("PUT", "/spiele/" + id + "/flotte", token, "{\"schiffe\": []}").statusCode());
assertEquals(400, sende("PUT", "/spiele/" + id + "/flotte", token, "kein json").statusCode());
assertEquals(400, sende("PUT", "/spiele/" + id + "/flotte", token, "{\"schiffe\": [{\"typ\": \"FLOSS\"}]}").statusCode());
assertEquals(404, sende("DELETE", "/spiele/" + id, token, null).statusCode());
}
}
Lösung

Der echte Spieldienst – für alle, die den Server mit einem richtigen Spiel ausprobieren wollen, bevor die Kern-Gruppe fertig ist. Ein Token gehört zu einem Platz: einem Spiel und einer Seite. Ein Token aus einem anderen Spiel wird abgelehnt.

LokalerSpieldienst.java
package de.drv.schiffe.dienst;
import de.drv.schiffe.spiel.Ergebnis;
import de.drv.schiffe.spiel.Flotte;
import de.drv.schiffe.spiel.Koordinate;
import de.drv.schiffe.spiel.Phase;
import de.drv.schiffe.spiel.Schiff;
import de.drv.schiffe.spiel.Seite;
import de.drv.schiffe.spiel.Spiel;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
/**
* Führt die Spiele im selben Programm: eine Map von Spiel-ID zu {@code Spiel} und eine von Token
* zu Seite. Er übersetzt die Aufrufe des Vertrags in Aufrufe des Kerns.
*
* <p>Der Server benutzt ihn für alle Spieler zugleich – deshalb sind die Methoden
* {@code synchronized}.
*/
public class LokalerSpieldienst implements Spieldienst {
/** Wem ein Token gehört: welchem Spiel, welcher Seite. */
private record Platz(String spielId, Seite seite) {
}
private final Map<String, Spiel> spiele = new HashMap<>();
private final Map<String, Platz> plaetze = new HashMap<>();
@Override
public synchronized Beitritt neuesSpiel() {
String spielId = UUID.randomUUID().toString();
spiele.put(spielId, new Spiel());
return new Beitritt(spielId, vergebeToken(spielId, Seite.EINS));
}
@Override
public synchronized Beitritt beitreten(String spielId) {
spiel(spielId).gegnerTrittBei(); // wirft, wenn schon zwei da sind
return new Beitritt(spielId, vergebeToken(spielId, Seite.ZWEI));
}
@Override
public synchronized void aufstellen(String spielId, String token, List<Aufstellung> flotte) {
Seite seite = seite(spielId, token);
List<Schiff> schiffe = new ArrayList<>();
for (Aufstellung aufstellung : flotte) {
schiffe.add(new Schiff(aufstellung.typ(), aufstellung.anfang(), aufstellung.richtung()));
}
spiel(spielId).stelleAuf(seite, new Flotte(schiffe));
}
@Override
public synchronized Spielstand stand(String spielId, String token) {
Seite seite = seite(spielId, token);
Spiel spiel = spiel(spielId);
Boolean gewonnen = spiel.getPhase() == Phase.VORBEI
? spiel.gewinner().orElseThrow() == seite
: null;
return new Spielstand(spiel.getPhase(),
spiel.amZug().map(amZug -> amZug == seite).orElse(false),
Map.copyOf(spiel.schuesseVon(seite)),
Map.copyOf(spiel.schuesseVon(seite.gegner())),
gewonnen);
}
@Override
public synchronized Ergebnis schiessen(String spielId, String token, Koordinate ziel) {
return spiel(spielId).schiesse(seite(spielId, token), ziel);
}
private Spiel spiel(String spielId) {
Spiel spiel = spiele.get(spielId);
if (spiel == null) {
throw new SpielNichtGefunden("Kein Spiel mit der ID " + spielId);
}
return spiel;
}
/** Die Seite, der das Token gehört – nur, wenn es auch zu diesem Spiel gehört. */
private Seite seite(String spielId, String token) {
spiel(spielId);
Platz platz = plaetze.get(token);
if (platz == null || !platz.spielId().equals(spielId)) {
throw new SpielNichtGefunden("Dieses Token gehört nicht zum Spiel " + spielId);
}
return platz.seite();
}
private String vergebeToken(String spielId, Seite seite) {
String token = UUID.randomUUID().toString();
plaetze.put(token, new Platz(spielId, seite));
return token;
}
}
Lösung
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 + ")");
}
}
}
Lösung
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
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();
}
}