Tic Tac Toe Minimax Algorithm | Winner , Winner Chicken Dinner

In two previous posts, I presented code to teach R to play the trivial game of Tic Tac Toe. I thought this was an unbeatable algorithm. Alas, a comment from Alberto shattered my pride as he was able to beat my code.

The reason for the demise of my code was that I didn’t implement a full minimax algorithm, but instead looked only two moves ahead. I thought the common strategy rules (start in the centre and occupy the corners) would make the program unbeatable. When I simulated the game by instructing the computer to play against itself, Alberto’s strategy never arose because the code forces the centre field. Alberto’s code shows that you need to look at least three moves ahead for a perfect game. He has been so kind to share his code and gave me permission to publish it.

Alberto recreated two functions, for completeness I have added the complete working code that merges his improvements with my earlier work. The first two functions are identical to the previous post. These functions draw the game board and process the human player’s move by waiting for a mouse click.

```draw.board <- function(game) {
xo <- c("X", " ", "O") # Symbols
par(mar = rep(1,4))
plot.new()
plot.window(xlim = c(0,30), ylim = c(0,30))
abline(h = c(10, 20), col = "darkgrey", lwd = 4)
abline(v = c(10, 20), col = "darkgrey", lwd = 4)
text(rep(c(5, 15, 25), 3), c(rep(25, 3), rep(15,3), rep(5, 3)), xo[game + 2], cex = 4)
square <- t(matrix(game, nrow = 3))
hor <- abs(rowSums(square))
if (any(hor == 3))
hor <- (4 - which(hor == 3)) * 10 - 5
else
hor <- 0
ver <- abs(colSums(square))
if (any(ver == 3))
ver <- which(ver == 3) * 10 - 5
else
ver <- 0
diag1 <- sum(diag(square))
diag2 <- sum(diag(t(apply(square, 2, rev))))
# Draw winning lines
if (all(hor &gt; 0))
for (i in hor) lines(c(0, 30), rep(i, 2), lwd = 10, col = "red")
if (all(ver &gt; 0))
for (i in ver) lines(rep(i, 2), c(0, 30), lwd = 10, col = "red")
if (abs(diag1) == 3)
lines(c(2, 28), c(28, 2), lwd = 10, col = "red")
if (abs(diag2) == 3)
lines(c(2, 28), c(2, 28), lwd = 10, col = "red")
}

move.human <- function(game) {
text(4, 0, "Click on screen to move", col = "grey", cex = .7)
empty <- which(game == 0)
move <- 0
while (!move %in% empty) {
coords <- locator(n = 1) # add lines
coords\$x <- floor(abs(coords\$x) / 10) + 1
coords\$y <- floor(abs(coords\$y) / 10) + 1
move <- coords\$x + 3 * (3 - coords\$y)
}
return (move)
}
```

Alberto rewrote the functions that analyse the board and determine the move of the computer. The ganador (Spanish for winning) function assesses the board condition by assigning -10 or + 10 for a winning game and 0 for any other situation.

```ganador <- function(juego, player) {
game <- matrix(juego, nrow = 3, byrow = T)
hor <- rowSums(game)
ver <- colSums(game)
diag <- c(sum(diag(game)), sum(diag(apply(game, 1, rev))))
if (-3 %in% c(hor, ver, diag))
return(-10)
if (3 %in% c(hor, ver, diag))
return(10)
else
return(0)
}
```

Tic Tac Toe Minimax

The next function is the Tic Tac Toe minimax algorithm. If the computer starts then the first move ($9!= 362880$ options to assess) takes a little while. The commented lines can be used to force a corner and make the games faster by forcing a random corner.

The minimax function returns a list with the move and its valuation through the ganador function. The function works recursively until it has filled the board and retains the best scoring move using the minimax method. To avoid the computer always playing the same move in the same situation random variables are added.

```minimax <- function(juego, player) {
free <- which(juego == 0)
if(length(free) == 1) {
juego[free] <- player
return(list(move = free, U = ganador(juego, player)))
}
poss.results <- rep(0, 9)
for(i in free) {
game <- juego
game[i] <- player
poss.results[i] <- ganador(game, player)
}
mm <- ifelse(player == -1, "which.min", "which.max")
if(any(poss.results == (player * 10))) {
move <- do.call(mm, list(poss.results))
return(list(move = move, U = poss.results[move]))
}
for(i in free) {
game <- juego
game[i] <- player
poss.results[i] <- minimax(game, -player)\$U
}
random <- runif(9, 0, 0.1)
poss.results[-free] <- 100 * -player
poss.results <- poss.results + (player * random)
move <- do.call(mm, list(poss.results))
return(list(move = move, U = poss.results[move]))
}
```

This final function stitches everything together and lets you play the game. Simply paste all functions in your R console and run them to play a game. The tic.tac.toe function can take two parameters, “human” and/or “computer”. The order of the parameters determines who starts the game.

```tic.tac.toe <- function(player1 = "human", player2 = "computer") {
game <- rep(0, 9) # Empty board
winner <- FALSE # Define winner
player <- 1 # First player
players <- c(player1, player2)
draw.board(game)
while (0 %in% game &amp; !winner) { # Keep playing until win or full board
if (players[(player + 3) %% 3] == "human") # Human player
move <- move.human(game)
else { # Computer player
move <- minimax(game, player)
move <- move\$move
}
game[move] <- player # Change board
draw.board(game)
winner <- max(eval.game(game, 1), abs(eval.game(game, -1))) == 6 # Winner, winner, chicken dinner?
player <- -player # Change player
}
}
tic.tac.toe()
```

This is my last word on Tic Tac Toe but now that the minimax conundrum is solved I could start working on other similar games such as Connect Four, Draughts or even the royal game of Chess. You can download the latest version of this code on GitHub.

5 thoughts on “Tic Tac Toe Minimax Algorithm | Winner , Winner Chicken Dinner”

1. You fooled the system, that’s awesome. So proud of you Alberto, my best wishes for y’all.

2. Thank you for this! I like R and I have been thinking about tic tac toe simulations as well.

One comment about the number of possible games: you can reduce this number by roughly a factor of 5 realizing that there are really only three opening moves (corner, edge, center) not 9. After that:

• If you play in the corner then there are only five second moves (neighboring edge, non-neighboring edge, opposite corner, non-opposite corner, center). You’re recognizing that the board is symmetrical along the diagonal containing the corner played in the first turn.
• Same thing if you If you play on an edge spot — only five second moves (neighboring corner, non-neighboring corner, opposite edge, non-opposite edge, center). You’re recognizing that the board is symmetrical along the row or column containing that edge spot played in the first turn.
• Technically, if you play in the center, there are only two second moves (corner, edge) b/c you have radial symmetry. And I’m guessing there are only four third moves following the logic above.
1. Beste Buurmans,

I did consider reducing the options by adding restrictions. The reason I did not do so is because I like the code to figure everything out from scratch, without any human strategic knowledge.

If you create your version, then please share it.

Peter

This site uses Akismet to reduce spam. Learn how your comment data is processed.