Win/Loss Logic for Snake

Add game-ending logic to our Snake game with custom events, state management, and visual cues for player feedback.

This lesson is part of the course:

Game Dev with SDL2

Learn C++ and SDL development by creating hands on, practical projects inspired by classic retro games

Get Started for Free

Ryan McCombe

Posted 8 hours ago

Now that we have a working Snake game with basic movement and apple collection, it's time to add win-and-loss conditions to create a complete gaming experience.

In this lesson, we'll implement collision detection for game over states, add a winning condition when the snake reaches maximum length, and provide visual feedback for both outcomes.

`GAME_WON` and `GAME_LOST` User Events

Let’s begin by creating new event types that we can dispatch to notify our components that a game has been won or lost:

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

Winning the Game

The only way to win in Snake is to get our snake to some target length. We’ll create a variable in our GameConfig.h to set what this should be. We’re free to set it however we like, and we can derive the value based on the grid size if we want:

1// GameConfig.h
2// ...
3
4namespace Config{
5  inline constexpr int MAX_LENGTH{
6    GRID_COLUMNS * GRID_ROWS};
7  // ...
8}
9// ...

Currently, the length of our snake is managed within the GameState class, where it is incremented every time an APPLE_EATEN event is encountered. Let’s expand that logic to dispatch a GAME_WON event if our snake’s length reaches the maximum length:

1// GameState.h
2// ...
3
4class GameState {
5public:
6  // ...
7  void HandleEvent(SDL_Event& E) {
8    using namespace UserEvents;
9    using namespace Config;
10    if (E.type == SDL_KEYDOWN) {
11      HandleKeyEvent(E.key);
12    } else if (E.type == APPLE_EATEN) {
13      ++Snake.Length;
14      if (Snake.Length == MAX_LENGTH) {
15        SDL_Event Event{GAME_WON};
16        SDL_PushEvent(&Event);
17      }
18    } else if (E.type == RESTART_GAME) {
19      RestartGame();
20    }
21  }
22  // ...
23};

Losing the Game

There are two failure conditions in our Snake game:

Boundary Collision: When the snake hits the edge of the grid
Self-Collision: When the snake runs into its own body

Let's implement both of these conditions.

Implementing Boundary Collision

We'll add boundary collision detection in the UpdateSnake() method of our GameState class. After calculating the new head position, we'll check if it lies outside the valid grid coordinates.

If it does, we’ll dispatch a GAME_LOST event, otherwise, we’ll dispatch an ADVANCE event as before:

1// GameState.h
2// ...
3
4class GameState {
5  // ...
6private:
7  void UpdateSnake() {
8    Snake.Direction = NextDirection;
9    switch (NextDirection) {
10      case Up:
11        Snake.HeadRow--;
12        break;
13      case Down:
14        Snake.HeadRow++;
15        break;
16      case Left:
17        Snake.HeadCol--;
18        break;
19      case Right:
20        Snake.HeadCol++;
21        break;
22    }
23
24    if (
25      Snake.HeadRow < 0 ||
26      Snake.HeadRow >= Config::GRID_ROWS ||
27      Snake.HeadCol < 0 ||
28      Snake.HeadCol >= Config::GRID_COLUMNS
29    ) {
30      SDL_Event Event{UserEvents::GAME_LOST};
31      SDL_PushEvent(&Event);
32    } else {
33      // If we're not going outside the bounds
34      // of the grid, advance as before
35      SDL_Event Event{UserEvents::ADVANCE};
36      Event.user.data1 = &Snake;
37      SDL_PushEvent(&Event);
38    }
39  }
40  // ...
41};

Implementing Self Collision

For detecting when the snake collides with itself, we'll use our Cell class. Within the Cell::Advance() method, we'll check if the snake is moving into a cell that already contains a snake segment. If it is, we’ll dispatch a GAME_LOST event:

1// Cell.h
2// ...
3
4class Cell {
5  // ...
6private:
7  void Advance(SDL_UserEvent& E) {
8    SnakeData* Data{
9      static_cast<SnakeData*>(E.data1)};
10
11    bool isThisCell{
12      Data->HeadRow == Row &&
13      Data->HeadCol == Column
14    };
15
16    if (isThisCell) {
17      if (CellState == Snake) {
18        SDL_Event Event{UserEvents::GAME_LOST};
19        SDL_PushEvent(&Event);
20        return;
21      }
22      if (CellState == Apple) {
23        SDL_Event Event{
24          UserEvents::APPLE_EATEN};
25        SDL_PushEvent(&Event);
26      }
27      CellState = Snake;
28      SnakeDuration = Data->Length;
29    } else if (CellState == Snake) {
30      SnakeDuration--;
31      if (SnakeDuration <= 0) {
32        CellState = Empty;
33      }
34    }
35  }
36  // ...
37};

Reacting to Victory and Loss

Now that we’re dispatching GAME_WON and GAME_LOST events at the correct time, we need to update our components to react to these events. We’ll do three things when the game is over:

Our GameState will have a GameOver state which pauses the game and ignores keyboard input until the user presses the restart button.
The RestartButton will be highlighted, indicating that the user needs to press it.
The snake’s color will change to indicate whether the user won or lost.

Let’s update these components step by step.

1. Updating the Game State

We’ll add an IsGameOver boolean to our GameState class. We’ll initialize it to false, and reset it back to false every time we restart the game:

1// GameState.h
2// ...
3
4class GameState {
5  // ...
6private:
7  bool IsGameOver{false};
8  
9  void RestartGame() {
10    IsPaused = true;
11    IsGameOver = false;
12    ElapsedTime = 0;
13    Snake = {Config::GRID_ROWS / 2, 3, 2, Right};
14    NextDirection = Right;
15  }
16  // ...
17};

When our GameState object receives a GAME_LOST or GAME_WON event, we’ll update this IsGameOver variable to true:

1// GameState.h
2// ...
3
4class GameState {
5public:
6  // ...
7  void HandleEvent(SDL_Event& E) {
8    using namespace UserEvents;
9    using namespace Config;
10    if (E.type == SDL_KEYDOWN) {
11      HandleKeyEvent(E.key);
12    } else if (E.type == APPLE_EATEN) {
13      ++Snake.Length;
14      if (Snake.Length == MAX_LENGTH) {
15        SDL_Event Event{GAME_WON};
16        SDL_PushEvent(&Event);
17      }
18    } else if (E.type == RESTART_GAME) {
19      RestartGame();
20    } else if (E.type == GAME_LOST ||
21               E.type == GAME_WON) {
22      IsGameOver = true;
23    }
24  }
25  // ...
26};

When the game is over, we’ll replicate a similar behavior to the initial IsPaused state. First, we’ll disable our ticking logic:

1// GameState.h
2// ...
3
4class GameState {
5public:
6  // ...
7  void Tick(Uint32 DeltaTime) {
8    if (IsPaused || IsGameOver) return;
9
10    ElapsedTime += DeltaTime;
11    if (ElapsedTime >= Config::ADVANCE_INTERVAL) {
12      ElapsedTime = 0;
13      UpdateSnake();
14    }
15  }
16  // ...
17};

Additionally, when the game is over, we’ll ignore keyboard input until the game is restarted:

1// GameState.h
2// ...
3
4class GameState {
5  // ...
6private:
7  void HandleKeyEvent(SDL_KeyboardEvent& E) {
8    if (IsGameOver) return;
38    }
39  }
40};

If we run our game, we should now note that our snake stops moving and our keyboard input is ignored once we win or lose the game. Note that the IsGameOver and IsPaused states are subtly different.

Both of these states disable our GameState object’s Tick() behavior, but the logic in our HandleKeyEvent() function continues to be evaluated if the game is only paused. Players can press the right arrow or D key to unpause the game by setting IsPaused to false, but to set IsGameOver to false, they need to restart the game.

2. Highlighting the Restart Button

To indicate to the user that they need to press the restart button when the game is over, let’s highlight that button. We’ll first create a variable to control the highlighted color of our button:

1// GameConfig.h
2// ...
3
4namespace Config{
5  inline constexpr SDL_Color BUTTON_COLOR{
6    73, 117, 46, 255};
7  inline constexpr SDL_Color BUTTON_HIGHLIGHT_COLOR{
8    67, 117, 234, 255};
9}
10// ...

In our RestartButton class, we’ll update our ButtonColor member based on GAME_LOST, GAME_WON, and RESTART_GAME events:

1// RestartButton.h
2// ...
3
4class RestartButton {
5public:
6  // ...
7  void HandleEvent(SDL_Event& E) {
8    using namespace UserEvents;
9    using namespace Config;
10    if (E.type == SDL_MOUSEBUTTONDOWN) {
11      HandleClick(E.button);
12    } else if (
13      E.type == GAME_LOST ||
14      E.type == GAME_WON
15    ) {
16      CurrentColor = BUTTON_HIGHLIGHT_COLOR;
17    } else if (E.type == RESTART_GAME) {
18      CurrentColor = BUTTON_COLOR;
19    }
20  }
21  // ...
22};

Running our code, we should now see that the restart button uses a different color when the game is over:

Screenshot showing the restart button highlighting after the snake collides with the border

3. Changing Snake Color

Finally, let’s update the color of our snake when the user has won or lost the game. We’ll add new configuration variables for these colors:

1// GameConfig.h
2// ...
3
4namespace Config{
5  inline constexpr SDL_Color SNAKE_COLOR{
6    67, 117, 234, 255};
7  inline constexpr SDL_Color SNAKE_LOST_COLOR{
8    227, 67, 97, 255};
9  inline constexpr SDL_Color SNAKE_VICTORY_COLOR{
10    255, 140, 0, 255};
11  // ...
12}

In our Cell class, we’ll add a SnakeColor variable to keep track of what color our snake segments should be. We’ll set this to the default SNAKE_COLOR variable every time our cell is initialized:

1// Cell.h
2// ...
3
4class Cell {
5  // ...
6private:
7  // ...
8  SDL_Color SnakeColor{Config::SNAKE_COLOR};
9  
10  void Initialize() {
11    CellState = Empty;
12    SnakeColor = Config::SNAKE_COLOR;
13    SnakeDuration = 0;
14
15    int MiddleRow{Config::GRID_ROWS / 2};
16    if (Row == MiddleRow && Column == 2) {
17      CellState = Snake;
18      SnakeDuration = 1;
19    } else if (Row == MiddleRow && Column == 3) {
20      CellState = Snake;
21      SnakeDuration = 2;
22    } else if (Row == MiddleRow && Column == 11) {
23      CellState = Apple;
24    }
25  }
26};

Within the HandleEvent() function, we’ll change this color depending on whether the player won or lost. Our Initialize() function is already being called when the game is restarted, so we’re already handling that scenario:

1// Cell.h
2// ...
3
4class Cell {
5public:
6  // ...
7  void HandleEvent(SDL_Event& E) {
8    using namespace UserEvents;
9    if (E.type == ADVANCE) {
10      Advance(E.user);
11    } else if (E.
12      type == APPLE_EATEN) {
13      if (CellState == Snake) {
14        ++SnakeDuration;
15      }
16    } else if (E.type == GAME_LOST) {
17      SnakeColor = Config::SNAKE_LOST_COLOR;
18    } else if (E.type == GAME_WON) {
19      SnakeColor = Config::SNAKE_VICTORY_COLOR;
20    } else if (E.type == RESTART_GAME) {
21      Initialize();
22    }
23  }
24  // ...
25};

Finally, let’s update our Render() method to use this new SnakeColor variable, rather than the static Config::SNAKE_COLOR value it was previously using:

1// Cell.h
2// ...
3
4class Cell {
5public:
6  // ...
7  void Render(SDL_Surface* Surface) {
8    SDL_FillRect(Surface, &BackgroundRect,
9      SDL_MapRGB(
10        Surface->format,
11        BackgroundColor.r,
12        BackgroundColor.g,
13        BackgroundColor.b
14      )
15    );
16
17    if (CellState == Apple) {
18      Assets.Apple.Render(
19        Surface, &BackgroundRect);
20    } else if (CellState == Snake) {
21      SDL_FillRect(Surface, &BackgroundRect,
22        SDL_MapRGB(
23          Surface->format,
24          SnakeColor.r,
25          SnakeColor.g,
26          SnakeColor.b
27        )
28      );
29    }
30  }
31  // ...
32};

Now, when we lose, our snake should be rendered in the SNAKE_LOSS_COLOR we defined:

Screenshot showing the snake colored red after colliding with the border wall

And, when we win, it should use the SNAKE_VICTORY_COLOR. To test this, it can be helpful to temporarily reduce the MAX_LENGTH value to make winning easier:

Screenshot showing the snake colored gold after winning the game

Complete Code

Complete versions of the files we changed in this part are available below

GameConfig.h (Edited)

1#pragma once
2#define CHECK_ERRORS
3
4#include <iostream>
5#include <SDL.h>
6#include <string>
7
8namespace UserEvents{
9  inline Uint32 ADVANCE =
10    SDL_RegisterEvents(1);
11  inline Uint32 APPLE_EATEN =
12    SDL_RegisterEvents(1);
13  inline Uint32 GAME_WON =
14    SDL_RegisterEvents(1);
15  inline Uint32 GAME_LOST =
16    SDL_RegisterEvents(1);
17  inline Uint32 RESTART_GAME =
18    SDL_RegisterEvents(1);
19}
20
21namespace Config{
22  // Game Settings
23  inline const std::string GAME_NAME{
24    "Snake"};
25  inline constexpr int ADVANCE_INTERVAL{200};
26
27  inline constexpr int GRID_COLUMNS{16};
28  static_assert(
29    GRID_COLUMNS >= 12,
30    "Grid must be at least 12 columns wide");
31
32  inline constexpr int GRID_ROWS{5};
33  static_assert(
34    GRID_ROWS >= 5,
35    "Grid must be at least 5 rows tall");
36
37  inline constexpr int MAX_LENGTH{
38    GRID_COLUMNS * GRID_ROWS};
39
40  // Size and Positioning
41  inline constexpr int PADDING{5};
42  inline constexpr int CELL_SIZE{36};
43  inline constexpr int FOOTER_HEIGHT{60};
44
45  inline constexpr int GRID_HEIGHT{
46    CELL_SIZE * GRID_ROWS};
47  inline constexpr int GRID_WIDTH{
48    CELL_SIZE * GRID_COLUMNS};
49
50  inline constexpr int WINDOW_HEIGHT{
51    GRID_HEIGHT + FOOTER_HEIGHT
52    + PADDING * 2};
53  inline constexpr int WINDOW_WIDTH{
54    GRID_WIDTH + PADDING * 2
55  };
56
57  // Colors
58  inline constexpr SDL_Color BACKGROUND_COLOR{
59    85, 138, 52, 255};
60  inline constexpr SDL_Color CELL_COLOR_A{
61    171, 214, 82, 255};
62  inline constexpr SDL_Color CELL_COLOR_B{
63    161, 208, 74, 255};
64  inline constexpr SDL_Color SNAKE_COLOR{
65    67, 117, 234, 255};
66  inline constexpr SDL_Color SNAKE_LOST_COLOR{
67    227, 67, 97, 255};
68  inline constexpr SDL_Color SNAKE_VICTORY_COLOR{
69    255, 140, 0, 255};
70  inline constexpr SDL_Color BUTTON_COLOR{
71    73, 117, 46, 255};
72  inline constexpr SDL_Color BUTTON_HIGHLIGHT_COLOR{
73    67, 117, 234, 255};
74  inline constexpr SDL_Color FONT_COLOR{
75    255, 255, 255, 255};
76
77  // Asset Paths
78  inline const std::string APPLE_IMAGE{
79    "apple.png"};
80  inline const std::string FONT{
81    "Rubik-SemiBold.ttf"};
82}
83
84inline void CheckSDLError(
85  const std::string& Msg){
86#ifdef CHECK_ERRORS
87  const char* error = SDL_GetError();
88  if (*error != '\0') {
89    std::cerr << Msg << " Error: "
90      << error << '\n';
91    SDL_ClearError();
92  }
93#endif
94}

GameState.h (Edited)

1#pragma once
2#include <SDL.h>
3#include "GameConfig.h"
4#include "SnakeData.h"
5
6class GameState {
7public:
8  void HandleEvent(SDL_Event& E) {
9    using namespace UserEvents;
10    using namespace Config;
11    if (E.type == SDL_KEYDOWN) {
12      HandleKeyEvent(E.key);
13    } else if (E.type == APPLE_EATEN) {
14      ++Snake.Length;
15      if (Snake.Length == MAX_LENGTH) {
16        SDL_Event Event{GAME_WON};
17        SDL_PushEvent(&Event);
18      }
19    } else if (E.type == RESTART_GAME) {
20      RestartGame();
21    } else if (E.type == GAME_LOST ||
22               E.type == GAME_WON) {
23      IsGameOver = true;
24    }
25  }
26
27  void Tick(Uint32 DeltaTime) {
28    if (IsPaused || IsGameOver) return;
29
30    ElapsedTime += DeltaTime;
31    if (ElapsedTime >= Config::ADVANCE_INTERVAL) {
32      ElapsedTime = 0;
33      UpdateSnake();
34    }
35  }
36
37private:
38  void HandleKeyEvent(SDL_KeyboardEvent& E) {
39    if (IsGameOver) return;
40    switch (E.keysym.sym) {
41      case SDLK_UP:
42      case SDLK_w:
43        if (Snake.Direction != Down) {
44          NextDirection = Up;
45        }
46        break;
47      case SDLK_DOWN:
48      case SDLK_s:
49        if (Snake.Direction != Up) {
50          NextDirection = Down;
51        }
52        break;
53      case SDLK_LEFT:
54      case SDLK_a:
55        if (Snake.Direction != Right) {
56          NextDirection = Left;
57        }
58        break;
59      case SDLK_RIGHT:
60      case SDLK_d:
61        if (IsPaused) {
62          NextDirection = Right;
63          IsPaused = false;
64          UpdateSnake();
65        } else if (Snake.Direction != Left) {
66          NextDirection = Right;
67        }
68        break;
69    }
70  }
71
72  void UpdateSnake() {
73    Snake.Direction = NextDirection;
74    switch (NextDirection) {
75      case Up:
76        Snake.HeadRow--;
77        break;
78      case Down:
79        Snake.HeadRow++;
80        break;
81      case Left:
82        Snake.HeadCol--;
83        break;
84      case Right:
85        Snake.HeadCol++;
86        break;
87    }
88
89    if (
90      Snake.HeadRow < 0 ||
91      Snake.HeadRow >= Config::GRID_ROWS ||
92      Snake.HeadCol < 0 ||
93      Snake.HeadCol >= Config::GRID_COLUMNS
94    ) {
95      SDL_Event Event{UserEvents::GAME_LOST};
96      SDL_PushEvent(&Event);
97    } else {
98      SDL_Event Event{UserEvents::ADVANCE};
99      Event.user.data1 = &Snake;
100      SDL_PushEvent(&Event);
101    }
102  }
103
104  void RestartGame() {
105    IsPaused = true;
106    IsGameOver = false;
107    ElapsedTime = 0;
108    Snake = {Config::GRID_ROWS / 2, 3, 2, Right};
109    NextDirection = Right;
110  }
111
112  bool IsPaused{true};
113  bool IsGameOver{false};
114  Uint32 ElapsedTime{0};
115  SnakeData Snake{Config::GRID_ROWS / 2, 3, 2};
116  MovementDirection NextDirection{Right};
117};

Cell.h (Edited)

1#pragma once
2#include <SDL.h>
3#include "GameConfig.h"
4#include "SnakeData.h"
5#include "Assets.h"
6
7enum CellState { Snake, Apple, Empty };
8
9class Cell {
10public:
11  Cell(int Row, int Column, Assets& Assets)
12    : Row(Row),
13      Column(Column),
14      Assets{Assets}
15  {
16    Initialize();
17  }
18
19  void HandleEvent(SDL_Event& E) {
20    using namespace UserEvents;
21    if (E.type == ADVANCE) {
22      Advance(E.user);
23    } else if (E.
24      type == APPLE_EATEN) {
25      if (CellState == Snake) {
26        ++SnakeDuration;
27      }
28    } else if (E.type == GAME_LOST) {
29      SnakeColor = Config::SNAKE_LOST_COLOR;
30    } else if (E.type == GAME_WON) {
31      SnakeColor = Config::SNAKE_VICTORY_COLOR;
32    } else if (E.type == RESTART_GAME) {
33      Initialize();
34    }
35  }
36
37  void Tick(Uint32 DeltaTime) {}
38
39  void Render(SDL_Surface* Surface) {
40    SDL_FillRect(Surface, &BackgroundRect,
41      SDL_MapRGB(
42        Surface->format,
43        BackgroundColor.r,
44        BackgroundColor.g,
45        BackgroundColor.b
46      )
47    );
48
49    if (CellState == Apple) {
50      Assets.Apple.Render(
51        Surface, &BackgroundRect);
52    } else if (CellState == Snake) {
53      SDL_FillRect(Surface, &BackgroundRect,
54        SDL_MapRGB(
55          Surface->format,
56          SnakeColor.r,
57          SnakeColor.g,
58          SnakeColor.b
59        )
60      );
61    }
62  }
63
64  bool PlaceApple() {
65    if (CellState != Empty) return false;
66
67    CellState = Apple;
68    return true;
69  }
70
71private:
72  void Initialize() {
73    CellState = Empty;
74    SnakeColor = Config::SNAKE_COLOR;
75    SnakeDuration = 0;
76
77    int MiddleRow{Config::GRID_ROWS / 2};
78    if (Row == MiddleRow && Column == 2) {
79      CellState = Snake;
80      SnakeDuration = 1;
81    } else if (Row == MiddleRow && Column == 3) {
82      CellState = Snake;
83      SnakeDuration = 2;
84    } else if (Row == MiddleRow && Column == 11) {
85      CellState = Apple;
86    }
87  }
88
89  void Advance(SDL_UserEvent& E) {
90    SnakeData* Data{
91      static_cast<SnakeData*>(E.data1)};
92
93    bool isThisCell{
94      Data->HeadRow == Row &&
95      Data->HeadCol == Column
96    };
97
98    if (isThisCell) {
99      if (CellState == Snake) {
100        SDL_Event Event{UserEvents::GAME_LOST};
101        SDL_PushEvent(&Event);
102        return;
103      }
104      if (CellState == Apple) {
105        SDL_Event Event{
106          UserEvents::APPLE_EATEN};
107        SDL_PushEvent(&Event);
108      }
109      CellState = Snake;
110      SnakeDuration = Data->Length;
111    } else if (CellState == Snake) {
112      SnakeDuration--;
113      if (SnakeDuration <= 0) {
114        CellState = Empty;
115      }
116    }
117  }
118
119  int Row;
120  int Column;
121  CellState CellState;
122  SDL_Color SnakeColor{Config::SNAKE_COLOR};
123  int SnakeDuration;
124
125  SDL_Rect BackgroundRect{
126    Column * Config::CELL_SIZE + Config::PADDING,
127    Row * Config::CELL_SIZE + Config::PADDING,
128    Config::CELL_SIZE,
129    Config::CELL_SIZE
130  };
131
132  SDL_Color BackgroundColor{
133    (Row + Column) % 2 == 0
134      ? Config::CELL_COLOR_A
135      : Config::CELL_COLOR_B
136  };
137  
138  Assets& Assets;
139};

RestartButton.h (Edited)

1#pragma once
2#include <SDL.h>
3#include "GameConfig.h"
4#include "Engine/Text.h"
5
6class RestartButton {
7public:
8  void Render(SDL_Surface* Surface) {
9    SDL_FillRect(Surface, &ButtonRect,
10      SDL_MapRGB(
11        Surface->format,
12        CurrentColor.r,
13        CurrentColor.g,
14        CurrentColor.b
15      )
16    );
17    Text.Render(Surface, &TextRect);
18  }
19
20  void HandleEvent(SDL_Event& E) {
21    using namespace UserEvents;
22    using namespace Config;
23    if (E.type == SDL_MOUSEBUTTONDOWN) {
24      HandleClick(E.button);
25    } else if (
26      E.type == GAME_LOST ||
27      E.type == GAME_WON
28    ) {
29      CurrentColor = BUTTON_HIGHLIGHT_COLOR;
30    } else if (E.type == RESTART_GAME) {
31      CurrentColor = BUTTON_COLOR;
32    }
33  }
34
35private:
36  void HandleClick(SDL_MouseButtonEvent& E) {
37    using namespace UserEvents;
38    if (
39      E.x >= ButtonRect.x &&
40      E.x <= ButtonRect.x + ButtonRect.w &&
41      E.y >= ButtonRect.y &&
42      E.y <= ButtonRect.y + ButtonRect.h
43    ) {
44      SDL_Event RestartEvent{RESTART_GAME};
45      SDL_PushEvent(&RestartEvent);
46    }
47  }
48
49  Text Text{"RESTART", 20};
50
51  SDL_Rect ButtonRect{
52    Config::WINDOW_WIDTH - 150,
53    Config::GRID_HEIGHT + 10,
54    150 - Config::PADDING,
55    Config::FOOTER_HEIGHT - Config::PADDING
56  };
57
58  SDL_Rect TextRect{
59    ButtonRect.x + Config::PADDING * 5,
60    ButtonRect.y + Config::PADDING * 3,
61    ButtonRect.w - Config::PADDING,
62    ButtonRect.h - Config::PADDING
63  };
64
65  SDL_Color CurrentColor{Config::BUTTON_COLOR};
66};

Files not listed above have not been changed since the previous section.

Summary

In this lesson, we've implemented win-and-loss conditions. We've used the familiar event-based techniques to signal changes in one component, and react to those events throughout our application to keep our game state synchronised and provide visual feedback to players.

Next, we’ll update our UI to include a score tracker, keeping track of how many apples the player has collected.

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

Ryan McCombe

Posted 8 hours ago

Lesson Contents