游戏客户端架构 / 系统课时

组件化设计

组件化设计

组件化设计解决“一个游戏对象承担所有数据和行为”的膨胀问题。完成本课后,你将能把生命值、移动、渲染等能力拆成独立组件,并通过组合构造不同对象。

学习目标

  • 理解游戏对象与组件之间的组合关系
  • 实现一个可添加并更新组件的最小对象模型
  • 识别组件依赖、生命周期和职责边界

为什么不用巨型对象

把角色、子弹、宝箱和机关都写成不同的大型继承类,通常会产生深层继承、重复字段和大量条件判断。组件化设计不再询问“这个对象属于哪个子类”,而是询问“这个对象拥有哪些能力”。

游戏对象负责身份、组件容器和生命周期;组件只负责一个相对独立的领域。例如,玩家可以组合变换、输入、移动、碰撞和生命值组件,宝箱则组合变换、碰撞和交互组件。

游戏对象通过组件组合能力的结构图

实现最小组件模型

下面的 C++17 示例让 GameObject 持有多个组件,并在每帧统一调用它们。生命值组件保存数据,再生组件通过引用协作,从而展示“数据与行为由组合获得”的核心方式。

cpp
#include <iostream>
#include <memory>
#include <utility>
#include <vector>

class Component {
public:
    virtual ~Component() = default;
    virtual void update(float deltaSeconds) = 0;
};

class HealthComponent final : public Component {
public:
    HealthComponent(int current, int maximum)
        : current_(current), maximum_(maximum) {}

    void damage(int value) {
        current_ = current_ - value < 0 ? 0 : current_ - value;
    }

    void heal(int value) {
        current_ = current_ + value > maximum_ ? maximum_ : current_ + value;
    }

    int current() const {
        return current_;
    }

    void update(float) override {}

private:
    int current_;
    int maximum_;
};

class RegenerationComponent final : public Component {
public:
    RegenerationComponent(HealthComponent& health, float pointsPerSecond)
        : health_(health), pointsPerSecond_(pointsPerSecond) {}

    void update(float deltaSeconds) override {
        // 示例按整数生命值结算,生产项目可保留小数累积量。
        health_.heal(static_cast<int>(pointsPerSecond_ * deltaSeconds));
    }

private:
    HealthComponent& health_;
    float pointsPerSecond_;
};

class GameObject {
public:
    template <typename T, typename... Args>
    T& addComponent(Args&&... args) {
        auto component = std::make_unique<T>(std::forward<Args>(args)...);
        T& reference = *component;
        components_.push_back(std::move(component));
        return reference;
    }

    void update(float deltaSeconds) {
        for (const auto& component : components_) {
            component->update(deltaSeconds);
        }
    }

private:
    // GameObject 统一拥有组件,避免组件生命周期早于宿主结束。
    std::vector<std::unique_ptr<Component>> components_;
};

int main() {
    GameObject player;
    auto& health = player.addComponent<HealthComponent>(100, 100);
    player.addComponent<RegenerationComponent>(health, 5.0F);

    health.damage(30);
    player.update(2.0F);

    std::cout << "HP: " << health.current() << std::endl;
    return 0;
}

预期输出:

text
HP: 80

GameObject 只负责保存和驱动组件,不知道生命值如何恢复。新增护盾、状态效果或音效时,可以继续添加组件,而不必修改宿主类的核心结构。

处理依赖与生命周期

组件之间可以协作,但依赖必须显式。示例中的再生组件需要生命值组件,因此创建顺序由调用方保证。更完整的引擎通常提供按类型查询、组件句柄或依赖声明,以便在缺少组件时立即报错。

删除组件时还要避免悬空引用。生产实现可以禁止运行期间删除被依赖组件,或使用稳定句柄并在访问时校验有效性。对象销毁时,应先停止更新,再释放组件,最后从场景索引中移除对象。

保持组件职责清晰

一个组件最好只围绕一种能力组织数据和行为。移动组件可以读取速度并修改变换,但不应同时处理背包、音频和任务逻辑。跨组件协调较多时,应由系统层统一批处理,而不是让每个组件互相调用形成网状依赖。

并非所有组件都必须每帧更新。纯数据组件可以没有更新逻辑,渲染、物理或动画组件则可由对应系统按批次处理,从而减少虚函数调用并提升缓存局部性。

本课总结

  • 组件化通过组合能力替代深层继承,使对象结构更灵活
  • 游戏对象负责拥有组件,组件负责单一领域的数据或行为
  • 组件依赖和删除规则必须显式设计,避免隐式耦合与悬空引用

下一课预告

下一课将实现变换组件,统一保存位置、旋转、缩放,并处理父子对象之间的局部与世界变换。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

组件化设计

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通