# TicTacToe Spiel programmieren



## ItundMathe1994 (1. Aug 2022)

Liebe Community

Ich habe vorhin euer Forum gefunden und mich sehr gefreut  Ich hoffe, dass mir vielleicht jemand von euch weiterhelfen kann, da ich gerade anscheinend ein Brett vor dem Kopf habe und mir die Aufgabe nicht vorstellen kann.

Hier mein aktueller Code:



```
import java.util.Scanner;

public class TicTacToe {
    static char [][] spielfeld = new char[3][3];
 
    public static void main(String[] args) {
    Scanner ks = new Scanner(System.in);
    System.out.println("Let's Play Tic Tac Toe");
    init();
    printSpielfeld();
    boolean spielerX  = true;
 
    for (int spielzug = 0; spielzug<9;spielzug++) {
        if (spielzug%2==0)  {
            System.out.print("SpielerIn "+getSymbol(spielerX)+": ");
            int position = ks.nextInt();
            System.out.println("Zeile: "+getZeile(position)+", Spalte: "+getSpalte(position));
            speichere(position, spielerX);
            printSpielfeld();
                    }
        else {
            System.out.print("SpielerIn "+getSymbol(!spielerX)+": ");
            int position = ks.nextInt();
            System.out.println("Zeile: "+getZeile(position)+", Spalte: "+getSpalte(position));
            speichere(position, spielerX);
            printSpielfeld();
        }
 
     
            char Zeile0                         = (char) ((spielfeld[0][0])+(spielfeld[0][1])+(spielfeld[0][2]));
            char Zeile1                         = (char) ((spielfeld[1][0])+(spielfeld[1][1])+(spielfeld[1][2]));
            char Zeile2                         = (char) ((spielfeld[2][0])+(spielfeld[2][1])+(spielfeld[2][2]));
            char Spalte0                         = (char) ((spielfeld[0][0])+(spielfeld[1][0])+(spielfeld[2][0]));
            char Spalte1                         = (char) ((spielfeld[0][1])+(spielfeld[0][1])+(spielfeld[0][1]));
            char Spalte2                         = (char) ((spielfeld[0][2])+(spielfeld[1][2])+(spielfeld[2][2]));
            char Diagonaleuntenlinksobenrechts     = (char) ((spielfeld[2][0])+(spielfeld[1][1])+(spielfeld[0][2]));
            char Diagonaleobenlinksuntenrechts     = (char) ((spielfeld[0][0])+(spielfeld[1][1])+(spielfeld[2][2]));

     
     
             
        if (Zeile0 == 'X'+'X'+'X'|| Zeile1 == 'X'+'X'+'X' || Zeile2 == 'X'+'X'+'X' || Spalte0 == 'X'+'X'+'X' || Spalte1 == 'X'+'X'+'X'|| Spalte2 == 'X'+'X'+'X'|| Diagonaleuntenlinksobenrechts == 'X'+'X'+'X' || Diagonaleobenlinksuntenrechts == 'X'+'X'+'X') {
            System.out.println("SpielerX gewinnt!");}
        else if (Zeile0 == 'O'+'O'+'O'|| Zeile1 == 'O'+'O'+'O' || Zeile2 == 'O'+'O'+'O' || Spalte0 == 'O'+'O'+'O' || Spalte1 == 'O'+'O'+'O'|| Spalte2 == 'O'+'O'+'O'|| Diagonaleuntenlinksobenrechts == 'O'+'O'+'O'|| Diagonaleobenlinksuntenrechts == 'O'+'O'+'O') {
            System.out.println("SpielerO gewinnt!");}
        else if (spielzug == 8){
            System.out.println("Untentschieden!");
        }
     
     
    }
 
    ks.close();
    }
 
 
    static void init() {
    for (int a = 0; a<3; a++) {
        for (int b = 0; b<3; b++) {
            spielfeld[a][b] = '.';
            }
        }
    }
 
static void speichere(int position, boolean spielerX) {

//Hier müsste noch eine Speicherfunktion gem. letzter Aufgabenstellung implementiert werden. Kann ich mir jedoch leider sehr schlecht vorstellen wie das klappen sollte. Evtl. könnt ihr mir kurz Schritt für Schritt erklären wie ich das gem. Aufgabe lösen kann.
     
    }
 

    static int getZeile(int position) {
        if (position  == 1) {
            return 0;}
        else if (position  == 2) {
            return 0;}
        else if (position  == 3) {
            return 0;}
        else if (position  == 4) {
            return 1;}
        else if (position  == 5) {
            return 1;}
        else if (position  == 6) {
            return 1;}
        else if (position  == 7) {
            return 2;}
        else if (position  == 8) {
            return 2;}
        else if (position  == 9) {
            return 2;}
        return position;    
        }
 
    static int getSpalte(int position) {
        if (position  == 1) {
            return 0;}
        else if (position  == 2) {
            return 1;}
        else if (position  == 3) {
            return 2;}
        else if (position  == 4) {
            return 0;}
        else if (position  == 5) {
            return 1;}
        else if (position  == 6) {
            return 2;}
        else if (position  == 7) {
            return 0;}
        else if (position  == 8) {
            return 1;}
        else if (position  == 9) {
            return 2;}
        return position;
        }

 
    static char getSymbol(boolean spielerX) {
     
        if (spielerX) {
            return 'X';}
        else {
            return 'O';}
                }
     

    static void printSpielfeld() {
        for (int i=0; i<3; i++) {
            for (int j=0; j<3; j++) {
                System.out.print(spielfeld[i][j]+" ");
            }
            System.out.println("");}
     
    }

 
}
```

*Hier die letzte Aufgabenstellung (siehe Zeile 67 im Code):*


-> >Von der Logik her muss ich bei dem 2D Array folgendes implementieren:

 spielfeld [get zeile position][get spalte position] = get Symbol;

Bei der Umsetzung dieser Lösung happert es aber irgendwie gerade und zerbreche mir wirklich enorm den Kopf .....
Für eine Rückmeldung und mögliche Erklärung wäre ich euch sehr dankbar.

LG
Alex


----------



## Blender3D (1. Aug 2022)

ItundMathe1994 hat gesagt.:


> Ich hoffe, dass mir vielleicht jemand von euch weiterhelfen kann, da ich gerade anscheinend ein Brett vor dem Kopf habe und mir die Aufgabe nicht vorstellen kann.


Du brauchts lediglich im Spielfeld [y][x]  den Spieler setzen. x, y lässt sich aus aus dem eingegeben wert 1-9 berechnen. 
Wert = y*3 + x
also y=2, x = 1 --> Eingabe war 7.

Hier eine fertige Variante des Spieles zum Probieren.

```
import java.util.Random;
import java.util.Scanner;

public class TicTakToe {
    // define random object
    private static Random random = new Random(System.currentTimeMillis());
    // define input object
    private final static Scanner input = new Scanner(System.in);
    // define board's dimension
    private final static int BOARD_DIM = 3;
    // create public char array board with 3 x 3 positions
    public static char board[] = new char[BOARD_DIM * BOARD_DIM];
    // define board's used characters
    private final static char PLAYER = 'x';
    private final static char CPU = 'o';
    private final static char EMPTY = ' ';
    private final static int NOT_FOUND = -1;
    private static int level = 1;

    public static void main(String[] args) {
        resetBoard();
        level = inputNumber("TicTacToe\nKI-Staerke waehlen [1-3]", 1, 3);
        char player = getBeginner();
        if (PLAYER == player)
            printBoard();
        while (!isBoardFull()) {
            if (doMove(player))
                break;
            player = getNextPlayer(player);
        }
        System.out.println("ENDE");
    }

    private static char getBeginner() {
        int coin = random.nextInt(2);
        return coin == 0 ? PLAYER : CPU;
    }

    private static char getNextPlayer(char player) {
        if (player == PLAYER)
            return CPU;
        return PLAYER;
    }

    private static boolean doMove(char player) {
        int pos = 0;
        if (player == PLAYER) {
            pos = getPlayerMove("An welcher Stelle wollen Sie setzen (0 - 8)?");
            System.out.println("Sie haben Position " + pos + " gewÃ¤hlt!");
        } else { // CPU
            pos = getCpuMove();
            System.out.println("CPU waehlt Position " + pos + "!");
        }
        board[pos] = player;
        printBoard();
        return isOver(player);
    }

    private static int getCpuMove() {
        if (isBoardFull())
            throw new IllegalAccessError("Board is full you can't get CPU's move!");

        int pos = getFinishMove(CPU);
        if (pos != NOT_FOUND)
            return pos;
        if (level > 1) {
            pos = getFinishMove(PLAYER);
            if (pos != NOT_FOUND)
                return pos;
        }
        if (level == 3) {
            if (board[4] == EMPTY)
                return 4;
        }
        do { // creating random number in between 0 - 8
            pos = random.nextInt(BOARD_DIM * BOARD_DIM);
        } while (board[pos] != EMPTY); // check's if random position isn't occupied
        return pos;
    }

    private static int getFinishMove(char player) {
        for (int i = 0; i < board.length; i++) {
            if (board[i] == EMPTY) {
                board[i] = player;
                boolean ok = isWin(player);
                board[i] = EMPTY;
                if (ok)
                    return i;
            }
        }
        return NOT_FOUND;
    }

    private static int getPlayerMove(String label) { // reads number 0-8 from the console.
        int pos = -1;
        do {
            pos = inputNumber(label, 0, 8);
            if (board[pos] != EMPTY)
                System.out.println("Ungueltige Eingabe! Ihre gewaehlte Position ist bereits besetzt!");
        } while (board[pos] != EMPTY);// new input if Position is already used
        return pos;
    }

    private static int inputNumber(String label, int min, int max) {
        int number = 0;
        boolean ok = false;
        do {
            try {
                System.out.print(label + ": ");
                number = Integer.parseInt(input.next());
                if (number < min || number > max)
                    System.err.println("Bitte nur Zahlen von " + min + "-" + max + " eingeben!");
                else
                    ok = true;
            } catch (NumberFormatException e) {
                System.err.println("Bitte nur ganze Zahlen eingeben!");
            }
        } while (!ok);
        return number;
    }

    private static boolean isBoardFull() {
        for (Character c : board) {
            if (c.equals(EMPTY))
                return false;
        }
        return true;
    }

    private static boolean isColumnWin(int col, char player) {
        for (int pos = 0; pos < BOARD_DIM; pos++) {
            if (board[pos * BOARD_DIM + col] != player)
                return false;
        }
        return true;
    }

    private static boolean isDiagonalWin(char player) {
        if (board[4] != player)
            return false;
        return (board[0] == player && board[8] == player) || (board[2] == player && board[6] == player);
    }

    private static boolean isOver(char player) {
        if (isWin(player)) { // checks for current player's win
            System.out.println((player == CPU ? "CPU" : "Spieler") + " hat gewonnen!");
            return true;
        }
        if (isBoardFull()) {
            System.out.println("Unetschieden!!");
            return true;
        }
        return false;
    }

    private static boolean isRowWin(int row, char player) {
        for (int pos = 0; pos < BOARD_DIM; pos++) {
            if (board[row * BOARD_DIM + pos] != player)
                return false;
        }
        return true;
    }

    private static boolean isWin(char player) {
        for (int pos = 0; pos < BOARD_DIM; pos++) {
            if (isColumnWin(pos, player))
                return true;
            if (isRowWin(pos, player))
                return true;
        }
        return isDiagonalWin(player);
    }

    public static void printBoard() {
        for (int y = 0; y < BOARD_DIM; y++) {
            int lineStart = y * BOARD_DIM;
            System.out.print(lineStart + "-" + (lineStart + 2) + " >> [");
            for (int x = 0; x < BOARD_DIM; x++)
                System.out.print(board[lineStart + x]);
            System.out.println("]");
        }
    }

    public static void resetBoard() { // initiating and declaring board values as own method
        for (int i = 0; i < board.length; i++)
            board[i] = EMPTY;
    }
}
```


----------

