python单机五子棋的代码怎么写

发布时间：2021-10-22 13:46:50 作者：柒染
来源：亿速云阅读：429

# Python单机五子棋的代码怎么写

本文将详细介绍如何使用Python开发一个单机版五子棋游戏，包含完整代码实现和分步解析。这个项目适合Python初学者学习基础语法和游戏开发逻辑。

## 一、项目概述

五子棋是一种经典的策略型棋类游戏，玩家通过在棋盘上交替落子，先形成五子连线的一方获胜。我们将使用Python的Pygame库来实现图形界面，并采用简单的算法实现人机对战。

### 主要功能模块
1. 图形界面绘制
2. 玩家落子处理
3. 简单实现
4. 胜负判断
5. 游戏状态管理

## 二、开发环境准备

首先需要安装必要的库：

```bash
pip install pygame numpy

Pygame：用于图形界面和事件处理
Numpy：简化二维数组操作（可选）

三、完整代码实现

以下是完整的五子棋游戏代码（约200行）：

import pygame
import sys
import numpy as np
from pygame.locals import *

# 初始化常量
BOARD_SIZE = 15  # 15x15的棋盘
GRID_SIZE = 40   # 每个格子的像素大小
MARGIN = 40      # 棋盘边距
PIECE_RADIUS = 18  # 棋子半径
WINDOW_SIZE = BOARD_SIZE * GRID_SIZE + 2 * MARGIN
BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
BOARD_COLOR = (220, 179, 92)
RED = (255, 0, 0)
BLUE = (0, 0, 255)

# 初始化游戏
def init_game():
    pygame.init()
    screen = pygame.display.set_mode((WINDOW_SIZE, WINDOW_SIZE))
    pygame.display.set_caption('五子棋')
    return screen

# 绘制棋盘
def draw_board(screen):
    screen.fill(BOARD_COLOR)
    # 绘制网格线
    for i in range(BOARD_SIZE):
        # 横线
        pygame.draw.line(screen, BLACK, 
                        (MARGIN, MARGIN + i * GRID_SIZE), 
                        (WINDOW_SIZE - MARGIN, MARGIN + i * GRID_SIZE), 2)
        # 竖线
        pygame.draw.line(screen, BLACK, 
                        (MARGIN + i * GRID_SIZE, MARGIN), 
                        (MARGIN + i * GRID_SIZE, WINDOW_SIZE - MARGIN), 2)
    # 绘制五个小黑点（天元等）
    dots = [(3, 3), (11, 3), (3, 11), (11, 11), (7, 7)]
    for dot in dots:
        pygame.draw.circle(screen, BLACK, 
                          (MARGIN + dot[0] * GRID_SIZE, MARGIN + dot[1] * GRID_SIZE), 5)

# 游戏主类
class GomokuGame:
    def __init__(self):
        self.board = np.zeros((BOARD_SIZE, BOARD_SIZE), dtype=int)  # 0空 1黑 2白
        self.current_player = 1  # 黑棋先行
        self.game_over = False
        self.winner = None
    
    # 落子
    def place_piece(self, row, col):
        if self.game_over or self.board[row][col] != 0:
            return False
        
        self.board[row][col] = self.current_player
        if self.check_win(row, col):
            self.game_over = True
            self.winner = self.current_player
        else:
            self.current_player = 3 - self.current_player  # 切换玩家
        return True
    
    # 检查是否获胜
    def check_win(self, row, col):
        directions = [(1, 0), (0, 1), (1, 1), (1, -1)]  # 横竖斜四个方向
        for dr, dc in directions:
            count = 1  # 当前落子
            # 正向检查
            r, c = row + dr, col + dc
            while 0 <= r < BOARD_SIZE and 0 <= c < BOARD_SIZE and self.board[r][c] == self.current_player:
                count += 1
                r += dr
                c += dc
            # 反向检查
            r, c = row - dr, col - dc
            while 0 <= r < BOARD_SIZE and 0 <= c < BOARD_SIZE and self.board[r][c] == self.current_player:
                count += 1
                r -= dr
                c -= dc
            if count >= 5:
                return True
        return False
    
    # 简单落子
    def ai_move(self):
        if self.game_over:
            return
        
        # 优先防守：检查玩家是否有四连
        for i in range(BOARD_SIZE):
            for j in range(BOARD_SIZE):
                if self.board[i][j] == 0:
                    self.board[i][j] = 1  # 假设玩家落子
                    if self.check_win(i, j):
                        self.board[i][j] = 2  # 拦截
                        if self.check_win(i, j):
                            self.game_over = True
                            self.winner = 2
                        self.current_player = 1
                        return (i, j)
                    self.board[i][j] = 0
        
        # 随机落子
        empty_positions = [(i, j) for i in range(BOARD_SIZE) for j in range(BOARD_SIZE) if self.board[i][j] == 0]
        if empty_positions:
            return empty_positions[np.random.randint(len(empty_positions))]
        return None

# 绘制棋子
def draw_pieces(screen, game):
    for i in range(BOARD_SIZE):
        for j in range(BOARD_SIZE):
            if game.board[i][j] == 1:  # 黑棋
                pygame.draw.circle(screen, BLACK, 
                                 (MARGIN + j * GRID_SIZE, MARGIN + i * GRID_SIZE), 
                                 PIECE_RADIUS)
            elif game.board[i][j] == 2:  # 白棋
                pygame.draw.circle(screen, WHITE, 
                                 (MARGIN + j * GRID_SIZE, MARGIN + i * GRID_SIZE), 
                                 PIECE_RADIUS)
                pygame.draw.circle(screen, BLACK, 
                                 (MARGIN + j * GRID_SIZE, MARGIN + i * GRID_SIZE), 
                                 PIECE_RADIUS, 1)

# 显示游戏结果
def show_result(screen, winner):
    font = pygame.font.Font(None, 72)
    if winner == 1:
        text = font.render("黑棋获胜!", True, RED)
    else:
        text = font.render("白棋获胜!", True, BLUE)
    text_rect = text.get_rect(center=(WINDOW_SIZE//2, WINDOW_SIZE//2))
    screen.blit(text, text_rect)

# 主函数
def main():
    screen = init_game()
    game = GomokuGame()
    
    while True:
        for event in pygame.event.get():
            if event.type == QUIT:
                pygame.quit()
                sys.exit()
            
            if event.type == MOUSEBUTTONDOWN and not game.game_over:
                if game.current_player == 1:  # 玩家回合
                    x, y = pygame.mouse.get_pos()
                    col = round((x - MARGIN) / GRID_SIZE)
                    row = round((y - MARGIN) / GRID_SIZE)
                    if 0 <= row < BOARD_SIZE and 0 <= col < BOARD_SIZE:
                        if game.place_piece(row, col):
                            # 回合
                            ai_pos = game.ai_move()
                            if ai_pos:
                                game.place_piece(*ai_pos)
        
        draw_board(screen)
        draw_pieces(screen, game)
        if game.game_over:
            show_result(screen, game.winner)
        pygame.display.update()

if __name__ == "__main__":
    main()

四、代码分步解析

1. 初始化设置

BOARD_SIZE = 15  # 标准五子棋棋盘大小
GRID_SIZE = 40   # 每个格子的像素尺寸
MARGIN = 40      # 棋盘边缘留白

这些常量定义了棋盘的基本参数，可以根据需要调整。标准五子棋使用15×15的棋盘，我们设置每个格子40像素宽，边缘留白40像素。

2. 游戏状态管理

GomokuGame类负责维护游戏状态：

board: 15×15的二维数组，记录每个位置的棋子状态
current_player: 当前回合玩家（1为黑棋，2为白棋）
game_over: 游戏是否结束标志
winner: 获胜方

3. 胜负判断算法

check_win方法实现了五子棋的核心胜负判断逻辑：

def check_win(self, row, col):
    directions = [(1, 0), (0, 1), (1, 1), (1, -1)]  # 横竖斜四个方向
    for dr, dc in directions:
        count = 1  # 当前落子
        # 正向检查
        r, c = row + dr, col + dc
        while 0 <= r < BOARD_SIZE and 0 <= c < BOARD_SIZE and self.board[r][c] == self.current_player:
            count += 1
            r += dr
            c += dc
        # 反向检查
        r, c = row - dr, col - dc
        while 0 <= r < BOARD_SIZE and 0 <= c < BOARD_SIZE and self.board[r][c] == self.current_player:
            count += 1
            r -= dr
            c -= dc
        if count >= 5:
            return True
    return False

该方法从当前落子位置向四个方向（水平、垂直、两个对角线）检查是否有五个或更多同色棋子连续排列。

4. 简单实现

我们的实现了基本防守逻辑：

def ai_move(self):
    # 优先拦截玩家即将获胜的位置
    for i in range(BOARD_SIZE):
        for j in range(BOARD_SIZE):
            if self.board[i][j] == 0:
                self.board[i][j] = 1  # 假设玩家落子
                if self.check_win(i, j):
                    self.board[i][j] = 2  # 拦截
                    return (i, j)
                self.board[i][j] = 0
    
    # 没有危险则随机落子
    empty_positions = [(i, j) for i in range(BOARD_SIZE) for j in range(BOARD_SIZE) if self.board[i][j] == 0]
    if empty_positions:
        return empty_positions[np.random.randint(len(empty_positions))]

这个会： 1. 首先检查玩家是否有四连需要拦截 2. 如果没有威胁，则随机选择空位落子

5. 图形界面渲染

使用Pygame绘制棋盘和棋子：

def draw_board(screen):
    # 绘制棋盘网格
    for i in range(BOARD_SIZE):
        pygame.draw.line(screen, BLACK, 
                       (MARGIN, MARGIN + i * GRID_SIZE), 
                       (WINDOW_SIZE - MARGIN, MARGIN + i * GRID_SIZE), 2)
        pygame.draw.line(screen, BLACK, 
                       (MARGIN + i * GRID_SIZE, MARGIN), 
                       (MARGIN + i * GRID_SIZE, WINDOW_SIZE - MARGIN), 2)

def draw_pieces(screen, game):
    for i in range(BOARD_SIZE):
        for j in range(BOARD_SIZE):
            if game.board[i][j] == 1:  # 黑棋
                pygame.draw.circle(screen, BLACK, 
                                 (MARGIN + j * GRID_SIZE, MARGIN + i * GRID_SIZE), 
                                 PIECE_RADIUS)

五、功能扩展建议

这个基础版本可以进一步扩展：

增强：实现评分函数、Minimax算法或Alpha-Beta剪枝
游戏设置：添加选择先手、调整棋盘大小等功能
悔棋功能：记录落子历史，支持回退
网络对战：使用socket实现联机对战
音效和动画：添加落子音效和动画效果

六、总结

通过这个约200行的Python项目，我们实现了一个完整的单机五子棋游戏，包含： - 图形界面显示 - 玩家交互 - 简单对手 - 胜负判断

这个项目涵盖了Python基础语法、面向对象编程、二维数组处理和基本游戏开发逻辑，是学习Python编程的绝佳实践项目。读者可以基于这个基础版本继续扩展更复杂的功能。

希望本文对你学习Python游戏开发有所帮助！完整代码已在上文提供，可以直接运行体验。 “`