Project Overview

Tic Tac Toe on a 16×16 LED Matrix 

Embark on an Exciting Journey with Tic Tac Toe on a 16×16 LED Matrix Display and experience the timeless game of Tic Tac Toe like never before with our innovative project that combines classic gameplay with cutting-edge technology. Utilizing the BrainPad Pulse microcomputer and a vibrant 16×16 LED matrix, this project promises hours of immersive entertainment for players of all ages.

How It Works

The project serves as a platform to enhance Python proficiency, showcasing its seamless integration with LEDs. Upon initiation, the LED matrix initializes the gaming arena, with a dynamic square pointer navigating automatically by coloring square borders. Pressing button A on the BrainPad Pulse selects the square indicated by the pointer, marking it with an ‘X’. The AI Bot strategically places its ‘O’, engaging players until the bot wins or a draw is achieved, note: you won’t win against the AI bot.

Hardware Requirements

To bring this project to life, you’ll need the following hardware components:

  • BrainPad Pulse Microcomputer: The heart of the project, providing computational power and control capabilities.
  • 16×16 LED Matrix (WS2812B Digital Flexible LED): A dazzling display that serves as the game board, offering vibrant visuals and dynamic animations.
  • BrainTronics Kit or 3 Alligator Clips to Dupont Wire: Essential accessories for easily and reliably connecting the microcomputer to the LED matrix.

Software Requirements

Install DUELink Python Library: Begin by installing the DUELink Python library, a versatile tool that facilitates seamless control of the microcomputer’s GPIO pins and NeoPixels. Execute the command pip install DUELink in your terminal to install the library and its dependencies effortlessly.

pip install DUELink 

Code Overview

Let’s break down the Python code and provide a comprehensive explanation for each method by comments: 

import time

# Define colors using hexadecimal values
redColor = 0xff0000
greenColor = 0x00ff00
blueColor = 0x0000ff


# Define the Game class
class Game:
    def __init__(self, bb, neoPin, neoCount):
        # Initialize game parameters
        self.bb = bb
        self.neoPin = neoPin
        self.neoCount = neoCount
        self.board = [[]]  # Initialize an empty board
        self.player_moves = {"x": [], "o": []}  # Store moves made by each player
        # Define square configurations for the tic-tac-toe grid
        self.SQUARES = {
            1: [(177, 205, 211, 235, 238, 210, 204, 180), (178, 179, 206, 209, 237, 236, 212, 203)],
            2: [(110, 114, 140, 148, 145, 141, 115, 107), (109, 108, 113, 142, 146, 147, 139, 116)],
            3: [(17, 45, 51, 75, 78, 50, 44, 20), (18, 19, 46, 49, 77, 76, 52, 43)],
            4: [(182, 200, 216, 230, 233, 215, 199, 185), (183, 184, 201, 214, 232, 231, 217, 198)],
            5: [(105, 119, 135, 153, 150, 136, 120, 102), (104, 103, 118, 137, 151, 152, 134, 121)],
            6: [(22, 40, 56, 70, 73, 55, 39, 25), (23, 24, 41, 54, 72, 71, 57, 38)],
            7: [(187, 195, 221, 225, 228, 220, 194, 190), (188, 189, 196, 219, 227, 226, 222, 193)],
            8: [(100, 124, 130, 158, 155, 131, 125, 97), (99, 98, 123, 132, 156, 157, 129, 126)],
            9: [(27, 35, 61, 65, 68, 60, 34, 30), (28, 29, 36, 59, 67, 66, 62, 33)]
        }
        # Define square borders for highlighting
        self.SQUARE_BORDERS = {
            1: [170, 171, 172, 173, 174, 175, 176, 240, 241, 242, 243, 244, 245, 176, 207, 208, 239, 181, 202, 213,
                234],
            2: [80, 81, 82, 83, 84, 85, 170, 171, 172, 173, 174, 175, 111, 112, 143, 144, 106, 117, 138, 149],
            3: [10, 11, 12, 13, 14, 15, 80, 81, 82, 83, 84, 85, 16, 47, 48, 79, 21, 42, 53, 74],
            4: [165, 166, 167, 168, 169, 170, 245, 246, 247, 248, 249, 250, 181, 202, 213, 234, 186, 197, 218, 229],
            5: [85, 86, 87, 88, 89, 90, 165, 166, 167, 168, 169, 170, 106, 117, 138, 149, 101, 122, 133, 154],
            6: [5, 6, 7, 8, 9, 10, 85, 86, 87, 88, 89, 90, 21, 42, 53, 74, 26, 37, 58, 69],
            7: [160, 161, 162, 163, 164, 165, 250, 251, 252, 253, 254, 255, 186, 197, 218, 229, 191, 192, 223, 224],
            8: [90, 91, 92, 93, 94, 95, 160, 161, 162, 163, 164, 165, 101, 122, 133, 154, 96, 127, 128, 159],
            9: [0, 1, 2, 3, 4, 5, 90, 91, 92, 93, 94, 95, 26, 37, 58, 69, 31, 32, 63, 64]
        }

    # Method to check if a player has won
    def check_win(self, player):
        # Define winning combinations
        winning_combinations = [
            [1, 2, 3], [4, 5, 6], [7, 8, 9],  # Rows
            [1, 4, 7], [2, 5, 8], [3, 6, 9],  # Columns
            [1, 5, 9], [3, 5, 7]  # Diagonals
        ]
        # Check if any winning combination is present in player's moves
        for combination in winning_combinations:
            if all(square in self.player_moves[player] for square in combination):
                return True, combination  # Return True if winning combination found
        return False, None  # Otherwise, return False

    # Method to convert cell number to row and column
    def cell_number_to_row_col(self, cell_number):
        row = (cell_number - 1) // 3
        col = (cell_number - 1) % 3
        return row, col

    # Method to highlight square borders
    def set_square_borders(self, square_num, color):
        borders = self.SQUARE_BORDERS.get(square_num)
        if borders:
            for val in borders:
                self.bb.Neo.SetColor(val, color)

    # Method to set square item (X or O) and color
    def set_square(self, square_num, item, color):
        square = self.SQUARES.get(square_num)
        if square:
            for index, val in enumerate(square[0 if item == 'x' else 1]):
                self.bb.Neo.SetColor(val, color)

    # Method to draw external borders of the grid
    def draw_external_borders(self, color):
        for z in range(0, 16):
            self.bb.Neo.SetColor(z, color)
            self.bb.Neo.SetColor(z + 240, color)

    # Method to draw horizontal rows of the grid
    def draw_rows(self, color):
        for z in range(0, 16, 5):
            for x in range(0, 256, 32):
                self.bb.Neo.SetColor(x + z, color)
                self.bb.Neo.SetColor(x + 31 - z, color)

    # Method to draw vertical columns of the grid
    def draw_columns(self, color):
        for z in range(80, 96):
            self.bb.Neo.SetColor(z, color)
        for z in range(160, 176):
            self.bb.Neo.SetColor(z, color)

    # Method to highlight winning lights
    def winning_lights(self, item, color, combination):
        # Highlight the winning combination
        item = item
        color = color
        toggle_time = 0.05
        toggle_count = 20
        self.draw_external_borders(blueColor)
        self.draw_rows(blueColor)
        self.draw_columns(blueColor)
        self.bb.Neo.Show(self.neoPin, self.neoCount)
        # Toggle the colors for visual effect
        for i in range(toggle_count):
            self.set_square(combination[0], item, 0x000000)
            self.set_square(combination[1], item, 0x000000)
            self.set_square(combination[2], item, 0x000000)
            self.bb.Neo.Show(self.neoPin, self.neoCount)
            time.sleep(toggle_time)
            self.set_square(combination[0], item, color)
            self.set_square(combination[1], item, color)
            self.set_square(combination[2], item, color)
            self.bb.Neo.Show(self.neoPin, self.neoCount)
            time.sleep(toggle_time)

    # Method to color square borders
    def coloring_square_borders(self, color, square_number):
        self.draw_external_borders(blueColor)
        self.draw_rows(blueColor)
        self.draw_columns(blueColor)
        self.bb.Neo.Show(self.neoPin, self.neoCount)
        for i in range(1, 10):
            if square_number == str(i):
                self.set_square_borders(i, color)
                self.bb.Neo.Show(self.neoPin, self.neoCount)
                break

    # Method to print the current state of the board in console and on microcomputer LCD screen
    def print_board(self):
        self.bb.Display.Clear(0)
        x = 10
        y = 10
        print("_______________________________")
        for i in range(3):
            row = [str(i * 3 + j + 1) if cell == ' ' else cell for j, cell in enumerate(self.board[i])]
            print(" | ".join(row))
            self.bb.Display.DrawTextScale(" | ".join(row), 1, x, y, 2, 1)
            if i < 2:
                print("-" * 9)
                self.bb.Display.DrawTextScale("-" * 9, 1, x, y + 10, 2, 1)
            y += 20
        self.bb.Display.Show()

    # Method to check if the game is over
    def is_game_over(self):
        # Check rows, columns, and diagonals for a win or a tie
        for row in self.board:
            if row.count(row[0]) == 3 and row[0] != ' ':
                return True

        for col in range(3):
            check = []
            for row in self.board:
                check.append(row[col])
            if check.count(check[0]) == 3 and check[0] != ' ':
                return True

        if self.board[0][0] == self.board[1][1] == self.board[2][2] != ' ':
            return True

        if self.board[0][2] == self.board[1][1] == self.board[2][0] != ' ':
            return True

        # Check for tie
        for row in self.board:
            for val in row:
                if val == ' ':
                    return False
        return True

    # Method to evaluate the current state of the game
    def evaluate(self):
        # Check for winning conditions
        for row in self.board:
            if row.count('O') == 3:
                return 1    # Player O wins
            if row.count('X') == 3:
                return -1   # Player X wins

        for col in range(3):
            check = []
            for row in self.board:
                check.append(row[col])
            if check.count('O') == 3:
                return 1    # Player O wins
            if check.count('X') == 3:
                return -1   # Player X wins

        if self.board[0][0] == self.board[1][1] == self.board[2][2] == 'O':
            return 1    # Player O wins
        if self.board[0][0] == self.board[1][1] == self.board[2][2] == 'X':
            return -1   # Player X wins

        if self.board[0][2] == self.board[1][1] == self.board[2][0] == 'O':
            return 1    # Player O wins
        if self.board[0][2] == self.board[1][1] == self.board[2][0] == 'X':
            return -1   # Player O wins

        return 0    # It's a tie

    # Method to implement the minimax algorithm for AI move selection
    def minimax(self, depth, is_maximizing, alpha, beta):
        if self.is_game_over():
            return self.evaluate()

        if is_maximizing:
            max_eval = -float('inf')
            for i in range(3):
                for j in range(3):
                    if self.board[i][j] == ' ':
                        self.board[i][j] = 'O'
                        evaluation = self.minimax(depth + 1, False, alpha, beta)
                        self.board[i][j] = ' '
                        max_eval = max(max_eval, evaluation)
                        alpha = max(alpha, evaluation)
                        if beta <= alpha:
                            break
            return max_eval
        else:
            min_eval = float('inf')
            for i in range(3):
                for j in range(3):
                    if self.board[i][j] == ' ':
                        self.board[i][j] = 'X'
                        evaluation = self.minimax(depth + 1, True, alpha, beta)
                        self.board[i][j] = ' '
                        min_eval = min(min_eval, evaluation)
                        beta = min(beta, evaluation)
                        if beta <= alpha:
                            break
            return min_eval

    # Method for AI to make a move using the minimax algorithm
    def bot_move(self):
        best_eval = -float('inf')
        best_move = (-1, -1)

        for i in range(3):
            for j in range(3):
                if self.board[i][j] == ' ':
                    self.board[i][j] = 'O'
                    evaluation = self.minimax(0, False, -float('inf'), float('inf'))
                    self.board[i][j] = ' '
                    if evaluation > best_eval:
                        best_eval = evaluation
                        best_move = (i, j)

        return best_move

    # Method to run the game
    def do_game(self):
        # Initialize the game state
        self.board = [[' ' for _ in range(3)] for _ in range(3)]
        self.bb.Display.Clear(0)
        self.draw_external_borders(blueColor)
        self.draw_rows(blueColor)
        self.draw_columns(blueColor)
        self.bb.Neo.Show(self.neoPin, self.neoCount)
        self.print_board()
        arena = ["1", "2", "3", "4", "5", "6", "7", "8", "9"]  # Available squares
        moves_made = 0  # Track number of moves
        self.bb.Button.Enable('a', True)  # Enable button 'a' for user input
        while len(arena) > 0:  # Continue until all squares are filled
            while True:
                index = 0
                while True:
                    self.coloring_square_borders(redColor, arena[index])  # Highlight square
                    if self.bb.Button.JustPressed('a'):  # Check for button press
                        square = arena[index - 1]  # Get selected square
                        row, col = self.cell_number_to_row_col(int(square))
                        self.board[row][col] = 'X'  # Set player's move
                        break
                    index = (index + 1) % len(arena)  # Move to next square
                    time.sleep(0.5)  # Delay for visual effect
                if square in arena:  # Check if selected square is available
                    moves_made += 1
                    for i in range(1, 10):
                        if square == str(i):
                            self.set_square(i, "x", redColor)  # Mark player's move on the board
                            self.player_moves["x"].append(i)  # Record player's move
                            break
                    break
                else:
                    print("try another square")  # Prompt user to try another square
                    continue
            self.bb.Neo.Show(self.neoPin, self.neoCount)  # Update NeoPixel display
            arena.remove(square)  # Remove selected square from available squares
            self.print_board()  # Print the updated board
            time.sleep(1)  # Delay for visual effect

            x_has_won, x_winning_combination = self.check_win("x")  # Check if player X has won
            y_has_won, y_winning_combination = self.check_win("o")  # Check if player O has won

            if x_has_won:  # If player X has won
                print("Player X wins with combination:", x_winning_combination)  # Print winning message
                self.bb.System.Println("Player X wins with")
                self.bb.System.Println(f"combination:{x_winning_combination}")  # Print winning combination
                self.winning_lights("x", redColor, x_winning_combination)  # Highlight winning combination
                self.bb.Neo.Clear()  # Clear NeoPixel display
                break
            if y_has_won:  # If player O has won
                print("Player Y wins with combination:", y_winning_combination)  # Print winning message
                self.bb.System.Println("Player Y wins with")
                self.bb.System.Println(f"combination:{y_winning_combination}")  # Print winning combination
                self.winning_lights("o", greenColor, y_winning_combination)  # Highlight winning combination
                self.bb.Neo.Clear()  # Clear NeoPixel display
                break
            if moves_made == 9:  # If all squares are filled (tie)
                print("It's a tie!")  # Print tie message
                self.bb.System.Println("It's a tie!")  # Print tie message
                self.bb.Neo.Clear()  # Clear NeoPixel display
                break
            if len(arena) > 0:  # If there are available squares
                bot_row, bot_col = self.bot_move()  # Get AI move
                self.board[bot_row][bot_col] = 'O'  # Set AI move on the board
                square = str(bot_row * 3 + bot_col + 1)  # Get square number
                time.sleep(0.5)  # Delay for visual effect
            if len(arena) > 0:  # If there are available squares
                moves_made += 1
                for i in range(1, 10):
                    if square == str(i):
                        self.set_square(i, "o", greenColor)  # Mark AI's move on the board
                        self.player_moves["o"].append(i)  # Record AI's move
                        break
                else:
                    print("try another square")  # Prompt user to try another square

                self.bb.Neo.Show(self.neoPin, self.neoCount)  # Update NeoPixel display
                x_has_won, x_winning_combination = self.check_win("x")  # Check if player X has won
                y_has_won, y_winning_combination = self.check_win("o")  # Check if player O has won
                self.print_board()  # Print the updated board
                if x_has_won:  # If player X has won
                    print("Player X wins with combination:", x_winning_combination)  # Print winning message
                    self.bb.System.Println("Player X wins with")
                    self.bb.System.Println(f"combination:{x_winning_combination}")  # Print winning combination
                    self.winning_lights("x", redColor, x_winning_combination)  # Highlight winning combination
                    self.bb.Neo.Clear()  # Clear NeoPixel display
                    break
                if y_has_won:  # If player O has won
                    print("Player Y wins with combination:", y_winning_combination)  # Print winning message
                    self.bb.System.Println("Player Y wins with")
                    self.bb.System.Println(f"combination:{y_winning_combination}")  # Print winning combination
                    self.winning_lights("o", greenColor, y_winning_combination)  # Highlight winning combination
                    self.bb.Neo.Clear()  # Clear NeoPixel display
                    break
                if moves_made == 9:  # If all squares are filled (tie)
                    print("It's a tie!")  # Print tie message
                    self.bb.System.Println("It's a tie!")  # Print tie message
                    self.bb.Neo.Clear()  # Clear NeoPixel display
                    break
                if len(arena) != 0:  # If there are available squares
                    arena.remove(square)  # Remove selected square from available squares
        self.bb.Neo.Show(self.neoPin, self.neoCount)  # Update NeoPixel display

Customization:

  • Algorithm Selection:

Explore a variety of the world of artificial intelligence by experimenting with different smart search algorithms beyond the MiniMax approach. Consider implementing algorithms such as A*, Depth-First Search (DFS), Breadth-First Search (BFS), and more to tailor the gameplay experience to your preferences and challenges.

  • Sound Effects Integration: 

Enhance the gaming experience further by incorporating sound effects into the project. Add special sounds for player and bot moves, victory celebrations, and game-ending scenarios you can take a look at the sounds with BrainPad microcomputers.

  • Multiplayer Support: 

Extend the project’s capabilities by introducing multiplayer functionality. Modify the code to accommodate two players competing against each other on the same LED matrix by adding custom buttons for each player from the BrainTronics kit.

  • Explore Different Programming Languages with BrainPad Edge: 

Try rewriting the project code in alternative languages such as C# or JavaScript using the BrainPad Edge or BrainPad Rave. Explore the various coding options here and observe how the project behaves in different languages.