Scribd
Upload
10 views9 pages

Java Tic Tac Toe Game Implementation

This Java code implements a Tic-Tac-Toe game. It uses a 2D array to represent the game board and tracks whose turn it is (player 1 or 2). The main game loop handles turns where players enter positions until someone wins or the board is full, resulting in a tie. Helper methods draw the board, check for a winner, and check if the board is full to end the game.

Uploaded by

Huzaifa
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
10 views9 pages

Java Tic Tac Toe Game Implementation

This Java code implements a Tic-Tac-Toe game. It uses a 2D array to represent the game board and tracks whose turn it is (player 1 or 2). The main game loop handles turns where players enter positions until someone wins or the board is full, resulting in a tie. Helper methods draw the board, check for a winner, and check if the board is full to end the game.

Uploaded by

Huzaifa
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd

Huzaifa Arshad 61353

import [Link];

class Main {

public static void main(String[] args) {


int n = 3; // This will set up the size of our
Tic-Tac-Toe board

// This will create a 2D array to represent the


game board
char[][] board = new char[n][n];

// This will initialize the game board with


empty positions
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
board[i][j] = '-';
}
}

// This will set up a scanner to collect player


names
Scanner in = new Scanner([Link]);
[Link]("Welcome to Tic Tac
Toe!\n");
[Link]("Player 1, please enter your
name: ");
String p1 = [Link]();
[Link]("Player 2, please enter your
name: ");
String p2 = [Link]();

boolean player1 = true; // This will track


whose turn it is (true for Player 1, false for Player 2)
boolean gameEnded = false; // This will
control the main game loop

while (!gameEnded) {

drawBoard(board); // This will display


the current state of the game board

if (player1) {
[Link](p1 + ", it's your
turn (x):");
} else {
[Link](p2 + ", it's your
turn (o):");
}

char c = '-';
if (player1) {
c = 'x';
} else {
c = 'o';
}

int row = 0;
int col = 0;

while (true) {
[Link]("Enter the row
number: ");
row = [Link]();
[Link]("Enter the column
number: ");
col = [Link]();
if (row < 0 || col < 0 || row >= n ||
col >= n) {
[Link]("Invalid
position! Please try again.");
} else if (board[row][col] != '-') {
[Link]("That
position is already taken! Please try again.");
} else {
break;
}
}

board[row][col] = c; // This will update


the game board with the player's move

char winner = playerHasWon(board);


if (winner == 'x') {
[Link](p1 + " wins!
Congratulations!");
gameEnded = true;
} else if (winner == 'o') {
[Link](p2 + " wins!
Congratulations!");
gameEnded = true;
} else {
if (boardIsFull(board)) {
[Link]("It's a tie!
The game is over.");
gameEnded = true;
} else {
player1 = !player1; // This will
switch turns between players
}
}
}
drawBoard(board); // This will display the
final state of the game board
}

public static void drawBoard(char[][] board) {


[Link]("Current Game Board:");
for (int i = 0; i < [Link]; i++) {
for (int j = 0; j < board[i].length; j++) {
[Link](board[i][j]);
}
[Link](); // This will move to
the next row
}
}

public static char playerHasWon(char[][] board) {


// This function will determine if a player has
won
// The implementation will check rows,
columns, and diagonals for a winner
return ' '; // This will return 'x', 'o', or ' ' (no
winner yet)
}

public static boolean boardIsFull(char[][] board) {


// This function will check if the game board is
fully occupied
// It will return true if all positions are filled,
indicating a tie
for (int i = 0; i < [Link]; i++) {
for (int j = 0; j < board[i].length; j++) {
if (board[i][j] == '-') {
return false; // This will
indicate the game is not over yet
}
}
}
return true; // This will indicate the game has
ended in a tie
}
}

Common questions

Powered by AI

The game determines a win by checking rows, columns, and diagonals for a matching set of 'x' or 'o' using the `playerHasWon` method, although the implementation details are left incomplete in Source 1. To check for a tie, the `boardIsFull` method verifies that all positions are filled; if so, the game ends in a tie if no player has won .

The implementation could be extended by replacing the fixed size 'n=3' with a variable size input, allowing users to specify the board dimensions at the start. This would involve dynamically adjusting the board creation logic and updating the win-checking logic in `playerHasWon` to accommodate different length rows, columns, and diagonals .

The game uses a boolean variable `player1` to track whose turn it is, switching between true and false at the end of each turn. Based on this variable, the game determines who the current player is and alternates turns between Player 1 and Player 2 .

Initializing the game board with '-' is appropriate as it distinguishes empty spots from player moves ('x' or 'o') clearly and simplifies the logic for checking available spaces in the `boardIsFull` and input validation processes .

To improve user experience, the game loop could implement a hint system showing available positions after an invalid entry, or maintain a counter to provide feedback if consecutive invalid attempts are detected. Adding a timeout or automated suggestions could help users correct their input more efficiently .

A console application is simpler to develop and requires less processing power, making it quick to implement for educational purposes. However, a graphical interface could provide a more engaging and intuitive user experience with richer visual feedback. A console application limits interaction to text input, while a graphical interface allows for more dynamic and interactive elements .

Separating game logic from input/output operations can improve the program's modularity and maintainability, making it easier to adapt the code for different interfaces or testing. By isolating the logic, changes to the user interface won't affect the game's underlying mechanics, promoting code reuse and potentially enhancing performance .

The game uses a loop with condition checks in the main game loop that repeatedly prompts the user until a valid move is made. An error message is displayed if the inputted position is out of bounds or if the chosen position is already occupied. This ensures that only valid moves are executed on the game board .

Directly modifying the board in the input loop can lead to errors if inputs are invalid or if the board state is reverted. This could be mitigated by first validating inputs and holding changes in a temporary variable, only updating the board once all checks are passed. This reduces side effects and ensures data integrity .

An AI opponent could use strategies like the minimax algorithm to evaluate potential game states and choose optimal moves. It could also implement heuristics for prioritizing center and corner positions, or blocks opponent wins by monitoring two-in-a-row situations. These approaches allow it to foresee possible outcomes and strategically plan ahead .

You might also like