Adjacent Cells and Bomb Counting

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 this method is called on.

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.

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 add 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// ...

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

Globals.h (Edited)

Minesweeper/Cell.h (Edited)

Minesweeper/Cell.cpp (Edited)

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.