c++ - 在 Entity-Component-System 中拆分组件需要太多的重构

Question

我有一个使用实体组件系统 (ECS) 的现有工作 C++ 游戏库。

我的库的用户想要创建一些组件，例如Cat :-

class Cat{ public:
    int hp;
    float flyPower;
};

他可以修改hp每个 cat通过例如:-

for(SmartComponentPtr<Cat> cat : getAll<Cat>()){
    cat->hp-=5;  //#1
}

几天后，他想 split Cat至 HP和 Flyable :-

class HP{ public:
    int hp;
};
class Flyable{ public:
    float flyPower;
};

因此，每个 cat该访问 hp将编译错误(例如上面代码中的 #1)。

要解决，用户可以将他的代码重构为:-

for(MyTuple<HP,Flyable> catTuple : getAllTuple<HP,Flyable>()){
    SmartComponentPtr<HP> hpPtr=catTuple ; //<-- some magic casting
    hpPtr->hp-=5; 
}

它有效，但需要在用户代码中进行大量重构(调用 cat->hp 的各个地方)。

ECS拆分组件时如何修改框架/引擎解决可维护性问题？

我从未发现任何方法不受此问题的影响，例如:-

• https://github.com/skypjack/entt
  (开源 - 搜索 vel.dx = 0.; 行)
• https://medium.com/@savas/nomad-game-engine-part-2-ecs-9132829188e5
  (博客 - 搜索 int currentHealth; 行)
• https://www.randygaul.net/2013/05/20/component-based-engine-design/
  (博客 - 搜索 comp->DoStuff( dt ); 行)
• (C#，Unity3D)http://www.sebaslab.com/learning-svelto-ecs-by-example-the-unity-survival-example/
  (由 https://codereview.stackexchange.com/questions/48536/an-ecs-model-for-game-development 引用的博客；
  搜索 playerGunComponent.timer += _time.deltaTime; )

赏金原因

Yuri 的回答是一项很酷的技术，但它仍然需要一些重构。

我当前的糟糕解决方案 (pimpl)

如果我想创建Cat ，我将创建 6 个组件:-

• Hp_ , Hp_OO
• Flyable_ , Flyable_OO
• Cat_ , Cat_OO

这是一个代码示例:-

class Hp_ : public BaseComponent{
    int hp=0;
};
class Hp_OO : public virtual BaseComponent{
    Hp_* hpPimpl;
    public: void damage(float dmg){ hpPimpl->hp-=dmg;}
};
class Flyable_  : public BaseComponent{ public:
    float flyPower;
};
class Flyable_OO: public virtual BaseComponent{
    Flyable_* flyPimpl;
    //other function
};
class Cat_: public virtual BaseComponent{};
class Cat_OO: public virtual Hp_OO , public virtual Flyable_OO{
   Cat_* catPimpl;
};

现在，调用是有效的:-

SmartComponentPtr<Cat_OO> catPtr;
catPtr->damage(5);   //: so convenient - no need to refactor 

实现:-

1. 如果用户添加 Cat_OO对于实体，我的游戏引擎会自动将其父类添加到实体，例如Hp_ , Hp_OO , Flyable_ , Flyable_OO , 和 Cat_ .

2. 还必须分配正确的 pimpl 指针/句柄。

3. ^ 两个 Action 都可以使用回调。

缺点是:-

• 需要创建很多组件。 (浪费内存)
• 如果有一个共同的基类，例如BaseComponent ，我需要虚拟继承。 (浪费大量内存)

优点是:-

• 如果用户查询getAll<Hp_OO>() , Hp_OO每个 Cat_OO也将在返回列表中。
• 无需重构。

Answer 1

救援的成员指针:

#include <tuple>

template <typename... Components>
struct MultiComponentPtr {
    explicit MultiComponentPtr(Components*... components)
        : components_{components...}
    {}

    template <typename Component, typename Type>
    Type& operator->*(Type Component::* member_ptr) const {
        return std::get<Component*>(components_)->*member_ptr;
    }

private:
    std::tuple<Components*...> components_;
};

struct Cat {
    int hp;
    float flyPower;
};

struct HP {
    int hp;    
};

struct Flyable {
    float flyPower;    
};

int main() {
    {
        Cat cat;
        MultiComponentPtr<Cat> ptr(&cat);
        ptr->*&Cat::hp += 1;
        ptr->*&Cat::flyPower += 1;
    }

    {
        HP hp;
        Flyable flyable;
        MultiComponentPtr<HP, Flyable> ptr(&hp, &flyable);
        ptr->*&HP::hp += 1;
        ptr->*&Flyable::flyPower += 1;
    }
}

从技术上讲，您仍然需要重构，但是将 &Cat::hp 自动替换为 &HP::hp 等是微不足道的