Breakout: Game Progression

Our game now has all its core interactive elements: a ball, a paddle, walls, and bricks. In this lesson, we'll tie them all together to create a complete gameplay loop, from destroying the first brick to advancing to the next level.

The main focus will be on handling the consequences of collisions. When the ball hits a brick, we need to "destroy" it. We'll implement this by disabling the brick's image and collision components, effectively removing it from play. We'll also use SDL's event system to broadcast a BLOCK_DESTROYED event.

Our BreakoutScene will listen for these events, keeping a count of the remaining bricks.

Once that count reaches zero, we'll trigger the level advancement logic, either loading the next level or declaring the game won.

Reacting to Block Collisions

Let's begin by having our blocks react to being collided with. We'll do this by disabling their components and, later, we'll also have them push an SDL_Event to report they were destroyed.

Earlier in the project, we added the ability to disable components and updated the collision component to react appropriately to being disabled. Let's do the same thing for our ImageComponent.

Disabling Image Components

Our Component base class has a GetIsEnabled() function, so supporting it within our ImageComponent is quite straightforward. We can stop our component from being rendered when it is disabled with a single line of code:

1// ...
2
3void ImageComponent::Render(
4  SDL_Surface* Surface
5) {
6  if (!GetIsEnabled()) return;
Remaining Code (Unchanged)|Show
35}
36
37// ...

We may also want to change what DrawDebugHelpers() does when the component is disabled. Perhaps it renders nothing, or we may want it to render a small indicator to signify the component is still there, even though it is disabled.

In our case, we'll just have it render nothing:

1// ...
2
3void ImageComponent::DrawDebugHelpers(
4  SDL_Surface* Surface
5) {
6  using Utilities::DrawRectOutline;
7  if (!GetIsEnabled()) return;
Remaining Code (Unchanged)|Show
55}

"Destroying" Blocks

Now, to get rid of our blocks when the ball hits them, we just need to override the HandleCollision() function and disable our image and collision components:

1// ...
2
3class Block : public Entity {
4 public:
5  // ...
6
7  void HandleCollision(Entity& Other) override {
8    Image->SetIsEnabled(false);
9    Collision->SetIsEnabled(false);
10  }
11  // ...
12};

With these changes, the core gameplay is now in place - we can bounce the ball off our paddle to "destroy" the blocks in our level:

1// ...
2
3class Block : public Entity {
4 public:
5  // ...
6
7  void HandleCollision(Entity& Other) override {
8    if (dynamic_cast<Block*>(&Other)) {
9      return;
10    }
11    Image->SetIsEnabled(false);
12    Collision->SetIsEnabled(false);
13  }
14  // ...
15};

1// ...
2#include "Breakout/Ball.h"
3
4class Block : public Entity {
5 public:
6  // ...
7
8  void HandleCollision(Entity& Other) override {
9    if (!dynamic_cast<Ball*>(&Other)) {
10      return;
11    }
12    Image->SetIsEnabled(false);
13    Collision->SetIsEnabled(false);
14  }
15  // ...
16};

1void HandleCollision(Entity& Other) override {
2  // Note that RemoveEntity() does not exist in our
3  // project - this is a hypothetical example:
4  GetScene().RemoveEntity(this);
5}

1void HandleCollision(Entity& Other) override {
2  RemoveComponent(Image);
3  RemoveComponent(Collision);
4}

1class Scene {
2public:
3  // ...
4  void RemoveEntity(Entity* EntityToDelete) {
5    EntitiesToDelete.push_back(EntityToDelete);
6  }
7  
8private:
9  // ...
10  std::vector<Entity*> EntitiesToDelete;
11}

Advancing the Game

Let's register some events that we can use to report progress through our game. We'll register events for a block being destroyed, as well as the overall game being won or lost:

1// ...
2
3namespace UserEvents{
4// ...
5inline Uint32 BLOCK_DESTROYED{
6  SDL_RegisterEvents(1)};
7inline Uint32 GAME_WON{SDL_RegisterEvents(1)};
8inline Uint32 GAME_LOST{SDL_RegisterEvents(1)};
9}
10
11// ...

Keeping Track of Remaining Blocks

In our Block class, in addition to disabling components when collided with, let's also broadcast one of our new BLOCK_DESTROYED events:

1// ...
2
3class Block : public Entity {
4 public:
5  // ...
6
7  void HandleCollision(Entity& Other) override {
Previous Code (Unchanged)|Show
13    SDL_Event E{UserEvents::BLOCK_DESTROYED};
14    SDL_PushEvent(&E);
15  }
16  // ...
17};

Over in our BreakoutScene, let's keep track of how many blocks are remaining in the scene. We'll add a member variable called BlocksRemaining and, when we receive a BLOCK_DESTROYED event, we'll decrement that count:

1// ...
2#include "Config.h"
3
4class BreakoutScene : public Scene {
5public:
6  // ...
7
8  void HandleEvent(const SDL_Event& E) {
9    Scene::HandleEvent(E);
10    using namespace UserEvents;
11    if (E.type == BLOCK_DESTROYED) {
12      --BlocksRemaining;
13    }
14  }
15
16private:
17  int BlocksRemaining{0};
18};

When we load a level, we'll update the BlocksRemaining count with the number of blocks we loaded:

1// ...
2
3void BreakoutScene::Load(int Level) {
Previous Code (Unchanged)|Show
47  BlocksRemaining = BlockCount;
48}

Loading the Next Level

When all the blocks in the level are destroyed, we want to advance the player to the next level. Let's have our BreakoutScene keep track of what level it has currently loaded:

1// ...
2
3class BreakoutScene : public Scene {
4  // ...
5
6private:
7  int LoadedLevel{1};
8  // ...
9};

We'll update our Load() function to set this variable to the correct value after a level is successfully loaded:

1// ...
2
3void BreakoutScene::Load(int Level) {
Previous Code (Unchanged)|Show
48  LoadedLevel = Level;
49}

When all the blocks are destroyed in our level, we'll call a new CompleteLevel() function. If the player just completed the last level in our game (which is level 3, in our case) we'll push a GAME_WON event. Alternatively, if they completed some other level, we'll load the next level:

1// ...
2
3class BreakoutScene : public Scene {
4public:
5  // ...
6
7  void HandleEvent(const SDL_Event& E) {
8    Scene::HandleEvent(E);
9    using namespace UserEvents;
10    if (E.type == BLOCK_DESTROYED) {
11      --BlocksRemaining;
12      if (BlocksRemaining == 0) {
13        CompleteLevel();
14      }
15    }
16  }
17  // ...
18
19private:
20  void CompleteLevel() {
21    if (LoadedLevel == 3) {
22      SDL_Event WonEvent{UserEvents::GAME_WON};
23      SDL_PushEvent(&WonEvent);
24    } else {
25      Load(LoadedLevel + 1);
26    }
27  }
28  // ...
29};

Enabling Cheats

Needing to complete a level to see if our code is working can get quite annoying. Typically, we'll add some cheats to our game to help with development and testing.

Let's add the cheats behind an ENABLE_CHEATS preprocessor macro. If that flag is set, and the user presses their "c" key, we'll immediately complete the current level:

1// ...
2
3class BreakoutScene : public Scene {
4public:
5  // ...
6
7  void HandleEvent(const SDL_Event& E) {
8    Scene::HandleEvent(E);
9    using namespace UserEvents;
10    if (E.type == BLOCK_DESTROYED) {
11      --BlocksRemaining;
12      if (BlocksRemaining == 0) {
13        CompleteLevel();
14      }
15    }
16#ifdef ENABLE_CHEATS
17    else if (
18      E.type == SDL_KEYDOWN &&
19      E.key.keysym.sym == SDLK_c
20    ) {
21      CompleteLevel();
22    }
23#endif
24  }
25
26  // ...
27};

Loading Levels from the Editor

In our Editor project, we added a button that lets us play a level directly from our editor. We had that button broadcast a LAUNCH_LEVEL event, with the code member set to the level that should be launched.

Let's have our BreakoutScene listen for those events, and load the requested level:

1// ...
2
3class BreakoutScene : public Scene {
4public:
5  // ...
6  void HandleEvent(const SDL_Event& E) {
Previous Code (Unchanged)|Show
22    else if (E.type == LAUNCH_LEVEL) {
23      Load(E.user.code);
24    } 
25  }
26
27  // ...
28};

With these changes, we can now advance through the levels of our game either by completing them, or pressing the C key when we have enabled cheats. We can also load a specific level from our editor window, and then play it in our game window.

Complete Code

Complete versions of the files we changed in this lesson are provided below:

Summary

We've now added a clear objective and a sense of progression to our game. This lesson focused on handling the aftermath of a block collision: making the block disappear and tracking it as progress towards winning the level.

We used component disabling for destruction, SDL events for communication, and simple state tracking in our scene to manage level advancement.

Here's an overview of our changes:

• Blocks now get "destroyed" when the ball hits them.
• We created a BLOCK_DESTROYED event to signal progress.
• Our BreakoutScene now counts remaining blocks to detect when a level is won.
• We implemented the logic to load the next level or trigger a GAME_WON event.
• We added a helpful cheat code to speed up testing.

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