Ending and Restarting Games

Implement win/loss detection and add a restart feature to complete the game loop

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

Free, Unlimited Access

Abstract art representing computer programming

Ryan McCombe

Updated 4 weeks ago

In this lesson, we’ll update our game to detect and react to the player winning or losing.

To win, the player must clear all the cells that do not have bombs
If the player clears a cell that has a bomb, they lose

Let’s get this working!

Updating Globals

When the player wins or loses, we’ll disable all the cells and reveal where the bombs are. If the player won, we’ll highlight those cells in green, but if the player lost, we’ll highlight them in red.

Let’s add those colours to our Globals.h. We’ll also register events that we can use to communicate when a win or loss happens:

1// Globals.h
2
3// ...
4
5namespace UserEvents{
6  // ...
7  inline Uint32 GAME_WON =
8    SDL_RegisterEvents(1);
9  inline Uint32 GAME_LOST =
10    SDL_RegisterEvents(1);
11}
12
13namespace Config{
14  // ...
15  inline constexpr SDL_Color BUTTON_SUCCESS_COLOR{
16    210, 235, 210, 255};
17  inline constexpr SDL_Color BUTTON_FAILURE_COLOR{
18    235, 210, 210, 255};
19  // ...
20}

Triggering `GAME_WON` and `GAME_LOST` Events

The game is won when the player clears all the cells, excluding those that have bombs. Currently, the MinesweeperGrid class is managing the cells and placing bombs, so this is the natural place to trigger the GAME_WON event.

GAME_LOST could reasonably be triggered from the MinesweeperCell class, but we’ll do it from the MinesweeperGrid too, just so both conditions are in the same place.

Let’s update our MinesweeperGrid class with a CellsToClear integer. When this value reaches 0, the player has won.

In our PlaceBombs function, we set this variable to the correct value. The player has to clear all the cells in the grid, excluding those that have bombs, so we do some arithmetic to work out the required value:

1// Minesweeper/Grid.h
2
3// ...
4
5class MinesweeperGrid {
6// ...
7
8private:
9  // ...
10
11  void PlaceBombs(){
12    int BombsToPlace{Config::BOMB_COUNT};
13    CellsToClear = Config::GRID_COLUMNS
14      * Config::GRID_ROWS - Config::BOMB_COUNT;
15    while (BombsToPlace > 0) {
16      const size_t RandomIndex{
17        Engine::Random::Int(
18          0, Children.size() - 1
19        )};
20      if (Children[RandomIndex].PlaceBomb()) {
21        --BombsToPlace;
22      }
23    }
24  }
25
26  std::vector<MinesweeperCell> Children;
27  int CellsToClear;
28};

We’ll add a HandleCellCleared function, which we’ll call every time a UserEvents::CELL_CLEARED event is received. Similar to the previous lesson, we’ll static_cast the event’s data1 void pointer, so we can call functions on the cell that was cleared.

If the cell contained a bomb, we’ll push a UserEvents::GAME_LOST event. Otherwise, we’ll decrement the CellsToClear variable, moving the user one step closer to victory.

If this causes CellsToClear to reach 0, the game is won and we push a UserEvents::GAME_WON event:

1// Minesweeper/Grid.h
2
3// ...
4
5class MinesweeperGrid {
6
7// ...
8
9private:
10  void HandleCellCleared(
11    const SDL_UserEvent& E){
12    auto* Cell{
13      static_cast<MinesweeperCell*>(
14        E.data1
15      )};
16
17    if (Cell->GetHasBomb()) {
18      SDL_Event Event{UserEvents::GAME_LOST};
19      SDL_PushEvent(&Event);
20    } else {
21      --CellsToClear;
22      if (CellsToClear == 0) {
23        SDL_Event Event{UserEvents::GAME_WON};
24        SDL_PushEvent(&Event);
25      }
26    }
27  }
28  
29  // ...
30};

Finally, let’s update HandleEvent() to forward any CELL_CLEARED events to this function:

1// Minesweeper/Grid.h
2
3// ...
4
5class MinesweeperGrid {
6public:
7  // ...
8  void HandleEvent(const SDL_Event& E){
9    if (E.type == UserEvents::CELL_CLEARED) {
10      HandleCellCleared(E.user);
11    }
12    
13    for (auto& Child : Children) {
14      Child.HandleEvent(E);
15    }
16  }
17  // ...
18};

Reacting to the Game Ending

Let’s have our MinesweeperCell objects react to the GAME_WON and GAME_LOST events being dispatched from our grid.

We’ll update the HandleEvent() function to check for them. When the game is won, we’ll change the color of the cell to the green value we set in our Globals.h if it has a bomb.

When the game is lost, we’ll reveal where the bombs are by setting isCleared to true, and we’ll set those cells to red.

We’ll also disable all the cells, preventing them from responding to future mouse events:

1// Minesweeper/Cell.cpp
2
3// ...
4
5void MinesweeperCell::HandleEvent(
6  const SDL_Event& E){
7  if (E.type == UserEvents::CELL_CLEARED) {
8    HandleCellCleared(E.user);
9  } else if (E.type ==
10    UserEvents::BOMB_PLACED) {
11    HandleBombPlaced(E.user);
12  } else if (E.type == UserEvents::GAME_WON) {
13    if (hasBomb) {
14      SetColor(Config::BUTTON_SUCCESS_COLOR);
15    }
16    SetIsDisabled(true);
17  } else if (E.type == UserEvents::GAME_LOST) {
18    if (hasBomb) {
19      isCleared = true;
20      SetColor(Config::BUTTON_FAILURE_COLOR);
21    }
22    SetIsDisabled(true);
23  }
24  Button::HandleEvent(E);
25}
26
27// ...

If we run our game, we should now see the correct behavior. If we win:

If we lose:

Note that these screenshot were taken with SHOW_DEBUG_HELPERS temporarily disabled to ensure the bombs are hidden if we win, and shown if we lose.

Restarting the Game

Let’s add a button to the UI that allows the player to start a new game. We’ll add a footer to our current interface that will store this button, as well as a flag counter we’ll add in the next part.

Let’s add a global to control the height of this footer, and also update our WINDOW_HEIGHT to accommodate it. We’ll also register a new event that the button can trigger when it is clicked:

1// Globals.h
2
3// ...
4
5namespace UserEvents{
6  // ...
7  inline Uint32 NEW_GAME =
8    SDL_RegisterEvents(1);
9}
10
11namespace Config{
12  // ...
13  
14  inline constexpr int FOOTER_HEIGHT{60};
15  
16  // ...
17
18  inline constexpr int WINDOW_HEIGHT{
19    GRID_HEIGHT + FOOTER_HEIGHT
20    + PADDING * 2
21  };
22  
23  // ...
24}

Creating the New Game Button

Let’s create our NewGameButton class. It will inherit from Engine::Button, and will additionally own a Engine::Text object to render the "New Game" text.

1// Minesweeper/NewGameButton.h
2#pragma once
3
4#include "Engine/Button.h"
5#include "Engine/Text.h"
6
7class NewGameButton : public Engine::Button {
8private:
9  Engine::Text Text;
10};

Our constructor will accept the usual x and y arguments to set the button position, and w and h arguments to set the size. We’ll forward these to the base Button constructor, as well as to the Text constructor.

Text will also receive 3 extra parameters:

The text to render - "NEW GAME" in this case
The color to use. The constructor has a default value for this argument, so we pass {} to use it
The size to render the text at - we’ll use 20

1// Minesweeper/NewGameButton.h
2#pragma once
3#include "Engine/Button.h"
4#include "Engine/Text.h"
5
6class NewGameButton : public Engine::Button {
7public:
8  NewGameButton(int x, int y, int w, int h)
9    : Button{x, y, w, h},
10      Text{x, y, w, h, "NEW GAME", {}, 20}{}
11
12private:
13  Engine::Text Text;
14};

We’ll override the base Button’s Render() method to ensure our Text gets rendered too, and we’ll override the HandleLeftClick() event to push our NEW_GAME event when the user clicks the button:

1// Minesweeper/NewGameButton.h
2#pragma once
3#include "Globals.h"
4
5#include "Engine/Button.h"
6#include "Engine/Text.h"
7
8class NewGameButton : public Engine::Button {
9public:
10  NewGameButton(int x, int y, int w, int h)
11    : Button{x, y, w, h},
12      Text{x, y, w, h, "NEW GAME", {}, 20}{}
13
14  void Render(SDL_Surface* Surface) override{
15    Button::Render(Surface);
16    Text.Render(Surface);
17  }
18
19  void HandleLeftClick() override{
20    SDL_Event E{UserEvents::NEW_GAME};
21    SDL_PushEvent(&E);
22  }
23
24private:
25  Engine::Text Text;
26};

Finally, lets add an instance of this class to our MinesweeperUI. We’ll do some arithmetic using our Config variables to ensure it has the correct position and size, and we’ll add it to our Render() and HandleEvent() functions to ensure it renders and receives events:

1// Minesweeper/UI.h
2
3#pragma once
4#include "Globals.h"
5#include "Minesweeper/Grid.h"
6#include "Minesweeper/NewGameButton.h"
7
8class MinesweeperUI {
9public:
10  void Render(SDL_Surface* Surface){
11    Grid.Render(Surface);
12    Button.Render(Surface);
13  }
14
15  void HandleEvent(const SDL_Event& E){
16    Grid.HandleEvent(E);
17    Button.HandleEvent(E);
18  };
19
20private:
21  MinesweeperGrid Grid{
22    Config::PADDING, Config::PADDING
23  };
24  NewGameButton Button{
25    Config::PADDING,
26    Config::GRID_HEIGHT + Config::PADDING * 2,
27    Config::WINDOW_WIDTH - Config::PADDING * 2,
28    Config::FOOTER_HEIGHT - Config::PADDING
29  };
30};

Creating the New Game Button

When the player wants to start a new game, we need to reset all of our cells, and place a new set of bombs.

Let’s implement this in the HandleEvent() function of MinesweeperGrid. When we receive a NEW_GAME event, we’ll call Reset() on all of the MinesweeperCell objects, and then invoke PlaceBombs().

Note that MinesweeperCell::Reset() doesn’t exist yet - we’ll create it in the next section.

With these changes, HandleEvent() in MinesweeperGrid looks like this:

1// Minesweeper/Grid.h
2
3// ...
4
5class MinesweeperGrid {
6public:
7  // ...
8  void HandleEvent(const SDL_Event& E){
9    if (E.type == UserEvents::CELL_CLEARED) {
10      HandleCellCleared(E.user);
11    } else if (E.type == UserEvents::NEW_GAME) {
12      for (auto& Child : Children) {
13        Child.Reset();
14      }
15      PlaceBombs();
16    }
17    for (auto& Child : Children) {
18      Child.HandleEvent(E);
19    }
20  }
21
22// ...
23
24};

Over in MinesweeperCell, lets add the Reset() method, which sets the key properties back to their initial values:

1// Minesweeper/Cell.h
2
3// ...
4
5class MinesweeperCell : public Engine::Button {
6public:
7  // ...
8  void Reset();
9  // ...
10};

1// Minesweeper/Cell.cpp
2
3// ...
4
5void MinesweeperCell::Reset(){
6  isCleared = false;
7  hasBomb = false;
8  AdjacentBombs = 0;
9  SetIsDisabled(false);
10  SetColor(Config::BUTTON_COLOR);
11}

Handling `NEW_GAME` within `MinesweeperCell`

Our MinesweeperCell class also has visibility of NEW_GAME events, so we could call Reset() from MinesweeperCell::HandleEvent instead of from the parent grid.

However, if taking this approach, we need to be mindful of the order the events will be processed in. We need to ensure the bombs are placed after the cells have been reset.

Running our program, we should now be able to click the button in the footer to start a new game at any time:

Complete Code

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

Globals.h (Edited)

1#pragma once
2
3#define SHOW_DEBUG_HELPERS
4
5#include <iostream>
6#include <SDL.h>
7#include <string>
8#include <vector>
9
10namespace UserEvents{
11  inline Uint32 CELL_CLEARED =
12    SDL_RegisterEvents(1);
13  inline Uint32 BOMB_PLACED =
14    SDL_RegisterEvents(1);
15  inline Uint32 GAME_WON =
16    SDL_RegisterEvents(1);
17  inline Uint32 GAME_LOST =
18    SDL_RegisterEvents(1);
19  inline Uint32 NEW_GAME =
20    SDL_RegisterEvents(1);
21}
22
23namespace Config{
24  // Game Settings
25  inline const std::string GAME_NAME{
26    "Minesweeper"};
27  inline constexpr int BOMB_COUNT{6};
28  inline constexpr int GRID_COLUMNS{8};
29  inline constexpr int GRID_ROWS{4};
30  static_assert(
31    BOMB_COUNT < GRID_COLUMNS * GRID_ROWS,
32    "Cannot have more bombs than cells"
33  );
34
35  // Size and Positioning
36  inline constexpr int PADDING{5};
37  inline constexpr int CELL_SIZE{50};
38  inline constexpr int FOOTER_HEIGHT{60};
39
40  inline constexpr int GRID_HEIGHT{
41    CELL_SIZE * GRID_ROWS
42    + PADDING * (GRID_ROWS - 1)
43  };
44
45    inline constexpr int GRID_WIDTH{
46    CELL_SIZE * GRID_COLUMNS
47    + PADDING * (GRID_COLUMNS - 1)
48  };
49
50  inline constexpr int WINDOW_HEIGHT{
51    GRID_HEIGHT + FOOTER_HEIGHT
52    + PADDING * 2
53  };
54  inline constexpr int WINDOW_WIDTH{
55    GRID_WIDTH + PADDING * 2
56  };
57
58  // Colors
59  inline constexpr SDL_Color BACKGROUND_COLOR{
60    170, 170, 170, 255};
61  inline constexpr SDL_Color BUTTON_COLOR{
62    200, 200, 200, 255};
63  inline constexpr SDL_Color BUTTON_HOVER_COLOR{
64    220, 220, 220, 255};
65  inline constexpr SDL_Color
66  BUTTON_CLEARED_COLOR{
67    240, 240, 240, 255};
68  inline constexpr SDL_Color
69  BUTTON_SUCCESS_COLOR{
70    210, 235, 210, 255};
71  inline constexpr SDL_Color
72  BUTTON_FAILURE_COLOR{
73    235, 210, 210, 255};
74
75  // Text color based on number of surrounding bombs 
76  inline const std::vector<SDL_Color>
77  TEXT_COLORS{
78    /* 0 */ {0, 0, 0, 255}, // Unused
79    /* 1 */ {0, 1, 249, 255},
80    /* 2 */ {1, 126, 1, 255},
81    /* 3 */ {250, 1, 2, 255},
82    /* 4 */ {1, 0, 128, 255},
83    /* 5 */ {129, 1, 0, 255},
84    /* 6 */ {0, 128, 128, 255},
85    /* 7 */ {0, 0, 0, 255},
86    /* 8 */ {128, 128, 128, 255}
87  };
88
89  // Asset Paths
90  inline const std::string BOMB_IMAGE{
91    "Bomb.png"};
92  inline const std::string FONT{
93    "Rubik-SemiBold.ttf"};
94}
95
96namespace Utils{
97#ifdef SHOW_DEBUG_HELPERS
98  inline void CheckSDLError(
99    const std::string& Msg){
100    const char* error = SDL_GetError();
101    if (*error != '\0') {
102      std::cerr << Msg << " Error: " << error <<
103        '\n';
104      SDL_ClearError();
105    }
106  }
107#endif
108}

Minesweeper/Cell.h (Edited)

1#pragma once
2#include "Engine/Button.h"
3#include "Engine/Image.h"
4#include "Engine/Text.h"
5
6class MinesweeperCell : public Engine::Button {
7public:
8  MinesweeperCell(
9    int X, int Y, int W, int H, int Row, int Col
10  );
11
12  void HandleEvent(const SDL_Event& E) override;
13  void Render(SDL_Surface* Surface) override;
14  void Reset();
15  bool PlaceBomb();
16
17  [[nodiscard]]
18  bool GetHasBomb() const{ return hasBomb; }
19
20  [[nodiscard]]
21  int GetRow() const{ return Row; }
22
23  [[nodiscard]]
24  int GetCol() const{ return Col; }
25
26protected:
27  void HandleLeftClick() override;
28
29private:
30  void ClearCell();
31  void ReportEvent(uint32_t EventType);
32  void HandleCellCleared(
33    const SDL_UserEvent& E);
34  void HandleBombPlaced(const SDL_UserEvent& E);
35  bool isAdjacent(MinesweeperCell* Other) const;
36
37  int AdjacentBombs{0};
38  int Row;
39  int Col;
40  bool hasBomb{false};
41  bool isCleared{false};
42  Engine::Image BombImage;
43  Engine::Text Text;
44};

Minesweeper/Cell.cpp (Edited)

1#include <string>
2#include "Minesweeper/Cell.h"
3#include "Globals.h"
4
5MinesweeperCell::MinesweeperCell(
6  int x, int y, int w, int h, int Row, int Col)
7  : Button{x, y, w, h}, Row{Row}, Col{Col},
8    BombImage{
9      x, y, w, h,
10      Config::BOMB_IMAGE},
11    Text{
12      x, y, w, h,
13      std::to_string(AdjacentBombs),
14      Config::TEXT_COLORS[AdjacentBombs]}{};
15
16void MinesweeperCell::HandleEvent(
17  const SDL_Event& E){
18  if (E.type == UserEvents::CELL_CLEARED) {
19    HandleCellCleared(E.user);
20  } else if (E.type ==
21    UserEvents::BOMB_PLACED) {
22    HandleBombPlaced(E.user);
23  } else if (E.type == UserEvents::GAME_WON) {
24    if (hasBomb) {
25      SetColor(Config::BUTTON_SUCCESS_COLOR);
26    }
27    SetIsDisabled(true);
28  } else if (E.type == UserEvents::GAME_LOST) {
29    if (hasBomb) {
30      isCleared = true;
31      SetColor(Config::BUTTON_FAILURE_COLOR);
32    }
33    SetIsDisabled(true);
34  }
35  Button::HandleEvent(E);
36}
37
38void MinesweeperCell::Render(
39  SDL_Surface* Surface){
40  Button::Render(Surface);
41  if (isCleared && hasBomb) {
42    BombImage.Render(Surface);
43  } else if (isCleared && AdjacentBombs > 0) {
44    Text.Render(Surface);
45  }
46
47#ifdef SHOW_DEBUG_HELPERS
48  else if (hasBomb) { BombImage.Render(Surface); }
49#endif
50}
51
52void MinesweeperCell::Reset(){
53  isCleared = false;
54  hasBomb = false;
55  AdjacentBombs = 0;
56  SetIsDisabled(false);
57  SetColor(Config::BUTTON_COLOR);
58}
59
60bool MinesweeperCell::PlaceBomb(){
61  if (hasBomb) return false;
62  hasBomb = true;
63  ReportEvent(UserEvents::BOMB_PLACED);
64  return true;
65}
66
67void MinesweeperCell::ClearCell(){
68  if (isCleared) return;
69  isCleared = true;
70  SetColor(Config::BUTTON_CLEARED_COLOR);
71  ReportEvent(UserEvents::CELL_CLEARED);
72}
73
74void MinesweeperCell::ReportEvent(
75  uint32_t EventType){
76  SDL_Event event{EventType};
77  event.user.data1 = this;
78  SDL_PushEvent(&event);
79}
80
81void MinesweeperCell::HandleCellCleared(
82  const SDL_UserEvent& E){
83  if (isCleared) return;
84  MinesweeperCell* Cell{
85    static_cast<MinesweeperCell*>(E.data1)
86  };
87  if (Cell->hasBomb) return;
88
89  if (isAdjacent(Cell) && Cell->AdjacentBombs ==
90    0) { ClearCell(); }
91}
92
93void MinesweeperCell::HandleBombPlaced(
94  const SDL_UserEvent& E){
95  MinesweeperCell* Cell{
96    static_cast<MinesweeperCell*>(E.data1)
97  };
98  if (isAdjacent(Cell)) {
99    ++AdjacentBombs;
100    Text.SetText(std::to_string(AdjacentBombs),
101                 Config::TEXT_COLORS[
102                   AdjacentBombs]);
103  }
104}
105
106bool MinesweeperCell::isAdjacent(
107  MinesweeperCell* Other) const{
108  return !(Other == this)
109    && std::abs(Other->GetRow() - Row) <= 1
110    && std::abs(Other->GetCol() - Col) <= 1;
111}
112
113void MinesweeperCell::HandleLeftClick(){
114  ClearCell();
115}

Minesweeper/NewGameButton.h (New)

1#pragma once
2#include "Globals.h"
3
4#include "Engine/Button.h"
5#include "Engine/Text.h"
6
7class NewGameButton : public Engine::Button {
8public:
9  NewGameButton(int x, int y, int w, int h)
10    : Button{x, y, w, h},
11      Text{x, y, w, h, "NEW GAME", {}, 20}{}
12
13  void Render(SDL_Surface* Surface) override{
14    Button::Render(Surface);
15    Text.Render(Surface);
16  }
17
18  void HandleLeftClick() override{
19    SDL_Event E{UserEvents::NEW_GAME};
20    SDL_PushEvent(&E);
21  }
22
23private:
24  Engine::Text Text;
25};

Minesweeper/UI.h (Edited)

1#pragma once
2#include "Globals.h"
3#include "Minesweeper/Grid.h"
4#include "Minesweeper/NewGameButton.h"
5
6class MinesweeperUI {
7public:
8  void Render(SDL_Surface* Surface){
9    Grid.Render(Surface);
10    Button.Render(Surface);
11  }
12
13  void HandleEvent(const SDL_Event& E){
14    Grid.HandleEvent(E);
15    Button.HandleEvent(E);
16  };
17
18private:
19  MinesweeperGrid Grid{
20    Config::PADDING, Config::PADDING
21  };
22  NewGameButton Button{
23    Config::PADDING,
24    Config::GRID_HEIGHT + Config::PADDING * 2,
25    Config::WINDOW_WIDTH - Config::PADDING * 2,
26    Config::FOOTER_HEIGHT - Config::PADDING
27  };
28};

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

Summary

In this lesson, we enhanced our Minesweeper game by implementing win and loss conditions.

We added new events to signal game outcomes, updated the UI to reflect these states, and created a "New Game" button for restarting. Key additions include:

Implementing win/loss detection in the MinesweeperGrid class
Updating cell appearance based on game outcome
Creating a NewGameButton class for game restarts
Resetting the game state when starting a new game

In the next lesson, we’ll finish off our project by letting the player right click to flag cells they think contain bombs.

We’ll also add a counter to our footer, keeping track of how many flags they have remaining.

Was this lesson useful?

Next Lesson

Placing Flags

Implement flag placement and tracking to complete your Minesweeper project.

New: AI-Powered AssistanceAI Assistance

Questions and HelpNeed Help?

Get instant help using our free AI assistant, powered by state-of-the-art language models.

Ryan McCombe

Updated 4 weeks ago

Lesson Contents