Our entities can now detect collisions thanks to the CollisionComponent, but they still pass through each other like ghosts. This lesson bridges the gap from detection to reaction. We'll implement two fundamental collision responses:

Stopping, such as a character landing on a floor.
Bouncing, such as a ball reflecting off surfaces.

We'll approach this by adding a virtual HandleCollision() function to our Entity() base class, allowing different entity types to define their unique reactions.

Starting Point

In the previous lesson, we created the CollisionComponent which calculates a world-space bounding box (WorldBounds) each frame:

We also added a CheckCollisions() loop in the Scene to detect overlaps between entities using CollisionComponent::IsCollidingWith().

Our entities can now detect when they collide, but they don't yet do anything about it. Here's the relevant code we ended with:

Currently, our program has the following characteristics:

Our Scene constructor creates Player and Floor objects, which are both Entity instances.
The Player has a PhysicsComponent, causing it to fall downwards due to gravity. It falls through the Floor.
The CheckCollisions() loop in our Scene is detecting the Floor and Player, intersection, but our entities don't currently react to it:

Screenshot showing our collision debug helpers

1Collision detected between Entity 0 and Entity 1!
2Collision detected between Entity 0 and Entity 1!
3Collision detected between Entity 0 and Entity 1!
4// ...

Reacting to Collisions

Instead of putting all collision response logic inside the central Scene::CheckCollisions() loop, we'll use a more distributed approach. Each entity type will be responsible for defining how it reacts when it collides with other specific entity types.

We can achieve this by adding a virtual function to the base Entity class. Let's call it HandleCollision().

1// Entity.h
2// ...
3
4class Entity {
5public:
6  // ...
7
8  // Called when this entity collides with 'Other'
9  virtual void HandleCollision(Entity& Other) {} 
10
11  // ...
12};

When the Scene detects a collision between EntityA and EntityB, it will notify both entities:

EntityA->HandleCollision(EntityB);
EntityB->HandleCollision(EntityA);

This allows EntityA to decide how to react to EntityB, and EntityB to decide how to react to EntityA. Let's add it to our CheckCollisions() function, replacing our basic logging statement:

1// Scene.cpp
2// ...
3
4void Scene::CheckCollisions() {
5  for (size_t i{0}; i < Entities.size(); ++i) {
6    CollisionComponent* ColA{
7      Entities[i]->GetCollisionComponent()};
8
9    // Skip if no collision component
10    if (!ColA) continue;
11
12    for (
13      size_t j{i + 1}; j < Entities.size(); ++j
14    ) {
15      CollisionComponent* ColB{
16        Entities[j]->GetCollisionComponent()};
17
18      // Skip if no collision component
19      if (!ColB) continue;
20
21      if (ColA->IsCollidingWith(*ColB)) {
22        std::cout <<
23          "Collision detected between "
24          "Entity " << i << " and Entity " << j
25          << "!\n";
26        Entities[i]->HandleCollision(*Entities[j]); 
27        Entities[j]->HandleCollision(*Entities[i]); 
28      }
29    }
30  }
31}

With this structure, the base Entity does nothing on collision, but derived classes can override HandleCollision() to implement specific reactions. Let's implement a couple of examples.

Example 1: Character Landing on Floor

First, let's see how we can make our existing Player entity land on the floor, without falling through it.

Creating Entity Subtypes

We need specific entity types. Let's define Character and Floor classes that inherit from Entity.

We'll also move the initial component configuration for our two objects (currently defined in the Scene constructor) to these classes. This will help remove some clutter from our Scene later:

1// Character.h
2#pragma once
3#include "Entity.h"
4
5class Scene;
6class Character : public Entity {
7 public:
8  Character(Scene& Scene)
9  : Entity{Scene}
10  {
11    AddTransformComponent()->SetPosition({6, 5});
12    AddPhysicsComponent()->SetMass(50.0);
13    AddImageComponent("player.png");
14    AddCollisionComponent()->SetSize(1.9, 1.7);
15  }
16};

1// Floor.h
2#pragma once
3#include "Entity.h"
4
5class Scene;
6class Floor : public Entity {
7 public:
8  Floor(Scene& Scene) : Entity{Scene} {
9    AddTransformComponent()->SetPosition({4.5, 1});
10    AddImageComponent("floor.png");
11    AddCollisionComponent()->SetSize(5.0, 2.0);
12  }
13};

Over in our Scene, let's update the constructor to use these new types. We can also delete all of their component setup, as that is now handled by the Character and Floor classes:

1// Scene.h
2// ...
3#include "Entity.h"
4#include "Character.h"
5#include "Floor.h"
6
7// ...
8
9class Scene {
10 public:
11  Scene() {
12    EntityPtr& Player{Entities.emplace_back(
13      std::make_unique<Entity>(*this))};
14
15    Player->AddTransformComponent()
16      ->SetPosition({6, 5});
17    Player->AddPhysicsComponent()
18      ->SetMass(50.0);
19    Player->AddImageComponent("player.png");
20    Player->AddCollisionComponent()
21      ->SetSize(1.9, 1.7);
22    Entities.emplace_back(
23      std::make_unique<Character>(*this));
24
25    EntityPtr& Floor{Entities.emplace_back(
26      std::make_unique<Entity>(*this))};
27
28    Floor->AddTransformComponent()
29      ->SetPosition({4.5, 1});
30    Floor->AddImageComponent("floor.png");
31    Floor->AddCollisionComponent()
32      ->SetSize(5.0, 2.0);
33    Entities.emplace_back(
34      std::make_unique<Floor>(*this));
35  }
36
37  void HandleEvent(SDL_Event& E) {
38    for (EntityPtr& Entity : Entities) {
39      Entity->HandleEvent(E);
40    }
41  }
42
43  // ...
44};

Implementing Character's Reaction

Now, let's implement Character::HandleCollision() for our Character.

The character only cares about collisions with the Floor. We use dynamic_cast to check if the Other entity it collided with is actually a Floor. We can use dynamic_cast for this and, if it's not a Floor, we're not interested in reacting so we'll just return:

1// Character.h
2// ...
3#include "Floor.h"
4
5// ...
6
7class Character : public Entity {
8 public:
9  // ...
10
11  void HandleCollision(Entity& Other) override {
12    // Check if we collided with a Floor
13    Floor* FloorPtr{dynamic_cast<Floor*>(&Other)};
14    
15    // It's not a floor, so we don't care
16    if (!FloorPtr) return;
17    
18    // It is a floor, so we need to react
19  }
20};

If it is a Floor, we next need to get the collision intersection rectangle using the GetCollisionRectangle() we added to CollisionComponent in the previous lesson. This tells us how much they overlap.

1// Character.h
2// ...
3#include "Floor.h"
4
5// ...
6
7class Character : public Entity {
8 public:
9  // ...
10
11  void HandleCollision(Entity& Other) override {
12    Floor* FloorPtr{dynamic_cast<Floor*>(&Other)};
13    if (!FloorPtr) return;
14    
15    CollisionComponent* MyCollider{
16      GetCollisionComponent()};
17    CollisionComponent* FloorCollider{
18      FloorPtr->GetCollisionComponent()};
19
20    SDL_FRect Intersection;
21    MyCollider->GetCollisionRectangle(
22      *FloorCollider, &Intersection);
23   
24   // ...
25  }
26};

Next, to resolve the penetration, we'll push the Character upwards out of the Floor. The distance to push is the height of the intersection rectangle. We modify the TransformComponent's position:

1// Character.h
2// ...
3#include "Floor.h"
4
5// ...
6
7class Character : public Entity {
8 public:
9  // ...
10
11  void HandleCollision(Entity& Other) override {
12    Floor* FloorPtr{dynamic_cast<Floor*>(&Other)};
13    if (!FloorPtr) return;
14    
15    CollisionComponent* MyCollider{
16      GetCollisionComponent()};
17    CollisionComponent* FloorCollider{
18      FloorPtr->GetCollisionComponent()};
19
20    SDL_FRect Intersection;
21    MyCollider->GetCollisionRectangle(
22      *FloorCollider, &Intersection);
23   
24   Vec2 CurrentPos{GetTransformComponent()
25     ->GetPosition()};
26   GetTransformComponent()->SetPosition({
27     CurrentPos.x,
28     CurrentPos.y + Intersection.h
29   });
30   
31   // ...
32  }
33};

Finally, we'll stop the downward motion of the Character by setting the vertical component of its PhysicsComponent's velocity to zero.

This prevents gravity from constantly accelerating the entity, to the point where it is travelling fast enough that it can fully penetrate the Floor within a single tick of our physics simulation:

1// Character.h
2// ...
3#include "Floor.h"
4
5// ...
6
7class Character : public Entity {
8 public:
9  // ...
10
11  void HandleCollision(Entity& Other) override {
12    Floor* FloorPtr{dynamic_cast<Floor*>(&Other)};
13    if (!FloorPtr) return;
14    
15    CollisionComponent* MyCollider{
16      GetCollisionComponent()};
17    CollisionComponent* FloorCollider{
18      FloorPtr->GetCollisionComponent()};
19
20    SDL_FRect Intersection;
21    MyCollider->GetCollisionRectangle(
22      *FloorCollider, &Intersection);
23   
24    Vec2 CurrentPos{GetTransformComponent()->GetPosition()};
25    GetTransformComponent()->SetPosition({
26      CurrentPos.x,
27      CurrentPos.y + Intersection.h
28    });
29   
30    PhysicsComponent* Physics{GetPhysicsComponent()};
31    if (Physics) {
32      Vec2 CurrentVel{Physics->GetVelocity()};
33      // Stop vertical movement upon landing
34      if (CurrentVel.y < 0) {  // Only if falling
35        Physics->SetVelocity({CurrentVel.x, 0.0});
36      }
37    }
38  }
39};

If we run our game now. The Character should fall due to its PhysicsComponent, collide with the Floor, and stop correctly on top of it, thanks to the logic in Character::HandleCollision().

Screenshot showing character stopped on the floor

Example 2: Bouncing Ball

Now for a different reaction: a ball that bounces off surfaces.

Creating the `BouncingBall` Entity

Similar to Character, let's define a BouncingBall entity type, with some initial components and state:

1// BouncingBall.h
2#pragma once
3#include "Entity.h"
4
5class Scene;
6
7class BouncingBall: public Entity {
8public:
9  BouncingBall(Scene& Scene) : Entity{Scene} {
10    AddTransformComponent()->SetPosition({3, 4});
11    AddPhysicsComponent()->SetVelocity({5, 3});
12    AddImageComponent("basketball.png");
13    AddCollisionComponent();
14  }
15};

We'll update our Scene to include a BouncingBall, and two simple entities that it can bounce off:

1// Scene.h
2// ...
3#include "BouncingBall.h"
4// ...
5
6class Scene {
7 public:
8  Scene() {
9    Entities.emplace_back(
10      std::make_unique<BouncingBall>(*this));
11
12    EntityPtr& Floor{Entities.emplace_back(
13      std::make_unique<Entity>(*this))};
14    Floor->AddTransformComponent()
15      ->SetPosition({3, 1});
16    Floor->AddCollisionComponent()
17      ->SetSize(7, 2);
18
19    EntityPtr& Wall{Entities.emplace_back(
20      std::make_unique<Entity>(*this))};
21    Wall->AddTransformComponent()
22      ->SetPosition({10, 5});
23    Wall->AddCollisionComponent()
24      ->SetSize(2, 5);
25  }
26
27  // ...
28};

For now, our ball just falls through the floor:

Screenshot showing ball falling through the floor

Resolving Penetration

Let's implement our bouncing behaviour by overriding the HandleCollision() function, in the same way we did for our Character. Let's get started by grabbing the physics and transform components as we did before, as well as the collision intersection. In this case, we'll let our ball bounce of anything, so we'll skip checking what the Other entity is:

1// BouncingBall.h
2// ...
3
4class BouncingBall : public Entity {
5public:
6  // ...
7
8  void HandleCollision(Entity& Other) override {
9    SDL_FRect Intersection;
10    
11    GetCollisionComponent()->GetCollisionRectangle(
12      *Other.GetCollisionComponent(), &Intersection
13    );
14
15    PhysicsComponent* Physics{
16      GetPhysicsComponent()};
17    TransformComponent* Transform{
18      GetTransformComponent()};
19    
20    // Safety check - we need these to bounce
21    if (!(Physics && Transform)) return;
22    
23    // ...
24  }
25};

Let's start by pushing the ball out of the object it collided with, similar to how we pushed our Character out from the Floor. The additional challenge here is that we don't just always assume we need to push our ball up. We need to determine the direction based on the nature of the collision.

Collision Normal

In physics and geometry, a normal (or normal vector) is a vector that is perpendicular to a surface at a given point. Think of it as an arrow pointing directly "out" from the surface.

When two objects collide, the collision normal represents the primary direction of the impact force. It's the direction along which the objects push against each other. For simple shapes like our Axis-Aligned Bounding Boxes (AABBs), the normal is usually aligned with one of the major axes (X or Y).

Flat Horizontal Surface (like our Floor): If an object hits it from above, the collision normal points straight up along the positive Y-axis, e.g., {0, 1}. This is the direction the floor "pushes back".
Vertical Surface (like a Wall): If an object hits it from the right, the normal points straight left along the negative X-axis, e.g., {-1, 0}. If hit from the left, it points right, {1, 0}.
Angled Surface: For more complex shapes or angled surfaces, the normal wouldn't align perfectly with the X or Y axis, but would still point perpendicularly away from the surface at the point of impact.

Knowing the collision normal is useful for realistic physics responses. It tells us the direction to push objects apart to resolve penetration and the axis along which velocity should be reflected for bouncing.

For AABB collisions, we can guess what the collision normal is based on the nature of the collision intersection rectangle:

If the intersection rectangle is wider than it is tall, we guess the collision is primarily vertical. If the ball was moving up, we push it back down. If the ball was moving down, we push it back up.
If the intersection rectangle is taller than it is wide, we guess the collision is primarily horizontal. If the ball was moving left, we push it back to the right. If the ball was moving right, we push it back to the left.

Let's implement this logic:

1// BouncingBall.h
2// ...
3
4class BouncingBall : public Entity {
5public:
6  // ...
7
8  void HandleCollision(Entity& Other) override {
9    SDL_FRect Intersection;
10    
11    GetCollisionComponent()->GetCollisionRectangle(
12      *Other.GetCollisionComponent(), &Intersection
13    );
14
15    PhysicsComponent* Physics{
16      GetPhysicsComponent()};
17    TransformComponent* Transform{
18      GetTransformComponent()};
19
20    if (!(Physics && Transform)) return;
21
22
23    Vec2 CurrentPos{Transform->GetPosition()};
24    if (Intersection.w < Intersection.h) {
25      if (Physics->GetVelocity().x > 0)
26        CurrentPos.x -= Intersection.w;
27      else
28        CurrentPos.x += Intersection.w;
29    } else {
30      if (Physics->GetVelocity().y <0)
31        CurrentPos.y += Intersection.h;
32      else
33        CurrentPos.y -= Intersection.h;
34    }
35    Transform->SetPosition(CurrentPos);
36    
37    // ...
38  }
39};

We should now see our ball hit the floor and then slide along it until it gets stuck in the corner:

Screenshot showing our ball reacting to collisions

Implementing Bouncing

Finally, let's implement our bouncing behaviour. This involves reversing one of the components of our ball's velocity. If the collision is primarily vertical, we'll reverse the ball's y velocity whilst, if it's horizontal, we'll reverse it's x velocity:

1// BouncingBall.h
2// ...
3
4class BouncingBall : public Entity {
5public:
6  // ...
7
8  void HandleCollision(Entity& Other) override {
9    SDL_FRect Intersection;
10    
11    GetCollisionComponent()->GetCollisionRectangle(
12      *Other.GetCollisionComponent(), &Intersection
13    );
14
15    PhysicsComponent* Physics{
16      GetPhysicsComponent()};
17    TransformComponent* Transform{
18      GetTransformComponent()};
19
20    if (!(Physics && Transform)) return;
21
22
23    Vec2 CurrentPos{Transform->GetPosition()};
24    if (Intersection.w < Intersection.h) {
25      if (Physics->GetVelocity().x > 0)
26        CurrentPos.x -= Intersection.w;
27      else
28        CurrentPos.x += Intersection.w;
29    } else {
30      if (Physics->GetVelocity().y <0)
31        CurrentPos.y += Intersection.h;
32      else
33        CurrentPos.y -= Intersection.h;
34    }
35    Transform->SetPosition(CurrentPos);
36
37
38    Vec2 CurrentVel{Physics->GetVelocity()};
39    // Wider intersection = vertical collision
40    if (Intersection.w > Intersection.h) {
41      Physics->SetVelocity({
42        CurrentVel.x,
43        -CurrentVel.y
44      });
45    } else {
46      Physics->SetVelocity({
47        -CurrentVel.x,
48        CurrentVel.y
49      });
50    }
51  }
52};

With these changes, our ball should now bounce off our other entities:

Dampening

We can make our ball bounces more realistic by applying a dampening effect, reducing the speed on each impact:

1// BouncingBall.h
2// ...
3
4class BouncingBall : public Entity {
5public:
6  // ...
7
8  void HandleCollision(Entity& Other) override {
32    
33    float DAMPENING{0.8};
34    Vec2 CurrentVel{Physics->GetVelocity()};
35    if (Intersection.w > Intersection.h) {
36      Physics->SetVelocity({
37        CurrentVel.x,
38        -CurrentVel.y * DAMPENING  
39      });
40    } else {
41      Physics->SetVelocity({
42        -CurrentVel.x * DAMPENING,
43        CurrentVel.y
44      });
45    }
46  }
47};

Screenshot showing our ball bouncing with dampening

More Robust Penetration Resolution

The penetration resolution logic above is quite simple. It pushes the ball out based only on the smallest overlap dimension. This can sometimes cause slightly incorrect behavior if the ball hits a corner, or if the "push out" moves the object into a position where it's now colliding with something else.

More robust (but complex) methods involve techniques like calculating the exact time of impact and "rewinding" the physics state to that exact moment. Examining the world at the specific moment the collision happened lets us better understand how it happened, so we can apply the bounce reaction more accurately.

Having implemented the reaction (eg, the change in the ball's velocity), we then re-simulate the remaining portion of the timestep to determine if that change caused any further collisions.

This technique is called Continuous Collision Detection (CCD) and is beyond the scope of this course, but is often used in more advanced physics engines. Our simpler "push-out" method is still commonly used, as it is less expensive and sufficiently accurate for less important objects.

Handling Different Reactions

The use of virtual functions allows for polymorphic collision handling. The Scene doesn't need to know the specific types involved; it simply calls HandleCollision(), and the runtime system ensures the correct overridden version for each Entity subtype is executed.

This makes our system easy to extend without requiring us to add additional complexity to important classes such as Scene. For example, let's reintroduce our Character and Floor to the Scene:

1// Scene.h
2// ...
3
4#include "BouncingBall.h"
5#include "Character.h"
6#include "Floor.h"
7
8// ...
9
10class Scene {
11 public:
12  Scene() {
13    Entities.emplace_back(
14      std::make_unique<BouncingBall>(*this));
15    Entities.emplace_back(
16      std::make_unique<Character>(*this));
17    Entities.emplace_back(
18      std::make_unique<Floor>(*this));
19  }
20};

Without any further changes, our bouncing ball now reacts with our Character and Floor, because it reacts with any Entity in our scene that has a CollisionComponent:

Screenshot showing our ball bouncing off the character

Updating our Character to react to being hit by a BouncingBall just takes a few lines of code in our Character class. In this example, we've also moved our floor collision logic into a new private function, to keep things organized:

1// Character.h
2// ...
3#include "BouncingBall.h"
4
5class Character : public Entity {
6 public:
7  // ...
8
9  void HandleCollision(Entity& Other) override {
10    auto* FloorPtr{dynamic_cast<Floor*>(&Other)};
11    if (FloorPtr) HandleCollision(FloorPtr);
12
13    auto* BallPtr{dynamic_cast<BouncingBall*>(&Other)};
14    if (BallPtr) HandleCollision(BallPtr);
15  }
16
17private:
18  void HandleCollision(Floor* FloorPtr){/*...*}
43
44  void HandleCollision(BouncingBall* BallPtr) {
45    std::cout << "A ball hit me!\n";
46  }
47};

1A ball hit me!

Dynamic Collision Reactions without Inheritance

As always, there are countless ways we can add capabilities to our programs. The inheritance approach using virtual functions is one option for dynamic collision reactions, but if we wanted to keep our class hierarchy simple, there are alternatives.

One option would be to use the functional techniques we covered earlier in the course. We can add a member variable to our Entity or CollisionComponent to store a callback to be invoked when a collision is detected. The std::function utility can help us here:

1// CollisionComponent.h
2// ...
3#include <functional>
4
5class CollisionComponent : public Component {
6 public:
7  // ...
8
9  std::function<void(
10    Entity& Parent, Entity& Other
11  )> Reaction;
12
13  // ...
14};

If a colliding component has a callback stored in this variable, our collision system would invoke it:

1// Scene.cpp
2#include <vector>
3#include "Scene.h"
4#include "CollisionComponent.h"
5
6void Scene::CheckCollisions() {
7  for (size_t i{0}; i < Entities.size(); ++i) {
8    CollisionComponent* ColA{
9      Entities[i]->GetCollisionComponent()};
10    if (!ColA) continue;
11
12    for (size_t j{i+1}; j < Entities.size(); ++j) {
13      CollisionComponent* ColB{
14        Entities[j]->GetCollisionComponent()};
15      if (!ColB) continue;
16
17      if (ColA->IsCollidingWith(*ColB)) {
18        // Before, using polymorphism:
19        Entities[i]->HandleCollision(*Entities[j]);
20        Entities[j]->HandleCollision(*Entities[i]);
21        
22        // After, using callbacks:
23        if (ColA->Reaction) {
24          ColA->Reaction(
25            *Entities[i], *Entities[j]
26          );
27        }
28        if (ColB->Reaction) {
29          ColB->Reaction(
30            *Entities[j], *Entities[i]
31          );
32        }
33      }
34    }
35  }
36}

This allows objects to have different collision reactions, even though they have the same type - Entity, in our case.

Below, we have a Entity called Wall that can collide, but doesn't react to collisions. We also have an Entity called Ball, which we set up to bounce when collided with. We do this by passing a function pointer to the Reaction member of its CollisionComponent:

1// Wall collides but does not react
2Entity Wall{ParentScene};
3Wall.AddCollisionComponent();
4
5// Ball collides...
6Entity Ball{ParentScene};
7Ball.AddCollisionComponent()
8  ->Reaction = Bounce; // ...and also reacts

When Scene::CheckCollision() detects a collision, it will invoke this function. It provides a reference to both entities, which we can modify as needed to implement the desired reaction:

1void Bounce(Entity& Parent, Entity& Other) {
2  // Bouncing logic
3  // ...
4}

Complete Code

Below, we've provided all the files we created and updated in this lesson. Our new Floor, BouncingBall, and Character classes are here:

Our updated Scene and Entity files are provided below, with the changes we made in this lesson highlighted:

Summary

In this lesson, we transitioned from simply detecting collisions to implementing meaningful reactions. We adopted a distributed response model using a virtual HandleCollision(Entity& Other) method in the base Entity class.

We created specific entity subtypes (Character, Floor, BouncingBall) that override HandleCollision() to define their unique behaviors when interacting with other types, identified using dynamic_cast.

Key takeaways:

Collision Response: The actions taken after a collision is detected.
Distributed Response: Using virtual functions - HandleCollision() - allows entity types to define their own reactions to specific collision partners.
Identifying Participants: dynamic_cast is used within HandleCollision() to determine the type of the Other entity involved.
Penetration Resolution: Pushing entities apart based on the intersection rectangle is used to prevent objects from occupying the same space in an unrealistic way. We adjusted TransformComponent::Position to push them apart.
Motion Correction: Modifying PhysicsComponent::Velocity is used for realistic reactions like stopping or bouncing.
Stopping: Typically involves setting the velocity component along the collision normal to zero (e.g., vertical velocity when landing).
Bouncing: Involves reversing the velocity component along the collision normal (approximated for AABBs by comparing intersection width/height).
The Scene::CheckCollisions() loop now triggers the response by calling HandleCollision() on both colliding entities.

Collision Response

Starting Point

Reacting to Collisions

Example 1: Character Landing on Floor

Creating Entity Subtypes

Implementing Character's Reaction

Example 2: Bouncing Ball

Creating the `BouncingBall` Entity

Resolving Penetration

Implementing Bouncing

Dampening

Handling Different Reactions

Complete Code

Summary

Breakout: Project Setup

Game Development with SDL2

Collision Response

Starting Point

Reacting to Collisions

Example 1: Character Landing on Floor

Creating Entity Subtypes

Implementing Character's Reaction

Example 2: Bouncing Ball

Creating the BouncingBall Entity

Resolving Penetration

Implementing Bouncing

Dampening

Handling Different Reactions

Complete Code

Summary

Breakout: Project Setup

Creating the `BouncingBall` Entity