Adding Bombs to the Minesweeper Grid

Updating the game to to place bombs randomly in the grid and render them when cells are cleared.

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

View Full CourseGet Started for Free

Abstract art representing computer programming

Minesweeper: Part 3

Ryan McCombe

Posted 11 months ago

In this part of our Minesweeper tutorial, we'll build upon our existing code to add a crucial element of the game: bombs.

We'll implement the ability to place bombs randomly within our grid and reveal them when cells containing bombs are cleared.

We'll start by updating our global configurations to include new variables for bomb-related events and settings. Then, we'll modify our grid and cell classes to handle bomb placement and rendering.

By the end of this section, you'll have a Minesweeper grid where bombs can be placed and revealed, setting the stage for implementing the game's core mechanics in future parts.

Updating Globals

To begin implementing bombs in our Minesweeper game, we'll first update our Globals.h file with some new variables. These additions will help us manage bomb-related events and configure the game's difficulty:

UserEvents::BOMB_PLACED: This new event type will be dispatched whenever a bomb is placed within a cell. This will allow other cells to keep track of how many bombs are in adjacent cells, which we'll use later to display the correct number.
Config::BOMB_COUNT: This variable will control how many bombs are placed in the grid. By adjusting this number, we can easily change the difficulty of the game - more bombs generally mean a more challenging experience for the player.
Config::BOMB_IMAGE: This string specifies the file name of the icon we want to render in cells that contain a bomb. By defining this in our global configuration, we can easily change the bomb image across our entire game if needed.

1// Globals.h
2
3// ...
4
5namespace UserEvents{
6  // ...
7  inline Uint32 BOMB_PLACED =
8    SDL_RegisterEvents(1);
9}
10
11namespace Config{
12  inline constexpr int BOMB_COUNT{6};
13  // ...
14
15  // Asset Paths
16  inline const std::string BOMB_IMAGE{
17    "Bomb.png"};
18  // ...
19}
20
21// ...

Dealing with Invalid Configurations

When working with our game configuration, it's possible to inadvertently create an invalid setup. For example, imagine if we set BOMB_COUNT to be greater than the total number of cells in our grid:

1inline constexpr int BOMB_COUNT{100};
2inline constexpr int GRID_COLUMNS{8};
3inline constexpr int GRID_ROWS{4};

In this case, we're trying to place 100 bombs in a grid with only 32 cells (8 * 4), which is impossible.

You might want to check for invalid configurations. One way of doing this is with static_assert. This is a compile-time check that ensures certain conditions are met before the program can be compiled.

Here's how static_assert works:

It takes two arguments: a boolean condition and an error message.
If the condition is false, compilation fails with the provided error message.
The condition must be known at compile-time, which our constexpr config variables satisfy.

Here's an example of how you could use static_assert to prevent this invalid configuration:

1// Globals.h
2
3// ...
4
5namespace Config{
6  // Game Settings
7  inline constexpr int BOMB_COUNT{100}; 
8  inline constexpr int GRID_COLUMNS{8};
9  inline constexpr int GRID_ROWS{4};
10  static_assert(
11    BOMB_COUNT < GRID_COLUMNS * GRID_ROWS,
12    "Cannot have more bombs than cells"
13  );
14  
15  // ...
16}
17// ...

1Error: static_assert failed: Cannot have more bombs than cells

Placing Bombs in Random Cells

To implement bomb placement in our grid, we'll update our MinesweeperGrid class with a new PlaceBombs() function. This function will be responsible for randomly selecting cells and placing bombs in them.

Here's how the PlaceBombs() function will work:

We'll create a loop that continues until we've placed the required number of bombs (specified by Config::BOMB_COUNT).
In each iteration, we'll select a random index from our Children vector, which contains all the cells in our grid.
We'll call a new PlaceBomb() function (which we'll add to our MinesweeperCell class later) on the randomly selected cell.
If PlaceBomb() returns true, indicating a successful bomb placement, we'll decrement our counter of bombs to place.
If PlaceBomb() returns false, indicating the selected cell already contains a bomb, we'll continue the loop to try placing the bomb in a different random cell.

This approach ensures that we place the correct number of bombs, and that no cell contains more than one bomb.

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

We'll call PlaceBombs() at the end of the MinesweeperGrid constructor.

1// Minesweeper/Grid.h
2
3// ...
4
5class MinesweeperGrid {
6public:
7  MinesweeperGrid(int x, int y){
8    // ...
9    PlaceBombs();
10  }
11  
12  // ...
13};

Updating Cells to Receive Bombs

Now that we've implemented bomb placement in our grid, we need to update our MinesweeperCell class to handle bombs. We'll make the following changes:

Add a new PlaceBomb() function that returns a bool. This function will be called by MinesweeperGrid when attempting to place a bomb in the cell.
Add a hasBomb member variable to keep track of whether the cell contains a bomb.
Create a GetHasBomb() getter function to allow other parts of our program to check if a cell contains a bomb without directly accessing the hasBomb variable.

Let's update our header file with these three declarations:

1// Minesweeper/Cell.h
2
3// ...
4
5class MinesweeperCell : public Engine::Button {
6public:
7  // ...
8  bool PlaceBomb();
9
10  [[nodiscard]]
11  bool GetHasBomb() const{ return hasBomb; }
12  // ...
13
14private:
15  bool hasBomb{false};
16  // ...
17};

Over in our MinesweeperCell.cpp file, we'll implement the PlaceBomb() function. If the cell already has a bomb, we'll immediately return false, prompting the PlaceBombs() loop back in MinesweeperGrid to choose another cell.

Otherwise, we'll update our hasBomb member variable, report that a bomb has been placed, and return true to inform MinesweeperGrid that a bomb was successfully placed:

1// Minesweeper/Cell.cpp
2
3// ...
4
5bool MinesweeperCell::PlaceBomb(){
6  if (hasBomb) return false;
7  hasBomb = true;
8  ReportEvent(UserEvents::BOMB_PLACED);
9  return true;
10}
11
12// ...

We'll also update our HandleEvent() function to react to bomb placement events.

For now, we'll just log that a bomb was placed, but in future parts, we'll use this to update the count of adjacent bombs for neighboring cells.

1// Minesweeper/Cell.cpp
2
3// ...
4
5void MinesweeperCell::HandleEvent(
6  const SDL_Event& E){
7  if (E.type == UserEvents::CELL_CLEARED) {
8    // TODO
9    std::cout << "A Cell Was Cleared\n";
10  } else if (E.type ==
11    UserEvents::BOMB_PLACED) {
12    // TODO
13    std::cout << "A Bomb was Placed\n";
14  }
15  Button::HandleEvent(E);
16}
17
18// ...

We can now run our program and verify everything is connected correctly by looking at our terminal output. Every time a bomb is placed in a cell, every cell will react to the event, so we should see a long list of logs:

1A Bomb was Placed
2A Bomb was Placed
3A Bomb was Placed
4...

Naturally, we'll replace this logging with more meaningful reactions later.

Rendering Bomb Images

Finally, lets update our program to render the bomb images in the appropriate cells. We'll add a BombImage member variable:

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

Over in our constructor, we'll initialize it. Our Engine::Image class needs to know the position (x and y) and size (w and h) we want the image to be rendered on the surface. It also needs to know the location of the image file. We'll pass all of this information to its constructor:

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    BombImage{
9      x, y, w, h,
10      Config::BOMB_IMAGE}{};
11
12// ...

Finally, we update the Render() method of our MinesweeperCell. If the player has cleared the cell and the cell contains a bomb, we render the image:

1// Minesweeper/Cell.cpp
2
3// ...
4
5void MinesweeperCell::Render(
6  SDL_Surface* Surface){
7  Button::Render(Surface);
8  if (isCleared && hasBomb) {
9    BombImage.Render(Surface);
10  }
11}

If we run our game and clear cells, we should now eventually find a bomb:

Development Helpers

To make future development easier, it would be helpful to know where the bombs are without having to find them by clearing cells. In our Globals.h file, we created a preprocessor definition called SHOW_DEBUG_HELPERS.

We can use this preprocessor definition in our MinesweeperCell::Render() method to display bombs in all cells during development, regardless of whether they've been cleared:

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

When our preprocessor definition is enabled, we will be able to see bombs without clearing cells, which will make future development more convenient:

To enable these debug helpers, ensure the SHOW_DEBUG_HELPERS macro is defined in your Globals.h file. To disable them, simply comment out or remove the #define SHOW_DEBUG_HELPERS line:

1// Globals.h
2
3// #define SHOW_DEBUG_HELPERS 
4
5// ...

Complete Code

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

1#pragma once
2
3#define SHOW_DEBUG_HELPERS
4
5#include <iostream>
6#include <SDL.h>
7#include <string>
8
9namespace UserEvents{
10  inline Uint32 CELL_CLEARED =
11    SDL_RegisterEvents(1);
12  inline Uint32 BOMB_PLACED =
13    SDL_RegisterEvents(1);
14}
15
16namespace Config{
17  // Game Settings
18  inline const std::string GAME_NAME{
19    "Minesweeper"};
20  inline constexpr int BOMB_COUNT{6};
21  inline constexpr int GRID_COLUMNS{8};
22  inline constexpr int GRID_ROWS{4};
23  static_assert(
24    BOMB_COUNT < GRID_COLUMNS * GRID_ROWS,
25    "Cannot have more bombs than cells"
26  );
27
28  // Size and Positioning
29  inline constexpr int PADDING{5};
30  inline constexpr int CELL_SIZE{50};
31
32  inline constexpr int GRID_HEIGHT{
33    CELL_SIZE * GRID_ROWS
34    + PADDING * (GRID_ROWS - 1)
35  };
36
37  inline constexpr int WINDOW_HEIGHT{
38    GRID_HEIGHT + PADDING * 2
39  };
40  inline constexpr int WINDOW_WIDTH{
41    CELL_SIZE * GRID_COLUMNS
42    + PADDING * (GRID_COLUMNS - 1)
43    + PADDING * 2
44  };
45
46  // Colors
47  inline constexpr SDL_Color BACKGROUND_COLOR{
48    170, 170, 170, 255};
49  inline constexpr SDL_Color BUTTON_COLOR{
50    200, 200, 200, 255};
51  inline constexpr SDL_Color BUTTON_HOVER_COLOR{
52    220, 220, 220, 255};
53  inline constexpr SDL_Color
54  BUTTON_CLEARED_COLOR{
55    240, 240, 240, 255};
56
57  // Asset Paths
58  inline const std::string BOMB_IMAGE{
59    "Bomb.png"};
60  inline const std::string FONT{
61    "Rubik-SemiBold.ttf"};
62}
63
64namespace Utils{
65#ifdef SHOW_DEBUG_HELPERS
66  inline void CheckSDLError(
67    const std::string& Msg){
68    const char* error = SDL_GetError();
69    if (*error != '\0') {
70      std::cerr << Msg << " Error: " << error <<
71        '\n';
72      SDL_ClearError();
73    }
74  }
75#endif
76}

1#pragma once
2#include "Globals.h"
3#include "Minesweeper/Cell.h"
4#include "Engine/Random.h"
5
6class MinesweeperGrid {
7public:
8  MinesweeperGrid(int x, int y){
9    using namespace Config;
10    Children.reserve(GRID_COLUMNS * GRID_ROWS);
11    for (int Col{1}; Col <= GRID_COLUMNS; ++
12         Col) {
13      for (int Row{1}; Row <= GRID_ROWS; ++
14           Row) {
15        constexpr int Spacing{
16          CELL_SIZE + PADDING};
17        Children.emplace_back(
18          x + (Spacing) * (Col - 1),
19          y + (Spacing) * (Row - 1),
20          CELL_SIZE, CELL_SIZE, Row, Col
21        );
22      }
23    }
24    PlaceBombs();
25  }
26
27  void Render(SDL_Surface* Surface){
28    for (auto& Child : Children) {
29      Child.Render(Surface);
30    }
31  }
32
33  void HandleEvent(const SDL_Event& E){
34    for (auto& Child : Children) {
35      Child.HandleEvent(E);
36    }
37  }
38
39private:
40  void PlaceBombs(){
41    int BombsToPlace{Config::BOMB_COUNT};
42    while (BombsToPlace > 0) {
43      const size_t RandomIndex{
44        Engine::Random::Int(
45          0, Children.size() - 1
46        )};
47      if (Children[RandomIndex].PlaceBomb()) {
48        --BombsToPlace;
49      }
50    }
51  }
52
53  std::vector<MinesweeperCell> Children;
54};

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

1#include <iostream>
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
12void MinesweeperCell::HandleEvent(
13  const SDL_Event& E){
14  if (E.type == UserEvents::CELL_CLEARED) {
15    // TODO
16    std::cout << "A Cell Was Cleared\n";
17  } else if (E.type ==
18    UserEvents::BOMB_PLACED) {
19    // TODO
20    std::cout << "A Bomb was Placed\n";
21  }
22  Button::HandleEvent(E);
23}
24
25void MinesweeperCell::Render(
26  SDL_Surface* Surface){
27  Button::Render(Surface);
28  if (isCleared && hasBomb) {
29    BombImage.Render(Surface);
30  }
31
32#ifdef SHOW_DEBUG_HELPERS
33  if (hasBomb) { BombImage.Render(Surface); }
34#endif
35}
36
37bool MinesweeperCell::PlaceBomb(){
38  if (hasBomb) return false;
39  hasBomb = true;
40  ReportEvent(UserEvents::BOMB_PLACED);
41  return true;
42}
43
44void MinesweeperCell::ClearCell(){
45  if (isCleared) return;
46  isCleared = true;
47  SetIsDisabled(true);
48  SetColor(Config::BUTTON_CLEARED_COLOR);
49  ReportEvent(UserEvents::CELL_CLEARED);
50}
51
52void MinesweeperCell::ReportEvent(
53  uint32_t EventType){
54  SDL_Event event{EventType};
55  event.user.data1 = this;
56  SDL_PushEvent(&event);
57}
58
59void MinesweeperCell::HandleLeftClick(){
60  ClearCell();
61}

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

Summary

In this part of our Minesweeper tutorial, we've made significant progress in implementing one of the core elements of the game: bombs. We are now:

Implementing a system for randomly placing bombs in the grid.
Updating cells to track whether they contain a bomb.
Rendering bomb images when cells are cleared.
Adding a debug helper to visualize bomb placement during development.

In the next part of our tutorial, we'll build upon this foundation to implement the ability for cleared cells to display the number of bombs in neighboring cells. This feature is essential for providing players with the information they need to deduce the location of bombs and clear the grid safely.

We'll modify our cell class to keep track of neighboring bombs, update this count when bombs are placed, and display the count when a cell is cleared. This will involve working with events, updating our rendering logic, and introducing new graphical elements to represent the numbers.

Free and Unlimited Access