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.
Was du am Ende kannst
Abschnitt betitelt „Was du am Ende kannst“- 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 herunterladenDer fertige Stand aus der Vorführung – zum Nachlesen, Ausprobieren und Weiterbauen.
Entpacke die ZIP-Datei nach C:\dev\intellij. In IntelliJ: File → Open… → den Ordner 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
Konsolemit 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.
Der Ablauf aus Sicht des Spielers
Abschnitt betitelt „Der Ablauf aus Sicht des Spielers“ ┌───────────────┐ │ 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.
Das Interface, das der Client bedient
Abschnitt betitelt „Das Interface, das der Client bedient“Der Client kennt nur den Spieldienst aus dem
Klassenmodell:
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)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(); } }
}Der Übungsgegner
Abschnitt betitelt „Der Übungsgegner“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:
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()); }
}Spiel uebung, Token duAbfrage 1: WARTEN_AUF_GEGNERAbfrage 2: AUFSTELLENAufgestellt, jetzt: LAEUFTSchuss auf B2: TREFFER – dran? nein jaSchuss auf C2: TREFFER – dran? nein jaSchuss auf J10: WASSER – dran? nein jaNoch einmal B2: Auf B2 wurde schon geschossenNach jedem Schuss kommt erst ein „nein“: Der Gegner hat noch nicht geschossen. Erst beim nächsten Nachfragen ist man wieder dran.
Warten: Polling
Abschnitt betitelt „Warten: Polling“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.
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.
Über das Netz: HttpSpieldienst
Abschnitt betitelt „Über das Netz: HttpSpieldienst“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.
@Overridepublic 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 HeaderX-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:
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
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); } }
}Übung: Ein Client zum Spielen
Abschnitt betitelt „Übung: Ein Client zum Spielen“Arbeite im Demo-Projekt 35-schiffe-client. Die Stufen 1 bis 3 spielst du gegen
den Übungsgegner – ganz ohne Server.
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; }
}-
Anmelden:
anmelden()fragt (n)eues Spiel oder (b)eitreten?. Beinlegt es ein Spiel an und zeigt die Spiel-ID, die man dem Gegner sagen muss. Beibfragt es nach der ID und tritt bei. Eine falsche Eingabe oder eine unbekannte ID führt zu einer Meldung und einer neuen Frage. -
Aufstellen:
stelleAuf()fragt für jedenSchiffstypnach Anfangsfeld und Richtung – etwaB2 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 WSCHLACHTSCHIFF (4): A3 WKREUZER (3): A5 WU_BOOT (3): A7 WZERSTOERER (2): K9 WKeine Koordinate: K9 – noch einmal von vorn. -
Schießen bis zum Ende:
spieleBisZumEnde()wartet mitwarteBis, bis man dran ist oder das Spiel vorbei ist. Ist man dran, zeigt es beide Felder mit derFeldanzeige, fragt nach dem Ziel, schießt und zeigt das Ergebnis. Ist das Spiel vorbei: Gewonnen! oder Verloren.Terminal-Fenster Dein Schuss: B2B2: TREFFERDer Gegner ist dran …Dein Feld – die Schüsse des Gegners:A B C D E F G H I J1 . . . . . . . . . .2 . . . . . . . . . ~… -
Über das Netz: Fülle die übrigen vier Methoden des
HttpSpieldienstaus – nach dem Muster vonneuesSpiel, mit den Nachrichten ausNachrichten. Dann zwei Clients gegen einen Server: einmalServerStartstarten, dannClientStartzweimal mit dem Argumenthttp://localhost:8080– oder mit der Adresse eines anderen Rechners. -
Für Schnelle: Bei der Aufstellung soll
zeine zufällige Flotte aufstellen – ohne Überschneidung und ohne über den Rand zu ragen. Und: Wie könnte ein Test für dieKonsoleaussehen, der ein ganzes Spiel gegen den Übungsgegner spielt, ohne dass jemand tippt?
Lösung
anmeldenundschiessefangen 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.stelleAufbaut die Eingabe zu einer Zeile wieKREUZER B2 Wzusammen und überlässt das LesenAufstellung.von.zufaelligeFlottewürfelt Anfangsfeld und Richtung, bis ein Schiff passt –verschobenwirft am Rand, einSetder 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.
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.
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.
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.
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()); }
}