从亡灵军团到优雅代码：用组合+策略模式重构游戏战斗系统
在《魔兽争霸3》的亡灵基地里，一个骷髅兵从坟场爬出需要12秒，而一支由骷髅法师、死亡骑士和骨龙组成的混合部队可能瞬间摧毁敌方基地——这种从简单单元到复杂体系的层级关系，与软件设计中处理对象组合的思维如出一辙。本文将亡灵族兵种进化树转化为设计模式教学案例，展示如何用组合模式管理部队层级，用策略模式切换战斗算法，最终实现可扩展的战斗系统架构。
1. 亡灵兵种体系中的设计模式启示
打开任何一款策略游戏的亡灵族科技树，都会发现明显的层次结构特征：基础骷髅兵可以组合成骷髅小队，小队又能与法师组成混编兵团，最终形成包含地面部队、空中单位和英雄的完整军团。这种部分-整体层次结构正是组合模式（Composite Pattern）的天然案例。
在战斗行为方面，亡灵兵种展现出惊人的策略多样性：骷髅海采用人海战术，亡灵巫师专注召唤援军，死亡骑士则擅长单体爆发。这些可互换的战术算法完美匹配策略模式（Strategy Pattern）的定义——定义算法族，分别封装起来，使它们可以互相替换。
表：亡灵兵种特征与设计模式对应关系
| 兵种类别 | 结构特征 | 行为特征 | 对应模式 |
|---|---|---|---|
| 基础单位（骷髅） | 叶子节点 | 简单攻击 | 组合模式中的Leaf |
| 复合单位（混编兵团） | 树形结构 | 协同作战 | 组合模式中的Composite |
| 法术单位（亡灵巫师） | 独立节点 | 召唤策略 | 策略模式具体实现 |
| 英雄单位（死亡骑士） | 特殊节点 | 爆发策略 | 策略模式具体实现 |
用TypeScript定义兵种接口时，这种设计变得直观：
interface Unit { attack(): void; add(unit: Unit): void; remove(unit: Unit): void; } class Skeleton implements Unit { attack() { console.log("骷髅挥动骨刀！") } add() { /* 叶子节点无需实现 */ } remove() { /* 叶子节点无需实现 */ } } class ArmyGroup implements Unit { private units: Unit[] = []; attack() { this.units.forEach(unit => unit.attack()); } add(unit: Unit) { this.units.push(unit); } remove(unit: Unit) { const index = this.units.indexOf(unit); if (index >= 0) this.units.splice(index, 1); } }2. 组合模式：构建亡灵军团层级体系
在亡灵族的军事架构中，从单兵到军团的演进展示了组合模式的核心价值。让我们解剖一个典型场景：玩家选中5个骷髅兵、2个僵尸和1个亡灵巫师，编组为"第一突击队"。这个编组本身又可以与其他编组组成更大的作战单位。
实现时我们需要区分简单元素和复合元素：
// 基础兵种（叶子节点） class Zombie implements Unit { attack() { console.log("僵尸释放瘟疫！") } //...省略add/remove } // 复合编组（容器节点） class UndeadLegion implements Unit { private children: Unit[] = []; attack() { console.log("亡灵军团协同进攻："); this.children.forEach(child => child.attack()); } add(unit: Unit) { this.children.push(unit); } // 实战技巧：添加批量编组方法 addUnits(...units: Unit[]) { units.forEach(unit => this.add(unit)); } } // 使用示例 const legion = new UndeadLegion(); legion.addUnits( new Skeleton(), new Skeleton(), new Zombie(), new Necromancer() // 假设已定义 ); legion.attack();组合模式在游戏开发中的三大优势：
- 统一处理：无论简单单位还是复杂编组，都通过同一接口操作
- 递归组合：军团可以无限嵌套子军团，形成任意复杂的指挥结构
- 动态调整：运行时可以灵活增减部队成员，适应战场变化
在Unity等游戏引擎中，这种模式常与GameObject的父子层级结合使用。例如可以将每个兵种的Prefab作为叶子节点，而空GameObject作为组合容器，通过GetComponentsInChildren
3. 策略模式：实现多变的亡灵战术
亡灵族的战斗策略手册读起来就像策略模式的教科书：面对重甲敌人使用衰老诅咒，对抗人海战术召唤骷髅，遭遇强力英雄则释放冰霜束缚。每种战术都是可互换的算法。
定义策略接口和具体实现：
interface CombatStrategy { execute(target: Enemy): void; } class SummonStrategy implements CombatStrategy { execute(target: Enemy) { console.log("召唤3个骷髅战士围攻目标"); // 实际游戏会实例化骷髅单位并设置AI } } class CurseStrategy implements CombatStrategy { execute(target: Enemy) { console.log("施加虚弱诅咒，降低目标50%攻击力"); // 实际游戏会修改敌人的状态数值 } } class FrostStrategy implements CombatStrategy { execute(target: Enemy) { console.log("释放冰霜新星冻结周围敌人"); // 实际游戏会播放粒子效果并施加减速DEBUFF } }在兵种类中使用策略：
class Necromancer implements Unit { private strategy: CombatStrategy; constructor(strategy: CombatStrategy) { this.strategy = strategy; } setStrategy(strategy: CombatStrategy) { this.strategy = strategy; } attack() { console.log("亡灵巫师开始施法..."); this.strategy.execute(selectedEnemy); } //...省略其他方法 } // 使用示例 const necro = new Necromancer(new SummonStrategy()); necro.attack(); // 使用召唤策略 // 根据战场情况切换策略 necro.setStrategy(new FrostStrategy()); necro.attack(); // 改为使用冰冻策略表：策略模式在游戏AI中的典型应用场景
| 情境 | 适用策略 | 效果 |
|---|---|---|
| 敌方数量>5 | 召唤骷髅海 | 用数量抵消敌方优势 |
| 敌方有治疗单位 | 瘟疫传播 | 禁止治疗效果 |
| 敌方英雄血量<30% | 死亡一指 | 高爆发单体伤害 |
| 友方单位密集 | 黑暗治愈 | 群体恢复亡灵血量 |
4. 模式联合作战：构建亡灵指挥系统
真正的设计艺术在于模式的组合运用。让我们创建一个同时使用组合模式和策略模式的亡灵指挥系统：
class IntelligentUnit implements Unit { private basicStrategy: CombatStrategy; private emergencyStrategy: CombatStrategy; private currentStrategy: CombatStrategy; private children: Unit[] = []; constructor( basic: CombatStrategy, emergency: CombatStrategy ) { this.basicStrategy = basic; this.emergencyStrategy = emergency; this.currentStrategy = basic; } attack() { // 组合模式：先让子单位攻击 this.children.forEach(child => child.attack()); // 策略模式：根据情况选择策略 if (this.shouldUseEmergency()) { this.currentStrategy = this.emergencyStrategy; } this.currentStrategy.execute(selectTarget()); } private shouldUseEmergency(): boolean { // 根据战场情况判断是否启用应急策略 return this.children.length < 3 || enemyHeroNearby(); } //...实现其他组合模式方法 }这个设计带来了战场上的灵活应对：
- 常规情况下使用基础策略（如骷髅兵的普通攻击）
- 当部队减员或敌方英雄靠近时自动切换应急策略（如死亡骑士的死亡缠绕）
- 编组内的所有单位协同执行统一战术
在MMO游戏开发中，这种模式组合可以扩展为更复杂的AI行为树。例如：
亡灵军团AI（组合模式） ├─ 前锋小队（策略：冲锋） │ ├─ 骷髅兵×5 │ └─ 僵尸×2 ├─ 远程支援（策略：集火） │ ├─ 骷髅法师×3 │ └─ 亡灵巫师×1 └─ 英雄单位（策略：斩首） └─ 死亡骑士5. 性能优化与陷阱规避
虽然组合+策略模式强大，但在游戏开发这个性能敏感的领域需要特别注意以下实现细节：
对象池优化：亡灵族的特点是大规模单位生成/销毁，应使用对象池管理模式：
class UnitPool { private static skeletons: Skeleton[] = []; static getSkeleton(): Skeleton { return this.skeletons.pop() || new Skeleton(); } static recycle(unit: Skeleton) { unit.resetState(); // 重置单位状态 this.skeletons.push(unit); } } // 使用示例 const skelly = UnitPool.getSkeleton(); // ...战斗结束后 UnitPool.recycle(skelly);策略切换成本控制：避免每帧都创建新策略实例，推荐预初始化：
// 预先创建策略单例 class CombatStrategies { static readonly SUMMON = new SummonStrategy(); static readonly CURSE = new CurseStrategy(); static readonly FROST = new FrostStrategy(); } // 使用时直接引用 necro.setStrategy(CombatStrategies.FROST);常见陷阱警示：
- 避免过度嵌套的组合结构（建议不超过7层）
- 策略实现应保持无状态，必要时通过参数传递上下文
- 在频繁调用的攻击方法中避免复杂策略判断
6. 现代游戏引擎中的实现演进
在Unity的ECS架构中，我们可以用更符合现代游戏开发的方式实现这些模式。以下是一个基于Entities 1.0的示例：
// 组合模式：通过Parent组件实现层级 public struct ArmyGroup : IComponentData { public Entity ParentEntity; } // 策略模式：通过状态组件切换 public struct CombatStrategy : IComponentData { public StrategyType Current; } public enum StrategyType { Summon, Curse, Frost } // 系统实现 [UpdateInGroup(typeof(CombatSystemGroup))] public partial class UndeadCombatSystem : SystemBase { protected override void OnUpdate() { Entities .WithAll<UndeadTag>() .ForEach((ref CombatStrategy strategy, in DynamicBuffer<Child> children) => { // 根据条件切换策略 if (/* 满足召唤条件 */) { strategy.Current = StrategyType.Summon; } // 执行当前策略 ExecuteStrategy(strategy.Current, children); }).Schedule(); } private void ExecuteStrategy(StrategyType type, DynamicBuffer<Child> units) { // 策略实现... } }这种数据导向的实现方式比传统OOP模式更适合现代高性能游戏开发，同时保留了组合与策略模式的核心思想。
7. 实战案例：亡灵族战役关卡设计
让我们设计一个体现模式优势的关卡流程：
关卡目标：突破人类防线摧毁圣堂玩家配置：
- 基础单位：骷髅兵（自动生成）
- 特殊单位：亡灵巫师×1（可切换策略）
- 英雄单位：死亡骑士×1（固定策略）
AI行为脚本：
def update_undead_ai(): # 组合模式管理 main_army = ArmyGroup() main_army.add(auto_spawn_skeletons()) # 自动生成骷髅 main_army.add(get_necromancer()) # 获取巫师实例 # 根据战场事件切换策略 if enemy_building_detected(): get_necromancer().set_strategy(SummonStrategy()) elif enemy_hero_detected(): get_necromancer().set_strategy(CurseStrategy()) # 执行攻击 main_army.attack() # 英雄特殊逻辑 if main_army.units.size() < 5: summon_death_knight() # 部队不足时召唤死亡骑士关卡设计技巧：
- 初期让玩家体验基础组合（骷髅+巫师）
- 中期引入策略选择（按Q切换巫师战术）
- 后期解锁高级组合（死亡骑士指挥混编部队）
- BOSS战展示模式协作（同时运用组合指挥和策略切换）
在Unreal Engine中，可以用行为树实现类似的AI逻辑：
UndeadBehaviorTree ├─ Selector（组合模式） │ ├─ Sequence: 召唤增援 │ │ ├─ 条件: 部队数量<10 │ │ └─ 动作: 执行召唤策略 │ └─ Sequence: 集火攻击 │ ├─ 条件: 发现高价值目标 │ └─ 动作: 执行集火策略 └─ 并行节点 ├─ 持续生成骷髅 └─ 监视英雄状态8. 扩展应用：从游戏到企业软件
这些游戏开发中的模式实践，同样适用于企业应用开发。比如电商平台：
组合模式：处理商品分类层级
- 电子产品
- 手机
- 智能手机
- 功能机
- 电脑
- 手机
- 家居用品
- ...
- 电子产品
策略模式：实现不同的促销算法
- 满减策略
- 折扣策略
- 赠品策略
Java实现示例：
// 组合模式：商品分类 public interface CatalogComponent { void display(); void add(CatalogComponent component); } public class ProductCategory implements CatalogComponent { private List<CatalogComponent> items = new ArrayList<>(); public void display() { items.forEach(CatalogComponent::display); } public void add(CatalogComponent component) { items.add(component); } } // 策略模式：促销策略 public interface PromotionStrategy { double applyDiscount(double originalPrice); } public class ChristmasPromotion implements PromotionStrategy { public double applyDiscount(double price) { return price * 0.7; // 30% off } }这种跨领域的模式迁移，正是软件设计模式的魅力所在。就像亡灵巫师将不同尸体组合成新的战斗单位，开发者通过模式组合也能创造出强大的系统架构。
