How to create a Minesweeper board in C++?

Hello everyone! Today, I'm going to show you how to build a Minesweeper game board in C++. This tutorial covers the core algorithm behind the game, but will not cover making it playable or interactive.

Let's start with the basics: What is Minesweeper?

Minesweeper is a classic single-player puzzle game, first introduced in the 1960s. The objective is to clear a rectangular board containing hidden mines without detonating any of them, using numerical clues that indicate how many mines are adjacent to each cell.

As shown in the picture above, each number tells us how many bombs are present in the surrounding fields.

Here's what we need to do:

• First, we'll create a 2D vector with the number of rows and columns provided by the user.
• Then, we'll randomly place bombs according to the bomb count specified by the user.
• After that, we'll calculate and assign numbers to the cells surrounding each bomb.
• Finally, we'll display the board in the command prompt.

Let's create our Minesweeper Class in C++. We have 2 files: Minesweeper.h and Minesweeper.cpp

#pragma once #include <iostream> //to show in command prompt #include <vector> //to create 2D Vector #include <algorithm> //to create random bombs #include <random> //to create random bombs #include <chrono> //to create random bombs #include <windows.h> //to Sleep() using namespace std; class Minesweeper { private: int rows; //rows, given by the user int columns; //columns, given by the user int max_size; //rows*columns int bomb_count; //total bombs, given by the user vector<vector<int>> table; //2D Vector vector<int> bombs; //the vector that contains locations of the bombs int find_column(int); //find the column of a field int find_row(int,int); //find the row of a field, with the known column void create_table(); // 1. Create table void add_bombs(); //2. Create random bombs void add_numbers(); //3. Add numbers around bombs void show_table(); //4. Show the table in Command Prompt public: //Default constructor Minesweeper(int columns_get=9, int rows_get=9, int bomb_count_get=10); //Default destructor ~Minesweeper(); };

We've defined our main class along with the method prototypes. Now we'll go through each method step by step in Minesweeper.cpp.

#include "Minesweeper.h" //Constructor Minesweeper::Minesweeper(int columns_get, int rows_get, int bomb_count_get): rows{rows_get}, columns{columns_get}, max_size{rows*columns}, bomb_count{bomb_count_get} { //initialize the variables //then run the methods below in order create_table(); // 1. create table; add_bombs(); // 2. add bombs; add_numbers(); // 3. add numbers; show_table(); // 4. show table; } //We don't need any destructors in this case Minesweeper::~Minesweeper() {}

We've defined the constructor, initialized the private variables with the user-provided values, and instructed the program to execute each method in order. Now let's take a closer look at those methods.

void Minesweeper::create_table(){ //resize the table //with the given values of "row" and "column" table.resize(rows,vector<int>(columns, 0)); }

We initialize the table by resizing the vector using the dimensions provided by the user. Next, it's time to place some bombs at random.

void Minesweeper::add_bombs(){ // Assume rows=20 columns=10 // so max_size=rows*columns // max_size=200 in this case // create a vector of integers called 'bombs' [1,2,3,4,5....,199,200] for(int i{1}; i<=max_size; ++i){ bombs.push_back(i); } // feed the shuffle function by the system clock unsigned seed = chrono::system_clock::now().time_since_epoch().count(); // because we want random bombs, we need to shuffle // shuffle bombs vector [1,2,3,4,5....,199,200] // e.g. output [20,32,50,120,153,.....1,12] shuffle(bombs.begin(), bombs.end(), default_random_engine(seed)); // user asks 3 bombs to be generated for example // bomb_count=3 // then the expected output of bombs: [20,32,50] // now we have 3 bombs at the 20th, 32nd and 50th squares bombs.reserve(bomb_count); bombs.resize(bomb_count); }

This algorithm is one of my own design, so let me walk you through it. First, we create an integer vector with as many elements as there are cells on the board. Assuming a size of 20 rows × 10 columns = 200, the vector would look like: [1, 2, 3, 4 ... 200]

We then shuffle this vector using the shuffle function, seeded with the system clock to ensure randomness. After shuffling, the vector might look something like: [20, 32, 50, 120, 153, ... 1, 12]

If the user requests 3 bombs, we simply take the first 3 values — [20, 32, 50] — meaning bombs are placed at the 20th, 32nd, and 50th cells. Simple as that. In the next method, we'll see how to determine the row and column of each of those cells.

int Minesweeper::find_column(int a){ //calculate the column by the given square number int column_of_it{0}; if(a%columns==0){ column_of_it = columns; }else{ column_of_it = a % columns; } return column_of_it; } int Minesweeper::find_row(int a, int column){ //calculate the row by the given square number and the column //we have to find_column first in order to find_row int row_of_it { ((a-column)/columns)+1 }; return row_of_it; }

This is straightforward math. The column must be found first, as it's required to calculate the row.

The find_column formula is: the remainder of (square ÷ total_columns). However, if the square number is an exact multiple of total_columns — which would yield 0 — we set the column to total_columns instead.

The find_row formula is: [ (square − column) ÷ total_columns ] + 1

void Minesweeper::add_numbers(){ // add numbers int column_of_the_bomb_real{}; int row_of_the_bomb_real{}; int column_of_the_bomb{}; //for vector starting at 0 int row_of_the_bomb{}; //for vector starting at 0 for(auto bomb: bombs){ //for each of the bombs //find the column of the bomb column_of_the_bomb_real = find_column(bomb); //find the row of the bomb row_of_the_bomb_real = find_row(bomb, column_of_the_bomb_real); //for vector starting at 0 column_of_the_bomb = column_of_the_bomb_real-1; //for vector starting at 0 row_of_the_bomb = row_of_the_bomb_real-1; // add the numbers around each bomb // if statements are checking for the edges of the table // the areas around one bomb look like this: // 1 2 3 // 4 * 5 // 6 7 8 //for area "1" if(row_of_the_bomb != 0 && column_of_the_bomb != 0) //check for edge table[row_of_the_bomb-1][column_of_the_bomb-1] += 1; //for area "2" if(row_of_the_bomb != 0) //check for edge table[row_of_the_bomb-1][column_of_the_bomb] += 1; //for area "3" if(row_of_the_bomb != 0 && column_of_the_bomb != columns-1) //check for edge table[row_of_the_bomb-1][column_of_the_bomb+1] += 1; //for area "4" if(column_of_the_bomb != 0) //check for edge table[row_of_the_bomb][column_of_the_bomb-1] += 1; //for area "5" if(column_of_the_bomb != columns-1) //check for edge table[row_of_the_bomb][column_of_the_bomb+1] += 1; //for area "6" if(row_of_the_bomb != rows-1 && column_of_the_bomb != 0) //check for edge table[row_of_the_bomb+1][column_of_the_bomb-1] += 1; //for area "7" if(row_of_the_bomb != rows-1) //check for edge table[row_of_the_bomb+1][column_of_the_bomb] += 1; //for area "8" if(row_of_the_bomb != rows-1 && column_of_the_bomb != columns-1) //check for edge table[row_of_the_bomb+1][column_of_the_bomb+1] += 1; } }

This is where the magic happens. We iterate over each bomb in the bombs vector, calculate its row and column, then increment by +1 all neighboring cells — as long as they're within the bounds of the board.

void Minesweeper::show_table(){ //print the 2D vector table int square_of_the_bomb{0}; for (int r = 1; r <= rows; r++) { for (int c = 1; c <= columns; c++){ // find the square of the bomb formula // (by given row and column) square_of_the_bomb = ((r-1)*columns)+c; if( find(bombs.begin(), bombs.end(), square_of_the_bomb) != bombs.end() ){ //if the square is bomb, print * cout << "*" << " "; }else if(table[r-1][c-1] == 0){ //if the square is empty, print white space cout << " "; }else{ //if the square is number, print number cout << table[r-1][c-1] << " "; } } cout << endl; } //print the bomb locations cout << endl << "[ "; for(auto a:bombs) cout << a << ", "; cout << "]" << endl; }

In this method, we print the board to the command prompt by checking whether each cell is a bomb, a number, or empty. We also print the bomb locations at the end.

We're all set to run the program. We just need a main.cpp to tie everything together.

#include "Minesweeper.h" int main(){ while(true){ //create random tables continiously on the heap //30 rows 16 columns and 55 bombs Minesweeper *app = new Minesweeper(30,16,55); delete app; cout << endl; Sleep( 3000 ); //wait for 3 sec } return 0; }

We run an infinite loop with a 3-second delay between iterations so we can watch freshly generated random boards appear one after another.

And that's it! The board generator is complete. Feel free to use this algorithm, build on it, modify it, or take it in whatever direction you like. The full project is available on my GitHub repository — feel free to fork it. And if you're a Minesweeper fan like me, I also built a fully playable version in JavaScript. Give it a try!

Thank you for your time, and I'll see you in the next post. Take care!