spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

struct Collider{
    bool rectangular;
    AABB box;
    Circle circle;
};

C-/C++-Quelltext

class RigidBody { ... };

class AABBRigidBody : public RigidBody { ... };
class CircleRigidBody : public RigidBody { ... };

C-/C++-Quelltext

// Collider-Strukturen: Achsengebundenes Rechteck und Kreis
//
struct AABB{
    float x;
    float y;
    float w;
    float h;
};

struct Circle{
    float x;
    float y;
    float r;
};
//



// Körper-Klasse: virtuelle Methoden für Kollision, normale Methoden für andere Simulation
//
class AABBBody;
class CircleBody;

class Body{
public:
    void update(float time) { /* Implementierung */ };

    virtual bool collidesWith(AABBBody& other) = 0;
    virtual bool collidesWith(CircleBody& other) = 0;

protected:
    float mass;
};
//



// Collider-Erweiterungen für Körper-Klasse: Achsengebundenes Rechteck und Kreis
//
class AABBBody : public Body{
public:
    bool collidesWith(AABBBody& other) override { /* Implementierung */ return false; }
    bool collidesWith(CircleBody& other) override { /* Implementierung */ return false; }

protected:
    AABB aabb;
};

class CircleBody : public Body{
public:
    bool collidesWith(AABBBody& other) override { /* Implementierung */ return false; }
    bool collidesWith(CircleBody& other) override { /* Implementierung */ return false; }

protected:
    Circle circle;
};
//



// Zwei Testklassen: Stein und Fenster
//
class Stone : public CircleBody{
public:
    Stone(float x, float y, float r)
    {
        mass = r * 5;
        circle = { x, y, r };
    }
};
class Window : public AABBBody{
public:
    Window(float x, float y, float w, float h)
    {
        mass = w * h * 2;
        aabb = { x, y, w, h };
    }
};
//



int main()
{
    Stone s(50.0F, 50.0F, 4.0F);
    Window w(30.0F, 30.0F, 100.0F, 20.0F);

    if (s.collidesWith(w)) return 1;

    return 0;
}

C-/C++-Quelltext

// Namespace für Kollisionprüfungen zwischen Collidern
//
class Collider;

namespace collision
{
    static bool boxVsBox(Collider* box1, Collider* box2) { return false; }
    static bool boxVsCircle(Collider* box, Collider* circle) { return false; }
    static bool circleVsCircle(Collider* circle1, Collider* circle2) { return false; }
}
//



// abstrakte Collider-Klasse
//
class Collider{
public:
    enum class Type{
        Box,
        Circle
    };
    struct Data{
        float x;
        float y;
        float wr; // Breite oder Radius
        float hu; // Höhe oder unbenutzt
    };

    virtual void set(Data& d) = 0;
    virtual bool collidesWith(Collider* other) = 0;
    virtual Type getType() = 0;
    virtual Data& getData() = 0;
};
//



// Collider-Typen: Rechteck und Kreis
//
class Box : public Collider{
public:
    void set(Data& d) override
    {
        x = d.x;
        y = d.y;
        w = d.wr;
        h = d.hu;
    }

    bool collidesWith(Collider* other) override
    {
        if (other->getType() == Type::Box) return collision::boxVsBox(this, other);
        if (other->getType() == Type::Circle) return collision::boxVsCircle(this, other);
    }

    Type getType() override
    {
        return Type::Box;
    }
    
    Data& getData() override
    {
        Data d = { x, y, w, h };
        return d;
    }

private:
    float x;
    float y;
    float w;
    float h;
};

class Circle : public Collider{
public:
    void set(Data& d) override
    {
        x = d.x;
        y = d.y;
        r = d.wr;
    }

    bool collidesWith(Collider* other) override
    {
        if (other->getType() == Type::Box) return collision::boxVsCircle(other, this);
        if (other->getType() == Type::Circle) return collision::circleVsCircle(this, other);
    }

    Type getType() override
    {
        return Type::Circle;
    }

    Data& getData() override
    {
        Data d = { x, y, r, 0.0f };
        return d;
    }

private:
    float x;
    float y;
    float r;
};
//