Introduction
In this tutorial, we will develop the Tic Tac Toe Game in Python using PyGame library. To add some excitement, we’ll implement the minimax algorithm to turn the computer into a formidable opponent. The computer will challenge us with its Artificial Intelligence, and unfortunately, the tough part is that it will be unbeatable; which means either the computer will win or the game will be tied.
So, let’s start this exciting journey step-by-step.
👉Read Also: AI Project: Six Degrees of Kevin Bacon in Python
What is the Tic Tac Toe Game?
Tic Tac Toe, also known as noughts and crosses, is a classic paper and pencil game that holds a special place in everyone’s childhood memories. In this game, two players, X and O, take turns on a three-by-three grid. Winning can be possible through nine positions, either horizontally, vertically, or diagonally. To win, you must strategically place your sign in a row within one of the three available locations.
We used to play this game with paper and pencil. Since we’re running through a Programming realm, we will create the same game using Python language for computer play.
What is the Minimax Algorithm?
The minimax algorithm is like the brainpower behind how computers play games against humans. It’s a clever strategy used in two-player games, especially in stuff like artificial intelligence and game theory.
Basically, it helps the computer figure out the best moves by looking at all the possible outcomes and trying to minimize any potential losses. You’ll find this algorithm working its magic in games like chess and tic-tac-toe, where two players are trying to outsmart each other.
What it does is systematically check out different moves and what might happen next, letting the computer make smart decisions and improve its gameplay against us humans.
Requirements and Installations
Before we get into the code, ensure that Python is installed on your computer. Also, make sure to have the PyGame library installed. You can install it using the following command:
pip install pygametictactoe.py
First, create a separate folder as “Tic-Tac-Toe” and declare a Python file named tictactoe.py within it. The tictactoe.py file contains all the essential functions and logic required to make the best move for each game state.
Import the libraries
Now start writing your code by importing these modules and initialising some variables.
import math
from random import choice
from math import inf as infinity
X = "X"
O = "O"
EMPTY = None
pl = X
first = TrueThe Initial State
The initial_state function returns a blank three-by-three grid where the program will store the input.
def initial_state():
"""
Returns starting state of the board.
"""
return [[EMPTY, EMPTY, EMPTY],
[EMPTY, EMPTY, EMPTY],
[EMPTY, EMPTY, EMPTY]]The Next Turn
The player function checks the current game state and tells us which player is up next – either ‘X’ or ‘O’. Usually, ‘X’ goes first, and then the turn rotates for each move until the terminal state comes.
def player(board):
"""
Returns player who has the next turn on the board.
"""
global pl
global first
NoOfX = 0
NoOfO = 0
if first is True:
first = False
return pl
else:
for i in range(0, len(board)):
for j in range(0, len(board[0])):
if board[i][j] == X:
NoOfX += 1
elif board[i][j] == O:
NoOfO += 1
if NoOfX > NoOfO:
pl = O
else:
pl = X
return plAll Possible Actions
The action function takes the board as input and returns a set of all possible moves available on the board. These potential actions are denoted as tuples (i, j), where ‘i’ represents the row number (1, 2, or 3), and ‘j’ corresponds to the column number (1, 2, or 3).
Possible actions are just the empty cells found on the given board.
def actions(board):
"""
Returns set of all possible actions (i, j) available on the board.
"""
places = []
if not terminal(board):
for x, row in enumerate(board):
for y, cell in enumerate(row):
if cell == None:
places.append([x, y])
return placesOutcome of Move
The result function takes the board and action as input and returns the resulting board after making a move, all without changing the original board.
def result(board, action):
"""
Returns the board that results from making move (i, j) on the board.
"""
b = board
x, y = action[0], action[1]
b[x][y] = player(board)
return bIdentify the Winner
The winner function takes the board as input and checks if there’s a winner and returns the winner if there is, otherwise, it returns None.
You can win by getting three of your signs in a row, either horizontally, vertically, or diagonally. Just make sure to place your sign in one of the three spots in a row.
def winner(board):
"""
Returns the winner of the game, if there is one.
"""
WinState = [
[board[0][0], board[0][1], board[0][2]],
[board[1][0], board[1][1], board[1][2]],
[board[2][0], board[2][1], board[2][2]],
[board[0][0], board[1][0], board[2][0]],
[board[0][1], board[1][1], board[2][1]],
[board[0][2], board[1][2], board[2][2]],
[board[0][0], board[1][1], board[2][2]],
[board[2][0], board[1][1], board[0][2]],
]
if [X, X, X] in WinState:
return X
elif [O, O, O] in WinState:
return O
else:
return NoneGame Over Check
The terminal function takes the board as input and checks the current state of the board. If the current state reaches the final state then it returns True, otherwise, it returns False.
def terminal(board):
"""
Returns True if the game is over, False otherwise.
"""
if (winner(board) is not None) or (not any(EMPTY in sublist for
sublist in board) and winner(board) is None):
return True
else:
return FalseEvaluate Game Results
The utility function returns 1 when ‘X’ wins, -1 when ‘O’ wins, and 0 (for a tie) only if the current board state is the final state.
def utility(board):
"""
Returns 1 if X has won the game, -1 if O has won, and 0 otherwise.
"""
if terminal(board):
if winner(board) == X:
score = 1
elif winner(board) == O:
score = -1
else:
score = 0
return scoreApply Minimax Algorithm
It is the most logical part of our program. The minimax function takes the board and returns the most optimal move for the computer. The Ai_Turn function looks at possible moves, and the player turns and evaluates the utility of different board states.
# AI Turn Function
def AI_Turn(board, length, pl):
if pl == X:
best = [-1, -1, -infinity]
elif pl == O:
best = [-1, -1, +infinity]
if length == 0 or terminal(board):
score = utility(board)
return [-1, -1, score]
for cell in actions(board):
x, y = cell[0], cell[1]
board[x][y] = pl
score = AI_Turn(board, length - 1, player(board))
board[x][y] = EMPTY
score[0], score[1] = x, y
if pl == X:
if score[2] > best[2]:
best = score # Max value
else:
if score[2] < best[2]:
best = score # Min value
return best
def minimax(board):
"""
Returns the optimal action for the current player on the board.
"""
length = len(actions(board))
if length == 0 or terminal(board):
return None
if length == 9:
x = choice([0, 1, 2])
y = choice([0, 1, 2])
else:
move = AI_Turn(board, length, pl)
x, y = move[0], move[1]
return [x, y]runner.py
Now, we’re going to make a program called runner.py that uses the Pygame library. It’ll create a cool-looking game board with graphics and take care of everything that happens while you play the game.
Download the Font
Download the font file used in the program and place it in the project folder (Make sure you unzip the downloaded file to get the “OpenSans-Regular.ttf” file).
import pygame
import sys
import time
import tictactoe as ttt
pygame.init()
size = width, height = 600, 400
# Colors
black = (0, 0, 0)
white = (255, 255, 255)
screen = pygame.display.set_mode(size)
mediumFont = pygame.font.Font("OpenSans-Regular.ttf", 28)
largeFont = pygame.font.Font("OpenSans-Regular.ttf", 40)
moveFont = pygame.font.Font("OpenSans-Regular.ttf", 60)
user = None
board = ttt.initial_state()
ai_turn = False
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
screen.fill(black)
# Let the user choose a player.
if user is None:
# Draw title
title = largeFont.render("Tic-Tac-Toe", True, white)
titleRect = title.get_rect()
titleRect.center = ((width / 2), 50)
screen.blit(title, titleRect)
# Draw buttons
playXButton = pygame.Rect((width / 8), (height / 2), width / 4, 50)
playX = mediumFont.render("Play as X", True, black)
playXRect = playX.get_rect()
playXRect.center = playXButton.center
pygame.draw.rect(screen, white, playXButton)
screen.blit(playX, playXRect)
playOButton = pygame.Rect(5 * (width / 8), (height / 2), width / 4, 50)
playO = mediumFont.render("Play as O", True, black)
playORect = playO.get_rect()
playORect.center = playOButton.center
pygame.draw.rect(screen, white, playOButton)
screen.blit(playO, playORect)
# Check if button is clicked
click, _, _ = pygame.mouse.get_pressed()
if click == 1:
mouse = pygame.mouse.get_pos()
if playXButton.collidepoint(mouse):
time.sleep(0.2)
user = ttt.X
elif playOButton.collidepoint(mouse):
time.sleep(0.2)
user = ttt.O
else:
# Draw game board
tile_size = 80
tile_origin = (width / 2 - (1.5 * tile_size),
height / 2 - (1.5 * tile_size))
tiles = []
for i in range(3):
row = []
for j in range(3):
rect = pygame.Rect(
tile_origin[0] + j * tile_size,
tile_origin[1] + i * tile_size,
tile_size, tile_size
)
pygame.draw.rect(screen, white, rect, 3)
if board[i][j] != ttt.EMPTY:
move = moveFont.render(board[i][j], True, white)
moveRect = move.get_rect()
moveRect.center = rect.center
screen.blit(move, moveRect)
row.append(rect)
tiles.append(row)
game_over = ttt.terminal(board) # At first Result should be False
player = ttt.player(board) # At first it should be the X
# Show title
if game_over:
winner = ttt.winner(board)
if winner is None:
title = f"Game Over: Tie."
else:
title = f"Game Over: {winner} wins."
elif user == player:
title = f"Your turn {user}"
else:
title = f"Computer thinking..."
title = largeFont.render(title, True, white)
titleRect = title.get_rect()
titleRect.center = ((width / 2), 30)
screen.blit(title, titleRect)
# Check for AI move
if user != player and not game_over:
if ai_turn:
time.sleep(0.5)
move = ttt.minimax(board)
board = ttt.result(board, move)
ai_turn = False
else:
ai_turn = True
# Check for a user move
click, _, _ = pygame.mouse.get_pressed()
if click == 1 and user == player and not game_over:
mouse = pygame.mouse.get_pos()
for i in range(3):
for j in range(3):
if (board[i][j] == ttt.EMPTY and tiles[i][j].collidepoint(mouse)):
board = ttt.result(board, [i, j]) # (i, j)->[i, j]
if game_over:
againButton = pygame.Rect(width / 3, height - 65, width / 3, 50)
again = mediumFont.render("Play Again", True, black)
againRect = again.get_rect()
againRect.center = againButton.center
pygame.draw.rect(screen, white, againButton)
screen.blit(again, againRect)
click, _, _ = pygame.mouse.get_pressed()
if click == 1:
mouse = pygame.mouse.get_pos()
if againButton.collidepoint(mouse):
time.sleep(0.2)
user = None
board = ttt.initial_state()
ai_turn = False
pygame.display.flip()In the above program, the Pygame library is utilized for graphical representation and event handling. Here, we set up the game window and let the player choose ‘X’ or ‘O’. The game takes turns between the player and the computer AI, which uses the minimax algorithm for the most optimal moves.
The program does more too! It draws the game board, shows how the game is going, and lets you play again when it’s finished.
Output of the Tic Tac Toe Game
Summary
In this article, we bring back the good old memories of the Tic Tac Toe game but with a modern twist. Here we create the Tic Tac Toe Game in Python using the PyGame library. What’s exciting is that here the computer is our super smart opponent. In this game, we make the computer unbeatable using Artificial Intelligence, and the logic is implemented using the minimax algorithm.
We’ve set up two Python files, tictactoe.py, and runner.py, for this project. In tictactoe.py, we’ve coded the essential functions for the game logic. Meanwhile, runner.py takes care of the game’s functionality, creating a visually pleasing game board, showing the game status, and ensuring a smooth user experience.
In a nutshell, it’s a mix of childhood nostalgia and coding fun, making Tic Tac Toe way more interesting with a genius computer opponent. Perfect for Python enthusiasts!
For any queries or feedback, please feel free to leave your comment below. Want more projects like this? Visit our dedicated Python Projects page, packed with exciting ideas. Here are a few examples to spark your interest:
- AI Project: Six Degrees of Kevin Bacon in Python
- Create a Sentiment Analysis Project in Python using NLP
- Build a Face Recognition Login System using Python
- Contact Management System Project in Python
Happy Gaming!
