Zum Inhalt springen

Schiffe versenken: Der Client

Der Client ist das Programm, mit dem ein Mensch spielt. Er zeigt die Felder, nimmt Eingaben an und spricht mit dem Server. Dabei hat er eine Aufgabe, die es in unseren bisherigen Programmen nicht gab: warten. Denn der Gegner sitzt an einem anderen Rechner, und wann er schießt, weiß niemand.

  • den Ablauf eines Spiels aus Sicht eines Spielers beschreiben
  • erklären, welches Interface der Client bedient und warum er nur dieses kennt
  • mit Polling auf etwas warten, das woanders passiert
  • HTTP-Antworten und Fehlercodes zurück in Ergebnisse und Exceptions übersetzen

Demo-Code: 35-schiffe-client

⤓ schiffe-client.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 35-schiffe-client 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, UebungsDemo.java, AttrappenSpieldienst.java, Aufstellung.java, Beitritt.java, LokalerSpieldienst.java, SpielNichtGefunden.java, Spieldienst.java, Spielstand.java, Uebungsgegner.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 alles aus dem Server-Artikel und dazu:

  • den Uebungsgegner – eine Attrappe, gegen die man ein ganzes Spiel spielen kann, ohne Server und ohne den echten Kern,
  • Aufstellung.von("KREUZER B2 W"), um Eingaben in Aufstellungen zu verwandeln,
  • eine Konsole mit festem Ablauf und fertigem Warten,
  • einen HttpSpieldienst, in dem ein Aufruf und alle Werkzeuge fertig sind,
  • UebungsDemo – ein Programm, das den Ablauf ohne Eingaben vorführt.
┌───────────────┐
│ 1. Anmelden │ neues Spiel anlegen – oder einem beitreten
└───────┬───────┘
▼
┌───────────────┐
│ warten … │ bis der Gegner da ist (Phase AUFSTELLEN)
└───────┬───────┘
▼
┌───────────────┐
│ 2. Aufstellen │ fünf Schiffe eingeben
└───────┬───────┘
▼
┌───────────────┐
┌──▶ │ warten … │ bis ich dran bin – oder das Spiel vorbei ist
│ └───────┬───────┘
│ ▼
│ ┌───────────────┐
│ │ 3. Schießen │ Felder zeigen, Ziel eingeben, Ergebnis zeigen
│ └───────┬───────┘
└────────────┘
▼ (Phase VORBEI)
┌───────────────┐
│ Gewonnen! │
│ oder verloren │
└───────────────┘

Zwischen den Schritten steht jedes Mal warten. Das ist der Teil, der über das Netz anders ist als am Küchentisch.

Der Client kennt nur den Spieldienst aus dem Klassenmodell:

Spieldienst.java
package de.drv.schiffe.dienst;
import de.drv.schiffe.spiel.Koordinate;
import de.drv.schiffe.spiel.Ergebnis;
import java.util.List;
/**
* Der Vertrag zwischen den Spielern und dem, der die Spiele führt – lokal im selben Programm
* oder über das Netz. Die Konsole kennt nur dieses Interface.
*
* <p>Jeder Aufruf nach dem Beitreten nennt Spiel und Token. Am Token erkennt der Dienst, welche
* Seite fragt – und dass sie es wirklich ist.
*/
public interface Spieldienst {
/** Legt ein Spiel an; der Aufrufer ist Spieler 1. */
Beitritt neuesSpiel();
/**
* Tritt einem Spiel als Spieler 2 bei.
*
* @throws SpielNichtGefunden wenn es das Spiel nicht gibt
* @throws IllegalStateException wenn schon zwei Spieler da sind
*/
Beitritt beitreten(String spielId);
/**
* Stellt die eigene Flotte auf.
*
* @throws IllegalArgumentException wenn die Aufstellung gegen eine Regel verstößt
* @throws IllegalStateException wenn gerade nicht aufgestellt werden kann
*/
void aufstellen(String spielId, String token, List<Aufstellung> flotte);
/** Der Stand des Spiels aus der Sicht dessen, dem das Token gehört. */
Spielstand stand(String spielId, String token);
/**
* Schießt auf das Feld des Gegners.
*
* @throws IllegalStateException wenn man nicht dran ist oder das Kästchen schon beschossen wurde
*/
Ergebnis schiessen(String spielId, String token, Koordinate ziel);
}
Schritt im Ablauf Aufruf was zurückkommt
Anmelden neuesSpiel() oder beitreten(id) ein Beitritt: Spiel-ID und Token – beides für jeden weiteren Aufruf aufheben
Warten stand(id, token) – immer wieder ein Spielstand: Phase, ob ich dran bin, alle Schüsse, gewonnen ja/nein
Aufstellen aufstellen(id, token, flotte) nichts – oder eine Exception, wenn die Aufstellung ungültig ist
Schießen schiessen(id, token, ziel) ein Ergebnis: Wasser, Treffer, versenkt

Und die Exceptions, die er erwarten muss:

Exception bedeutet was der Client tut
IllegalArgumentException die Eingabe ist falsch – K11, Schiff über den Rand Meldung zeigen, noch einmal fragen
IllegalStateException gerade nicht erlaubt – nicht dran, schon beschossen Meldung zeigen, noch einmal fragen
SpielNichtGefunden falsche Spiel-ID oder falsches Token Meldung zeigen – beim Beitreten noch einmal fragen

Es gibt den Spieldienst mehrmals – und die Konsole merkt den Unterschied nicht:

Konsole ── kennt nur ──▶ Spieldienst
▲ ▲ ▲
┌──────────────────┘ │ └────────────────┐
Uebungsgegner HttpSpieldienst LokalerSpieldienst
(Attrappe: allein (über das Netz (der echte, im selben
üben, ohne Server) zum Server) Programm)
ClientStart.java
package de.drv.schiffe.client;
import de.drv.schiffe.dienst.Spieldienst;
import de.drv.schiffe.dienst.Uebungsgegner;
import java.util.Scanner;
/**
* Steckt den Client zusammen: ohne Argument gegen den Übungsgegner (allein, ohne Server), mit einer
* Server-Adresse über das Netz. Die Konsole ist in beiden Fällen dieselbe.
*/
public class ClientStart {
public static void main(String[] args) {
Spieldienst dienst = args.length > 0
? new HttpSpieldienst(args[0])
: new Uebungsgegner();
try (Scanner scanner = new Scanner(System.in)) {
new Konsole(dienst, scanner).spiele();
}
}
}
Uebungsgegner.java
Uebungsgegner.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 de.drv.schiffe.spiel.Schiffstyp;
import java.util.ArrayList;
import java.util.EnumMap;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Set;
/**
* Eine Attrappe für den Client: ein ganzer Spielablauf gegen einen Gegner im selben Programm –
* ohne Server und ohne den echten Kern.
*
* <ul>
* <li>Nach {@code neuesSpiel} „tritt der Gegner bei“, sobald zweimal nach dem Stand gefragt wurde.</li>
* <li>Seine Flotte steht fest – immer dieselbe, siehe {@link #GEGNERFLOTTE}.</li>
* <li>Nach jedem eigenen Schuss schießt der Gegner zurück – aber erst bei der zweiten Abfrage
* des Stands, er „denkt nach“. Wer nicht nachfragt, wartet für immer. Genau wie über das Netz.</li>
* </ul>
*/
public class Uebungsgegner implements Spieldienst {
private static final String SPIEL = "uebung";
private static final String TOKEN = "du";
/** Die Flotte des Gegners – dieselbe wie im ersten Artikel. */
public static final String[] GEGNERFLOTTE = {
"FLUGZEUGTRAEGER B2 WAAGERECHT", "SCHLACHTSCHIFF G8 WAAGERECHT", "KREUZER I3 SENKRECHT",
"U_BOOT B4 SENKRECHT", "ZERSTOERER A9 WAAGERECHT",
};
private final Random zufall = new Random();
private Phase phase;
private int abfragenBeimWarten;
private boolean amZug;
private boolean gegnerMussSchiessen;
private int abfragenBisZumGegenschuss;
private Boolean gewonnen;
private final Map<Koordinate, Schiffstyp> gegnerFelder = new HashMap<>();
private final Map<Schiffstyp, Integer> gegnerRest = new EnumMap<>(Schiffstyp.class);
private final Map<Koordinate, Schiffstyp> eigeneFelder = new HashMap<>();
private final Map<Schiffstyp, Integer> eigenerRest = new EnumMap<>(Schiffstyp.class);
private final Map<Koordinate, Ergebnis> eigeneSchuesse = new LinkedHashMap<>();
private final Map<Koordinate, Ergebnis> gegnerischeSchuesse = new LinkedHashMap<>();
@Override
public Beitritt neuesSpiel() {
beginne(Phase.WARTEN_AUF_GEGNER);
return new Beitritt(SPIEL, TOKEN);
}
@Override
public Beitritt beitreten(String spielId) {
if (!SPIEL.equals(spielId)) {
throw new SpielNichtGefunden("Kein Spiel mit der ID " + spielId + " – der Übungsgegner wartet in \"uebung\"");
}
beginne(Phase.AUFSTELLEN); // der Gegner wartet schon
return new Beitritt(SPIEL, TOKEN);
}
@Override
public void aufstellen(String spielId, String token, List<Aufstellung> flotte) {
pruefe(spielId, token);
if (phase != Phase.AUFSTELLEN) {
throw new IllegalStateException("Aufstellen geht gerade nicht (Phase " + phase + ")");
}
eigeneFelder.clear();
eigenerRest.clear();
stelle(flotte, eigeneFelder, eigenerRest);
phase = Phase.LAEUFT;
amZug = true; // wer übt, fängt an
}
@Override
public Spielstand stand(String spielId, String token) {
pruefe(spielId, token);
if (phase == Phase.WARTEN_AUF_GEGNER && ++abfragenBeimWarten >= 2) {
phase = Phase.AUFSTELLEN;
}
if (phase == Phase.LAEUFT && gegnerMussSchiessen && --abfragenBisZumGegenschuss <= 0) {
gegnerSchiesst();
}
return new Spielstand(phase, amZug, Map.copyOf(eigeneSchuesse), Map.copyOf(gegnerischeSchuesse), gewonnen);
}
@Override
public Ergebnis schiessen(String spielId, String token, Koordinate ziel) {
pruefe(spielId, token);
if (phase != Phase.LAEUFT) {
throw new IllegalStateException("Das Spiel läuft nicht (Phase " + phase + ")");
}
if (!amZug) {
throw new IllegalStateException("Du bist nicht dran");
}
if (eigeneSchuesse.containsKey(ziel)) {
throw new IllegalStateException("Auf " + ziel + " wurde schon geschossen");
}
Ergebnis ergebnis = triff(ziel, gegnerFelder, gegnerRest);
eigeneSchuesse.put(ziel, ergebnis);
amZug = false;
if (allesVersenkt(gegnerRest)) {
phase = Phase.VORBEI;
gewonnen = true;
} else {
gegnerMussSchiessen = true;
abfragenBisZumGegenschuss = 2;
}
return ergebnis;
}
// ----- intern ------------------------------------------------------------------------
private void beginne(Phase start) {
phase = start;
abfragenBeimWarten = 0;
amZug = false;
gegnerMussSchiessen = false;
gewonnen = null;
eigeneSchuesse.clear();
gegnerischeSchuesse.clear();
gegnerFelder.clear();
gegnerRest.clear();
List<Aufstellung> flotte = new ArrayList<>();
for (String zeile : GEGNERFLOTTE) {
flotte.add(Aufstellung.von(zeile));
}
stelle(flotte, gegnerFelder, gegnerRest);
}
private void gegnerSchiesst() {
Koordinate ziel;
do {
ziel = new Koordinate(zufall.nextInt(Koordinate.GROESSE), zufall.nextInt(Koordinate.GROESSE));
} while (gegnerischeSchuesse.containsKey(ziel));
gegnerischeSchuesse.put(ziel, triff(ziel, eigeneFelder, eigenerRest));
gegnerMussSchiessen = false;
if (allesVersenkt(eigenerRest)) {
phase = Phase.VORBEI;
gewonnen = false;
} else {
amZug = true;
}
}
/** Prüft eine Aufstellung und trägt jedes Kästchen mit seinem Schiffstyp ein. */
private static void stelle(List<Aufstellung> flotte, Map<Koordinate, Schiffstyp> felder, Map<Schiffstyp, Integer> rest) {
Set<Schiffstyp> typen = EnumSet.noneOf(Schiffstyp.class);
for (Aufstellung schiff : flotte) {
if (!typen.add(schiff.typ())) {
throw new IllegalArgumentException(schiff.typ() + " ist doppelt");
}
for (int i = 0; i < schiff.typ().getLaenge(); i++) {
Koordinate feld = schiff.anfang().verschoben(schiff.richtung(), i); // wirft am Rand
if (felder.put(feld, schiff.typ()) != null) {
throw new IllegalArgumentException("Zwei Schiffe überschneiden sich auf " + feld);
}
}
rest.put(schiff.typ(), schiff.typ().getLaenge());
}
if (typen.size() != Schiffstyp.values().length) {
throw new IllegalArgumentException("Eine Flotte hat genau fünf Schiffe, jedes einmal");
}
}
private static Ergebnis triff(Koordinate ziel, Map<Koordinate, Schiffstyp> felder, Map<Schiffstyp, Integer> rest) {
Schiffstyp typ = felder.get(ziel);
if (typ == null) {
return Ergebnis.WASSER;
}
int uebrig = rest.merge(typ, -1, Integer::sum);
return uebrig == 0 ? Ergebnis.VERSENKT : Ergebnis.TREFFER;
}
private static boolean allesVersenkt(Map<Schiffstyp, Integer> rest) {
return rest.values().stream().allMatch(uebrig -> uebrig == 0);
}
private void pruefe(String spielId, String token) {
if (phase == null || !SPIEL.equals(spielId) || !TOKEN.equals(token)) {
throw new SpielNichtGefunden("Kein Spiel " + spielId + " mit diesem Token");
}
}
}

Der Uebungsgegner erfüllt den Vertrag und spielt ein ganzes Spiel – ganz ohne Server und ohne den echten Kern:

  • Nach neuesSpiel „tritt der Gegner bei“, sobald zweimal nach dem Stand gefragt wurde.
  • Seine Flotte steht fest – dieselbe wie im ersten Artikel. Wer sie kennt, gewinnt in 17 Schüssen. Zum Üben ist das genau richtig.
  • Nach jedem eigenen Schuss schießt er zurück, zufällig – aber erst bei der zweiten Abfrage des Stands. Er „denkt nach“.

Das Wichtigste daran: Er meldet sich nie von selbst. Wer nicht nachfragt, erfährt nie, dass der Gegner geschossen hat. Genau wie bei einem echten Server.

UebungsDemo führt den Ablauf ohne Eingaben vor:

UebungsDemo.java
package de.drv.schiffe.client;
import de.drv.schiffe.dienst.Aufstellung;
import de.drv.schiffe.dienst.Beitritt;
import de.drv.schiffe.dienst.Spieldienst;
import de.drv.schiffe.dienst.Spielstand;
import de.drv.schiffe.dienst.Uebungsgegner;
import de.drv.schiffe.spiel.Ergebnis;
import de.drv.schiffe.spiel.Koordinate;
import de.drv.schiffe.spiel.Phase;
import java.util.List;
/** Der Ablauf eines Spiels als feste Folge von Aufrufen – ohne Eingaben, zum Nachlesen. */
public class UebungsDemo {
public static void main(String[] args) {
Spieldienst dienst = new Uebungsgegner();
Beitritt beitritt = dienst.neuesSpiel();
String id = beitritt.spielId();
String token = beitritt.token();
System.out.println("Spiel " + id + ", Token " + token);
// Warten, bis der Gegner da ist – Polling
for (int abfrage = 1; ; abfrage++) {
Spielstand stand = dienst.stand(id, token);
System.out.println("Abfrage " + abfrage + ": " + stand.phase());
if (stand.phase() != Phase.WARTEN_AUF_GEGNER) {
break;
}
}
dienst.aufstellen(id, token, List.of(
Aufstellung.von("FLUGZEUGTRAEGER A1 W"),
Aufstellung.von("SCHLACHTSCHIFF A3 W"),
Aufstellung.von("KREUZER A5 W"),
Aufstellung.von("U_BOOT A7 W"),
Aufstellung.von("ZERSTOERER A9 W")));
System.out.println("Aufgestellt, jetzt: " + dienst.stand(id, token).phase());
for (String feld : List.of("B2", "C2", "J10")) {
Ergebnis ergebnis = dienst.schiessen(id, token, Koordinate.von(feld));
System.out.print("Schuss auf " + feld + ": " + ergebnis + " – dran?");
// Polling: nachfragen, bis der Gegner geschossen hat
while (!dienst.stand(id, token).amZug()) {
System.out.print(" nein");
}
System.out.println(" ja");
}
try {
dienst.schiessen(id, token, Koordinate.von("B2"));
} catch (IllegalStateException e) {
System.out.println("Noch einmal B2: " + e.getMessage());
}
Spielstand stand = dienst.stand(id, token);
System.out.println("\nDein Zielfeld:");
System.out.print(Feldanzeige.zeichne(stand.eigeneSchuesse()));
System.out.println("Schüsse des Gegners auf dich: " + stand.gegnerischeSchuesse().size());
}
}
Terminal-Fenster
Spiel uebung, Token du
Abfrage 1: WARTEN_AUF_GEGNER
Abfrage 2: AUFSTELLEN
Aufgestellt, jetzt: LAEUFT
Schuss auf B2: TREFFER – dran? nein ja
Schuss auf C2: TREFFER – dran? nein ja
Schuss auf J10: WASSER – dran? nein ja
Noch einmal B2: Auf B2 wurde schon geschossen

Nach jedem Schuss kommt erst ein „nein“: Der Gegner hat noch nicht geschossen. Erst beim nächsten Nachfragen ist man wieder dran.

Bei HTTP fragt immer der Client, und der Server antwortet. Von sich aus meldet sich der Server nie. Wer wissen will, ob der Gegner geschossen hat, muss also nachfragen – immer wieder, mit einer Pause dazwischen. Das heißt Polling.

Konsole.java (Ausschnitt)
Spielstand warteBis(Beitritt beitritt, Predicate<Spielstand> bedingung, String meldung) {
Spielstand stand = dienst.stand(beitritt.spielId(), beitritt.token());
if (!bedingung.test(stand)) {
System.out.println(meldung);
}
while (!bedingung.test(stand)) {
try {
Thread.sleep(WARTEZEIT_MS);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new IllegalStateException("Warten unterbrochen", e);
}
stand = dienst.stand(beitritt.spielId(), beitritt.token());
}
return stand;
}
  • Worauf gewartet wird, sagt ein Predicate – ein Lambda aus dem Kapitel Lambdas. So passt dieselbe Methode für „bis der Gegner da ist“ und für „bis ich dran bin oder das Spiel vorbei ist“:

    warteBis(beitritt, stand -> stand.phase() != Phase.WARTEN_AUF_GEGNER, "Warte auf den Gegner …");
    warteBis(beitritt, stand -> stand.amZug() || stand.phase() == Phase.VORBEI, "Der Gegner ist dran …");
  • Die Pause ist wichtig. Ohne sie fragt der Client tausendmal in der Sekunde – und der Server hat mit neun Clients mehr zu tun als mit dem Spiel selbst. Eine Sekunde ist für ein Spiel, bei dem Menschen nachdenken, mehr als schnell genug.

  • Die Methode liefert den Stand, auf den gewartet wurde. Mit ihm geht es weiter: Felder zeigen oder das Ende melden.

Der HttpSpieldienst ist das Spiegelbild des Servers: Was der Server aus HTTP in Aufrufe übersetzt, übersetzt der HttpSpieldienst aus Aufrufen in HTTP – und die Antwort zurück.

HttpSpieldienst.java (Ausschnitt)
@Override
public Beitritt neuesSpiel() {
String antwort = sende("POST", Protokoll.SPIELE, null, null);
BeitrittAntwort beitritt = json.readValue(antwort, BeitrittAntwort.class);
return new Beitritt(beitritt.spielId(), beitritt.token());
}

Die Werkzeuge dafür sind fertig:

  • sende(methode, pfad, token, nachricht) schreibt die Nachricht als JSON, setzt den Header X-Spieler, schickt die Anfrage und liefert den Rumpf der Antwort.
  • pruefe(antwort) übersetzt einen Fehlercode zurück in die Exception, die der Vertrag verspricht – damit die Konsole nichts von Statuscodes wissen muss:
HttpSpieldienst.java (Ausschnitt)
switch (status) {
case 400 -> throw new IllegalArgumentException(meldung);
case 403, 404 -> throw new SpielNichtGefunden(meldung);
case 409 -> throw new IllegalStateException(meldung);
default -> throw new IllegalStateException("Fehler im Server (" + status + "): " + meldung);
}

Ist der Server gar nicht erreichbar, wirft der HttpClient eine IOException – sende verpackt sie in eine UncheckedIOException, denn der Vertrag sieht keine geprüften Exceptions vor.

HttpSpieldienst.java im Ganzen
HttpSpieldienst.java
package de.drv.schiffe.client;
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.Protokoll;
import de.drv.schiffe.spiel.Ergebnis;
import de.drv.schiffe.spiel.Koordinate;
import tools.jackson.databind.json.JsonMapper;
import java.io.IOException;
import java.io.UncheckedIOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.List;
/**
* Erfüllt den Vertrag {@link Spieldienst} über das Netz: Jeder Aufruf wird zu einer HTTP-Anfrage
* an den Server, jede Antwort zurück zu einem Ergebnis – und jeder Fehlercode wieder zu der
* Exception, die der Vertrag verspricht.
*
* <p>Fertig: {@link #neuesSpiel()} und die Werkzeuge {@code sende} und {@code pruefe}. Die anderen
* vier Methoden sind die Übung.
*/
public class HttpSpieldienst implements Spieldienst {
private final String server;
private final HttpClient client = HttpClient.newHttpClient();
private final JsonMapper json = JsonMapper.builder().build();
/** @param server z. B. "http://localhost:8080" */
public HttpSpieldienst(String server) {
this.server = server;
}
@Override
public Beitritt neuesSpiel() {
String antwort = sende("POST", Protokoll.SPIELE, null, null);
BeitrittAntwort beitritt = json.readValue(antwort, BeitrittAntwort.class);
return new Beitritt(beitritt.spielId(), beitritt.token());
}
@Override
public Beitritt beitreten(String spielId) {
throw new UnsupportedOperationException("Übung, Stufe 4");
}
@Override
public void aufstellen(String spielId, String token, List<Aufstellung> flotte) {
throw new UnsupportedOperationException("Übung, Stufe 4");
}
@Override
public Spielstand stand(String spielId, String token) {
throw new UnsupportedOperationException("Übung, Stufe 4");
}
@Override
public Ergebnis schiessen(String spielId, String token, Koordinate ziel) {
throw new UnsupportedOperationException("Übung, Stufe 4");
}
// ----- Werkzeuge ---------------------------------------------------------------------
/**
* Schickt eine Anfrage und liefert den Rumpf der Antwort.
*
* @param token für den Header X-Spieler – oder {@code null}
* @param nachricht wird als JSON geschickt – oder {@code null} für keinen Rumpf
*/
String sende(String methode, String pfad, String token, Object nachricht) {
HttpRequest.BodyPublisher rumpf = nachricht == null
? HttpRequest.BodyPublishers.noBody()
: HttpRequest.BodyPublishers.ofByteArray(json.writeValueAsBytes(nachricht));
HttpRequest.Builder anfrage = HttpRequest.newBuilder(URI.create(server + pfad))
.method(methode, rumpf)
.header("Content-Type", "application/json");
if (token != null) {
anfrage.header(Protokoll.TOKEN_HEADER, token);
}
try {
HttpResponse<String> antwort = client.send(anfrage.build(), HttpResponse.BodyHandlers.ofString());
pruefe(antwort);
return antwort.body();
} catch (IOException e) {
throw new UncheckedIOException("Server nicht erreichbar: " + server, e);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new IllegalStateException("Unterbrochen", e);
}
}
/** Übersetzt einen Fehlercode zurück in die Exception, die der Vertrag verspricht. */
void pruefe(HttpResponse<String> antwort) {
int status = antwort.statusCode();
if (status < 400) {
return;
}
String meldung = antwort.body().isBlank()
? "Status " + status
: json.readValue(antwort.body(), Fehler.class).fehler();
switch (status) {
case 400 -> throw new IllegalArgumentException(meldung);
case 403, 404 -> throw new SpielNichtGefunden(meldung);
case 409 -> throw new IllegalStateException(meldung);
default -> throw new IllegalStateException("Fehler im Server (" + status + "): " + meldung);
}
}
}

Arbeite im Demo-Projekt 35-schiffe-client. Die Stufen 1 bis 3 spielst du gegen den Übungsgegner – ganz ohne Server.

Konsole.java
package de.drv.schiffe.client;
import de.drv.schiffe.dienst.Beitritt;
import de.drv.schiffe.dienst.Spieldienst;
import de.drv.schiffe.dienst.Spielstand;
import de.drv.schiffe.spiel.Phase;
import java.util.Scanner;
import java.util.function.Predicate;
/**
* Das Spiel auf der Konsole. Sie kennt nur den {@link Spieldienst} – ob er ein Übungsgegner ist
* oder über das Netz spricht, weiß sie nicht.
*
* <p>Der Ablauf steht fest, und das Warten ist fertig. Die vier Abschnitte sind die Übung.
*/
public class Konsole {
private static final long WARTEZEIT_MS = 1000; // wie oft nachgefragt wird
private final Spieldienst dienst;
private final Scanner scanner;
public Konsole(Spieldienst dienst, Scanner scanner) {
this.dienst = dienst;
this.scanner = scanner;
}
/** Der ganze Ablauf eines Spiels. */
public void spiele() {
Beitritt beitritt = anmelden(); // 1. anlegen oder beitreten
warteBis(beitritt, stand -> stand.phase() != Phase.WARTEN_AUF_GEGNER, "Warte auf den Gegner …");
stelleAuf(beitritt); // 2. Flotte aufstellen
spieleBisZumEnde(beitritt); // 3. schießen und warten
}
/** 1. Fragt, ob ein Spiel angelegt oder einem beigetreten wird – und tut es. */
private Beitritt anmelden() {
throw new UnsupportedOperationException("Übung, Stufe 1");
}
/** 2. Liest fünf Aufstellungen ein und stellt die Flotte auf. */
private void stelleAuf(Beitritt beitritt) {
throw new UnsupportedOperationException("Übung, Stufe 2");
}
/** 3. Abwechselnd: warten, bis man dran ist, Felder zeigen, schießen – bis das Spiel vorbei ist. */
private void spieleBisZumEnde(Beitritt beitritt) {
throw new UnsupportedOperationException("Übung, Stufe 3");
}
/**
* Fragt so lange nach dem Stand, bis die Bedingung erfüllt ist – mit einer Pause dazwischen.
* Das ist <em>Polling</em>: Der Server meldet sich nie von selbst, also fragt der Client nach.
*
* @return der erste Stand, der die Bedingung erfüllt
*/
Spielstand warteBis(Beitritt beitritt, Predicate<Spielstand> bedingung, String meldung) {
Spielstand stand = dienst.stand(beitritt.spielId(), beitritt.token());
if (!bedingung.test(stand)) {
System.out.println(meldung);
}
while (!bedingung.test(stand)) {
try {
Thread.sleep(WARTEZEIT_MS);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new IllegalStateException("Warten unterbrochen", e);
}
stand = dienst.stand(beitritt.spielId(), beitritt.token());
}
return stand;
}
}
  1. Anmelden: anmelden() fragt (n)eues Spiel oder (b)eitreten?. Bei n legt es ein Spiel an und zeigt die Spiel-ID, die man dem Gegner sagen muss. Bei b fragt es nach der ID und tritt bei. Eine falsche Eingabe oder eine unbekannte ID führt zu einer Meldung und einer neuen Frage.

  2. Aufstellen: stelleAuf() fragt für jeden Schiffstyp nach Anfangsfeld und Richtung – etwa B2 W – und stellt die Flotte auf. Ist die Aufstellung ungültig, fängt man von vorn an.

    Terminal-Fenster
    Stelle deine Flotte auf: Anfangsfeld und Richtung, z. B. B2 W (waagerecht) oder B2 S (senkrecht).
    FLUGZEUGTRAEGER (5): A1 W
    SCHLACHTSCHIFF (4): A3 W
    KREUZER (3): A5 W
    U_BOOT (3): A7 W
    ZERSTOERER (2): K9 W
    Keine Koordinate: K9 – noch einmal von vorn.
  3. Schießen bis zum Ende: spieleBisZumEnde() wartet mit warteBis, bis man dran ist oder das Spiel vorbei ist. Ist man dran, zeigt es beide Felder mit der Feldanzeige, fragt nach dem Ziel, schießt und zeigt das Ergebnis. Ist das Spiel vorbei: Gewonnen! oder Verloren.

    Terminal-Fenster
    Dein Schuss: B2
    B2: TREFFER
    Der Gegner ist dran …
    Dein Feld – die Schüsse des Gegners:
    A B C D E F G H I J
    1 . . . . . . . . . .
    2 . . . . . . . . . ~
    …
  4. Über das Netz: Fülle die übrigen vier Methoden des HttpSpieldienst aus – nach dem Muster von neuesSpiel, mit den Nachrichten aus Nachrichten. Dann zwei Clients gegen einen Server: einmal ServerStart starten, dann ClientStart zweimal mit dem Argument http://localhost:8080 – oder mit der Adresse eines anderen Rechners.

  5. Für Schnelle: Bei der Aufstellung soll z eine zufällige Flotte aufstellen – ohne Überschneidung und ohne über den Rand zu ragen. Und: Wie könnte ein Test für die Konsole aussehen, der ein ganzes Spiel gegen den Übungsgegner spielt, ohne dass jemand tippt?

Lösung
  • anmelden und schiesse fangen die Exceptions des Vertrags, zeigen ihre Meldung und fragen in einer Schleife noch einmal. Die Meldungen kommen vom Dienst – die Konsole muss die Regeln nicht kennen.
  • stelleAuf baut die Eingabe zu einer Zeile wie KREUZER B2 W zusammen und überlässt das Lesen Aufstellung.von.
  • zufaelligeFlotte würfelt Anfangsfeld und Richtung, bis ein Schiff passt – verschoben wirft am Rand, ein Set der belegten Felder verhindert Überschneidungen.
  • Ein zweiter Konstruktor nimmt die Wartezeit als Parameter. Im Test ist sie 0 – sonst dauerte ein ganzes Spiel eine halbe Minute.
Konsole.java
package de.drv.schiffe.client;
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.spiel.Ergebnis;
import de.drv.schiffe.spiel.Koordinate;
import de.drv.schiffe.spiel.Phase;
import de.drv.schiffe.spiel.Richtung;
import de.drv.schiffe.spiel.Schiffstyp;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Random;
import java.util.Scanner;
import java.util.Set;
import java.util.function.Predicate;
/**
* Das Spiel auf der Konsole. Sie kennt nur den {@link Spieldienst} – ob er ein Übungsgegner ist
* oder über das Netz spricht, weiß sie nicht.
*/
public class Konsole {
private final Spieldienst dienst;
private final Scanner scanner;
private final long wartezeitMs;
public Konsole(Spieldienst dienst, Scanner scanner) {
this(dienst, scanner, 1000);
}
/** Mit eigener Wartezeit zwischen zwei Abfragen – für Tests 0. */
public Konsole(Spieldienst dienst, Scanner scanner, long wartezeitMs) {
this.dienst = dienst;
this.scanner = scanner;
this.wartezeitMs = wartezeitMs;
}
/** Der ganze Ablauf eines Spiels. */
public void spiele() {
Beitritt beitritt = anmelden();
warteBis(beitritt, stand -> stand.phase() != Phase.WARTEN_AUF_GEGNER, "Warte auf den Gegner …");
stelleAuf(beitritt);
spieleBisZumEnde(beitritt);
}
/** 1. Fragt, ob ein Spiel angelegt oder einem beigetreten wird – und tut es. */
private Beitritt anmelden() {
while (true) {
System.out.print("(n)eues Spiel oder (b)eitreten? ");
String wahl = scanner.nextLine().trim().toLowerCase();
try {
if (wahl.startsWith("n")) {
Beitritt beitritt = dienst.neuesSpiel();
System.out.println("Spiel angelegt. Gib deinem Gegner die ID: " + beitritt.spielId());
return beitritt;
}
if (wahl.startsWith("b")) {
System.out.print("Spiel-ID: ");
return dienst.beitreten(scanner.nextLine().trim());
}
} catch (SpielNichtGefunden | IllegalStateException e) {
System.out.println(e.getMessage());
}
}
}
/** 2. Liest fünf Aufstellungen ein – oder würfelt sie aus – und stellt die Flotte auf. */
private void stelleAuf(Beitritt beitritt) {
System.out.println("Stelle deine Flotte auf: Anfangsfeld und Richtung, z. B. B2 W (waagerecht) oder B2 S (senkrecht).");
System.out.println("Oder z für eine zufällige Flotte.");
while (true) {
List<Aufstellung> flotte = new ArrayList<>();
try {
for (Schiffstyp typ : Schiffstyp.values()) {
System.out.print(typ + " (" + typ.getLaenge() + "): ");
String eingabe = scanner.nextLine().trim();
if (eingabe.equalsIgnoreCase("z")) {
flotte = zufaelligeFlotte();
break;
}
flotte.add(Aufstellung.von(typ + " " + eingabe));
}
dienst.aufstellen(beitritt.spielId(), beitritt.token(), flotte);
System.out.println("Aufgestellt.");
return;
} catch (IllegalArgumentException e) {
System.out.println(e.getMessage() + " – noch einmal von vorn.");
}
}
}
/** 3. Abwechselnd: warten, bis man dran ist, Felder zeigen, schießen – bis das Spiel vorbei ist. */
private void spieleBisZumEnde(Beitritt beitritt) {
while (true) {
Spielstand stand = warteBis(beitritt, s -> s.amZug() || s.phase() == Phase.VORBEI, "Der Gegner ist dran …");
if (stand.phase() == Phase.VORBEI) {
System.out.println(Boolean.TRUE.equals(stand.gewonnen()) ? "Gewonnen!" : "Verloren.");
return;
}
System.out.println("Dein Feld – die Schüsse des Gegners:");
System.out.print(Feldanzeige.zeichne(stand.gegnerischeSchuesse()));
System.out.println("Dein Zielfeld:");
System.out.print(Feldanzeige.zeichne(stand.eigeneSchuesse()));
schiesse(beitritt);
}
}
private void schiesse(Beitritt beitritt) {
while (true) {
System.out.print("Dein Schuss: ");
try {
Koordinate ziel = Koordinate.von(scanner.nextLine());
Ergebnis ergebnis = dienst.schiessen(beitritt.spielId(), beitritt.token(), ziel);
System.out.println(ziel + ": " + ergebnis);
return;
} catch (IllegalArgumentException | IllegalStateException e) {
System.out.println(e.getMessage());
}
}
}
/** Fünf Schiffe an zufälligen Stellen – ohne Überschneidung, ohne über den Rand zu ragen. */
static List<Aufstellung> zufaelligeFlotte() {
Random zufall = new Random();
List<Aufstellung> flotte = new ArrayList<>();
Set<Koordinate> belegt = new HashSet<>();
for (Schiffstyp typ : Schiffstyp.values()) {
while (true) {
Richtung richtung = zufall.nextBoolean() ? Richtung.WAAGERECHT : Richtung.SENKRECHT;
Koordinate anfang = new Koordinate(zufall.nextInt(Koordinate.GROESSE), zufall.nextInt(Koordinate.GROESSE));
try {
List<Koordinate> felder = new ArrayList<>();
for (int i = 0; i < typ.getLaenge(); i++) {
felder.add(anfang.verschoben(richtung, i)); // wirft am Rand
}
if (felder.stream().noneMatch(belegt::contains)) {
belegt.addAll(felder);
flotte.add(new Aufstellung(typ, anfang, richtung));
break;
}
} catch (IllegalArgumentException ueberDenRand) {
// nächster Versuch
}
}
}
return flotte;
}
/**
* Fragt so lange nach dem Stand, bis die Bedingung erfüllt ist – mit einer Pause dazwischen.
* Das ist <em>Polling</em>: Der Server meldet sich nie von selbst, also fragt der Client nach.
*/
Spielstand warteBis(Beitritt beitritt, Predicate<Spielstand> bedingung, String meldung) {
Spielstand stand = dienst.stand(beitritt.spielId(), beitritt.token());
if (!bedingung.test(stand)) {
System.out.println(meldung);
}
while (!bedingung.test(stand)) {
try {
Thread.sleep(wartezeitMs);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new IllegalStateException("Warten unterbrochen", e);
}
stand = dienst.stand(beitritt.spielId(), beitritt.token());
}
return stand;
}
}
Lösung

Jede Methode folgt demselben Muster: fachliche Typen in eine Nachricht, sende, die Antwort zurück in fachliche Typen. alsTypen ist das Gegenstück zu alsText im Server.

HttpSpieldienst.java
package de.drv.schiffe.client;
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.Phase;
import tools.jackson.databind.json.JsonMapper;
import java.io.IOException;
import java.io.UncheckedIOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* Erfüllt den Vertrag {@link Spieldienst} über das Netz: Jeder Aufruf wird zu einer HTTP-Anfrage
* an den Server, jede Antwort zurück zu einem Ergebnis – und jeder Fehlercode wieder zu der
* Exception, die der Vertrag verspricht.
*
*/
public class HttpSpieldienst implements Spieldienst {
private final String server;
private final HttpClient client = HttpClient.newHttpClient();
private final JsonMapper json = JsonMapper.builder().build();
/** @param server z. B. "http://localhost:8080" */
public HttpSpieldienst(String server) {
this.server = server;
}
@Override
public Beitritt neuesSpiel() {
String antwort = sende("POST", Protokoll.SPIELE, null, null);
BeitrittAntwort beitritt = json.readValue(antwort, BeitrittAntwort.class);
return new Beitritt(beitritt.spielId(), beitritt.token());
}
@Override
public Beitritt beitreten(String spielId) {
String antwort = sende("POST", Protokoll.spieler(spielId), null, null);
BeitrittAntwort beitritt = json.readValue(antwort, BeitrittAntwort.class);
return new Beitritt(beitritt.spielId(), beitritt.token());
}
@Override
public void aufstellen(String spielId, String token, List<Aufstellung> flotte) {
// fachliche Typen → Nachricht: Enums und Koordinaten werden zu Texten
List<SchiffNachricht> schiffe = new ArrayList<>();
for (Aufstellung schiff : flotte) {
schiffe.add(new SchiffNachricht(schiff.typ().name(), schiff.anfang().toString(), schiff.richtung().name()));
}
sende("PUT", Protokoll.flotte(spielId), token, new FlotteAnfrage(schiffe));
}
@Override
public Spielstand stand(String spielId, String token) {
StandAntwort stand = json.readValue(sende("GET", Protokoll.spiel(spielId), token, null), StandAntwort.class);
return new Spielstand(Phase.valueOf(stand.phase()), stand.amZug(),
alsTypen(stand.eigeneSchuesse()), alsTypen(stand.gegnerischeSchuesse()), stand.gewonnen());
}
@Override
public Ergebnis schiessen(String spielId, String token, Koordinate ziel) {
String antwort = sende("POST", Protokoll.schuesse(spielId), token, new SchussAnfrage(ziel.toString()));
return Ergebnis.valueOf(json.readValue(antwort, SchussAntwort.class).ergebnis());
}
/** Nachricht → fachliche Typen: Texte werden wieder zu Koordinaten und Ergebnissen. */
private static Map<Koordinate, Ergebnis> alsTypen(Map<String, String> schuesse) {
Map<Koordinate, Ergebnis> typen = new HashMap<>();
for (Map.Entry<String, String> schuss : schuesse.entrySet()) {
typen.put(Koordinate.von(schuss.getKey()), Ergebnis.valueOf(schuss.getValue()));
}
return typen;
}
// ----- Werkzeuge ---------------------------------------------------------------------
/**
* Schickt eine Anfrage und liefert den Rumpf der Antwort.
*
* @param token für den Header X-Spieler – oder {@code null}
* @param nachricht wird als JSON geschickt – oder {@code null} für keinen Rumpf
*/
String sende(String methode, String pfad, String token, Object nachricht) {
HttpRequest.BodyPublisher rumpf = nachricht == null
? HttpRequest.BodyPublishers.noBody()
: HttpRequest.BodyPublishers.ofByteArray(json.writeValueAsBytes(nachricht));
HttpRequest.Builder anfrage = HttpRequest.newBuilder(URI.create(server + pfad))
.method(methode, rumpf)
.header("Content-Type", "application/json");
if (token != null) {
anfrage.header(Protokoll.TOKEN_HEADER, token);
}
try {
HttpResponse<String> antwort = client.send(anfrage.build(), HttpResponse.BodyHandlers.ofString());
pruefe(antwort);
return antwort.body();
} catch (IOException e) {
throw new UncheckedIOException("Server nicht erreichbar: " + server, e);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new IllegalStateException("Unterbrochen", e);
}
}
/** Übersetzt einen Fehlercode zurück in die Exception, die der Vertrag verspricht. */
void pruefe(HttpResponse<String> antwort) {
int status = antwort.statusCode();
if (status < 400) {
return;
}
String meldung = antwort.body().isBlank()
? "Status " + status
: json.readValue(antwort.body(), Fehler.class).fehler();
switch (status) {
case 400 -> throw new IllegalArgumentException(meldung);
case 403, 404 -> throw new SpielNichtGefunden(meldung);
case 409 -> throw new IllegalStateException(meldung);
default -> throw new IllegalStateException("Fehler im Server (" + status + "): " + meldung);
}
}
}
Lösung

Der Test ersetzt die Tastatur durch einen Scanner über einem Text – mit falschen Eingaben und allen 17 Feldern der Gegnerflotte. Die Ausgabe fängt er ab, indem er System.out vorübergehend auf einen ByteArrayOutputStream umlenkt.

KonsoleTest.java
package de.drv.schiffe.client;
import static org.junit.jupiter.api.Assertions.assertTrue;
import de.drv.schiffe.dienst.Aufstellung;
import de.drv.schiffe.dienst.Uebungsgegner;
import de.drv.schiffe.spiel.Koordinate;
import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
class KonsoleTest {
@Test
@DisplayName("Ein ganzes Spiel gegen den Übungsgegner – mit falschen Eingaben zwischendurch")
void ganzesSpiel() {
StringBuilder eingabe = new StringBuilder();
eingabe.append("x\nn\n"); // erst Unsinn, dann neues Spiel
eingabe.append("A1 W\nA3 W\nA5 W\nA7 W\nK9 W\n"); // Zerstörer auf K9 gibt es nicht …
eingabe.append("A1 W\nA3 W\nA5 W\nA7 W\nA9 W\n"); // … also alles noch einmal
eingabe.append("Z99\n"); // kein Feld
for (String zeile : Uebungsgegner.GEGNERFLOTTE) { // alle 17 Felder des Gegners
Aufstellung schiff = Aufstellung.von(zeile);
for (int i = 0; i < schiff.typ().getLaenge(); i++) {
Koordinate feld = schiff.anfang().verschoben(schiff.richtung(), i);
eingabe.append(feld).append('\n');
}
}
ByteArrayOutputStream ausgabe = new ByteArrayOutputStream();
PrintStream vorher = System.out;
System.setOut(new PrintStream(ausgabe, true, StandardCharsets.UTF_8));
try {
new Konsole(new Uebungsgegner(), new Scanner(eingabe.toString()), 0).spiele();
} finally {
System.setOut(vorher);
}
String text = ausgabe.toString(StandardCharsets.UTF_8);
assertTrue(text.contains("Keine Koordinate: K9"), text);
assertTrue(text.contains("Keine Koordinate: Z99"), text);
assertTrue(text.contains("VERSENKT"), text);
assertTrue(text.contains("Gewonnen!"), text);
}
}
Lösung

Zwei HttpSpieldienste gegen einen echten Server auf Port 0 – ein ganzes Spiel nur über den Vertrag. Der zweite Test prüft, dass jeder Fehlercode wieder zur richtigen Exception wird.

HttpSpieldienstTest.java
package de.drv.schiffe.client;
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 de.drv.schiffe.dienst.Aufstellung;
import de.drv.schiffe.dienst.Beitritt;
import de.drv.schiffe.dienst.LokalerSpieldienst;
import de.drv.schiffe.dienst.SpielNichtGefunden;
import de.drv.schiffe.dienst.Spielstand;
import de.drv.schiffe.server.SpielServer;
import de.drv.schiffe.spiel.Ergebnis;
import de.drv.schiffe.spiel.Koordinate;
import de.drv.schiffe.spiel.Phase;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
/** Zwei Clients spielen über einen echten Server gegeneinander – nur über das Interface. */
class HttpSpieldienstTest {
private static final List<Aufstellung> FLOTTE = List.of(
Aufstellung.von("FLUGZEUGTRAEGER A1 W"), Aufstellung.von("SCHLACHTSCHIFF A3 W"),
Aufstellung.von("KREUZER A5 W"), Aufstellung.von("U_BOOT A7 W"), Aufstellung.von("ZERSTOERER A9 W"));
private SpielServer server;
private HttpSpieldienst anna;
private HttpSpieldienst ben;
@BeforeEach
void starte() throws IOException {
server = new SpielServer(new LokalerSpieldienst(), 0);
server.starte();
anna = new HttpSpieldienst("http://localhost:" + server.getPort());
ben = new HttpSpieldienst("http://localhost:" + server.getPort());
}
@AfterEach
void stoppe() {
server.stoppe();
}
@Test
@DisplayName("Ein ganzes Spiel über HTTP – Anna versenkt alles, Ben trifft nur Wasser")
void ganzesSpiel() {
Beitritt a = anna.neuesSpiel();
assertEquals(Phase.WARTEN_AUF_GEGNER, anna.stand(a.spielId(), a.token()).phase());
Beitritt b = ben.beitreten(a.spielId());
anna.aufstellen(a.spielId(), a.token(), FLOTTE);
ben.aufstellen(b.spielId(), b.token(), FLOTTE);
List<Koordinate> bensSchiffe = new ArrayList<>();
for (Aufstellung schiff : FLOTTE) {
for (int i = 0; i < schiff.typ().getLaenge(); i++) {
bensSchiffe.add(schiff.anfang().verschoben(schiff.richtung(), i));
}
}
Ergebnis letztes = null;
for (int i = 0; i < bensSchiffe.size(); i++) {
letztes = anna.schiessen(a.spielId(), a.token(), bensSchiffe.get(i));
if (i < bensSchiffe.size() - 1) {
assertEquals(Ergebnis.WASSER, ben.schiessen(b.spielId(), b.token(), new Koordinate(i % 10, 1 + 2 * (i / 10))));
}
}
assertEquals(Ergebnis.VERSENKT, letztes);
Spielstand annasStand = anna.stand(a.spielId(), a.token());
Spielstand bensStand = ben.stand(b.spielId(), b.token());
assertEquals(Phase.VORBEI, annasStand.phase());
assertTrue(annasStand.gewonnen());
assertFalse(bensStand.gewonnen());
assertEquals(17, annasStand.eigeneSchuesse().size());
assertEquals(16, bensStand.eigeneSchuesse().size());
}
@Test
@DisplayName("Fehlercodes werden wieder zu den Exceptions des Vertrags")
void fehler() {
Beitritt a = anna.neuesSpiel();
assertThrows(SpielNichtGefunden.class, () -> ben.beitreten("gibt-es-nicht"));
assertThrows(SpielNichtGefunden.class, () -> anna.stand(a.spielId(), "falsches-token"));
assertThrows(IllegalStateException.class, () -> anna.schiessen(a.spielId(), a.token(), Koordinate.von("A1")));
Beitritt b = ben.beitreten(a.spielId());
assertThrows(IllegalStateException.class, () -> ben.beitreten(a.spielId()));
assertThrows(IllegalArgumentException.class, () -> anna.aufstellen(a.spielId(), a.token(), FLOTTE.subList(0, 4)));
assertEquals(Phase.AUFSTELLEN, ben.stand(b.spielId(), b.token()).phase());
}
}