Zum Inhalt springen

Wordle 4: Das Spiel als Objekt

In Teil 3 steckt das ganze Spiel in main: ein Zähler für die Versuche, ein boolean für „gelöst“, das gesuchte Wort als Konstante, die Muster als Texte aus +, ? und -. Mit dem, was du über eigene Klassen gelernt hast, bauen wir daraus jetzt Objekte – genau nach dem Entwurf aus der Übung im Kapitel Denken in Objekten.

  • einen vorgegebenen Entwurf in Enums, einen Record und eine Klasse umsetzen
  • eine Klasse ihre Spielregeln selbst durchsetzen lassen
  • mit vorgegebenen Tests prüfen, ob die Umsetzung stimmt
  • die Konsole so umbauen, dass sie nur noch das Spiel benutzt

Ausgangsstand für wordle

⤓ wordle-4.zip herunterladen

Wer die letzte Stufe nicht fertig hat, startet hiermit: Rechtsklick auf das Projektwordle → Import… → General → Archive File → die ZIP-Datei wählen →Finish. Vorhandene Dateien werden dabei – nach Rückfrage – überschrieben.

Enthält: Wordle.java, WordleKonsole.java, WordleTest.java

Vier neue Typen im Package de.drv.wordle:

Typ Art Aufgabe
Feld Enum die Bewertung eines Buchstabens: Treffer, kommt vor, fehlt
Status Enum läuft, gewonnen oder verloren
Bewertung Record ein Versuch und sein Muster
Spiel Klasse kennt die Lösung, zählt die Versuche, entscheidet über Sieg und Niederlage

Die Funktion Wordle.bewerte aus Teil 1 und 2 bleibt, wie sie ist – mit allen zwölf Tests. Das Spiel benutzt sie.

public enum Feld {
TREFFER('+'), ENTHALTEN('?'), FEHLT('-');
public char getZeichen() // das Zeichen im Muster
public static Feld vonZeichen(char zeichen) // das Feld zu einem Zeichen
}

Ein unbekanntes Zeichen bei vonZeichen führt zu einer IllegalArgumentException.

public enum Status {
LAEUFT, GEWONNEN, VERLOREN
}
public record Bewertung(String versuch, String muster) {
public Feld feld(int position) // das Feld an dieser Position
public boolean istGeloest() // true, wenn das Muster nur aus '+' besteht
}

Sind Versuch und Muster nicht gleich lang, lehnt der kompakte Konstruktor die Bewertung mit einer IllegalArgumentException ab.

public class Spiel {
public static final int WORTLAENGE = 5;
public static final int MAX_VERSUCHE = 6;
public Spiel(String loesung)
public Bewertung rate(String versuch)
public Status getStatus()
public int getAnzahlVersuche()
public String getAufloesung()
}

Die Regeln:

  1. Ein neues Spiel läuft und hat 0 Versuche. Eine Lösung, die nicht genau 5 Buchstaben hat, wird mit einer IllegalArgumentException abgelehnt.
  2. rate bewertet den Versuch mit Wordle.bewerte, zählt ihn und liefert die Bewertung.
  3. Ist der Versuch gelöst, ist das Spiel gewonnen. Ist es der sechste Versuch und nicht gelöst, ist es verloren.
  4. rate nach Spielende löst eine IllegalStateException aus.
  5. getAufloesung() verrät die Lösung erst nach Spielende – vorher gibt es eine IllegalStateException.

Für die neuen Typen gibt es fertige Tests. Lege sie im Ordner test an – sie werden zunächst nicht einmal übersetzen, weil es die Klassen noch nicht gibt. Deine Aufgabe: Schreibe Feld, Status, Bewertung und Spiel so, dass alle Tests grün werden – die neuen und die zwölf alten.

BewertungTest.java
BewertungTest.java
package de.drv.wordle;
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 org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
class BewertungTest {
@Test
@DisplayName("Jedes Feld hat sein Zeichen – und umgekehrt")
void feldUndZeichen() {
assertEquals('+', Feld.TREFFER.getZeichen());
assertEquals('?', Feld.ENTHALTEN.getZeichen());
assertEquals('-', Feld.FEHLT.getZeichen());
assertEquals(Feld.TREFFER, Feld.vonZeichen('+'));
assertEquals(Feld.ENTHALTEN, Feld.vonZeichen('?'));
assertEquals(Feld.FEHLT, Feld.vonZeichen('-'));
}
@Test
@DisplayName("Ein unbekanntes Zeichen ist kein Feld")
void unbekanntesZeichen() {
assertThrows(IllegalArgumentException.class, () -> Feld.vonZeichen('x'));
}
@Test
@DisplayName("Die Felder einer Bewertung")
void felder() {
Bewertung bewertung = new Bewertung("ADIEU", "---+?");
assertEquals(Feld.FEHLT, bewertung.feld(0));
assertEquals(Feld.TREFFER, bewertung.feld(3));
assertEquals(Feld.ENTHALTEN, bewertung.feld(4));
}
@Test
@DisplayName("Gelöst nur, wenn alle Felder Treffer sind")
void geloest() {
assertTrue(new Bewertung("FEUER", "+++++").istGeloest());
assertFalse(new Bewertung("FEUER", "++++?").istGeloest());
}
@Test
@DisplayName("Gleiche Bewertungen sind gleich")
void gleichheit() {
assertEquals(new Bewertung("ADIEU", "---+?"), new Bewertung("ADIEU", "---+?"));
}
@Test
@DisplayName("Versuch und Muster müssen gleich lang sein")
void ungleicheLaenge() {
assertThrows(IllegalArgumentException.class, () -> new Bewertung("ADIEU", "---"));
}
}
SpielTest.java
SpielTest.java
package de.drv.wordle;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
class SpielTest {
@Test
@DisplayName("Ein neues Spiel läuft und hat noch keine Versuche")
void neuesSpiel() {
Spiel spiel = new Spiel("FEUER");
assertEquals(Status.LAEUFT, spiel.getStatus());
assertEquals(0, spiel.getAnzahlVersuche());
}
@Test
@DisplayName("Ein Versuch liefert seine Bewertung und wird gezählt")
void versuch() {
Spiel spiel = new Spiel("FEUER");
assertEquals(new Bewertung("ADIEU", "---+?"), spiel.rate("ADIEU"));
assertEquals(1, spiel.getAnzahlVersuche());
assertEquals(Status.LAEUFT, spiel.getStatus());
}
@Test
@DisplayName("Wer das Wort errät, gewinnt")
void gewonnen() {
Spiel spiel = new Spiel("FEUER");
spiel.rate("ADIEU");
spiel.rate("FEUER");
assertEquals(Status.GEWONNEN, spiel.getStatus());
assertEquals(2, spiel.getAnzahlVersuche());
}
@Test
@DisplayName("Nach sechs Fehlversuchen ist das Spiel verloren")
void verloren() {
Spiel spiel = new Spiel("FEUER");
for (int i = 0; i < Spiel.MAX_VERSUCHE; i++) {
spiel.rate("ADIEU");
}
assertEquals(Status.VERLOREN, spiel.getStatus());
}
@Test
@DisplayName("Ein Treffer im letzten Versuch gewinnt noch")
void gewonnenImLetztenVersuch() {
Spiel spiel = new Spiel("FEUER");
for (int i = 0; i < Spiel.MAX_VERSUCHE - 1; i++) {
spiel.rate("ADIEU");
}
spiel.rate("FEUER");
assertEquals(Status.GEWONNEN, spiel.getStatus());
}
@Test
@DisplayName("Nach Spielende kann nicht weiter geraten werden")
void keinVersuchNachSpielende() {
Spiel spiel = new Spiel("FEUER");
spiel.rate("FEUER");
assertThrows(IllegalStateException.class, () -> spiel.rate("ADIEU"));
assertEquals(1, spiel.getAnzahlVersuche());
}
@Test
@DisplayName("Die Lösung wird erst nach Spielende verraten")
void aufloesung() {
Spiel spiel = new Spiel("FEUER");
assertThrows(IllegalStateException.class, () -> spiel.getAufloesung());
for (int i = 0; i < Spiel.MAX_VERSUCHE; i++) {
spiel.rate("ADIEU");
}
assertEquals("FEUER", spiel.getAufloesung());
}
@Test
@DisplayName("Eine Lösung mit falscher Länge wird abgelehnt")
void falscheLoesung() {
assertThrows(IllegalArgumentException.class, () -> new Spiel("HALLOO"));
}
}
Wie findet vonZeichen das passende Feld?

values() liefert alle Felder. Durchlaufe sie und gib das zurück, dessen Zeichen passt. Findet die Schleife keins, ist das Zeichen ungültig.

Gewonnen oder verloren – in welcher Reihenfolge prüfen?

Erst auf gewonnen prüfen, dann auf verloren. Sonst wird ein Treffer im sechsten Versuch als Niederlage gewertet. Der Test „Ein Treffer im letzten Versuch gewinnt noch“ achtet genau darauf.

Welche Felder braucht das Spiel?

Die Lösung (final), die Anzahl der Versuche und den Status. Die einzelnen Bewertungen muss sich das Spiel nicht merken – die bekommt der Aufrufer von rate zurück.

Lösung
Feld.java
package de.drv.wordle;
public enum Feld {
TREFFER('+'), ENTHALTEN('?'), FEHLT('-');
private final char zeichen;
Feld(char zeichen) {
this.zeichen = zeichen;
}
public char getZeichen() {
return zeichen;
}
public static Feld vonZeichen(char zeichen) {
for (Feld feld : values()) {
if (feld.zeichen == zeichen) {
return feld;
}
}
throw new IllegalArgumentException("Unbekanntes Zeichen im Muster: " + zeichen);
}
}
Lösung
Bewertung.java
package de.drv.wordle;
public record Bewertung(String versuch, String muster) {
public Bewertung {
if (versuch == null || muster == null || versuch.length() != muster.length()) {
throw new IllegalArgumentException("Versuch und Muster müssen gleich lang sein.");
}
}
public Feld feld(int position) {
return Feld.vonZeichen(muster.charAt(position));
}
public boolean istGeloest() {
return muster.equals("+".repeat(muster.length()));
}
}
Lösung

rate prüft zuerst, ob das Spiel noch läuft – erst prüfen, dann verändern, wie beim Konto. Der Zähler wird nur erhöht, wenn der Versuch wirklich bewertet wurde.

Spiel.java
package de.drv.wordle;
public class Spiel {
public static final int WORTLAENGE = 5;
public static final int MAX_VERSUCHE = 6;
private final String loesung;
private int anzahlVersuche;
private Status status;
public Spiel(String loesung) {
if (loesung == null || loesung.length() != WORTLAENGE) {
throw new IllegalArgumentException("Die Lösung muss " + WORTLAENGE + " Buchstaben haben.");
}
this.loesung = loesung.toUpperCase();
this.anzahlVersuche = 0;
this.status = Status.LAEUFT;
}
public Bewertung rate(String versuch) {
if (status != Status.LAEUFT) {
throw new IllegalStateException("Das Spiel ist bereits vorbei.");
}
Bewertung bewertung = new Bewertung(versuch, Wordle.bewerte(versuch, loesung));
anzahlVersuche++;
if (bewertung.istGeloest()) {
status = Status.GEWONNEN;
} else if (anzahlVersuche == MAX_VERSUCHE) {
status = Status.VERLOREN;
}
return bewertung;
}
public Status getStatus() {
return status;
}
public int getAnzahlVersuche() {
return anzahlVersuche;
}
public String getAufloesung() {
if (status == Status.LAEUFT) {
throw new IllegalStateException("Die Lösung wird erst nach Spielende verraten.");
}
return loesung;
}
}

Die Konsole aus Teil 3 rechnet noch selbst mit Zähler und boolean. Baue sie so um, dass sie nur noch das Spiel benutzt:

  • Die Schleife läuft, solange spiel.getStatus() == Status.LAEUFT.
  • Nach dem Spiel entscheidet ein switch über den Status, welche Meldung erscheint.
  • Die farbige Ausgabe aus Teil 3 wählt die Farbe jetzt mit einem switch über bewertung.feld(i) – ohne default.
Lösung

Vergleiche die beiden switch-Ausdrücke mit der Fassung aus Teil 3: Dort stand default -> GRAU, weil der Compiler nicht wissen konnte, welche Zeichen im Muster vorkommen. Über ein Enum weiß er es – und meldet sich, falls je ein viertes Feld dazukommt.

Auch die Konstanten WORTLAENGE und MAX_VERSUCHE kommen jetzt aus Spiel statt aus der Konsole: Die Regeln gehören zum Spiel, nicht zur Anzeige.

WordleKonsole.java
package de.drv.wordle;
import java.util.Scanner;
public class WordleKonsole {
private static final String GRUEN = "\u001B[30;42m";
private static final String GELB = "\u001B[30;43m";
private static final String GRAU = "\u001B[30;47m";
private static final String ZURUECK = "\u001B[0m";
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
Spiel spiel = new Spiel("FEUER");
System.out.println("WORDLE – errate das Wort mit " + Spiel.WORTLAENGE + " Buchstaben.");
System.out.println();
while (spiel.getStatus() == Status.LAEUFT) {
System.out.print("Versuch " + (spiel.getAnzahlVersuche() + 1) + "/" + Spiel.MAX_VERSUCHE + ": ");
String eingabe = scanner.nextLine().strip().toUpperCase();
if (eingabe.length() != Spiel.WORTLAENGE) {
System.out.println("Bitte genau " + Spiel.WORTLAENGE + " Buchstaben eingeben.");
} else {
Bewertung bewertung = spiel.rate(eingabe);
System.out.println(" " + farbig(bewertung));
}
}
System.out.println();
String meldung = switch (spiel.getStatus()) {
case GEWONNEN -> "Gelöst mit " + spiel.getAnzahlVersuche() + " Versuch(en)!";
case VERLOREN -> "Leider nicht geschafft. Gesucht war: " + spiel.getAufloesung();
case LAEUFT -> "Das Spiel läuft noch.";
};
System.out.println(meldung);
scanner.close();
}
public static String farbig(Bewertung bewertung) {
StringBuilder ergebnis = new StringBuilder();
for (int i = 0; i < bewertung.versuch().length(); i++) {
String farbe = switch (bewertung.feld(i)) {
case TREFFER -> GRUEN;
case ENTHALTEN -> GELB;
case FEHLT -> GRAU;
};
ergebnis.append(farbe).append(' ').append(bewertung.versuch().charAt(i)).append(' ').append(ZURUECK);
}
return ergebnis.toString();
}
}
  1. Ergänze das Spiel um eine Methode getVerbleibendeVersuche() und zeige in der Konsole „noch 4 Versuche“ an. Schreibe zuerst einen Test.

    Lösung
    public int getVerbleibendeVersuche() {
    return MAX_VERSUCHE - anzahlVersuche;
    }

    Eine neue Methode hinzuzufügen ändert nichts an dem, was es schon gibt – alle bisherigen Tests und die Konsole funktionieren unverändert weiter.

  2. Verlauf: Merke dir in der Konsole alle Bewertungen in einem Array Bewertung[] und gib nach jedem Versuch den ganzen Verlauf farbig aus.

  3. Versuche, in der Konsole während des Spiels spiel.getAufloesung() auszugeben. Was passiert? Und wo steht das gesuchte Wort trotzdem noch im Klartext?

    Lösung

    Während das Spiel läuft, bricht getAufloesung() mit einer IllegalStateException ab. Im Klartext steht das Wort aber immer noch in der Konsole: new Spiel("FEUER"). Wer den Quelltext – oder die übersetzte .class-Datei – hat, kann es lesen. Wie man das ändert, ist eine Frage für später.