面向对象编程实战：用Python开发回合制PK游戏-代码聚汇网

面向对象编程实战：用Python开发回合制PK游戏

呕文不踢足球·2026-08-10·阅读 22 GEO检测（免费）

面向对象编程Python游戏开发回合制战斗系统

|难度：普通|阅读约 20 分钟

1. 项目概述：当类与对象遇上PK游戏

十年前我刚接触面向对象编程时，总把类和对象理解成"数据类型+变量"的高级版本，直到用它们开发了一个回合制PK游戏才真正开窍。这个项目用不到200行代码就实现了角色对战系统，却涵盖了面向对象三大特性最生动的应用场景。

在典型的PK游戏设计中，每个角色都是对象（Object），而它们的共性特征和行为模式则抽象为类（Class）。比如战士和法师都属于角色类（Character），但各自有不同的属性初始值和技能实现方式。当战士对象对法师对象发动攻击时，就发生了对象间的交互（Interaction），这正是面向对象编程最擅长的领域。

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. 核心类设计解析

2.1 角色基类构建

先看最基础的Character类设计，这里用Python语法演示但原理通用：

python复制class Character:
    def __init__(self, name, hp, attack):
        self.name = name    # 角色名称
        self.hp = hp        # 生命值
        self.max_hp = hp    # 最大生命值
        self.attack = attack # 攻击力
        self.skills = []    # 技能列表
    
    def take_damage(self, damage):
        self.hp = max(0, self.hp - damage)
        return f"{self.name}受到{damage}点伤害"
    
    def use_skill(self, skill_index, target):
        skill = self.skills[skill_index]
        return skill.execute(self, target)

这个基类体现了几个关键设计原则：

封装性：将角色状态（hp/attack）和行为（受伤害/使用技能）绑定在一起
可扩展性：通过skills列表支持后续添加新技能
防御性编程：take_damage方法确保hp不会变为负数

2.2 继承与多态实战

创建战士和法师这两个子类时，差异点主要体现在：

python复制class Warrior(Character):
    def __init__(self, name):
        super().__init__(name, hp=150, attack=25)
        self.skills = [NormalAttack(), FurySlash()]
        
    def passive_ability(self):
        # 战士被动：每损失10%生命值增加3点攻击
        lost_percent = (self.max_hp - self.hp) / self.max_hp
        self.attack += 3 * int(lost_percent // 0.1)

class Mage(Character):
    def __init__(self, name): 
        super().__init__(name, hp=90, attack=15)
        self.skills = [MagicMissile(), Fireball()]
        self.mana = 100  # 法师特有属性
        
    def take_damage(self, damage):
        # 法师被动：有30%概率用魔法抵消一半伤害
        if random.random() < 0.3:
            damage = damage // 2
            print(f"{self.name}发动魔法护盾！")
        return super().take_damage(damage)

这里展示了面向对象两大核心特性：

继承：子类复用父类属性和方法
多态：
- 方法重写（take_damage）
- 特有属性扩展（mana）
- 差异化技能配置

2.3 技能系统的类设计

技能系统采用策略模式实现，核心接口如下：

python复制class Skill:
    def execute(self, caster, target):
        raise NotImplementedError

class NormalAttack(Skill):
    def execute(self, caster, target):
        damage = caster.attack
        return target.take_damage(damage)

class Fireball(Skill):
    def __init__(self):
        self.cost = 20
        
    def execute(self, caster, target):
        if caster.mana < self.cost:
            return "法力值不足！"
        caster.mana -= self.cost
        damage = caster.attack * 2.5
        return target.take_damage(int(damage))

这种设计带来三个优势：

新技能只需实现Skill接口
技能效果与角色解耦
可以动态组合技能（如给战士添加魔法技能）

3. 战斗系统实现细节

3.1 回合制流程控制

战斗主循环采用状态模式管理：

python复制class Battle:
    def __init__(self, player, enemy):
        self.participants = [player, enemy]
        self.current_turn = 0
        
    def next_turn(self):
        actor = self.participants[self.current_turn % 2]
        target = self.participants[(self.current_turn + 1) % 2]
        
        print(f"\n=== {actor.name}的回合 ===")
        self.show_status()
        
        # 这里简化了实际选择逻辑
        skill_index = 0 if len(actor.skills) == 1 else get_player_input()
        result = actor.use_skill(skill_index, target)
        print(result)
        
        if target.hp <= 0:
            print(f"{target.name}已战败！")
            return False
            
        self.current_turn += 1
        return True
    
    def show_status(self):
        for char in self.participants:
            hp_bar = '█' * int(char.hp / char.max_hp * 20)
            print(f"{char.name}: {hp_bar} {char.hp}/{char.max_hp}")

关键点说明：

回合交替通过current_turn的奇偶性控制
状态显示使用文本进度条增强可读性
每次行动后检查胜负条件

3.2 对象交互时序图

用文字描述主要交互流程：

Battle.next_turn()获取当前行动者
行动者选择技能（简化版自动选择第一个技能）
技能.execute()方法被调用：
a. 消耗资源（如法力值）
b. 计算伤害公式
c. 调用target.take_damage()
目标对象更新hp状态
检查是否触发被动技能
返回战斗结果描述文本

4. 进阶实现技巧

4.1 对象池优化

当需要大量生成临时战斗特效对象时，使用对象池模式：

python复制class EffectPool:
    _instance = None
    
    @classmethod
    def get_instance(cls):
        if not cls._instance:
            cls._instance = EffectPool()
        return cls._instance
    
    def __init__(self):
        self.pool = {}
        
    def get_effect(self, effect_type):
        if effect_type not in self.pool:
            self.pool[effect_type] = []
            
        if not self.pool[effect_type]:
            new_effect = self._create_effect(effect_type)
            self.pool[effect_type].append(new_effect)
            
        return self.pool[effect_type].pop()
    
    def recycle_effect(self, effect):
        self.pool[type(effect)].append(effect)

使用方式：

python复制# 获取火球特效对象
effect = EffectPool.get_instance().get_effect(FireEffect)
# 使用后回收
EffectPool.get_instance().recycle_effect(effect)

4.2 状态管理

用享元模式实现角色状态：

python复制class StateFactory:
    _states = {}
    
    @classmethod
    def get_state(cls, state_type):
        if state_type not in cls._states:
            if state_type == "poison":
                cls._states[state_type] = PoisonState()
            elif state_type == "stun":
                cls._states[state_type] = StunState()
        return cls._states[state_type]

class PoisonState:
    def affect(self, character):
        damage = character.max_hp * 0.05
        character.take_damage(int(damage))
        print(f"{character.name}受到毒伤！")

5. 常见问题与调试技巧

5.1 对象引用问题

典型错误场景：

python复制# 错误示范：多个角色共享同一个技能列表
class Character:
    def __init__(self):
        self.skills = []  # 所有实例会共享这个列表！

# 正确做法
def __init__(self):
    self.skills = []  # 每个实例有自己的列表

调试建议：

在__init__中打印对象ID确认实例独立性
使用深拷贝(copy.deepcopy)处理嵌套对象

5.2 继承链断裂

当重写__init__时容易忘记调用父类方法：

python复制class Mage(Character):
    def __init__(self, name):
        self.mana = 100  # 错误！未初始化父类属性
        # 应该先调用：
        super().__init__(name, hp=90, attack=15)

检测方法：

单元测试验证所有父类属性是否正常初始化
使用Pylint等工具检查missing-super-call警告

5.3 多态陷阱

子类修改方法签名会导致多态失败：

python复制class Character:
    def heal(self, amount): ...

class Priest(Character):
    def heal(self, amount, is_holy=False):  # 参数不匹配！

解决方案：

保持方法参数一致，用kwargs处理扩展参数
使用ABC模块定义抽象基类强制接口一致

6. 项目扩展方向

6.1 网络对战版改造

将对象序列化用于网络传输：

python复制import json

class Character:
    def to_json(self):
        return json.dumps({
            "name": self.name,
            "hp": self.hp,
            "skills": [s.__class__.__name__ for s in self.skills]
        })
    
    @classmethod
    def from_json(cls, data):
        char_data = json.loads(data)
        char = cls(char_data["name"])
        char.hp = char_data["hp"]
        # 需要额外处理技能重建
        return char

6.2 数据驱动设计

将角色配置移到JSON文件中：

json复制{
  "warrior": {
    "base_hp": 150,
    "base_attack": 25,
    "skills": ["NormalAttack", "FurySlash"],
    "growth": {
      "hp_per_level": 15,
      "attack_per_level": 2
    }
  }
}

加载方式：

python复制with open('balance.json') as f:
    config = json.load(f)
    
class Warrior(Character):
    def __init__(self, name, level=1):
        conf = config["warrior"]
        super().__init__(
            name,
            hp=conf["base_hp"] + conf["growth"]["hp_per_level"] * (level-1),
            attack=conf["base_attack"] + conf["growth"]["attack_per_level"] * (level-1)
        )

6.3 可视化改造

用Pygame实现简单图形界面：

python复制import pygame

class GameGUI:
    def __init__(self, battle):
        pygame.init()
        self.battle = battle
        self.screen = pygame.display.set_mode((800, 600))
        
    def draw_character(self, char, x, y):
        # 绘制角色立绘
        # 绘制血条
        hp_width = 200 * (char.hp / char.max_hp)
        pygame.draw.rect(self.screen, (255,0,0), (x, y-30, hp_width, 20))
        
    def render(self):
        self.screen.fill((0,0,0))
        self.draw_character(self.battle.participants[0], 100, 300)
        self.draw_character(self.battle.participants[1], 500, 300)
        pygame.display.flip()

这个项目最让我惊喜的是，当把战斗日志输出改成图形化显示后，那些抽象的类关系突然变得具象化——屏幕上跳动的伤害数字背后，是对象间严格遵循的消息传递机制。这种从抽象到具象的认知跃迁，正是面向对象编程最迷人的地方。