Überprüfen Sie für Winner Tic Tac Toe Spiel Java

Question

Problem wurde noch nicht gelöst, musste aber abgebaut werden.

Answer 1

Du bist gerade nicht, wenn der „Computer“ gewonnen, wenn der Computer nur knapp sein Ziel hat, und Spieler entweder, dann können Sie die tieGame Flagge wahr

Answer 2

Das Problem ist dieser Ausdruck in der if-Anweisung drehen:

GameBoard[0][0] == player && GameBoard[0][1] == player && GameBoard[0][2] == player && 
        GameBoard[1][0] == player && GameBoard[1][1] == player && GameBoard[1][2] == player && 
        GameBoard[2][0] == player && GameBoard[2][1] == player && GameBoard[2][2] == player 

Sie überprüfen, ob der Spieler in jeder Brettposition ist.

Sie möchten feststellen, dass es keinen Gewinner gab. Das bedeutet, dass keine der Zeilen, Spalten und Diagonalen den gleichen Spieler hat.

Answer 3

Ändern Sie zu GameBoard[0][0] != 0 für alle 9 Bedingungen.

Answer 4

Der Fehler ist im Hauptcode/Struktur der Funktion. Deine Funktion muss zwei Variablen zurückgeben, Finalwinner und Tie-Spiel. Im Moment stoppt Ihre Funktion bei der ersten return-Anweisung und setzt diese im Prinzip auf finalwinner.

versuchen, etwas wie folgt aus:

public static boolean[] CheckForWinner(int player) 
     { 
      //Row and Column Check 
      if (GameBoard[0][0] == player && GameBoard[0][1] == player && GameBoard[0][2] == player || 
       GameBoard[1][0] == player && GameBoard[1][1] == player && GameBoard[1][2] == player || 
       GameBoard[2][0] == player && GameBoard[2][1] == player && GameBoard[2][2] == player || 
       GameBoard[0][0] == player && GameBoard[1][0] == player && GameBoard[2][0] == player || 
       GameBoard[0][1] == player && GameBoard[1][1] == player && GameBoard[2][1] == player || 
       GameBoard[0][2] == player && GameBoard[1][2] == player && GameBoard[2][2] == player) 
       { 
        boolean finalwinner=true; 
       } 

      //diagonal checks 
      if (GameBoard[0][0]==player && GameBoard[1][1]==player && GameBoard[2][2]==player) 
      { 
       boolean finalwinner=true; 
      } 

      if (GameBoard[2][0]==player && GameBoard[1][1]==player && GameBoard[0][2]==player) 
      { 
       boolean finalwinner=true; 
      } 

      //Tie Game Check 
      if (GameBoard[0][0] == player && GameBoard[0][1] == player && GameBoard[0][2] == player && 
       GameBoard[1][0] == player && GameBoard[1][1] == player && GameBoard[1][2] == player && 
       GameBoard[2][0] == player && GameBoard[2][1] == player && GameBoard[2][2] == player) 
       { 
       boolean tieGame=true; 
      } 
      return new boolean [] {finalwinner, tiegame}; 
     } 

public static void main (String[] args) 
       { 
       System.out.println("Tic Tac Toe Game"); 
       System.out.println("Player 1 is 1, Computer is 2"); 
      Draw(); 
      currentplayer=1; 
      while (winner!= true) 
      { 
       if(currentplayer==1) 
        { 
         System.out.println("Your Turn"); 
         Player1Turn(currentplayer); 
        } 
       else 
        ComputerTurn(currentplayer); 

       boolean result[] = CheckForWinner(currentplayer); 

       if(result[0]==true && result[1]==false) 
       { 
        System.out.println("Winner is Player" +currentplayer+ "Congrats Champion!"); 
        System.out.println("Beginning New Game! Press Cancel then Enter to Exit"); 
        Reset(); 
       } 

       if(result[1]==true) 
       { 
        System.out.println("It's a Tie! Play Again."); 
        System.out.println("Beginning New Game! Press Cancel then Enter to Exit"); 
        Reset(); 
       } 

       if(currentplayer==1) 
        currentplayer=2; 
       else if(currentplayer==2) 
        currentplayer=1; 
      } 

      } 

Answer 5

EDIT: Info on enums

Dies ist wahrscheinlich nicht das, was Sie bevorzugen würden, aber ich empfehle gehen Sie für einen anderen Zug/Board Darstellung:

WIE

Erstens, ich schlage vor, Sie implementieren Ihre Board-Zellen als enums (sin ce gibt es nur 9 von ihnen).

Dann implementieren die Platine als ein Satz von 9 Aufzählungen, die als solche:

public enum Move { 
A0, A1, A2, B0, B1, B2, C0, C1, C2; } 

Auch implementieren Muster (zB eine ganze Linie, eine ganze diagonal) als Gruppen von 3 enums gewinnen (dh eine Teilmenge der Tafel).

Nach diesen Änderungen wird es viel einfacher zu überprüfen, ob ein Spieler (sei es du oder der Computer) gewonnen hat.

Ich empfehle Ihnen, die Teilmengen und die Methode hinzuzufügen, die prüft, ob ein Spieler auch innerhalb der Move-Klasse gewonnen hat.

Eine Teilmenge kann wie folgt erstellt werden: z.

static private final EnumSet<Move> lineA = EnumSet.of(A0,A1,A2); 

Und ein Scheck von Ihrem gewonnen Methode (beachten Sie für alle Untergruppen überprüfen müssen) könnte möglicherweise sein:

moves.containsAll(lineA) 

wo bewegt sich der Satz von Bewegungen durch Spieler (wenn ein Spieler macht aus eine Bewegung, die du die Enum zu seinen Bewegungen addierst).

WARUM

Dieser Entwurf prägnanter, einfach und elegant ist. Sie sollten die beschriebenen Probleme nicht mehr erleben, wenn Sie diesen Ansatz verwenden.

Answer 6

Zuerst, in Ihrer Hauptmethode sagen Sie finalwinner=CheckForWinner(currentplayer);, so dass Sie finalwinner=true; nicht jedes Mal nach Überprüfung der Zeile, Spalte und Diagonale setzen müssen. return true; ist genug.

Ihr Problem ist, überprüfen Sie für eine Krawatte Spiel, und wenn es der Fall ist, können Sie auch true zurück, aber es ist falsch, weil keiner der beiden Spieler noch Computer gewinnt! So Ihre checkForWinner Methode immer kehrt wahr.

Sie haben nicht wirklich für Tie Spiel Extra zu überprüfen. Überprüfen Sie den Gewinn für den Spieler, checken Sie den Gewinn für den Computer, wenn beide falsch sind und der letzte Zug ist erledigt - es ist ein Unentschieden.