Python实例题：人机对战初体验Python基于Pygame实现四子棋游戏

Python实例题

题目

人机对战初体验Python基于Pygame实现四子棋游戏

代码实现

import pygame
import sys
import numpy as np
import random

class ConnectFour:
    def __init__(self):
        # 游戏常量
        self.ROWS = 6
        self.COLUMNS = 7
        self.SQUARE_SIZE = 100
        self.WIDTH = self.COLUMNS * self.SQUARE_SIZE
        self.HEIGHT = (self.ROWS + 1) * self.SQUARE_SIZE
        self.SCREEN_SIZE = (self.WIDTH, self.HEIGHT)
        self.RADIUS = int(self.SQUARE_SIZE / 2 - 5)
        
        # 颜色定义
        self.BLUE = (0, 0, 255)
        self.BLACK = (0, 0, 0)
        self.RED = (255, 0, 0)
        self.YELLOW = (255, 255, 0)
        self.WHITE = (255, 255, 255)
        
        # 初始化游戏
        pygame.init()
        self.screen = pygame.display.set_mode(self.SCREEN_SIZE)
        pygame.display.set_caption("四子棋")
        self.font = pygame.font.SysFont("SimHei", 40)
        self.small_font = pygame.font.SysFont("SimHei", 24)
        
        # 游戏变量
        self.board = np.zeros((self.ROWS, self.COLUMNS))
        self.game_over = False
        self.turn = 1  # 1: 玩家1/人类, 2: 玩家2/AI
        self.player_mode = 1  # 1: 人机对战, 2: 双人对战
        self.winner = 0
        
        # 绘制初始界面
        self.draw_board()
        pygame.display.update()
    
    def draw_board(self):
        """绘制游戏棋盘"""
        # 绘制背景
        self.screen.fill(self.BLUE)
        
        # 绘制标题区域
        title_rect = pygame.Rect(0, 0, self.WIDTH, self.SQUARE_SIZE)
        pygame.draw.rect(self.screen, self.BLACK, title_rect)
        
        # 显示标题和模式
        title_text = self.font.render("四子棋", True, self.WHITE)
        self.screen.blit(title_text, (self.WIDTH // 2 - title_text.get_width() // 2, 30))
        
        mode_text = self.small_font.render(
            "模式: 人机对战" if self.player_mode == 1 else "模式: 双人对战", 
            True, self.WHITE
        )
        self.screen.blit(mode_text, (20, 35))
        
        # 绘制切换模式按钮
        button_rect = pygame.Rect(self.WIDTH - 150, 25, 120, 50)
        pygame.draw.rect(self.screen, self.RED if self.player_mode == 1 else self.YELLOW, button_rect)
        button_text = self.small_font.render(
            "切换双人" if self.player_mode == 1 else "切换人机", 
            True, self.WHITE
        )
        self.screen.blit(button_text, (button_rect.centerx - button_text.get_width() // 2, 
                                      button_rect.centery - button_text.get_height() // 2))
        
        # 绘制棋盘格子
        for c in range(self.COLUMNS):
            for r in range(self.ROWS):
                pygame.draw.rect(self.screen, self.BLACK, 
                                (c * self.SQUARE_SIZE, (r + 1) * self.SQUARE_SIZE, 
                                 self.SQUARE_SIZE, self.SQUARE_SIZE))
                pygame.draw.circle(self.screen, self.WHITE, 
                                  (int(c * self.SQUARE_SIZE + self.SQUARE_SIZE / 2), 
                                   int((r + 1) * self.SQUARE_SIZE + self.SQUARE_SIZE / 2)), 
                                  self.RADIUS)
        
        # 绘制当前棋子
        for c in range(self.COLUMNS):
            for r in range(self.ROWS):
                if self.board[r][c] == 1:
                    pygame.draw.circle(self.screen, self.RED, 
                                      (int(c * self.SQUARE_SIZE + self.SQUARE_SIZE / 2), 
                                       self.HEIGHT - int(r * self.SQUARE_SIZE + self.SQUARE_SIZE / 2)), 
                                      self.RADIUS)
                elif self.board[r][c] == 2:
                    pygame.draw.circle(self.screen, self.YELLOW, 
                                      (int(c * self.SQUARE_SIZE + self.SQUARE_SIZE / 2), 
                                       self.HEIGHT - int(r * self.SQUARE_SIZE + self.SQUARE_SIZE / 2)), 
                                      self.RADIUS)
        
        # 如果游戏结束，显示获胜信息
        if self.game_over:
            overlay = pygame.Surface(self.SCREEN_SIZE, pygame.SRCALPHA)
            overlay.fill((0, 0, 0, 180))
            self.screen.blit(overlay, (0, 0))
            
            winner_text = self.font.render(
                f"玩家 {'红方' if self.winner == 1 else '黄方'} 获胜!" if self.winner != 0 else "平局!", 
                True, self.WHITE
            )
            self.screen.blit(winner_text, (self.WIDTH // 2 - winner_text.get_width() // 2, 
                                           self.HEIGHT // 2 - 30))
            
            restart_text = self.font.render("按R键重新开始", True, self.WHITE)
            self.screen.blit(restart_text, (self.WIDTH // 2 - restart_text.get_width() // 2, 
                                            self.HEIGHT // 2 + 30))
    
    def is_valid_location(self, col):
        """检查指定列是否可以放置棋子"""
        return self.board[0][col] == 0
    
    def get_next_open_row(self, col):
        """获取指定列中下一个可用的行"""
        for r in range(self.ROWS - 1, -1, -1):
            if self.board[r][col] == 0:
                return r
    
    def drop_piece(self, row, col, player):
        """在指定位置放置棋子"""
        self.board[row][col] = player
    
    def check_winning_move(self, player):
        """检查玩家是否获胜"""
        # 检查水平方向
        for c in range(self.COLUMNS - 3):
            for r in range(self.ROWS):
                if (self.board[r][c] == player and 
                    self.board[r][c + 1] == player and 
                    self.board[r][c + 2] == player and 
                    self.board[r][c + 3] == player):
                    return True
        
        # 检查垂直方向
        for c in range(self.COLUMNS):
            for r in range(self.ROWS - 3):
                if (self.board[r][c] == player and 
                    self.board[r + 1][c] == player and 
                    self.board[r + 2][c] == player and 
                    self.board[r + 3][c] == player):
                    return True
        
        # 检查正对角线
        for c in range(self.COLUMNS - 3):
            for r in range(self.ROWS - 3):
                if (self.board[r][c] == player and 
                    self.board[r + 1][c + 1] == player and 
                    self.board[r + 2][c + 2] == player and 
                    self.board[r + 3][c + 3] == player):
                    return True
        
        # 检查反对角线
        for c in range(self.COLUMNS - 3):
            for r in range(3, self.ROWS):
                if (self.board[r][c] == player and 
                    self.board[r - 1][c + 1] == player and 
                    self.board[r - 2][c + 2] == player and 
                    self.board[r - 3][c + 3] == player):
                    return True
        
        return False
    
    def is_board_full(self):
        """检查棋盘是否已满"""
        for c in range(self.COLUMNS):
            if self.is_valid_location(c):
                return False
        return True
    
    def evaluate_window(self, window, player):
        """评估一个窗口(四个位置)的得分"""
        score = 0
        opponent = 1 if player == 2 else 2
        
        if window.count(player) == 4:
            score += 100
        elif window.count(player) == 3 and window.count(0) == 1:
            score += 10
        elif window.count(player) == 2 and window.count(0) == 2:
            score += 5
        
        if window.count(opponent) == 3 and window.count(0) == 1:
            score -= 80  # 阻止对手三连
        
        return score
    
    def score_position(self, player):
        """评估整个棋盘的得分"""
        score = 0
        
        # 评估中心列
        center_array = [int(i) for i in list(self.board[:, self.COLUMNS // 2])]
        center_count = center_array.count(player)
        score += center_count * 3
        
        # 评估水平方向
        for r in range(self.ROWS):
            row_array = [int(i) for i in list(self.board[r, :])]
            for c in range(self.COLUMNS - 3):
                window = row_array[c:c + 4]
                score += self.evaluate_window(window, player)
        
        # 评估垂直方向
        for c in range(self.COLUMNS):
            col_array = [int(i) for i in list(self.board[:, c])]
            for r in range(self.ROWS - 3):
                window = col_array[r:r + 4]
                score += self.evaluate_window(window, player)
        
        # 评估正对角线
        for r in range(self.ROWS - 3):
            for c in range(self.COLUMNS - 3):
                window = [self.board[r + i][c + i] for i in range(4)]
                score += self.evaluate_window(window, player)
        
        # 评估反对角线
        for r in range(self.ROWS - 3):
            for c in range(self.COLUMNS - 3):
                window = [self.board[r + 3 - i][c + i] for i in range(4)]
                score += self.evaluate_window(window, player)
        
        return score
    
    def get_valid_locations(self):
        """获取所有可用的列"""
        valid_locations = []
        for col in range(self.COLUMNS):
            if self.is_valid_location(col):
                valid_locations.append(col)
        return valid_locations
    
    def minimax(self, depth, maximizingPlayer, alpha, beta):
        """使用Minimax算法和Alpha-Beta剪枝选择最佳移动"""
        valid_locations = self.get_valid_locations()
        is_terminal = self.is_board_full() or self.check_winning_move(1) or self.check_winning_move(2)
        
        if depth == 0 or is_terminal:
            if is_terminal:
                if self.check_winning_move(2):
                    return (None, 10000000)
                elif self.check_winning_move(1):
                    return (None, -10000000)
                else:  # 平局
                    return (None, 0)
            else:  # 深度为0
                return (None, self.score_position(2))
        
        if maximizingPlayer:
            value = -float('inf')
            column = random.choice(valid_locations)
            for col in valid_locations:
                row = self.get_next_open_row(col)
                temp_board = self.board.copy()
                self.drop_piece(row, col, 2)
                new_score = self.minimax(depth - 1, False, alpha, beta)[1]
                self.board = temp_board
                if new_score > value:
                    value = new_score
                    column = col
                alpha = max(alpha, value)
                if alpha >= beta:
                    break
            return column, value
        else:  # 最小化玩家
            value = float('inf')
            column = random.choice(valid_locations)
            for col in valid_locations:
                row = self.get_next_open_row(col)
                temp_board = self.board.copy()
                self.drop_piece(row, col, 1)
                new_score = self.minimax(depth - 1, True, alpha, beta)[1]
                self.board = temp_board
                if new_score < value:
                    value = new_score
                    column = col
                beta = min(beta, value)
                if alpha >= beta:
                    break
            return column, value
    
    def ai_move(self):
        """AI移动逻辑"""
        if not self.game_over:
            # 使用minimax算法选择最佳列，深度为4
            col, _ = self.minimax(4, True, -float('inf'), float('inf'))
            
            if self.is_valid_location(col):
                pygame.time.wait(500)  # 让AI思考看起来更自然
                row = self.get_next_open_row(col)
                self.drop_piece(row, col, 2)
                
                if self.check_winning_move(2):
                    self.game_over = True
                    self.winner = 2
                elif self.is_board_full():
                    self.game_over = True
                    self.winner = 0
                
                self.turn = 1  # 回到玩家1
                self.draw_board()
                pygame.display.update()
    
    def restart_game(self):
        """重新开始游戏"""
        self.board = np.zeros((self.ROWS, self.COLUMNS))
        self.game_over = False
        self.turn = 1
        self.winner = 0
        self.draw_board()
        pygame.display.update()
    
    def run(self):
        """运行游戏主循环"""
        clock = pygame.time.Clock()
        
        while True:
            clock.tick(60)
            
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    pygame.quit()
                    sys.exit()
                
                if event.type == pygame.KEYDOWN:
                    if event.key == pygame.K_r and self.game_over:
                        self.restart_game()
                
                if event.type == pygame.MOUSEBUTTONDOWN:
                    # 检查是否点击了模式切换按钮
                    button_rect = pygame.Rect(self.WIDTH - 150, 25, 120, 50)
                    if button_rect.collidepoint(event.pos):
                        self.player_mode = 2 if self.player_mode == 1 else 1
                        self.restart_game()
                        continue
                    
                    # 游戏未结束且轮到人类玩家
                    if not self.game_over and (self.turn == 1 or self.player_mode == 2):
                        # 获取鼠标位置
                        pos_x = event.pos[0]
                        col = int(pos_x // self.SQUARE_SIZE)
                        
                        # 检查列是否有效
                        if self.is_valid_location(col):
                            # 获取下一个可用行
                            row = self.get_next_open_row(col)
                            
                            # 放置棋子
                            player = self.turn
                            self.drop_piece(row, col, player)
                            
                            # 检查是否获胜
                            if self.check_winning_move(player):
                                self.game_over = True
                                self.winner = player
                            
                            # 检查是否平局
                            elif self.is_board_full():
                                self.game_over = True
                                self.winner = 0
                            
                            # 切换玩家
                            self.turn = 2 if self.turn == 1 else 1
                            
                            # 绘制棋盘
                            self.draw_board()
                            pygame.display.update()
            
            # AI移动（人机对战且轮到AI）
            if not self.game_over and self.turn == 2 and self.player_mode == 1:
                self.ai_move()


if __name__ == "__main__":
    game = ConnectFour()
    game.run()

实现原理

这个四子棋游戏基于以下核心技术实现：

游戏逻辑：
- 使用 numpy 数组表示游戏棋盘
- 实现棋子放置、胜利条件检查和棋盘状态评估
- 支持人机对战和双人对战模式
AI 算法：
- 使用 Minimax 算法进行决策
- 实现 Alpha-Beta 剪枝优化搜索效率
- 设计评分函数评估棋盘状态
界面渲染：
- 使用 Pygame 创建图形界面
- 实现棋盘、棋子和交互元素的绘制
- 添加游戏状态提示和模式切换功能

关键代码解析

游戏棋盘渲染

def draw_board(self):
    # 绘制背景和标题
    self.screen.fill(self.BLUE)
    title_rect = pygame.Rect(0, 0, self.WIDTH, self.SQUARE_SIZE)
    pygame.draw.rect(self.screen, self.BLACK, title_rect)
    
    # 绘制棋盘格子和棋子
    for c in range(self.COLUMNS):
        for r in range(self.ROWS):
            pygame.draw.rect(self.screen, self.BLACK, 
                           (c * self.SQUARE_SIZE, (r + 1) * self.SQUARE_SIZE, 
                            self.SQUARE_SIZE, self.SQUARE_SIZE))
            pygame.draw.circle(self.screen, self.WHITE, 
                             (int(c * self.SQUARE_SIZE + self.SQUARE_SIZE / 2), 
                              int((r + 1) * self.SQUARE_SIZE + self.SQUARE_SIZE / 2)), 
                             self.RADIUS)
    
    # 绘制当前棋子状态
    for c in range(self.COLUMNS):
        for r in range(self.ROWS):
            if self.board[r][c] == 1:
                pygame.draw.circle(self.screen, self.RED, 
                                 (int(c * self.SQUARE_SIZE + self.SQUARE_SIZE / 2), 
                                  self.HEIGHT - int(r * self.SQUARE_SIZE + self.SQUARE_SIZE / 2)), 
                                 self.RADIUS)
            elif self.board[r][c] == 2:
                pygame.draw.circle(self.screen, self.YELLOW, 
                                 (int(c * self.SQUARE_SIZE + self.SQUARE_SIZE / 2), 
                                  self.HEIGHT - int(r * self.SQUARE_SIZE + self.SQUARE_SIZE / 2)), 
                                 self.RADIUS)

AI 决策算法

def minimax(self, depth, maximizingPlayer, alpha, beta):
    valid_locations = self.get_valid_locations()
    is_terminal = self.is_board_full() or self.check_winning_move(1) or self.check_winning_move(2)
    
    if depth == 0 or is_terminal:
        if is_terminal:
            if self.check_winning_move(2):
                return (None, 10000000)
            elif self.check_winning_move(1):
                return (None, -10000000)
            else:
                return (None, 0)
        else:
            return (None, self.score_position(2))
    
    if maximizingPlayer:
        value = -float('inf')
        column = random.choice(valid_locations)
        for col in valid_locations:
            row = self.get_next_open_row(col)
            temp_board = self.board.copy()
            self.drop_piece(row, col, 2)
            new_score = self.minimax(depth - 1, False, alpha, beta)[1]
            self.board = temp_board
            if new_score > value:
                value = new_score
                column = col
            alpha = max(alpha, value)
            if alpha >= beta:
                break
        return column, value
    else:
        value = float('inf')
        column = random.choice(valid_locations)
        for col in valid_locations:
            row = self.get_next_open_row(col)
            temp_board = self.board.copy()
            self.drop_piece(row, col, 1)
            new_score = self.minimax(depth - 1, True, alpha, beta)[1]
            self.board = temp_board
            if new_score < value:
                value = new_score
                column = col
            beta = min(beta, value)
            if alpha >= beta:
                break
        return column, value

胜利条件检查

def check_winning_move(self, player):
    # 检查水平方向
    for c in range(self.COLUMNS - 3):
        for r in range(self.ROWS):
            if (self.board[r][c] == player and 
                self.board[r][c + 1] == player and 
                self.board[r][c + 2] == player and 
                self.board[r][c + 3] == player):
                return True
    
    # 检查垂直方向
    for c in range(self.COLUMNS):
        for r in range(self.ROWS - 3):
            if (self.board[r][c] == player and 
                self.board[r + 1][c] == player and 
                self.board[r + 2][c] == player and 
                self.board[r + 3][c] == player):
                return True
    
    # 检查正对角线
    for c in range(self.COLUMNS - 3):
        for r in range(self.ROWS - 3):
            if (self.board[r][c] == player and 
                self.board[r + 1][c + 1] == player and 
                self.board[r + 2][c + 2] == player and 
                self.board[r + 3][c + 3] == player):
                return True
    
    # 检查反对角线
    for c in range(self.COLUMNS - 3):
        for r in range(3, self.ROWS):
            if (self.board[r][c] == player and 
                self.board[r - 1][c + 1] == player and 
                self.board[r - 2][c + 2] == player and 
                self.board[r - 3][c + 3] == player):
                return True
    
    return False