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

介绍

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

环境设置

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

pip install pygame
1

项目分布

• 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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

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

代码解释：

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实现复杂小游戏源码教程》（点击可跳转）进一步了解扩展游戏的功能