TicTacToe AI Java

Question

asked Aug 28, 2019 in AI and Deep Learning by ashely (50.2k points)

So this is a college assignment and everything is pretty much done except the AI doesn't know how to "take the win" and its moves at the start aren't as random as I'd like to be as they always go top corner and work their way down. The assignment only required two rules for the AI in that it could "take the win" or "block the win".

Also, the game doesn't seem to end when the board is filled. It asks me to choose my move.

I was hoping some people might have suggestions as to how I can improve it or point out where it is I'm going wrong.

Any help would be greatly appreciated.

Here is the play

import java.util.Scanner;
public class play {

    public static void main(String[] args) {

        System.out.println("Welcome to Tickle Tackle Toe!!! :D");
        System.out.println();
        //creat markers
        String marker1 = "x";
        String marker2 = "o";
        boolean playAgain = true;
        Scanner s = new Scanner(System.in);

        //create player objects
        Human human = new Human();
        Computer computer = new Computer();
        while(playAgain){
        //run board setup
        set Setup = new set();
        Setup.createBoard();
        Setup.printBoard();
        System.out.println("please choose your marker");
        System.out.println("type 1 for 'x' or 2 for 'o'");
        //set markers
        if(s.nextInt() == 1){
         // create player objects
         human.setMarker("x");
         computer.setMarker("o");
        }
        else
        {
        human.setMarker("o");
        computer.setMarker("x");
        }

    // determine who goes first
    int first = (int) (Math.random() * 2);

    boolean won = false;
    int turns = 0;
   if(first == 0){
   System.out.println("You go first!");
    System.out.println();
   while(!won){
    human.takeTurn(Setup.getBoard());
    turns++;
    Setup.printBoard();
    if(Setup.hasWon(Setup.getBoard())){
        won = true;
        System.out.println("Congrats you won!");
        }
        if(turns == 9){
        won = true;
        System.out.println("Its a draw!");
        break;
        }
    if(!won){
        computer.takeTurn(Setup.getBoard(), human);
        turns++;
        System.out.println();
        Setup.printBoard();
        System.out.println();
        if(Setup.hasWon(Setup.getBoard())){
            won = true;
            System.out.println("You lost!");
            }
            if(turns == 9){
        won = true;
        System.out.println("Its a draw!");
        break;
        }
        }
   } // close while 1
  }
  else {
    System.out.println("Computer goes first!");
    System.out.println();
    while(!won){
    computer.takeTurn(Setup.getBoard(), human);
    turns++;
    Setup.printBoard();
    if(Setup.hasWon(Setup.getBoard())){
        won = true;
        System.out.println("You lost!");
        }
    if(!won){
        human.takeTurn(Setup.getBoard());
        turns++;
        System.out.println();
        Setup.printBoard();
        System.out.println();
        if(Setup.hasWon(Setup.getBoard())){
            won = true;
            System.out.println("Congrats you won!");
            }
        }

   } // close while 2
  }
  System.out.println("Would you like to play again? Type 1 for yes or 2 to quit");
   System.out.println();
   if(s.nextInt() == 2){
   playAgain = false;
   }
  }
}
}

And here is the computer class

class Computer extends player {
    public Computer(){
    }
    int boardsize = 3;

    public void takeTurn(String[][] board, Human human) {
    int vertical = 0;
    int horizontal = 0;
    int diagonal = 0;
    boolean mademove = false;
    // check if you can take a win horizontally
    for(int i = 0; i<3; i++){
        if(board[0][i].equals(board[1][i]) && board[0][i].equals(Marker)){
            if(board[2][i] != human.getMarker()){
            board[2][i] = Marker;
            mademove = true;
            return;
            }
        }
    }
    for(int i = 0; i<3; i++){
        if(board[2][i].equals(board[1][i]) && board[2][i].equals(Marker)){
            if(board[0][i] != human.getMarker()){
            board[0][i] = Marker;
            mademove = true;
            return;
            }
        }

    }

        // check if you can take a win vertically
    for(int i = 0; i<3; i++){
        if(board[i][0].equals(board[i][1]) && board[i][0].equals(Marker)){
            if(board[i][2] != human.getMarker()){
            board[i][2] = Marker;
            mademove = true;
            return;
            }
        }
    }
    for(int i = 0; i<3; i++){
        if(board[i][2].equals(board[i][1]) && board[i][2].equals(Marker)){
            if(board[i][0] != human.getMarker()){
            board[i][0] = Marker;
            mademove = true;
            return;
            }
        }
    }

    // check if you can take a win diagonally

        if(board[0][0].equals(board[1][1]) && board[0][0].equals(Marker)){
            if(board[2][2] != human.getMarker()){
            board[2][2] = Marker;
            mademove = true;
            return;
            }
    }
        if(board[2][2].equals(board[1][1]) && board[2][2].equals(Marker)){
            if(board[0][0] != human.getMarker()){
            board[0][0] = Marker;
            mademove = true;
            return;
            }
    }
        if(board[0][0].equals(board[1][1]) && board[0][0].equals(Marker)){
            if(board[2][2] != human.getMarker()){
            board[2][2] = Marker;
            mademove = true;
            return;
            }
    }
        if(board[0][2].equals(board[1][1]) && board[0][2].equals(Marker)){
            if(board[2][0] != human.getMarker()){
            board[2][0] = Marker;
            mademove = true;
            return;
            }
    }
        if(board[2][0].equals(board[1][1]) && board[2][0].equals(Marker)){
            if(board[0][2] != human.getMarker()){
            board[0][2] = Marker;
            mademove = true;
            return;
            }
    }

    // BLOCKS!!!! //
    // check if you can block a win horizontally
    for(int i = 0; i<3; i++){
        if(board[0][i].equals(board[1][i]) && board[0][i].equals(human.getMarker())){
            if(board[2][i] != Marker){
            board[2][i] = Marker;
            mademove = true;
            return;
            }
        }
    }
    for(int i = 0; i<3; i++){
        if(board[2][i].equals(board[1][i]) && board[0][i].equals(human.getMarker())){
            if(board[0][i] != Marker){
            board[0][i] = Marker;
            mademove = true;
            return;
            }
        }

    }

    // check if you can block a win horizontally
    for(int i = 0; i<3; i++){
        if(board[i][0].equals(board[i][1]) && board[i][0].equals(human.getMarker())){
            if(board[i][2] != Marker){
            board[i][2] = Marker;
            mademove = true;
            return;
            }
        }
    }
    for(int i = 0; i<3; i++){
        if(board[i][2].equals(board[i][1]) && board[i][2].equals(human.getMarker())){
            if(board[i][0] != Marker){
            board[i][0] = Marker;
            mademove = true;
            return;
            }
        }
    }

    // check if you can block a win diagonally

        if(board[0][0].equals(board[1][1]) && board[0][0].equals(human.getMarker())){
            if(board[2][2] != Marker){
            board[2][2] = Marker;
            mademove = true;
            return;
            }
    }
        if(board[2][2].equals(board[1][1]) && board[2][2].equals(human.getMarker())){
            if(board[0][0] != Marker){
            board[0][0] = Marker;
            mademove = true;
            return;
            }
    }
        if(board[0][0].equals(board[1][1]) && board[0][0].equals(human.getMarker())){
            board[2][2] = Marker;
            mademove = true;
            return;
    }
        if(board[0][2].equals(board[1][1]) && board[0][2].equals(human.getMarker())){
            if(board[2][0] != Marker){
            board[2][0] = Marker;
            mademove = true;
            return;
            }
    }
        if(board[2][0].equals(board[1][1]) && board[2][0].equals(human.getMarker())){
            if(board[0][2] != Marker){
            board[0][2] = Marker;
            mademove = true;
            return;
            }
    }

         // make random move if above rules dont apply
        for(int i = 0; i<3; i++){
        if(board[i][0] != "x" && board[i][0] != "o"){
            board[i][0] = Marker;
            return;
            }
        }
        for(int i = 0; i<3; i++){
        if(board[i][1] != "x" && board[i][0] != "o"){
            board[i][1] = Marker;
            return;
            }
        }
            for(int i = 0; i<3; i++){
        if(board[i][2] != "x" && board[i][0] != "o"){
            board[i][2] = Marker;
            return;
            }
        }

    }
}

1 Answer

vinita · Answer 1 · 2019-08-28T09:42:20+0000

About making random moves, your current code loops through all nine tiles place a marker on the first empty spot it encounters and then returns. What you would want is to make a list of all empty spots, and then randomly select one of them. Alternately, keep generating x and y coordinates between 0 and 2, check if it's empty and if so place a marker.

If you win by placing the ninth piece, you'll get both the "you won" and "it's a draw!" messages, I don't think that's the intended behavior. Same if you lose on the ninth turn. Whereas, the draw code is not reached when nobody has won, which is why the game doesn't end. You can implement the following piece of code in your program to fix your query:

if(!won){
    computer.takeTurn(Setup.getBoard(), human);
    turns++;
    System.out.println();
    Setup.printBoard();
    System.out.println();
    if(Setup.hasWon(Setup.getBoard())){
        won = true;
        System.out.println("You lost!");
    } else if (turns == 9){
        won = true;
        System.out.println("Its a draw!");
    }
}

TicTacToe AI Java

1 Answer

Related questions

Browse Categories