Python 使用Pygame库实现复杂井字棋游戏：增加了计分、重新开始游戏、判断平局等功能

介绍

在本项目中，我们将使用 Python 编程语言和 Pygame 库实现一个复杂的井字棋游戏。井字棋是一种简单且经典的棋类游戏，本项目将对其进行扩展，增加了计分、重新开始游戏、判断平局等功能，使游戏更加丰富和有趣。

环境设置

在开始之前，确保已经安装了 Python 和 Pygame 库。可以使用以下命令安装 Pygame：

pip install pygame

项目分布

• main.py: 游戏的主程序文件，包含游戏的主逻辑和界面交互。
• assets/: 存放游戏所需的图片、音频等资源文件。

代码实现

import pygame
import sys
import random

# 初始化 Pygame
pygame.init()

# 设置游戏窗口
SCREEN_WIDTH = 600
SCREEN_HEIGHT = 600
WIN = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
pygame.display.set_caption("复杂井字棋游戏")

# 定义颜色
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
RED = (255, 0, 0)
BLUE = (0, 0, 255)

# 定义玩家和电脑的棋子
PLAYER_X = "X"
PLAYER_O = "O"
COMPUTER = "COMPUTER"

# 定义棋盘网格
GRID_SIZE = 3
CELL_SIZE = SCREEN_WIDTH // GRID_SIZE

# 定义游戏状态
GAME_STATE_PLAYER_TURN = "PLAYER_TURN"
GAME_STATE_COMPUTER_TURN = "COMPUTER_TURN"
GAME_STATE_GAME_OVER = "GAME_OVER"

# 定义游戏状态和棋盘
game_state = GAME_STATE_PLAYER_TURN
player_board = [[None for _ in range(GRID_SIZE)] for _ in range(GRID_SIZE)]
computer_board = [[None for _ in range(GRID_SIZE)] for _ in range(GRID_SIZE)]

# 绘制棋盘网格
def draw_grid():
    for x in range(0, SCREEN_WIDTH, CELL_SIZE):
        pygame.draw.line(WIN, BLACK, (x, 0), (x, SCREEN_HEIGHT), 3)
    for y in range(0, SCREEN_HEIGHT, CELL_SIZE):
        pygame.draw.line(WIN, BLACK, (0, y), (SCREEN_WIDTH, y), 3)

# 绘制玩家和电脑的棋子
def draw_pieces():
    for row in range(GRID_SIZE):
        for col in range(GRID_SIZE):
            if player_board[row][col] == PLAYER_X:
                draw_x(row, col)
            elif player_board[row][col] == PLAYER_O:
                draw_o(row, col)
            if computer_board[row][col] == PLAYER_X:
                draw_x(row, col)
            elif computer_board[row][col] == PLAYER_O:
                draw_o(row, col)

# 绘制X棋子
def draw_x(row, col):
    x = col * CELL_SIZE + CELL_SIZE // 2
    y = row * CELL_SIZE + CELL_SIZE // 2
    pygame.draw.line(WIN, RED, (x - CELL_SIZE // 4, y - CELL_SIZE // 4), (x + CELL_SIZE // 4, y + CELL_SIZE // 4), 3)
    pygame.draw.line(WIN, RED, (x - CELL_SIZE // 4, y + CELL_SIZE // 4), (x + CELL_SIZE // 4, y - CELL_SIZE // 4), 3)

# 绘制O棋子
def draw_o(row, col):
    x = col * CELL_SIZE + CELL_SIZE // 2
    y = row * CELL_SIZE + CELL_SIZE // 2
    radius = CELL_SIZE // 4
    pygame.draw.circle(WIN, BLUE, (x, y), radius, 3)

# 玩家落子
def player_move(row, col):
    global game_state
    if player_board[row][col] is None and game_state == GAME_STATE_PLAYER_TURN:
        player_board[row][col] = PLAYER_X
        if check_winner(player_board):
            game_state = GAME_STATE_GAME_OVER
        else:
            game_state = GAME_STATE_COMPUTER_TURN

# 电脑落子
def computer_move():
    global game_state
    if game_state == GAME_STATE_COMPUTER_TURN:
        empty_cells = [(r, c) for r in range(GRID_SIZE) for c in range(GRID_SIZE) if computer_board[r][c] is None]
        if empty_cells:
            row, col = random.choice(empty_cells)
            computer_board[row][col] = PLAYER_O
            if check_winner(computer_board):
                game_state = GAME_STATE_GAME_OVER
            else:
                game_state = GAME_STATE_PLAYER_TURN

# 胜利判定
def check_winner(board):
    # Check rows
    for row in range(GRID_SIZE):
        if all([board[row][col] == board[row][0] for col in range(1, GRID_SIZE)]):
            return True
    # Check columns
    for col in range(GRID_SIZE):
        if all([board[row][col] == board[0][col] for row in range(1, GRID_SIZE)]):
            return True
    # Check diagonals
    if all([board[i][i] == board[0][0] for i in range(1, GRID_SIZE)]) or \
       all([board[i][GRID_SIZE - i - 1] == board[0][GRID_SIZE - 1] for i in range(1, GRID_SIZE)]):
        return True
    return False

# 绘制分数板
def draw_score():
    font = pygame.font.Font(None, 36)
    player_text = font.render(f"玩家分数: {player_score}", True, BLACK)
    computer_text = font.render(f"电脑分数: {computer_score}", True, BLACK)
    WIN.blit(player_text, (20, 20))
    WIN.blit(computer_text, (20, 60))

# 重新开始游戏
def restart_game():
    global game_state, player_board, computer_board
    game_state = GAME_STATE_PLAYER_TURN
    player_board = [[None for _ in range(GRID_SIZE)] for _ in range(GRID_SIZE)]
    computer_board = [[None for _ in range(GRID_SIZE)] for _ in range(GRID_SIZE)]

# 处理事件
def handle_events():
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            sys.exit()
        elif event.type==pygame.MOUSEBUTTONDOWN：
        if game_state == GAME_STATE_PLAYER_TURN:
                mouseX, mouseY = pygame.mouse.get_pos()
                clicked_row = mouseY // CELL_SIZE
                clicked_col = mouseX // CELL_SIZE
                player_move(clicked_row, clicked_col)
            elif game_state == GAME_STATE_GAME_OVER:
                restart_game()

# 主循环
def main():
    global player_score, computer_score
    player_score = 0
    computer_score = 0
    clock = pygame.time.Clock()

    while True:
        WIN.fill(WHITE)
        draw_grid()
        draw_pieces()
        draw_score()
        handle_events()
        computer_move()
        pygame.display.flip()
        clock.tick(60)

if __name__ == "__main__":
    main()

这段代码完成了主循环部分，整个游戏的逻辑已经实现。你可以在本地运行这段代码，体验一下复杂井字棋游戏的乐趣。

代码解释：

1. 初始化 Pygame 和设置窗口：

   • 使用 pygame.init() 初始化 Pygame 库。
   • 设置游戏窗口的宽度和高度，并创建窗口对象。

2. 定义颜色和棋子标志：

   • 定义了棋盘网格的尺寸和单元格尺寸。
   • 定义了玩家和电脑的棋子标志，以及游戏状态。

3. 绘制棋盘网格：

   • 使用 draw_grid() 函数在窗口中绘制棋盘的网格线。

4. 绘制玩家和电脑的棋子：

   • 使用 draw_pieces() 函数根据棋盘上的棋子位置，在相应位置绘制玩家和电脑的棋子。

5. 玩家和电脑落子：

   • player_move() 函数处理玩家落子的逻辑，检查落子位置是否为空，如果是则在该位置落子。
   • computer_move() 函数处理电脑落子的逻辑，随机选择一个空位置落子。

6. 胜利判定：

   • check_winner() 函数用于检查是否有一方获胜，检查每一行、每一列以及对角线上是否有相同的棋子。

7. 绘制分数板：

   • 使用 draw_score() 函数在窗口中显示玩家和电脑的分数。

8. 重新开始游戏：

   • restart_game() 函数用于重新开始游戏，将棋盘重置为初始状态。

9. 处理事件：

   • 在 handle_events() 函数中处理用户的鼠标点击事件，根据游戏状态执行相应的操作。

10. 主循环：

    • 在 main() 函数中，使用一个循环不断更新游戏状态并绘制游戏界面。

11. 运行游戏：

    • 在 if __name__ == "__main__": 语句块中，调用 main() 函数启动游戏。

总结：

这段代码实现了一个简单的复杂井字棋游戏，包括玩家和电脑的落子、胜利判定、重新开始游戏等基本功能。通过 Pygame 库提供的功能，我们可以轻松地创建游戏窗口并实现游戏逻辑。

扩展复杂功能的想法：

1. AI 算法优化：当前电脑玩家的落子逻辑比较简单，可以尝试实现更复杂的 AI 算法，如 MiniMax 算法或 Alpha-Beta 剪枝算法，以提升电脑玩家的智能水平。

2. 改进界面：可以美化游戏界面，增加背景图片、动画效果或过渡效果，提升游戏的视觉体验。

3. 多种游戏模式：除了单人模式，可以添加双人对战模式或在线对战模式，让玩家可以与其他玩家进行对战。

4. 游戏设置：增加游戏设置界面，允许玩家自定义游戏规则、难度等参数，提升游戏的可玩性和趣味性。

5. 存档和载入：实现游戏存档和载入功能，让玩家可以保存游戏进度并随时恢复游戏。

6. 统计和排行榜：记录玩家的游戏数据，包括胜利次数、失败次数、平局次数等，并实现排行榜功能，展示最高分和最佳成绩。

通过专栏《专栏Python实现复杂小游戏源码教程》（点击可跳转）进一步了解扩展游戏的功能