Sudoku Game Development with Python and Pygame

Introduction

In this project, we will create a Sudoku game using Python and the Pygame library. The game will generate a Sudoku grid of the specified difficulty level and let players solve the puzzle by filling in the empty cells with numbers. The game will provide features like selecting difficulty, highlighting selected cells, and checking if the grid is complete.

👀 Preview

🎯 Tasks

In this project, you will learn:

• How to import required libraries
• How to initialize PyGame
• How to define colors
• How to set game window dimensions and title
• How to create the game window
• How to load fonts
• How to generate a Sudoku grid
• How to solve the Sudoku grid using backtracking algorithm
• How to remove numbers from the grid based on difficulty
• How to draw the Sudoku grid on the game window
• How to check if the grid is fully filled
• How to get the cell coordinates under mouse position
• How to select the difficulty level
• How to implement the main game loop

🏆 Achievements

After completing this project, you will be able to:

• Use the Pygame library for game development in Python
• Generate a Sudoku grid of a specified difficulty level
• Solve a Sudoku grid using the backtracking algorithm
• Handle mouse and keyboard events in Pygame
• Draw shapes and text on the game window
• Implement the main game loop in Pygame

Skills Graph

Create the Project Files

To begin, create a file named sudoku_game.py and open it in your preferred text editor or integrated development environment (IDE).

cd ~/project
touch sudoku_game.py

Import Required Libraries

Import the required libraries at the beginning of the file. We need the pygame and random libraries for this game.

import pygame
import random

Install the pygame library using the pip command.

sudo pip install pygame

Initialize PyGame

Initialize the Pygame library to set up the game window.

pygame.init()

Define Colors

Define the colors to be used in the game. We will use the RGB format for colors.

BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
GRAY = (200, 200, 200)
BLUE = (0, 0, 255)
LIGHT_BLUE = (100, 100, 255)

Set Game Window Dimensions and Title

Set the dimensions of the game window and set a title for the game.

WINDOW_SIZE = (550, 550)
CELL_SIZE = WINDOW_SIZE[0] // 9

pygame.display.set_caption("Sudoku Game")

Create the Game Window

Create the game window using the specified dimensions.

screen = pygame.display.set_mode(WINDOW_SIZE)

Load Fonts

We will need to load fonts to display numbers on the game screen. Load two fonts, one for the larger numbers and one for the smaller numbers.

font_large = pygame.font.SysFont("calibri", 50)
font_small = pygame.font.SysFont("calibri", 30)

Generate Sudoku Grid

Create a function generate_sudoku(difficulty) that generates a new Sudoku grid of the specified difficulty level. The function should return the generated grid.

def generate_sudoku(difficulty):
    ## Function code goes here
    pass

Fill Diagonal Subgrids

Inside the generate_sudoku function, fill the diagonal subgrids of the grid with random numbers. This ensures that each subgrid contains numbers from 1 to 9 without repetition.

## Fill diagonal subgrids
for i in range(0, 9, 3):
    nums = random.sample(range(1, 10), 3)
    for j in range(3):
        grid[i + j][i + j] = nums[j]

Solve Sudoku Grid

Create a function solve_sudoku(grid) that solves the Sudoku grid using the backtracking algorithm. The function should return True if the grid is solvable and False otherwise.

def solve_sudoku(grid):
    ## Function code goes here
    pass

Find Empty Cell

Inside the solve_sudoku function, create a helper function find_empty_cell(grid) that returns the coordinates of the next empty cell in the grid. If there are no empty cells, return None.

def find_empty_cell(grid):
    for row in range(9):
        for col in range(9):
            if grid[row][col] == 0:
                return (row, col)

    return None

Check Valid Move

Inside the solve_sudoku function, create a helper function is_valid_move(grid, row, col, num) that checks if placing a number in a cell is a valid move. The function should return True if the move is valid and False otherwise.

def is_valid_move(grid, row, col, num):
    ## Function code goes here
    pass

Solve Sudoku Grid (Continued)

Inside the solve_sudoku function, use the helper functions find_empty_cell and is_valid_move to implement the backtracking algorithm. If a solution is found, return True. If the current number leads to an invalid solution, backtrack by setting the current cell to 0.

## Try filling the empty cell with numbers from 1 to 9
for num in range(1, 10):
    if is_valid_move(grid, row, col, num):
        grid[row][col] = num

        if solve_sudoku(grid):
            return True

        ## If the current number leads to an invalid solution, backtrack
        grid[row][col] = 0

return False

Remove Numbers Based on Difficulty

Inside the generate_sudoku function, remove numbers from the grid based on the specified difficulty level. The difficulty levels are: 1 (easy), 2 (medium), 3 (hard). The number of numbers to remove is calculated as num_to_remove = 45 + 10 * difficulty.

## Remove numbers based on difficulty level
num_to_remove = 45 + 10 * difficulty
for _ in range(num_to_remove):
    row = random.randint(0, 8)
    col = random.randint(0, 8)
    grid[row][col] = 0

return grid

Draw Grid

Create a function draw_grid(grid, selected_cell) that draws the Sudoku grid on the game window. This function should be responsible for drawing cells, numbers, and highlighting the selected cell.

def draw_grid(grid, selected_cell):
    ## Function code goes here
    pass

Fill Cells and Draw Numbers

Inside the draw_grid function, loop through the grid and draw the cells and numbers using the Pygame functions pygame.draw.rect and screen.blit.

## Draw the cells
for row in range(9):
    for col in range(9):
        cell_rect = pygame.Rect(
            col * CELL_SIZE, row * CELL_SIZE, CELL_SIZE, CELL_SIZE
        )
        pygame.draw.rect(screen, GRAY, cell_rect)

        ## Draw the numbers
        if grid[row][col] != 0:
            number = font_small.render(str(grid[row][col]), True, BLACK)
            text_rect = number.get_rect(
                center=(
                    col * CELL_SIZE + CELL_SIZE // 2,
                    row * CELL_SIZE + CELL_SIZE // 2,
                )
            )
            screen.blit(number, text_rect)

Highlight Selected Cell

Inside the draw_grid function, highlight the selected cell if it is not None using the pygame.draw.rect function.

## Highlight the selected cell
if (row, col) == selected_cell:
    pygame.draw.rect(screen, LIGHT_BLUE, cell_rect, 3)

Draw Grid Lines

Inside the draw_grid function, draw the lines to create the grid using the pygame.draw.line function.

## Draw the lines
for i in range(10):
    if i % 3 == 0:
        thickness = 4
    else:
        thickness = 1

    pygame.draw.line(
        screen,
        BLACK,
        (0, i * CELL_SIZE),
        (WINDOW_SIZE[0], i * CELL_SIZE),
        thickness,
    )
    pygame.draw.line(
        screen,
        BLACK,
        (i * CELL_SIZE, 0),
        (i * CELL_SIZE, WINDOW_SIZE[1]),
        thickness,
    )

Update the Display

Inside the draw_grid function, update the display using the pygame.display.update function.

pygame.display.update()

Check If Grid Is Full

Create a function is_grid_full(grid) that checks if the Sudoku grid is fully filled. This can be done by looping through the grid and checking if any cell contains 0.

def is_grid_full(grid):
    ## Function code goes here
    pass

Get Cell Under Mouse

Create a function get_cell_under_mouse(pos) that returns the cell coordinates under the mouse position. This can be calculated by dividing the mouse position by the cell size.

def get_cell_under_mouse(pos):
    ## Function code goes here
    pass

Select Difficulty

Create a function select_difficulty() that allows the player to select the difficulty level before starting the game. This function should display the difficulty options and return the selected difficulty level.

def select_difficulty():
    ## Function code goes here
    pass

Implement Difficulty Selection

Inside the select_difficulty function, implement the difficulty selection logic using the Pygame functions pygame.mouse.get_pos and pygame.event.get.

## Display difficulty selection text
title_text = font_large.render("Select Difficulty", True, BLACK)
screen.blit(title_text, (110, 200))

## Display difficulty options
option_y = 300
for difficulty, label in difficulties.items():
    option_text = font_small.render(f"{difficulty}. {label}", True, BLACK)
    text_rect = option_text.get_rect(center=(WINDOW_SIZE[0] // 2, option_y))
    screen.blit(option_text, text_rect)
    option_y += 70

pygame.display.update()

## Wait for difficulty selection
difficulty_selected = False
difficulty = 1

while not difficulty_selected:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            return
        elif event.type == pygame.MOUSEBUTTONDOWN:
            if event.button == 1:  ## Left mouse button
                pos = pygame.mouse.get_pos()
                if 180 <= pos[0] <= 380:
                    if 300 <= pos[1] <= 350:
                        difficulty = 1
                        difficulty_selected = True
                    elif 370 <= pos[1] <= 420:
                        difficulty = 2
                        difficulty_selected = True
                    elif 440 <= pos[1] <= 490:
                        difficulty = 3
                        difficulty_selected = True

return difficulty

Main Game Loop

Create the main game loop by defining a function main().

def main():
    ## Function code goes here
    pass

Select Difficulty and Generate Grid

Inside the main function, select the difficulty level by calling select_difficulty() and return if the difficulty is None. Then, generate a Sudoku grid using the selected difficulty level by calling generate_sudoku(difficulty).

## Select the difficulty level
difficulty = select_difficulty()
if difficulty is None:
    return

## Generate a new Sudoku grid
grid = generate_sudoku(difficulty)

Game Loop Variables

Inside the main function, create game loop variables selected_cell and running. Set selected_cell to None and running to True.

selected_cell = None
running = True

Enable Key Repeat

Inside the main function, enable key repeat using the pygame.key.set_repeat function. We set the delay and interval to 100 milliseconds to make it easier for players to fill cells.

## Enable key repeat
pygame.key.set_repeat(100, 100)

Handle Events

Inside the game loop, handle events using the pygame.event.get function. Check for quit events, mouse button events, and key events.

for event in pygame.event.get():
    if event.type == pygame.QUIT:
        running = False
    elif event.type == pygame.MOUSEBUTTONDOWN:
        ## Handle mouse button events
        pass
    elif event.type == pygame.KEYDOWN:
        ## Handle key events
        pass

Handle Mouse Button Events

Inside the event handling for mouse button events, check if the left mouse button is clicked or the right mouse button is clicked.

if event.button == 1:  ## Left mouse button
    ## Handle left mouse button click
    pass
elif event.button == 3:  ## Right mouse button
    ## Handle right mouse button click
    pass

Handle Left Mouse Button Click

Inside the left mouse button click handling, get the cell coordinates under the mouse position by calling get_cell_under_mouse(pos).

## Get the cell under the mouse position
pos = pygame.mouse.get_pos()
row, col = get_cell_under_mouse(pos)

Handle Left Mouse Button Click (Continued)

Inside the left mouse button click handling, select the cell if it's empty by checking if grid[row][col] == 0.

## Select the cell if it's empty
if grid[row][col] == 0:
    selected_cell = (row, col)

Handle Right Mouse Button Click

Inside the right mouse button click handling, clear the selected cell if it's not None and it's empty by checking if grid[selected_cell[0]][selected_cell[1]] == 0.

if selected_cell:
    ## Clear the selected cell if it's empty
    if grid[selected_cell[0]][selected_cell[1]] == 0:
        grid[selected_cell[0]][selected_cell[1]] = 0

Handle Key Events

Inside the event handling for key events, check which number key is pressed and set the value of the selected cell accordingly.

if selected_cell:
    ## Get the key pressed
    if event.key == pygame.K_1:
        grid[selected_cell[0]][selected_cell[1]] = 1
    elif event.key == pygame.K_2:
        grid[selected_cell[0]][selected_cell[1]] = 2
    elif event.key == pygame.K_3:
        grid[selected_cell[0]][selected_cell[1]] = 3
    elif event.key == pygame.K_4:
        grid[selected_cell[0]][selected_cell[1]] = 4
    elif event.key == pygame.K_5:
        grid[selected_cell[0]][selected_cell[1]] = 5
    elif event.key == pygame.K_6:
        grid[selected_cell[0]][selected_cell[1]] = 6
    elif event.key == pygame.K_7:
        grid[selected_cell[0]][selected_cell[1]] = 7
    elif event.key == pygame.K_8:
        grid[selected_cell[0]][selected_cell[1]] = 8
    elif event.key == pygame.K_9:
        grid[selected_cell[0]][selected_cell[1]] = 9

Draw Grid and Check Completion

Inside the game loop, draw the grid by calling draw_grid(grid, selected_cell). Then, check if the grid is complete by calling is_grid_full(grid).

## Draw the grid
draw_grid(grid, selected_cell)

## Check if the grid is complete
if is_grid_full(grid):
    print("Congratulations! You solved the Sudoku puzzle.")

Update Display and Quit

After the game loop, update the display using the pygame.display.update function and quit the game using pygame.quit().

## Update the display
pygame.display.update()

## Quit the game
pygame.quit()

Run the Game

Finally, add a condition to check if the current file is the main entry point of the program. If it is, run the game by calling the main() function.

if __name__ == "__main__":
    main()

Run the game using the python command.

python sudoku_game.py

Summary

Congratulations! You have successfully created a Sudoku game using Python and the Pygame library. The game allows players to select a difficulty level, fill in the empty cells with numbers, and checks if the grid is complete. Have fun playing and solving Sudoku puzzles!