Breakout: Final Touches

Welcome to the home stretch! In this last lesson, we'll add the finishing touches that turn our Breakout project into a complete, replayable game. Our focus will be on the overall game flow - managing how the game begins, how it can be won or lost, and how it can be started again.

We'll implement a GameState enum to keep track of the current situation. We'll use this state to trigger a loss when the ball misses the paddle and to provide visual feedback to the player when they win or lose. We'll also add a pause system, so the action doesn't start until the player is ready, and a simple keypress to restart the entire game from level one.

Finally, we'll look at how to prepare our project for distribution by creating a "release" build configuration that strips out the level editor and other development tools, leaving us with a clean, standalone game.

Ending and Restarting Games

Finally, let's implement our game ending and restarting logic.

Tracking GameState

Let's begin by tracking what state the game is currently in - whether the player has won, lost, or the game is still in progress. This is likely to be useful to a wide variety of games, so we'll add it to the Scene base class in our engine. We'll default it to InProgress:

1// ...
2
3enum class GameState { InProgress, Won, Lost };
4
5class Scene {
6public:
7  // ...
8
9  GameState GetState() const { return State; }
10  
11  void SetState(GameState NewState) {
12    State = NewState;
13  }
14
15private:
16  // ...
17  GameState State{GameState::InProgress};
18};

Back in our BreakoutScene class, let's set this state in response to the GAME_WON and GAME_LOST events. We're already broadcasting the GAME_WON event at the appropriate time and will implement the GAME_LOST scenario in the next section.

In our level skip cheat, we'll also set the game state to be InProgress. This allows our cheat to complete the level even if we lost:

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 (E.type == SDL_KEYDOWN &&
18      E.key.keysym.sym == SDLK_c
19    ) {
20      SetState(GameState::InProgress);
21      CompleteLevel();
22    }
23#endif
24    else if (E.type == LAUNCH_LEVEL) {
25      Load(E.user.code);
26    } else if (E.type == GAME_WON) {
27      SetState(GameState::Won);
28    } else if (E.type == GAME_LOST) {
29      SetState(GameState::Lost);
30    } 
31  }
32  // ...
33};

Losing Games

When the player misses the ball with their paddle, we want the game to end. We can detect this if the ball collides with our bottom wall. When that happens, we'll push our GAME_LOST event:

1// ...
2#include "Breakout/Ball.h"
3
4// ...
5
6class Wall : public Entity {
7 public:
8  // ...
9  void HandleCollision(Entity& Other) override {
10    if (
11      dynamic_cast<Ball*>(&Other) &&
12      Position == WallPosition::Bottom
13    ) {
14      SDL_Event E{UserEvents::GAME_LOST};
15      SDL_PushEvent(&E);
16    }
17  }
18  // ...
19};

Restarting

We'll let the player restart the game by pressing the "R" key. When we detect that event, we'll set our game state back to InProgress, and load the first 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;
Previous Code (Unchanged)|Show
10    if (E.type == BLOCK_DESTROYED) {/*...*/}
32    else if (
33      E.type == SDL_KEYDOWN &&
34      E.key.keysym.sym == SDLK_r
35    ) {
36      SetState(GameState::InProgress);
37      Load(1);
38    }
39  }
40  // ...
41};

Reacting to Game Loss and Victory

Now that win and loss events are being broadcast through our program, we're free to make any part of our application react to those events in the usual ways. Alternatively, we can check the state of our game at any time using the scene's GetState() function.

For example, let's override our scene's Render() function to change the background color depending on the game state. We'll fill the surface with a solid color first, and then call the base Scene's Render() method to render our entities on top of that rectangle:

1// ...
2
3class BreakoutScene : public Scene {
4public:
5  // ...
6  void Render(SDL_Surface* Surface) {
7    if (GetState() == GameState::Won) {
8      SDL_FillRect(Surface, nullptr,
9        SDL_MapRGB(Surface->format, 20, 50, 20)
10      );
11    } else if (GetState() == GameState::Lost) {
12      SDL_FillRect(Surface, nullptr,
13        SDL_MapRGB(Surface->format, 50, 0, 0)
14      );
15    }
16    Scene::Render(Surface);
17  }
18  // ...
19};

With those changes, our background turns red when we lose:

And green when we win:

Pausing the Game

For our final feature, let's implement pausing. To support a paused state, let's first allow our physics and input to be paused. We'll pause them simply by disabling them, so let's update those components to support that.

Disabling Physics

To have our physics component pause when it is disabled, we can simply stop all of the updates that happen in our Tick() function:

1// ...
2
3void PhysicsComponent::Tick(float DeltaTime) {
4  if (!GetIsEnabled()) return;
Remaining Code (Unchanged)|Show
23}
24
25// ...

Again, we may want to take this further. For example, in our current implementation, a disabled physics component will still allow ApplyForce() and ApplyImpulse() to be used. The effect of those will be to change the acceleration and velocity of the component, which will be used as soon as it's unpaused.

This may be the preferred approach. Alternatively, it may be more intuitive to have the component effectively ignore those instructions when disabled, perhaps with an error message.

1// ...
2
3void PhysicsComponent::Tick(float DeltaTime) {
4  if (DeltaTime > 0.1) return;
5  // ...
6}
7
8// ...

Disabling Input

Our current input commands are setting the velocity of the physics component so, when the physics component is disabled, the input component is effectively disabled too.

However, that won't be true for any other inputs we might potentially use in the future, so let's explicitly support disabling our InputComponent.

To prevent inputs from having any effect on a disabled input component, it also shouldn't tick, which will therefore stop it from polling the keyboard state. We should also disable the HandleEvent() logic so that the input component stops responding to SDL_KEYDOWN events:

1// ...
2
3void InputComponent::Tick(float DeltaTime) {
4  if (!GetIsEnabled()) return;
Remaining Code (Unchanged)|Show
19}
20
21void InputComponent::HandleEvent(
22  const SDL_Event& E) {
23  if (!GetIsEnabled()) return;
Remaining Code (Unchanged)|Show
33}

Triggering the Game Pause

Currently, our ball starts moving as soon as the program starts. That can be a little annoying, so let's open the game in a paused state, and only start the level when the player is ready.

We'll do this by disabling our paddle's PhysicsComponent and InputComponent, and also our ball's PhysicsComponent. Let's add a new private helper function, and call it in the constructor:

1// ...
2
3class Paddle : public Entity {
4public:
5  Paddle(BreakoutScene& Scene) : Entity{Scene} {
6    // ...
7
8    SetIsPaused(true);
9  }
10  
11  // ...
12  
13private:
14  void SetIsPaused(bool isPaused) {
15    Input->SetIsEnabled(!isPaused);
16    Physics->SetIsEnabled(!isPaused);
17  }
18
19  // ...
20};

Similarly, for our ball:

1// ...
2
3class Ball : public Entity {
4public:
5  Ball(BreakoutScene& Scene) : Entity{Scene} {
6    // ...
7
8    SetIsPaused(true);
9  }
10
11  // ...
12private:
13  void SetIsPaused(bool isPaused) {
14    Physics->SetIsEnabled(!isPaused);
15  }
16};

If we run our game now, it starts in a paused state. Every time we load a new level, we load a new ball and paddle, so we also effectively pause between levels.

Unpausing the Game

We'll let the user press their space bar to start each level. When they do that, and the game is in the InProgress state (that is, they haven't already won or lost), then we'll unpause our paddle:

1// ...
2
3class Paddle : public Entity {
4public:
5  // ...
6
7  void HandleEvent(const SDL_Event& E) override {
8    if (
9      E.type == SDL_KEYDOWN &&
10      E.key.keysym.sym == SDLK_SPACE &&
11      GetScene().GetState() == GameState::InProgress
12    ) {
13      SetIsPaused(false);
14    } else if (
15      E.type == UserEvents::GAME_WON ||
16      E.type == UserEvents::GAME_LOST
17    ) {
18      SetIsPaused(true);
19    }
20  }
21  
22  // ...
23
24};

And similarly, for our ball:

1// ...
2
3class Ball : public Entity {
4public:
5  // ...
6  void HandleEvent(const SDL_Event& E) override {
7    if (
8      E.type == SDL_KEYDOWN &&
9      E.key.keysym.sym == SDLK_SPACE &&
10      GetScene().GetState() == GameState::InProgress
11    ) {
12      SetIsPaused(false);
13    } else if (
14      E.type == UserEvents::GAME_WON ||
15      E.type == UserEvents::GAME_LOST
16    ) {
17      SetIsPaused(true);
18    }
19  }
20  // ...
21};

1#pragma once
2#include "Engine/ECS/Component.h"
3#include "Engine/ECS/PhysicsComponent.h"
4#include "Engine/ECS/InputComponent.h"
5#include "Config.h"
6
7class BreakoutPauseManager : public Component {
8public:
9  BreakoutPauseManager(Entity* Parent)
10  : Component{Parent} {
11    SetIsPaused(true);
12  }
13
14  void HandleEvent(const SDL_Event& E) override {
15    if (
16      E.type == SDL_KEYDOWN &&
17      E.key.keysym.sym == SDLK_SPACE &&
18      GetScene().GetState() == GameState::InProgress
19    ) {
20      SetIsPaused(false);
21    } else if (
22      E.type == UserEvents::GAME_WON ||
23      E.type == UserEvents::GAME_LOST
24    ) {
25      SetIsPaused(true);
26    }
27  }
28
29private:
30  void SetIsPaused(bool isPaused) {
31    if (InputComponent* Input{
32      GetOwner()->GetComponent<InputComponent>()
33    }) {
34      Input->SetIsEnabled(!isPaused);
35   }
36
37   if (PhysicsComponent* Physics{
38     GetOwner()->GetComponent<PhysicsComponent>()
39   }) {
40     Physics->SetIsEnabled(!isPaused);
41   }
42  }
43};

1// ...
2#include "Breakout/BreakoutPauseManager.h"
3
4class Paddle : public Entity {
5public:
6  Paddle(BreakoutScene& Scene) : Entity{Scene} {
7    // ...
8
9    SetIsPaused(true); 
10    AddComponent<BreakoutPauseManager>();
11  }
12  
13  void HandleEvent(const SDL_Event& E) override {
14    if (
15      E.type == SDL_KEYDOWN &&
16      E.key.keysym.sym == SDLK_SPACE &&
17      GetScene().GetState() == GameState::InProgress
18    ) {
19      SetIsPaused(false);
20    } else if (
21      E.type == UserEvents::GAME_WON ||
22      E.type == UserEvents::GAME_LOST
23    ) {
24      SetIsPaused(true);
25    }
26  }
27  
28  // ...
29  
30private:
31  void SetIsPaused(bool isPaused) {
32    Input->SetIsEnabled(!isPaused);
33    Physics->SetIsEnabled(!isPaused);
34  }
35  
36  // ...
37};

1// ...
2#include "Breakout/BreakoutPauseManager.h"
3
4class Ball : public Entity {
5public:
6  Ball(BreakoutScene& Scene) : Entity{Scene} {
7    // ...
8
9    SetIsPaused(true);
10    AddComponent<BreakoutPauseManager>();
11  }
12  
13  // ...
14
15  void HandleEvent(const SDL_Event& E) override {
16    if (
17      E.type == SDL_KEYDOWN &&
18      E.key.keysym.sym == SDLK_SPACE &&
19      GetScene().GetState() == GameState::InProgress
20    ) {
21      SetIsPaused(false);
22    } else if (
23      E.type == UserEvents::GAME_WON ||
24      E.type == UserEvents::GAME_LOST
25    ) {
26      SetIsPaused(true);
27    }
28  }
29
30private:
31  void SetIsPaused(bool isPaused) {
32    Physics->SetIsEnabled(!isPaused);
33  }
34
35  // ...
36};

Excluding the Editor

With all our features in place, we're now ready to ship our game! The last step is to disable any undesirable preprocessor definitions (such as DRAW_DEBUG_HELPERS and ENABLE_CHEATS.

We also need detach our editor from the project. Our files already include preprocessor directives that will exclude editor-specific logic when the WITH_EDITOR macro is not defined.

However, our editor source files are still being sent to the compiler, and that may cause compilation issues or other problems. The simplest way to solve this is to include the #ifdef checks in those files, too. This means that, when WITH_EDITOR isn't defined, those files will be empty by the time the compiler sees them.

For example:

1#ifdef WITH_EDITOR
Previous Content (Unchanged)|Show
45#endif

A more elegant solution would involve conditionally not sending those files to be compiled at all. The build management tools included in most IDEs should let us automate this.

In Visual Studio, for example, you can select the files in the Solution Explorer, right-click on them, click on Properties, and set Excluded From Build to "Yes" for any build configuration that should not include the editor:

If you're using CMake, the simplest option is to set() a variable. We can then append the files to the build and set the preprocessor directive only if that variable is ON:

1cmake_minimum_required(VERSION 3.16)
2set(CMAKE_CXX_STANDARD 20)
3
4# Change me to ON to enable the editor
5SET(WITH_EDITOR OFF)
6
7project(Breakout VERSION 1.0.0)
8
9set(SOURCE_FILES
10  "main.cpp"
11
12  "Engine/Source/Scene.cpp"
13  "Engine/ECS/Source/Component.cpp"
14  "Engine/ECS/Source/CollisionComponent.cpp"
15  "Engine/ECS/Source/ImageComponent.cpp"
16  "Engine/ECS/Source/PhysicsComponent.cpp"
17  "Engine/ECS/Source/InputComponent.cpp"
18  "Engine/ECS/Source/Commands.cpp"
19
20  "Breakout/Source/BreakoutScene.cpp"
21  "Breakout/Source/Ball.cpp"
22)
23
24# Include the editor files only if WITH_EDITOR is ON
25if(WITH_EDITOR) 
26  list(APPEND SOURCE_FILES 
27    "Editor/Source/Button.cpp" 
28    "Editor/Source/Blocks.cpp" 
29    "Editor/Source/Actor.cpp" 
30    "Editor/Source/ActorTooltip.cpp" 
31    "Editor/Source/Level.cpp" 
32  ) 
33endif() 
34
35add_executable(Breakout
36  ${SOURCE_FILES}
37)
38
39target_compile_definitions(Breakout PUBLIC
40  CHECK_ERRORS
41  # ENABLE_CHEATS
42  # DRAW_DEBUG_HELPERS
43)
44
45# Conditionally set the WITH_EDITOR preprocessor definition
46if(WITH_EDITOR) 
47  target_compile_definitions(Breakout PUBLIC 
48    WITH_EDITOR 
49  ) 
50endif() 
51
52target_include_directories(
53  Breakout PUBLIC
54  ${PROJECT_SOURCE_DIR}
55)
56
57add_subdirectory(external/SDL)
58add_subdirectory(external/SDL_image)
59add_subdirectory(external/SDL_ttf)
60
61target_link_libraries(Breakout PRIVATE
62  SDL2
63  SDL2_image
64  SDL2_ttf
65)
66
67if (WIN32)
68  target_link_libraries(
69    Breakout PRIVATE SDL2main
70  )
71endif()
72
73set(AssetDirectory "${PROJECT_SOURCE_DIR}/Assets")
74add_custom_command(
75  TARGET Breakout POST_BUILD
76  COMMAND
77    ${CMAKE_COMMAND} -E copy_if_different
78      "$<TARGET_FILE:SDL2>"
79      "$<TARGET_FILE:SDL2_image>"
80      "$<TARGET_FILE:SDL2_ttf>"
81      "$<TARGET_FILE_DIR:Breakout>"
82  COMMAND
83    ${CMAKE_COMMAND} -E copy_directory_if_different
84      "${AssetDirectory}"
85      "$<TARGET_FILE_DIR:Breakout>/Assets"
86  VERBATIM
87)

With those changes, we can now easily prepare a version of our game that doesn't include our developer tools. Remember, our game still needs the output of those tools, such as the "Level1.bin" files.

Ensure that those are included alongside all the other assets (such as image files, fonts, and SDL's library files) that our program needs at run time.

Complete Code

Complete versions of all the files we updated in this lesson are available below:

A zip file containing all of the code is available here:

• breakout-end.zip

The fonts and images used in our screenshots are available here:

• Breakout Free Assets on Itch.io
• Rubik Font on Google Fonts

Summary

Our Breakout clone is now finished! This lesson was about adding the final logic that defines a complete game experience.

We introduced a GameState enum, implemented win and loss conditions, gave the player a way to restart, and created a pause system that activates at the start of levels and on game-end conditions.

Finally, we prepared our build system to easily exclude the editor for a release version.

Here's what we've accomplished in this project:

• We built a fully featured Breakout clone with multiple levels.
• We created a data-driven workflow with a separate level editor.
• We implemented a component-based engine for managing game entities.
• We handled player input, physics, and complex collision responses.
• We managed the overall game state, including winning, losing, pausing, and restarting.

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