Schiffe versenken: Spiel und Protokoll
Zwei Spieler, zwei Rechner, ein Spiel: Schiffe versenken. Bisher liefen unsere Programme allein auf einem Rechner. Jetzt sollen zwei Programme miteinander reden – über das Netz. Dafür brauchen wir zweierlei: ein gutes Modell des Spiels und ein Protokoll, also feste Regeln, wie die Programme miteinander sprechen.
Dieser Artikel baut noch nichts fertig. Er legt die Grundlage: Was gehört zum Spiel, was macht es über das Netz schwierig, und wie könnte das Protokoll aussehen? Am Ende steht ein kleiner Server, mit dem ihr anfangen könnt.
Was du am Ende kannst
Abschnitt betitelt „Was du am Ende kannst“- die Regeln des Spiels in Begriffe und Typen übersetzen
- erklären, was ein Client und ein Server sind
- eine HTTP-Anfrage und eine HTTP-Antwort lesen
- die Probleme eines Spiels über das Netz benennen – und Lösungen dafür
- mit dem
HttpServeraus dem JDK einen eigenen Server starten
Demo-Code: 32-schiffe-start
⤓ schiffe-start.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 32-schiffe-start 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, HalloServer.java, HalloClient.java
Das Spiel
Abschnitt betitelt „Das Spiel“Jeder Spieler hat ein Feld aus 10 × 10 Kästchen. Die Spalten heißen A bis
J, die Zeilen 1 bis 10 – ein Kästchen ist also zum Beispiel B7.
A B C D E F G H I J 1 . . . . . . . . . . 2 . ■ ■ ■ ■ ■ . . . . ■ ein Schiff 3 . . . . . . . . ■ . . Wasser 4 . ■ . . . . . . ■ . 5 . ■ . . . . . . ■ . 6 . ■ . . . . . . . . 7 . . . . . . . . . . 8 . . . . . . ■ ■ ■ ■ 9 ■ ■ . . . . . . . .10 . . . . . . . . . .Die Flotte – jeder Spieler hat genau diese fünf Schiffe:
| Schiff | Länge |
|---|---|
| Flugzeugträger | 5 |
| Schlachtschiff | 4 |
| Kreuzer | 3 |
| U-Boot | 3 |
| Zerstörer | 2 |
Die Regeln:
- Aufstellen: Jeder stellt seine Flotte auf sein Feld – waagerecht oder senkrecht, ganz innerhalb des Felds, ohne Überschneidung. Wo die Schiffe des anderen stehen, sieht man nicht.
- Schießen: Abwechselnd nennt jeder ein Kästchen beim Gegner. Der antwortet mit Wasser, Treffer oder versenkt – versenkt heißt: Das war das letzte noch nicht getroffene Kästchen eines Schiffs.
- Ende: Wer zuerst alle Schiffe des Gegners versenkt hat, gewinnt.
Eine häufige Zusatzregel: Schiffe dürfen sich nicht berühren, auch nicht über Eck. Ob ihr sie nehmt, entscheidet ihr – aber vorher, und für beide Seiten gleich.
Die Begriffe und ihre Typen
Abschnitt betitelt „Die Begriffe und ihre Typen“Wie bei jedem Programm lohnt der Blick auf die Begriffe, bevor die erste Zeile Code entsteht. Ein Vorschlag:
| Begriff | Typ | Art | warum |
|---|---|---|---|
Kästchen, z. B. B7 |
Koordinate |
Record (spalte, zeile) |
ein unveränderlicher Wert; kann sich selbst aus "B7" lesen und prüfen |
| waagerecht / senkrecht | Richtung |
Enum | genau zwei Werte |
| Flugzeugträger, Kreuzer … | Schiffstyp |
Enum mit Feld laenge |
feste Auswahl, jeder mit eigener Länge |
| ein aufgestelltes Schiff | Schiff |
Klasse | kennt seine Kästchen und merkt sich Treffer – ein Zustand, der sich ändert |
| Wasser / Treffer / versenkt | Ergebnis |
Enum | genau drei Antworten |
| eigenes Feld mit Flotte | Flotte |
Klasse | prüft das Aufstellen, beantwortet Schüsse, weiß, ob alles versenkt ist |
| Wer ist dran? Läuft das Spiel noch? | Phase, Spiel |
Enum und Klasse | ein Spiel durchläuft Phasen und verwaltet zwei Flotten |
Ein Gedanke ist dabei entscheidend: Der Kern des Spiels weiß nichts vom
Netz. Flotte und Spiel sind gewöhnliche Klassen, die man mit JUnit testen
kann – ohne Server, ohne Client. Das Netz kommt außen herum, wie beim
Spielleiter im Zahlenraten.
Zwei Sichten auf ein Feld
Abschnitt betitelt „Zwei Sichten auf ein Feld“Jeder Spieler sieht zwei Felder: sein eigenes, mit seinen Schiffen und den Schüssen des Gegners darauf – und das Zielfeld des Gegners, auf dem er nur seine eigenen Schüsse und deren Ergebnisse sieht. Die Schiffe des Gegners kennt er nicht. Genau das macht das Spiel aus – und genau das muss das Programm schützen.
Was das Spiel über das Netz schwierig macht
Abschnitt betitelt „Was das Spiel über das Netz schwierig macht“Am Küchentisch regelt sich vieles von selbst. Über das Netz muss das Programm es regeln:
| Problem | Frage | mögliche Lösung |
|---|---|---|
| Geheimnis | Wer kennt die Flotten? | Ein Server als Schiedsrichter kennt beide. Jeder Spieler erfährt nur, was er wissen darf. |
| Schummeln | Was, wenn ein Programm „Wasser“ sagt, obwohl es ein Treffer war? | Der Server beurteilt die Schüsse – nicht die Spieler selbst. |
| Reihenfolge | Was, wenn beide gleichzeitig schießen? | Der Server weiß, wer dran ist, und lehnt alles andere ab. |
| Warten | Woher weiß Anna, dass Ben geschossen hat? | Bei HTTP fragt immer der Client. Also fragt Annas Programm regelmäßig nach: Bin ich dran? (Polling) |
| Wer bin ich? | Wie erkennt der Server, ob eine Anfrage von Anna kommt – und nicht von Ben, der sich als Anna ausgibt? | Beim Beitreten bekommt jeder ein geheimes Token, das er bei jeder Anfrage mitschickt. |
| Phasen | Darf man schießen, bevor der Gegner aufgestellt hat? | Das Spiel kennt Phasen: warten auf Spieler 2, aufstellen, läuft, vorbei. Jede Anfrage passt nur in bestimmte Phasen. |
| Gleichzeitigkeit | Der Server bekommt Anfragen von beiden Spielern zugleich. | Gemeinsame Daten schützen – siehe Parallelität. |
| Abbrüche | Was, wenn ein Spieler einfach verschwindet? | Fürs Erste: nichts. Aber gut, darüber nachgedacht zu haben. |
Client und Server
Abschnitt betitelt „Client und Server“ Anna (Client) Server Ben (Client) │ (Schiedsrichter) │ │ ─── Anfrage ──────────▶ │ │ │ ◀────────── Antwort ─── │ │ │ │ ◀──────── Anfrage ───── │ │ │ ─── Antwort ──────────▶ │- Ein Server ist ein Programm, das wartet, bis jemand etwas von ihm will.
Er lauscht an einem Port – einer Nummer, unter der er auf dem Rechner zu
erreichen ist, etwa
8080. - Ein Client ist ein Programm, das fragt. Er kennt die Adresse des Servers: den Rechner und den Port.
localhostist der eigene Rechner. Läuft der Server bei euch selbst, heißt seine Adressehttp://localhost:8080. Ein anderer Teilnehmer erreicht ihn über die IP-Adresse eures Rechners, etwahttp://192.168.1.23:8080.
Wichtig: Der Client fragt, der Server antwortet. Von sich aus meldet sich ein Server bei HTTP nie. Das ist der Grund für das Polling oben.
HTTP in fünf Minuten
Abschnitt betitelt „HTTP in fünf Minuten“HTTP ist das Protokoll des Webs – und ein gutes Protokoll für unser Spiel, weil Java Server und Client schon mitbringt. Eine Anfrage besteht aus:
POST /spiele/7f3a/schuesse HTTP/1.1 ← Methode, Pfad, VersionHost: localhost:8080 ← Kopfzeilen (Header)Content-Type: application/jsonX-Spieler: 9c41e2…
{"feld":"B7"} ← Rumpf (Body)und eine Antwort aus:
HTTP/1.1 200 OK ← StatuscodeContent-Type: application/json
{"ergebnis":"TREFFER"} ← Rumpf| Methode | Bedeutung | Beispiel |
|---|---|---|
GET |
etwas abfragen – ändert nichts | den Spielstand holen |
POST |
etwas Neues anlegen oder auslösen | ein Spiel anlegen, einen Schuss abgeben |
PUT |
etwas festlegen oder ersetzen | die Flotte aufstellen |
DELETE |
etwas entfernen | ein Spiel aufgeben |
| Status | heißt | für unser Spiel |
|---|---|---|
200 OK |
hat geklappt, Antwort im Rumpf | Schuss beantwortet |
201 Created |
etwas Neues ist entstanden | Spiel angelegt |
400 Bad Request |
die Anfrage ist falsch | Z99, Schiff außerhalb des Felds |
403 Forbidden |
nicht erlaubt | falsches Token |
404 Not Found |
gibt es nicht | unbekannte Spiel-ID |
409 Conflict |
passt gerade nicht | nicht dran, falsche Phase, Feld schon beschossen |
Ein Protokoll – ein Vorschlag
Abschnitt betitelt „Ein Protokoll – ein Vorschlag“Ein Protokoll ist ein Vertrag zwischen Client und Server: Wer das Protokoll einhält, kann mitspielen – egal, wer das Programm geschrieben hat. Deshalb wird es zuerst festgelegt und aufgeschrieben, und erst dann programmiert. Hier ein Vorschlag als Diskussionsgrundlage:
| Anfrage | Rumpf | Antwort | Fehler |
|---|---|---|---|
POST /spiele |
– | 201, Spiel-ID und Token für Spieler 1 |
– |
POST /spiele/{id}/spieler |
– | 201, Token für Spieler 2 |
404; 409, wenn schon zwei da sind |
PUT /spiele/{id}/flotte |
die fünf Schiffe | 204 (No Content) |
400 ungültige Aufstellung; 409 falsche Phase |
GET /spiele/{id} |
– | 200, der Stand aus eigener Sicht |
403; 404 |
POST /spiele/{id}/schuesse |
ein Kästchen | 200, Wasser, Treffer oder versenkt |
400 ungültiges Feld; 409 nicht dran oder schon beschossen |
Alle Anfragen nach dem Beitreten tragen das Token im Header X-Spieler.
So könnte der Stand aus Annas Sicht aussehen, als JSON:
{ "phase": "LAEUFT", "amZug": true, "eigeneSchuesse": { "B7": "TREFFER", "C7": "WASSER" }, "gegnerischeSchuesse": { "D4": "WASSER" }, "versenkteGegnerschiffe": []}Die Positionen von Bens Schiffen stehen nicht darin – nur, was Anna durch ihre Schüsse weiß.
Ein Spiel als Ablauf
Abschnitt betitelt „Ein Spiel als Ablauf“Anna Server Ben │ POST /spiele │ │ │ ─────────────────────────────▶ │ │ │ ◀── 201 {id: 7f3a, token: A…} │ │ │ │ POST /spiele/7f3a/spieler │ │ │ ◀────────────────────────────────── │ │ │ ──── 201 {token: B…} ─────────────▶ │ │ PUT /spiele/7f3a/flotte │ PUT /spiele/7f3a/flotte │ │ ─────────────────────────────▶ │ ◀────────────────────────────────── │ │ ◀── 204 │ ──── 204 ─────────────────────────▶ │ │ GET /spiele/7f3a (bin ich dran?) │ │ ◀── 200 {amZug: true} │ │ │ POST /spiele/7f3a/schuesse B7 │ │ │ ◀── 200 {ergebnis: TREFFER} │ GET /spiele/7f3a (bin ich dran?) │ │ │ ──── 200 {amZug: true, …} ────────▶ │ │ │ POST /spiele/7f3a/schuesse D4 │ │ │ ◀────────────────────────────────── │ │ … abwechselnd, bis eine Flotte versenkt ist │Fragen, die ihr festlegen müsst
Abschnitt betitelt „Fragen, die ihr festlegen müsst“Ein Protokoll ist erst fertig, wenn es keine offenen Fragen mehr gibt:
- Format: einfacher Text oder JSON? Text ist schneller gebaut. JSON lässt sich leichter erweitern – braucht aber eine Bibliothek wie Gson aus dem Kapitel Maven.
- Die Flotte im Rumpf: Wie beschreibt man ein Schiff? Typ, Anfangsfeld und
Richtung – etwa
KREUZER B2 WAAGERECHT? - Wer beginnt? Wer das Spiel angelegt hat? Ein Zufall?
- Versenkt: Erfährt der Schütze, welches Schiff versenkt wurde?
- Ende: Was liefert
GET, wenn das Spiel vorbei ist – und wer gewonnen hat? - Polling: Wie oft fragt ein Client nach? Einmal pro Sekunde reicht.
Schreibt die Antworten auf. Das Dokument ist euer Vertrag.
Zum Start: ein eigener Server
Abschnitt betitelt „Zum Start: ein eigener Server“Das Starter-Projekt enthält einen kleinen Server, der zwei Anfragen versteht – gebaut nur mit dem JDK:
package de.drv.schiffe;
import com.sun.net.httpserver.HttpExchange;import com.sun.net.httpserver.HttpServer;
import java.io.IOException;import java.io.InputStream;import java.io.OutputStream;import java.net.InetSocketAddress;import java.nio.charset.StandardCharsets;
/** * Ein kleiner HTTP-Server – nur mit dem JDK. Er versteht zwei Anfragen: * <ul> * <li>{@code GET /hallo} – antwortet mit einem Gruß</li> * <li>{@code POST /echo} – schickt den Rumpf der Anfrage zurück</li> * </ul> * Startpunkt für den eigenen Spiel-Server. */public class HalloServer {
public static void main(String[] args) throws IOException { HttpServer server = HttpServer.create(new InetSocketAddress(8080), 0); server.createContext("/hallo", HalloServer::hallo); server.createContext("/echo", HalloServer::echo); server.start(); System.out.println("Server läuft auf http://localhost:8080 – beenden mit dem roten Quadrat in IntelliJ"); }
/** GET /hallo */ static void hallo(HttpExchange anfrage) throws IOException { System.out.println(anfrage.getRequestMethod() + " " + anfrage.getRequestURI()); if (!anfrage.getRequestMethod().equals("GET")) { antworte(anfrage, 405, "Nur GET\n"); // 405: Method Not Allowed return; } antworte(anfrage, 200, "Hallo! Hier spricht der Server.\n"); }
/** POST /echo */ static void echo(HttpExchange anfrage) throws IOException { System.out.println(anfrage.getRequestMethod() + " " + anfrage.getRequestURI()); if (!anfrage.getRequestMethod().equals("POST")) { antworte(anfrage, 405, "Nur POST\n"); return; } String rumpf; try (InputStream ein = anfrage.getRequestBody()) { rumpf = new String(ein.readAllBytes(), StandardCharsets.UTF_8); } antworte(anfrage, 200, "Du hast geschickt: " + rumpf + "\n"); }
/** Schickt eine Text-Antwort mit Statuscode – und schließt die Anfrage ab. */ static void antworte(HttpExchange anfrage, int status, String text) throws IOException { byte[] bytes = text.getBytes(StandardCharsets.UTF_8); anfrage.getResponseHeaders().set("Content-Type", "text/plain; charset=utf-8"); anfrage.sendResponseHeaders(status, bytes.length); try (OutputStream aus = anfrage.getResponseBody()) { aus.write(bytes); } }
}HttpServer.create(new InetSocketAddress(8080), 0)legt einen Server auf Port 8080 an.createContext("/hallo", …)sagt: Anfragen auf diesen Pfad bearbeitet diese Methode. Übergeben wird sie als Methodenreferenz.- In jeder Methode steckt die Anfrage in einem
HttpExchange: Methode, Pfad, Header, Rumpf – und die Möglichkeit, zu antworten. antworteerledigt das Antworten: erst Statuscode und Länge mitsendResponseHeaders, dann der Rumpf – als Bytes in UTF-8, wie im Kapitel Ströme und Ressourcen.
-
Starte
HalloServerin IntelliJ. -
Öffne im Browser
http://localhost:8080/hallo. -
Probiere es im Terminal –
curl.exegehört zu Windows:PowerShell curl.exe -i http://localhost:8080/halloTerminal-Fenster HTTP/1.1 200 OKDate: Fri, 23 Oct 2026 08:35:59 GMTContent-type: text/plain; charset=utf-8Content-length: 32Hallo! Hier spricht der Server.Mit
-izeigtcurldie ganze Antwort – Statuszeile, Header und Rumpf. Genau wie oben beschrieben. -
Und eine Anfrage mit Rumpf:
PowerShell curl.exe -X POST -d "B7" http://localhost:8080/echoTerminal-Fenster Du hast geschickt: B7Eine falsche Methode (
curl.exe -i -X POST http://localhost:8080/hallo) liefert405 Method Not Allowed, ein unbekannter Pfad404 Not Found.
Das Gegenstück ist ein Client mit dem HttpClient aus dem Kapitel Ströme und
Ressourcen:
package de.drv.schiffe;
import java.io.IOException;import java.net.URI;import java.net.http.HttpClient;import java.net.http.HttpRequest;import java.net.http.HttpResponse;
/** Der Gegenpart zum HalloServer: schickt zwei Anfragen und zeigt die Antworten. */public class HalloClient {
public static void main(String[] args) throws IOException, InterruptedException { String server = args.length > 0 ? args[0] : "http://localhost:8080";
try (HttpClient client = HttpClient.newHttpClient()) { HttpRequest hallo = HttpRequest.newBuilder(URI.create(server + "/hallo")).GET().build(); HttpResponse<String> antwort = client.send(hallo, HttpResponse.BodyHandlers.ofString()); System.out.println(antwort.statusCode() + " " + antwort.body().strip());
HttpRequest echo = HttpRequest.newBuilder(URI.create(server + "/echo")) .POST(HttpRequest.BodyPublishers.ofString("B7")) .build(); antwort = client.send(echo, HttpResponse.BodyHandlers.ofString()); System.out.println(antwort.statusCode() + " " + antwort.body().strip()); } }
}200 Hallo! Hier spricht der Server.200 Du hast geschickt: B7Mit der Adresse eines anderen Rechners als Argument – etwa
http://192.168.1.23:8080 – spricht der Client mit dem Server eines anderen
Teilnehmers.
Wie ihr vorgehen könnt
Abschnitt betitelt „Wie ihr vorgehen könnt“- Das Protokoll festlegen. Gemeinsam, schriftlich, mit Beispielen für jede Anfrage und jede Antwort.
- Der Kern.
Koordinate,Schiffstyp,Schiff,Flotte,Spiel– ohne Netz, mit JUnit-Tests. Kann eineFlotteaufgestellt werden? Liefert ein Schuss das richtige Ergebnis? Wann ist alles versenkt? - Der Server. Er übersetzt HTTP in Aufrufe des Kerns – und die Ergebnisse
zurück in HTTP. Ausprobieren mit
curl.exe, noch ohne Client. - Der Client. Eine Konsole, die das Zielfeld und das eigene Feld zeichnet, nach dem nächsten Schuss fragt und zwischendurch den Stand abfragt.
- Zusammenspielen. Zuerst gegen den eigenen Server, dann Rechner gegen Rechner.
Arbeitsteilung: Weil das Protokoll ein Vertrag ist, kann eine Gruppe den Server bauen und eine andere den Client – gleichzeitig. Wenn beide sich an das Protokoll halten, passt am Ende alles zusammen. Genau so entsteht Software in echten Teams.