Python 一步一步教你用pyglet制作“彩色方块连连看”游戏(续)

一、背景与问题

在上一篇文章中，我们完成了彩色方块连连看游戏的基础框架，包括窗口创建、方块绘制和基本的事件处理。现在我们需要深入探讨游戏的核心机制，包括：

1. 精确的坐标计算和碰撞检测
2. 游戏状态管理与重玩机制
3. 动画效果与性能优化
4. 可扩展性设计
5. 安全性考量

这些内容将帮助我们构建一个更完整、更健壮的游戏系统，同时揭示在实际开发中需要注意的关键点。

二、基本原理

1. 坐标系统与碰撞检测

pyglet使用的是基于屏幕坐标的坐标系，原点(0,0)位于左上角。我们需要将游戏中的逻辑坐标转换为屏幕坐标：

def logical_to_screen(x, y):
    # 假设每个方块大小为64x64
    return (x * 64 + 32, y * 64 + 32)

碰撞检测需要考虑以下因素：

• 方块的相对位置
• 连线的长度限制
• 路径的平滑度

2. 游戏状态管理

游戏状态通常包含：

• 当前选择的方块
• 已连接的路径
• 游戏是否结束
• 计时器信息

3. 动画效果

使用pyglet的Schedule系统实现平滑动画效果：

pyglet.clock.schedule_interval(update, 1/60)

三、环境准备

确保已安装pyglet和必要的依赖：

pip install pyglet

项目结构建议：

connect4/
│
├── main.py                # 主程序入口
├── game.py               # 游戏核心逻辑
├── assets/               # 资源文件
│   ├── icons/            # 图标资源
│   └── sounds/           # 音效资源
└── utils/                # 工具类
    ├── collision.py      # 碰撞检测工具
    └── state.py          # 状态管理工具

四、核心实现

1. 方块类实现

class Block:
    def __init__(self, x, y, color):
        self.x = x
        self.y = y
        self.color = color
        self.selected = False
        self.connected = False
        
    def draw(self):
        # 绘制方块逻辑
        pass
        
    def is_connected(self, other):
        # 判断是否能连接
        return abs(self.x - other.x) <= 2 and abs(self.y - other.y) <= 2
        
    def calculate_distance(self, other):
        # 计算欧几里得距离
        return math.sqrt((self.x - other.x)**2 + (self.y - other.y)**2)

关键点：

• 使用坐标差判断相邻方块
• 欧几里得距离用于判断连线长度
• selected状态用于标记选中方块

2. 碰撞检测系统

class CollisionDetector:
    def __init__(self, blocks):
        self.blocks = blocks
        
    def check_connection(self, block1, block2):
        if block1 is None or block2 is None:
            return False
            
        # 检查是否相邻
        if not block1.is_connected(block2):
            return False
            
        # 检查是否已连接
        if block1.connected or block2.connected:
            return False
            
        # 检查是否形成环路
        return self._check_cycle(block1, block2)
    
    def _check_cycle(self, start, end):
        visited = set()
        stack = [start]
        
        while stack:
            current = stack.pop()
            if current in visited:
                continue
            visited.add(current)
            
            if current == end:
                return True
                
            for block in self.blocks:
                if block is not current and block.is_connected(current):
                    stack.append(block)
        
        return False

关键点：

• 使用深度优先搜索检测环路
• 避免重复连接
• 确保路径有效性

3. 游戏状态管理

class GameState:
    def __init__(self):
        self.selected_block = None
        self.path = []
        self.game_over = False
        self.start_time = None
        
    def select_block(self, block):
        if self.selected_block:
            self.deselect_block()
            
        self.selected_block = block
        block.selected = True
        
    def deselect_block(self):
        if self.selected_block:
            self.selected_block.selected = False
            self.selected_block = None
            
    def connect_blocks(self, block1, block2):
        if self.selected_block is None:
            return False
            
        if block1 is None and block2 is None:
            return False
            
        if self.selected_block is block1:
            self.path.append(block2)
        elif self.selected_block is block2:
            self.path.append(block1)
        else:
            return False
            
        # 确认连接有效性
        if self._validate_connection(block1, block2):
            block1.connected = True
            block2.connected = True
            self.path.clear()
            return True
            
        return False
    
    def _validate_connection(self, block1, block2):
        # 验证连接逻辑
        return self.collision_detector.check_connection(block1, block2)

关键点：

• 状态切换逻辑
• 路径管理
• 有效性验证

五、完整案例

创建完整的连连看游戏：

import pyglet
import math
import random

class Block:
    def __init__(self, x, y, color):
        self.x = x
        self.y = y
        self.color = color
        self.selected = False
        self.connected = False
        
    def draw(self):
        # 绘制方块逻辑
        pass
        
    def is_connected(self, other):
        return abs(self.x - other.x) <= 2 and abs(self.y - other.y) <= 2
        
    def calculate_distance(self, other):
        return math.sqrt((self.x - other.x)**2 + (self.y - other.y)**2)

class CollisionDetector:
    def __init__(self, blocks):
        self.blocks = blocks
        
    def check_connection(self, block1, block2):
        if block1 is None or block2 is None:
            return False
            
        if not block1.is_connected(block2):
            return False
            
        if block1.connected or block2.connected:
            return False
            
        return self._check_cycle(block1, block2)
    
    def _check_cycle(self, start, end):
        visited = set()
        stack = [start]
        
        while stack:
            current = stack.pop()
            if current in visited:
                continue
            visited.add(current)
            
            if current == end:
                return True
                
            for block in self.blocks:
                if block is not current and block.is_connected(current):
                    stack.append(block)
        
        return False

class GameState:
    def __init__(self):
        self.selected_block = None
        self.path = []
        self.game_over = False
        self.start_time = None
        self.collision_detector = CollisionDetector([])
        
    def select_block(self, block):
        if self.selected_block:
            self.deselect_block()
            
        self.selected_block = block
        block.selected = True
        
    def deselect_block(self):
        if self.selected_block:
            self.selected_block.selected = False
            self.selected_block = None
            
    def connect_blocks(self, block1, block2):
        if self.selected_block is None:
            return False
            
        if block1 is None and block2 is None:
            return False
            
        if self.selected_block is block1:
            self.path.append(block2)
        elif self.selected_block is block2:
            self.path.append(block1)
        else:
            return False
            
        if self._validate_connection(block1, block2):
            block1.connected = True
            block2.connected = True
            self.path.clear()
            return True
            
        return False
    
    def _validate_connection(self, block1, block2):
        return self.collision_detector.check_connection(block1, block2)

class GameWindow(pyglet.window.Window):
    def __init__(self):
        super().__init__(width=800, height=600, caption='彩色方块连连看')
        self.game_state = GameState()
        self.blocks = []
        self.load_blocks()
        self.schedule_update()
        
    def load_blocks(self):
        # 创建随机分布的方块
        for i in range(10):
            x = random.randint(0, 9)
            y = random.randint(0, 6)
            color = random.choice(['red', 'blue', 'green', 'yellow'])
            self.blocks.append(Block(x, y, color))
            self.game_state.collision_detector.blocks = self.blocks
        
    def schedule_update(self):
        pyglet.clock.schedule_interval(self.update, 1/60)
        
    def update(self, dt):
        # 游戏逻辑更新
        pass
        
    def on_draw(self):
        self.clear()
        # 绘制方块
        for block in self.blocks:
            block.draw()
            
    def on_mouse_press(self, x, y, button, modifiers):
        # 处理鼠标点击
        pass
            
    def on_mouse_release(self, x, y, button, modifiers):
        # 处理鼠标释放
        pass
            
    def on_mouse_motion(self, x, y, dx, dy):
        # 处理鼠标移动
        pass

if __name__ == '__main__':
    game_window = GameWindow()
    pyglet.app.run()

关键点：

• 游戏主循环
• 方块管理
• 事件处理
• 状态更新

六、源码解析

1. 坐标转换逻辑

在Block.draw()方法中需要将逻辑坐标转换为屏幕坐标：

def draw(self):
    # 假设每个方块大小为64x64
    screen_x = self.x * 64 + 32
    screen_y = self.y * 64 + 32
    # 绘制方块的代码

2. 碰撞检测算法

在CollisionDetector.check_connection()中，通过深度优先搜索检测环路：

def _check_cycle(self, start, end):
    visited = set()
    stack = [start]
    
    while stack:
        current = stack.pop()
        if current in visited:
            continue
        visited.add(current)
        
        if current == end:
            return True
            
        for block in self.blocks:
            if block is not current and block.is_connected(current):
                stack.append(block)
    
    return False

3. 状态管理逻辑

在GameState.connect_blocks()中处理连接逻辑：

def connect_blocks(self, block1, block2):
    # 有效性验证
    if self._validate_connection(block1, block2):
        block1.connected = True
        block2.connected = True
        self.path.clear()
        return True
        
    return False

七、进阶使用

1. 动画效果优化

使用pyglet的Animation类实现平滑动画：

class Animation:
    def __init__(self, target, duration):
        self.target = target
        self.duration = duration
        self.start_time = pyglet.clock.get_time()
        
    def update(self, dt):
        elapsed = pyglet.clock.get_time() - self.start_time
        if elapsed > self.duration:
            self.target = None
            
    def draw(self):
        # 动画绘制逻辑
        pass

2. 状态持久化

使用pickle保存游戏状态：

import pickle

def save_game(state):
    with open('game_state.pkl', 'wb') as f:
        pickle.dump(state, f)
        
def load_game():
    with open('game_state.pkl', 'rb') as f:
        return pickle.load(f)

3. 多语言支持

添加国际化支持：

import gettext

def setup_i18n():
    lang = gettext.translation('game', localedir='locale', languages=['zh_CN', 'en_US'])
    lang.install()
    return lang

八、性能与工程实践

1. 性能优化

• 使用对象池管理方块实例
• 启用双缓冲减少闪烁
• 使用pyglet.image优化图像加载
• 使用pyglet.sprite.Sprite代替手动绘制

2. 异常处理

处理可能的异常情况：

try:
    block = Block(x, y, color)
except Exception as e:
    print(f"创建方块失败: {e}")
    # 记录日志

3. 安全性考量

• 验证用户输入
• 防止恶意连接
• 资源加载安全检查

九、常见问题与踩坑

1. 坐标计算错误

错误示例：

def draw(self):
    screen_x = self.x * 64  # 错误：未加偏移
    screen_y = self.y * 64

解决方法：确保坐标转换正确，考虑屏幕坐标系的差异。

2. 碰撞检测环路

错误示例：

def _check_cycle(self, start, end):
    # 错误的环路检测逻辑
    return start == end

解决方法：使用深度优先搜索算法检测环路。

3. 资源管理不当

错误示例：

def load_blocks(self):
    # 错误：未清理旧方块
    for i in range(10):
        self.blocks.append(Block(...))

解决方法：在加载新方块前清空旧列表。

十、最佳实践

1. 使用面向对象设计分离关注点
2. 使用状态机管理游戏状态
3. 使用工厂模式创建方块
4. 使用策略模式处理不同连接规则
5. 使用观察者模式通知状态变化
6. 使用单元测试验证关键逻辑
7. 使用性能分析工具监控资源使用

十一、总结

通过本篇文章，我们深入探讨了使用pyglet开发"彩色方块连连看"游戏的各个方面。从核心的碰撞检测算法到复杂的状态管理，再到性能优化和安全性考量，我们构建了一个完整的2D游戏框架。

在实际开发中，pyglet特别适合以下场景：

• 小型2D游戏开发
• 快速原型设计
• 教学项目
• 简单的图形界面应用

但需要注意以下限制：

• 不适合复杂的3D图形
• 不适合需要网络功能的游戏
• 不适合需要处理大量数据的场景

通过合理的设计和优化，pyglet仍然可以成为开发高质量2D游戏的优秀选择。记住，良好的架构设计和测试是确保游戏稳定性的关键。