Back

Activity 5.6 — Milestone: Tic-Tac-Toe

Introduction

Activity 5.6

Milestone Program: Tic-Tac-Toe

Why this milestone?

You now know arrays, traversal, and 2D arrays.
This game forces you to use grid thinking.
You'll practice methods, validation, and algorithms.

Board Model

We store the board as a 3×3 2D array.
'-' means empty.
'X' and 'O' are player moves.

1
// Tic-Tac-Toe board as a 2D array (3 rows, 3 columns)
2
char[][] board =
3
{
4
    {'-', '-', '-'},
5
    {'-', '-', '-'},
6
    {'-', '-', '-'}
7
};
8

9
// board[row][col] is one cell

Coordinates

Players choose a row and col (0–2).

1
// Printing seeable coordinates
2
// (r,c) indices:
3
// (0,0) (0,1) (0,2)
4
// (1,0) (1,1) (1,2)
5
// (2,0) (2,1) (2,2)

Move Rules

Row and col must be within 0–2
The cell must be empty
If a move is invalid, we ask again

1
// Valid move rules
2
// 1) row and col must be 0..2
3
// 2) chosen cell must be empty ('-')

Game Loop (what repeats?)

Print the board
Ask current player for a move
Validate move
Place piece
Check win / tie
Switch players

Switching Players

After a valid move, switch turns.

1
// Turn switching
2
char currentPlayer = 'X';
3

4
// after a successful move:
5
if (currentPlayer == 'X')
6
{
7
    currentPlayer = 'O';
8
}
9
else
10
{
11
    currentPlayer = 'X';
12
}

Win Checking

A player wins by making 3 in a row.

1
// Win check idea: a player wins if 3 in a row match
2
// Rows: board[r][0], board[r][1], board[r][2]
3
// Cols: board[0][c], board[1][c], board[2][c]
4
// Diagonals: (0,0)(1,1)(2,2) and (0,2)(1,1)(2,0)

We check rows, columns, and diagonals.

Example: Row Win Check

One row check is just comparing three positions.

1
// Example row check (r = 1)
2
if (board[1][0] == player &&
3
    board[1][1] == player &&
4
    board[1][2] == player)
5
{
6
    return true;
7
}

Tie Checking

If nobody won and the board has no empty cells, it's a tie.
This requires scanning the entire grid.

1
// Tie check idea
2
// If no '-' remain and nobody won -> tie

How you'll build it

Start with printing the board
Add one move + validation
Add win check + tie check as methods
Combine into the full game loop

'F' → Fullscreen

Objectives

Use a 2D array to represent a 3×3 game board.
Traverse and print a grid using nested loops.
Validate user input before updating the board.
Write methods to check win conditions and ties.

Activity Tasks

Create a new project named Activity5_6_TicTacToe.
Complete Tasks 1–4 first, then build the full game in Task 5.
Use Allman braces in all code.
Keep your code neat: methods go below main.

Figures: Reference Methods

1
// Figure 1 — A printable board method (Allman style)
2
public static void printBoard(char[][] board)
3
{
4
    System.out.println();
5
    System.out.println("   0   1   2");
6
    System.out.println("  -----------");
7

8
    for (int r = 0; r < board.length; r++)
9
    {
10
        System.out.print(r + " |");
11

12
        for (int c = 0; c < board[r].length; c++)
13
        {
14
            System.out.print(" " + board[r][c] + " |");
15
        }
16

17
        System.out.println();
18
        System.out.println("  -----------");
19
    }
20

21
    System.out.println();
22
}

1
// Figure 2 — Move validation (Allman style)
2
public static boolean isValidMove(char[][] board, int row, int col)
3
{
4
    if (row < 0 || row >= board.length)
5
    {
6
        return false;
7
    }
8

9
    if (col < 0 || col >= board[row].length)
10
    {
11
        return false;
12
    }
13

14
    if (board[row][col] != '-')
15
    {
16
        return false;
17
    }
18

19
    return true;
20
}

1
// Figure 3 — Win check (Allman style)
2
public static boolean checkWin(char[][] board, char player)
3
{
4
    // Rows
5
    for (int r = 0; r < board.length; r++)
6
    {
7
        if (board[r][0] == player && board[r][1] == player && board[r][2] == player)
8
        {
9
            return true;
10
        }
11
    }
12

13
    // Columns
14
    for (int c = 0; c < board[0].length; c++)
15
    {
16
        if (board[0][c] == player && board[1][c] == player && board[2][c] == player)
17
        {
18
            return true;
19
        }
20
    }
21

22
    // Diagonals
23
    if (board[0][0] == player && board[1][1] == player && board[2][2] == player)
24
    {
25
        return true;
26
    }
27

28
    if (board[0][2] == player && board[1][1] == player && board[2][0] == player)
29
    {
30
        return true;
31
    }
32

33
    return false;
34
}

1
// Figure 4 — Tie check (Allman style)
2
public static boolean isBoardFull(char[][] board)
3
{
4
    for (int r = 0; r < board.length; r++)
5
    {
6
        for (int c = 0; c < board[r].length; c++)
7
        {
8
            if (board[r][c] == '-')
9
            {
10
                return false;
11
            }
12
        }
13
    }
14

15
    return true;
16
}

Task 1: Create + Print the Board

Create a 3×3 board filled with '-'.
Print it using a nested-loop method.
Your board should include row/col labels.

1
public class Program
2
{
3
    public static void main(String[] args)
4
    {
5
        // Task 1 — Build the board + print it
6
        //
7
        // 1) Create a 3x3 char board filled with '-'
8
        // 2) Call printBoard(board) to display it
9
        //
10
        // Expected: an empty 3x3 grid with row/col labels.
11

12
        char[][] board =
13
        {
14
            {'-', '-', '-'},
15
            {'-', '-', '-'},
16
            {'-', '-', '-'}
17
        };
18

19
        printBoard(board);
20
    }
21

22
    public static void printBoard(char[][] board)
23
    {
24
        System.out.println();
25
        System.out.println("   0   1   2");
26
        System.out.println("  -----------");
27

28
        for (int r = 0; r < board.length; r++)
29
        {
30
            System.out.print(r + " |");
31

32
            for (int c = 0; c < board[r].length; c++)
33
            {
34
                System.out.print(" " + board[r][c] + " |");
35
            }
36

37
            System.out.println();
38
            System.out.println("  -----------");
39
        }
40

41
        System.out.println();
42
    }
43
}

Task 2: Place One Move (with Validation)

Ask the user for row and col.
Validate the move, then place an 'X'.
Print the board after the attempt.

1
import java.util.Scanner;
2

3
public class Program
4
{
5
    public static void main(String[] args)
6
    {
7
        // Task 2 — Place a move (single turn)
8
        //
9
        // 1) Start with an empty board
10
        // 2) Ask the user for row and col (0-2)
11
        // 3) If the move is valid, place 'X' there
12
        // 4) Print the board
13
        //
14
        // Note: We'll build the full game loop later.
15

16
        char[][] board =
17
        {
18
            {'-', '-', '-'},
19
            {'-', '-', '-'},
20
            {'-', '-', '-'}
21
        };
22

23
        Scanner scanner = new Scanner(System.in);
24

25
        printBoard(board);
26

27
        System.out.print("Enter row (0-2): ");
28
        int row = scanner.nextInt();
29

30
        System.out.print("Enter col (0-2): ");
31
        int col = scanner.nextInt();
32

33
        if (isValidMove(board, row, col))
34
        {
35
            board[row][col] = 'X';
36
            System.out.println("Move placed!");
37
        }
38
        else
39
        {
40
            System.out.println("Invalid move.");
41
        }
42

43
        printBoard(board);
44

45
        scanner.close();
46
    }
47

48
    public static void printBoard(char[][] board)
49
    {
50
        System.out.println();
51
        System.out.println("   0   1   2");
52
        System.out.println("  -----------");
53

54
        for (int r = 0; r < board.length; r++)
55
        {
56
            System.out.print(r + " |");
57

58
            for (int c = 0; c < board[r].length; c++)
59
            {
60
                System.out.print(" " + board[r][c] + " |");
61
            }
62

63
            System.out.println();
64
            System.out.println("  -----------");
65
        }
66

67
        System.out.println();
68
    }
69

70
    public static boolean isValidMove(char[][] board, int row, int col)
71
    {
72
        if (row < 0 || row >= board.length)
73
        {
74
            return false;
75
        }
76

77
        if (col < 0 || col >= board[row].length)
78
        {
79
            return false;
80
        }
81

82
        if (board[row][col] != '-')
83
        {
84
            return false;
85
        }
86

87
        return true;
88
    }
89
}

Task 3: Win Checking Method

Implement checkWin(board, player).
Test it using the provided winning board.

1
public class Program
2
{
3
    public static void main(String[] args)
4
    {
5
        // Task 3 — Implement checkWin(board, player)
6
        //
7
        // 1) Copy the board below
8
        // 2) Call checkWin(board, 'X') and print the result
9
        //
10
        // The board below is a win for X on the top row.
11

12
        char[][] board =
13
        {
14
            {'X', 'X', 'X'},
15
            {'O', '-', 'O'},
16
            {'-', '-', '-'}
17
        };
18

19
        boolean xWon = checkWin(board, 'X');
20
        System.out.println("X won? " + xWon);
21
    }
22

23
    public static boolean checkWin(char[][] board, char player)
24
    {
25
        // Rows
26
        for (int r = 0; r < board.length; r++)
27
        {
28
            if (board[r][0] == player && board[r][1] == player && board[r][2] == player)
29
            {
30
                return true;
31
            }
32
        }
33

34
        // Columns
35
        for (int c = 0; c < board[0].length; c++)
36
        {
37
            if (board[0][c] == player && board[1][c] == player && board[2][c] == player)
38
            {
39
                return true;
40
            }
41
        }
42

43
        // Diagonals
44
        if (board[0][0] == player && board[1][1] == player && board[2][2] == player)
45
        {
46
            return true;
47
        }
48

49
        if (board[0][2] == player && board[1][1] == player && board[2][0] == player)
50
        {
51
            return true;
52
        }
53

54
        return false;
55
    }
56
}

Task 4: Tie Helper (Board Full)

Implement isBoardFull(board).
Test it using a full and not-full board.

1
public class Program
2
{
3
    public static void main(String[] args)
4
    {
5
        // Task 4 — Implement isBoardFull(board)
6
        //
7
        // 1) Create two boards:
8
        //    A) a full board (no '-')
9
        //    B) a not-full board (has '-')
10
        // 2) Print isBoardFull(...) for each
11

12
        char[][] fullBoard =
13
        {
14
            {'X', 'O', 'X'},
15
            {'X', 'O', 'O'},
16
            {'O', 'X', 'X'}
17
        };
18

19
        char[][] notFullBoard =
20
        {
21
            {'X', 'O', '-'},
22
            {'X', '-', 'O'},
23
            {'O', 'X', 'X'}
24
        };
25

26
        System.out.println("Full board? " + isBoardFull(fullBoard));
27
        System.out.println("Full board? " + isBoardFull(notFullBoard));
28
    }
29

30
    public static boolean isBoardFull(char[][] board)
31
    {
32
        for (int r = 0; r < board.length; r++)
33
        {
34
            for (int c = 0; c < board[r].length; c++)
35
            {
36
                if (board[r][c] == '-')
37
                {
38
                    return false;
39
                }
40
            }
41
        }
42

43
        return true;
44
    }
45
}

Task 5: Full Game (Milestone)

Combine everything into a full Tic-Tac-Toe loop.
Players alternate between X and O.
Stop the game on win or tie.
Print helpful messages after each move.

1
import java.util.Scanner;
2

3
public class Program
4
{
5
    public static void main(String[] args)
6
    {
7
        // Task 5 — Milestone: Full Tic-Tac-Toe Game
8
        //
9
        // Features:
10
        // - 2D char board
11
        // - player turns (X then O)
12
        // - input validation (row/col in range, cell empty)
13
        // - win detection
14
        // - tie detection
15
        //
16
        // Suggested flow:
17
        // while (true)
18
        //   print board
19
        //   prompt move for current player
20
        //   if invalid -> message and continue
21
        //   place piece
22
        //   if win -> print board + winner and break
23
        //   if tie -> print board + tie message and break
24
        //   switch player
25

26
        char[][] board =
27
        {
28
            {'-', '-', '-'},
29
            {'-', '-', '-'},
30
            {'-', '-', '-'}
31
        };
32

33
        Scanner scanner = new Scanner(System.in);
34

35
        char currentPlayer = 'X';
36

37
        while (true)
38
        {
39
            printBoard(board);
40

41
            System.out.println("Player " + currentPlayer + "'s turn.");
42
            System.out.print("Enter row (0-2): ");
43
            int row = scanner.nextInt();
44

45
            System.out.print("Enter col (0-2): ");
46
            int col = scanner.nextInt();
47

48
            if (!isValidMove(board, row, col))
49
            {
50
                System.out.println("Invalid move. Try again.");
51
                continue;
52
            }
53

54
            board[row][col] = currentPlayer;
55

56
            if (checkWin(board, currentPlayer))
57
            {
58
                printBoard(board);
59
                System.out.println("Player " + currentPlayer + " wins!");
60
                break;
61
            }
62

63
            if (isBoardFull(board))
64
            {
65
                printBoard(board);
66
                System.out.println("It's a tie!");
67
                break;
68
            }
69

70
            // switch player
71
            if (currentPlayer == 'X')
72
            {
73
                currentPlayer = 'O';
74
            }
75
            else
76
            {
77
                currentPlayer = 'X';
78
            }
79
        }
80

81
        scanner.close();
82
    }
83

84
    public static void printBoard(char[][] board)
85
    {
86
        System.out.println();
87
        System.out.println("   0   1   2");
88
        System.out.println("  -----------");
89

90
        for (int r = 0; r < board.length; r++)
91
        {
92
            System.out.print(r + " |");
93

94
            for (int c = 0; c < board[r].length; c++)
95
            {
96
                System.out.print(" " + board[r][c] + " |");
97
            }
98

99
            System.out.println();
100
            System.out.println("  -----------");
101
        }
102

103
        System.out.println();
104
    }
105

106
    public static boolean isValidMove(char[][] board, int row, int col)
107
    {
108
        if (row < 0 || row >= board.length)
109
        {
110
            return false;
111
        }
112

113
        if (col < 0 || col >= board[row].length)
114
        {
115
            return false;
116
        }
117

118
        if (board[row][col] != '-')
119
        {
120
            return false;
121
        }
122

123
        return true;
124
    }
125

126
    public static boolean checkWin(char[][] board, char player)
127
    {
128
        // Rows
129
        for (int r = 0; r < board.length; r++)
130
        {
131
            if (board[r][0] == player && board[r][1] == player && board[r][2] == player)
132
            {
133
                return true;
134
            }
135
        }
136

137
        // Columns
138
        for (int c = 0; c < board[0].length; c++)
139
        {
140
            if (board[0][c] == player && board[1][c] == player && board[2][c] == player)
141
            {
142
                return true;
143
            }
144
        }
145

146
        // Diagonals
147
        if (board[0][0] == player && board[1][1] == player && board[2][2] == player)
148
        {
149
            return true;
150
        }
151

152
        if (board[0][2] == player && board[1][1] == player && board[2][0] == player)
153
        {
154
            return true;
155
        }
156

157
        return false;
158
    }
159

160
    public static boolean isBoardFull(char[][] board)
161
    {
162
        for (int r = 0; r < board.length; r++)
163
        {
164
            for (int c = 0; c < board[r].length; c++)
165
            {
166
                if (board[r][c] == '-')
167
                {
168
                    return false;
169
                }
170
            }
171
        }
172

173
        return true;
174
    }
175
}

Sample Output

Your program output should something similar to the sample output below.

   0   1   2
  -----------
0 | - | - | - |
  -----------
1 | - | - | - |
  -----------
2 | - | - | - |
  -----------

Player X's turn.
Enter row (0-2): 1
Enter col (0-2): 1

   0   1   2
  -----------
0 | - | - | - |
  -----------
1 | - | X | - |
  -----------
2 | - | - | - |
  -----------

Player O's turn.
Enter row (0-2): 0
Enter col (0-2): 0

... (game continues) ...

Player X wins!

Reflection Questions

You may write your reflection answers as comments at the bottom of your code.

Why is a 2D array a good choice to represent the Tic-Tac-Toe board?
What two checks must be true for a move to be valid?
Explain (in words) how your checkWin method works.
Why is it helpful to move win checking and printing into separate methods?
What was the hardest bug you ran into while building the full game loop?

Submission

Submit your activity and reflection answers to the appropriate dropbox.