Adding Bombs to the Grid

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:

1. 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.
2. Add a hasBomb member variable to keep track of whether the cell contains a bomb.
3. 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#pragma once
2#include <SDL3/SDL.h>
3#include "Engine/Button.h"
4#include "Engine/Image.h"
5
6class MinesweeperCell : public Engine::Button {
7public:
8  // ...
9  bool PlaceBomb();
10
11  [[nodiscard]]
12  bool GetHasBomb() const{ return hasBomb; }
13  // ...
14
15private:
16  // ...
17  bool hasBomb{false};
18  // ...
19};

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#include <iostream>
2#include <SDL3/SDL.h>
3#include "Minesweeper/Cell.h"
4#include "Globals.h"
5
6// ...
7
8bool MinesweeperCell::PlaceBomb(){
9  if (hasBomb) return false;
10  hasBomb = true;
11  ReportEvent(UserEvents::BOMB_PLACED);
12  return true;
13}
14
15// ...

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

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

We'll replace this logging with more meaningful reactions later.

Finally, lets update our program to render the bomb images in the appropriate cells. We'll add a BombImage member variable. Because Engine::Image has its copy constructor deleted, we must store it as a pointer, such as a std::unique_ptr. This allows our MinesweeperCell to be movable, which is a requirement for it to be storable in a std::vector.

We'll create more elegant ways of handling images and other assets later in the course.

1#pragma once
2#include <SDL3/SDL.h>
3#include <memory>
4#include "Engine/Button.h"
5#include "Engine/Image.h"
6
7class MinesweeperCell : public Engine::Button {
8 // ...
9
10private:
11  //...
12  std::unique_ptr<Engine::Image> BombImage;
13};

Over in our constructor, we'll initialize our image. 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 on our hard drive. We'll pass all of this information to its constructor using std::make_unique:

1#include <iostream>
2#include <memory>
3#include <SDL3/SDL.h>
4#include "Minesweeper/Cell.h"
5#include "Globals.h"
6
7MinesweeperCell::MinesweeperCell(
8  int x, int y, int w, int h, int Row, int Col)
9  : Button{x, y, w, h}, Row{Row}, Col{Col} {
10    BombImage = std::make_unique<Engine::Image>(
11      x, y, w, h,
12      Config::BOMB_IMAGE
13    );
14};
15
16// ...

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// ...
2
3void MinesweeperCell::Render(
4  SDL_Surface* Surface){
5  Button::Render(Surface);
6  if (isCleared && hasBomb) {
7    BombImage->Render(Surface);
8  }
9}
10
11// ...

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

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// ...
2
3void MinesweeperCell::Render(
4  SDL_Surface* Surface){
5  Button::Render(Surface);
6  if (isCleared && hasBomb) {
7    BombImage->Render(Surface);
8  }
9#ifdef SHOW_DEBUG_HELPERS
10  else if (hasBomb) {
11    BombImage->Render(Surface);
12  }
13#endif
14}
15
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// #define SHOW_DEBUG_HELPERS 
2
3// ...

Creating development helpers and tools like this is generally a good idea. The more complex the project, the more effort we should put into creating these systems. They'll save us time in the long run, and make the experience of working on the project much more pleasant.

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 part of our tutorial, we've made progress in implementing one of the core elements of the game: bombs. We are now:

1. Implementing a system for randomly placing bombs in the grid.
2. Updating cells to track whether they contain a bomb.
3. Rendering bomb images when cells are cleared.
4. 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 provides 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.