Designfrage



  • Hi,

    ich zerbreche mir grade meinen Kopf bei der Planung meines neuen Spieles, zwar sind es Kleinigkeiten aber im Detail liegt oft der Teufel...

    Also:

    Es gibt in meinem Spiel Objekte (z.B. Raumschiffchen, Panzer, Felsen usw.) Diese ganzen Objekte werden von diesem Interface abgeleitet und dann per FactoryPlattern in einen EntityManager gestopft:

    class IEntity
    {
    public:
        // paar getter paar setter
    
    protected:
        vectorN<float, 4> position_;
        vectorN<float, 4> rotation_;
    };
    

    Soweit sogut, nun gibt es natürlich auch Kollisionsabfragen! Diese sollen in folgender Reihenfolge erfolgen (Schnell zu Langsam):
    - Sphere
    - BoundingBox (Objektorientiert)
    - BSP
    - Triangle

    Nun hab ich jedoch paar fragen:
    Sollte so ein IEntity objekt eine klasse beinhalten für Spheren (z.B. class sphere) und BoundingBoxen? Oder nur für Sphere den Radius und für BoundingBox nur Min und Max-Value angeben aber keine extra klasse erstellen und Kollisionsabfrage per Funktion durchnehmen?

    Was findet ihr besser?



  • *push*

    Könnt ihr mir keine "popelige" Designfrage beantworten?



  • Ich hatte mir vor kurzen auch darüber Gedanken gemacht und mir sowas überlegt:

    class CollisionTest
    {
    virtual bool Test( IEntity* CollideWith ) = 0;
    };
    
    class CollisionTestSphere : CollisionTest
    {
        bool Test( IEntity* CollideWith)
        {
            //Do something
        }
    };
    
    class CollisionTestBBox : CollisionTest
    {
        bool Test( IEntity* CollideWith)
        {
            //Do something
        }
    };
    
    class CollisionTestBSP : CollisionTest
    {
        bool Test( IEntity* CollideWith)
        {
            //Do something
        }
    };
    
    class CollisionTestTriangle : CollisionTest
    {
        bool Test( IEntity* CollideWith )
        {
            //Do something
        }
    };
    
    class IEntity
    {
    public:
    
        IEntity( ..., enum_CollisonType ct)
        {
            switch(ct)
            {
            case CT_SPHERE:
                this->Col = new (CollisonTest*) CollisionTestSphere(Vertex_Liste_übergeben);
                break;
            case CT_BOUNDINGBOX:
                this->Col = new (CollisonTest*) CollistionTestBBox(Vertex_Liste_übergeben);
                break;
            case CT_BSP:
                this->Col = new (CollisonTest*) CollisionTestBSP(Vertex_Liste_übergeben);
                break;
            case CT_TRIANGLE:
                this->Col = new (CollisonTest*) CollisionTestTriangle(Vertex_Liste_übergeben);
                break;
            }
        }    
    
        bool TestCollision( IEntity* CollideWith)
        {
            return this->Col->Test(CollideWith);
        }
    
        CollionTest Col;
    
    protected:
        vectorN<float, 4> position_;
        vectorN<float, 4> rotation_;
    };
    

Log in to reply