Handling Object Collisions

A common requirement we will have when implementing our game logic is a need to understand not just when a collision happened, but the nature of that collision.

For example, our HandleCollision() function may encounter a situation like the following:

It's not entirely clear how this should be resolved. If the player got into this situation by falling down, the expected resolution would be to push the character back up. But, if they got into this situation by jumping into the wall from the left, the natural response would be to push the character back to the left:

To understand how to resolve this situation, our HandleCollision() function often needs to get a deeper understanding of how this situation arose. This might involve tactics like:

• Checking the velocity of the player
• Comparing the positions of the colliding objects
• Comparing the width and height of the intersection rectangle

Ultimately, how we react to any collision will be a judgment call based on the needs of our game. The following code shows some examples of implementing these checks:

1// GameObject.cpp
2// ...
3
4void GameObject::HandleCollisions() {
5  isOnGround = false;
6  for (const GameObject& O
7    : Scene.GetObjects()
8  ) {
9    // Prevent self-collision
10    if (&O == this) continue;
11
12    SDL_FRect Intersection;
13    if (Bounds.GetIntersection(
14      O.Bounds, &Intersection
15    )) {
16      if (Velocity.x > 0) {
17        std::cout << "I was moving right\n";
18      }
19      if (Velocity.y >= 0) {
20        std::cout << "I wasn't falling\n";
21      }
22      if (Position.x < O.Position.x) {
23        std::cout << "I'm to the left of the "
24          "object I collided with\n";
25      }
26      if (Intersection.h > Intersection.w) {
27        std::cout << "The intersection is "
28          "mostly vertical\n";
29      }
30
31      std::cout << "I think I should be pushed "
32        "to the left";
33      Position.x -= Intersection.w;
34    }
35  }
36}

1I was moving right
2I wasn't falling
3I'm to the left of the object I collided with
4The intersection is mostly vertical
5I think I should be pushed to the left

For more complex simulations, our object may need to be comprised of multiple bounding boxes. For example, we might need to determine if objects hit our player's weapon, shield, or body:

We'll introduce an efficient way to let our objects have multiple bounding boxes in the next chapter. However, this is less necessary than we might expect. We can create many mechanics with a single bounding box and some clever logic.

For example, classic platformer games typically have mechanics where jumping on the head of an enemy defeats them, but hitting any other part causes the player to lose a life.

An intuitive approach to solve this problem might be to add separate bounding boxes for the head and the body, but this is rarely necessary. Instead, the illusion can be created with a single bounding box, and comparing the state of the objects at the time they intersect:

1// GameObject.cpp
2// ...
3
4void GameObject::HandleCollisions() {
5  isOnGround = false;
6  for (const GameObject& O
7    : Scene.GetObjects()
8  ) {
9    // Prevent self-collision
10    if (&O == this) continue;
11
12    SDL_FRect Intersection;
13    if (Bounds.GetIntersection(
14      O.Bounds, &Intersection
15    )) {
16      if (Position.y > O.Position.y) {
17        std::cout << "I landed on his head";
18      }
19    }
20  }
21}

In a more complex game, our objects can collide with many different things, such as enemies, walls, and projectiles.

If the player collides with a wall, we might want to change their position but, if they collide with a projectile, perhaps we want to reduce their health instead.

In a real project, it is typically the case that our objects will use some form of inheritance based on a polymorphic base type. Within that context, we can add a virtual method for retrieving information as to the type of the object.

Derived types can override those functions as needed:

1// GameObject.h
2// ...
3
4enum class GameObjectType {
5  GameObject, Player, Projectile, Floor
6};
7
8class GameObject {
9public:
10  virtual GameObjectType GetType() {
11    return GameObjectType::GameObject;
12  }
13  
14  virtual std::string GetTypeName() {
15    return "GameObject";
16  }
17  
18  bool HasType(GameObjectType TargetType) {
19    return GetType() == TargetType;
20  }
21  
22  virtual ~GameObject() = default;
23  // ...
24};
25
26class Player : public GameObject {
27public:
28  using GameObject::GameObject;
29  GameObjectType GetType() override {
30    return GameObjectType::Player;
31  }
32  
33  std::stringGetTypeName() override {
34    return "Player";
35  }
36};
37
38class Floor: public GameObject {
39public:
40  using GameObject::GameObject;
41  GameObjectType GetType() override {
42    return GameObjectType::Floor;
43  }
44  std::stringGetTypeName() override {
45    return "Floor";
46  }
47};
48
49class Projectile : public GameObject {
50public:
51  using GameObject::GameObject;
52  GameObjectType GetType() override {
53    return GameObjectType::Projectile;
54  }
55  std::stringGetTypeName() override {
56    return "Projectile";
57  }
58};

To implement run-time polymorphism, systems like our Scene and physics code will be working with pointers or references to that polymorphic base type. For example, rather than managing a collection of GameObject instances, our Scene might manage a collection of GameObject pointers, or smart pointers:

1// Scene.h
2// ...
3#include <memory> // for std::unique_ptr
4
5class Scene {
6public:
7  Scene() {
8    Objects.emplace_back(std::make_unique<Player>(
9      "dwarf.png", Vec2{6, 2.8}, 1.9, 1.7, *this, true));
10    Objects.emplace_back(std::make_unique<Floor>(
11      "floor.png", Vec2{4.5, 1}, 5, 2, *this, false));
12  }
13  // ...
14
15private:
16  std::vector<std::unique_ptr<GameObject>> Objects;
17  // ...
18};

Note that this type change requires more code updates than what is shown above. In the Complete Code section at the end of this lesson, we include all the changes.

Now that we've split our game objects across multiple types, our collision system has more information with which to determine its reaction:

1// GameObject.cpp
2// ...
3
4void GameObject::HandleCollisions() {
5  isOnGround = false;
6  for (const std::unique_ptr<GameObject>& O
7    : Scene.GetObjects()
8  ) {
9    // Prevent self-collision
10    if (O.get() == this) continue;
11
12    SDL_FRect Intersection;
13    if (Bounds.GetIntersection(
14      O->Bounds, &Intersection
15    )) {
16      std::cout << "I hit a " << O->GetTypeName();
17      if (O->HasType(GameObjectType::Floor)) {
18        std::cout << "\nReacting to floor..."
19        // ...
20      }
21    }
22  }
23}

1I hit a floor
2Reacting to floor...

A common design is also to let the object itself determine what effect it should have when it hits some other object. This can include simple values that the colliding object can examine or functions that it can call for more complex behaviors.

Below, we add a CanPassThrough() method that determines whether our type is a solid object like the floor or something that objects can move through such as light foliage:

1// GameObject.h
2// ...
3
4class GameObject {
5public:
6  virtual bool CanPassThrough() { return true; };
7  // ...
8};
9
10class Floor : public GameObject {
11 public:
12  bool CanPassThrough() override { return false; }
13  // ...
14};

We can also add an OnHit() method to our base class, which subtypes can override to create more complex hit interactions. Below, our FloorTrap type uses this to inflict damage if it hits a Player:

1// GameObject.h
2// ...
3
4class GameObject {
5public:
6  virtual void OnHit(GameObject& Target) {}
7  // ...
8};
9 
10// ...
11class Player : public GameObject {
12 public:
13  // ...
14  void TakeDamage(int Damage) {
15    Health -= Damage;
16  }
17
18  int Health{100};
19};
20
21class FloorTrap : public Floor {
22 public:
23  using Floor::Floor;
24  void OnHit(GameObject& Target) override {
25    if (Player* P{dynamic_cast<Player*>(&Target)}) {
26      P->TakeDamage(10);
27    }
28  }
29};

Using these new functions in our collision system would look something like this:

1// GameObject.h
2// ...
3
4void GameObject::HandleCollisions() {
5  isOnGround = false;
6  for (const GameObject& O : Scene.GetObjects()) {
7    // Prevent self-collision
8    if (&O == this) continue;
9
10    SDL_FRect Intersection;
11    if (Bounds.GetIntersection(
12      O.Bounds, &Intersection
13    )) {
14      O->OnHit(this);
15      if (O->CanPassThrough()) {
16        // I can pass through this object - no need
17        // to change my position or velocity
18        continue;
19      }
20  
21    // I can't pass through - I need to be
22    // pushed back
23    // ...
24  }
25}

We've included the complete versions of our GameObject and Scene classes below, containing all the techniques and concepts we covered in this lesson:

In this lesson, we made our game objects interact by implementing a collision system. We replaced arbitrary position limits with detection logic based on bounding box intersections. We focused on resolving collisions by correcting object positions and velocities, particularly for floor interactions, and applied polymorphism to allow varied responses depending on what objects are colliding.

Key Takeaways:

• Check for collisions by iterating through scene objects and testing bounding box intersections, skipping self-collision checks.
• The intersection rectangle (SDL_FRect) provides data (width, height) crucial for resolving the collision.
• Basic floor collision response involves moving the object up by the intersection height and zeroing vertical velocity.
• Use flags like isOnGround to communicate collision state to other parts of the game logic (e.g., jumping).
• More advanced resolution considers collision angle/sides by comparing intersection width and height or object velocities.
• Object-oriented design with virtual methods enables defining specific behaviors (like damage on hit or pass-through ability) for different object types.
• Using smart pointers like std::unique_ptr manages memory for polymorphic objects stored in collections like std::vector.