Entity-Component-System中的拆分组件需要过多的重构

Question

我有一个使用Entity-Component-System（ECS）的现有C ++游戏库。

我的图书馆用户希望创建一些组件，例如Cat ： -

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

他可以修改每cat的hp ，例如： -

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

几天后，他想将Cat分为HP和Flyable ： -

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

因此，每个访问hp cat都会编译错误（例如，在上面的代码中为#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
  （opensource - 搜索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. ^两个动作都可以使用回调。

缺点是： -

• 需要创建许多组件。 （浪费记忆）
• 如果有一个公共基类，例如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;
    }
}

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