IT 114: Introduction to Java

IT 114: Introduction to Java
Class 40

Topics

New Material

Tic-Tak-Toe
Two Dimensional Arrays
The Tic-Tac-Toe Application
The Tic-Tac-Toe Board
Marking a Cell
Creating a User Move
Creating a Machine Move
Ending the Game
The player_wins Method
The game_is_tie Method

New Material

Tic-Tak-Toe

Tic-Tac-Toe is a paper and pencil game for children played on a 3 by 3 square
Two player take turns putting their mark on the page
The marks are either X or O
The goal is to get three in a row
Either across, down or diagonally

In the United Kingdom the game is called Noughts and Crosses
We will create a Java application to play this game

Two Dimensional Arrays

Tic-Tac-Toe is played on a 3 by 3 square
In order to create a Java version of the game we need something to represent this game board
We could represent this board as three arrays

Each of which has three elements

char [] row_1;
char [] row_2;
char [] row_3;

Using this approach we can write Java code to represent and print the game in the image above like this

public class ThreeRowBoard {
    public static void main (String[] args){
        char [] row_1 = {'O', 'X', 'X'};
        char [] row_2 = {'X', '0', 'O'};
        char [] row_3 = {'X', 'O', 'O'};

        System.out.println(row_1[0] + "|" + row_1[1] + "|" + row_1[2]);
        System.out.println("-----");
        System.out.println(row_2[0] + "|" + row_2[1] + "|" + row_2[2]);
        System.out.println("-----");
        System.out.println(row_3[0] + "|" + row_3[1] + "|" + row_3[2]);
    }
}

$ java ThreeRowBoard 
O|X|X
-----
X|0|O
-----
X|O|O

But if we can have an array of anything, why can't we have an array of arrays?
No reason at all
We can declare it like this
```
char [][] board = new char [3][3];
```
This is a two dimensional array
The first index determines the row
And the second determines the column within that row

We can use this to rewrite the code above

public class OneRowBoard {
    public static void main (String[] args){
        char [][] board = new char [3][3];

        board[0][0] = 'O';
        board[0][1] = 'X';
        board[0][2] = 'X';
        board[1][0] = 'X';
        board[1][1] = '0';
        board[1][2] = '0';
        board[2][0] = 'X';
        board[2][1] = '0';
        board[2][2] = '0';

        System.out.println(board[0][0] + "|" + board[0][1] + "|" + board[0][2]);
        System.out.println("-----");
        System.out.println(board[1][0] + "|" + board[1][1] + "|" + board[1][2]);
        System.out.println("-----");
        System.out.println(board[2][0] + "|" + board[2][1] + "|" + board[2][2]);
    }
}

[1007] glenn - ~/workspace/it114/resources_it114/code_it114/examples_it114
$ java OneRowBoard
O|X|X
-----
X|0|0
-----
X|0|0

The Tic-Tac-Toe Application

The application will consist of two classes
- TicTacToe
- TicTacToeBoard
TicTacToe has a main method and will be the driver
It will ask the user for a mover
And create a machine move
It will do this inside a while loop
That will stop when someone wins
Or there is a tie
TicTacToeBoard will have the array representing the board
A toString method used to print the board
A method to place a mark on the board
And a method to determine whether the game is over

The Tic-Tac-Toe Board

We need a Java class to represent the game board
The board will be a two dimensional array of characters
```
    private char [][] board;
```
We will also need a constructor which will create the board array
And set each cell to blank
In order to do this we need a nested for loop

The outer loop sets the row while the inner sets the column

    public TicTacToeBoard1 (){
        board = new char [3][3];
        for (int row = 0; row < 3; row++){
            for (int col =0; col < 3; col++){
                board[row][col] = ' ';
            }
        }
    }

We also need a toString method
It will print each row using the helper method row

And the horizontal line using horizontal

    public String toString (){
        String result = "";
        result += row(0);
        result += horizontal();
        result += row(1);
        result += horizontal();
        result += row(2);
        return result;
    }

    private String row(int row){
        return board[row][0] + "|" + board[row][1] + "|" + board[row][2] + "\n";
    }

    private String horizontal (){
        return "------\n";
    }

To test this TicTacToe.java will create a board

And print it

public class TicTacToe {

	private static TicTacToeBoard board = new TicTacToeBoard();

    public static void main (String[] args){
        boolean game_over = false;
        TicTacToeBoard board = new TicTacToeBoard();
        System.out.println(board);
    }
}

$ java TicTacToe
 | | 
------
 | | 
------
 | |

You can see the code for this version of TicTacToeBoard here

Marking a Cell

Now that we have a working board, we need a way to mark a cell
To do this we will define a mark_cell method in TicTacToeBoard that takes 3 parameters
- The row number
- The column number
- The mark to be placed in the cell
But we don't want to do this if any of the parameters are invalid
So we will create a method move_good to check the argument
There are 4 ways the parameters can be wrong
- The row number can be out of bounds
- The column number can be out of bounds
- The mark may not be a legal character
- The cell may already be occupied
If there is a problem with any of the values this method will throw an IllegalArgumentException

To make this work we need we need two constants

    private final char USER_MARK    = 'X';
    private final char MACHINE_MARK = 'O';

mark_cell simply calls mark_good

And changes the character in the cell if it can

    public void mark_cell(int row, int col, char mark) throws IllegalArgumentException {
        move_good(row, col, mark);
        board[row][col] = mark;
    }

move_good has more work to do

    private void move_good(int row, int col, char mark) throws IllegalArgumentException {
        if (row < 0 || row > 2){
            throw new IllegalArgumentException(row + " is not a valid row number");
        } else if (col < 0 || col > 2) {
            throw new IllegalArgumentException(col + " is not a valid column number");
        } else if (mark != USER_MARK && mark != MACHINE_MARK) {
            throw new IllegalArgumentException(mark + " is not a valid mark");
        } else if (board[row][col] != ' ') {
            throw new IllegalArgumentException("The square " + row + "," + col + " is occupied");
        }
    }

And here is

 
public class TicTacToe {
    public static void main (String[] args){
        TicTacToeBoard board = new TicTacToeBoard();
        System.out.println(board);
        board.mark_cell(1,1, 'X');
        System.out.println(board);
        try {
            board.mark_cell(3,1,'X');
        } catch (Exception e1) {
            System.out.println(e1.getMessage());
        }
        try {
            board.mark_cell(2,3,'X');
        } catch (Exception e2) {
            System.out.println(e2.getMessage());
        }
        try {
            board.mark_cell(2,2,'Z');
        } catch (Exception e2) {
            System.out.println(e2.getMessage());
        }
        try {
            board.mark_cell(1,1,'X');
        } catch (Exception e2) {
            System.out.println(e2.getMessage());
        }
    }
}

$ java TicTacToe 
 | | 
------
 | | 
------
 | | 

 | | 
------
 |X| 
------
 | | 

3 is not a valid row number
3 is not a valid column number
Z is not a valid mark
The square 1,1 is occupied

You can see the code for this version of TicTacToeBoard here

Creating a User Move

TicTacToe will interact with the user
So need need to create the method user_move
This method has to
- Keep looping until it gets a valid move
- Get the row and column number from the user
- Check that the row and column are valid
- If there is a problem, print an error message
- Make the move if the row and column values are good
To talk to the user we will need a Scanner object
So we need an import statement
```
import java.util.Scanner;
```
The main method will create a Scanner object
Then call user_move

Here is the new version of TicTacToe

import java.util.Scanner;

public class TicTacToe {
    private static TicTacToeBoard board = new TicTacToeBoard();

    public static void main (String[] args){
        Scanner console = new Scanner(System.in);
        System.out.println(board);
        user_move(console);
        System.out.println(board);
    }

    private static void user_move(Scanner console){
        boolean done = false;
        while (! done){
            System.out.print("Your move (row col): ");
            String reply = console.nextLine();
            String []fields = reply.split(" ");
            int row = Integer.parseInt(fields[0]);
            int col = Integer.parseInt(fields[1]);
            System.out.println(row + "," + col);
            try {
                board.mark_cell(row, col, 'X');
                done = true;
            } catch (Exception e) {
                System.out.println(e.getMessage());
            }
        }
    }
}


$ java TicTacToe
 | | 
------
 | | 
------
 | | 

Next move (row col): 3 3
3,3
3 is not a valid row number
Next move (row col): 2 3
2,3
3 is not a valid column number
Next move (row col): 1 1
1,1
 | | 
------
 |X| 
------
 | |

Creating a Machine Move

Now we need to create machine_move in TicTacToe
This method will be similar to user_move but with one critical difference
Instead of asking the user for a move
We will call rand_int

Here is a method copied from a Google search

    // copied from https://www.techiedelight.com/generate-random-integers-specified-range-java/
    public static int rand_int(int max, int min){
        return new Random().nextInt(max - min + 1) + min;
    }

If you copy something from the Internet in an assignment, you must say so in a comment in your code

Here is the code for machine_move

    private static void machine_move(){
        boolean done = false;
        while (! done){
            int row = rand_int(0, 2);
            int col = rand_int(0, 2);
            try {
                board.mark_cell(row, col, 'O');
                done = true;
            } catch (Exception e) {
                continue;
            }
        }
    }

Notice that we still have to catch the exception
But we don't print an error message
We simply continue looping

To the main method we add the following lines

        machine_move();
        System.out.println(board);

Now we we rung this we get

$ java TicTacToe.java 
 | | 
------
 | | 
------
 | | 

Your move (row col): 1 1
 | | 
------
 |X| 
------
 | | 

Machine move
 | | 
------
 |X| 
------
 |O|

You can see the code for this version of TicTacToe and TicTacToeBoard here and here

Ending the Game

The code to run the game will consist of a
Now we need to create a loop to run the game
We will use a while loop that will stop when the game is over
How do we know when the game is over?
When one of two things happens
- One play has filled a row, column or diagonal with it's mark
- All the cells have been taken
We need to write a method to test for each of these conditions inside TicTacToeBoard

The player_wins Method

There are three ways a player can win the game
- Fill a row with their mark
- Fill a column with their mark
- Fill a diagonal with their mark
The code will have to have three sections
One for each of the different ways to win
But before we do this we have to create the helper method cell_has_mark

Which simply returns true if a cell has a specific mark

    private boolean cell_has_mark(int row, int col, char mark) {
        return board[row][col] == mark;
    }

The section of code checking for row completion has a for that checks each column in the row

        // check rows
        for (int row = 0; row <= 2; row++){
            if (cell_has_mark(row, 0, mark) && cell_has_mark(row, 1, mark) && cell_has_mark(row, 2, mark)){
                return true;
            }
        }

The column check code is similar

        // check columns
        for (int col = 0; col <= 2; col++){
            if (cell_has_mark(0, col, mark) && cell_has_mark(1, col, mark) && cell_has_mark(2, col, mark)){
                return true;
            }
        }

The last test section checks each diagonal

        // check diagonals
        if (cell_has_mark(0, 0, mark) && cell_has_mark(1, 1, mark) && cell_has_mark(2, 2, mark)){
            return true;
        } else if (cell_has_mark(0, 2, mark) && cell_has_mark(1, 1, mark) && cell_has_mark(2, 0, mark)) {
            return true;
        }

If all the checks fail the method returns false

We need to app several times to check each possibility

$ java TicTacToe
 | | 
------
 | | 
------
 | | 

Next move (row col): 1 1
 | | 
------
 |X| 
------
 | | 

 |O| 
------
 |X| 
------
 | | 

Next move (row col): 0 1
The square 0,1 is occupied
Next move (row col): 1 0
 |O| 
------
X|X| 
------
 | | 

 |O| 
------
X|X| 
------
 | | 

Next move (row col): 1 2
 |O| 
------
X|X|X
------
 | | 

User wins!

$ java TicTacToe
 | | 
------
 | | 
------
 | | 

Next move (row col): 1 1
 | | 
------
 |X| 
------
 | | 

O| | 
------
 |X| 
------
 | | 

Next move (row col): 0 1
O|X| 
------
 |X| 
------
 | | 

O|X| 
------
O|X| 
------
 | | 

Next move (row col): 2 1
O|X| 
------
O|X| 
------
 |X| 

User wins!

$ java TicTacToe.java 
 | | 
------
 | | 
------
 | | 

Next move (row col): 1 1
 | | 
------
 |X| 
------
 | | 

 |O| 
------
 |X| 
------
 | | 

Next move (row col): 0 0
X|O| 
------
 |X| 
------
 | | 

X|O| 
------
O|X| 
------
 | | 

Next move (row col): 2 2
X|O| 
------
O|X| 
------
 | |X

User wins!

You can see the code for this version of TicTacToe and TicTacToeBoard here and here

The game_is_tie Method

When all squares are filled
And no player has completed a row, column or diagonal
The game ends in a tie
We need to create the game_is_tie method in TicTacToeBoard to check for this
The code is simple
We have a nested for loop that loop over each row and column
If any cell has a space we return false

If both for loop finish without finding a space, we return true

    public boolean game_is_tie() {
        for (int row = 0; row <= 2; row++){
            for (int col = 1; col <= 2; col++){
                if (board[row][col] == ' ') {
                    return false;
                }
            }
        }
        return true;
    }

Now we have to add code to call this method in the main method of TicTacToe
We don't have to check after each user move
Why?
Because there are 9 squares on the board
Which is an odd number
So we only have to check after an odd number move has been completed
But the user goes first, so we only have to check after the user has moved

Here is the code

public static void main (String[] args){
        Scanner console = new Scanner(System.in);
        System.out.println(board);
        while (true){
            user_move(console);
            System.out.println(board);
            if (board.player_wins('X')){
                System.out.println("User wins!");
                break;
            }
            if (board.game_is_tie()) {
                System.out.println("Game is over. No one wins.");
                break;
            }
            machine_move();
            System.out.println(board);
            if (board.player_wins('O')){
                System.out.println("Machine wins");
                break;
            }
        }
    }

You can see the final version of TicTacToe and TicTacToeBoard here and here