Handling Object Collisions

In this lesson, we’ll revisit our physics system and integrate our new bounding boxes and rectangle intersection tools to allow objects to interact with each other.

We'll start by adding a floor object, and we’ll use bounding box intersections to detect when our object hits the floor (or anything else).

Finally, we'll code the logic to react to these collisions appropriately, with behaviors such as preventing objects from overlapping or reducing our player’s health if they get hit by a projectile.

Currently, we’re simulating the effects of gravity, which is constantly accelerating objects towards the floor of our world. However, we don’t really have a "floor" - we’re just faking it by limiting our object’s y position:

1// GameObject.cpp
2// ...
3
4void GameObject::Tick(float DeltaTime) {
5  ApplyForce(FrictionForce(DeltaTime));
6  ApplyForce(DragForce());
7  Velocity += Acceleration * DeltaTime;
8  Position += Velocity * DeltaTime;
9
10  Acceleration = {0, -9.8};
11
12  // Don't fall through the floor
13  if (Position.y < 2) {
14    Position.y = 2;
15    Velocity.y = 0;
16  }
17  Bounds.SetPosition(GetPosition());
18  Clamp(Velocity);
19}
20
21// ...

Let’s improve this by introducing an object that represents our floor, and prevents other objects from falling through it. We’ll do this using our new bounding boxes and intersection tests, rather than the hard-coded assumption that the ground’s y-position is always 2.

Adding Stationary Objects

Let’s add an object to our scene to represent our floor. We typically don’t want our floor and similar objects to be affected by gravity or movable in general. To handle this, we’ll add an isMovable boolean to our GameObject class:

1// GameObject.h
2// ...
3
4class GameObject {
5public:
6  GameObject(
7    const std::string& ImagePath,
8    const Vec2& InitialPosition,
9    float Width,
10    float Height,
11    const Scene& Scene,
12    bool isMovable = false
13  ) : Image{ImagePath},
14      Position{InitialPosition},
15      Scene{Scene},
16      isMovable{isMovable},
17      Bounds{
18        SDL_FRect{
19          InitialPosition.x, InitialPosition.y,
20          Width, Height
21        }} {}
22
23private:
24  bool isMovable;
25};

Within our Tick() function, we’ll skip all of our physics simulations for stationary objects:

1// GameObject.cpp
2// ...
3
4void GameObject::Tick(float DeltaTime) {
5  if (!isMovable) return;
Tick Logic (Unchanged)|Show
20}
21
22// ...

Let’s update our Scene to make our dwarf movable, and construct an immovable object representing our floor:

1// Scene.h
2// ...
3
4class Scene {
5public:
6  Scene() {
7    Objects.emplace_back("dwarf.png",
8      Vec2{6, 2.8}, 1.9, 1.7, *this, true);
9    Objects.emplace_back("floor.png",
10      Vec2{4.5, 1}, 5, 2, *this, false);
11  }
12  // ...
13};

We should now see both of our objects rendered, and our character will fall until it reaches our hardcoded Position.y < 2 check.

Collision Checks

To determine what an object is colliding with, the object will need access to the things within our scene. We’ll add a getter to our Scene to provide this access:

1// Scene.h
2// ...
3
4class Scene {
5public:
6  // ...
7  const std::vector<GameObject>& GetObjects() const {
8    return Objects;
9  }
10  // ...
11};

Within our GameObject class, we’ll add a HandleCollisions() function.

1// GameObject.h
2// ...
3
4class GameObject {
5// ...
6private:
7  // ...
8  void HandleCollisions();
9};

1// GameObject.cpp
2// ...
3
4void GameObject::HandleCollisions() {
5  // ...
6}

We’ll call it within our Tick() function. We’ll also remove our rudimentary floor check, as our HandleCollision() function will take care of it eventually:

1// GameObject.cpp
2// ...
3
4void GameObject::Tick(float DeltaTime) {
Unchanged Code|Show
11
12  // Don't fall through the floor
13  if (Position.y < 2) {
14    Position.y = 2;
15    Velocity.y = 0;
16  }
17  Bounds.SetPosition(GetPosition());
18  HandleCollisions();
19  Clamp(Velocity);
20}
21
22// ...

Running our game, we should now see that our player immediately falls through the floor and off the bottom of our screen:

To solve this problem, we first need to detect when our character hits the floor. Earlier in the chapter, we added bounding boxes to our GameObject instances so, to understand which objects are colliding, we need to check which bounding boxes are intersecting.

Let’s do this within our HandleCollisions() function:

1// GameObject.cpp
2// ...
3
4void GameObject::HandleCollisions() {
5  for (const GameObject& O : Scene.GetObjects()) {
6    // Prevent self-collision
7    if (&O == this) continue;
8
9    SDL_FRect Intersection;
10    if (Bounds.GetIntersection(
11      O.Bounds, &Intersection
12    )) {
13      std::cout << "Collision Detected\n";
14      // Handle Collision...
15    } else {
16      std::cout << "No Collision\n";
17    }
18  }
19}

We should now see collisions being detected. Eventually, our player will completely fall through the floor to the space below it, at which point their bounding boxes will no longer be overlapping:

1Collision Detected
2Collision Detected
3Collision Detected
4...
5No Collision
6No Collision
7...

Physics Sub-Stepping

When an object is moving very quickly, or our physics system is ticking slowly, it may miss some collisions. For example, a projectile may be moving so quickly that it travels through its target within a single frame:

From the perspective of our physics system, the projectile was never overlapping its target, so this would have been inaccurately reported as a miss.

A common way to solve this is using substepping. For example, within every frame, we may decide to have our physics system tick 4 times, where each step simulates 25% of the total frame delta time:

We won’t need physics sub-stepping in our simple games, but it’s a useful concept to be aware of

Reacting to Collisions

Once we’ve detected a collision, we next need to understand how to react to it. The nature of our reaction depends entirely on our game and the mechanics we’re trying to create.

Throughout the rest of this lesson, we’ll cover many techniques to understand the nature of collisions so we can create more dynamic reactions. For now, though, the only possible collision our system could have detected was the character falling into the floor, so let’s react to that.

The reaction to floor collisions is usually pretty standard across games - we resolve the overlap by moving our object out of the collision. When falling onto a surface, this typically means pushing our object upwards by increasing it’s Position.y.

To understand how much we need to increase y by, we need to determine how far our character has fallen into the floor. The most generally useful approach is to retrieve the intersection rectangle using a function like the GetIntersection() method we added to our BoundingBox class in the previous lesson.

Then, using the intersection rectangle calculated by GetIntersection(), we can determine the overlap depth. For a simple vertical collision (like landing on a floor), we push our object up by the height of that intersection (Intersection.h), thereby resolving the overlap and placing our object correctly on top of the surface it was colliding with:

1// GameObject.cpp
2// ...
3
4void GameObject::HandleCollisions() {
5  for (const GameObject& O : Scene.GetObjects()) {
6    // Prevent self-collision
7    if (&O == this) continue;
8
9    SDL_FRect Intersection;
10    if (Bounds.GetIntersection(
11      O.Bounds, &Intersection
12    )) {
13      Position.y += Intersection.h;
14
15      // See note below
16      Velocity.y = 0;
17    }
18  }
19}

Remember, the physics and collision reactions are all happening within the same frame - the player never sees our objects overlapping. It happens behind the scenes, and our HandleCollision() function resolves it before the player sees any overlap.

Note: Updating Velocity

In most cases, we should ensure we change the velocity of objects as a result of collisions, not just their position. Not setting velocity is a common source of bugs.

If we don’t do it, our program can still appear to be working correctly. But, behind the scenes, the gravity acceleration is constantly increasing the velocity, and, eventually, it can get so high that our object can fully move through the floor within a single frame without the collision being detected.

Tracking when the Character is on the Ground

In addition to moving our character, our floor collisions should also update a member variable to let other code determine whether the character is currently on the ground.

By default, we’ll assume an object is not on the ground on any given frame, unless our collision system detects that it is:

1// GameObject.h
2// ...
3
4class GameObject {
5  // ...
6private:
7  // ...
8  bool isOnGround;
9};

1// GameObject.cpp
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      isOnGround = true; 
15      Position.y += Intersection.h;
16      Velocity.y = 0;
17    }
18  }
19}

In our HandleEvent() function, we’re currently controlling whether our character can jump based on a hard-coded comparison of its y position. Let’s update that to use our new variable:

1// GameObject.cpp
2// ...
3
4void GameObject::HandleEvent(
5  const SDL_Event& E) {
6  if (E.type == SDL_MOUSEBUTTONDOWN) {
7    // Create explosion at click position
8    if (E.button.button == SDL_BUTTON_LEFT) {
9      ApplyPositionalImpulse(
10        Scene.ToWorldSpace({
11          static_cast<float>(E.button.x),
12          static_cast<float>(E.button.y)
13        }), 1000);
14    }
15  } else if (E.type == SDL_KEYDOWN) {
16    // Jump
17    if (E.key.keysym.sym == SDLK_SPACE) {
18      if (Position.y > 2) return;
19      if (!isOnGround) return;
20      ApplyImpulse({0.0f, 300.0f});
21    }
22  }
23}

We’re using the same logic to enable friction in our GetCoefficientFunction() function, so let’s update that too:

1// GameObject.h
2// ...
3
4class GameObject {
5  // ...
6private:
7  // ...
8  float GetFrictionCoefficient() const {
9    return Position.y > 2 ? 0 : 0.5;
10    return isOnGround ? 0.5 : 0; 
11  }
12};

How did I Collide?

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

1// GameObject.h
2// ...
3
4class GameObject {
5  // ...
6private:
7  Vec2 Position{0, 0};
8  // Where was I on the previous frame?
9  Vec2 PreviousPosition{Position}; 
10  // ...
11};

1// GameObject.cpp
2// ...
3
4void GameObject::Tick(float DeltaTime) {
Previous Code (Unchanged)|Show
16  PreviousPosition = Position; 
17}

Multiple Colliders

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}

What did I Collide With?

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}

Text Replacement Macros

In this section, we had a situation where we have a base class that, in a complex game, is likely to have many child classes. Additionally, all (or most) of these child classes are expected to override some simple inherited functions in a predictable, repeated pattern:

1// GameObject.h
2// ...
3
4class Projectile : public GameObject {
5public:
6  using GameObject::GameObject;
7
8  GameObjectType GetType() override {
9    return GameObjectType::Projectile;
10  }
11
12  std::string GetTypeName() override {
13    return "Projectile";
14  }
15};
16
17class Enemy: public GameObject {
18public:
19  using GameObject::GameObject;
20
21  GameObjectType GetType() override {
22    return GameObjectType::Enemy;
23  }
24
25  std::string GetTypeName() override {
26    return "Enemy";
27  }
28};

This is a situation where text replacement macros are often used. To simplify and standardize the overriding of these methods, we’d often provide a macro that all of our child classes can use. It might look something like this:

1#define GAME_OBJECT_TYPE(TypeName)     \
2  GameObjectType GetType() override {  \
3    return GameObjectType::TypeName;   \
4  }                                    \
5                                       \
6  std::string GetTypeName() override { \
7    return #TypeName;                  \
8  }                                    \

Using this macro in a derived class would look like this:

1// GameObject.h
2// ...
3
4class Projectile : public GameObject {
5public:
6  using GameObject::GameObject;
7  GAME_OBJECT_TYPE(Projectile)
8  
9  GameObjectType GetType() override {
10    return GameObjectType::Projectile;
11  }
12
13  std::string GetTypeName() override {
14    return "Projectile";
15  }
16};

We covered text replacement macros in more detail in our introductory course:

Preprocessor Definitions

Explore the essential concepts of C++ preprocessing, from understanding directives to implementing macros

Complete Code

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

1#pragma once
2#include <SDL.h>
3#include <vector>
4#include "GameObject.h"
5
6using GameObjectPtr = std::unique_ptr<GameObject>;
7using GameObjectPtrs = std::vector<GameObjectPtr>;
8
9class Scene {
10public:
11  Scene() {
12    Objects.emplace_back(std::make_unique<Player>(
13     "dwarf.png", Vec2{6, 2.8}, 1.9, 1.7, *this, true));
14    Objects.emplace_back(std::make_unique<Floor>(
15      "floor.png", Vec2{4.5, 1}, 5, 2, *this, false));
16  }
17
18  const GameObject& GetPlayerCharacter() const {
19    return *Objects[0];
20  }
21
22  const GameObjectPtrs& GetObjects() const {
23    return Objects;
24  }
25
26  Vec2 ToScreenSpace(const Vec2& Pos) const {
27    auto [vx, vy, vw, vh]{Viewport};
28    float HorizontalScaling{vw / WorldSpaceWidth};
29    float VerticalScaling{vh / WorldSpaceHeight};
30
31    return {
32      vx + Pos.x * HorizontalScaling,
33      vy + (WorldSpaceHeight - Pos.y)
34      * VerticalScaling
35    };
36  }
37
38  SDL_FRect ToScreenSpace(
39    const SDL_FRect& Rect) const {
40    Vec2 ScreenPos{
41      ToScreenSpace(Vec2{Rect.x, Rect.y})};
42    float HorizontalScaling{
43      Viewport.w / WorldSpaceWidth};
44    float VerticalScaling{
45      Viewport.h / WorldSpaceHeight};
46
47    return {
48      ScreenPos.x,
49      ScreenPos.y,
50      Rect.w * HorizontalScaling,
51      Rect.h * VerticalScaling
52    };
53  }
54
55  Vec2 ToWorldSpace(const Vec2& Pos) const {
56    auto [vx, vy, vw, vh]{Viewport};
57    float HorizontalScaling{
58      WorldSpaceWidth / vw};
59    float VerticalScaling{
60      WorldSpaceHeight / vh};
61
62    return {
63      (Pos.x - vx) * HorizontalScaling,
64      WorldSpaceHeight - (Pos.y - vy)
65      * VerticalScaling
66    };
67  }
68
69  void HandleEvent(SDL_Event& E) {
70    for (GameObjectPtr& Object : Objects) {
71      Object->HandleEvent(E);
72    }
73  }
74
75  void Tick(float DeltaTime) {
76    for (GameObjectPtr& Object : Objects) {
77      Object->Tick(DeltaTime);
78    }
79  }
80
81  void Render(SDL_Surface* Surface) {
82    SDL_GetClipRect(Surface, &Viewport);
83    for (GameObjectPtr& Object : Objects) {
84      Object->Render(Surface);
85    }
86  }
87
88  const SDL_Rect& GetViewport() const {
89    return Viewport;
90  }
91
92private:
93  SDL_Rect Viewport;
94  GameObjectPtrs Objects;
95  float WorldSpaceWidth{14}; // meters
96  float WorldSpaceHeight{6}; // meters
97};

1#pragma once
2#include <SDL.h>
3#include "BoundingBox.h"
4#include "Vec2.h"
5#include "Image.h"
6
7class Scene;
8enum class GameObjectType {
9  GameObject, Player, Floor, FloorTrap
10};
11
12class GameObject {
13public:
14  GameObject(
15    const std::string& ImagePath,
16    const Vec2& InitialPosition,
17    float Width,
18    float Height,
19    const Scene& Scene,
20    bool isMovable = false
21  ) : Image{ImagePath},
22      Position{InitialPosition},
23      Scene{Scene},
24      isMovable{isMovable},
25      Bounds{
26        SDL_FRect{
27          InitialPosition.x, InitialPosition.y,
28          Width, Height
29        }} {}
30
31  virtual GameObjectType GetType() {
32    return GameObjectType::GameObject;
33  }
34
35  virtual std::string GetTypeName() {
36    return "GameObject";
37  }
38
39  bool HasType(GameObjectType TargetType) {
40    return GetType() == TargetType;
41  }
42
43  virtual void OnHit(GameObject& Target) {}
44  virtual bool CanPassThrough() { return true; }
45
46  void HandleEvent(const SDL_Event& E);
47
48  const Vec2& GetPosition() const {
49    return Position; 
50  }
51
52  void Tick(float DeltaTime);
53
54  void Render(SDL_Surface* Surface);
55
56  void ApplyForce(const Vec2& Force) {
57    Acceleration += Force / Mass;
58  }
59
60  virtual ~GameObject() = default;
61
62private:
63  Image Image;
64  const Scene& Scene;
65  bool isMovable;
66
67  Vec2 Position{0, 0};
68  Vec2 Velocity{0, 0};
69  Vec2 Acceleration{0, -9.8};
70  float Mass{70};
71  BoundingBox Bounds;
72
73  float DragCoefficient{0.2};
74
75  Vec2 DragForce() const {
76    return -Velocity * DragCoefficient
77      * Velocity.GetLength();
78  }
79
80  float GetFrictionCoefficient() const {
81    return isOnGround ? 0.5 : 0;
82  }
83
84  Vec2 FrictionForce(float DeltaTime) const {
85    float MaxMagnitude{
86      GetFrictionCoefficient()
87      * Mass * -Acceleration.y};
88    if (MaxMagnitude <= 0) return Vec2(0, 0);
89
90    float StoppingMagnitude{
91      Mass *
92      Velocity.GetLength() / DeltaTime};
93
94    return -Velocity.Normalize() * std::min(
95      MaxMagnitude, StoppingMagnitude);
96  }
97
98  void Clamp(Vec2& V) const {
99    V.x = std::abs(V.x) > 0.01 ? V.x : 0;
100    V.y = std::abs(V.y) > 0.01 ? V.y : 0;
101  }
102
103  void ApplyImpulse(const Vec2& Impulse) {
104    Velocity += Impulse / Mass;
105  }
106
107  void ApplyPositionalImpulse(
108    const Vec2& Origin, float Magnitude
109  ) {
110    Vec2 Displacement{GetPosition() - Origin};
111    Vec2 Direction{Displacement.Normalize()};
112    float Distance{Displacement.GetLength()};
113    float AdjustedMagnitude{
114      Magnitude /
115      ((Distance + 0.1f) * (Distance + 0.1f))};
116
117    ApplyImpulse(Direction * AdjustedMagnitude);
118  }
119
120  void HandleCollisions();
121  bool isOnGround;
122};
123
124#define GAME_OBJECT_TYPE(TypeName)     \
125  GameObjectType GetType() override {  \
126    return GameObjectType::TypeName;   \
127  }                                    \
128                                       \
129  std::string GetTypeName() override { \
130    return #TypeName;                  \
131  }                                    \
132
133class Player : public GameObject {
134 public:
135  using GameObject::GameObject;
136  GAME_OBJECT_TYPE(Player)
137
138  void TakeDamage(int Damage) {
139    Health -= Damage;
140  }
141
142  int Health{100};
143};
144
145class Floor : public GameObject {
146 public:
147  using GameObject::GameObject;
148  GAME_OBJECT_TYPE(Floor)
149
150  bool CanPassThrough() override {
151    return false;
152  }
153};
154
155class FloorTrap : public Floor {
156 public:
157  using Floor::Floor;
158  GAME_OBJECT_TYPE(FloorTrap)
159
160  void OnHit(GameObject& Target) override {
161    if (Player* P{dynamic_cast<Player*>(&Target)}) {
162      P->TakeDamage(10);
163    }
164  }
165};

1#include <SDL.h>
2#include "GameObject.h"
3#include "Scene.h"
4#include "BoundingBox.h"
5
6#define DRAW_BOUNDING_BOXES
7#define DRAW_TRAJECTORIES
8
9#ifdef DRAW_TRAJECTORIES
10namespace{
11  SDL_Surface* Trajectories{
12    SDL_CreateRGBSurfaceWithFormat(
13      0, 700, 300, 32,
14      SDL_PIXELFORMAT_RGBA32
15    )};
16}
17#endif
18
19void GameObject::Tick(float DeltaTime) {
20  if (!isMovable) return;
21  ApplyForce(FrictionForce(DeltaTime));
22  ApplyForce(DragForce());
23  Velocity += Acceleration * DeltaTime;
24  Position += Velocity * DeltaTime;
25
26  Bounds.SetPosition(GetPosition());
27  HandleCollisions();
28
29  Acceleration = {0, -9.8};
30  Clamp(Velocity);
31}
32
33void GameObject::HandleCollisions() {
34  isOnGround = false;
35  for (const std::unique_ptr<GameObject>& O
36    : Scene.GetObjects()
37  ) {
38    // Prevent self-collision
39    if (O.get() == this) continue;
40
41    SDL_FRect Intersection;
42    if (Bounds.GetIntersection(
43      O->Bounds, &Intersection
44    )) {
45      O->OnHit(*this);
46      if (O->CanPassThrough()) {
47        continue;
48      }
49
50      if (O->HasType(GameObjectType::Floor)) {
51        isOnGround = true;
52        Position.y += Intersection.h;
53        Velocity.y = 0;
54      }
55    }
56  }
57}
58
59void GameObject::Render(SDL_Surface* Surface) {
60#ifdef DRAW_TRAJECTORIES
61  auto [x, y]{Scene.ToScreenSpace(GetPosition())};
62  SDL_Rect PositionIndicator{
63    int(x) - 16, int(y), 20, 20};
64  SDL_FillRect(Trajectories, &PositionIndicator,
65               SDL_MapRGB(Trajectories->format,
66                          220, 0, 0));
67
68  SDL_BlitSurface(Trajectories, nullptr,
69                  Surface, nullptr);
70#endif
71
72  Image.Render(Surface,
73               Scene.ToScreenSpace(GetPosition()));
74#ifdef DRAW_BOUNDING_BOXES
75  Bounds.Render(Surface, Scene);
76#endif
77}
78
79void GameObject::HandleEvent(
80  const SDL_Event& E) {
81  if (E.type == SDL_MOUSEBUTTONDOWN) {
82    // Create explosion at click position
83    if (E.button.button == SDL_BUTTON_LEFT) {
84      ApplyPositionalImpulse(
85        Scene.ToWorldSpace({
86          static_cast<float>(E.button.x),
87          static_cast<float>(E.button.y)
88        }), 1000);
89    }
90  } else if (E.type == SDL_KEYDOWN) {
91    // Jump
92    if (E.key.keysym.sym == SDLK_SPACE) {
93      if (!isOnGround) return;
94      ApplyImpulse({0.0f, 300.0f});
95    }
96  }
97}

Summary

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.

Free and Unlimited Access

Professional C++

Unlock the true power of C++ by mastering complex features, optimizing performance, and learning expert workflows used in professional development

View Course