LESSON 404 OF 404 · PROJECTS: OBJECT-ORIENTED

Tic Tac Toe - A Two-Player Game Class in Go

Practice

Build a TicTacToe class for two players, X and O, on a 3 by 3 board. One object is one game: it remembers the board and whose turn it is, lets the players take turns, and tells who has won.

The board: rows and columns are numbered 0, 1 and 2. Cell (0, 0) is the top-left corner, (0, 2) the top-right, (2, 0) the bottom-left and (2, 2) the bottom-right. A cell holds 'X', 'O' or '.' when it is still empty.

Build:

A new game. Go has no constructors, so func newTicTacToe() *TicTacToe returns a new game: the struct has a board [3][3]rune filled with '.' by two nested loops and a player rune set to 'X'. All nine cells are empty and X moves first.
func (game *TicTacToe) move(row int, col int) plays one turn at the given row and column (always between 0 and 2, so you do not need to check the range).
- If the cell is not empty, ignore the call: nothing changes and it is still the same player's turn.
- Otherwise put the current player's mark in the cell, then give the turn to the other player (X becomes O, O becomes X).
func (game TicTacToe) winner() rune returns the winner as a rune: 'X', 'O' or '.'.
- A player wins by having the same mark in all three cells of a row, a column, or one of the two diagonals ((0,0), (1,1), (2,2) and (0,2), (1,1), (2,0)). Three empty cells in a line are not a win.
- If nobody has three in a row, return '.'. That covers a game still in progress, an empty board and a draw.

You start with this code, which plays six games and prints the result of each one:

func mainFunction() {
	game := newTicTacToe()
	game.move(0, 0)
	game.move(1, 0)
	game.move(0, 1)
	game.move(1, 1)
	game.move(0, 2)
	fmt.Printf("%c wins!\n", game.winner())
	game = newTicTacToe()
	game.move(0, 0)
	game.move(0, 1)
	game.move(0, 0)
	game.move(1, 0)
	game.move(1, 1)
	game.move(2, 2)
	game.move(2, 1)
	fmt.Printf("%c wins!\n", game.winner())
	game = newTicTacToe()
	game.move(0, 0)
	game.move(0, 1)
	game.move(1, 1)
	game.move(0, 2)
	game.move(2, 2)
	fmt.Printf("%c wins!\n", game.winner())
	game = newTicTacToe()
	game.move(0, 2)
	game.move(0, 0)
	game.move(1, 1)
	game.move(0, 1)
	game.move(2, 0)
	fmt.Printf("%c wins!\n", game.winner())
	game = newTicTacToe()
	game.move(0, 0)
	game.move(0, 1)
	game.move(0, 2)
	game.move(1, 1)
	game.move(1, 0)
	game.move(1, 2)
	game.move(2, 1)
	game.move(2, 0)
	game.move(2, 2)
	fmt.Printf("No winner: %c\n", game.winner())
	game = newTicTacToe()
	fmt.Printf("No winner: %c\n", game.winner())
}

Games played: X fills the top row; then a game where X tries to play on a cell that is already taken (ignored, and still X's turn) and O wins the middle column; X on the main diagonal; X on the other diagonal; a full board with no three in a row; and a brand-new game.

Expected output:

X wins!
O wins!
X wins!
X wins!
No winner: .
No winner: .

There are eight winning lines: three rows, three columns and two diagonals. A loop over i from 0 to 2 can check row i and column i together; the two diagonals come after the loop. Skip a line whose first cell is empty.

Check for a taken cell first and leave the move method before touching the board or the turn. Only a successful move passes the turn to the other player.

type TicTacToe struct {
	board  [3][3]rune
	player rune
}

func newTicTacToe() *TicTacToe {
	game := &TicTacToe{player: 'X'}
	for row := range game.board {
		for col := range game.board[row] {
			game.board[row][col] = '.'
		}
	}
	return game
}

func (game *TicTacToe) move(row int, col int) {
	if game.board[row][col] != '.' {
		return
	}
	game.board[row][col] = game.player
	if game.player == 'X' {
		game.player = 'O'
	} else {
		game.player = 'X'
	}
}

func (game TicTacToe) winner() rune {
	for i := 0; i < 3; i++ {
		if game.board[i][0] != '.' && game.board[i][0] == game.board[i][1] && game.board[i][1] == game.board[i][2] {
			return game.board[i][0]
		}
		if game.board[0][i] != '.' && game.board[0][i] == game.board[1][i] && game.board[1][i] == game.board[2][i] {
			return game.board[0][i]
		}
	}
	if game.board[0][0] != '.' && game.board[0][0] == game.board[1][1] && game.board[1][1] == game.board[2][2] {
		return game.board[0][0]
	}
	if game.board[0][2] != '.' && game.board[0][2] == game.board[1][1] && game.board[1][1] == game.board[2][0] {
		return game.board[0][2]
	}
	return '.'
}

STEP 1 OF 21

Guided

Ctrl + Enter to check

Tic Tac Toe - A Two-Player Game Class in Go

Tic Tac Toe in Go