Python 一步一步教你用pyglet制作“彩色方块连连看”游戏(续)
一、背景与问题
在上一篇文章中，我们完成了彩色方块连连看游戏的基础框架，包括窗口创建、方块绘制和基本的事件处理。现在我们需要深入探讨游戏的核心机制，包括：
- 精确的坐标计算和碰撞检测
- 游戏状态管理与重玩机制
- 动画效果与性能优化
- 可扩展性设计
- 安全性考量
这些内容将帮助我们构建一个更完整、更健壮的游戏系统，同时揭示在实际开发中需要注意的关键点。
二、基本原理
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 False3. 状态管理逻辑
在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):
# 动画绘制逻辑
pass2. 状态持久化
使用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(...))解决方法：在加载新方块前清空旧列表。
十、最佳实践
- 使用面向对象设计分离关注点
- 使用状态机管理游戏状态
- 使用工厂模式创建方块
- 使用策略模式处理不同连接规则
- 使用观察者模式通知状态变化
- 使用单元测试验证关键逻辑
- 使用性能分析工具监控资源使用
十一、总结
通过本篇文章，我们深入探讨了使用pyglet开发"彩色方块连连看"游戏的各个方面。从核心的碰撞检测算法到复杂的状态管理，再到性能优化和安全性考量，我们构建了一个完整的2D游戏框架。
在实际开发中，pyglet特别适合以下场景：
- 小型2D游戏开发
- 快速原型设计
- 教学项目
- 简单的图形界面应用
但需要注意以下限制：
- 不适合复杂的3D图形
- 不适合需要网络功能的游戏
- 不适合需要处理大量数据的场景
通过合理的设计和优化，pyglet仍然可以成为开发高质量2D游戏的优秀选择。记住，良好的架构设计和测试是确保游戏稳定性的关键。