Placing Flags

Implement flag placement and tracking to complete your Minesweeper project.

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 3 weeks ago

In this final part of our Minesweeper series, we'll add the ability for players to place flags on suspected mine locations.

We'll update our game logic to handle flag placement and removal, create a visual representation for flags, and implement a counter to track the number of flags placed.

By the end of this lesson, you'll have a fully functional Minesweeper game with all the classic features players expect!

Updating Globals

Let’s start by updating our Globals.h. We’ll register events for flags being placed and cleared, and we’ll also add a string to define where our flag image is stored:

1// Globals.h
2
3// ...
4
5namespace UserEvents{
6  // ...
7  inline Uint32 FLAG_PLACED =
8    SDL_RegisterEvents(1);
9  inline Uint32 FLAG_CLEARED =
10    SDL_RegisterEvents(1);
11}
12
13namespace Config{
14  // ...
15  inline const std::string FLAG_IMAGE{
16    "flag.png"};
17}
18
19// ...

Placing Flags

To place a flag, players will right click on a cell, so we need to update our MinesweeperCell class. The base Engine::Button class has a HandleRightClick() method we can override, and we’ll additionally at a boolean to store whether the player has placed a flag in this cell:

1// Minesweeper/Cell.h
2
3// ...
4
5class MinesweeperCell : public Engine::Button {
6protected:
7  void HandleRightClick() override;
8  
9  // ...
10
11private:
12  // ...
13  bool hasFlag{false};
14};

In our HandleRightClick() implementation, we’ll simply toggle the hasFlag variable, and report the appropriate event:

1// Minesweeper/Cell.cpp
2
3// ...
4
5void MinesweeperCell::HandleRightClick(){
6  if (hasFlag) {
7    ReportEvent(UserEvents::FLAG_CLEARED);
8    hasFlag = false;
9  } else {
10    ReportEvent(UserEvents::FLAG_PLACED);
11    hasFlag = true;
12  }
13}

Left-clicking on a cell that contains a flag shouldn’t clear the cell, so let’s add that logic to our HandleLeftClick() function:

1// Minesweeper/Cell.cpp
2
3// ...
4
5void MinesweeperCell::HandleLeftClick(){
6  if (!hasFlag) { ClearCell(); }
7}
8
9// ...

When the player starts a new game, all the flags should be cleared. Let’s add that to our Reset() function:

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

The player doesn’t necessarily need to mark all the bombs to win the game. As a small presentational improvement, let’s just automatically flag all the cells with bombs in response to the GAME_WON event:

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      hasFlag = hasBomb; 
15      SetColor(Config::BUTTON_SUCCESS_COLOR);
16    }
17    SetIsDisabled(true);
18  } else if (E.type == UserEvents::GAME_LOST) {
19    if (hasBomb) {
20      isCleared = true;
21      SetColor(Config::BUTTON_FAILURE_COLOR);
22    }
23    SetIsDisabled(true);
24  }
25  Button::HandleEvent(E);
26}
27
28// ...

Rendering Flags

Now that our cells are keeping track of whether or not they’re flagged, let’s render some visual output for the flags. We’ll add another Engine::Image member to our MinesweeperCell to render the flag:

1// Minesweeper/Cell.h
2
3class MinesweeperCell : public Engine::Button {
4// ...
5private:
6  // ...
7  Engine::Image FlagImage;
8};

In our constructor, we initialize this variable in much the same way we initialized the bomb image:

1// Minesweeper/Cell.cpp
2
3// ...
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    FlagImage{
9      x, y, w, h,
10      Config::FLAG_IMAGE},
11    BombImage{
12      x, y, w, h,
13      Config::BOMB_IMAGE},
14    Text{
15      x, y, w, h,
16      std::to_string(AdjacentBombs),
17      Config::TEXT_COLORS[AdjacentBombs]}{};
18
19// ...

Finally, in our Render() method, if the cell has a flag, we’ll render the FlagImage:

1//  Minesweeper/Cell.cpp
2
3// ...
4
5void MinesweeperCell::Render(
6  SDL_Surface* Surface){
7  Button::Render(Surface);
8  if (hasFlag) {
9    FlagImage.Render(Surface);
10  } else if (isCleared && hasBomb) {
11    BombImage.Render(Surface);
12  } else if (isCleared && AdjacentBombs > 0) {
13    Text.Render(Surface);
14  }
15
16#ifdef SHOW_DEBUG_HELPERS
17  else if (hasBomb) { BombImage.Render(Surface); }
18#endif
19}

Running our game, we can now right-click in any uncleared cell to place a flag. Left clicking a flagged cell should have no effect, but right clicking it will remove the flag:

Flag Counter

Let’s add a counter to our footer, so the player can keep track of how many bombs they have yet to place flags on. This indicator will have the full height of the footer, with its width and color controlled by Config variables in Global.h:

1//  Globals.h
2
3// ...
4
5namespace Config{
6  // ...
7  inline constexpr int FLAG_COUNTER_WIDTH{100};
8  // ...
9  inline constexpr SDL_Color FLAG_COUNTER_COLOR{
10    80, 80, 80, 255};
11  // ...
12}
13
14// ...

Let’s create our Minesweeper/FlagCounter class. It inherits from Engine::Rectangle, and will contain an Image and Text element side-by-side.

The position and size of the Rectangle will be controlled by constructor arguments, with the color coming from our Config namespace.

The Image will be placed at the top left of the Rectangle, with its height being based on the FOOTER_HEIGHT config variable, and its width being the same as the height to ensure it is square. We also apply a 24 pixel padding to make the image slightly smaller.

The Text variable uses slightly more arithmetic to ensure it appears to the right of the Image. We also set the initial string to be the total number of bombs in the grid. We set the color to white, and the font size to 20:

1// Minesweeper/FlagCounter.h
2#pragma once
3#include <string>
4
5#include "Globals.h"
6
7#include "Engine/Rectangle.h"
8#include "Engine/Text.h"
9#include "Engine/Image.h"
10
11class FlagCounter : public Engine::Rectangle {
12public:
13  FlagCounter(int x, int y, int w, int h)
14    : Rectangle{
15        x, y, w, h, Config::FLAG_COUNTER_COLOR},
16      Image{
17        x, y,
18        Config::FOOTER_HEIGHT - Config::PADDING,
19        Config::FOOTER_HEIGHT - Config::PADDING,
20        Config::FLAG_IMAGE,
21        24},
22      Text{
23        x + Config::FOOTER_HEIGHT, y,
24        w - Config::FOOTER_HEIGHT - 24, h,
25        std::to_string(Config::BOMB_COUNT),
26        {255, 255, 255, 255}, 20}{}
27
28private:
29  Engine::Image Image;
30  Engine::Text Text;
31};

We’ll override the base rectangle’s Render() method to ensure the Text and Image are also rendered:

1// Minesweeper/FlagCounter.h
2
3// ...
4
5class FlagCounter : public Engine::Rectangle {
6public:
7  // ...
8
9  void Render(SDL_Surface* Surface) override{
10    Rectangle::Render(Surface);
11    Text.Render(Surface);
12    Image.Render(Surface);
13  }
14
15 // ...
16};

Finally, we’ll implement a HandleEvent() method so that the FlagCounter can update appropriately:

When the player places a flag, we decrement the number of available flags
When the player clears a flag, we increment the number of available flags
When the game is won, we set the available flags to 0, because when this happens, our MinesweeperCell objects automatically place flags where all the bombs were
When the user restarts the game, the number of available flags is set to its initial value.

Additionally, when any of these events occur, we call Text member’s SetText() function to inform it what number it should be rendering:

1// Minesweeper/FlagCounter.h
2
3// ...
4
5class FlagCounter : public Engine::Rectangle {
6public:
7  // ...
8
9  void HandleEvent(const SDL_Event& E){
10    if (E.type ==
11      UserEvents::FLAG_PLACED) {
12      --FlagsAvailable;
13    } else if (E.type ==
14      UserEvents::FLAG_CLEARED) {
15      ++FlagsAvailable;
16    } else if (E.type == UserEvents::GAME_WON) {
17      FlagsAvailable = 0;
18    } else if (E.type == UserEvents::NEW_GAME) {
19      FlagsAvailable = Config::BOMB_COUNT;
20    } else { return; }
21    Text.SetText(
22      std::to_string(FlagsAvailable)
23    );
24  }
25
26private:
27  // ...
28  int FlagsAvailable{Config::BOMB_COUNT};
29};

Finally, let’s add it to the UI. As before, we add it as a member of our MinesweeperUI, and add it to our Render() and HandleEvent() functions.

We reduce the width of the NewGameButton to make space in the footer, and then do some arithmetic to set the FlagCounter's position (x and y) and size (w and h).

The calculations involved to determine these constructor arguments is getting excessively messy and something we’d typically want to address.

Given we’re essentially finished with this project, we’ll leave it like this for now, but it’s a problem we should consider solving in our Engine module to make future projects easier. We discuss options for this later in the lesson.

Our final MinesweeperUI class looks like this:

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

Our game is now complete and should be fully working! Remember to disable the SHOW_DEBUG_HELPERS definition to hide the bombs:

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

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  void HandleRightClick() override;
29
30private:
31  void ClearCell();
32  void ReportEvent(uint32_t EventType);
33  void HandleCellCleared(
34    const SDL_UserEvent& E);
35  void HandleBombPlaced(const SDL_UserEvent& E);
36  bool isAdjacent(MinesweeperCell* Other) const;
37
38  int AdjacentBombs{0};
39  int Row;
40  int Col;
41  bool hasBomb{false};
42  bool hasFlag{false};
43  bool isCleared{false};
44  Engine::Image FlagImage;
45  Engine::Image BombImage;
46  Engine::Text Text;
47};

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

Minesweeper/UI.h (Edited)

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

Minesweeper/FlagCounter.h (New)

1#pragma once
2#include <string>
3
4#include "Globals.h"
5
6#include "Engine/Rectangle.h"
7#include "Engine/Text.h"
8#include "Engine/Image.h"
9
10class FlagCounter : public Engine::Rectangle {
11public:
12  FlagCounter(int x, int y, int w, int h)
13    : Rectangle{
14        x, y, w, h, Config::FLAG_COUNTER_COLOR},
15      Image{
16        x, y,
17        Config::FOOTER_HEIGHT - Config::PADDING,
18        Config::FOOTER_HEIGHT - Config::PADDING,
19        Config::FLAG_IMAGE,
20        24},
21      Text{
22        x + Config::FOOTER_HEIGHT, y,
23        w - Config::FOOTER_HEIGHT - 24, h,
24        std::to_string(Config::BOMB_COUNT),
25        {255, 255, 255, 255}, 20}{}
26
27  void Render(SDL_Surface* Surface) override{
28    Rectangle::Render(Surface);
29    Text.Render(Surface);
30    Image.Render(Surface);
31  }
32
33  void HandleEvent(const SDL_Event& E){
34    if (E.type ==
35      UserEvents::FLAG_PLACED) {
36      --FlagsAvailable;
37    } else if (E.type ==
38      UserEvents::FLAG_CLEARED) {
39      ++FlagsAvailable;
40    } else if (E.type == UserEvents::GAME_WON) {
41      FlagsAvailable = 0;
42    } else if (E.type == UserEvents::NEW_GAME) {
43      FlagsAvailable = Config::BOMB_COUNT;
44    } else { return; }
45    Text.SetText(
46      std::to_string(FlagsAvailable)
47    );
48  }
49
50private:
51  Engine::Image Image;
52  Engine::Text Text;
53  int FlagsAvailable{Config::BOMB_COUNT};
54};

The remaining project files (which were not changed in this section) are available here:

Engine/Button.h

1#pragma once
2#include "Globals.h"
3#include "Engine/Rectangle.h"
4
5namespace Engine{
6  class Button : public Rectangle {
7  public:
8    Button(int x, int y, int w, int h)
9      : Rectangle{x, y, w, h}{
10      SetColor(Config::BUTTON_COLOR);
11    }
12
13    virtual void
14    HandleEvent(const SDL_Event& E){
15      if (isDisabled) return;
16      if (E.type == SDL_MOUSEMOTION) {
17        HandleMouseMotion(E.motion);
18      } else if (E.type ==
19        SDL_MOUSEBUTTONDOWN) {
20        if (IsWithinBounds(E.button.x,
21                           E.button.y)) {
22          E.button.button == SDL_BUTTON_LEFT
23            ? HandleLeftClick()
24            : HandleRightClick();
25        }
26      }
27    }
28
29    void SetIsDisabled(bool NewValue){
30      isDisabled = NewValue;
31    }
32
33  protected:
34    virtual void HandleLeftClick(){}
35    virtual void HandleRightClick(){}
36
37    virtual void HandleMouseMotion(
38      const SDL_MouseMotionEvent& E){
39      if (IsWithinBounds(E.x, E.y)) {
40        SetColor(Config::BUTTON_HOVER_COLOR);
41      } else { SetColor(Config::BUTTON_COLOR); }
42    }
43
44  private:
45    bool isDisabled{false};
46  };
47}

Engine/Image.h

1#pragma once
2#include <SDL_image.h>
3
4namespace Engine{
5  class Image {
6  public:
7    Image(
8      int x, int y, int w, int h,
9      const std::string& Filename,
10      int Padding = 12
11    ): Destination{
12      x + Padding/2, y + Padding/2,
13      w-Padding, h-Padding
14    }{
15      ImageSurface = IMG_Load(Filename.c_str());
16#ifdef SHOW_DEBUG_HELPERS
17      Utils::CheckSDLError("IMG_Load");
18#endif
19    }
20
21    void Render(SDL_Surface* Surface) {
22      SDL_BlitScaled(
23        ImageSurface,nullptr,
24        Surface, &Destination
25      );
26    }
27
28    ~Image() {
29      if (ImageSurface) {
30        SDL_FreeSurface(ImageSurface);
31      }
32    }
33
34    Image(const Image&){}
35
36  private:
37    SDL_Surface* ImageSurface{nullptr};
38    SDL_Rect Destination{0, 0, 0, 0};
39  };
40}

Engine/Random.h

1#pragma once
2#include <random>
3
4namespace Engine::Random{
5  inline std::random_device SEEDER;
6  inline std::mt19937 ENGINE{SEEDER()};
7
8  inline size_t Int(size_t Min, size_t Max){
9    std::uniform_int_distribution Get{Min, Max};
10    return Get(ENGINE);
11  }
12}

Engine/Rectangle.h

1#pragma once
2#include <SDL.h>
3
4namespace Engine{
5  class Rectangle {
6  public:
7    Rectangle(
8      int x, int y, int w, int h,
9      SDL_Color Color = {0, 0, 0, 255})
10      : Rect{x, y, w, h}, Color{Color}{}
11
12    virtual void Render(SDL_Surface* Surface){
13      SDL_FillRect(
14        Surface, &Rect, SDL_MapRGB(
15          Surface->format, Color.r, Color.g,
16          Color.b
17        )
18      );
19    }
20
21    void SetColor(SDL_Color C){ Color = C; }
22
23    bool IsWithinBounds(int x, int y) const{
24      // Too far left
25      if (x < Rect.x) return false;
26      // Too far right
27      if (x > Rect.x + Rect.w) return false;
28      // Too high
29      if (y < Rect.y) return false;
30      // Too low
31      if (y > Rect.y + Rect.h) return false;
32      // Within bounds
33      return true;
34    }
35
36    SDL_Rect* GetRect(){ return &Rect; }
37
38    virtual ~Rectangle() = default;
39
40  private:
41    SDL_Rect Rect{0, 0, 0, 0};
42    SDL_Color Color{0, 0, 0, 0};
43  };
44}

Engine/Text.h

1#pragma once
2#include <SDL_ttf.h>
3#include "Globals.h"
4
5namespace Engine{
6  class Text {
7  public:
8    Text(
9      int x, int y, int w, int h,
10      const std::string& Content,
11      SDL_Color Color = {0, 0, 0, 255},
12      int FontSize = 30
13    ) : DestinationRect{x, y, w, h},
14        Color{Color}
15    {
16      Font = TTF_OpenFont(
17        Config::FONT.c_str(), FontSize);
18#ifdef SHOW_DEBUG_HELPERS
19      Utils::CheckSDLError("TTF_OpenFont");
20#endif
21      SetText(Content);
22    }
23
24    void SetText(const std::string& Text){
25      SetText(Text, Color);
26    }
27
28    void SetText(const std::string& Text,
29                 SDL_Color NewColor){
30      if (TextSurface) {
31        SDL_FreeSurface(TextSurface);
32      }
33      Color = NewColor;
34
35      TextSurface = TTF_RenderUTF8_Blended(
36        Font, Text.c_str(), Color
37      );
38
39      auto [x, y, w, h] = DestinationRect;
40      // Horizontally centering
41      const int WidthDifference{
42        w - TextSurface->w};
43      const int LeftOffset{WidthDifference / 2};
44
45      // Vertically centering
46      const int HeightDifference{
47        h - TextSurface->h};
48      const int TopOffset{HeightDifference / 2};
49
50      TextPosition = {
51        x + LeftOffset, y + TopOffset, w, h
52      };
53    }
54
55    void Render(SDL_Surface* Surface) {
56      SDL_BlitSurface(
57        TextSurface, nullptr,
58        Surface, &TextPosition
59      );
60    }
61
62    ~Text() {
63      if (Font) { TTF_CloseFont(Font); }
64      if (TextSurface) {
65        SDL_FreeSurface(TextSurface);
66      }
67    }
68
69  private:
70    SDL_Surface* TextSurface{nullptr};
71    TTF_Font* Font{nullptr};
72    SDL_Rect DestinationRect{0, 0, 0, 0};
73    SDL_Rect TextPosition{0, 0, 0, 0};
74    SDL_Color Color{0, 0, 0, 255};
75  };
76}

Engine/Window.h

1#pragma once
2#include <SDL.h>
3#include "Globals.h"
4
5namespace Engine{
6  class Window {
7  public:
8    Window(){
9      SDLWindow = SDL_CreateWindow(
10        Config::GAME_NAME.c_str(),
11        SDL_WINDOWPOS_UNDEFINED,
12        SDL_WINDOWPOS_UNDEFINED,
13        Config::WINDOW_WIDTH,
14        Config::WINDOW_HEIGHT, 0
15      );
16    }
17
18    void Render(){
19      SDL_FillRect(
20        GetSurface(), nullptr,
21        SDL_MapRGB(GetSurface()->format,
22                   Config::BACKGROUND_COLOR.r,
23                   Config::BACKGROUND_COLOR.g,
24                   Config::BACKGROUND_COLOR.b));
25    }
26
27    void Update(){
28      SDL_UpdateWindowSurface(SDLWindow);
29    }
30
31    SDL_Surface* GetSurface(){
32      return SDL_GetWindowSurface(SDLWindow);
33    }
34    
35    ~Window() {
36      SDL_DestroyWindow(SDLWindow);
37    }
38    Window(const Window&) = delete;
39    Window& operator=(const Window&) = delete;
40
41  private:
42    SDL_Window* SDLWindow;
43  };
44}

Minesweeper/NewGameButton.h

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/Grid.h

1#pragma once
2#include <SDL.h>
3#include "Globals.h"
4#include "Minesweeper/Cell.h"
5#include "Engine/Random.h"
6
7class MinesweeperGrid {
8public:
9  MinesweeperGrid(int x, int y){
10    using namespace Config;
11    Children.reserve(GRID_COLUMNS * GRID_ROWS);
12    for (int Col{1}; Col <= GRID_COLUMNS; ++
13         Col) {
14      for (int Row{1}; Row <= GRID_ROWS; ++
15           Row) {
16        constexpr int Spacing{
17          CELL_SIZE + PADDING};
18        Children.emplace_back(
19          x + (Spacing) * (Col - 1),
20          y + (Spacing) * (Row - 1),
21          CELL_SIZE, CELL_SIZE, Row, Col
22        );
23      }
24    }
25    PlaceBombs();
26  };
27
28  void Render(SDL_Surface* Surface){
29    for (auto& Child : Children) {
30      Child.Render(Surface);
31    }
32  }
33
34  void HandleEvent(const SDL_Event& E){
35    if (E.type == UserEvents::CELL_CLEARED) {
36      HandleCellCleared(E.user);
37    } else if (E.type == UserEvents::NEW_GAME) {
38      for (auto& Child : Children) {
39        Child.Reset();
40      }
41      PlaceBombs();
42    }
43    for (auto& Child : Children) {
44      Child.HandleEvent(E);
45    }
46  };
47
48private:
49  void HandleCellCleared(
50    const SDL_UserEvent& E){
51    auto* Cell{
52      static_cast<MinesweeperCell*>(
53        E.data1
54      )};
55
56    if (Cell->GetHasBomb()) {
57      SDL_Event Event{UserEvents::GAME_LOST};
58      SDL_PushEvent(&Event);
59    } else {
60      --CellsToClear;
61      if (CellsToClear == 0) {
62        SDL_Event Event{UserEvents::GAME_WON};
63        SDL_PushEvent(&Event);
64      }
65    }
66  }
67
68  void PlaceBombs(){
69    int BombsToPlace{Config::BOMB_COUNT};
70    CellsToClear = Config::GRID_COLUMNS
71      * Config::GRID_ROWS - Config::BOMB_COUNT;
72    while (BombsToPlace > 0) {
73      const size_t RandomIndex{
74        Engine::Random::Int(
75          0, Children.size() - 1
76        )};
77      if (Children[RandomIndex].PlaceBomb()) {
78        --BombsToPlace;
79      }
80    }
81  }
82
83  std::vector<MinesweeperCell> Children;
84  int CellsToClear;
85};

main.cpp

1#include <SDL_image.h>
2#include <SDL_ttf.h>
3
4#include "Globals.h"
5#include "Engine/Window.h"
6#include "Minesweeper/UI.h"
7
8int main(int argc, char** argv){
9  SDL_Init(SDL_INIT_VIDEO);
10#ifdef SHOW_DEBUG_HELPERS
11  Utils::CheckSDLError("SDL_Init");
12#endif
13
14  IMG_Init(IMG_INIT_PNG);
15#ifdef SHOW_DEBUG_HELPERS
16  Utils::CheckSDLError("IMG_Init");
17#endif
18
19  TTF_Init();
20#ifdef SHOW_DEBUG_HELPERS
21  Utils::CheckSDLError("TTF_Init");
22#endif
23
24  Engine::Window GameWindow;
25  MinesweeperUI UI;
26
27  SDL_Event Event;
28  bool shouldQuit{false};
29
30  while (!shouldQuit) {
31    while (SDL_PollEvent(&Event)) {
32      if (Event.type == SDL_QUIT) {
33        shouldQuit = true;
34      } else { UI.HandleEvent(Event); }
35    }
36    GameWindow.Render();
37    UI.Render(GameWindow.GetSurface());
38    GameWindow.Update();
39  }
40
41  SDL_Quit();
42  return 0;
43}

CMakeLists.txt

1cmake_minimum_required(VERSION 3.16)
2
3set(CMAKE_CXX_STANDARD 20)
4
5project(Minesweeper VERSION 1.0.0)
6add_executable(Minesweeper
7  "main.cpp"
8  "Globals.h"
9  "Engine/Button.h"
10  "Engine/Rectangle.h"
11  "Engine/Image.h"
12  "Engine/Text.h"
13  "Engine/Window.h"
14  "Engine/Random.h"
15  "Minesweeper/Grid.h"
16  "Minesweeper/UI.h"
17  "Minesweeper/Cell.h"
18  "Minesweeper/Cell.cpp"
19  "Minesweeper/NewGameButton.h"
20  "Minesweeper/FlagCounter.h"
21)
22
23target_include_directories(
24  Minesweeper PUBLIC ${PROJECT_SOURCE_DIR}
25)
26
27add_subdirectory(external/SDL)
28add_subdirectory(external/SDL_image)
29add_subdirectory(external/SDL_ttf)
30
31target_link_libraries(Minesweeper PRIVATE
32  SDL2
33  SDL2_image
34  SDL2_ttf
35)
36
37if (WIN32)
38  target_link_libraries(
39    Minesweeper PRIVATE SDL2main
40  )
41endif()
42
43set(AssetDirectory "${PROJECT_SOURCE_DIR}/Assets")
44add_custom_command(
45  TARGET Minesweeper POST_BUILD COMMAND
46  ${CMAKE_COMMAND} -E copy_if_different
47    "$<TARGET_FILE:SDL2>"
48    "$<TARGET_FILE:SDL2_image>"
49    "$<TARGET_FILE:SDL2_ttf>"
50    "${AssetDirectory}/bomb.png"
51    "${AssetDirectory}/Rubik-SemiBold.ttf"
52    "${AssetDirectory}/flag.png"
53    "$<TARGET_FILE_DIR:Minesweeper>"
54  VERBATIM
55)

Assets/Rubik-SemiBold.tff available from Google Fonts
Assets/bomb.png available from IconFinder
Assets/flag.png available from IconsDB

Improvement Ideas

To make the most of our learning, it can be helpful to go back to our project and change some things around, reworking how things work, or even completely rebuilding it.

This self-directed learning helps solidify the concepts we’ve covered, and makes it easier to apply them to new projects that won’t have as much guidance. Some ideas on how the project could be reworked are below:

Refactoring

Something we should constantly be reviewing is areas of our code that seem quite complex and difficult to follow.

For example, our program has a very simple visual layout, with a grid at the top and a new game button and flag counter side by side at the bottom.

However, the code to establish such a simple layout is already difficult to write and follow:

1// ...
2
3class MinesweeperUI {
4public:
5  void Render(SDL_Surface* Surface){
6    Grid.Render(Surface);
7    Button.Render(Surface);
8    Counter.Render(Surface);
9  }
10  // ...
11private:
12  MinesweeperGrid Grid{
13    Config::PADDING, Config::PADDING
14  };
15  NewGameButton Button{
16    Config::PADDING,
17    Config::GRID_HEIGHT + Config::PADDING * 2,
18    Config::WINDOW_WIDTH - Config::PADDING * 3
19    - Config::FLAG_COUNTER_WIDTH,
20    Config::FOOTER_HEIGHT - Config::PADDING
21  };
22  FlagCounter Counter{
23    Config::WINDOW_WIDTH - Config::PADDING
24    - Config::FLAG_COUNTER_WIDTH,
25    Config::GRID_HEIGHT + Config::PADDING * 2,
26    Config::FLAG_COUNTER_WIDTH,
27    Config::FOOTER_HEIGHT - Config::PADDING
28  };
29};

Laying objects out in columns and rows is a recurring problem, so we could consider introducing generic classes like Column and Row that take care of that for us.

These classes can simply position children next to each other vertically or horizontally, and could accept arguments to control things like the padding between objects:

1// ...
2#include "Engine/Column.h"
3#include "Engine/Row.h"
4
5class MinesweeperUI {
6public:
7  void Render(SDL_Surface* Surface){
8    Layout.Render(Surface);
9  }
10  // ...
11  
12private:
13  MinesweeperGrid Grid;
14  NewGameButton Button;
15  FlagCounter Counter;
16
17  Column Layout{
18    Grid,
19    Row{
20      Button, Counter
21    }
22  }
23};

Gameplay Improvements

Currently, our game places bombs before the user clears the first cell. This can cause unfair outcomes, such as the first cell containing a bomb.

Many implementations of Minesweeper do not choose bomb positions until after the user clicks their first cell. This allows them to guarantee the cell is safe so the player doesn’t lose immediately.

Additionally, it allows them to place bombs further away from this starting point. For example, we can ensure the adjacent cells to where the player starts have no bombs, either.

This results in the first click clearing a large area of the grid, allowing the player to proceed strategically and reducing the probability they’ll need to make guesses.

Pooling Image Data

Currently, the cells in our grid are generating surfaces unnecessarily. For example, if our settings specify the grid has 20 bombs, then the bomb images is loaded 20 times, and 20 identical surfaces are generated.

Similarly, we’re rasterizing text surfaces unnecessarily - every cell that shows a 3 image, for example, is generating it’s own surface, which is identical to every other 3.

If a cell ultimately has 3 adjacent bombs, the bomb placement algorithm has it generate 1 and 2 surfaces which it ultimately discards.

For performance reasons, it can be helpful to pool these surfaces together into a shared repository that all the cells can access.

We can optimize this concept even further by pooling the images into a single image, called a texture atlas. The original Microsoft version of Minesweeper might have a texture atlas that looks like this:

Cells can then select the data they want by providing a source rectangle to the SDL_BlitSurface() or SDL_BlitScaled() functions:

1#include "MinesweeperAtlas.h"
2
3// ...
4
5void Render(SDL_Surface* Surface) {
6  SDL_BlitScaled(
7    MinesweeperAtlas::Surface,
8    MinesweeperAtlas::Bomb,
9    Surface,
10    &Destination
11  );
12}
13
14// ...

Difficulty Modes

Most Minesweeper games allow players to choose their preferred difficulty - typically, easy, medium or hard.

Harder difficulties increase the size of the grid, and increase the number of bombs within the grid. It would involve a lot of changes to set our game up to support this. However, it wouldn’t require any new concepts - we know everything we need to know.

The SDL_SetWindowSize() function (official documentation) let’s us programatically resize the window, which can be useful if our grid size changes based on difficulty setting.

Reducing Event Traffic

To keep things simple, our project routed pretty much every event through to every relevant object in our game. This results in a lot of excess traffic, where object’s HandleEvent() functions are invoked with an event the object has no interest in.

Every function call that results in no effect has an unnecessary performance cost, and that’s especially true when the functions are virtual.

An obvious way to reduce this traffic is having each parent check an event is relevant to its children before forwarding it:

1void HandleEvent(const SDL_Event& E){
2  if (isRelevantToChildren(E.type) {
3    for (auto& Child : Children) {
4      Child.HandleEvent(E);
5    }
6  }
7};

However, this limits flexibility. When creating a parent class, we often won’t know what type of children we’ll eventually be managing.

Even if we did know exactly what event types the children are interested in, declaring that within the parent would typically be a bad design.

To keep our code well organised and understandable, the event types that a class is interested in should be managed within that same class. For example, the event types that MinesweeperCell objects are interested in should be declared in MinesweeperCell class.

Objects can then provide that list to their parent, or to some object that is managing event traffic. For example:

1class Child: public EventReceiver {
2  // Subscribe to event types from constructor
3  Child(EventReceiver* Parent) {
4    Parent->SubscribeToEventTypes({
5      UserEvents::GAME_START,
6      UserEvents::GAME_END,
7      UserEvents::CELL_CLEARED,
8      // ...
9    })
10  }
11  
12  // ...
13}

This system can become increasingly elaborate - for example, objects may subscribe or unsubscribe from events at different points during their lifecycle:

1class Child: public EventReceiver {
2  // ...
3  void SetIsDisabled() {
4    // No longer interested in mouse events
5    Parent->UnsubscribeToEventTypes({
6      SDL_MOUSEMOTION,
7      SDL_MOUSEBUTTON
8    })
9  }
10  
11  // ...
12}

Designs that implement these inversions of control are often called publish-subscribe pattern or observer pattern.

Timer and High Score

Usually, Minesweeper tracks how long it takes us to complete a game, and keeps track of our fastest time. Implementing this may require research into some new topics.

The C++ standard library includes chrono, a system for working with time. We covered it in our beginner course:

3D art showing a sundial in a fantasy environment

Dates, Times and Durations

Learn the basics of the chrono library and discover how to effectively manage durations, clocks, and time points

Remembering our best time within a single session is easy, but keeping track of it from one session to the next requires saving the data to the player’s hard drive.

Again, the C++ standard library can help us here. We covered it’s file system utilities in our advanced course:

Working with the File System

Create, delete, move, and navigate through directories and files using the standard library's filesystem module.

Mechanics like these can also be implemented using functions provided by the SDL library. SDL_GetTicks64() (official documentation) can be used to track the time between two events, and RWops (official documentation) can be used to read and write data to the hard drive.

Summary

Well done on finishing your Minesweeper project! We've successfully added flag placement functionality, complete with visual feedback and a counter in the UI.

These final features round out the gameplay, allowing players to mark potential mine locations and strategize their moves.

With all elements now in place, you have a fully-featured Minesweeper game that offers the same engaging puzzle-solving experience as the classic versions.

Congratulations on your achievement!

Was this lesson useful?

Next Lesson

Handling Keyboard Input

Learn how to detect and respond to keyboard input events in your SDL-based applications. This lesson covers key events, key codes, and modifier keys.

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 3 weeks ago

Lesson Contents

Placing Flags

Implement flag placement and tracking to complete your Minesweeper project.

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

Whirlwind Tour of C++ Basics

Setting up an SDL2 Development Environment

Creating an SDL Application

Implementing User Interaction

Rendering Images and Text

Project: Making Minesweeper

37. Placing Flags

Implement flag placement and tracking to complete your Minesweeper project.

Keyboard Input

Mouse Input

Reading and Writing (RWops)

The 2D Rendering API

44.GPUs and Rasterization
45.SDL Renderers

Movement and Physics

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

This course includes:

46 Lessons
100+ Code Samples
91% Positive Reviews
Regularly Updated
Help and FAQ

Next Lesson

Handling Keyboard Input

Learn how to detect and respond to keyboard input events in your SDL-based applications. This lesson covers key events, key codes, and modifier keys.

Contact|Privacy Policy|Terms of Use

Placing Flags

Game Dev with SDL2

Ryan McCombe

Updating Globals

Placing Flags

Rendering Flags

Flag Counter

Complete Code

Globals.h (Edited)

Minesweeper/Cell.h (Edited)

Minesweeper/Cell.cpp (Edited)

Minesweeper/UI.h (Edited)

Minesweeper/FlagCounter.h (New)

Engine/Button.h

Engine/Image.h

Engine/Random.h

Engine/Rectangle.h

Engine/Text.h

Engine/Window.h

Minesweeper/NewGameButton.h

Minesweeper/Grid.h

main.cpp

CMakeLists.txt

Improvement Ideas

Refactoring

Gameplay Improvements

Pooling Image Data

Difficulty Modes

Reducing Event Traffic

Timer and High Score

Dates, Times and Durations

Working with the File System

Summary

Was this lesson useful?

Edit History

References and Related Content

Handling Keyboard Input

Questions and HelpNeed Help?

Ryan McCombe

Placing Flags

Game Dev with SDL2

Whirlwind Tour of C++ Basics

Setting up an SDL2 Development Environment

Creating an SDL Application

Implementing User Interaction

Rendering Images and Text

Project: Making Minesweeper

37.

Placing Flags

Keyboard Input

Mouse Input

Reading and Writing (RWops)

The 2D Rendering API

Movement and Physics

Course Content

Game Dev with SDL2

This course includes:

Handling Keyboard Input