How to create a Minesweeper board in C++?

Hello everyone, today I am going to show you how to create a Minesweeper game-board in C++ programming language. This tutorial will cover up the basic algorithm of the game but will not cover how to make it playable or user-interactable.

So let's start with basic: What is Minesweeper?

Minesweeper is a historical single-player puzzle game, firstly introduced around 1960s. The objective of the game is to clear a rectangular board containing hidden "mines" or bombs without detonating any of them, with help from clues about the number of neighboring mines in each field.

As you can see in the picture above, numbers are showing us how many bombs there are, in the neighbour fields.

So what we have to do is:

• Firstly, we will create a 2D vector in our code with rows and columns given by the user.
• Then, we will create random bombs with the number of bombs given by the user again.
• After that, we will add the numbers around each bomb.
• Lastly, we will show 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 have created our main class and the prototypes of the methods. Now we will go step by step to create our methods 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 have declared the constructor for our class and initialize the private variables with the values given by the user. After that, we have told our program to run the methods below in order. Now let's take a look at these methods.

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

We create the table by resizing the vector with the values given by the user. Now it's time to add some random bombs.

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 designed by me so let me explain. First, we create a vector of integers that is size of the table. Let's assume the size is 20 rows * 10 columns = 200 Then our vector of integers should look: [1,2,3,4....200]

Then we will shuffle this vector with the shuffle function. And we will seed the shuffle function with the system clock so that it runs correctly. After the shuffling, let's assume the vector is now: [20,32,50,120,153,....1,12]

Now user tells us that he needs 3 bombs for example. So we get the first 3 values of the vector, which is [20,32,50] in this case. Now we have bombs at 20th, 32nd and 50th squares. Simple as that. In the next method, we will see how to get the row and the column of these squares.

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 simple math here. We have to find the column at first, otherwise we cannot find the row.

find_column formula is: the remainder of (square/total_column) But if the square is equals to total_column which will give the output of 0, then we set the column of it to the total_column.

find_row formula is: [ (square-column) / total_column ] + 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; } }

Here is where the magic happens. We are looping through each of the bombs in the vector of bombs. Then we calculate the row and the column of the bomb. After that, we add +1 at the neighbours of the bomb if the neighbour is not out of bounds.

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 are printing the vector in the Command Prompt by checking if the square is a bomb, a number or empty. Then we also print out the bomb locations.

Now we are all set to run our program. We need main.cpp to run the program of course so let's create that.

#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 are performing an infinite loop with 3 seconds sleep time to see those brand-new randomly created boards.

That's it! We have perfectly created our app. You can use this algorithm, implement it, change it or do whatever you'd like to do. I have this project on my Github Repository and you can fork it there too. As you might have guessed, I love Minesweeper. There is a Minesweeper app that I have created in Javascript. You can play it too.

Thank you for your time, and see you again in the next blog posts. Take care!