Game Collision-Handling

Question

The code given is for example purposes, not copypasta from my codebase

I'm writing a primitive, cross-platform Snake game in C++ with Boost & SDL, and I'm wondering what the best way to implement collision-handling is (not collision-detection). So far, I've been using a single-dispatch idea, with ugly spaghetti code, like so:

void Snake::CollisionHandler(const WorldObject& obj)
{
    // collided with self
    if(obj.GetObjectType() == snake)
        Die();
    ...
    ...
}

Also, I have a "global" collision handler, which does things involved in a collision, which are independent of each object, for example:

void GameWorld::CollisionHandler(WorldObject& obj1, WorldObject& obj2)
{
    if(obj1.GetObjectType() == snake && obj2.GetObjectType() == snake)
        PlayDeathSound();
    ...
    ...
}

To avoid things like sounds being played twice for collisions.

I've also considered double-dispatch, like so:

void Snake::CollisionHandler(WorldObject& obj) const
{
    // invoke obj's collision handler with a const Snake& parameter
    obj.CollisionHandler(*this);
}
// collided with self
void Snake::CollisionHandler(const Snake& obj)
{
    Die();
}

This also includes a similar global collision handler like above.

Then there's the approach of only having a global collision handler (which is a friend function to all game objects), like so:

void GameWorld::CollisionHandler(WorldObject& obj1, WorldObject& obj2)
{
    // snake collided with self
    if(obj1.GetObjectType() == snake && obj2.GetObjectType() == snake)
    {
        obj1.Die();
        obj2.Die();
        PlayDeathSound();
    }
    ...
    ...
}

Are there any strategies I'm missing? Which of these ends up being the nicest? They all seem to have some ugly code involved, and the single- and double- dispatch ones involve polymorphism, which I personally try to shy away from.

Answer 1

Collision handling is an area where C++/Java-style object orientation (with single dispatch) is not flexible enough. The result of a collision depends on the types of both colliding objects, so you need multiple dispatch to handle it. (It's no coincidence that the motivating example on Wikipedia's multiple dispatch article is collision handling!)

I think that a global collision handler that then dispatches to individual object methods is the best workaround for this inadequacy in C++.