1
// ============ 抽象基类——统一容器和叶子 ============
2
class SceneNode {
3
public:
4
    virtual ~SceneNode() = default;
5

6
    // 核心操作——容器和叶子都支持
7
    virtual void Render(Camera* camera) = 0;
8
    virtual Matrix4x4 GetWorldTransform() const = 0;
9

10
    // 子节点操作——默认空实现（叶子不需要）
11
    virtual void AddChild(std::unique_ptr<SceneNode> child) {}
12
    virtual SceneNode* GetChild(int index) { return nullptr; }
13
    virtual int GetChildCount() const { return 0; }
14

15
    // 公共属性
16
    void SetName(const std::string& n) { name = n; }
17
    const std::string& GetName() const { return name; }
18

19
protected:
20
    std::string name;
21
};
22

23
// ============ 容器节点——GameObject ============
24
class GameObject : public SceneNode {
25
public:
26
    void Render(Camera* camera) override {
27
        if (!isActive) return;
28

29
        // 容器本身不渲染——委托给子节点
30
        for (auto& child : children) {
31
            child->Render(camera);
32
        }
33
    }
34

35
    Matrix4x4 GetWorldTransform() const override {
36
        Matrix4x4 world = localTransform;
37
        if (parent) {
38
            world = parent->GetWorldTransform() * localTransform;
39
        }
40
        return world;
41
    }
42

43
    // 容器特有的子节点管理
44
    void AddChild(std::unique_ptr<SceneNode> child) override {
45
        children.push_back(std::move(child));
46
    }
47

48
    SceneNode* GetChild(int index) override {
49
        return index < children.size() ? children[index].get() : nullptr;
50
    }
51

52
    int GetChildCount() const override { return children.size(); }
53

54
    void SetActive(bool active) { isActive = active; }
55

56
private:
57
    std::vector<std::unique_ptr<SceneNode>> children;
58
    Matrix4x4 localTransform = Matrix4x4::Identity();
59
    GameObject* parent = nullptr;
60
    bool isActive = true;
61
};
62

63
// ============ 叶子节点——MeshRenderer ============
64
class MeshRenderer : public SceneNode {
65
public:
66
    MeshRenderer(Mesh* mesh, Material* mat) : mesh(mesh), material(mat) {}
67

68
    void Render(Camera* camera) override {
69
        if (!isVisible) return;
70

71
        Matrix4x4 world = GetWorldTransform();
72
        Graphics::DrawMesh(mesh, material, world, camera);
73
    }
74

75
    Matrix4x4 GetWorldTransform() const override {
76
        return owner ? owner->GetWorldTransform() : Matrix4x4::Identity();
77
    }
78

79
private:
80
    Mesh* mesh;
81
    Material* material;
82
    GameObject* owner = nullptr;
83
    bool isVisible = true;
84
};
85

86
// ============ 叶子节点——Light ============
87
class Light : public SceneNode {
88
public:
89
    void Render(Camera* camera) override {
90
        Graphics::SubmitLight(this, camera);
91
    }
92

93
    Matrix4x4 GetWorldTransform() const override {
94
        return owner->GetWorldTransform();
95
    }
96

97
private:
98
    Color color = Color::White;
99
    float intensity = 1.0f;
100
    LightType type = LightType::Point;
101
    GameObject* owner = nullptr;
102
};
103

104
// ============ 使用——客户端不需要区分容器和叶子 ============
105
void RenderScene(SceneNode* root, Camera* camera) {
106
    root->Render(camera);  // 递归渲染整棵树——一句代码
107
}
108

109
// Unity 风格的场景组装
110
auto scene = std::make_unique<GameObject>();
111
scene->SetName("MainScene");
112

113
auto player = std::make_unique<GameObject>();
114
player->SetName("Player");
115
player->AddChild(std::make_unique<MeshRenderer>(playerMesh, playerMat));
116

117
auto weapon = std::make_unique<GameObject>();
118
weapon->SetName("Sword");
119
weapon->AddChild(std::make_unique<MeshRenderer>(swordMesh, swordMat));
120
weapon->AddChild(std::make_unique<Light>());  // 发光的剑
121

122
player->AddChild(std::move(weapon));
123
scene->AddChild(std::move(player));
124

125
// 渲染整棵树——递归处理所有节点，不管类型
126
RenderScene(scene.get(), mainCamera);

1
// 透明组合：基类包含所有操作
2
class SceneNode {
3
    virtual void AddChild(...) {}  // 叶子空实现
4
};
5
// 客户端可以写 node.AddChild(...) 而不用知道具体类型
6
// 代价：叶子对象上调用 AddChild 不会报错，只是无效
7

8
// 安全组合：子节点操作只在容器类
9
class SceneNode {
10
    // 不包含 AddChild
11
};
12
class GameObject : public SceneNode {
13
    void AddChild(...) { /* 真正的实现 */ }
14
};
15
// 客户端需要先 dynamic_cast<GameObject> 才能 AddChild
16
// 更安全，但失去了"一视同仁"的便利性

1
// UI 系统是组合模式的另一个经典应用
2
class UIElement {
3
public:
4
    virtual void Render(Canvas* canvas) = 0;
5
    virtual bool HitTest(const Vector2& point) = 0;
6

7
    // 布局
8
    void SetRect(const Rect& r) { rect = r; }
9
    Rect GetRect() const { return rect; }
10

11
protected:
12
    Rect rect;
13
};
14

15
class UIPanel : public UIElement {
16
    std::vector<std::unique_ptr<UIElement>> children;
17

18
public:
19
    void Render(Canvas* canvas) override {
20
        // 先渲染自己（背景）
21
        canvas->DrawRect(rect, backgroundColor);
22

23
        // 再渲染子元素（前景）
24
        for (auto& child : children) {
25
            child->Render(canvas);
26
        }
27
    }
28

29
    bool HitTest(const Vector2& point) override {
30
        if (!rect.Contains(point)) return false;
31

32
        // 检查子元素（子元素在父元素之上）
33
        for (auto& child : children) {
34
            if (child->HitTest(point)) return true;
35
        }
36
        return true;  // 点中了面板本身
37
    }
38
};
39

40
class UIButton : public UIElement {
41
    std::string text;
42
    std::function<void()> onClick;
43
    bool isHovered = false;
44

45
public:
46
    void Render(Canvas* canvas) override {
47
        Color bg = isHovered ? hoverColor : normalColor;
48
        canvas->DrawRect(rect, bg);
49
        canvas->DrawText(text, rect.Center());
50
    }
51

52
    bool HitTest(const Vector2& point) override {
53
        return rect.Contains(point);
54
    }
55
};

1
// ============ 享元——共享的纹理/材质数据 ============
2
class ParticleFlyweight {
3
public:
4
    ParticleFlyweight(Texture2D* tex, Material* mat, Mesh* m, float lifetime)
5
        : texture(tex), material(mat), mesh(m), maxLifetime(lifetime) {}
6

7
    void Render(const Vector3& pos, float scale, const Color& color, float rotation) const {
8
        // 使用共享的纹理和材质，配合独有数据（位置/大小/颜色/旋转）
9
        Graphics::DrawMeshInstanced(mesh, material, pos, scale, rotation, color);
10
    }
11

12
private:
13
    Texture2D* texture;    // 所有同类型粒子共享
14
    Material* material;    // 所有同类型粒子共享
15
    Mesh* mesh;            // 所有同类型粒子共享（通常是 Billboard Quad）
16
    float maxLifetime;     // 所有同类型粒子共享
17
};
18

19
// ============ 粒子实例——只有运行时状态 ============
20
class ParticleInstance {
21
public:
22
    ParticleInstance(const ParticleFlyweight* fw)
23
        : flyweight(fw) {}
24

25
    void Update(float dt) {
26
        lifetime += dt;
27
        position += velocity * dt;
28
        velocity.y += gravity * dt;
29
        alpha = 1.0f - (lifetime / flyweight->GetMaxLifetime());  // 淡出
30
    }
31

32
    void Render() const {
33
        if (lifetime < flyweight->GetMaxLifetime()) {
34
            Color faded = baseColor;
35
            faded.a *= alpha;
36
            flyweight->Render(position, scale, faded, rotation);
37
        }
38
    }
39

40
    bool IsAlive() const {
41
        return lifetime < flyweight->GetMaxLifetime();
42
    }
43

44
    // 初始化——对象池复用后重新设置
45
    void Spawn(const Vector3& pos, const Vector3& vel, const Color& col) {
46
        position = pos;
47
        velocity = vel;
48
        baseColor = col;
49
        lifetime = 0.0f;
50
        alpha = 1.0f;
51
    }
52

53
private:
54
    const ParticleFlyweight* flyweight;  // 指向共享数据
55
    // 以下都是独有数据——每个粒子不同
56
    Vector3 position;
57
    Vector3 velocity;
58
    Color baseColor;
59
    float lifetime = 0.0f;
60
    float alpha = 1.0f;
61
    float scale = 1.0f;
62
    float rotation = 0.0f;
63
    float gravity = -9.8f;
64
};
65

66
// ============ 享元工厂——管理共享对象 ============
67
class ParticleFlyweightFactory {
68
public:
69
    const ParticleFlyweight* GetFlyweight(const std::string& type) {
70
        auto it = flyweights.find(type);
71
        if (it != flyweights.end()) {
72
            return it->second.get();
73
        }
74

75
        // 创建新的享元
76
        auto flyweight = CreateFlyweight(type);
77
        auto* ptr = flyweight.get();
78
        flyweights[type] = std::move(flyweight);
79
        return ptr;
80
    }
81

82
private:
83
    std::unique_ptr<ParticleFlyweight> CreateFlyweight(const std::string& type) {
84
        if (type == "smoke") {
85
            return std::make_unique<ParticleFlyweight>(
86
                smokeTex, smokeMat, quadMesh, 2.0f);
87
        } else if (type == "fire") {
88
            return std::make_unique<ParticleFlyweight>(
89
                fireTex, fireMat, quadMesh, 1.0f);
90
        } else if (type == "spark") {
91
            return std::make_unique<ParticleFlyweight>(
92
                sparkTex, sparkMat, quadMesh, 0.5f);
93
        }
94
        return nullptr;
95
    }
96

97
    std::unordered_map<std::string, std::unique_ptr<ParticleFlyweight>> flyweights;
98
    // 纹理/材质资源...
99
};
100

101
// ============ 粒子系统——综合使用享元 + 对象池 ============
102
class ParticleSystem {
103
    ParticleFlyweightFactory flyweightFactory;
104
    std::vector<ParticleInstance> particles;
105
    static constexpr size_t MAX_PARTICLES = 5000;
106

107
public:
108
    void Emit(const std::string& type, const Vector3& pos, int count) {
109
        auto* flyweight = flyweightFactory.GetFlyweight(type);
110

111
        for (int i = 0; i < count; ++i) {
112
            if (particles.size() >= MAX_PARTICLES) break;
113

114
            Vector3 vel = RandomOnSphere() * Random::Range(1.0f, 5.0f);
115
            Color col = Color::RandomHue();
116

117
            particles.emplace_back(flyweight);
118
            particles.back().Spawn(pos, vel, col);
119
        }
120
    }
121

122
    void Update(float dt) {
123
        for (auto& p : particles) p.Update(dt);
124

125
        // 移除死亡粒子
126
        particles.erase(
127
            std::remove_if(particles.begin(), particles.end(),
128
                [](auto& p) { return !p.IsAlive(); }),
129
            particles.end());
130
    }
131

132
    void Render() const {
133
        for (auto& p : particles) p.Render();
134
    }
135
};

1
// 瓦片地图是享元模式的经典应用
2
// 1000×1000 的地图，只有 ~20 种瓦片类型
3

4
class TileFlyweight {
5
public:
6
    TileFlyweight(Texture2D* atlas, const Rect& uvRect, bool isWalkable,
7
                  float moveCost)
8
        : atlasTexture(atlas), uv(uvRect), walkable(isWalkable),
9
          movementCost(moveCost) {}
10

11
    void Render(const Vector2& worldPos) const {
12
        Graphics::DrawQuad(atlasTexture, uv, worldPos, TILE_SIZE);
13
    }
14

15
    bool IsWalkable() const { return walkable; }
16
    float GetMovementCost() const { return movementCost; }
17

18
private:
19
    Texture2D* atlasTexture;  // 所有瓦片共享同一张图集
20
    Rect uv;                  // 在图集中的位置
21
    bool walkable;
22
    float movementCost;
23
};
24

25
// 地图存储的是享元指针的二维数组
26
class TileMap {
27
    std::vector<std::vector<const TileFlyweight*>> tiles;
28

29
public:
30
    void Render() const {
31
        for (int y = 0; y < height; ++y) {
32
            for (int x = 0; x < width; ++x) {
33
                tiles[y][x]->Render(Vector2(x * TILE_SIZE, y * TILE_SIZE));
34
            }
35
        }
36
    }
37
};
38

39
// 1000×1000 的地图，内存占用：
40
// 不用享元：每个 tile 存完整纹理引用 + 属性 ≈ 64B × 1,000,000 = 64MB
41
// 用享元：享元（20 个 × 64B = 1.3KB）+ tile 指针（8B × 1,000,000 = 8MB）= 8MB
42
// 节省：87.5%

1
// ============ 虚拟代理：延迟加载 ============
2
// 问题：加载一张 4096×4096 的纹理需要 200ms，但玩家可能永远不会看到它
3
// 解决：先用低分辨率占位图，真正需要时才加载
4

5
class TextureProxy : public ITexture {
6
    std::unique_ptr<RealTexture> realTexture;
7
    std::unique_ptr<ImageData> placeholder;
8
    std::string filePath;
9
    bool isLoaded = false;
10

11
public:
12
    TextureProxy(const std::string& path) : filePath(path) {
13
        placeholder = GeneratePlaceholder(32, 32);  // 32×32 占位图
14
    }
15

16
    ImageData* GetPixels() override {
17
        EnsureLoaded();
18
        return realTexture->GetPixels();
19
    }
20

21
    Size GetSize() override {
22
        if (isLoaded) return realTexture->GetSize();
23
        return placeholder->GetSize();  // 返回占位图尺寸
24
    }
25

26
private:
27
    void EnsureLoaded() {
28
        if (!isLoaded) {
29
            realTexture = std::make_unique<RealTexture>();
30
            realTexture->LoadFromDisk(filePath);  // 真正加载
31
            isLoaded = true;
32
        }
33
    }
34
};
35

36
// ============ 保护代理：权限控制 ============
37
class ProtectedConsoleCommand : public IConsoleCommand {
38
    IConsoleCommand* realCommand;
39
    UserPermission requiredPermission;
40

41
public:
42
    void Execute(const std::string& args) override {
43
        if (CurrentUser::HasPermission(requiredPermission)) {
44
            realCommand->Execute(args);
45
        } else {
46
            Log::Warning("Permission denied for command");
47
        }
48
    }
49
};
50

51
// ============ 日志代理：性能分析 ============
52
class ProfilingProxy : public IComponent {
53
    IComponent* realComponent;
54
    std::string componentName;
55

56
public:
57
    void Update(float dt) override {
58
        auto start = Clock::now();
59
        realComponent->Update(dt);
60
        auto elapsed = Clock::now() - start;
61

62
        if (elapsed > 1ms) {
63
            Log::Warning(componentName + "::Update took " +
64
                         std::to_string(elapsed.count()) + "us");
65
        }
66
    }
67
};

1
// ============ 抽象武器 ============
2
class IWeapon {
3
public:
4
    virtual void Attack(Enemy* target) = 0;
5
    virtual float GetDamage() const = 0;
6
    virtual std::string GetDescription() const = 0;
7
    virtual ~IWeapon() = default;
8
};
9

10
// ============ 具体武器——被装饰的对象 ============
11
class LongSword : public IWeapon {
12
public:
13
    void Attack(Enemy* target) override {
14
        target->TakeDamage(baseDamage);
15
        PlaySwingSound();
16
    }
17

18
    float GetDamage() const override { return baseDamage; }
19
    std::string GetDescription() const override { return "长剑"; }
20

21
private:
22
    float baseDamage = 50.0f;
23
};
24

25
// ============ 装饰器基类——包装另一个 IWeapon ============
26
class WeaponEnchantment : public IWeapon {
27
protected:
28
    std::unique_ptr<IWeapon> innerWeapon;  // 被装饰的武器
29

30
public:
31
    WeaponEnchantment(std::unique_ptr<IWeapon> weapon)
32
        : innerWeapon(std::move(weapon)) {}
33

34
    // 默认转发——子类选择性重写
35
    void Attack(Enemy* target) override {
36
        innerWeapon->Attack(target);
37
    }
38

39
    float GetDamage() const override {
40
        return innerWeapon->GetDamage();
41
    }
42

43
    std::string GetDescription() const override {
44
        return innerWeapon->GetDescription();
45
    }
46
};
47

48
// ============ 具体装饰器 ============
49

50
class FireEnchantment : public WeaponEnchantment {
51
public:
52
    using WeaponEnchantment::WeaponEnchantment;
53

54
    void Attack(Enemy* target) override {
55
        innerWeapon->Attack(target);
56
        // 附加火焰效果
57
        target->TakeDamage(bonusDamage, DamageType::FIRE);
58
        target->ApplyBurn(burnDamagePerSec, burnDuration);
59
        SpawnEffect("fire_hit", target->GetPosition());
60
    }
61

62
    float GetDamage() const override {
63
        return innerWeapon->GetDamage() + bonusDamage;
64
    }
65

66
    std::string GetDescription() const override {
67
        return innerWeapon->GetDescription() + " + 火焰附魔";
68
    }
69

70
private:
71
    float bonusDamage = 10.0f;
72
    float burnDamagePerSec = 5.0f;
73
    float burnDuration = 3.0f;
74
};
75

76
class LifeStealEnchantment : public WeaponEnchantment {
77
public:
78
    using WeaponEnchantment::WeaponEnchantment;
79

80
    void Attack(Enemy* target) override {
81
        innerWeapon->Attack(target);
82

83
        float dmg = innerWeapon->GetDamage();  // 基于最终伤害吸血
84
        if (target->IsAlive()) {
85
            owner->Heal(dmg * stealPercent);
86
            SpawnEffect("lifesteal", owner->GetPosition());
87
        }
88
    }
89

90
    void SetOwner(Character* o) { owner = o; }
91

92
private:
93
    Character* owner = nullptr;
94
    float stealPercent = 0.15f;
95
};
96

97
class LightningEnchantment : public WeaponEnchantment {
98
public:
99
    using WeaponEnchantment::WeaponEnchantment;
100

101
    void Attack(Enemy* target) override {
102
        innerWeapon->Attack(target);
103

104
        // 连锁闪电——击中最近的 3 个敌人
105
        auto nearby = FindNearbyEnemies(target->GetPosition(), chainRange, chainCount);
106
        for (auto* enemy : nearby) {
107
            enemy->TakeDamage(chainDamage, DamageType::LIGHTNING);
108
        }
109
    }
110

111
private:
112
    float chainDamage = 20.0f;
113
    float chainRange = 5.0f;
114
    int chainCount = 3;
115
};
116

117
// ============ 使用——装饰器的任意组合 ============
118

119
// 普通长剑
120
auto sword = std::make_unique<LongSword>();
121
sword->Attack(target);  // 物理伤害 50
122

123
// 火焰长剑
124
auto fireSword = std::make_unique<FireEnchantment>(std::move(sword));
125
fireSword->Attack(target);  // 物理 50 + 火焰 10 + 燃烧
126

127
// 火焰吸血长剑
128
auto lifestealFireSword = std::make_unique<LifeStealEnchantment>(
129
    std::make_unique<FireEnchantment>(
130
        std::make_unique<LongSword>()
131
    )
132
);
133
lifestealFireSword->SetOwner(player);
134
lifestealFireSword->Attack(target);
135
// 物理 50 + 火焰 10 + 燃烧 + 吸血 15%
136

137
// 火焰吸血连锁闪电长剑——任意组合，不用新写类
138
auto godSword = std::make_unique<LightningEnchantment>(
139
    std::make_unique<LifeStealEnchantment>(
140
        std::make_unique<FireEnchantment>(
141
            std::make_unique<LongSword>()
142
        )
143
    )
144
);
145
std::cout << godSword->GetDescription();
146
// 输出：长剑 + 火焰附魔 + 吸血附魔 + 闪电附魔

1
// ============ 装饰器：每层都必须执行到底 ============
2
class FireEnchantment {
3
    void Attack(Enemy* target) override {
4
        innerWeapon->Attack(target);  // 基础攻击一定会发生
5
        target->ApplyBurn(5.0f);      // 再附加火焰
6
        // innerWeapon->Attack 一定会被调用——装饰器不能跳过
7
    }
8
};
9

10
// ============ 职责链：每层可以选择不传递 ============
11
class InvincibleBuff {
12
    void HandleDamage(DamageContext& ctx) override {
13
        ctx.finalDamage = 0;
14
        // 不调用 CallNext(ctx)——链在此中断，后续 Buff 不会执行
15
    }
16
};

1
// ============ 游戏中已有的接口——不能改 ============
2
class IAudioService {
3
public:
4
    virtual void PlaySound(const std::string& name) = 0;
5
    virtual void StopSound(const std::string& name) = 0;
6
    virtual void SetVolume(float volume) = 0;
7
    virtual ~IAudioService() = default;
8
};
9

10
// ============ Wwise 的原生 API——不能改（第三方库）============
11
class WwiseAPI {
12
public:
13
    void PostEvent(uint32_t eventId) {
14
        // Wwise 底层调用
15
    }
16

17
    void StopEvent(uint32_t eventId) {
18
        // Wwise 底层调用
19
    }
20

21
    void SetMasterVolume(float vol) {
22
        // Wwise 底层调用
23
    }
24
};
25

26
// ============ 适配器——连接两边 ============
27
class WwiseAudioAdapter : public IAudioService {
28
    WwiseAPI* wwise;  // 被适配者
29
    std::unordered_map<std::string, uint32_t> nameToEventId;
30

31
public:
32
    WwiseAudioAdapter() {
33
        wwise = new WwiseAPI();
34
        // 初始化名称到 ID 的映射
35
        nameToEventId["explosion"] = 1001;
36
        nameToEventId["footstep"]  = 1002;
37
        nameToEventId["hit"]       = 1003;
38
    }
39

40
    void PlaySound(const std::string& name) override {
41
        auto it = nameToEventId.find(name);
42
        if (it != nameToEventId.end()) {
43
            wwise->PostEvent(it->second);  // 适配：string → eventId
44
        }
45
    }
46

47
    void StopSound(const std::string& name) override {
48
        auto it = nameToEventId.find(name);
49
        if (it != nameToEventId.end()) {
50
            wwise->StopEvent(it->second);
51
        }
52
    }
53

54
    void SetVolume(float volume) override {
55
        wwise->SetMasterVolume(volume);
56
    }
57
};
58

59
// ============ 游戏代码——一行不改 ============
60
class Game {
61
    IAudioService* audio;
62

63
public:
64
    Game(IAudioService* audioService) : audio(audioService) {}
65

66
    void OnExplosion() {
67
        audio->PlaySound("explosion");  // 不需要知道底层是 FMOD 还是 Wwise
68
    }
69
};
70

71
// 切换音频引擎——只改这一行，游戏代码不动
72
Game game(std::make_unique<WwiseAudioAdapter>());  // 原来是 FmodAudioService