1
// ============ 继承地狱 —— "钻石型继承"的实际后果 ============
2

3
// 策划："我们的游戏需要这些角色——"
4
// "近战战士、远程弓箭手、法师、会冲锋的兽人、会隐身的盗贼、
5
//  会飞的龙、会潜水的鱼人、机械巨人（不能治疗）……"
6

7
// 用继承你怎么组织？
8
// Entity → Character → Humanoid → Melee → Warrior
9
// Entity → Character → Humanoid → Ranged → Archer
10
// Entity → Character → Beast → Flying → Dragon
11
// Entity → Character → Beast → Aquatic → Merman
12
// Entity → Mechanical → Golem           ← 机械不吃治疗，从哪个分支开始？
13

14
// 策划："加一个'半机械龙'——Boss，能飞、能喷火、能召唤小机器人、不吃治疗"
15
// 你：从 Dragon 继承？从 Golem 继承？多重继承？

1
// ============ 组件天堂 —— 组合你想要的能力 ============
2

3
class Entity {
4
    std::vector<std::unique_ptr<Component>> components;
5

6
public:
7
    template<typename T>
8
    T* AddComponent() {
9
        auto comp = std::make_unique<T>();
10
        comp->SetOwner(this);
11
        T* ptr = comp.get();
12
        components.push_back(std::move(comp));
13
        return ptr;
14
    }
15

16
    template<typename T>
17
    T* GetComponent() {
18
        for (auto& c : components) {
19
            if (auto* casted = dynamic_cast<T*>(c.get())) {
20
                return casted;
21
            }
22
        }
23
        return nullptr;
24
    }
25
};
26

27
// 各种组件——每个都是一个独立的、可复用的模块
28
class HealthComponent : public Component {
29
public:
30
    void TakeDamage(float amount) { /* ... */ }
31
    void Heal(float amount) { /* ... */ }
32
    bool IsAlive() const { return health > 0; }
33
private:
34
    float health = 100, maxHealth = 100;
35
};
36

37
class MovementComponent : public Component {
38
public:
39
    void MoveTo(const Vector3& target) { /* ... */ }
40
    void Jump() { /* ... */ }
41
    bool IsGrounded() const { /* ... */ }
42
private:
43
    float moveSpeed = 5.0f;
44
};
45

46
class FlightComponent : public Component {
47
public:
48
    void FlyTo(const Vector3& target) { /* ... */ }
49
    void SetAltitude(float height) { /* ... */ }
50
};
51

52
class MeleeAttackComponent : public Component {
53
public:
54
    void Attack(Entity* target) { /* ... */ }
55
};
56

57
class FireBreathComponent : public Component {
58
public:
59
    void BreatheFire(const Vector3& direction) { /* ... */ }
60
};
61

62
class SummonComponent : public Component {
63
public:
64
    void SummonMinion(const std::string& type) { /* ... */ }
65
};
66

67
// ============ 组装角色 ============
68

69
// 半机械龙——组合即可，不需要多重继承
70
Entity* mechaDragon = new Entity();
71
mechaDragon->AddComponent<HealthComponent>();       // 有血量
72
mechaDragon->AddComponent<MovementComponent>();     // 能走路
73
mechaDragon->AddComponent<FlightComponent>();       // 能飞！
74
mechaDragon->AddComponent<FireBreathComponent>();   // 能喷火！
75
mechaDragon->AddComponent<SummonComponent>();       // 能召唤！
76
// 故意不加 HealableComponent——机械龙不吃治疗
77

78
// 兽人战士
79
Entity* orcWarrior = new Entity();
80
orcWarrior->AddComponent<HealthComponent>();
81
orcWarrior->AddComponent<MovementComponent>();
82
orcWarrior->AddComponent<MeleeAttackComponent>();
83

84
// 鱼人
85
Entity* merman = new Entity();
86
merman->AddComponent<HealthComponent>();
87
merman->AddComponent<SwimComponent>();            // 游泳组件
88
merman->AddComponent<MeleeAttackComponent>();
89

90
// 加新能力？写一个新 Component 就行，不改任何已有代码。OCP 完美达成。

1
// ❌ 紧耦合——组件直接依赖另一个组件
2
class HealthComponent : public Component {
3
    HealthBarUI* healthBar;  // 直接引用 UI 组件——耦合了！
4
public:
5
    void TakeDamage(float amount) {
6
        health -= amount;
7
        healthBar->UpdateDisplay(health / maxHealth);  // 不该在这里
8
    }
9
};
10

11
// ✅ 松耦合——通过事件系统通信（Ch3 的事件总线）
12
class HealthComponent : public Component {
13
public:
14
    void TakeDamage(float amount) {
15
        health -= amount;
16
        // 向世界宣告——不关心谁在听
17
        EventBus::Emit(HealthChangedEvent{
18
            .entity = owner,
19
            .currentHealth = health,
20
            .maxHealth = maxHealth
21
        });
22

23
        if (health <= 0) {
24
            EventBus::Emit(EntityDeathEvent{ .entity = owner });
25
        }
26
    }
27
};
28

29
// HealthBarUI 订阅事件——完全独立
30
class HealthBarUI : public Component {
31
    void OnEnable() override {
32
        listener = EventBus::Subscribe<HealthChangedEvent>(
33
            [this](const HealthChangedEvent& e) {
34
                if (e.entity == owner) {
35
                    UpdateDisplay(e.currentHealth / e.maxHealth);
36
                }
37
            });
38
    }
39
};

1
// ============ 第一步：Entity 只是一个 ID ============
2
using Entity = uint32_t;
3
constexpr Entity INVALID_ENTITY = 0;
4

5
// ============ 第二步：Component 只是纯数据 ============
6
struct PositionComponent {
7
    float x, y, z;
8
};
9

10
struct VelocityComponent {
11
    float vx, vy, vz;
12
};
13

14
struct HealthComponent {
15
    float current;
16
    float max;
17
};
18

19
struct RenderComponent {
20
    Mesh* mesh;
21
    Material* material;
22
};
23

24
// ============ 第三步：System 拥有全部行为 ============
25

26
// MovementSystem：任何同时有 Position + Velocity 的 Entity 都会自动移动
27
class MovementSystem {
28
public:
29
    void Update(float dt) {
30
        // 遍历所有拥有 Position AND Velocity 的 Entity
31
        for (auto entity : world->View<PositionComponent, VelocityComponent>()) {
32
            auto& pos = world->Get<PositionComponent>(entity);
33
            auto& vel = world->Get<VelocityComponent>(entity);
34

35
            pos.x += vel.vx * dt;
36
            pos.y += vel.vy * dt;
37
            pos.z += vel.vz * dt;
38
        }
39
    }
40
};
41

42
// DamageSystem：处理伤害请求
43
class DamageSystem {
44
public:
45
    void ProcessDamage(Entity target, float amount) {
46
        if (world->Has<HealthComponent>(target)) {
47
            auto& health = world->Get<HealthComponent>(target);
48
            health.current -= amount;
49

50
            if (health.current <= 0) {
51
                health.current = 0;
52
                OnEntityDeath(target);
53
            }
54
        }
55
    }
56
};
57

58
// RenderSystem：渲染所有可见 Entity
59
class RenderSystem {
60
public:
61
    void Render(Camera* camera) {
62
        for (auto entity : world->View<PositionComponent, RenderComponent>()) {
63
            auto& pos = world->Get<PositionComponent>(entity);
64
            auto& render = world->Get<RenderComponent>(entity);
65

66
            Graphics::DrawMesh(render.mesh, render.material,
67
                               Vector3(pos.x, pos.y, pos.z), camera);
68
        }
69
    }
70
};

1
OOP 组件模式（离散内存）：
2
  内存布局（简化）：
3
  [Entity0 Header][Pos0][Vel0][Health0]  ← 分散在堆上，每次 new 分配
4
  [Entity1 Header][Pos1][Vel1][Health1]    遍历时在内存中跳来跳去
5
  [Entity2 Header][Pos2][Vel2][Health2]    Cache Miss 频繁
6

7
ECS（连续内存 - SoA）：
8
  内存布局（简化）：
9
  Position 数组: [Pos0][Pos1][Pos2]...[Pos999]  ← 连续！64 bytes per cache line
10
  Velocity 数组: [Vel0][Vel1][Vel2]...[Vel999]  ← 连续！
11
  Health 数组:   [HP0] [HP1] [HP2] ...[HP999]    ← 连续！
12

13
  MovementSystem 遍历时：
14
  - 读 Position 数组 → 每次 Cache Miss 加载 4-8 个 Position（64 bytes cache line）
15
  - 读 Velocity 数组 → 每次 Cache Miss 加载 4-8 个 Velocity
16
  - 相比 OOP 模式每次只能加载 1 个 Entity 的混合数据，效率高 4-8 倍

1
// 简化的 ECS 世界——展示内存布局
2
class ECSWorld {
3
    // 每个 Component 类型一个数组（连续存储）
4
    std::vector<PositionComponent> positions;   // 索引 = entityId
5
    std::vector<VelocityComponent> velocities;
6
    std::vector<HealthComponent> healths;
7
    std::vector<RenderComponent> renders;
8

9
    // Entity 拥有的 Component 集合（位掩码）
10
    std::vector<uint64_t> componentMasks;
11

12
    // 空闲 Entity 列表（复用已删除的 entityId）
13
    std::vector<Entity> freeEntities;
14

15
public:
16
    Entity CreateEntity() {
17
        if (!freeEntities.empty()) {
18
            Entity e = freeEntities.back();
19
            freeEntities.pop_back();
20
            return e;
21
        }
22

23
        // 扩展所有 Component 数组
24
        Entity id = positions.size();
25
        positions.emplace_back();
26
        velocities.emplace_back();
27
        healths.emplace_back();
28
        renders.emplace_back();
29
        componentMasks.push_back(0);
30
        return id;
31
    }
32

33
    template<typename T>
34
    void AddComponent(Entity e, T component) {
35
        GetArray<T>()[e] = component;
36
        componentMasks[e] |= GetComponentMask<T>();
37
    }
38

39
    template<typename T>
40
    T& Get(Entity e) {
41
        return GetArray<T>()[e];
42
    }
43

44
    // View：返回所有同时拥有指定 Component 的 Entity
45
    template<typename... Ts>
46
    std::vector<Entity> View() {
47
        uint64_t requiredMask = (GetComponentMask<Ts>() | ...);
48

49
        std::vector<Entity> result;
50
        for (Entity e = 0; e < componentMasks.size(); ++e) {
51
            if ((componentMasks[e] & requiredMask) == requiredMask) {
52
                result.push_back(e);
53
            }
54
        }
55
        return result;
56
    }
57

58
private:
59
    template<typename T>
60
    std::vector<T>& GetArray();
61

62
    template<typename T>
63
    uint64_t GetComponentMask();
64
};
65

66
// 使用
67
ECSWorld world;
68

69
auto player = world.CreateEntity();
70
world.AddComponent<PositionComponent>(player, {0, 0, 0});
71
world.AddComponent<VelocityComponent>(player, {0, 0, 0});
72
world.AddComponent<HealthComponent>(player, {100, 100});
73
world.AddComponent<RenderComponent>(player, {playerMesh, playerMat});
74

75
auto goblin = world.CreateEntity();
76
world.AddComponent<PositionComponent>(goblin, {5, 0, 0});
77
world.AddComponent<HealthComponent>(goblin, {50, 50});
78
world.AddComponent<RenderComponent>(goblin, {goblinMesh, goblinMat});
79
// goblin 没有 VelocityComponent——它不移动
80

81
// MovementSystem 自动处理所有移动实体
82
MovementSystem movementSys(&world);
83
movementSys.Update(dt);  // 遍历 player（有 Vel），跳过 goblin（无 Vel）

1
// ❌ 无架构——数据和 UI 搅在一起
2
class InventoryPanel : public MonoBehaviour {
3
    public Text goldText;
4
    public Transform contentParent;
5
    public GameObject itemPrefab;
6

7
    void Update() {
8
        // 每帧轮询刷新——浪费性能
9
        goldText.text = PlayerData.Gold.ToString();
10
        // 物品变化了？不知道，全量刷新吧
11
        RefreshAllItems();
12
    }
13

14
    void RefreshAllItems() {
15
        foreach (Transform child in contentParent) {
16
            Destroy(child.gameObject);  // 全删
17
        }
18
        foreach (var item in PlayerData.Inventory) {
19
            var go = Instantiate(itemPrefab, contentParent);
20
            go.GetComponent<ItemSlot>().SetData(item);  // 全重建
21
        }
22
        // 每帧都在全量删除重建——性能灾难
23
    }
24
};

1
// ============ Model —— 纯数据，不知道 UI 的存在 ============
2
class InventoryModel {
3
public:
4
    int GetGold() const { return gold; }
5
    const std::vector<Item>& GetItems() const { return items; }
6

7
    void AddGold(int amount) {
8
        gold += amount;
9
        OnGoldChanged(gold);  // 通知变化
10
    }
11

12
    void AddItem(const Item& item) {
13
        items.push_back(item);
14
        OnItemAdded(items.size() - 1, item);  // 通知新增——而不是全量刷新
15
    }
16

17
    void RemoveItem(int index) {
18
        Item removed = items[index];
19
        items.erase(items.begin() + index);
20
        OnItemRemoved(index, removed);  // 通知移除
21
    }
22

23
    // 变化通知——观察者模式（Ch3）
24
    std::function<void(int)> OnGoldChanged;
25
    std::function<void(int, const Item&)> OnItemAdded;
26
    std::function<void(int, const Item&)> OnItemRemoved;
27

28
private:
29
    int gold = 0;
30
    std::vector<Item> items;
31
};
32

33
// ============ ViewModel —— Model 和 View 之间的适配层 ============
34
class InventoryViewModel {
35
    InventoryModel* model;
36

37
public:
38
    // 暴露给 View 的数据——经过格式化和排序
39
    std::string GetGoldDisplay() const {
40
        return std::to_string(model->GetGold()) + " G";
41
    }
42

43
    int GetItemCount() const {
44
        return model->GetItems().size();
45
    }
46

47
    // 获取单个物品的显示数据
48
    ItemDisplayData GetItemDisplay(int index) const {
49
        auto& item = model->GetItems()[index];
50
        return ItemDisplayData{
51
            .name = item.name,
52
            .icon = item.icon,
53
            .rarityColor = GetRarityColor(item.rarity),
54
            .count = item.count,
55
            .isEquipped = item.isEquipped
56
        };
57
    }
58

59
    // 排序/筛选逻辑——放在 ViewModel 而非 View
60
    void SortByRarity() { /* 对 model->GetItems() 的索引排序 */ }
61
    void FilterByType(ItemType type) { /* 筛选 */ }
62
};
63

64
// ============ View —— 只负责显示，不知道数据怎么来的 ============
65
class InventoryView : public MonoBehaviour {
66
    InventoryViewModel* viewModel;
67
    Text goldText;
68
    Transform contentParent;
69
    GameObject itemPrefab;
70
    std::vector<ItemSlot*> itemSlots;
71

72
public:
73
    void Bind(InventoryViewModel* vm) {
74
        viewModel = vm;
75
        // 订阅变化——只更新变化的部分
76
        vm->GetModel()->OnGoldChanged = [this](int gold) {
77
            goldText.text = viewModel->GetGoldDisplay();  // 只更新金币文字
78
        };
79
        vm->GetModel()->OnItemAdded = [this](int index, const Item& item) {
80
            AddItemSlot(index, item);  // 只新增一个 item UI——不重建全部
81
        };
82
        vm->GetModel()->OnItemRemoved = [this](int index, const Item&) {
83
            RemoveItemSlot(index);  // 只移除一个
84
        };
85
    }
86

87
    void AddItemSlot(int index, const Item& item) {
88
        auto go = Instantiate(itemPrefab, contentParent);
89
        auto slot = go.GetComponent<ItemSlot>();
90
        slot.SetData(viewModel->GetItemDisplay(index));
91
        itemSlots.insert(itemSlots.begin() + index, slot);
92
    }
93

94
    void RemoveItemSlot(int index) {
95
        Destroy(itemSlots[index].gameObject);
96
        itemSlots.erase(itemSlots.begin() + index);
97
    }
98
};

1
// ============ 服务接口 ============
2
class IAudioService {
3
public:
4
    virtual void PlaySound(const std::string& name) = 0;
5
    virtual void SetVolume(float vol) = 0;
6
    virtual ~IAudioService() = default;
7
};
8

9
class IInputService {
10
public:
11
    virtual bool GetKey(KeyCode key) const = 0;
12
    virtual Vector2 GetMousePosition() const = 0;
13
    virtual ~IInputService() = default;
14
};
15

16
class ISceneService {
17
public:
18
    virtual void LoadScene(const std::string& name) = 0;
19
    virtual Scene* GetCurrentScene() = 0;
20
    virtual ~ISceneService() = default;
21
};
22

23
// ============ 服务定位器 ============
24
class ServiceLocator {
25
public:
26
    // 注册服务
27
    template<typename T>
28
    static void Register(std::unique_ptr<T> service) {
29
        auto& registry = GetRegistry();
30
        auto key = std::type_index(typeid(T));
31
        registry[key] = std::move(service);
32
    }
33

34
    // 获取服务
35
    template<typename T>
36
    static T* Get() {
37
        auto& registry = GetRegistry();
38
        auto key = std::type_index(typeid(T));
39
        auto it = registry.find(key);
40
        if (it != registry.end()) {
41
            return static_cast<T*>(it->second.get());
42
        }
43
        return nullptr;  // 或返回一个 Null 对象（见下文）
44
    }
45

46
    // 清理（在程序退出时调用）
47
    static void Shutdown() {
48
        GetRegistry().clear();
49
    }
50

51
private:
52
    using ServiceMap = std::unordered_map<std::type_index,
53
                                           std::unique_ptr<void, void(*)(void*)>>;
54
    static ServiceMap& GetRegistry() {
55
        static ServiceMap registry;
56
        return registry;
57
    }
58
};
59

60
// ============ 使用 ============
61

62
// 程序初始化
63
void Game::Init() {
64
    ServiceLocator::Register<IAudioService>(
65
        std::make_unique<FmodAudioService>());
66
    ServiceLocator::Register<IInputService>(
67
        std::make_unique<KeyboardMouseInput>());
68
    ServiceLocator::Register<ISceneService>(
69
        std::make_unique<SceneManager>());
70
}
71

72
// 任何地方——一行获取服务
73
void Enemy::PlayHitSound() {
74
    ServiceLocator::Get<IAudioService>()->PlaySound("enemy_hit");
75
    // 不需要知道是 FMOD 还是 Wwise
76
}
77

78
// 测试时——替换为 Mock
79
void Test::Init() {
80
    ServiceLocator::Register<IAudioService>(
81
        std::make_unique<MockAudioService>());  // 测试用空实现
82
}
83

84
// 程序退出
85
void Game::Shutdown() {
86
    ServiceLocator::Shutdown();  // 统一释放所有服务
87
}

1
// 如果服务未注册，Get<T>() 返回一个 Null 对象而非 nullptr
2
// 调用方不需要判空
3

4
class NullAudioService : public IAudioService {
5
public:
6
    void PlaySound(const std::string&) override {}  // 什么都不做
7
    void SetVolume(float) override {}
8

9
    static NullAudioService& Instance() {
10
        static NullAudioService instance;
11
        return instance;
12
    }
13
};
14

15
template<typename T>
16
static T* Get() {
17
    auto it = GetRegistry().find(std::type_index(typeid(T)));
18
    if (it != GetRegistry().end()) {
19
        return static_cast<T*>(it->second.get());
20
    }
21

22
    // 返回 Null 对象而非 nullptr
23
    if constexpr (std::is_same_v<T, IAudioService>) {
24
        return &NullAudioService::Instance();
25
    }
26
    return nullptr;
27
}
28

29
// 使用——不需要判空
30
ServiceLocator::Get<IAudioService>()->PlaySound("explosion");
31
// 如果忘记注册 AudioService，不崩溃，只是没声音

1
// ============ 服务定位器 ============
2
class Enemy {
3
public:
4
    void Die() {
5
        // 被动查找——自己去找服务
6
        auto* audio = ServiceLocator::Get<IAudioService>();
7
        audio->PlaySound("enemy_death");
8
    }
9
};
10

11
// ============ 依赖注入 ============
12
class Enemy {
13
    IAudioService* audio;  // 由外部注入
14
public:
15
    Enemy(IAudioService* audioService) : audio(audioService) {}
16

17
    void Die() {
18
        audio->PlaySound("enemy_death");  // 使用注入的服务
19
    }
20
};

1
// ============ 组件层 —— 每种职责一个组件 ============
2

3
// 移动——纯逻辑，不依赖 UI 或音效
4
class MovementComponent : public Component {
5
    Rigidbody* rb;
6
    float moveSpeed = 5.0f;
7
    float jumpForce = 10.0f;
8

9
public:
10
    void Move(Vector3 direction) {
11
        rb->velocity = direction * moveSpeed;
12
        EventBus::Emit(PlayerMovedEvent{ .position = owner->GetPosition() });
13
    }
14

15
    void Jump() {
16
        if (IsGrounded()) {
17
            rb->AddForce(Vector3::up * jumpForce, ForceMode::Impulse);
18
            EventBus::Emit(PlayerJumpedEvent{});
19
        }
20
    }
21
};
22

23
// 战斗——不依赖移动或动画
24
class CombatComponent : public Component {
25
    float health = 100;
26
    float maxHealth = 100;
27
    float attackPower = 50;
28

29
public:
30
    void TakeDamage(float amount) {
31
        health -= amount;
32
        EventBus::Emit(HealthChangedEvent{
33
            .entity = owner,
34
            .current = health,
35
            .max = maxHealth
36
        });
37

38
        if (health <= 0) {
39
            EventBus::Emit(EntityDeathEvent{ .entity = owner });
40
        }
41
    }
42
};
43

44
// ============ 服务层 —— 全局系统 ============
45
// 音频服务（服务定位器）
46
// 输入服务（服务定位器）
47
// 场景服务（服务定位器）
48

49
// ============ 事件驱动的跨系统通信 ============
50
// UI 系统订阅 CombatComponent 的事件
51
EventBus::Subscribe<HealthChangedEvent>([](const HealthChangedEvent& e) {
52
    if (e.entity->IsPlayer()) {
53
        UIManager::Get().UpdateHealthBar(e.current / e.max);
54
    }
55
});
56

57
// 音效系统订阅——独立模块，可以整体替换
58
EventBus::Subscribe<PlayerJumpedEvent>([](const PlayerJumpedEvent&) {
59
    ServiceLocator::Get<IAudioService>()->PlaySound("jump");
60
});
61

62
EventBus::Subscribe<EntityDeathEvent>([](const EntityDeathEvent& e) {
63
    if (e.entity->IsPlayer()) {
64
        ServiceLocator::Get<IAudioService>()->PlaySound("player_death");
65
        ServiceLocator::Get<ISceneService>()->LoadScene("GameOver");
66
    }
67
});
68

69
// ============ 组装 ============
70
auto* player = new Entity();
71
player->AddComponent<MovementComponent>();
72
player->AddComponent<CombatComponent>();
73
player->AddComponent<AnimationComponent>();
74
player->AddComponent<NetworkSyncComponent>();
75

76
// Player 类消失了——它被拆成了多个独立的组件，通过事件系统协作。
77
// 加新功能？加新 Component 或订阅新事件。不改已有代码。