• C语言小游戏之扫雷（万字详解）

    hello，大家好，今天我们继续为大家带来一个小游戏，扫雷。相信这个游戏又是很多人的童年，那么我们今天就来实现一下这个扫雷游戏。

    目录

    一、游戏简介

     二、游戏的基本设计

    1.游戏基本思路

    2.游戏基本框架

    3.如何设计布置雷与排查雷？

     4.数组的大小如何设置

    5.数组的定义代码展示

     三、游戏具体功能详解

    1.初始化数组（InitBoard)

    (1)函数的声明和定义

     （2）初始化数组代码展示

     （3）初始化数组代码如下

    2.打印数组（DisplayBoard）

    （1）打印数组的定义和声明

     （2）代码的实现

     （3）测试代码

     （4）更进一步优化

     （5）运行测试

    （6）更进一步的优化界面

    （7）代码实现如下

    3.布置雷(SetMine)

    (1)布置雷函数的定义和声明

     （3）具体的布置雷实现

     （4）测试布雷

     （5）布置雷的代码实现

    4.排查雷（FindMine)

    (1)排查雷函数的声明和定义

    （2）排查雷的实现逻辑

    （3)测试

    （4）排雷的结束条件

     （5）优化多次排查同一个位置的bug

    （6）排查雷代码实现如下

    四、游戏完整代码（分文件）

    test.c文件

    game.h文件

    game.c文件

    五、完整代码展示（合并为同一个文件）

    总结

    一、游戏简介

    虽然说是一个基本上大家都听过，并且大多数人都玩过的一个小游戏，但是其实很多人当时都是瞎玩的。所以呢，我们先来介绍一下游戏规则。这个游戏，我们可以直接在电脑上搜索到，打开浏览器直接搜索扫雷。我们使用如下图所示的游戏

     点击9*9棋盘，如下图所示，每一行是9个元素，每一列也是9

    我们随机点开其中的一个方格，他会进行展开，其中白色方格代表这块没有雷。有数字的方格代表其周围一圈的八个格子里面有雷的个数 。我们就是根据这些提示进行排雷

    而一旦踩中了雷以后，就会失败

     二、游戏的基本设计

    1.游戏基本思路

    1.布置雷：创建一个二维数组，随机生成十个坐标放到位置上

    2.排查雷：选择一个坐标，判断是否是雷，如果是，则爆炸，如果不是则遍历以他为中心的9个元素，并显示一个周围雷的个数。

    2.游戏基本框架

    在我们前面讲解了三子棋还有猜数字小游戏后，相信大家已经对这个思路很熟悉了，我们还是采用分文件的形式写代码，创建test.c，game.h，game.c三个文件。

    这里就不在赘述了，直接给出代码，以下都是test.c文件中的代码

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include
    3. void meau()
    4. {
    5. 	printf("*************************\n");
    6. 	printf("******* 1. 开始扫雷 ******\n");
    7. 	printf("******* 0. 退出游戏 ******\n");
    8. 	printf("*************************\n");
    9.  
    10. }
    11. void game()
    12. {
    13. 	printf("开始扫雷\n");
    14. }
    15. void test()
    16. {
    17. 	meau();
    18. 	int input = 0;
    19. 	do
    20. 	{
    21. 		printf("请输入选项>:\n");
    22. 		scanf("%d", &input);
    23. 		switch (input)
    24. 		{
    25. 		case 1:
    26. 			game();
    27. 			break;
    28. 		case 0:
    29. 			printf("退出游戏\n");
    30. 			break;
    31. 		default:
    32. 			printf("输入错误，请重新输入\n");
    33. 			break;
    34. 		}
    35. 	} while (input);
    36. }
    37. int main()
    38. {
    39. 	test();
    40. 	return 0;
    41. }

    当然还是需要测试的，我们进行一次测试，结果符合我们的预期

    3.如何设计布置雷与排查雷？

    我们的目标是布置雷与排查雷，那么这个时候有一个问题了，我们如果使用一个数组来记录布置雷的话，假如说我们记作，有雷是1，无雷是0。那么未来我开始排查雷的时候，想要扫雷，扫的这个位置是需要显示出周围有几个雷的。那这样的话，加入说我周围只有一个雷，那么打印出来的就只有1。可是这样子的话，我们这个位置就相当于被修改了，莫名奇妙的多出了一个雷，这就导致了一些混乱，产生了大量的bug。所以说这样的方法不太合理，我们需要进行优化。

    那么如何进行优化呢？我们想到，既然只使用一个数组会乱，那么我们使用两个数组呢？一个数组仅仅用来放雷，一个数组用来打印出来让人来看。并且要记录这个周围有多少个雷。所以说，这样做的话就是可行的。程序就不会乱套了。

    对于我们那个需要让人看的数组而言，我们一开始人是看不见雷的，所以说我们需要一开始打印的全是*号这个字符，为了方便起见，我们显示出周围有几个雷的时候也是使用字符数字来显示出周围有多少个雷。那么这样的话，不妨统一一下，两个数组都是字符数组。

     4.数组的大小如何设置

    有很多人不经思考的直接回答说9*9即可，可是当我们在排查雷的时候，遇到边界的坐标如何排查呢，我们如果想要排查他的一圈的话，那么毫无疑问越界了。所以这不是明智之举。我们应当进行在这个数组上加上一圈，所以行和列都应该加上2。这样就不会越界访问了，当然为了统一一下，我们两个数组都是这样加上一圈。

    5.数组的定义代码展示

    有了前面那么多代码的思考，那么我们能不能实现一下呢。我们先定义一下数组吧。如下图所示，我们为了方便起见我们直接在game.h中define一下，然后我们想要在test.c文件中使用这个define定义常量。就得引入这个game.h这个头文件。然后就可以定义字符数组了。当然我们是要使用行和列都+2的那个define定义的常量。

     三、游戏具体功能详解

    1.初始化数组（InitBoard)

    (1)函数的声明和定义

    很显然，我们要初始化数组两次，所以说，我们除了传数组名，行和列以外，需要传一个初始化成什么样子的一个字符。需要注意的是，这里传的是字符0，字符0和数字0是不一样的，字符0的ASCII值是48。'\0'的ASCII值是0，而如果传一个0的话，那么他最终打印出来的就是一堆'\0'也就是什么都没有。

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

     

     （2）初始化数组代码展示

    这块还是比较简单的，我们用两层循环即可

    注意：此图中出现了一个经典的错误，标准的零分

    在第12行中，这个set不应该带有单引号，因为我们set他本身是一个变量，对变量带一个单引号，那么就势必导致一些不可预料的错误。

    这也是很多人都喜欢犯的一个错误！！！

     （3）初始化数组代码如下

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

    2.打印数组（DisplayBoard）

    我们初始化好数组以后，我们肯定希望我们现在就能看到这个数组。这也是方便我们后续进行测试的一个重要步骤,不过需要注意的是，我们打印肯定不是打印这个11*11的数组，而是只打印9*9的数组即可，因为这个人只需要看到9*9的就可以了

    （1）打印数组的定义和声明

    这里唯一需要注意的是，我们定义和声明函数的时候，数组的大小可千万不要写错了，写出了ROW，注意，我们这里数组的大小仍然是11*11的，只不过因为我只需要9*9就足够了。

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

     

     

     （2）代码的实现

    对于这个代码，其实也不是很难，同样两个for循环解决

     （3）测试代码

    同样的，写一点，测一点，好在结果也确实符合我们的预期，需要注意的是，有的人可能注意到了printf为什么有绿色警告，其实这是因为我们的game.c文件中还没有这个头文件。为了方便，我们直接把test.c中的挪到game.h文件中,就可以解决了

     （4）更进一步优化

    当然，我们此时打印出来的数组还不够完美，因为打印出来的数组密密麻麻，我们无法识别坐标，所以我们最好能把行标和列表打印出来就更加完美了。

     （5）运行测试

    这样一来就完美了

    （6）更进一步的优化界面

     这样可以使得测试更好看

    （7）代码实现如下

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

    3.布置雷(SetMine)

    (1)布置雷函数的定义和声明

    我们布置雷都是往mine数组里面放的，这个数组的大小是11*11，需要操作的行是9，列是9。所以定义和声明为

    void SetMine(char board[ROWS][COLS], int row, int col);

     

     （2）雷的个数以及雷坐标的生成

    我们开始生成雷的个数和坐标。雷的个数我们可以使用一个define来进行定义。雷的坐标则需要使用一个随机数的使用。代码实现如下

     （3）具体的布置雷实现

     （4）测试布雷

    如下图所示，我们在布置好雷以后在后面打印一下数组

     结果为下图所示，刚好符合我们的预期，就是10个雷

     （5）布置雷的代码实现

    1. //布置雷
    2. void SetMine(char board[ROWS][COLS], int row, int col)
    3. {
    4. 	//雷的个数
    5. 	int count = EASY_COUNT;
    6. 	while (count)
    7. 	{
    8. 		//生成随机下标
    9. 		int x = rand() % row + 1;
    10. 		int y = rand() % col + 1;
    11. 		//布雷
    12. 		if (board[x][y] == '0')
    13. 		{
    14. 			board[x][y] = '1';
    15. 			count--;
    16. 		}
    17. 	}
    18. }

    4.排查雷（FindMine)

    (1)排查雷函数的声明和定义

    我们在排查的时候，是在mine数组中进行查找，然后将结果反馈给show数组，所以需要两个数组都传过去。我们进行排查的时候，只需要使用行9列9即可

     

     

    （2）排查雷的实现逻辑

    我们在排查雷的过程中的逻辑是这样，让用户输入一个坐标，通过这个坐标先判断是否合法，如下图所示

     现在我们可以确保我们的坐标是合法的了，在合法的基础上，如果这个坐标中的位置已经是字符1了，那玩家就被炸死了，游戏结束并打印出雷区的棋盘。如果不是字符1，那就开始统计他的一圈有多少个雷，为了方便统起见，我们使用一个函数来进行统计。这个函数我们不妨就定义为

    int get_mine_count(char mine[ROWS][COLS], int x, int y);

    这个函数返回一个整型数字，传一个数组和需要查询的坐标即可。我们最后只需要将返回的这个整型数字+字符0即可得到对应的字符，然后将这个字符赋值给show数组对应的位置，并打印出来

     那么我们现在该实现get_mine_count这个函数了，这个难度也不大，我们把周围一圈的都加起来然后减去8个字符0就可以解决了

    （3)测试

    此时我们的test.c文件是这样的。前面打印出来的那些部分我们后期可以将其给删掉。但是现在我们是正在测试中，没有必要删除。

    被炸死案例

     坐标不合法案例

    （4）排雷的结束条件

    当我们一直排雷下去，我们会发现我们的代码有一点问题，那就是排雷无法结束。所以说我们要在循环加上限制条件，我们可以定义一个变量，每一次没有被炸死则这个变量++。对于我们9*9的棋盘而言只要有81-10=71次没有被炸死，就赢了。所以说我们的代码实现如下

     为了方便测试，我们将雷的数量暂时改为80个，符合我们的预期。

     （5）优化多次排查同一个位置的bug

    在这里相信很多人也都发现了一个bug，那就是这个坐标已经被排查过了，还重复排查的话，那win依然会++，这就是一个漏洞了。所以我们要优化这个bug

    我们在这个位置加上这样一段代码即可，只要不是'*'，就代表这个位置已经被查过了，利用一个continue就可以解决问题了。

     下面是运行测试

    （6）排查雷代码实现如下

    1. //排雷时候需要统计的雷个数
    2. int get_mine_count(char mine[ROWS][COLS], int x, int y)
    3. {
    4. 	return (mine[x - 1][y - 1] + mine[x - 1][y] + mine[x - 1][y + 1] +
    5. 		mine[x + 1][y - 1] + mine[x + 1][y] + mine[x + 1][y + 1] +
    6. 		mine[x][y - 1] + mine[x][y + 1] - 8 * '0');
    7. }
    8.  
    9. //排查雷
    10. void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
    11. {
    12. 	int x = 0;
    13. 	int y = 0;
    14. 	int win = 0;
    15. 	while (win< row*col-EASY_COUNT)
    16. 	{
    17. 		printf("请输入坐标>:\n");
    18. 		scanf("%d %d", &x, &y);
    19. 		if (show[x][y] != '*')
    20. 		{
    21. 			printf("这个位置已经被排查过了，请重新输入坐标\n");
    22. 			continue;
    23. 		}
    24. 		if (x >= 1 && x <= row && y >= 1 && y <= col)
    25. 		{
    26. 			if (mine[x][y] == '1')
    27. 			{
    28. 				printf("很遗憾，你被炸死了\n");
    29. 				DisplayBoard(mine, ROW, COL);
    30. 				break;
    31. 			}
    32. 			else
    33. 			{
    34. 				int n = get_mine_count(mine, x, y);
    35. 				show[x][y] = n + '0';
    36. 				DisplayBoard(show, ROW, COL);
    37. 				win++;
    38. 			}
    39. 		}
    40. 		else
    41. 		{
    42. 			printf("坐标不合法，请重新输入\n");
    43. 		}
    44. 	}
    45. 	if (win == row * col - EASY_COUNT)
    46. 	{
    47. 		printf("恭喜你，你赢了\n");
    48. 		DisplayBoard(mine, ROW, COL);
    49. 	}
    50. }

    四、游戏完整代码（分文件）

    test.c文件

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2.  
    3. #include"game.h"
    4. void meau()
    5. {
    6. 	printf("*************************\n");
    7. 	printf("****** 1. 开始扫雷 ******\n");
    8. 	printf("****** 0. 退出游戏 ******\n");
    9. 	printf("*************************\n");
    10.  
    11. }
    12. void game()
    13. {
    14. 	printf("开始扫雷\n");
    15. 	char mine[ROWS][COLS] = { 0 };
    16. 	char show[ROWS][COLS] = { 0 };
    17. 	//初始化数组
    18. 	InitBoard(mine, ROWS, COLS, '0');
    19. 	InitBoard(show, ROWS, COLS, '*');
    20. 	//打印数组
    21. 	//DisplayBoard(mine, ROW, COL);//这是用来测试时使用的
    22. 	DisplayBoard(show, ROW, COL);
    23. 	//布置雷
    24. 	SetMine(mine, ROW, COL);
    25. 	//DisplayBoard(mine, ROW, COL);//这是用来测试时使用的
    26. 	//排查雷
    27. 	FindMine(mine, show, ROW, COL);
    28.  
    29.  
    30. }
    31. void test()
    32. {
    33. 	srand((unsigned int)time(NULL));
    34. 	int input = 0;
    35. 	do
    36. 	{
    37. 		meau();
    38. 		printf("请输入选项>:\n");
    39. 		scanf("%d", &input);
    40. 		switch (input)
    41. 		{
    42. 		case 1:
    43. 			game();
    44. 			break;
    45. 		case 0:
    46. 			printf("退出游戏\n");
    47. 			break;
    48. 		default:
    49. 			printf("输入错误，请重新输入\n");
    50. 			break;
    51. 		}
    52. 	} while (input);
    53. }
    54. int main()
    55. {
    56. 	test();
    57. 	return 0;
    58. }

    game.h文件

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

    game.c文件

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include"game.h"
    3. //初始化数组
    4. void InitBoard(char board[ROWS][COLS], int rows, int cols, char set)
    5. {
    6. 	int i = 0;
    7. 	for (i = 0; i < rows; i++)
    8. 	{
    9. 		int j = 0;
    10. 		for (j = 0; j < cols; j++)
    11. 		{
    12. 			board[i][j] = set;
    13. 		}
    14. 	}
    15. }
    16. //打印数组
    17. void DisplayBoard(char board[ROWS][COLS], int row, int col)
    18. {
    19. 	printf("-------扫雷--------\n");
    20. 	int i = 0;
    21. 	int j = 0;
    22. 	for (j = 0; j <= col; j++)
    23. 	{
    24. 		printf("%d ", j);
    25. 	}
    26. 	printf("\n");
    27. 	for (i = 1; i <= row; i++)
    28. 	{
    29. 		printf("%d ", i);
    30. 		for (j = 1; j <= col; j++)
    31. 		{
    32. 			printf("%c ", board[i][j]);
    33. 		}
    34. 		printf("\n");
    35. 	}
    36. 	printf("-------扫雷--------\n");
    37.  
    38. }
    39. //布置雷
    40. void SetMine(char board[ROWS][COLS], int row, int col)
    41. {
    42. 	//雷的个数
    43. 	int count = EASY_COUNT;
    44. 	while (count)
    45. 	{
    46. 		//生成随机下标
    47. 		int x = rand() % row + 1;
    48. 		int y = rand() % col + 1;
    49. 		//布雷
    50. 		if (board[x][y] == '0')
    51. 		{
    52. 			board[x][y] = '1';
    53. 			count--;
    54. 		}
    55. 	}
    56. }
    57. //排雷时候需要统计的雷个数
    58. int get_mine_count(char mine[ROWS][COLS], int x, int y)
    59. {
    60. 	return (mine[x - 1][y - 1] + mine[x - 1][y] + mine[x - 1][y + 1] +
    61. 		mine[x + 1][y - 1] + mine[x + 1][y] + mine[x + 1][y + 1] +
    62. 		mine[x][y - 1] + mine[x][y + 1] - 8 * '0');
    63. }
    64.  
    65. //排查雷
    66. void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
    67. {
    68. 	int x = 0;
    69. 	int y = 0;
    70. 	int win = 0;
    71. 	while (win< row*col-EASY_COUNT)
    72. 	{
    73. 		printf("请输入坐标>:\n");
    74. 		scanf("%d %d", &x, &y);
    75. 		if (show[x][y] != '*')
    76. 		{
    77. 			printf("这个位置已经被排查过了，请重新输入坐标\n");
    78. 			continue;
    79. 		}
    80. 		if (x >= 1 && x <= row && y >= 1 && y <= col)
    81. 		{
    82. 			if (mine[x][y] == '1')
    83. 			{
    84. 				printf("很遗憾，你被炸死了\n");
    85. 				DisplayBoard(mine, ROW, COL);
    86. 				break;
    87. 			}
    88. 			else
    89. 			{
    90. 				int n = get_mine_count(mine, x, y);
    91. 				show[x][y] = n + '0';
    92. 				DisplayBoard(show, ROW, COL);
    93. 				win++;
    94. 			}
    95. 		}
    96. 		else
    97. 		{
    98. 			printf("坐标不合法，请重新输入\n");
    99. 		}
    100. 	}
    101. 	if (win == row * col - EASY_COUNT)
    102. 	{
    103. 		printf("恭喜你，你赢了\n");
    104. 		DisplayBoard(mine, ROW, COL);
    105. 	}
    106. }
    107.

    五、完整代码展示（合并为同一个文件）

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2.  
    3.  
    4. #include<stdio.h>
    5. #include<time.h>
    6. #include<stdlib.h>
    7.  
    8. #define ROW 9
    9. #define COL 9
    10.  
    11. #define ROWS ROW+2
    12. #define COLS COL+2
    13.  
    14. #define EASY_COUNT 10
    15.  
    16. //初始化数组
    17. void InitBoard(char board[ROWS][COLS], int rows, int cols, char set);
    18. //打印数组
    19. void DisplayBoard(char board[ROWS][COLS], int row, int col);
    20. //布置雷
    21. void SetMine(char board[ROWS][COLS], int row, int col);
    22. //排查雷
    23. void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col);
    24. void meau()
    25. {
    26. 	printf("*************************\n");
    27. 	printf("****** 1. 开始扫雷 ******\n");
    28. 	printf("****** 0. 退出游戏 ******\n");
    29. 	printf("*************************\n");
    30.  
    31. }
    32. void game()
    33. {
    34. 	printf("开始扫雷\n");
    35. 	char mine[ROWS][COLS] = { 0 };
    36. 	char show[ROWS][COLS] = { 0 };
    37. 	//初始化数组
    38. 	InitBoard(mine, ROWS, COLS, '0');
    39. 	InitBoard(show, ROWS, COLS, '*');
    40. 	//打印数组
    41. 	//DisplayBoard(mine, ROW, COL);//这是用来测试时使用的
    42. 	DisplayBoard(show, ROW, COL);
    43. 	//布置雷
    44. 	SetMine(mine, ROW, COL);
    45. 	//DisplayBoard(mine, ROW, COL);//这是用来测试时使用的
    46. 	//排查雷
    47. 	FindMine(mine, show, ROW, COL);
    48.  
    49.  
    50. }
    51. void test()
    52. {
    53. 	srand((unsigned int)time(NULL));
    54. 	int input = 0;
    55. 	do
    56. 	{
    57. 		meau();
    58. 		printf("请输入选项>:\n");
    59. 		scanf("%d", &input);
    60. 		switch (input)
    61. 		{
    62. 		case 1:
    63. 			game();
    64. 			break;
    65. 		case 0:
    66. 			printf("退出游戏\n");
    67. 			break;
    68. 		default:
    69. 			printf("输入错误，请重新输入\n");
    70. 			break;
    71. 		}
    72. 	} while (input);
    73. }
    74. int main()
    75. {
    76. 	test();
    77. 	return 0;
    78. }
    79.  
    80.  
    81. //初始化数组
    82. void InitBoard(char board[ROWS][COLS], int rows, int cols, char set)
    83. {
    84. 	int i = 0;
    85. 	for (i = 0; i < rows; i++)
    86. 	{
    87. 		int j = 0;
    88. 		for (j = 0; j < cols; j++)
    89. 		{
    90. 			board[i][j] = set;
    91. 		}
    92. 	}
    93. }
    94. //打印数组
    95. void DisplayBoard(char board[ROWS][COLS], int row, int col)
    96. {
    97. 	printf("-------扫雷--------\n");
    98. 	int i = 0;
    99. 	int j = 0;
    100. 	for (j = 0; j <= col; j++)
    101. 	{
    102. 		printf("%d ", j);
    103. 	}
    104. 	printf("\n");
    105. 	for (i = 1; i <= row; i++)
    106. 	{
    107. 		printf("%d ", i);
    108. 		for (j = 1; j <= col; j++)
    109. 		{
    110. 			printf("%c ", board[i][j]);
    111. 		}
    112. 		printf("\n");
    113. 	}
    114. 	printf("-------扫雷--------\n");
    115.  
    116. }
    117. //布置雷
    118. void SetMine(char board[ROWS][COLS], int row, int col)
    119. {
    120. 	//雷的个数
    121. 	int count = EASY_COUNT;
    122. 	while (count)
    123. 	{
    124. 		//生成随机下标
    125. 		int x = rand() % row + 1;
    126. 		int y = rand() % col + 1;
    127. 		//布雷
    128. 		if (board[x][y] == '0')
    129. 		{
    130. 			board[x][y] = '1';
    131. 			count--;
    132. 		}
    133. 	}
    134. }
    135. //排雷时候需要统计的雷个数
    136. int get_mine_count(char mine[ROWS][COLS], int x, int y)
    137. {
    138. 	return (mine[x - 1][y - 1] + mine[x - 1][y] + mine[x - 1][y + 1] +
    139. 		mine[x + 1][y - 1] + mine[x + 1][y] + mine[x + 1][y + 1] +
    140. 		mine[x][y - 1] + mine[x][y + 1] - 8 * '0');
    141. }
    142.  
    143. //排查雷
    144. void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
    145. {
    146. 	int x = 0;
    147. 	int y = 0;
    148. 	int win = 0;
    149. 	while (win < row * col - EASY_COUNT)
    150. 	{
    151. 		printf("请输入坐标>:\n");
    152. 		scanf("%d %d", &x, &y);
    153. 		if (show[x][y] != '*')
    154. 		{
    155. 			printf("这个位置已经被排查过了，请重新输入坐标\n");
    156. 			continue;
    157. 		}
    158. 		if (x >= 1 && x <= row && y >= 1 && y <= col)
    159. 		{
    160. 			if (mine[x][y] == '1')
    161. 			{
    162. 				printf("很遗憾，你被炸死了\n");
    163. 				DisplayBoard(mine, ROW, COL);
    164. 				break;
    165. 			}
    166. 			else
    167. 			{
    168. 				int n = get_mine_count(mine, x, y);
    169. 				show[x][y] = n + '0';
    170. 				DisplayBoard(show, ROW, COL);
    171. 				win++;
    172. 			}
    173. 		}
    174. 		else
    175. 		{
    176. 			printf("坐标不合法，请重新输入\n");
    177. 		}
    178. 	}
    179. 	if (win == row * col - EASY_COUNT)
    180. 	{
    181. 		printf("恭喜你，你赢了\n");
    182. 		DisplayBoard(mine, ROW, COL);
    183. 	}
    184. }

    总结

    本节主要讲解了扫雷游戏的实现。这是一个经典的游戏。其中的很多细节都在里面讲到了。当然还有一些不足之处，我们在网页上的扫雷他是可以进行展开的，可以展开一片的。这一点我们本节咱不讨论。我们会放在后面的文章中将扫雷进行升级，同样的三子棋也在后面的文章中进行升级。

    写文章不易，如果对你有帮助的话，不要忘记点赞加收藏哦！！！

  • 相关阅读:
    pyspark实现csv文件转parquet格式（最优解决方案）
    第二章 第二十五节：文件操作：with和复制
    SpringBoot防Xss攻击
    ArcGIS笔记7_如何创建新的shp要素文件？新shp的坐标系选择？
    Fedora 35 部署DNS主从和分离解析 —— 筑梦之路
    基于深度强化学习的四旋翼无人机航线跟随
    el-input输入框涉及到scope的校验问题
    MySQL数据库用户管理
    同花顺平台指标源码 【控盘度指标线】
    天融信上网行为管理系统设置wifi短信验证流程
  • 原文地址：https://blog.csdn.net/jhdhdhehej/article/details/127940885