How to architect collision detection in SFML

Question

I have a pretty simple game engine that I'm making for a 2d platformer game. I don't want it to be super advanced, but it does have some basic properties. Most important to this question is a class called Entity. Entities are basically just objects in the game that are drawn to the screen and move around. They all have a square bounding box aroud them. Each different entity inherits from the class Entity (ex. Player and Ground inherit from Entity).

I want a nice, object oriented way to handle collisions between different entities. I'd like to be able to write rules of what happens when two things collide in such a way that I don't have to do a ton of casts or rewrite a lot of code. I was thinking of doing something like

class Entity {
    public:
        void collide(Entity* ent);
}

But I'm not sure how I would go about getting the type of the argument. Any suggestions on what to do?

Answer 1

It sounds to me like you could make use of a 2D jump table. The idea is to store the identity of each entity as an integer, and use this ID to index into a virtual table of function calls.

class Entity
{
  enum Type
  {
    eAABB,
    eCircle,
    ePolygon
  };

  Type type;
};

bool AABBtoAABB( Entity *a, Entity *b )
{
  AABB *A = (AABB *)a;
  AABB *B = (AABB *)b;

  // ...
}

bool AABBtoCircle( Entity *a, Entity *b );
bool AABBtoPolygon( Entity *a, Entity *b );
bool CircletoCircle( Entity *a, Entity *b );
bool CircletoAABB( Entity *a, Entity *b );
bool CircletoPolygon( Entity *a, Entity *b );
// ...

CollideArray[][] = {
  AABBtoAABB, AABBtoCircle, AABBtoPolygon,
  CircletoCircle, CircletoAABB, CircletoPolygon,
  // ...
};

bool Collide( Entity *a, Entity *b )
{
  return CollideArray[a->type][b->type]( a, b );
}

This style makes you code an N^2 number of functions, where N is the number of different entity types that participate. However some of the entries are just duplicates where the two types are swapped.

This is pretty implementation dynamic dispatch for multiple types, as opposed to how standard C++ often is implemented with a single dimensional jump table for the virtual keyword.