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.

The `GAME_WON` and `GAME_LOST` 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

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.

Win/Loss Logic for Snake

The `GAME_WON` and `GAME_LOST` Events

Winning the Game

Losing the Game

Implementing Boundary Collision

Implementing Self Collision

Reacting to Victory and Loss

1. Updating the Game State

2. Highlighting the Restart Button

3. Changing Snake Color

Complete Code

Summary

Building the Score Display

Game Development with SDL2

Win/Loss Logic for Snake

The GAME_WON and GAME_LOST Events

Winning the Game

Losing the Game

Implementing Boundary Collision

Implementing Self Collision

Reacting to Victory and Loss

1. Updating the Game State

2. Highlighting the Restart Button

3. Changing Snake Color

Complete Code

Summary

Building the Score Display

The `GAME_WON` and `GAME_LOST` Events