Ending and Restarting Games

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}

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};

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}

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

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.

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.