Aufgabe auswerten

Bevor man beginnt sich den Kopf zu zerbrechen, wie man am besten ein 4-Gewinnt-Spiel umsetzen könnte, sollte man einen Blick in die Aufgabenstellung werfen. Wenn man alle Informationen der Aufgabe auswertet, kann man damit auch schon das Grundgerüst unseres Vier-Gewinnt-Spiels aufbauen:

/* viergewinnt.java */
public class viergewinnt {
    private final static int ROEHREN = 9;
    private final static int HOEHE = 8;
    private static char[][] spielfeld = new char [ROEHREN][HOEHE];
    private static char spieler;

    public static void main(String[] args){
        //...Main-Methode
    }
    
    public static void zeichenSpielFeld(char[][] spielfeld){
        //...Hier soll das aktuelle Spielfeld ausgegeben werden
    }
    
    public static boolean einwerfen(char[][] spielfeld, int roehre){
        boolean ret = false;
        //...Soll true zurückgeben, wenn man einen Stein in die Röhre werfen kann 
        return ret;
    }
    
    public static boolean neuesSpiel() throws IOException{
        boolean ret = false;
        //...Soll true zurückgeben, wenn ein weiteres Spiel erwünscht wird
        return ret;
    }
    
    public static int readNextZug(char spieler){
        int ret=-1;
        //...Soll eine Zahl zurückgeben die die gewählte Röhre repräsentiert
        return ret;
    }
}

zeichenSpielFeld

Die Methode zeichenSpielfeld soll als Übergabeparameter das Spielfeld (char[][]) bekommen und uns dann dieses Spielfeld in die Konsole "zeichnen". Da dieses Spielfeld zweidimensional ist werden wir zur Ausgabe auch zwei Schleifen benötigen:

        // Spielmatrix
        int y = HOEHE;
        do {
            y--;
            System.out.print("|");
            for(int x = 0; x < ROEHREN; x++){
                System.out.print(" "+ spielfeld[x][y] +" |");
            }
            System.out.println();
        } while(y > 0);

Dass wir die Höhe umgedreht haben, hat den Hintergrund, dass das erste Element eines Arrays ja auf die Position 0 kommt - Diese Position 0 würde bei einer Ausgabe zuerst und damit ganz oben ausgegeben werden - da wir aber wollen, dass man das Spielfeld von unten nach oben "bestücken" kann, wird einfach die Schleife bei der Ausgabe einfach umgedreht ;)

Für die Vollständige Ausgabe fehlen nur noch eine Trennlinie (=> "+===+===" etc) zwischen der Spielmatrix und der Legende (=> "| A | B |" etc.)

initSpielfeld

Dass unsere Ausgabe (richtig) funktioniert, müssen wir zu Beginn des Spiels eine Methode aufrufen, die dem Array spielfeld an jeder Position einen Wert (EMPTY) übergibt:

    public static void initSpielFeld(char[][] spielfeld){
        char EMPTY = ' ';
        for(int y = 0; y < HOEHE; y++){
            for(int x = 0; x < ROEHREN; x++){
                spielfeld[x][y] = EMPTY;
            }
        }
        
        zeichenSpielFeld(spielfeld);
    }

Anschließend wird gleich das leere Spielfeld durch unsere zeichenSpielFeld-Methode gezeichnet.

einwerfen

Die Methode einwerfen mit den Übergabeparametern char[][] (= das Spielfeld) und int (= die Röhre) soll einen Boolean-Wert (true / false) zurückliefern - je nachdem, ob in der übergebenen Röhre noch platz für einen "Stein" ist. Wenn noch Platz ist soll dieser Stein dann auch in dieses Feld gesetzt werden.

        boolean ret = false;
        if(roehre >= 0 && roehre < ROEHREN){
            for(int y = 0; y < HOEHE; y++){
                if(spielfeld[roehre][y] == EMPTY){
                    ret = true;
                    spielfeld[roehre][y] = spieler;
                    break;
                } else {
                    ret = false;
                }
            }
        }
        return ret;

Wir durchlaufen hier die Höhe der gewünschten Röhre und suchen nach dem ersten Element, das dem Wert EMPTY entspricht (= unser init-Wert für alle Felder des Spielfeldes) Wenn ein solches Element gefunden wurde wird ret auf true gesetzt und EMPTY durch das Zeichen des aktuellen Spielers ersetzt.

Wenn man diese Methode effektiver programmieren möchte, kann man sich einfach den letzten "Füllstand" der Röhren merken, so dass man nicht immer die Höhe bis zu einem "leeren" Feld durchlaufen muss ;)

readNextZug

Die Methode readNextZug soll die Eingabe einlesen und bei dem Zeichen 'A' eine 0 zurückgeben, bei 'B' eine 1, etc. Diese Vorgehensweise ist uns ja schon aus den etlichen Aufgaben mit einem "Einlesevorgang" bekannt.

        int ret=-1;
        System.out.println("Spieler "+spieler+" - Röhre angeben: ");
        while(true){
            input = System.in.read();
            if(input >= 'A' && input < (ROEHREN + 'A')){
                ret = input - 'A';
            } else if (input == '\n'){
                break;
            } else if (input == '\r'){
                // Ignore
            } else {
                System.out.println("Ungültige Eingabe!");
            }
        }
        return ret;

Das Zeichen '\r' wird hier ignoriert um unerwünschte Ausgaben zu vermeiden. (Stichwort: Unix-basierende OS vs. Windows)

main

In der Main-Methode soll die Spiel-Schleife laufen, also

            int roehre;
            while(true){
                do{
                    roehre = readNextZug(spieler);
                } while (!einwerfen(spielfeld, roehre));
                zeichenSpielFeld(spielfeld);
                toggleSpieler();
            }

Die Methode toggleSpieler() soll der Variablen spieler abwechselnd die Werte 'x' oder 'o' zuweisen, also einen Spielerwechsel darstellen.

Es fehlt noch die Methode neuesSpiel, die nach einem gewonnenen oder unentschiedenen Spiel aufgerufen wird. Diese zu schreiben und das Programm so umzuschreiben/ergänzen, dass diese auch richtig arbeitet überlasse ich jetzt euch und wünsche viel Spaß beim tüfteln =)