main.cpp

#include<bits/stdc++.h>
using namespace std;

#define BEGINNER 0
#define INTERMEDIATE 1
#define ADVANCED 2
#define MAXSIDE 25
#define MAXMINES 99
#define MOVESIZE 526 // (25 * 25 - 99)

int SIDE ; // side length of the board
int MINES ; // number of mines on the board

// Function to check whether given cell (row, col)
// is a valid cell or not
bool isValid(int row, int col){
	// Returns true if row number and column number
	// is in range
	return (row >= 0) && (row < SIDE) &&
		(col >= 0) && (col < SIDE);
}

// Function to check whether given cell (row, col)
// has a mine or not.
bool isMine (int row, int col, char board[][MAXSIDE]){
	if (board[row][col] == '*')
		return (true);
	else
		return (false);
}

// A Function to get the user's move
void makeMove(int *x, int *y){
	// To take the input move
	printf("Enter your move, (row, column) -> ");
	scanf("%d %d", x, y);
	return;
}

// A Function to print the current gameplay board
void printBoard(char myBoard[][MAXSIDE]){
	int i, j;
	printf (" ");
	for (i=0; i<SIDE; i++)
		printf (" %d", i);
	printf ("\n");
	for (i=0; i<SIDE; i++){
		printf ("%d ", i);
		for (j=0; j<SIDE; j++)
			printf ("%c ", myBoard[i][j]);
		printf ("\n");
	}
	return;
}

// A Function to count the number of
// mines in the adjacent cells
int countAdjacentMines(int row, int col, int mines[][2], char realBoard[][MAXSIDE]){
	int i;
	int count = 0;

        // 1st Neighbour (North)
		// Only process this cell if this is a valid one
		if (isValid (row-1, col) == true){
			if (isMine (row-1, col, realBoard) == true)
			count++;
		}

        // 2nd Neighbour (South)
		// Only process this cell if this is a valid one
		if (isValid (row+1, col) == true){
			if (isMine (row+1, col, realBoard) == true)
			count++;
		}

        // 3rd Neighbour (East)
		// Only process this cell if this is a valid one
		if (isValid (row, col+1) == true){
			if (isMine (row, col+1, realBoard) == true)
			count++;
		}

        // 4th Neighbour (West)
		// Only process this cell if this is a valid one
		if (isValid (row, col-1) == true){
			if (isMine (row, col-1, realBoard) == true)
			count++;
		}

        // 5th Neighbour (North-East)
		// Only process this cell if this is a valid one
		if (isValid (row-1, col+1) == true){
			if (isMine (row-1, col+1, realBoard) == true)
			count++;
		}

        // 6th Neighbour (North-West)
		// Only process this cell if this is a valid one
		if (isValid (row-1, col-1) == true){
			if (isMine (row-1, col-1, realBoard) == true)
			count++;
		}

        // 7th Neighbour (South-East)
		// Only process this cell if this is a valid one
		if (isValid (row+1, col+1) == true){
			if (isMine (row+1, col+1, realBoard) == true)
			count++;
		}

        // 8th Neighbour (South-West)
		// Only process this cell if this is a valid one
		if (isValid (row+1, col-1) == true){
			if (isMine (row+1, col-1, realBoard) == true)
			count++;
		}
	return (count);
}

// A Recursive Function to play the Minesweeper Game
bool playMinesweeperUtil(char myBoard[][MAXSIDE], char realBoard[][MAXSIDE], int mines[][2], int row, int col, int *movesLeft){

	// Base Case of Recursion
	if (myBoard[row][col] != '-')
		return (false);
	int i, j;
	// You opened a mine
	// You are going to lose
	if (realBoard[row][col] == '*'){
		myBoard[row][col]='*';
		for (i=0; i<MINES; i++)
			myBoard[mines[i][0]][mines[i][1]]='*';
		printBoard (myBoard);
		printf ("\nYou lost!\n");
		return (true) ;
	}
	else{
		// Calculate the number of adjacent mines and put it
		// on the board
		int count = countAdjacentMines(row, col, mines, realBoard);
		(*movesLeft)--;

		myBoard[row][col] = count + '0';

		if (!count){

            //1st Neighbour (North) 

			// Only process this cell if this is a valid one
			if (isValid (row-1, col) == true){
				if (isMine (row-1, col, realBoard) == false)
				playMinesweeperUtil(myBoard, realBoard, mines, row-1, col, movesLeft);
			}

			// 2nd Neighbour (South) 

			// Only process this cell if this is a valid one
			if (isValid (row+1, col) == true){
				if (isMine (row+1, col, realBoard) == false)
					playMinesweeperUtil(myBoard, realBoard, mines, row+1, col, movesLeft);
			}

			// 3rd Neighbour (East)

			// Only process this cell if this is a valid one
			if (isValid (row, col+1) == true){
				if (isMine (row, col+1, realBoard) == false)
					playMinesweeperUtil(myBoard, realBoard, mines, row, col+1, movesLeft);
			}

			// 4th Neighbour (West)

			// Only process this cell if this is a valid one
			if (isValid (row, col-1) == true){
				if (isMine (row, col-1, realBoard) == false)
					playMinesweeperUtil(myBoard, realBoard, mines, row, col-1, movesLeft);
			}

			// 5th Neighbour (North-East)

			// Only process this cell if this is a valid one
			if (isValid (row-1, col+1) == true){
				if (isMine (row-1, col+1, realBoard) == false)
					playMinesweeperUtil(myBoard, realBoard, mines, row-1, col+1, movesLeft);
			}

			// 6th Neighbour (North-West)

			// Only process this cell if this is a valid one
			if (isValid (row-1, col-1) == true){
				if (isMine (row-1, col-1, realBoard) == false)
					playMinesweeperUtil(myBoard, realBoard, mines, row-1, col-1, movesLeft);
			}

			// 7th Neighbour (South-East)

			// Only process this cell if this is a valid one
			if (isValid (row+1, col+1) == true){
				if (isMine (row+1, col+1, realBoard) == false)
					playMinesweeperUtil(myBoard, realBoard, mines, row+1, col+1, movesLeft);
			}

			// 8th Neighbour (South-West)

			// Only process this cell if this is a valid one
			if (isValid (row+1, col-1) == true){
				if (isMine (row+1, col-1, realBoard) == false)
					playMinesweeperUtil(myBoard, realBoard, mines, row+1, col-1, movesLeft);
			}
		}
		return (false);
	}
}

// A Function to place the mines randomly
// on the board
void placeMines(int mines[][2], char realBoard[][MAXSIDE])
{
	bool mark[MAXSIDE*MAXSIDE];
	memset (mark, false, sizeof (mark));

	// Continue until all random mines have been created.
	for (int i=0; i<MINES; ){
		int random = rand() % (SIDE*SIDE);
		int x = random / SIDE;
		int y = random % SIDE;

		// Add the mine if no mine is placed at this
		// position on the board
		if (mark[random] == false){
			// Row Index of the Mine
			mines[i][0]= x;
			// Column Index of the Mine
			mines[i][1] = y;

			// Place the mine
			realBoard[mines[i][0]][mines[i][1]] = '*';
			mark[random] = true;
			i++;
		}
	}
	return;
}

// A Function to initialise the game
void initialise(char realBoard[][MAXSIDE], char myBoard[][MAXSIDE]){
	// Initiate the random number generator so that
	// the same configuration doesn't arises
	srand(time (NULL));

	// Assign all the cells as mine-free
	for (int i=0; i<SIDE; i++){
		for (int j=0; j<SIDE; j++){
			myBoard[i][j] = realBoard[i][j] = '-';
		}
	}
	return;
}

// A Function to cheat by revealing where the mines are
// placed.
void cheatMinesweeper (char realBoard[][MAXSIDE]){
	printf ("The mines locations are-\n");
	printBoard (realBoard);
	return;
}

// A function to replace the mine from (row, col) and put
// it to a vacant space
void replaceMine (int row, int col, char board[][MAXSIDE]){
	for (int i=0; i<SIDE; i++){
		for (int j=0; j<SIDE; j++){
            // Find the first location in the board
            // which is not having a mine and put a mine
            // there.
            if (board[i][j] != '*'){
                board[i][j] = '*';
                board[row][col] = '-';
                return;
            }
        }
	}
	return;
}

// A Function to play Minesweeper game
void playMinesweeper (){
	// Initially the game is not over
	bool gameOver = false;

	// Actual Board and My Board
	char realBoard[MAXSIDE][MAXSIDE], myBoard[MAXSIDE][MAXSIDE];

	int movesLeft = SIDE * SIDE - MINES, x, y;
	int mines[MAXMINES][2]; // stores (x,y) coordinates of all mines.

	initialise (realBoard, myBoard);

	// Place the Mines randomly
	placeMines (mines, realBoard);

	/*
        cheatMinesweeper(realBoard);
	*/

	// You are in the game until you have not opened a mine
	// So keep playing

	int currentMoveIndex = 0;
	while (gameOver == false){
		printf ("Current Status of Board : \n");
		printBoard (myBoard);
		makeMove (&x, &y);

		// This is to guarantee that the first move is
		// always safe
		// If it is the first move of the game
		if (currentMoveIndex == 0){
			// If the first move itself is a mine
			// then we remove the mine from that location
			if (isMine (x, y, realBoard) == true)
				replaceMine (x, y, realBoard);
		}

		currentMoveIndex ++;

		gameOver = playMinesweeperUtil (myBoard, realBoard, mines, x, y, &movesLeft);

		if ((gameOver == false) && (movesLeft == 0)){
			printf ("\nYou won !\n");
			gameOver = true;
		}
	}
	return;
}

// A Function to choose the difficulty level
// of the game
void chooseDifficultyLevel (){
	/*
	--> BEGINNER = 9 * 9 Cells and 10 Mines
	--> INTERMEDIATE = 16 * 16 Cells and 40 Mines
	--> ADVANCED = 24 * 24 Cells and 99 Mines
	*/

	int level;

	printf ("Enter the Difficulty Level\n");
	printf ("Press 0 for BEGINNER (9 * 9 Cells and 10 Mines)\n");
	printf ("Press 1 for INTERMEDIATE (16 * 16 Cells and 40 Mines)\n");
	printf ("Press 2 for ADVANCED (24 * 24 Cells and 99 Mines)\n");

	scanf ("%d", &level);

	if (level == BEGINNER){
		SIDE = 9;
		MINES = 10;
	}

	if (level == INTERMEDIATE){
		SIDE = 16;
		MINES = 40;
	}

	if (level == ADVANCED){
		SIDE = 24;
		MINES = 99;
	}
	return;
}

// Driver Program to test above functions
int main(){
	/* Choose a level between
	--> BEGINNER = 9 * 9 Cells and 10 Mines
	--> INTERMEDIATE = 16 * 16 Cells and 40 Mines
	--> ADVANCED = 24 * 24 Cells and 99 Mines
	*/
	chooseDifficultyLevel ();

	playMinesweeper ();

	return (0);
}