w3resource

Tic-Tac-Toe Game in Java: Two-Player Console-Based Project

Introduction to the Java Tic-Tac-Toe Game:

Tic-Tac-Toe Game:

Create a simple two-player console-based game.

A console-based version of the classic two-player game. Players take turns marking spaces on a 3x3 grid, and the first player to get three marks in a row (horizontally, vertically, or diagonally) wins.

Input: Player move (row and column) on a 3x3 grid.
Output: Updated game board and game status (win/draw/continue).

Example:

  • Input: Player 1 selects row 1, column 2
  • Output: Updated grid, "Player 1 wins" or "Continue playing"

Solution 1: Tic-Tac-Toe with Simple Array and Loops

Code:

import java.util.Scanner;

public class TicTacToeSimple {
    // Declare a 3x3 array to represent the game board
    static char[][] board = new char[3][3];

    public static void main(String[] args) {
        // Initialize the board with empty spaces
        initializeBoard();

        // Variable to keep track of the current player ('X' or 'O')
        char currentPlayer = 'X';

        // Variable to check if the game is won or drawn
        boolean gameWon = false;
        boolean draw = false;

        // Create a Scanner object for input
        Scanner scanner = new Scanner(System.in);

        // Main game loop, runs until a player wins or it's a draw
        while (!gameWon && !draw) {
            printBoard();  // Display the board
            System.out.println("Player " + currentPlayer + "'s turn. Enter row and column (1-3):");

            // Get player input for row and column
            int row = scanner.nextInt() - 1;
            int col = scanner.nextInt() - 1;

            // Check if the selected cell is empty
            if (board[row][col] == ' ') {
                // Place the current player's mark on the board
                board[row][col] = currentPlayer;

                // Check if the current player has won the game
                gameWon = checkWin(currentPlayer);

                if (!gameWon) {
                    // Check if the board is full (draw)
                    draw = checkDraw();

                    // Switch the player if the game isn't won
                    currentPlayer = (currentPlayer == 'X') ? 'O' : 'X';
                }
            } else {
                System.out.println("Cell is already occupied! Try again.");
            }
        }

        // Display the final board
        printBoard();

        // Display game result
        if (gameWon) {
            System.out.println("Player " + currentPlayer + " wins!");
        } else {
            System.out.println("It's a draw!");
        }

        // Close the scanner
        scanner.close();
    }

    // Function to initialize the board with empty spaces
    public static void initializeBoard() {
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                board[i][j] = ' ';
            }
        }
    }

    // Function to print the current state of the board
    public static void printBoard() {
        System.out.println("  1 2 3");
        for (int i = 0; i < 3; i++) {
            System.out.print((i + 1) + " ");
            for (int j = 0; j < 3; j++) {
                System.out.print(board[i][j]);
                if (j < 2) System.out.print("|");
            }
            System.out.println();
            if (i < 2) System.out.println("  -----");
        }
    }

    // Function to check if the current player has won
    public static boolean checkWin(char player) {
        // Check rows, columns, and diagonals
        for (int i = 0; i < 3; i++) {
            if (board[i][0] == player && board[i][1] == player && board[i][2] == player)
                return true;
            if (board[0][i] == player && board[1][i] == player && board[2][i] == player)
                return true;
        }
        if (board[0][0] == player && board[1][1] == player && board[2][2] == player)
            return true;
        if (board[0][2] == player && board[1][1] == player && board[2][0] == player)
            return true;
        return false;
    }

    // Function to check if the board is full (indicating a draw)
    public static boolean checkDraw() {
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                if (board[i][j] == ' ') {
                    return false;  // If any cell is empty, it's not a draw
                }
            }
        }
        return true;  // If no empty cells, it's a draw
    }
}

Output:

1 2 3
1  | | 
  -----
2  | | 
  -----
3  | | 
Player X's turn. Enter row and column (1-3):
 1
 1
  1 2 3
1 X| | 
  -----
2  | | 
  -----
3  | | 
Player O's turn. Enter row and column (1-3):
 1
 2
  1 2 3
1 X|O| 
  -----
2  | | 
  -----
3  | | 
Player X's turn. Enter row and column (1-3):
 3
 3
  1 2 3
1 X|O| 
  -----
2  | | 
  -----
3  | |X
Player O's turn. Enter row and column (1-3):
 3
 2
  1 2 3
1 X|O| 
  -----
2  | | 
  -----
3  |O|X
Player X's turn. Enter row and column (1-3):
 2
 2
  1 2 3
1 X|O| 
  -----
2  |X| 
  -----
3  |O|X
Player X wins!

Explanation :

  • Game Board: The board is represented by a 2D array, initialized with empty spaces.
  • Player Input: Players input the row and column to place their mark.
  • Win/Draw Conditions: The game checks for a win by rows, columns, or diagonals. It also checks if all spaces are filled (indicating a draw).
  • Switching Players: The game alternates between 'X' and 'O'.
  • Loop: The game loop runs until either a player wins or the game ends in a draw.

Solution 2: Using Object-Oriented Approach

Key points:

  • Game Board Initialization: The board is initialized as a 3x3 grid, filled with empty spaces.
  • Player Moves: The user inputs row and column values, and the game updates the board accordingly if the input is valid.
  • Win Condition: After every move, the game checks if the current player has completed a row, column, or diagonal.
  • Draw Condition: If the board is full and no one wins, the game is a draw.
  • Switching Players: After every valid move, the current player switches between 'X' and 'O'.
  • Game Restart: After a game ends, players can choose to restart the game with an empty board or end the session.
  • Statistics: The game keeps track of how many games each player has won and the number of draws.
  • Input Validation: Invalid inputs (e.g., selecting already occupied spots or entering out-of-bound values) are handled, and the player is prompted to re-enter their move.

Code:

TicTacToe.java

import java.util.Scanner;

class TicTacToe {
    private char[][] board;
    private char currentPlayer;
    private int playerXWins;
    private int playerOWins;
    private int draws;

    // Constructor to initialize the board and set the starting player
    public TicTacToe() {
        board = new char[3][3];
        currentPlayer = 'X';
        initializeBoard();
        playerXWins = 0;  // Track Player X wins
        playerOWins = 0;  // Track Player O wins
        draws = 0;        // Track draws
    }

    // Initialize the board with empty spaces
    private void initializeBoard() {
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                board[i][j] = ' ';
            }
        }
    }

    // Display the current state of the board
    public void printBoard() {
        System.out.println("  1 2 3");
        for (int i = 0; i < 3; i++) {
            System.out.print((i + 1) + " ");
            for (int j = 0; j < 3; j++) {
                System.out.print(board[i][j]);
                if (j < 2) System.out.print("|");
            }
            System.out.println();
            if (i < 2) System.out.println("  -----");
        }
    }

    // Switch the current player between 'X' and 'O'
    public void switchPlayer() {
        currentPlayer = (currentPlayer == 'X') ? 'O' : 'X';
    }

    // Handle player input and update the board
    public boolean makeMove(int row, int col) {
        if (row >= 0 && row < 3 && col >= 0 && col < 3 && board[row][col] == ' ') {
            board[row][col] = currentPlayer;
            return true;
        }
        return false;
    }

    // Check if the current player has won the game
    public boolean checkWin() {
        for (int i = 0; i < 3; i++) {
            if (board[i][0] == currentPlayer && board[i][1] == currentPlayer && board[i][2] == currentPlayer)
                return true;
            if (board[0][i] == currentPlayer && board[1][i] == currentPlayer && board[2][i] == currentPlayer)
                return true;
        }
        if (board[0][0] == currentPlayer && board[1][1] == currentPlayer && board[2][2] == currentPlayer)
            return true;
        if (board[0][2] == currentPlayer && board[1][1] == currentPlayer && board[2][0] == currentPlayer)
            return true;
        return false;
    }

    // Check if the board is full (indicating a draw)
    public boolean checkDraw() {
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                if (board[i][j] == ' ') {
                    return false;
                }
            }
        }
        return true;
    }

    // Get the current player
    public char getCurrentPlayer() {
        return currentPlayer;
    }

    // Update the win count for the current player
    public void updateWinCount() {
        if (currentPlayer == 'X') {
            playerXWins++;
        } else {
            playerOWins++;
        }
    }

    // Increment the draw count
    public void updateDrawCount() {
        draws++;
    }

    // Display the game statistics
    public void displayStatistics() {
        System.out.println("Player X Wins: " + playerXWins);
        System.out.println("Player O Wins: " + playerOWins);
        System.out.println("Draws: " + draws);
    }

    // Reset the board for a new game
    public void resetBoard() {
        initializeBoard();
        currentPlayer = 'X';  // Player X always starts the new game
    }
}

Explanation:

  • Class Definition:
    • The TicTacToe class manages the game's logic, including the board, player turns, win checks, and statistics.
  • Fields:
    • board: A 3x3 char array representing the game board.
    • currentPlayer: Tracks the current player ('X' or 'O').
    • playerXWins, playerOWins, draws: Integers to track the number of wins for each player and the number of draws.
  • Constructor:
    • Initializes the board, sets the starting player to 'X', and resets the win/draw counters.
  • initializeBoard():
    • Fills the board with empty spaces (' ') to prepare it for gameplay.
  • printBoard():
    • Displays the current state of the board in a 3x3 grid format with row and column numbers for easy reference.
  • switchPlayer():
    • Switches the current player between 'X' and 'O' after each turn.
  • makeMove(int row, int col):
    • Places the current player's mark on the specified row and column, if the spot is valid and unoccupied.
    • Returns true if the move is valid, otherwise false.
  • checkWin():
    • Checks all possible winning conditions (rows, columns, and diagonals) to determine if the current player has won.
    • Returns true if there is a win, otherwise false.
  • checkDraw():
    • Checks if the board is full and no moves are possible, indicating a draw.
    • Returns true if the game is a draw, otherwise false.
  • getCurrentPlayer():
    • Returns the current player ('X' or 'O').
  • updateWinCount():
    • Increments the win count for the current player (either playerXWins or playerOWins).
  • updateDrawCount():
    • Increments the draw count (draws).
  • displayStatistics():
    • Displays the current statistics: number of wins for Player X, Player O, and the number of draws.
  • resetBoard():
    • Resets the board for a new game, clearing all spaces and setting the starting player to 'X'.

TicTacToeOOP.java

import java.util.Scanner; 
public class TicTacToeOOP {
    public static void main(String[] args) {
        TicTacToe game = new TicTacToe(); // Create a new TicTacToe game object
        Scanner scanner = new Scanner(System.in);
        boolean playAgain = true;

        // Main game loop (for multiple games)
        while (playAgain) {
            boolean gameWon = false;
            boolean draw = false;

            // Game loop for a single game
            while (!gameWon && !draw) {
                game.printBoard();  // Display the game board
                System.out.println("Player " + game.getCurrentPlayer() + "'s turn. Enter row and column (1-3):");

                // Get player input for row and column
                int row = scanner.nextInt() - 1;
                int col = scanner.nextInt() - 1;

                // Make the move and check for validity
                if (game.makeMove(row, col)) {
                    gameWon = game.checkWin();
                    if (!gameWon) {
                        draw = game.checkDraw();
                        if (!draw) {
                            game.switchPlayer();  // Switch player if game isn't won
                        } else {
                            System.out.println("It's a draw!");
                            game.updateDrawCount();  // Increment the draw count
                        }
                    } else {
                        game.printBoard();
                        System.out.println("Player " + game.getCurrentPlayer() + " wins!");
                        game.updateWinCount();  // Increment win count for the current player
                    }
                } else {
                    System.out.println("Invalid move. Try again.");
                }
            }

            // Display the game statistics
            game.displayStatistics();

            // Ask if the players want to play again
            System.out.println("Do you want to play again? (yes/no):");
            String response = scanner.next();

            if (response.equalsIgnoreCase("yes")) {
                game.resetBoard();  // Reset the board for a new game
            } else {
                playAgain = false;  // Exit the game loop
            }
        }

        System.out.println("Thanks for playing!");
        scanner.close();
    }
}

Explanation:

  • Imports:
    • java.util.Scanner: Used to capture user input from the console.
  • main() Method:
    • The entry point of the program where the game logic is executed.
  • Game Initialization:
    • Creates a TicTacToe object named game.
    • Initializes a Scanner object to read user input.
  • Main Game Loop (while (playAgain)):
    • Controls whether the players want to play another game.
    • Runs continuously until the players choose not to play again.
  • Single Game Loop:
    • Repeats until either a player wins or the game ends in a draw.
    • Calls game.printBoard() to display the current state of the board.
    • Prompts the current player to enter row and column coordinates for their move.
  • Input Handling:
    • Player enters row and column (1-3), which are converted to 0-indexed values.
    • Checks if the move is valid using game.makeMove().
  • Move Validation:
    • If the move is valid:
      • Calls game.checkWin() to see if the current player has won.
      • If no one has won, calls game.checkDraw() to see if the game is a draw.
      • If the game is ongoing, switches the player using game.switchPlayer().
  • Winning Condition:
    • If a player wins, the board is displayed, and the current player is declared the winner.
    • Increments the win count for the winner using game.updateWinCount().
  • Draw Condition:
    • If the game is a draw, displays a message and increments the draw count with game.updateDrawCount().
  • Display Statistics:
    • After each game, game.displayStatistics() shows the win and draw counts.
  • Play Again Prompt:
    • Asks the players if they want to play another game.
    • If they answer "yes", the board is reset using game.resetBoard().
    • If "no", the loop ends, and the game concludes.
  • Game Conclusion:
    • Displays a thank-you message and closes the Scanner object.

Output:

1 2 3
1  | |
  -----
2  | |
  -----
3  | |
Player X's turn. Enter row and column (1-3):
1
1
  1 2 3
1 X| |
  -----
2  | |
  -----
3  | |
Player O's turn. Enter row and column (1-3):
1
3
  1 2 3
1 X| |O
  -----
2  | |
  -----
3  | |
Player X's turn. Enter row and column (1-3):
2
1
  1 2 3
1 X| |O
  -----
2 X| |
  -----
3  | |
Player O's turn. Enter row and column (1-3):
3
1
  1 2 3
1 X| |O
  -----
2 X| |
  -----
3 O| |
Player X's turn. Enter row and column (1-3):
2
2
  1 2 3
1 X| |O
  -----
2 X|X|
  -----
3 O| |
Player O's turn. Enter row and column (1-3):
2
3
  1 2 3
1 X| |O
  -----
2 X|X|O
  -----
3 O| |
Player X's turn. Enter row and column (1-3):
1
2
  1 2 3
1 X|X|O
  -----
2 X|X|O
  -----
3 O| |
Player O's turn. Enter row and column (1-3):
3
3
  1 2 3
1 X|X|O
  -----
2 X|X|O
  -----
3 O| |O
Player O wins!
Player X Wins: 0
Player O Wins: 1
Draws: 0
Do you want to play again? (yes/no):
no
Thanks for playing!

Java Code Editor:




Follow us on Facebook and Twitter for latest update.