• C语言第十一课(下)：优化扫雷游戏

    目录

    前言：

    一、功能优化：

    1.清理展开优化：

    2.估测地雷标记：

    3.剩余雷量显示：

    4.胜利条件更新：

    二、界面优化：

    三、终极优化后最终全部代码：

    1.game.h：

    2.game.c：

    3.test.c：

    四、总结：

    前言：

            在上一篇文章中，我和各位小伙伴们一起，成功编写出了一个基础版扫雷游戏。但作为基础版的它依旧存在着一些缺陷，而在本文中，我们将要对基础版扫雷游戏进行功能、界面两个方面的优化。

    一、功能优化：

    1.清理展开优化：

            我们上次说到，在我们进行扫雷时，当我们对某坐标进行排雷时，只能排除该坐标，而不能像真正的扫雷游戏一样，在排除一个坐标时，选中一次就可以展开相邻的一大片安全位置。我们现在就来增加并优化这个功能。

            我们该怎么优化这个功能呢？首先，我们执行该功能的前提是该位置是安全的。则我们将该功能写成一个函数，并将其添加在我们之前就写好的，判断该位置没有“地雷”、已经判断安全的位置上：

    1. else
    2. {
    3. 	int n = get_mine_count(mine, x, y);
    4. 	show[x][y] = n + '0';
    5. 	
    6.     //清除展开函数：
    7.     Cls(mine, show, row, col, x, y);
    8.  
    9. 	DisplayBoard(show, ROW, COL);
    10. 	win++;
    11. 	break;
    12. }

            接下来就是这个函数功能的实现了，首先当前选中位置已经确定为安全了，则将数组与该位置坐标全部传入函数中，若该位置存放的位置为' 0 '，则说明该以位置为中心的九宫格内均不是“地雷”，则将该位置替换为空格符'  '并放置在展示数组中，在每一次清除展开处理结束后打印展示给玩家：

    1. void Cls(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col, int x, int y)
    2. {
    3. 	if (show[x][y] == '0')
    4. 	//若此元素已经为'0'，则进入此函数
    5. 	{
    6. 		show[x][y] = ' ';
    7. 	}
    8. }

            当然，仅仅只处理选中坐标是远远不够的，我们的目标是一次性处理大片的坐标。我们的处理方法是，通过遍历来对以该坐标为中心的九宫格内其他坐标进行相同的操作：

    1. void Cls(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col, int x, int y)
    2. {
    3. 	if (show[x][y] == '0')
    4. 	//若此坐标内元素为'0'，则进入此函数
    5. 	{
    6. 		show[x][y] = ' ';
    7. 		int i = x - 1;
    8. 		for (; i <= x + 1; i++)
    9. 		{
    10. 			int j = y - 1;
    11. 			for (; j <= y + 1; j++)
    12. 			{
    13. 				if (i >= 1 && i <= row && j >= 1 && j <= col)
    14.                 //检查坐标越界
    15. 				{
    16. 					int ret = get_mine_count(mine, i, j);
    17. 					show[i][j] = '0' + ret;
    18. 				}
    19. 			}
    20. 		}
    21. 	}
    22. }

            同时，在对周围坐标进行处理前，若周围坐标已经在之前的处理中被替换为了空格符，则不再进行接下来的替换操作，进行下一个坐标的判断与操作：

    1. void Cls(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col, int x, int y)
    2. {
    3. 	if (show[x][y] == '0')
    4. 	//若此坐标内元素为'0'，则进入此函数
    5. 	{
    6. 		show[x][y] = ' ';
    7. 		int i = x - 1;
    8. 		for (; i <= x + 1; i++)
    9. 		{
    10. 			int j = y - 1;
    11. 			for (; j <= y + 1; j++)
    12. 			{
    13. 				if (show[i][j] == ' ')
    14. 				{
    15. 					continue;
    16. 				}
    17. 				if (i >= 1 && i <= row && j >= 1 && j <= col)
    18. 				//检查坐标越界
    19. 				{
    20. 					int ret = get_mine_count(mine, i, j);
    21. 					show[i][j] = '0' + ret;
    22. 					Cls(mine, show, row, col, i, j);
    23. 					//不断迭代，直到不再出现0或数字为止
    24. 				}
    25.  
    26. 			}
    27. 		}
    28. 	}
    29. }

            同时我们还要注意之前进行过周围计数处理，并且需要在屏幕上打印出周围“地雷”数量的坐标，我们也要将其跳过，不能进行重复处理：

    1. void Cls(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col, int x, int y)
    2. {
    3. 	if (show[x][y] == '0')
    4. 	//若此坐标内元素为'0'，则进入此函数
    5. 	{
    6. 		show[x][y] = ' ';
    7. 		int i = x - 1;
    8. 		for (; i <= x + 1; i++)
    9. 		{
    10. 			int j = y - 1;
    11. 			for (; j <= y + 1; j++)
    12. 			{
    13. 				if (show[i][j] == ' ')
    14. 				{
    15. 					continue;
    16. 				}
    17. 				if (i >= 1 && i <= row && j >= 1 && j <= col)
    18. 				//检查坐标越界
    19. 				{
    20. 					if (show[i][j] != '*')
    21. 					//如果该元素不是'*'，即已经被赋值,则无需进行下面的操作
    22. 					{
    23. 						continue;
    24. 					}
    25. 					int ret = get_mine_count(mine, i, j);
    26. 					show[i][j] = '0' + ret;
    27. 				}
    28. 			}
    29. 		}
    30. 	}
    31. }

            最后，我们通过使用迭代处理，对最初的坐标周围九宫格内的坐标进行相同的上述操作，清除展开功能实现：

    1. void Cls(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col, int x, int y)
    2. {
    3. 	if (show[x][y] == '0')
    4. 	//若此坐标内元素为'0'，则进入此函数
    5. 	{
    6. 		show[x][y] = ' ';
    7. 		int i = x - 1;
    8. 		for (; i <= x + 1; i++)
    9. 		{
    10. 			int j = y - 1;
    11. 			for (; j <= y + 1; j++)
    12. 			{
    13. 				if (show[i][j] == ' ')
    14. 				{
    15. 					continue;
    16. 				}
    17. 				if (i >= 1 && i <= row && j >= 1 && j <= col)
    18. 				//检查坐标越界
    19. 				{
    20. 					if (show[i][j] != '*')
    21. 					//如果该元素不是'*'，即已经被赋值,则无需进行下面的操作
    22. 					{
    23. 						continue;
    24. 					}
    25. 					int ret = get_mine_count(mine, i, j);
    26. 					show[i][j] = '0' + ret;
    27. 					Cls(mine, show, row, col, i, j);
    28. 					//不断迭代，直到不再出现0或数字为止
    29. 				}
    30. 			}
    31. 		}
    32. 	}
    33. }

    2.估测地雷标记：

            为了方便玩家更好的进行排雷，我们还可以在每次排雷前向玩家提供一个标记地雷的功能，来帮助玩家对排雷推理的展示更加清晰，使玩家的游戏过程更加轻松：

    1. void PlayerJudge(char show[ROWS][COLS], int row, int col)
    2. {
    3. 	int m = 0;
    4. 	do
    5. 	{
    6. 		printf("请问您是否想要标记某位置？\n");
    7. 		printf("是：1 否：0：");
    8. 		scanf("%d", &m);
    9. 		switch (m)
    10. 		{
    11. 		case 1:
    12. 			Judge(show, row, col);
    13. 			break;
    14. 		case 0:
    15. 			break;
    16. 		default:
    17. 			printf("输入有误，请重新输入:\n");
    18. 			break;
    19. 		}
    20. 	} while (m);
    21. }

            实现原理类似于菜单函数的处理，通过do-while语句与switch语句的结合使用来达到我们的目的。

            而该功能的重点依旧是标记功能函数Judge的实现定义：

    1. void Judge(char show[ROWS][COLS], int row, int col)
    2. {
    3. 	int x = 0;
    4. 	int y = 0;
    5. 	while (1)
    6. 	{
    7. 		int a = 0;
    8. 		int b = 0;
    9. 		printf("请输入你想标记的坐标行号：");
    10. 		scanf("%d", &a);
    11. 		printf("请输入你想标记的坐标列号：");
    12. 		scanf("%d", &b);
    13. 		if (a >= 1 && a <= row && b >= 1 && b <= col)
    14. 		{
    15. 			x = a;
    16. 			y = b;
    17. 			break;
    18. 		}
    19. 		else
    20. 		{
    21. 			printf("您选择的坐标有误，请重新选择！\n");
    22. 		}
    23. 	}
    24. 	while (1)
    25. 	{
    26. 		printf("1 - 不确定是否为雷\n");
    27. 		printf("2 - 确定是雷\n");
    28. 		printf("3 - 取消标记\n");
    29. 		printf("4 - 取消操作\n");
    30. 		printf("请输入你想对该坐标进行的操作：");
    31. 		int c = 0;
    32. 		scanf("%d", &c);
    33. 		if (show[x][y] == '*')
    34. 		{
    35. 			if (c == 1)
    36. 			{
    37. 				c = 63;
    38. 				//符号？对应的ASCII码值为63
    39. 			}
    40. 			if (c == 2)
    41. 			{
    42. 				c = 35;
    43. 				//符号#对应的ASCII码值为35
    44. 			}
    45. 			if (c == 4)
    46. 			{
    47. 				printf("操作已取消，请重新选择！\n");
    48. 				DisplayBoard(show, row, col);
    49. 				break;
    50. 			}
    51. 			char ch = c;
    52. 			show[x][y] = ch;
    53. 			printf("标记成功!\n");
    54. 			DisplayBoard(show, row, col);
    55. 			break;
    56. 		}
    57. 		else if (show[x][y] == '？' || show[x][y] == '#' && c == 3)
    58. 		//如果输入3还要判断该元素是否已经被标记
    59. 		{
    60. 			show[x][y] = '*';
    61. 			printf("取消成功!\n");
    62. 			DisplayBoard(show, row, col);
    63. 			break;
    64. 		}
    65. 		if (c == 4)
    66. 		{
    67. 			printf("操作已取消，请重新选择！\n");
    68. 			break;
    69. 		}
    70. 		else
    71. 		{
    72. 			printf("输入位置不合法，请重新输入\n");
    73. 		}
    74. 	}
    75. }

            首先，我们让玩家按照一定格式输入想要进行标记的坐标，并对该坐标进行合理性确认。接着我们定义出一个整型变量C，用于接收玩家的标记操作输入选择，这个时候我们需要对玩家输入的操作选项C进行分类操作，确保进行正确的对应操作，同时对玩家的标记操作选择合理性也应当进行检查。

            这里我们需要注意，当我们进行取消操作时，会出现两种情况，即该位置上的符号可能为' # '，也可能不为' # '，所以我们在对选项4进行处理时，应当对各种情况均考虑到位。

    3.剩余雷量显示：

            在上面的游戏中，我们便可以进行排雷和标记，则我们可以再度添加一个剩余雷量显示来辅助玩家进行游戏：

    1. else
    2. {
    3. 	int n = get_mine_count(mine, x, y);
    4. 	show[x][y] = n + '0';
    5. 	Cls(mine, show, row, col, x, y);
    6.  
    7. 	int res = LeaveMine(show, row, col);
    8. 	printf("剩余雷量：%d\n", EASY_COUNT - res);
    9.  
    10. 	DisplayBoard(show, ROW, COL);
    11. 	win++;
    12. 	break;
    13. }

            剩余雷量的计算则十分简单了，它的计算不是去计算真实的雷量，我们只需要采用遍历思想，计算展示数组show中被我们标记为“地雷”的表示符号' # '即可：

    1. int LeaveMine(char show[ROWS][COLS], int row, int col)
    2. {
    3. 	int i = 1;
    4. 	int num = 0;
    5. 	for (i = 1; i <= row; i++)
    6. 	{
    7. 		int j = 1;
    8. 		for (j = 1; j <= col; j++)
    9. 		{
    10. 			if (show[i][j] == '#')
    11. 			{
    12. 				num++;
    13. 			}
    14. 		}
    15. 	}
    16. 	return num;
    17. }

    4.胜利条件更新：

            细心的小伙伴们应该已经发现了，在我们进行清除展开时，在函数中同时处理了大量的坐标，而在这些坐标被操作时并没有被计算，最终导致原有的胜利条件无法进行计算，于是我们就需要一个新的胜利判断函数来帮助我们进行胜利条件判断。

            那么我们应该怎么进行判断呢？这里使用的方法是，在执行完每次循环中每个坐标操作后，进行胜利条件判断，死亡或胜利则破坏循环条件，终止循环，在终止循环时再对死亡或胜利进行区别处理即可：

    1. void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
    2. {
    3. 	printf("请输入您想要排查的坐标：\n");
    4. 	int x = 0;
    5. 	int y = 0;
    6. 	int win = 1;
    7. 	while (win)
    8. 	{
    9. 		PlayerJudge(show, row, col);
    10. 		printf("您想排查哪一行：");
    11. 		scanf("%d", &x);
    12. 		if (x >= 1 && x <= row)
    13. 		{
    14. 			while (1)
    15. 			{
    16. 				printf("您想排查哪一列：");
    17. 				scanf("%d", &y);
    18. 				if (y >= 1 && y <= col)
    19. 				{
    20. 					if (show[x][y] != '*')
    21. 					{
    22. 						printf("该坐标已被排查过！\n");
    23. 						DisplayBoard(show, ROW, COL);
    24. 						break;
    25. 					}
    26. 					if (mine[x][y] == '1')
    27. 					{
    28. 						DisplayBoard(mine, ROW, COL);
    29. 						printf("很遗憾，您死了！\n");
    30. 						win = 0;
    31. 						break;
    32. 					}
    33. 					else
    34. 					{
    35. 						int n = get_mine_count(mine, x, y);
    36. 						show[x][y] = n + '0';
    37. 						Cls(mine, show, row, col, x, y, &win);
    38. 						int res = LeaveMine(show, row, col);
    39. 						printf("剩余雷量：%d\n", EASY_COUNT - res);
    40. 						Really_win(show, row, col, &win);
    41. 						DisplayBoard(show, ROW, COL);
    42. 						break;
    43. 					}
    44. 				}
    45. 				else
    46. 				{
    47. 					printf("您输入的列数有误，请重新输入！\n");
    48. 				}
    49. 			}
    50. 		}
    51. 		else
    52. 		{
    53. 			printf("您输入的行数有误，请重新输入！\n");
    54. 		}
    55. 	}
    56. }

            我们对这个胜利判断函数进行定义，当我们排出的“地雷”的数量等于设置的“地雷”数量时，且没有空余格子时，破坏判断条件：

    1. void Really_win(char show[ROWS][COLS], int row, int col, int* win)
    2. {
    3. 	int count1 = 0;
    4. 	int count2 = 0;
    5. 	int i = 0;
    6. 	for (i = 1; i <= row; i++)
    7. 	{
    8. 		int j = 0;
    9. 		for (j = 1; j <= col; j++)
    10. 		{
    11. 			if (show[i][j] == '#')
    12. 			{
    13. 				count1++;
    14. 			}
    15. 			if (show[i][j] == '*')
    16. 			{
    17. 				count2++;
    18. 			}
    19. 		}
    20. 	}
    21. 	if (count1 == EASY_COUNT && count2 == 0)
    22. 	{
    23. 		*win = 0;
    24. 	}
    25. }

            接着我们最后再添加一个变量really_win，并在判断为胜利后改变其取值，再根据其取值来区别于游戏失败，反馈玩家胜利。

            定义并初始化变量really_win：

    int really_win = 0;

            传入函数进行操作： 

    Really_win(show, row, col, &win, &really_win);

            函数进行操作：

    1. void Really_win(char show[ROWS][COLS], int row, int col, int* win, int* really_win)
    2. {
    3. 	int count1 = 0;
    4. 	int count2 = 0;
    5. 	int i = 0;
    6. 	for (i = 1; i <= row; i++)
    7. 	{
    8. 		int j = 0;
    9. 		for (j = 1; j <= col; j++)
    10. 		{
    11. 			if (show[i][j] == '#')
    12. 			{
    13. 				count1++;
    14. 			}
    15. 			if (show[i][j] == '*')
    16. 			{
    17. 				count2++;
    18. 			}
    19. 		}
    20. 	}
    21. 	if (count1 == EASY_COUNT && count2 == 0)
    22. 	{
    23. 		*win = 0;
    24. 		*really_win = 1;
    25. 	}
    26. }

            最后在排雷步骤最后根据really_win的取值反馈给玩家：

    1. if (really_win == 1)
    2. {
    3. 	printf("恭喜您，扫雷成功！\n");
    4. }

            将其组合起来即为完整的功能实现：

    1. void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
    2. {
    3. 	printf("请输入您想要排查的坐标：\n");
    4. 	int x = 0;
    5. 	int y = 0;
    6. 	int win = 1;
    7. 	int really_win = 0;
    8. 	while (win)
    9. 	{
    10. 		PlayerJudge(show, row, col);
    11. 		printf("您想排查哪一行：");
    12. 		scanf("%d", &x);
    13. 		if (x >= 1 && x <= row)
    14. 		{
    15. 			while (1)
    16. 			{
    17. 				printf("您想排查哪一列：");
    18. 				scanf("%d", &y);
    19. 				if (y >= 1 && y <= col)
    20. 				{
    21. 					if (show[x][y] != '*')
    22. 					{
    23. 						printf("该坐标已被排查过！\n");
    24. 						DisplayBoard(show, ROW, COL);
    25. 						break;
    26. 					}
    27. 					if (mine[x][y] == '1')
    28. 					{
    29. 						DisplayBoard(mine, ROW, COL);
    30. 						printf("很遗憾，您死了！\n");
    31. 						win = 0;
    32. 						break;
    33. 					}
    34. 					else
    35. 					{
    36. 						int n = get_mine_count(mine, x, y);
    37. 						show[x][y] = n + '0';
    38. 						Cls(mine, show, row, col, x, y, &win);
    39. 						int res = LeaveMine(show, row, col);
    40. 						printf("剩余雷量：%d\n", EASY_COUNT - res);
    41. 						Really_win(show, row, col, &win, &really_win);
    42. 						DisplayBoard(show, ROW, COL);
    43. 						break;
    44. 					}
    45. 				}
    46. 				else
    47. 				{
    48. 					printf("您输入的列数有误，请重新输入！\n");
    49. 				}
    50. 			}
    51. 		}
    52. 		else
    53. 		{
    54. 			printf("您输入的行数有误，请重新输入！\n");
    55. 		}
    56. 	}
    57. 	if (really_win == 1)
    58. 	{
    59. 		printf("恭喜您，扫雷成功！\n");
    60. 	}
    61. }

    二、界面优化：

            同井字棋的界面优化一样，我们也使用同样的方式对扫雷游戏进行优化，使用的函数、头文件均与井字棋游戏的界面优化完全一致，这里便不再作过多阐述。

    三、终极优化后最终全部代码：

    1.game.h：

    1. #pragma once
    2.  
    3. #define ROW 9
    4. #define COL 9
    5. #define ROWS ROW+2
    6. #define COLS ROW+2
    7. #define EASY_COUNT 10
    8.  
    9. #include
    10. #include
    11. #include
    12. #include
    13.  
    14. void menu();
    15. void game();
    16. void InitBoard(char board[ROWS][COLS], int rows, int cols, char set);
    17. void DisplayBoard(char board[ROWS][COLS], int row, int col);
    18. void SetMine(char mine[ROWS][ROWS], int row, int col);
    19. void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col);
    20. int get_mine_count(char mine[ROWS][COLS], int x, int y);
    21. void Cls(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col, int x, int y, int* win);
    22. void Judge(char show[ROWS][COLS], int row, int col);
    23. void PlayerJudge(char show[ROWS][COLS], int row, int col);
    24. int LeaveMine(char show[ROWS][COLS], int row, int col);
    25. void Really_win(char show[ROWS][COLS], int row, int col, int* win, int* really_win);

    2.game.c：

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2.  
    3. #include"game.h"
    4.  
    5. //打印菜单：
    6. void menu()
    7. {
    8. 	printf("******************************\n");
    9. 	printf("******************************\n");
    10. 	printf("*****  欢迎来到扫雷游戏  *****\n");
    11. 	printf("*****       1.play       *****\n");
    12. 	printf("*****       0.exit       *****\n");
    13. 	printf("******************************\n");
    14. 	printf("******************************\n");
    15. }
    16.  
    17. //初始化棋盘：
    18. void InitBoard(char board[ROWS][COLS], int rows, int cols, char set)
    19. {
    20. 	int i = 0;
    21. 	for (i = 0; i < rows; i++)
    22. 	{
    23. 		int j = 0;
    24. 		for (j = 0; j < cols; j++)
    25. 		{
    26. 			board[i][j] = set;
    27. 		}
    28. 	}
    29. }
    30.  
    31. //打印棋盘：
    32. void DisplayBoard(char board[ROWS][COLS], int row, int col)
    33. {
    34. 	printf("  --------扫雷--------\n");
    35. 	int i = 0;
    36. 	printf("| \\ 1 2 3 4 5 6 7 8 9 |\n");
    37. 	for (i = 1; i <= row; i++)
    38. 	{
    39. 		int j = 0;
    40. 		printf("| %d ", i);
    41. 		for (j = 1; j <= col; j++)
    42. 		{
    43. 			printf("%c ", board[i][j]);
    44. 		}
    45. 		printf("|\n");
    46. 	}
    47. 	printf("  --------扫雷--------\n");
    48. }
    49.  
    50. //布置雷：
    51. void SetMine(char mine[ROWS][ROWS], int row, int col)
    52. {
    53. 	int count = EASY_COUNT;
    54. 	while (count)
    55. 	{
    56. 		//生成随机下标：
    57. 		int x = rand() % row + 1;
    58. 		int y = rand() % col + 1;
    59. 		//布置雷：
    60. 		if (mine[x][y] == '0')
    61. 		{
    62. 			mine[x][y] = '1';
    63. 			count--;
    64. 		}
    65. 	}
    66. }
    67.  
    68. //统计雷：
    69. int get_mine_count(char mine[ROWS][COLS], int x, int y)
    70. {
    71. 	return (mine[x - 1][y - 1] + mine[x][y - 1] + mine[x + 1][y - 1] + mine[x - 1][y] + mine[x + 1][y] + mine[x - 1][y + 1] + mine[x][y + 1] + mine[x + 1][y + 1] - 8 * '0');
    72. }
    73.  
    74. //清理展开：
    75. void Cls(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col, int x, int y, int* win)
    76. 	{
    77. 	if (show[x][y] == '0')
    78. 	//若此坐标内元素为'0'，则进入此函数
    79. 	{
    80. 		show[x][y] = ' ';
    81. 		int i = x - 1;
    82. 		for (; i <= x + 1; i++)
    83. 		{
    84. 			int j = y - 1;
    85. 			for (; j <= y + 1; j++)
    86. 			{
    87. 				if (show[i][j] == ' ')
    88. 				{
    89. 					continue;
    90. 				}
    91. 				if (i >= 1 && i <= row && j >= 1 && j <= col)
    92. 				//检查坐标越界
    93. 				{
    94. 					if (show[i][j] != '*')
    95. 					//如果该元素不是'*'，即已经被赋值,则无需进行下面的操作
    96. 					{
    97. 						continue;
    98. 					}
    99. 					int ret = get_mine_count(mine, i, j);
    100. 					show[i][j] = '0' + ret;
    101. 					*win++;
    102. 					Cls(mine, show, row, col, i, j, &win);
    103. 					//不断迭代，直到不再出现0或数字为止
    104. 				}
    105. 			}
    106. 		}
    107. 	}
    108. }
    109.  
    110. //标记坐标：
    111. void Judge(char show[ROWS][COLS], int row, int col)
    112. {
    113. 	int x = 0;
    114. 	int y = 0;
    115. 	while (1)
    116. 	{
    117. 		int a = 0;
    118. 		int b = 0;
    119. 		printf("请输入你想标记的坐标行号：");
    120. 		scanf("%d", &a);
    121. 		printf("请输入你想标记的坐标列号：");
    122. 		scanf("%d", &b);
    123. 		if (a >= 1 && a <= row && b >= 1 && b <= col)
    124. 		{
    125. 			x = a;
    126. 			y = b;
    127. 			Sleep(500);
    128. 			break;
    129. 		}
    130. 		else
    131. 		{
    132. 			system("cls");
    133. 			printf("您选择的坐标有误，请重新选择！\n");
    134. 			Sleep(1000);
    135. 			system("cls");
    136. 			DisplayBoard(show, row, col);
    137. 		}
    138. 	}
    139. 	while (1)
    140. 	{
    141. 		system("cls");
    142. 		DisplayBoard(show, row, col);
    143. 		printf("1 - 不确定是否为雷\n");
    144. 		printf("2 - 确定是雷\n");
    145. 		printf("3 - 取消标记\n");
    146. 		printf("4 - 取消操作\n");
    147. 		printf("请输入你想对该坐标进行的操作：");
    148. 		int c = 0;
    149. 		scanf("%d", &c);
    150. 		Sleep(500);
    151. 		system("cls");
    152. 		if (show[x][y] == '*')
    153. 		{
    154. 			if (c == 1)
    155. 			{
    156. 				c = 63;
    157. 				//符号？对应的ASCII码值为63
    158. 			}
    159. 			if (c == 2)
    160. 			{
    161. 				c = 35;
    162. 				//符号#对应的ASCII码值为35
    163. 			}
    164. 			if (c == 4)
    165. 			{
    166. 				printf("操作已取消，请重新选择！\n");
    167. 				DisplayBoard(show, row, col);
    168. 				break;
    169. 			}
    170. 			char ch = c;
    171. 			show[x][y] = ch;
    172. 			printf("标记成功!\n");
    173. 			DisplayBoard(show, row, col);
    174. 			break;
    175. 		}
    176. 		else if (show[x][y] == '？' || show[x][y] == '#' && c == 3)
    177. 		//如果输入3还要判断该元素是否已经被标记
    178. 		{
    179. 			show[x][y] = '*';
    180. 			printf("取消成功!\n");
    181. 			DisplayBoard(show, row, col);
    182. 			break;
    183. 		}
    184. 		else if (c == 4)
    185. 		{
    186. 			printf("操作已取消，请重新选择！\n");
    187. 			Sleep(1000);
    188. 			system("cls");
    189. 			DisplayBoard(show, row, col);
    190. 			break;
    191. 		}
    192. 		else
    193. 		{
    194. 			printf("输入位置不合法，请重新输入\n");
    195. 		}
    196. 	}
    197. }
    198.  
    199. //标记确认：
    200. void PlayerJudge(char show[ROWS][COLS], int row, int col)
    201. {
    202. 	int m = 0;
    203. 	do
    204. 	{
    205. 		printf("请问您是否想要标记某位置？\n");
    206. 		printf("是：1 否：0：");
    207. 		scanf("%d", &m);
    208. 		switch (m)
    209. 		{
    210. 		case 1:
    211. 			Sleep(500);
    212. 			system("cls");
    213. 			DisplayBoard(show, ROW, COL);
    214. 			Judge(show, row, col);
    215. 			break;
    216. 		case 0:
    217. 			Sleep(1000);
    218. 			system("cls");
    219. 			DisplayBoard(show, ROW, COL);
    220. 			break;
    221. 		default:
    222. 			system("cls");
    223. 			printf("输入有误，请重新输入:\n");
    224. 			Sleep(1000);
    225. 			system("cls");
    226. 			DisplayBoard(show, ROW, COL);
    227. 			break;
    228. 		}
    229. 	} while (m);
    230. }
    231.  
    232. //剩余雷量计算：
    233. int LeaveMine(char show[ROWS][COLS], int row, int col)
    234. {
    235. 	int i = 1;
    236. 	int num = 0;
    237. 	for (i = 1; i <= row; i++)
    238. 	{
    239. 		int j = 1;
    240. 		for (j = 1; j <= col; j++)
    241. 		{
    242. 			if (show[i][j] == '#')
    243. 			{
    244. 				num++;
    245. 			}
    246. 		}
    247. 	}
    248. 	return num;
    249. }
    250.  
    251. //胜利判定：
    252. void Really_win(char show[ROWS][COLS], int row, int col, int* win, int* really_win)
    253. {
    254. 	int count1 = 0;
    255. 	int count2 = 0;
    256. 	int i = 0;
    257. 	for (i = 1; i <= row; i++)
    258. 	{
    259. 		int j = 0;
    260. 		for (j = 1; j <= col; j++)
    261. 		{
    262. 			if (show[i][j] == '#')
    263. 			{
    264. 				count1++;
    265. 			}
    266. 			if (show[i][j] == '*')
    267. 			{
    268. 				count2++;
    269. 			}
    270. 		}
    271. 	}
    272. 	if (count1 == EASY_COUNT && count2 == 0)
    273. 	{
    274. 		*win = 0;
    275. 		*really_win = 1;
    276. 	}
    277. }
    278.  
    279. //排雷：
    280. void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
    281. {
    282. 	printf("请输入您想要排查的坐标：\n");
    283. 	int x = 0;
    284. 	int y = 0;
    285. 	int win = 1;
    286. 	int really_win = 0;
    287. 	while (win)
    288. 	{
    289. 		PlayerJudge(show, row, col);
    290. 		printf("您想排查哪一行：");
    291. 		scanf("%d", &x);
    292. 		if (x >= 1 && x <= row)
    293. 		{
    294. 			while (1)
    295. 			{
    296. 				printf("您想排查哪一列：");
    297. 				scanf("%d", &y);
    298. 				if (y >= 1 && y <= col)
    299. 				{
    300. 					if (show[x][y] != '*')
    301. 					{
    302. 						system("cls");
    303. 						printf("该坐标已被排查过！\n");
    304. 						Sleep(1000);
    305. 						system("cls");
    306. 						DisplayBoard(show, ROW, COL);
    307. 						break;
    308. 					}
    309. 					if (mine[x][y] == '1')
    310. 					{
    311. 						system("cls");
    312. 						DisplayBoard(mine, ROW, COL);
    313. 						printf("很遗憾，您死了！\n");
    314. 						win = 0;
    315. 						Sleep(1000);
    316. 						system("cls");
    317. 						break;
    318. 					}
    319. 					else
    320. 					{
    321. 						int n = get_mine_count(mine, x, y);
    322. 						show[x][y] = n + '0';
    323. 						Cls(mine, show, row, col, x, y, &win);
    324. 						int res = LeaveMine(show, row, col);
    325. 						printf("剩余雷量：%d\n", EASY_COUNT - res);
    326. 						Sleep(1000);
    327. 						system("cls");
    328. 						Really_win(show, row, col, &win, &really_win);
    329. 						DisplayBoard(show, ROW, COL);
    330. 						break;
    331. 					}
    332. 				}
    333. 				else
    334. 				{
    335. 					printf("您输入的列数有误，请重新输入！\n");
    336. 				}
    337. 			}
    338. 		}
    339. 		else
    340. 		{
    341. 			printf("您输入的行数有误，请重新输入！\n");
    342. 		}
    343. 	}
    344. 	if (really_win == 1)
    345. 	{
    346. 		system("cls");
    347. 		printf("恭喜您，扫雷成功！\n");
    348. 		Sleep(1000);
    349. 		system("cls");
    350. 	}
    351. }

    3.test.c：

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

    四、总结：

            当我们完成以上优化后，一个扫雷游戏程序的雏形就基本完成了，我们对其功能和界面都进行了相当程度的优化。但是对于一个程序的全部优化过程来说，可远远不止如此，在以后的学习过程中，我们会学到更多知识，到时候我们还可以使用更高深的知识来对我们的游戏程序进行更深层次的优化。

            到这里我们对扫雷游戏的优化就宣告结束啦，能熟练灵活的掌握、运用我们学过的知识，才是我们的最终目的。懒惰不会让你一下子跌倒，但会在不知不觉中减少你的收获；勤奋也不会让你一夜成功，但会在不知不觉中积累你的成果！

            新人初来乍到，辛苦各位小伙伴们动动小手，三连走一走 ~ ~ ~  最后，本文仍有许多不足之处，欢迎各位看官老爷随时私信批评指正！

  • 相关阅读:
    数据结构与算法———力扣977——双指针——python
    [Python]多任务编程--线程
    前后端分离的后台管理系统源码，快速开发OA、CMS网站后台管理、毕业设计项目
    17.Table Api基础概念讲解
    数据分析 - 分散性与变异的量度
    【网络安全】使用meterpreter进行远控、Mysql注入、反弹型XSS攻防
    OpenAI视频生成Sora技术简析
    百度大模型算法实习岗上岸经验！
    【ros】解决protobuf的安装问题
    Git常用命令汇总
  • 原文地址：https://blog.csdn.net/weixin_59392935/article/details/127985581