1
// ========== 重构前：一个类包含所有 ==========
2
class GameCharacter {
3
    Vector3 position;
4
    float health;
5
    Mesh* mesh;
6

7
public:
8
    void MoveTo(const Vector3& target) { /* ... */ }
9
    void TakeDamage(float dmg)          { /* ... */ }
10
    void Draw()                         { /* ... */ }
11
};
12

13
// ========== 重构后：按职责拆分 ==========
14

15
// 纯数据结构——数据本身不应该知道怎么被修改
16
struct CharacterData {
17
    Vector3 position;
18
    Vector3 velocity;
19
    float health;
20
    float maxHealth;
21
};
22

23
// 移动系统——只关心位置和速度
24
class MovementSystem {
25
public:
26
    void MoveTo(CharacterData& data, const Vector3& target) {
27
        Vector3 direction = (target - data.position).Normalized();
28
        data.position += direction * speed * Time::Delta();
29
    }
30

31
    void Jump(CharacterData& data) {
32
        if (IsGrounded(data)) {
33
            data.velocity.y = jumpForce;
34
        }
35
    }
36

37
private:
38
    float speed = 5.0f;
39
    float jumpForce = 10.0f;
40
    bool IsGrounded(const CharacterData& data) const;
41
};
42

43
// 战斗系统——只关心血量
44
class CombatSystem {
45
public:
46
    void TakeDamage(CharacterData& data, float amount) {
47
        data.health = std::max(0.0f, data.health - amount);
48
        if (data.health <= 0.0f) {
49
            OnDeath(data);
50
        }
51
    }
52

53
    // 死亡事件——观察者模式（Ch3 会深入讲）
54
    std::function<void(const CharacterData&)> OnDeath;
55
};
56

57
// 渲染组件——只关心怎么画
58
class RenderComponent {
59
    Mesh* mesh;
60
    Material* material;
61
public:
62
    void Draw(const CharacterData& data) {
63
        Graphics::DrawMesh(mesh, material, data.position);
64
    }
65
};

1
// ❌ 违反 OCP：加一种伤害类型就要改这段代码
2
float CalculateDamage(DamageType type, float baseDamage, const Enemy& target) {
3
    switch (type) {
4
    case DamageType::PHYSICAL:
5
        return baseDamage - target.GetArmor();
6
    case DamageType::MAGICAL:
7
        return baseDamage * (1.0f - target.GetMagicResist());
8
    case DamageType::FIRE:
9
        return baseDamage * GetFireMultiplier(target);
10
    case DamageType::ICE:
11
        return baseDamage * GetIceMultiplier(target) + SlowEffect(target);
12
    // 策划说"加一个'真实伤害'类型"——你又来改这里了
13
    default:
14
        return baseDamage;
15
    }
16
}

1
// ✅ OCP 版本：加新伤害类型 = 加新类，不改旧代码
2

3
// 抽象基类——定义了"伤害计算"这个契约
4
class IDamageCalculator {
5
public:
6
    virtual float Calculate(float baseDamage, const Enemy& target) const = 0;
7
    virtual ~IDamageCalculator() = default;
8
};
9

10
class PhysicalDamage : public IDamageCalculator {
11
public:
12
    float Calculate(float base, const Enemy& target) const override {
13
        return base - target.GetArmor();
14
    }
15
};
16

17
class MagicalDamage : public IDamageCalculator {
18
public:
19
    float Calculate(float base, const Enemy& target) const override {
20
        return base * (1.0f - target.GetMagicResist());
21
    }
22
};
23

24
class TrueDamage : public IDamageCalculator {
25
public:
26
    float Calculate(float base, const Enemy&) const override {
27
        return base;  // 无视一切防御——新类型，新建一个类就完了
28
    }
29
};
30

31
// 使用方——不再依赖具体类型
32
float ApplyDamage(const IDamageCalculator& calculator,
33
                  float base, const Enemy& target) {
34
    return calculator.Calculate(base, target);
35
}

1
class Rectangle {
2
protected:
3
    int width, height;
4
public:
5
    virtual void SetWidth(int w)  { width = w; }
6
    virtual void SetHeight(int h) { height = h; }
7
    int GetWidth()  const { return width; }
8
    int GetHeight() const { return height; }
9
    int Area()      const { return width * height; }
10
};
11

12
// "正方形是特殊的矩形"——数学上对，代码上错
13
class Square : public Rectangle {
14
public:
15
    void SetWidth(int w) override {
16
        Rectangle::SetWidth(w);
17
        Rectangle::SetHeight(w);  // 保持正方形约束
18
    }
19
    void SetHeight(int h) override {
20
        Rectangle::SetWidth(h);
21
        Rectangle::SetHeight(h);  // 保持正方形约束
22
    }
23
};
24

25
// ========== Bug 在此 ==========
26
void ResizeShape(Rectangle& r) {
27
    r.SetWidth(5);
28
    r.SetHeight(3);
29
    // 对于 Rectangle：area = 5 × 3 = 15  ✅
30
    // 对于 Square：area = 3 × 3 = 9   ❌ 调用方不知道发生了什么
31
    assert(r.Area() == 15);  // 传入 Square 时爆炸
32
}

1
// ❌ 一个游戏中的 LSP 违反案例
2

3
class Entity {
4
public:
5
    virtual void MoveTo(const Vector3& target) {
6
        position = target;
7
    }
8
    virtual void TakeDamage(float amount) {
9
        health -= amount;
10
    }
11
protected:
12
    Vector3 position;
13
    float health;
14
};
15

16
// 建筑物——不能移动，没有血量
17
class Building : public Entity {
18
public:
19
    void MoveTo(const Vector3&) override {
20
        // 建筑不能移动——抛异常？
21
        throw std::logic_error("Building cannot move!");
22
    }
23

24
    void TakeDamage(float amount) override {
25
        // 建筑没有传统血量——空实现？
26
        // 调用方期望 Entity 扣血，Building 什么都不做
27
    }
28
};
29

30
// 调用方
31
void HandleEntityClick(Entity& e, const Vector3& clickPos) {
32
    e.MoveTo(clickPos);  // 点了建筑 → 崩溃
33
}

1
// ✅ LSP 安全的拆分
2
class IMovable {
3
public:
4
    virtual void MoveTo(const Vector3& target) = 0;
5
    virtual ~IMovable() = default;
6
};
7

8
class IDamageable {
9
public:
10
    virtual void TakeDamage(float amount) = 0;
11
    virtual ~IDamageable() = default;
12
};
13

14
class Character : public IMovable, public IDamageable {
15
    // 角色既可移动又可以被伤害
16
};
17

18
class Building : public IDamageable {
19
    // 建筑可以被摧毁，但不能移动——不继承 IMovable
20
};
21

22
// 现在调用方明确表达自己的需求
23
void HandleClick(IMovable& movable, const Vector3& pos) {
24
    movable.MoveTo(pos);  // 编译期保证：只有能移动的才会传进来
25
}

1
// ❌ 一个"全能"接口——每个实体都必须实现所有方法
2
class IEntity {
3
public:
4
    virtual void MoveTo(const Vector3& target) = 0;
5
    virtual void Attack(Entity* target) = 0;
6
    virtual void TakeDamage(float amount) = 0;
7
    virtual void Heal(float amount) = 0;
8
    virtual void PlayAnimation(const std::string& name) = 0;
9
    virtual void PlaySound(SoundId id) = 0;
10
    virtual void SaveToFile(std::ofstream& file) = 0;
11
    virtual void LoadFromFile(std::ifstream& file) = 0;
12
    virtual ~IEntity() = default;
13
};
14

15
// 陷阱——实现了 6 个空方法
16
class Trap : public IEntity {
17
public:
18
    void MoveTo(const Vector3&) override {}        // 陷阱不能动
19
    void Attack(Entity*) override {}                // 陷阱不攻击
20
    void Heal(float) override {}                    // 陷阱不能治疗
21
    void PlayAnimation(const std::string&) override {} // 陷阱没动画
22
    void PlaySound(SoundId) override {}             // 也许有音效
23
    void SaveToFile(std::ofstream&) override {}     // 不需要存档
24
    void LoadFromFile(std::ifstream&) override {}   // 不需要读档
25

26
    // 真正的逻辑只有这一个
27
    void TakeDamage(float amount) override {
28
        durability -= amount;
29
        if (durability <= 0) Destroy();
30
    }
31
private:
32
    float durability = 100.0f;
33
};

1
// ✅ 小而专注的接口
2

3
class IMovable {
4
public:
5
    virtual void MoveTo(const Vector3& target) = 0;
6
    virtual ~IMovable() = default;
7
};
8

9
class IDamageable {
10
public:
11
    virtual void TakeDamage(float amount) = 0;
12
    virtual ~IDamageable() = default;
13
};
14

15
class IAttacker {
16
public:
17
    virtual void Attack(IDamageable* target) = 0;
18
    virtual ~IAttacker() = default;
19
};
20

21
class ISerializable {
22
public:
23
    virtual void Save(std::ofstream& file) = 0;
24
    virtual void Load(std::ifstream& file) = 0;
25
    virtual ~ISerializable() = default;
26
};
27

28
// 陷阱只实现自己需要的
29
class Trap : public IDamageable {
30
public:
31
    void TakeDamage(float amount) override { /* ... */ }
32
};
33

34
// Player 实现所有需要的
35
class Player : public IMovable, public IDamageable, public IAttacker, public ISerializable {
36
    // 每个接口都有真正的实现
37
};
38

39
// 调用方现在精确表达自己的需求
40
void MoveAllUnits(std::vector<IMovable*>& units, const Vector3& target) {
41
    for (auto* u : units) {
42
        u->MoveTo(target);  // 只能传可移动的，编译期就过滤了 Trap
43
    }
44
}

1
// Unity 风格的组件系统就是 ISP 的极致体现
2
class GameObject {
3
    std::vector<Component*> components;
4

5
public:
6
    template<typename T>
7
    T* GetComponent() {
8
        for (auto* c : components) {
9
            if (auto* casted = dynamic_cast<T*>(c))
10
                return casted;
11
        }
12
        return nullptr;
13
    }
14
};
15

16
// 每个 Component 就是一个"小接口"
17
class HealthComponent : public Component {
18
public:
19
    void TakeDamage(float amount);
20
    void Heal(float amount);
21
};
22

23
class MovementComponent : public Component {
24
public:
25
    void MoveTo(const Vector3& target);
26
    void Jump();
27
};
28

29
// 现在任意 GameObject 都可以按需组合
30
GameObject* trap = new GameObject();
31
trap->AddComponent<HealthComponent>();      // 有血量
32
// 没有 MovementComponent —— 不能动
33

34
GameObject* player = new GameObject();
35
player->AddComponent<HealthComponent>();    // 有血量
36
player->AddComponent<MovementComponent>();  // 能移动
37
player->AddComponent<AttackComponent>();    // 能攻击

1
// ❌ 高层模块（SkillSystem）直接依赖低层模块（AudioManager）
2
class AudioManager {
3
public:
4
    void PlaySound(const std::string& filename) {
5
        // 调用 FMOD 底层 API
6
        fmod::System::Play(filename);
7
    }
8
};
9

10
class SkillSystem {
11
    AudioManager* audio;  // 直接依赖具体类
12

13
public:
14
    void CastSkill(const Skill& skill) {
15
        // 技能逻辑...
16
        audio->PlaySound(skill.soundName);  // 硬编码依赖
17
    }
18
};
19

20
// 问题：如果要换音频引擎（FMOD → Wwise），你需要改 SkillSystem 吗？
21
// 答案：是——因为 SkillSystem 直接持有 AudioManager。
22
// 但 SkillSystem 只是"想播放一个音效"，它不应该关心用的是什么音频引擎。

1
// ✅ 依赖抽象
2

3
// 抽象——定义"播放音效"的契约
4
class IAudioService {
5
public:
6
    virtual void PlaySound(const std::string& name) = 0;
7
    virtual ~IAudioService() = default;
8
};
9

10
// 具体实现——FMOD 版
11
class FmodAudioService : public IAudioService {
12
public:
13
    void PlaySound(const std::string& name) override {
14
        fmod::System::Play(name.c_str());
15
    }
16
};
17

18
// 具体实现——Wwise 版（换引擎只要新写一个类）
19
class WwiseAudioService : public IAudioService {
20
public:
21
    void PlaySound(const std::string& name) override {
22
        Wwise::PostEvent(name.c_str());
23
    }
24
};
25

26
// 高层模块——只依赖抽象
27
class SkillSystem {
28
    IAudioService* audio;  // 依赖接口，不依赖具体类
29

30
public:
31
    SkillSystem(IAudioService* audioService)
32
        : audio(audioService) {}
33

34
    void CastSkill(const Skill& skill) {
35
        audio->PlaySound(skill.soundName);  // 不关心底层是什么引擎
36
    }
37
};

1
// 继承方案：深层继承树
2
class Entity {};
3
class Character : public Entity {};
4
class Humanoid : public Character {};
5
class Player : public Humanoid {};
6
class Mage : public Player {};
7
class FireMage : public Mage {};
8
// 策划说"加一个冰火双修的法师"——你怎么继承？？同时继承 FireMage 和 IceMage？
9

10
// 组合方案：能力组件
11
class Entity {
12
    std::vector<Component*> components;
13
};
14

15
// 冰火双修法师：加一个 FireComponent 和一个 IceComponent 即可
16
auto* hybridMage = new GameObject();
17
hybridMage->AddComponent<FireMagicComponent>();
18
hybridMage->AddComponent<IceMagicComponent>();

1
// ❌ 过度设计：一个简单的 bool 被套上了策略模式
2
class ICondition {
3
public:
4
    virtual bool Evaluate() const = 0;
5
    virtual ~ICondition() = default;
6
};
7
class IsAliveCondition : public ICondition {
8
    Entity* entity;
9
public:
10
    bool Evaluate() const override { return entity->IsAlive(); }
11
};
12
class AndCondition : public ICondition { /* ... */ };
13
class OrCondition : public ICondition { /* ... */ };
14
// 实际使用：只是要判断角色是否活着
15

16
// ✅ 直接写
17
if (entity->IsAlive()) {
18
    // do something
19
}

1
// ❌ "以后可能会用"的预留设计
2
class Skill {
3
    // 策划明确说了只有主动技能和被动技能，但你写了 6 种类型
4
    enum class SkillType {
5
        Active, Passive, Toggle, Channeling, Charge, Ultimate,
6
        // 后面三种"以后可能会加"
7
    };
8

9
    // "以后可能会加网络同步"——预留了序列化接口
10
    virtual void Serialize(NetworkBuffer& buf);
11
    virtual void Deserialize(NetworkBuffer& buf);
12
};
13

14
// ✅ 只实现当前需要的
15
class Skill {
16
    enum class SkillType { Active, Passive };
17

18
    // 等真的有网络需求了再加——加了你也用不了，因为还没测试过
19
};

1
// ❌ 重复代码
2
void Player::TakeDamage(float amount) {
3
    health -= amount;
4
    if (health <= 0) {
5
        OnDeath();
6
        GameManager::Instance().OnPlayerDeath();
7
    }
8
    ui->UpdateHealthBar(health / maxHealth);
9
}
10

11
void Enemy::TakeDamage(float amount) {
12
    health -= amount;
13
    if (health <= 0) {
14
        OnDeath();
15
        QuestSystem::Instance().OnEnemyKilled(this);
16
    }
17
    // 血条逻辑和 Player 一模一样——复制过来了
18
}
19

20
// ✅ 抽取公共逻辑
21
void DamageableComponent::TakeDamage(float amount) {
22
    health -= amount;
23
    if (health <= 0) {
24
        OnDeath();  // 各自注册的事件回调
25
    }
26
    OnHealthChanged(health / maxHealth);  // UI 通过事件更新
27
}

1
// ============ 纯数据 ============
2
struct CharacterData {
3
    Vector3 position;
4
    Vector3 velocity;
5
    float health;
6
    float maxHealth;
7
    float moveSpeed;
8
};
9

10
// ============ 抽象接口（DIP + ISP）============
11
class IMovable {
12
public:
13
    virtual void MoveTo(const Vector3& target) = 0;
14
    virtual void Jump() = 0;
15
    virtual ~IMovable() = default;
16
};
17

18
class IDamageable {
19
public:
20
    virtual void TakeDamage(float amount) = 0;
21
    virtual ~IDamageable() = default;
22
};
23

24
// ============ 组件实现（SRP + 组合优于继承）============
25
class MovementComponent : public IMovable {
26
    CharacterData* data;
27
public:
28
    void MoveTo(const Vector3& target) override {
29
        Vector3 dir = (target - data->position).Normalized();
30
        data->position += dir * data->moveSpeed * Time::Delta();
31
    }
32
    void Jump() override {
33
        if (IsGrounded()) data->velocity.y = 10.0f;
34
    }
35
private:
36
    bool IsGrounded() const;
37
};
38

39
// 伤害计算——OCP：通过策略模式扩展
40
class IDamageCalculator {
41
public:
42
    virtual float Calculate(float base, const CharacterData& target) const = 0;
43
    virtual ~IDamageCalculator() = default;
44
};
45

46
class HealthComponent : public IDamageable {
47
    CharacterData* data;
48
    std::vector<std::unique_ptr<IDamageCalculator>> damageModifiers;  // OCP
49

50
public:
51
    void TakeDamage(float amount) override {
52
        float finalDmg = amount;
53
        for (auto& mod : damageModifiers) {
54
            finalDmg = mod->Calculate(finalDmg, *data);
55
        }
56
        data->health = std::max(0.0f, data->health - finalDmg);
57
        if (data->health <= 0) OnDeath();
58
    }
59

60
    std::function<void()> OnDeath;  // 观察者模式（Ch3 深入）
61
};
62

63
// 渲染（SRP）——独立的 RenderComponent
64
class RenderComponent {
65
    Mesh* mesh;
66
    Material* material;
67
public:
68
    void Draw(const CharacterData& data) {
69
        Graphics::DrawMesh(mesh, material, data.position);
70
    }
71
};
72

73
// ============ 使用方 ============
74
class Character {
75
public:
76
    CharacterData data;
77
    MovementComponent movement{&data};
78
    HealthComponent health{&data};
79
    RenderComponent render;
80

81
    Character() {
82
        // 依赖注入——外部可以替换组件实现（DIP）
83
        health.OnDeath = [this] {
84
            render.PlayDeathAnimation();
85
            AudioService::Get().PlaySound("death_sfx");
86
        };
87
    }
88
};