• 【C语言】扫雷----详解（扩展版）

    💓博客主页：江池俊的博客

    ⏩收录专栏：C语言初阶之路

    💻代码仓库：江池俊的代码仓库

    ✉️每一次努力都是一次进步，每一次尝试都是一次机会。无论遇到什么困难，都要坚定地向       前迈进。相信自己，并相信自己的潜力，您注定会取得非凡的成就！

    🍁 如果觉得博主的文章还不错的话，请点赞👍收藏🌟 三连支持一下博主💞

    🔥编译环境：Visual Studio 2022

    目录

    一、游戏介绍

    游戏规则： 

    游戏玩法：

    二、游戏实现思路 

    三、创建文件

    1.test.c文件 

    😆（menu）菜单函数的实现

    😆game函数的实现

    😆main函数的实现

    2.game.c文件

    😊书写初始化棋盘函数

    😊书写打印棋盘信息的函数

    😊书写设置雷的函数（是雷则为‘1’）

    😊书写统计周围雷个数的函数

    😊书写展开一片非雷区域的函数

    😊书写计算非雷和非标记的位置个数

    😊书写排查雷的函数

     3.game.h文件

    😄需要使用的头文件

    😄定义棋盘行列

    😄定义雷的个数

    😄初始化棋盘

    😄打印棋盘

    😄布置雷

    😄排查雷

    四、总代码 

    （一）game.h文件

    （二）game.c文件 

    （三）test.c文件

    五、效果展示

    前言

    本篇文章主要是讲解用C语言实现扫雷游戏，与三子棋的实现思路类似，可以参考我前面的两篇文章：三子棋小游戏   猜数字小游戏

    下面我们回归正题，让我来详细讲解如何实现扫雷游戏。

    这里我们以9*9的网格为例。

    一、游戏介绍

    扫雷是一款经典的单人益智游戏，目标是在一个由方格组成的区域中找到并标记出所有的地雷，同时避免触雷。下面是扫雷游戏的网页链接，你可以通过玩下方的游戏加深自己对游戏的逻辑和原理的理解。

    扫雷游戏网页版 - Minesweeper

     5752a50bb6954d6f8fbe985d177d1c27.png   a8f8785734d640ad906c3fd72f1817de.png  402e368914154b67a1647f8558903392.png 

    上面依次是游戏进行、失败和胜利的界面 。

    游戏规则： 

    1.游戏开始时，整个区域被分割成一系列方格，其中一些方格中隐藏有地雷。

    2.方格可以是未被揭开的状态，也可以是已被揭开或标记过的状态。

    3.点击一个方格可以揭开它，如果该方格中没有地雷，则会显示数字，表示周围8个方格中地     雷的数量。

    4.如果揭开的方格没有地雷数量，则会自动会揭开周围相邻的空方格。

    5.如果揭开的方格中有地雷，游戏结束，玩家失败。

    游戏玩法：

     1.目标是找到并标记出所有的地雷，而不触雷。

     2.揭开方格时，根据方格周围的地雷数量，判断周围的方格是否安全。数字表示周围有多少颗地雷。

     3.如果您确定某个方格中有地雷，可以标记该方格为雷。这有助于您记住哪些方格是地雷，也可以帮助您避免不小心触雷。

     4.使用推理和逻辑来判断哪些方格一定是地雷，哪些方格一定是安全的。通过标记地雷并推断周围的数字，逐渐揭开更多的方格，直到找到所有的地雷。

    二、游戏实现思路 

    1.创建游戏棋盘：使用二维数组表示游戏棋盘，每个格子可以是开放状态、地雷或者标记状态。

    2.随机布雷：使用随机数生成地雷的位置，并在对应位置上设置地雷。

    3.计算周围地雷数量：遍历游戏棋盘，对于每个非地雷格子，统计周围八个格子中地雷的数量。

    4.游戏循环：进入游戏循环，每次循环包括以下步骤：
       a. 显示游戏棋盘。
       b. 接收用户输入，包括选择要打开的格子或标记地雷。
       c. 根据用户选择更新游戏棋盘状态。
       d. 检查游戏是否胜利或失败。

    5.判断游戏是否胜利：检查游戏棋盘中所有非地雷格子是否被正确打开。

    6.判断游戏是否失败：当玩家选择打开一个格子时，如果该格子是地雷，则游戏失败。

    7.标记地雷：当玩家选择标记一个格子时，在游戏棋盘中该格子的状态为已标记。

    8.打开格子：当玩家选择打开一个格子时，根据该格子的状态进行相应操作：
       a. 如果该格子已经被标记，则忽略。
       b. 如果该格子是地雷，则游戏失败。
       c. 如果该格子是数字格子，则显示该数字。
       d. 如果该格子是空白格子，则继续打开周围的空白格子直到遇到数字格子。(使用递归思想)

    10.继续游戏或退出：在游戏胜利或失败后，询问玩家是否继续游戏。

    三、创建文件

    由于该游戏的实现需要大量的代码，为了提高代码的可读性已经方便后续写代码时的自我检查，这里我们创建三个文件来实现该游戏，我们依次将三个文件命名为game.h \ game.c \ test.c。

    🌴game.h文件用来定义游戏棋盘的行列，以及包含该过程中需要用到的头文件和声明各种函数。

    🌴game.c文件最为重要，它主要是来写实现各种游戏功能的函数，即初始化棋盘，打印棋盘信息，设置棋盘雷的位置，统计雷的个数，展开无雷的一片区域，判断游戏输赢以及标记雷的位置。

    🌴test.c文件则是为了打印游戏菜单和实现game游戏函数。

    1.test.c文件 

    😆（menu）菜单函数的实现

    1. void menu()
    2. {
    3. 	printf("\t\t\t\t\t\t\t\t\t\t\t\n");
    4. 	printf("*********************\n");
    5. 	printf("*****  1. play  *****\n");
    6. 	printf("*****  0. exit  *****\n");
    7. 	printf("*********************\n");
    8. }

    打印结果： 

    😆game函数的实现

    主要功能如下：

    1.创建并初始化棋盘

    2.设置雷的位置（使用rand函数）

    3.打印棋盘信息

    4.排查雷：a.展开一片非雷区域

                      b.显示周围雷的个数

                      c.判断游戏输赢

    1. void game()
    2. {
    3. 	char mine[ROWS][COLS] = { 0 };//存放布置好的雷的信息
    4. 	char show[ROWS][COLS] = { 0 };//存放排查出的雷的信息
    5. 	//初始化数组的内容为指定内容
    6. 	//mine数组在没有布置雷的时候，都是‘0’
    7. 	InitBoard(mine, ROWS, COLS,'0');
    8. 	//show数组在没有排查雷的时候都是‘*’
    9. 	InitBoard(show, ROWS, COLS, '*'); 
    10.  
    11.  
    12. 	//设置雷
    13. 	Setmine(mine, ROW, COL);
    14. 	DisplayBoard(show, ROW, COL);
    15. 	//DisplayBoard(mine, ROW, COL);
    16. 	//排查雷
    17. 	FindMine(mine, show, ROW, COL);
    18.  
    19. }

    这里我们需要创建两个数组作为棋盘，但是棋盘比实际的要大一圈，这是因为在对边上的格子进行排查时，往往不满八个格子，对9*9之外的格子访问时会越界，这时我们需要手动创建它周围的格子使得它能够成功访问，这样的话创建的数组棋盘就从9*9变成了11*11。

    当访问棋盘右上角的格子时，右上角黄色方框中的格子就是排查时要访问的格子

    这里我们要设置两个棋盘，其中一个棋盘（名字为mine）存放雷的信息，另一个棋盘（名字为show）存放排查雷的信息，这里我们初始化mine棋盘为字符‘0’，show棋盘为字符‘*’。

    打印结果：

    😆main函数的实现

    1. int main()
    2. {
    3. 	int input = 0;
    4. 	srand((unsigned int)time(NULL));
    5. 	do
    6. 	{
    7. 		menu();
    8. 		printf("请选择:>");
    9. 		scanf("%d", &input);
    10. 		switch (input)
    11. 		{
    12. 		case 1:system("cls"); game();
    13. 			break;
    14. 		case 0:printf("退出游戏\n");
    15. 			break;
    16. 		default:printf("选择错误，请重新输入！\n");
    17. 			break;
    18. 		}
    19. 	} while (input);
    20. 	return 0;
    21. }

    这里我们通过do while循环和switch语句来实现游戏的持续进行和对不同输入的选择，输入1，进入游戏，输入0，退出游戏，输入其他时，输出“选择错误，请重新输入！”。

    打印结果：

    2.game.c文件

    😊书写初始化棋盘函数

    1. //初始化棋盘
    2. void InitBoard(char board[ROWS][COLS], int rows, int cols,char set)
    3. {
    4. 	int i = 0;
    5. 	int j = 0;
    6. 	for(i=0;i
    7. 		for (j = 0; j < cols; j++)
    8. 		{
    9. 			board[i][j] = set;
    10. 		}
    11. }

    因为有两个棋盘，所以我们需要一个字符型变量（char）set 来设置棋盘初始化的值，如果是mine棋盘，则 set = ‘0’；如果是show棋盘，则 set = ‘*’ 。

    😊书写打印棋盘信息的函数

    1. //打印棋盘信息
    2. void DisplayBoard(char board[ROWS][COLS], int row, int col)
    3. {
    4. 	int i = 0;
    5. 	int j = 0;
    6. 	printf("------扫雷游戏------\n");
    7. 	printf("════════════════════\n");//美化棋盘
    8. 	for (j = 0; j <= col; j++)
    9. 	{
    10. 		printf("%d|", j);
    11. 	}
    12. 	printf("\n-|══════════════════");//美化棋盘
    13. 	printf("\n");
    14. 	for (i = 1; i <= row; i++)
    15. 	{
    16. 		printf("%d|", i);
    17. 		for (j = 1; j <= col; j++)
    18. 		{
    19. 			printf("%c|", board[i][j]);
    20. 		}
    21. 		printf("\n");
    22. 	}
    23. 	printf("════════════════════\n");//美化棋盘
    24. 	printf("------扫雷游戏------\n\n");
    25. }

    打印结果： 

    😊书写设置雷的函数（是雷则为‘1’）

    1. //设置雷的函数
    2. void Setmine(char board[ROWS][COLS], int row, int col)
    3. {
    4. 	int count = EASY_COUNT;
    5. 	//行1-9  列1-9
    6. 	while (count)
    7. 	{
    8. 		int x = rand() % row + 1;
    9. 		int y = rand() % col + 1;
    10. 		if (board[x][y] == '0')
    11. 		{
    12. 			board[x][y] = '1';
    13. 			count--;
    14. 		}
    15. 	}
    16. }

    下面我会针对遇到的问题进行解答👀

    👀如何随机设置雷的位置？ 

    使用srand()来随机设置雷的坐标

    1. //test.c
    2. srand((unsigned int)time(NULL));//设置随机数的生成起点

     👀如何控制雷的坐标位置合理

    1. int x = rand() % row + 1;//生成1-9的随机数
    2. int y = rand() % col + 1;//生成1-9的随机数

    利用rand() 函数取row或col的模再+1来得到1-9的随机数，这样就可以控制雷的位置在棋盘上。

    😊书写统计周围雷个数的函数

    1. //统计周围雷数的函数
    2. int get_mine_count(char board[ROWS][COLS],int x,int y)
    3. {
    4. 	int count = 0;
    5. 	for(int i=-1;i<=1;i++)
    6. 		for (int j = -1; j <= 1; j++)
    7. 		{
    8. 			if (board[x + i][y + j] == '1')
    9. 				count++;
    10. 		}
    11. 	return count;
    12.  
    13. 	/*return (board[x - 1][y] +
    14. 		board[x - 1][y - 1] +
    15. 		board[x][y - 1] +
    16. 		board[x + 1][y - 1] +
    17. 		board[x + 1][y] +
    18. 		board[x + 1][y + 1] +
    19. 		board[x][y + 1] +
    20. 		board[x - 1][y + 1] - 8 * '0');*/
    21. }

    当排查的位置为x，y时，根据上图可知周围八个格子的坐标，计算周围雷的个数，当这八个位置每有一个雷时我们就加一。

    😊书写展开一片非雷区域的函数

    1. //递归，展开一片区域的函数
    2. void OpenArea(char mine[ROWS][COLS],char show[ROWS][COLS], int row, int col,int x, int y)
    3. {
    4. 	int count = get_mine_count(mine, x, y);
    5. 	if (count == 0) 
    6. 	{
    7. 		show[x][y] = ' ';
    8. 		for (int i = x - 1; i <= x + 1; i++) 
    9. 		{
    10. 			for (int j = y - 1; j <= y + 1; j++) 
    11. 			{
    12. 				if (show[i][j] == '*' && x >= 1 && x <= row && y >= 1 && y <= col) 
    13. 				{
    14. 					OpenArea(mine, show,ROW,COL, i, j);
    15. 				}
    16. 			}
    17. 		}
    18. 	}
    19. 	else 
    20. 	{
    21. 		show[x][y] = count + '0';
    22. 	}
    23. }

     因为需要对存储雷位置的棋盘和显示棋盘信息的棋盘进行操作，所以形参中需要两个棋盘。

    当周围没有雷时，将此位置的show棋盘上显示为 ‘  ’ (空格)，同时对周围八个坐标位置的格子进行判断，如果这些坐标（合理）在9*9的棋盘上，则再次对他们进行同样的判断，此时就需要利用递归的思想（即再次调用展开一片非雷区域的函数）；当周围有雷，这时就需要统计雷的个数，并将雷的个数显示在show棋盘上。

    注意：

    因为show棋盘上存储的是字符（char），而统计的数是整型，所以我们需要将整型转换为字符型（即让数字加上字符‘0’）。

    😊书写计算非雷和非标记的位置个数

    1. //计算非雷和非标记的位置个数
    2. int get_win(char board[ROWS][COLS], int row, int col)
    3. {
    4. 	int win = 0;
    5. 	for(int i=1;i<=row;i++)
    6. 		for (int j = 1; j <= col; j++)
    7. 		{
    8. 			if (board[i][j]!='*'&&board[i][j]!='!')
    9. 				win++;
    10. 		}
    11. 	return win;
    12. }

    该函数作用是为了判断游戏输赢。 

    😊书写排查雷的函数

    1. //排雷的函数
    2. void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
    3. {
    4. 	 //1.输入排查的坐标
    5.      //2.检查该坐标处是不是雷
    6. 	 //(1) 是雷   - 很遗憾，你被炸死了 - 游戏结束
    7. 	 //(2) 不是雷 - 统计坐标周围有几个雷 - 存储排查雷的信息到show数组，游戏继续
    8. 	int x = 0;
    9. 	int y = 0;
    10. 	int win = 0;
    11. 	int select = 0;
    12.  
    13. 	while (win < row * col - EASY_COUNT)
    14. 	{
    15. 		printf("请选择：1.排查雷 2.标记雷 3.取消标记\t");
    16. 		scanf("%d", &select);
    17. 		if (select == 1) 
    18. 		{
    19. 			printf("请输入要排查雷的坐标：>");
    20. 			scanf("%d %d", &x, &y);
    21. 			//判断坐标合法性
    22. 			if (x >= 1 && x <= row && y >= 1 && y <= col) 
    23. 			{
    24. 				if (show[x][y] == '*')
    25. 				{
    26. 					if (mine[x][y] == '1')
    27. 					{
    28. 						printf("\n\n很遗憾，你被炸死了！\n");
    29. 						printf("雷的分布情况，其中（'1'表示雷）：\n");
    30. 						DisplayBoard(mine, ROW, COL);
    31. 						break;
    32. 					}
    33. 					else
    34. 					{
    35. 						OpenArea(mine, show,ROW,COL, x, y);
    36. 						//显示排查出的信息
    37. 						DisplayBoard(show, ROW, COL);
    38. 						//计算已经排出的非雷位置的个数
    39. 						win = get_win(show, ROW, COL);
    40. 					}
    41. 				}
    42. 				else
    43. 				{
    44. 					printf("该位置已被排查过，请重新输入！\n");
    45. 				}
    46. 			}
    47. 			else
    48. 			{
    49. 				printf("坐标不合法，请重新输入！\n");
    50. 			}
    51. 		}
    52. 		else if (select == 2)
    53. 		{
    54. 			printf("请输入要标记的坐标：>");
    55. 			scanf("%d %d", &x, &y);
    56. 			//判断坐标合法性
    57. 			if (x >= 1 && x <= row && y >= 1 && y <= col) 
    58. 			{
    59. 				if (show[x][y] == '*')
    60. 				{
    61. 					show[x][y] = '!';
    62. 					DisplayBoard(show, ROW, COL);
    63. 				}
    64. 				else if(show[x][y]=='!')
    65. 				{
    66. 					printf("该位置已被标记，请重新选择！\n");
    67. 				}
    68. 				else
    69. 				{
    70. 					printf("该位置不能标记，请重新选择！\n");
    71. 				}
    72. 			}
    73. 			else 
    74. 			{
    75. 				printf("坐标不合法，请重新输入！\n");
    76. 			}
    77. 		}
    78. 		else if (select == 3)
    79. 		{
    80. 			printf("请输入要取消标记的坐标：>");
    81. 			scanf("%d %d", &x, &y );
    82. 			if (x >= 1 && x <= row && y >= 1 && y <= col)
    83. 			{
    84. 				if (show[x][y] == '!')
    85. 				{
    86. 					show[x][y] = '*';
    87. 					DisplayBoard(show, ROW, COL);
    88. 				}
    89. 				else
    90. 				{
    91. 					printf("该位置不能取消标记，请重新选择！\n");
    92. 				}
    93. 			}
    94. 			else
    95. 			{
    96. 				printf("坐标不合法，请重新输入！\n");
    97. 			}
    98. 		}
    99. 		else 
    100. 		{
    101. 			printf("输入有误，请重新输入！\n");
    102. 		}
    103. 		
    104. 		//printf("win=%d\n", win);
    105. 	}
    106. 	if (win == row * col - EASY_COUNT) 
    107. 	{
    108. 		printf("\n恭喜你，排雷成功！\n");
    109. 		printf("雷的分布情况，其中（'1'表示雷）：\n");
    110. 		DisplayBoard(mine, ROW, COL);
    111. 	}
    112. }
    113.  
    114. //基础功能+拓展功能
    115. //1.标记功能（用'!'）
    116. //2.展开一片区域的功能（使用递归）      
    117. //*当排查下x，y坐标时：（1）该坐标不是雷  （2）该坐标周围没有雷  （3）该坐标没有被排查过

    👀如何排查雷？ 

    基本思路：

                    1.输入排查的坐标
                    2.检查该坐标处是不是雷
                      ❌ 是雷   - 很遗憾，你被炸死了 - 游戏结束
                      ✔️不是雷 - 统计坐标周围有几个雷 - 存储排查雷的信息到show数组，游戏继续

    1.      		printf("请输入要排查雷的坐标：>");
    2. 			scanf("%d %d", &x, &y);
    3. 			//判断坐标合法性
    4. 			if (x >= 1 && x <= row && y >= 1 && y <= col) 
    5. 			{
    6. 				if (show[x][y] == '*')
    7. 				{
    8. 					if (mine[x][y] == '1')
    9. 					{
    10. 						printf("\n\n很遗憾，你被炸死了！\n");
    11. 						printf("雷的分布情况，其中（'1'表示雷）：\n");
    12. 						DisplayBoard(mine, ROW, COL);
    13. 						break;
    14. 					}
    15. 					else
    16. 					{
    17. 						OpenArea(mine, show,ROW,COL, x, y);
    18. 						//显示排查出的信息
    19. 						DisplayBoard(show, ROW, COL);
    20. 						//计算已经排出的非雷位置的个数
    21. 						win = get_win(show, ROW, COL);
    22. 						//win++;
    23. 					}
    24. 				}
    25. 				else
    26. 				{
    27. 					printf("该位置已被排查过，请重新输入！\n");
    28. 				}
    29. 			}
    30. 			else
    31. 			{
    32. 				printf("坐标不合法，请重新输入！\n");
    33. 			}

    👀如何标记雷？ 

    因为排查雷和标记雷是两个不同的过程，所以这时我们需要通过使用if-else语句来选择排查雷还是标记雷，标记雷的位置用‘ ！’来表示。

    1. //printf("请选择：1.排查雷 2.标记雷\t");
    2. //scanf("%d", &select);
    3. else if (select == 2)
    4. 		{
    5. 			printf("请输入要标记的坐标：>");
    6. 			scanf("%d %d", &x, &y);
    7. 			//判断坐标合法性
    8. 			if (x >= 1 && x <= row && y >= 1 && y <= col) 
    9. 			{
    10. 				if (show[x][y] == '*')
    11. 				{
    12. 					show[x][y] = '!';
    13. 					DisplayBoard(show, ROW, COL);
    14. 				}
    15. 				else if(show[x][y]=='!')
    16. 				{
    17. 					printf("该位置已被标记，请重新选择！\n");
    18. 				}
    19. 				else
    20. 				{
    21. 					printf("该位置不能标记，请重新选择！\n");
    22. 				}
    23. 			}
    24. 			else 
    25. 			{
    26. 				printf("坐标不合法，请重新输入！\n");
    27. 			}
    28. 		}
    29. 		else 
    30. 		{
    31. 			printf("输入有误，请重新输入！\n");
    32. 		}
    33. 		
    34. 		//printf("win=%d\n", win);
    35. 	}

    👀 如何判断输赢？

    1. if (win == row * col - EASY_COUNT) 
    2. 	{
    3. 		printf("\n恭喜你，排雷成功！\n");
    4. 		printf("雷的分布情况，其中（'1'表示雷）：\n");
    5. 		DisplayBoard(mine, ROW, COL);
    6. 	}

    当show棋盘上非雷位置和非标记位置个数与mine棋盘上‘0’的个数（即非雷个数）相等时，打印“恭喜你，排雷成功！”，并打印mine棋盘的雷的分布情况。若不等于则继续进行排雷或标记雷的步骤。

    打印结果： 

     

     3.game.h文件

    😄需要使用的头文件

    1. #include
    2. #include
    3. #include;

    😄定义棋盘行列

    1. #define ROW 9
    2. #define COL 9
    3.  
    4. #define ROWS ROW+2
    5. #define COLS COL+2

    打印棋盘信息时，使用9*9的棋盘，在进行初始化，设置雷，排查雷，标记雷等操作时使用11*11的棋盘。

    😄定义雷的个数

    #define EASY_COUNT 10

    😄初始化棋盘

    1. //初始化棋盘
    2. void InitBoard(char board[ROWS][COLS], int rows, int cols,char set);

    😄打印棋盘

    1. //打印棋盘
    2. void DisplayBoard(char board[ROWS][COLS], int row, int col);

    😄布置雷

    1. //布置雷
    2. void Setmine(char board[ROWS][COLS],int row,int col);

    😄排查雷

    1. //排查雷
    2. void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS],int row,int col);

    四、总代码 

    注意：此代码分为三个部分的代码

    （一）game.h文件

    1. #include
    2. #include
    3. #include;
    4.  
    5. #define ROW 9
    6. #define COL 9
    7.  
    8. #define ROWS ROW+2
    9. #define COLS COL+2
    10.  
    11. #define EASY_COUNT 10
    12. //初始化棋盘
    13. void InitBoard(char board[ROWS][COLS], int rows, int cols,char set);
    14. //打印棋盘
    15. void DisplayBoard(char board[ROWS][COLS], int row, int col);
    16. //布置雷
    17. void Setmine(char board[ROWS][COLS],int row,int col);
    18. //排查雷
    19. void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS],int row,int col);

    （二）game.c文件 

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2.  
    3. #include"game.h"
    4. //初始化棋盘
    5. void InitBoard(char board[ROWS][COLS], int rows, int cols,char set)
    6. {
    7. 	int i = 0;
    8. 	int j = 0;
    9. 	for(i=0;i
    10. 		for (j = 0; j < cols; j++)
    11. 		{
    12. 			board[i][j] = set;
    13. 		}
    14. }
    15. //打印棋盘信息
    16. void DisplayBoard(char board[ROWS][COLS], int row, int col)
    17. {
    18. 	int i = 0;
    19. 	int j = 0;
    20. 	printf("------扫雷游戏------\n");
    21. 	printf("════════════════════\n");//美化棋盘
    22. 	for (j = 0; j <= col; j++)
    23. 	{
    24. 		printf("%d|", j);
    25. 	}
    26. 	printf("\n-|══════════════════");//美化棋盘
    27. 	printf("\n");
    28. 	for (i = 1; i <= row; i++)
    29. 	{
    30. 		printf("%d|", i);
    31. 		for (j = 1; j <= col; j++)
    32. 		{
    33. 			printf("%c|", board[i][j]);
    34. 		}
    35. 		printf("\n");
    36. 	}
    37. 	printf("════════════════════\n");//美化棋盘
    38. 	printf("------扫雷游戏------\n\n");
    39. }
    40. //设置雷的函数
    41. void Setmine(char board[ROWS][COLS], int row, int col)
    42. {
    43. 	int count = EASY_COUNT;
    44. 	//行1-9  列1-9
    45. 	while (count)
    46. 	{
    47. 		int x = rand() % row + 1;
    48. 		int y = rand() % col + 1;
    49. 		if (board[x][y] == '0')
    50. 		{
    51. 			board[x][y] = '1';
    52. 			count--;
    53. 		}
    54. 	}
    55. }
    56. //统计周围雷数的函数
    57. int get_mine_count(char board[ROWS][COLS],int x,int y)
    58. {
    59. 	int count = 0;
    60. 	for(int i=-1;i<=1;i++)
    61. 		for (int j = -1; j <= 1; j++)
    62. 		{
    63. 			if (board[x + i][y + j] == '1')
    64. 				count++;
    65. 		}
    66. 	return count;
    67.  
    68. 	/*return (board[x - 1][y] +
    69. 		board[x - 1][y - 1] +
    70. 		board[x][y - 1] +
    71. 		board[x + 1][y - 1] +
    72. 		board[x + 1][y] +
    73. 		board[x + 1][y + 1] +
    74. 		board[x][y + 1] +
    75. 		board[x - 1][y + 1] - 8 * '0');*/
    76. }
    77.  
    78. //递归，展开一片区域的函数
    79. void OpenArea(char mine[ROWS][COLS],char show[ROWS][COLS], int row, int col,int x, int y)
    80. {
    81. 	int count = get_mine_count(mine, x, y);
    82. 	if (count == 0) 
    83. 	{
    84. 		show[x][y] = ' ';
    85. 		for (int i = x - 1; i <= x + 1; i++) 
    86. 		{
    87. 			for (int j = y - 1; j <= y + 1; j++) 
    88. 			{
    89. 				if (show[i][j] == '*' && x >= 1 && x <= row && y >= 1 && y <= col) 
    90. 				{
    91. 					OpenArea(mine, show,ROW,COL, i, j);
    92. 				}
    93. 			}
    94. 		}
    95. 	}
    96. 	else 
    97. 	{
    98. 		show[x][y] = count + '0';
    99. 	}
    100. }
    101.  
    102. // 计算非雷和非标记的位置个数
    103. int get_win(char board[ROWS][COLS], int row, int col)
    104. {
    105. 	int win = 0;
    106. 	for(int i=1;i<=row;i++)
    107. 		for (int j = 1; j <= col; j++)
    108. 		{
    109. 			if (board[i][j]!='*'&&board[i][j]!='!')
    110. 				win++;
    111. 		}
    112. 	return win;
    113. }
    114.  
    115. //排雷的函数
    116. void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
    117. {
    118. 	 //1.输入排查的坐标
    119.      //2.检查该坐标处是不是雷
    120. 	 //(1) 是雷   - 很遗憾，你被炸死了 - 游戏结束
    121. 	 //(2) 不是雷 - 统计坐标周围有几个雷 - 存储排查雷的信息到show数组，游戏继续
    122. 	int x = 0;
    123. 	int y = 0;
    124. 	int win = 0;
    125. 	int select = 0;
    126.  
    127. 	while (win < row * col - EASY_COUNT)
    128. 	{
    129. 		printf("请选择：1.排查雷 2.标记雷 3.取消标记\t");
    130. 		scanf("%d", &select);
    131. 		if (select == 1) 
    132. 		{
    133. 			printf("请输入要排查雷的坐标：>");
    134. 			scanf("%d %d", &x, &y);
    135. 			//判断坐标合法性
    136. 			if (x >= 1 && x <= row && y >= 1 && y <= col) 
    137. 			{
    138. 				if (show[x][y] == '*')
    139. 				{
    140. 					if (mine[x][y] == '1')
    141. 					{
    142. 						printf("\n\n很遗憾，你被炸死了！\n");
    143. 						printf("雷的分布情况，其中（'1'表示雷）：\n");
    144. 						DisplayBoard(mine, ROW, COL);
    145. 						break;
    146. 					}
    147. 					else
    148. 					{
    149. 						OpenArea(mine, show,ROW,COL, x, y);
    150. 						//显示排查出的信息
    151. 						DisplayBoard(show, ROW, COL);
    152. 						//计算已经排出的非雷位置的个数
    153. 						win = get_win(show, ROW, COL);
    154. 					}
    155. 				}
    156. 				else
    157. 				{
    158. 					printf("该位置已被排查过，请重新输入！\n");
    159. 				}
    160. 			}
    161. 			else
    162. 			{
    163. 				printf("坐标不合法，请重新输入！\n");
    164. 			}
    165. 		}
    166. 		else if (select == 2)
    167. 		{
    168. 			printf("请输入要标记的坐标：>");
    169. 			scanf("%d %d", &x, &y);
    170. 			//判断坐标合法性
    171. 			if (x >= 1 && x <= row && y >= 1 && y <= col) 
    172. 			{
    173. 				if (show[x][y] == '*')
    174. 				{
    175. 					show[x][y] = '!';
    176. 					DisplayBoard(show, ROW, COL);
    177. 				}
    178. 				else if(show[x][y]=='!')
    179. 				{
    180. 					printf("该位置已被标记，请重新选择！\n");
    181. 				}
    182. 				else
    183. 				{
    184. 					printf("该位置不能标记，请重新选择！\n");
    185. 				}
    186. 			}
    187. 			else 
    188. 			{
    189. 				printf("坐标不合法，请重新输入！\n");
    190. 			}
    191. 		}
    192. 		else if (select == 3)
    193. 		{
    194. 			printf("请输入要取消标记的坐标：>");
    195. 			scanf("%d %d", &x, &y );
    196. 			if (x >= 1 && x <= row && y >= 1 && y <= col)
    197. 			{
    198. 				if (show[x][y] == '!')
    199. 				{
    200. 					show[x][y] = '*';
    201. 					DisplayBoard(show, ROW, COL);
    202. 				}
    203. 				else
    204. 				{
    205. 					printf("该位置不能取消标记，请重新选择！\n");
    206. 				}
    207. 			}
    208. 			else
    209. 			{
    210. 				printf("坐标不合法，请重新输入！\n");
    211. 			}
    212. 		}
    213. 		else 
    214. 		{
    215. 			printf("输入有误，请重新输入！\n");
    216. 		}
    217. 		
    218. 		//printf("win=%d\n", win);
    219. 	}
    220. 	if (win == row * col - EASY_COUNT) 
    221. 	{
    222. 		printf("\n恭喜你，排雷成功！\n");
    223. 		printf("雷的分布情况，其中（'1'表示雷）：\n");
    224. 		DisplayBoard(mine, ROW, COL);
    225. 	}
    226. }
    227.  
    228. //基础功能+拓展功能
    229. //1.标记功能（用'!'）
    230. //2.展开一片区域的功能（使用递归）      
    231. //*当排查下x，y坐标时：（1）该坐标不是雷  （2）该坐标周围没有雷  （3）该坐标没有被排查过

    （三）test.c文件

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2.  
    3. #include"game.h"
    4.  
    5. void menu()
    6. {
    7. 	printf("\t\t\t\t\t\t\t\t\t\t\t\n");
    8. 	printf("*********************\n");
    9. 	printf("*****  1. play  *****\n");
    10. 	printf("*****  0. exit  *****\n");
    11. 	printf("*********************\n");
    12. }
    13.  
    14. void game()
    15. {
    16. 	char mine[ROWS][COLS] = { 0 };//存放布置好的雷的信息
    17. 	char show[ROWS][COLS] = { 0 };//存放排查出的雷的信息
    18. 	//初始化数组的内容为指定内容
    19. 	//mine数组在没有布置雷的时候，都是‘0’
    20. 	InitBoard(mine, ROWS, COLS,'0');
    21. 	//show数组在没有排查雷的时候都是‘*’
    22. 	InitBoard(show, ROWS, COLS, '*'); 
    23.  
    24.  
    25. 	//设置雷
    26. 	Setmine(mine, ROW, COL);
    27. 	DisplayBoard(show, ROW, COL);
    28. 	//DisplayBoard(mine, ROW, COL);
    29. 	//排查雷
    30. 	FindMine(mine, show, ROW, COL);
    31.  
    32. }
    33.  
    34.  
    35. int main()
    36. {
    37. 	int input = 0;
    38. 	srand((unsigned int)time(NULL));
    39. 	do
    40. 	{
    41. 		menu();
    42. 		printf("请选择:>");
    43. 		scanf("%d", &input);
    44. 		switch (input)
    45. 		{
    46. 		case 1:system("cls"); game();
    47. 			break;
    48. 		case 0:printf("退出游戏\n");
    49. 			break;
    50. 		default:printf("选择错误，请重新输入！\n");
    51. 			break;
    52. 		}
    53. 	} while (input);
    54. 	return 0;
    55. }

    五、效果展示

    扫雷游戏展示

    扫雷游戏展示

    🔥好了， 今天的内容就分享到这里了。愿这篇博客能够为您带来新的思考和启示。感谢您的耐心阅读和支持。无论在人生的道路上遇到怎样的困难和挑战，记住相信自己的力量，努力前行。期待与您共同探索更多精彩的内容。再次感谢！

  • 相关阅读:
    【从零开始学习深度学习】7.自己动手实现softmax回归的训练与预测
    TiDB Lightning 并行导入
    JavaScript 基础知识| 数据类型|类型转换
    档案信息化咨询方法论实践要点有哪些？
    day31-JQuery04
    超实用！推荐5款办公黑科技软件，用了就离不开
    二叉树题目：二叉树寻路
    “AI大模型革新浪潮：农业、生态、气象科研的新智能助手，开启智慧科研新篇章！“
    [vue3] 使用ElementPlus页面布局搭建架子
    UIC 564-2 座椅耐火测试
  • 原文地址：https://blog.csdn.net/2201_75743654/article/details/131636089