通过本综合教程，学习如何使用 Pygame 在 Python 中创建自己的数独游戏。本指南涵盖安装、游戏逻辑、用户界面和计时器功能，是希望创建功能性和可扩展性数独益智游戏的爱好者的理想之选。

数独是一种经典的数字谜题，多年来一直吸引着谜题爱好者。在本教程中，我们将介绍使用 Python 创建数独游戏的过程。本指南结束时，您将拥有一个功能齐全的数独游戏，您可以玩这个游戏，甚至可以进一步扩展。

安装和设置

让我们先确保 Pygame 已安装在电脑上；前往终端，使用 pip 安装 pygame 模块。

$ pip install pygame

然后，为游戏创建一个目录，并在其中创建以下 .py 文件：settings.py、main.py、sudoku.py、cell.py、table.py 和 clock.py。

让我们在 settings.py 中定义游戏变量和有用的外部函数：

# setting.py
from itertools import islice

WIDTH, HEIGHT = 450, 450
N_CELLS = 9
CELL_SIZE = (WIDTH // N_CELLS, HEIGHT // N_CELLS)

# Convert 1D list to 2D list
def convert_list(lst, var_lst):
    it = iter(lst)
    return [list(islice(it, i)) for i in var_lst]

接下来，让我们创建游戏的主类。该类将负责调用游戏和运行游戏循环：

# main.py
import pygame, sys
from settings import WIDTH, HEIGHT, CELL_SIZE
from table import Table

pygame.init()

screen = pygame.display.set_mode((WIDTH, HEIGHT + (CELL_SIZE[1] * 3)))
pygame.display.set_caption("Sudoku")

pygame.font.init()

class Main:
    def __init__(self, screen):
        self.screen = screen
        self.FPS = pygame.time.Clock()
        self.lives_font = pygame.font.SysFont("monospace", CELL_SIZE[0] // 2)
        self.message_font = pygame.font.SysFont('Bauhaus 93', (CELL_SIZE[0]))
        self.color = pygame.Color("darkgreen")

    def main(self):
        table = Table(self.screen)
        while True:
            self.screen.fill("gray")
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    pygame.quit()
                    sys.exit()
                if event.type == pygame.MOUSEBUTTONDOWN:
                    if not table.game_over:
                        table.handle_mouse_click(event.pos)
            # lower screen display
            if not table.game_over:
                my_lives = self.lives_font.render(f"Lives Left: {table.lives}", True, pygame.Color("black"))
                self.screen.blit(my_lives, ((WIDTH // table.SRN) - (CELL_SIZE[0] // 2), HEIGHT + (CELL_SIZE[1] * 2.2)))
            else:
                if table.lives <= 0:
                    message = self.message_font.render("GAME OVER!!", True, pygame.Color("red"))
                    self.screen.blit(message, (CELL_SIZE[0] + (CELL_SIZE[0] // 2), HEIGHT + (CELL_SIZE[1] * 2)))
                elif table.lives > 0:
                    message = self.message_font.render("You Made It!!!", True, self.color)
                    self.screen.blit(message, (CELL_SIZE[0] , HEIGHT + (CELL_SIZE[1] * 2)))
            table.update()
            pygame.display.flip()
            self.FPS.tick(30)

if __name__ == "__main__":
    play = Main(screen)
    play.main()

从名称本身来看，Main 类将是我们游戏的主类。它的参数 screen 将作为游戏窗口，用于制作游戏动画。

main() 函数将运行并更新我们的游戏。它将首先初始化 Table（作为谜题表）。为了保持游戏运行而不故意退出，我们在其中设置了一个 while 循环。在循环内部，我们还将设置另一个循环（for 循环），它将捕捉游戏窗口内发生的所有事件，如按键、鼠标移动、鼠标按键点击或玩家点击退出键等事件。

main() 还负责显示玩家的 "剩余生命 "和游戏结束信息，无论玩家是赢还是输。为了更新游戏，我们调用 table.update() 来更新游戏表中的变化。然后，pygame.display.flip() 会呈现这些变化。self.FPS.tick(30) 控制帧频更新速度。

生成数独谜题

sudoku() 类将负责为我们随机生成数独谜题。在 sudoku.py 中创建一个类并命名为 Sudoku。首先导入必要的模块：random, math 和 copy：

# sudoku.py
import random
import math
import copy

class Sudoku:
    def __init__(self, N, E):
        self.N = N
        self.E = E
        # compute square root of N
        self.SRN = int(math.sqrt(N))
        self.table = [[0 for x in range(N)] for y in range(N)]
        self.answerable_table = None
        self._generate_table()

    def _generate_table(self):
        # fill the subgroups diagonally table/matrices
        self.fill_diagonal()
        # fill remaining empty subgroups
        self.fill_remaining(0, self.SRN)
        # Remove random Key digits to make game
        self.remove_digits()

该类有一个初始化方法（__init__()），需要两个参数N和E，分别代表数独网格的大小和创建谜题时需要移除的单元格数。类属性包括 N（网格大小）、E（需要删除的单元格数）、SRN（N 的平方根）、table（数独网格）和 answerable_table（删除部分单元格后的网格副本）。在创建对象时，会立即调用 _generate_table() 方法来设置数独谜题。

主要数字填充：

    def fill_diagonal(self):
        for x in range(0, self.N, self.SRN):
            self.fill_cell(x, x)
    
    def not_in_subgroup(self, rowstart, colstart, num):
        for x in range(self.SRN):
            for y in range(self.SRN):
                if self.table[rowstart + x][colstart + y] == num:
                    return False
        return True
    
    def fill_cell(self, row, col):
        num = 0
        for x in range(self.SRN):
            for y in range(self.SRN):
                while True:
                    num = self.random_generator(self.N)
                    if self.not_in_subgroup(row, col, num):
                        break
                self.table[row + x][col + y] = num

fill_diagonal() 方法通过调用每个子组的 fill_cell() 方法对角填充子组。fill_cell() 方法会在每个子组单元格中生成并放置一个唯一的数字。

    def random_generator(self, num):
        return math.floor(random.random() * num + 1)

    def safe_position(self, row, col, num):
        return (self.not_in_row(row, num) and self.not_in_col(col, num) and self.not_in_subgroup(row - row % self.SRN, col - col % self.SRN, num))
    
    def not_in_row(self, row, num):
        for col in range(self.N):
            if self.table[row][col] == num:
                return False
        return True
    
    def not_in_col(self, col, num):
        for row in range(self.N):
            if self.table[row][col] == num:
                return False
        return True
    
    def fill_remaining(self, row, col):
        # check if we have reached the end of the matrix
        if row == self.N - 1 and col == self.N:
            return True
        # move to the next row if we have reached the end of the current row
        if col == self.N:
            row += 1
            col = 0
        # skip cells that are already filled
        if self.table[row][col] != 0:
            return self.fill_remaining(row, col + 1)
        # try filling the current cell with a valid value
        for num in range(1, self.N + 1):
            if self.safe_position(row, col, num):
                self.table[row][col] = num
                if self.fill_remaining(row, col + 1):
                    return True
                self.table[row][col] = 0
        # no valid value was found, so backtrack
        return False

定义了几个辅助方法（random_generator()、safe_position()、not_in_row()、not_in_col() 和 not_in_subgroup()）。这些方法有助于生成随机数、检查放置数字的位置是否安全，以及确保行、列或子群中没有已存在的数字。

    def remove_digits(self):
        count = self.E
        # replicates the table so we can have a filled and pre-filled copy
        self.answerable_table = copy.deepcopy(self.table)
        # removing random numbers to create the puzzle sheet
        while (count != 0):
            row = self.random_generator(self.N) - 1
            col = self.random_generator(self.N) - 1
            if (self.answerable_table[row][col] != 0):
                count -= 1
                self.answerable_table[row][col] = 0

remove_digits() 方法会从填满的网格中移除指定数量的随机数字来创建谜题。在移除数字之前，它还会创建一个网格副本（answerable_table）。

    def puzzle_table(self):
        return self.answerable_table

    def puzzle_answers(self):
        return self.table

    def print_sudoku(self):
        for row in range(self.N):
            for col in range(self.N):
                print(self.table[row][col], end=" ")
            print()
        print("")
        for row in range(self.N):
            for col in range(self.N):
                print(self.answerable_table[row][col], end=" ")
            print()

if __name__ == "__main__":
    N = 9
    E = (N * N) // 2
    sudoku = Sudoku(N, E)
    sudoku.print_sudoku()

最后 3 个方法负责返回并打印谜题和/或答案。puzzle_table() 返回答案表（去掉部分单元格的谜题）。puzzle_answers() 返回完整的数独表格。print_sudoku() 同时打印完整的数独网格和答案网格。

创建游戏表

在创建游戏网格之前，我们先创建表格单元。在 cell.py 中，创建函数 Cell()：

# cell.py
import pygame
from settings import convert_list

pygame.font.init()

class Cell:
    def __init__(self, row, col, cell_size, value, is_correct_guess = None):
        self.row = row
        self.col = col
        self.cell_size = cell_size
        self.width = self.cell_size[0]
        self.height = self.cell_size[1]
        self.abs_x = row * self.width
        self.abs_y = col * self.height
        self.value = value
        self.is_correct_guess = is_correct_guess
        self.guesses = None if self.value != 0 else [0 for x in range(9)]
        self.color = pygame.Color("white")
        self.font = pygame.font.SysFont('monospace', self.cell_size[0])
        self.g_font = pygame.font.SysFont('monospace', (cell_size[0] // 3))
        self.rect = pygame.Rect(self.abs_x,self.abs_y,self.width,self.height)

    def update(self, screen, SRN = None):
        pygame.draw.rect(screen, self.color, self.rect)
        if self.value != 0:
            font_color = pygame.Color("black") if self.is_correct_guess else pygame.Color("red")
            num_val = self.font.render(str(self.value), True, font_color)
            screen.blit(num_val, (self.abs_x, self.abs_y))
        elif self.value == 0 and self.guesses != None:
            cv_list = convert_list(self.guesses, [SRN, SRN, SRN])
            for y in range(SRN):
                for x in range(SRN):
                    num_txt = " "
                    if cv_list[y][x] != 0:
                        num_txt = cv_list[y][x]
                    num_txt = self.g_font.render(str(num_txt), True, pygame.Color("orange"))
                    abs_x = (self.abs_x + ((self.width // SRN) * x))
                    abs_y = (self.abs_y + ((self.height // SRN) * y))
                    abs_pos = (abs_x, abs_y)
                    screen.blit(num_txt, abs_pos)

Cell() 类的属性包括：row 和 col（单元格在表格中的位置）、cell_size、width 和 height、abs_x 和 abs_y（单元格在屏幕上的绝对 x 坐标和 y 坐标）、value（数值，空单元格为 0）、is_correct_guess（表示当前值是否为正确的猜测值）和 guesses（列表，表示空单元格的可能猜测值，如果单元格已填充，则表示无）。

update() 方法负责更新屏幕上单元格的图形表示。它使用 pygame.draw.rect 绘制一个指定颜色的矩形。根据单元格是填充的（value != 0）还是空的（value ==0），它要么在填充的单元格中绘制数值，要么在空的单元格中绘制可能的猜测。

如果单元格为空并且有可能的猜测，则使用 convert_list() 函数将猜测列表转换为二维列表。然后遍历转换后的列表，并在单元格的相应位置绘制每个猜测。它会使用小字体 (g_font) 将每个猜测渲染为文本。根据二维列表中的位置，计算每个猜测在单元格中的绝对位置。然后，在计算出的位置将文本显示（绘制）到屏幕上。

现在，让我们继续创建游戏表格。在 table.py 中创建一个类并命名为 Table。它使用 Pygame 库创建数独网格，处理用户输入，并显示谜题、数字选择、按钮和计时器。

import pygame
import math
from cell import Cell
from sudoku import Sudoku
from clock import Clock

from settings import WIDTH, HEIGHT, N_CELLS, CELL_SIZE

pygame.font.init()

class Table:
    def __init__(self, screen):
        self.screen = screen
        self.puzzle = Sudoku(N_CELLS, (N_CELLS * N_CELLS) // 2)
        self.clock = Clock()
        self.answers = self.puzzle.puzzle_answers()
        self.answerable_table = self.puzzle.puzzle_table()
        self.SRN = self.puzzle.SRN
        self.table_cells = []
        self.num_choices = []
        self.clicked_cell = None
        self.clicked_num_below = None
        self.cell_to_empty = None
        self.making_move = False
        self.guess_mode = True
        self.lives = 3
        self.game_over = False
        self.delete_button = pygame.Rect(0, (HEIGHT + CELL_SIZE[1]), (CELL_SIZE[0] * 3), (CELL_SIZE[1]))
        self.guess_button = pygame.Rect((CELL_SIZE[0] * 6), (HEIGHT + CELL_SIZE[1]), (CELL_SIZE[0] * 3), (CELL_SIZE[1]))
        self.font = pygame.font.SysFont('Bauhaus 93', (CELL_SIZE[0] // 2))
        self.font_color = pygame.Color("white")
        self._generate_game()
        self.clock.start_timer()

    def _generate_game(self):
        # generating sudoku table
        for y in range(N_CELLS):
            for x in range(N_CELLS):
                cell_value = self.answerable_table[y][x]
                is_correct_guess = True if cell_value != 0 else False
                self.table_cells.append(Cell(x, y, CELL_SIZE, cell_value, is_correct_guess))
        # generating number choices
        for x in range(N_CELLS):
            self.num_choices.append(Cell(x, N_CELLS, CELL_SIZE, x + 1))

Table 类的 __init__() 方法（构造函数）初始化了各种属性，如 Pygame 屏幕、数独谜题、时钟、答案、可回答的表格以及其他与游戏相关的变量。

    def _draw_grid(self):
        grid_color = (50, 80, 80)
        pygame.draw.rect(self.screen, grid_color, (-3, -3, WIDTH + 6, HEIGHT + 6), 6)
        i = 1
        while (i * CELL_SIZE[0]) < WIDTH:
            line_size = 2 if i % 3 > 0 else 4
            pygame.draw.line(self.screen, grid_color, ((i * CELL_SIZE[0]) - (line_size // 2), 0), ((i * CELL_SIZE[0]) - (line_size // 2), HEIGHT), line_size)
            pygame.draw.line(self.screen, grid_color, (0, (i * CELL_SIZE[0]) - (line_size // 2)), (HEIGHT, (i * CELL_SIZE[0]) - (line_size // 2)), line_size)
            i += 1

    def _draw_buttons(self):
        # adding delete button details
        dl_button_color = pygame.Color("red")
        pygame.draw.rect(self.screen, dl_button_color, self.delete_button)
        del_msg = self.font.render("Delete", True, self.font_color)
        self.screen.blit(del_msg, (self.delete_button.x + (CELL_SIZE[0] // 2), self.delete_button.y + (CELL_SIZE[1] // 4)))
        # adding guess button details
        gss_button_color = pygame.Color("blue") if self.guess_mode else pygame.Color("purple")
        pygame.draw.rect(self.screen, gss_button_color, self.guess_button)
        gss_msg = self.font.render("Guess: On" if self.guess_mode else "Guess: Off", True, self.font_color)
        self.screen.blit(gss_msg, (self.guess_button.x + (CELL_SIZE[0] // 3), self.guess_button.y + (CELL_SIZE[1] // 4)))

_draw_grid() 方法负责绘制数独网格；它使用 Pygame 函数根据单元格的大小绘制网格线。_draw_buttons() 方法负责绘制删除和猜测按钮；它使用 Pygame 函数绘制带有适当颜色和信息的矩形按钮。

    def _get_cell_from_pos(self, pos):
        for cell in self.table_cells:
            if (cell.row, cell.col) == (pos[0], pos[1]):
                return cell

_get_cell_from_pos() 方法返回数独表中给定位置（行、列）上的单元格对象。

    # checking rows, cols, and subgroups for adding guesses on each cell
    def _not_in_row(self, row, num):
        for cell in self.table_cells:
            if cell.row == row:
                if cell.value == num:
                    return False
        return True
    
    def _not_in_col(self, col, num):
        for cell in self.table_cells:
            if cell.col == col:
                if cell.value == num:
                    return False
        return True

    def _not_in_subgroup(self, rowstart, colstart, num):
        for x in range(self.SRN):
            for y in range(self.SRN):
                current_cell = self._get_cell_from_pos((rowstart + x, colstart + y))
                if current_cell.value == num:
                    return False
        return True

    # remove numbers in guess if number already guessed in the same row, col, subgroup correctly
    def _remove_guessed_num(self, row, col, rowstart, colstart, num):
        for cell in self.table_cells:
            if cell.row == row and cell.guesses != None:
                for x_idx,guess_row_val in enumerate(cell.guesses):
                    if guess_row_val == num:
                        cell.guesses[x_idx] = 0
            if cell.col == col and cell.guesses != None:
                for y_idx,guess_col_val in enumerate(cell.guesses):
                    if guess_col_val == num:
                        cell.guesses[y_idx] = 0
        for x in range(self.SRN):
            for y in range(self.SRN):
                current_cell = self._get_cell_from_pos((rowstart + x, colstart + y))
                if current_cell.guesses != None:
                    for idx,guess_val in enumerate(current_cell.guesses):
                        if guess_val == num:
                            current_cell.guesses[idx] = 0

方法 _not_in_row()、_not_in_col()、_not_in_subgroup() 和 _remove_guessed_num() 负责检查数字在行、列或子群中是否有效，并在正确放置后删除猜测的数字。

    def handle_mouse_click(self, pos):
        x, y = pos[0], pos[1]
        # getting table cell clicked
        if x <= WIDTH and y <= HEIGHT:
            x = x // CELL_SIZE[0]
            y = y // CELL_SIZE[1]
            clicked_cell = self._get_cell_from_pos((x, y))
            # if clicked empty cell
            if clicked_cell.value == 0:
                self.clicked_cell = clicked_cell
                self.making_move = True
            # clicked unempty cell but with wrong number guess
            elif clicked_cell.value != 0 and clicked_cell.value != self.answers[y][x]:
                self.cell_to_empty = clicked_cell
        # getting number selected
        elif x <= WIDTH and y >= HEIGHT and y <= (HEIGHT + CELL_SIZE[1]):
            x = x // CELL_SIZE[0]
            self.clicked_num_below = self.num_choices[x].value
        # deleting numbers
        elif x <= (CELL_SIZE[0] * 3) and y >= (HEIGHT + CELL_SIZE[1]) and y <= (HEIGHT + CELL_SIZE[1] * 2):
            if self.cell_to_empty:
                self.cell_to_empty.value = 0
                self.cell_to_empty = None
        # selecting modes
        elif x >= (CELL_SIZE[0] * 6) and y >= (HEIGHT + CELL_SIZE[1]) and y <= (HEIGHT + CELL_SIZE[1] * 2):
            self.guess_mode = True if not self.guess_mode else False
        # if making a move
        if self.clicked_num_below and self.clicked_cell != None and self.clicked_cell.value == 0:
            current_row = self.clicked_cell.row
            current_col = self.clicked_cell.col
            rowstart = self.clicked_cell.row - self.clicked_cell.row % self.SRN
            colstart = self.clicked_cell.col - self.clicked_cell.col % self.SRN
            if self.guess_mode:
                # checking the vertical group, the horizontal group, and the subgroup
                if self._not_in_row(current_row, self.clicked_num_below) and self._not_in_col(current_col, self.clicked_num_below):
                    if self._not_in_subgroup(rowstart, colstart, self.clicked_num_below):
                        if self.clicked_cell.guesses != None:
                            self.clicked_cell.guesses[self.clicked_num_below - 1] = self.clicked_num_below
            else:
                self.clicked_cell.value = self.clicked_num_below
                # if the player guess correctly
                if self.clicked_num_below == self.answers[self.clicked_cell.col][self.clicked_cell.row]:
                    self.clicked_cell.is_correct_guess = True
                    self.clicked_cell.guesses = None
                    self._remove_guessed_num(current_row, current_col, rowstart, colstart, self.clicked_num_below)
                # if guess is wrong
                else:
                    self.clicked_cell.is_correct_guess = False
                    self.clicked_cell.guesses = [0 for x in range(9)]
                    self.lives -= 1
            self.clicked_num_below = None
            self.making_move = False
        else:
            self.clicked_num_below = None

handle_mouse_click() 方法根据鼠标在屏幕上的位置来处理鼠标点击。它会相应地更新游戏变量，如 clicked_cell、clicked_num_below 和 cell_to_empty。

    def _puzzle_solved(self):
        check = None
        for cell in self.table_cells:
            if cell.value == self.answers[cell.col][cell.row]:
                check = True
            else:
                check = False
                break
        return check

_puzzle_solved() 方法通过比较每个单元格中的值与正确答案，检查数独谜题是否已解。

    def update(self):
        [cell.update(self.screen, self.SRN) for cell in self.table_cells]
        [num.update(self.screen) for num in self.num_choices]
        self._draw_grid()
        self._draw_buttons()
        if self._puzzle_solved() or self.lives == 0:
            self.clock.stop_timer()
            self.game_over = True
        else:
            self.clock.update_timer()
        self.screen.blit(self.clock.display_timer(), (WIDTH // self.SRN,HEIGHT + CELL_SIZE[1]))

update 方法负责更新显示内容。它更新单元格和数字的图形表示，绘制网格和按钮，检查谜题是否已解开或游戏是否已结束，以及更新计时器。

添加游戏计时器

在代码的最后一部分，我们要为计时器创建一个类。在 clock.py 中创建时钟类：

import pygame, time
from settings import CELL_SIZE

pygame.font.init()

class Clock:
    def __init__(self):
        self.start_time = None
        self.elapsed_time = 0
        self.font = pygame.font.SysFont("monospace", CELL_SIZE[0])
        self.message_color = pygame.Color("black")

    # Start the timer
    def start_timer(self):
        self.start_time = time.time()

    # Update the timer
    def update_timer(self):
        if self.start_time is not None:
            self.elapsed_time = time.time() - self.start_time

    # Display the timer
    def display_timer(self):
        secs = int(self.elapsed_time % 60)
        mins = int(self.elapsed_time / 60)
        my_time = self.font.render(f"{mins:02}:{secs:02}", True, self.message_color)
        return my_time

    # Stop the timer
    def stop_timer(self):
        self.start_time = None

start_timer() 方法在调用时使用 time.time() 将 start_time 属性设置为当前时间。这标志着计时器的开始。

update_timer() 方法计算定时器开始后的耗时。如果 start_time 属性不是 None，则用 start_time 减去当前时间来更新 elapsed_time。

display_timer() 方法会将已用时间转换为分钟和秒。然后使用 Pygame 字体以 "MM:SS "格式创建时间的文本表示。渲染后的文本将被返回。

stop_timer() 方法将 start_time 重置为 None，从而有效地停止计时器。

现在，我们的编码工作完成了要体验我们的游戏，只需在进入项目目录后在终端运行 python main.py 或 python3 main.py。下面是一些游戏快照：

结论

最后，本教程概述了使用 Pygame 库在 Python 中开发数独游戏的过程。实现过程涵盖了数独谜题生成、图形表示、用户交互和计时器功能等关键方面。通过将代码分解为模块化类（如数独、单元格、表格和时钟），本教程强调了一种结构化和有组织的游戏开发方法。对于那些希望创建自己的数独游戏或加深对使用 Pygame 开发 Python 游戏的理解的人来说，本教程是一个宝贵的资源。