コンポーネントベースのゲームの設計

私はシューティングゲーム（1942、クラシック2Dグラフィックスなど）を書いていますが、コンポーネントベースのアプローチを使用したいと思います。これまでのところ、次の設計について考えました。

1. 各ゲーム要素（飛行船、発射物、パワーアップ、敵）はエンティティです

2. 各エンティティは、実行時に追加または削除できるコンポーネントのセットです。例には、Position、Sprite、Health、IA、Damage、BoundingBoxなどがあります。

飛行船、発射物、敵、パワーアップはゲームクラスではないという考え方です。エンティティは、所有するコンポーネントによってのみ定義されます（時間の経過とともに変化する可能性があります）。そのため、プレイヤーの飛行船は、スプライト、位置、ヘルス、および入力コンポーネントから始まります。パワーアップには、Sprite、Position、BoundingBoxがあります。等々。

メインループは、ゲームの「物理」、つまりコンポーネントの相互作用を管理します。

foreach(entity (let it be entity1) with a Damage component)
    foreach(entity (let it be entity2) with a Health component)
    if(the entity1.BoundingBox collides with entity2.BoundingBox)
    {
        entity2.Health.decrease(entity1.Damage.amount());
    }

foreach(entity with a IA component)
    entity.IA.update(); 

foreach(entity with a Sprite component)
    draw(entity.Sprite.surface()); 

...

コンポーネントは、メインC ++アプリケーションにハードコーディングされています。エンティティはXMLファイル（luaまたはpythonファイルのIAパーツ）で定義できます。

メインループはエンティティをあまり気にしません。コンポーネントを管理するだけです。ソフトウェア設計では、次のことを許可する必要があります。

1. コンポーネントを指定して、それが属するエンティティを取得します

2. エンティティを指定すると、タイプ「type」のコンポーネントを取得します

3. すべてのエンティティについて、何かをする

4. すべてのエンティティのコンポーネントについて、何かを実行します（例：シリアル化）

私は次のことを考えていました：

class Entity;
class Component { Entity* entity; ... virtual void serialize(filestream, op) = 0; ...}
class Sprite : public Component {...};
class Position : public Component {...};
class IA : public Component {... virtual void update() = 0; };

// I don't remember exactly the boost::fusion map syntax right now, sorry.
class Entity
{
   int id; // entity id
   boost::fusion::map< pair<Sprite, Sprite*>, pair<Position, Position*> > components;
   template <class C> bool has_component() { return components.at<C>() != 0; }
   template <class C> C* get_component() { return components.at<C>(); }
   template <class C> void add_component(C* c) { components.at<C>() = c; }
   template <class C> void remove_component(C* c) { components.at<C>() = 0; }
   void serialize(filestream, op) { /* Serialize all componets*/ }
...
};

std::list<Entity*> entity_list;

この設計では、＃1、＃2、＃3（boost :: fusion :: mapアルゴリズムに感謝）と＃4を取得できます。また、すべてがO（1）です（正確ではありませんが、それでも非常に高速です）。

より一般的なアプローチもあります。

class Entity;
class Component { Entity* entity; ... virtual void serialize(filestream, op) = 0; ...}
class Sprite : public Component { static const int type_id = 0; };
class Position : public Component { static const int type_id = 1; };

class Entity
{
   int id; // entity id
   std::vector<Component*> components;
   bool has_component() { return components[i] != 0; }
   template <class C> C* get_component() { return dynamic_cast<C> components[C::id](); } // It's actually quite safe
...
};

もう1つの方法は、Entityクラスを削除することです。各コンポーネントタイプは独自のリストにあります。スプライトリスト、ヘルスリスト、ダメージリストなどがあります。これらはエンティティIDにより同じロジックエンティティに属していることがわかります。これはもっと簡単ですが、IAコンポーネントは基本的に他のすべてのエンティティのコンポーネントにアクセスする必要があり、各ステップで他のコンポーネントのリストを検索する必要があります。

どのアプローチが良いと思いますか？boost :: fusion mapは、そのように使用するのに適していますか？

コンポーネントベースの設計とデータ指向の設計が密接に関連していることがわかりました。コンポーネントの同種リストを持ち、ファーストクラスのエンティティオブジェクトを削除する（コンポーネント自体のエンティティIDを選択する）のは「遅い」と言いますが、実際のコードをプロファイリングしていないため、ここでもそこにもありません両方のアプローチを実装して、その結論に到達します。実際、データ指向設計のさまざまな利点（並列化、キャッシュ使用率、モジュール性など）により、コンポーネントの均質化と従来の重い仮想化の回避がより高速になることをほぼ保証できます。

このアプローチがすべてに理想的だとは言いませんが、基本的にはすべてのフレームで同じ変換を実行する必要があるデータのコレクションであるコンポーネントシステムは、単にデータ指向であると叫びます。コンポーネントが異なるタイプの他のコンポーネントと通信する必要がある場合がありますが、これはいずれにせよ必要な悪事になるでしょう。ただし、メッセージキューやfutureなどのすべてのコンポーネントが並行して処理される極端な場合でも、この問題を解決する方法があるため、設計を推進すべきではありません。

コンポーネントベースのシステムに関連するデータ指向のデザインをGoogleが担当しているのは、このトピックが多く取り上げられ、かなりの議論と逸話的なデータが出回っているからです。

このようなコードを書く場合は、このアプローチを使用します（あなたにとって重要な場合はブーストを使用しません）いくつかのコンポーネントを共有していないため、コンポーネントを見つけるには時間がかかります。それ以外には、私ができる他の問題はありません：

// declare components here------------------------------
class component
{
};

class health:public component
{
public:
    int value;
};

class boundingbox:public component
{
public :
    int left,right,top,bottom;
    bool collision(boundingbox& other)
    {
        if (left < other.right || right > other.left)
            if (top < other.bottom || bottom > other.top)
                return true;
        return false;
    }
};

class damage : public component
{
public:
    int value;
};

// declare enteties here------------------------------

class entity
{
    virtual int id() = 0;
    virtual int size() = 0;
};

class aircraft :public entity, public health,public boundingbox
{
    virtual int id(){return 1;}
    virtual int size() {return sizeof(*this);};
};

class bullet :public entity, public damage, public boundingbox
{
    virtual int id(){return 2;}
    virtual int size() {return sizeof(*this);};
};

int main()
{
    entity* gameobjects[3];
    gameobjects[0] = new aircraft;
    gameobjects[1] = new bullet;
    gameobjects[2] = new bullet;
    for (int i=0;i<3;i++)
        for(int j=0;j<3;j++)
            if (dynamic_cast<boundingbox*>(gameobjects[i]) && dynamic_cast<boundingbox*>(gameobjects[j]) &&
                dynamic_cast<boundingbox*>(gameobjects[i])->collision(*dynamic_cast<boundingbox*>(gameobjects[j])))
                if (dynamic_cast<health*>(gameobjects[i]) && dynamic_cast<damage*>(gameobjects[j]))
                    dynamic_cast<health*>(gameobjects[i])->value -= dynamic_cast<damage*>(gameobjects[j])->value;
}

このアプローチでは、すべてのコンポーネントはエンティティのベースであるため、コンポーネントのポインタはエンティティでもあります。あなたが求める2番目のことは、いくつかのエンティティのコンポーネントへの直接アクセスを持つことです。私が使用するエンティティのいずれかで損傷にアクセスする必要があるdynamic_cast<damage*>(entity)->value場合、entity損傷コンポーネントがある場合は値を返します。entityコンポーネントに損傷があるかどうかわからない場合、キャストが有効でない場合はif (dynamic_cast<damage*> (entity))戻り値dynamic_castが常にNULLであり、有効な場合は要求された型と同じポインターであることを簡単に確認できます。だから、entitiesいくつかを持っているすべてのもので何かをするためには、component以下のようにすることができます

for (int i=0;i<enteties.size();i++)
    if (dynamic_cast<component*>(enteties[i]))
        //do somthing here

他に質問があれば、喜んでお答えします。