Adjacent Cells and Bomb Counting

In this part of our Minesweeper tutorial, we'll build upon our previous code by adding the ability to track and display the count of bombs in adjacent cells.

This feature provides players with the information they need to make informed decisions during gameplay.

We’ll also allow cells to be cleared when there are no adjacent bombs, allowing players to clear large sections of the grid automatically.

Determining Cell Adjacency

To implement the adjacent bomb count feature, we first need to determine if a MinesweeperCell is adjacent to another MinesweeperCell.

We'll add a new method to our MinesweeperCell class called isAdjacent. This method will take another MinesweeperCell pointer as an argument and return a boolean indicating whether that cell is adjacent to the cell that is calling the method.

1// Minesweeper/Cell.h
2
3// ...
4
5class MinesweeperCell : public Engine::Button {
6// ...
7
8private:
9  bool isAdjacent(MinesweeperCell* Other) const;
10  // ...
11};

Our MinesweeperCell objects already know where they are in the grid, thanks to the Row and Col values (and associated GetRow() and GetCol() getters) provided when the MinesweeperGrid constructs them.

We can use this to implement our isAdjacent method:

1// Minesweeper/Cell.cpp
2
3// ...
4
5bool MinesweeperCell::isAdjacent(
6  MinesweeperCell* Other) const{
7  return !(Other == this)
8    && std::abs(GetRow() - Other->GetRow()) <= 1
9    && std::abs(GetCol() - Other->GetCol()) <= 1;
10}

If it’s not clear what this logic is doing, we can imagine that two cells, A and B, are adjacent if they are within one row and one column of each other - that is:

• A.Row - B.Row is either -1, 0 or 1, and
• A.Col - B.Col is either -1, 0 or 1

We can use the concept of absolute value to simplify this. The absolute value of a number is how far away the number is from 0. Typically, we can imagine this as simply removing the negative sign from a number, if it had one.

The std::abs function receives a number and returns its absolute value - for example, std::abs(-1) will return 1.

So, equivalently, two cells are adjacent if:

• std::abs(A.Row - B.Row) is <= 1, and
• std::abs(A.Col - B.Col) is <= 1

Note that if std::abs(A.Row - B.Row) and std::abs(A.Col - B.Col) are both 0, that means A and B are in the exact same position in the grid.

In the context of our game, that means the the two cells are the same object. We don’t want a cell to be considered adjacent to itself so, if Other == this, isAdjacent() will return false.

Keeping Track of Adjacent Bombs

In the previous part, our MinesweeperCell objects were pushing an SDL_Event to the event queue whenever they received a bomb. Every cell is notified of this event, so they can use them to keep track of the number of adjacent bombs.

To implement this, we'll adding two new elements to our MinesweeperCell class:

1. An AdjacentBombs integer to store the count of adjacent bombs.
2. A HandleBombPlaced method to receive the event, and update the AdjacentBombs count if the event was created by an adjacent cell.

1// Minesweeper/Cell.h
2
3// ...
4
5class MinesweeperCell : public Engine::Button {
6// ...
7
8private:
9  void HandleBombPlaced(const SDL_UserEvent& E);
10  int AdjacentBombs{0};
11  
12  // ...
13};

We’ll call the HandleBombPlaced() method whenever a bomb is placed on the board. The ReportEvent() method our our MinesweeperCell class is attaching a pointer to the cell that created each event. This pointer is in the data1 variable of the SDL_UserEvent.

data1 is technically a void pointer (void*), but we know it’s pointing to a MinesweeperCell, so we can statically cast it:

1MinesweeperCell* Cell{
2  static_cast<MinesweeperCell*>(E.data1)
3};

We’ll pass this MinesweeperCell* off to our isAdjacent function. If isAdjacent() returns true, that means a bomb was placed in an adjacent cell, and we’ll update our AdjacentBombs counter accordingly:

1// Minesweeper/Cell.cpp
2
3// ...
4
5void MinesweeperCell::HandleBombPlaced(
6  const SDL_UserEvent& E){
7  MinesweeperCell* Cell{
8    static_cast<MinesweeperCell*>(E.data1)
9  };
10  if (isAdjacent(Cell)) {
11    ++AdjacentBombs;
12  }
13}

Finally, we need to call HandleBombPlaced at the appropriate time, so we’ll update the HandleEvent method. Previously, this method was simply logging to the terminal when a bomb was placed. Now, it will call our new HandleBombPlaced function:

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 == UserEvents::BOMB_PLACED) {
11    HandleBombPlaced(E.user);
12  }
13  Button::HandleEvent(E);
14}
15
16// ...

Rendering Adjacent Bomb Count

To visually represent the number of adjacent bombs, we'll update our game to render this count on cleared cells that have at least one adjacent bomb.

We want the count to have a different color depending on the number of adjacent bombs, so let’s add a TEXT_COLORS array to our Config namespace in Globals.h.

This array maps the number of adjacent bombs to a specific color. We won’t render any text if there are no adjacent bombs, so TEXT_COLORS[0] will technically not be used, but we’ll include it anyway as indices must start at 0:

1// Globals.h
2
3// ...
4
5namespace Config{
6  // ...
7  
8  // Text color based on number of surrounding bombs 
9  inline const std::vector<SDL_Color> TEXT_COLORS{
10    /* 0 */ {0, 0, 0, 255}, // Unused
11    /* 1 */ {0, 1, 249, 255},
12    /* 2 */ {1, 126, 1, 255},
13    /* 3 */ {250, 1, 2, 255},
14    /* 4 */ {1, 0, 128, 255},
15    /* 5 */ {129, 1, 0, 255},
16    /* 6 */ {0, 128, 128, 255},
17    /* 7 */ {0, 0, 0, 255},
18    /* 8 */ {128, 128, 128, 255}
19  };
20  
21  // ...
22}
23
24// ...

We're using the Engine::Text class to handle the rendering of the adjacent bomb count. This class takes care of creating and rendering text surfaces for us. Let’s add an Engine::Text member to each of our MinesweeperCell objects:

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

In the MinesweeperCell constructor, we initialize the Text object with its position (x and y), size (w and h), the text to render (which is "0" for now) and its corresponding color.

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    Text{
12      x, y, w, h,
13      std::to_string(AdjacentBombs),
14      Config::TEXT_COLORS[AdjacentBombs]}{};
15      
16// ...

Whenever a bomb is placed adjacent to the cell, we’ll call the SetText() method of Engine::Text, passing the new value, and the corresponding colour:

1// Minesweeper/Cell.cpp
2
3// ...
4
5void MinesweeperCell::HandleBombPlaced(
6  const SDL_UserEvent& E){
7  MinesweeperCell* Cell{
8    static_cast<MinesweeperCell*>(E.data1)
9  };
10  if (isAdjacent(Cell)) {
11    ++AdjacentBombs;
12    Text.SetText(std::to_string(AdjacentBombs),
13      Config::TEXT_COLORS[AdjacentBombs]);
14  }
15}

Finally, we'll updated the Render method to render the text when a cell is cleared and has adjacent bombs:

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  } else if (isCleared && AdjacentBombs > 0) {
11    Text.Render(Surface);
12  }
13#ifdef SHOW_DEBUG_HELPERS
14  else if (hasBomb) { BombImage.Render(Surface); }
15#endif
16}

If we run our application and clear cells that are adjacent to bombs, we should now see the correct number display, in the correct color:

Remember, the reason we can see the bombs is because of the preprocessor directive enabling debug helpers. If we want to test the game as a player would, we can comment out that declaration:

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

Automatically Clearing Adjacent Cells

In Minesweeper, when a cell with no adjacent bombs is cleared, all adjacent cells are automatically cleared as well. This creates a cascading effect that can clear large areas of the board at once.

To implement this feature, we'll follow a similar pattern as before. Our MinesweeperCell objects are already being notified when any cell is cleared.

We’ll add a HandleCellCleared method to implement the automatic-clearing behaviour where appropriate:

1// Minesweeper/Cell.h
2
3// ...
4
5class MinesweeperCell : public Engine::Button {
6// ...
7
8private:
9  void HandleCellCleared(const SDL_UserEvent& E);
10  
11  // ...
12};

As before, our implementation will static_cast the data1 void pointer to a MinesweeperCell*.

We check if the cell that was cleared had a bomb. If it does, we don’t want to clear any adjacent cells, as the game is effectively over. We’ll implement the game-over logic in the next part.

If the cell that was cleared did not have a bomb, is adjacent to this cell, and it had no adjacent bombs, we’ll clear this cell too:

1// Minesweeper/Cell.cpp
2
3// ...
4
5void MinesweeperCell::HandleCellCleared(
6  const SDL_UserEvent& E){
7  MinesweeperCell* Cell{
8    static_cast<MinesweeperCell*>(E.data1)
9  };
10  
11  
12  if (Cell->hasBomb) return;
13
14  if (
15    isAdjacent(Cell) &&
16    Cell->AdjacentBombs == 0
17  ) {
18    ClearCell();
19  }
20}

Remember, the ClearCell() method creates further UserEvents::CELL_CLEARED events, causing the chain reaction that allows large areas of the board to be cleared automatically.

Finally, let’s update our HandleEvent() method to forward UserEvents::CELL_CLEARED to our new HandleCellCleared() method:

1//
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  }
13  Button::HandleEvent(E);
14}

With these changes, we should now be able to click on an area of our grid that does not have any nearby bombs, and see a chain reaction clearing a large area of the board automatically:

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

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

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  }
24  Button::HandleEvent(E);
25}
26
27void MinesweeperCell::Render(
28  SDL_Surface* Surface){
29  Button::Render(Surface);
30  if (isCleared && hasBomb) {
31    BombImage.Render(Surface);
32  } else if (isCleared && AdjacentBombs > 0) {
33    Text.Render(Surface);
34  }
35
36#ifdef SHOW_DEBUG_HELPERS
37  else if (hasBomb) { BombImage.Render(Surface); }
38#endif
39}
40
41void MinesweeperCell::Reset(){
42  isCleared = false;
43  hasBomb = false;
44  AdjacentBombs = 0;
45  SetIsDisabled(false);
46  SetColor(Config::BUTTON_COLOR);
47}
48
49bool MinesweeperCell::PlaceBomb(){
50  if (hasBomb) return false;
51  hasBomb = true;
52  ReportEvent(UserEvents::BOMB_PLACED);
53  return true;
54}
55
56void MinesweeperCell::ClearCell(){
57  if (isCleared) return;
58  isCleared = true;
59  SetIsDisabled(true);
60  SetColor(Config::BUTTON_CLEARED_COLOR);
61  ReportEvent(UserEvents::CELL_CLEARED);
62}
63
64void MinesweeperCell::ReportEvent(
65  uint32_t EventType){
66  SDL_Event event{EventType};
67  event.user.data1 = this;
68  SDL_PushEvent(&event);
69}
70
71void MinesweeperCell::HandleCellCleared(
72  const SDL_UserEvent& E){
73  MinesweeperCell* Cell{
74    static_cast<MinesweeperCell*>(E.data1)
75  };
76  if (Cell->hasBomb) return;
77
78  if (isAdjacent(Cell) && Cell->AdjacentBombs ==
79    0) { ClearCell(); }
80}
81
82void MinesweeperCell::HandleBombPlaced(
83  const SDL_UserEvent& E){
84  MinesweeperCell* Cell{
85    static_cast<MinesweeperCell*>(E.data1)
86  };
87  if (isAdjacent(Cell)) {
88    ++AdjacentBombs;
89    Text.SetText(std::to_string(AdjacentBombs),
90                 Config::TEXT_COLORS[
91                   AdjacentBombs]);
92  }
93}
94
95bool MinesweeperCell::isAdjacent(
96  MinesweeperCell* Other) const{
97  return !(Other == this)
98    && std::abs(Other->GetRow() - Row) <= 1
99    && std::abs(Other->GetCol() - Col) <= 1;
100}
101
102void MinesweeperCell::HandleLeftClick(){
103  ClearCell();
104}

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

Summary

In this part of the tutorial, we've significantly enhanced our Minesweeper game by implementing the adjacent bomb count feature.

We've added methods to determine cell adjacency, keep track of adjacent bombs, render the bomb count, and automatically clear adjacent empty cells.

These additions bring our game closer to a fully functional Minesweeper implementation.

In the next part, we'll focus on detecting and reacting to win and lose conditions, which will complete the core gameplay loop of our Minesweeper game.

Next Lesson

Ending and Restarting Games

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

ContinueView Course