Zum Inhalt springen

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.

  • 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 HttpServer aus dem JDK einen eigenen Server starten

Demo-Code: 32-schiffe-start

⤓ schiffe-start.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 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

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:

  1. 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.
  2. 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.
  3. 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.

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.

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.

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.
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.
  • localhost ist der eigene Rechner. Läuft der Server bei euch selbst, heißt seine Adresse http://localhost:8080. Ein anderer Teilnehmer erreicht ihn über die IP-Adresse eures Rechners, etwa http://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 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, Version
Host: localhost:8080 ← Kopfzeilen (Header)
Content-Type: application/json
X-Spieler: 9c41e2…
{"feld":"B7"} ← Rumpf (Body)

und eine Antwort aus:

HTTP/1.1 200 OK ← Statuscode
Content-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 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ß.

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 │

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.

Das Starter-Projekt enthält einen kleinen Server, der zwei Anfragen versteht – gebaut nur mit dem JDK:

HalloServer.java
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.
  • antworte erledigt das Antworten: erst Statuscode und Länge mit sendResponseHeaders, dann der Rumpf – als Bytes in UTF-8, wie im Kapitel Ströme und Ressourcen.
  1. Starte HalloServer in IntelliJ.

  2. Öffne im Browser http://localhost:8080/hallo.

  3. Probiere es im Terminal – curl.exe gehört zu Windows:

    PowerShell
    curl.exe -i http://localhost:8080/hallo
    Terminal-Fenster
    HTTP/1.1 200 OK
    Date: Fri, 23 Oct 2026 08:35:59 GMT
    Content-type: text/plain; charset=utf-8
    Content-length: 32
    Hallo! Hier spricht der Server.

    Mit -i zeigt curl die ganze Antwort – Statuszeile, Header und Rumpf. Genau wie oben beschrieben.

  4. Und eine Anfrage mit Rumpf:

    PowerShell
    curl.exe -X POST -d "B7" http://localhost:8080/echo
    Terminal-Fenster
    Du hast geschickt: B7

    Eine falsche Methode (curl.exe -i -X POST http://localhost:8080/hallo) liefert 405 Method Not Allowed, ein unbekannter Pfad 404 Not Found.

Das Gegenstück ist ein Client mit dem HttpClient aus dem Kapitel Ströme und Ressourcen:

HalloClient.java
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());
}
}
}
Terminal-Fenster
200 Hallo! Hier spricht der Server.
200 Du hast geschickt: B7

Mit der Adresse eines anderen Rechners als Argument – etwa http://192.168.1.23:8080 – spricht der Client mit dem Server eines anderen Teilnehmers.

  1. Das Protokoll festlegen. Gemeinsam, schriftlich, mit Beispielen für jede Anfrage und jede Antwort.
  2. Der Kern. Koordinate, Schiffstyp, Schiff, Flotte, Spiel – ohne Netz, mit JUnit-Tests. Kann eine Flotte aufgestellt werden? Liefert ein Schuss das richtige Ergebnis? Wann ist alles versenkt?
  3. Der Server. Er übersetzt HTTP in Aufrufe des Kerns – und die Ergebnisse zurück in HTTP. Ausprobieren mit curl.exe, noch ohne Client.
  4. Der Client. Eine Konsole, die das Zielfeld und das eigene Feld zeichnet, nach dem nächsten Schuss fragt und zwischendurch den Stand abfragt.
  5. 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.