• 【C语言】扫雷小游戏（保姆教程）

    目录

    一、扫雷游戏介绍

    二、代码分装

    三、代码实现步骤

    1. 制作菜单menu函数以及游戏运行逻辑流程

    2. 数组棋盘分析

    3. 创建棋盘数组

     4. 初始化棋盘InitBoard函数

    5. 显示棋盘DisplayBoard函数

    6. 布置雷SetMine函数

     7. 统计雷个数GetMineCount函数

     8. 排查雷FindMine函数

    四、扫雷完整代码

    一、扫雷游戏介绍

    《扫雷》是一款大众类的益智小游戏，于1992年发行。游戏目标是在最短的时间内根据点击格子出现的数字找出所有非雷格子，同时避免踩雷，踩到一个雷即全盘皆输。

    二、代码分装

    源文件：

    test.c: 整个游戏相关的测试

    game.c: 实现游戏的相关函数

    头文件：

    game.h: 相关函数的声明，整个代码要引用的头文件以及宏定义

    三、代码实现步骤

    1. 制作菜单menu函数以及游戏运行逻辑流程

    • 首先在 test.c 中定义一个menu函数打印菜单，提示玩家1开始游戏，0退出游戏。
    • scanf接收玩家输入并用switch判断，1即开始游戏，0则退出游戏，非1非0则提示选择错误，重新选择。而为了能够让用户重新选择以及结束一局游戏后能够再来一盘，需要使用do while语句将它们包含起来。
    1. void menu()
    2. {
    3. 	printf("*********************\n");
    4. 	printf("*****  1. game  *****\n");
    5. 	printf("*****  0. exit  *****\n");
    6. 	printf("*********************\n");
    7. }
    8.  
    9. void game()
    10. {
    11. 	printf("扫雷\n");
    12. }
    13.  
    14. int main()
    15. {
    16. 	int input = 0;
    17. 	srand((unsigned int)time(NULL));
    18. 	do
    19. 	{
    20. 		menu();
    21. 		printf("请选择：>");
    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. 	return 0;
    37. }

    2. 数组棋盘分析

    假设需要的棋盘大小为9*9，不是雷用0表示，是雷用1表示。

    为了方便操作，这里定义两个棋盘数组，mine和show，mine棋盘用于存放雷的信息，初始化为0，而show棋盘用来打印给玩家看，初始化为*。同时两个棋盘内存放的类型统一设置为char类型即字符数组，方便操作。

    • 假设雷已经布置进去mine棋盘了，然后假设排查坐标(7,6)的区域时，如果不是雷，系统则需要返回坐标(7,6)周围8个区域的雷数（即黄色的8个区域），此时需要在坐标(7,6)处返回1，而如果返回雷的个数1放在mine棋盘的(7,6)中容易与表示雷的1产生歧义，因此这里的做法是将雷的个数1存放在show棋盘中。
    • 这里还有一个问题，如果排查例如坐标(4,9)的区域时，出现了一部分区域超出了数组的情况（即红色的区域）。为了防止数组越界，此时在每次排查时都需要对周围每个区域进行判断是否超出数组范围，这样操作起来即麻烦，效率又低。

    而我这里的做法是将两个棋盘都扩充一圈（即蓝色区域），此时数组大小便是11*11，这样的好处是既不用担心数组会越界，又可以使坐标系的位置规范，坐标可以完全匹配起来，使得代码的书写更加的方便。

    3. 创建棋盘数组

    为了方便修改，在game.h中定义ROW=9,COL=9,ROWS=ROW+2,COLS=COL+2;

    这里ROW和COL设置为9而ROWS和COLS设置为11是因为，虽然实际的使用范围是11*11，但是布雷区域和给玩家展示的区域仍然是9*9，因此需要两个符号分别表示11*11、9*9。

    1. #define ROW 9
    2. #define COL 9
    3.  
    4. #define ROWS ROW+2 //11
    5. #define COLS COL+2 //11
    1. void game()
    2. {
    3. 	char mine[ROWS][COLS] = { 0 };//放置雷的数组
    4. 	char show[ROWS][COLS] = { 0 };//排查雷信息的数组
    5. }

     4. 初始化棋盘InitBoard函数

    因为初始化的内容不定，一个是0，一个是*，因此需要添加多一个参数用于表示初始化的内容。

    game.h 

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

     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 < rows; i++)
    7. 	{
    8. 		for ( j = 0; j < cols; j++)
    9. 		{
    10. 			board[i][j] = set;
    11. 		}
    12. 	}
    13. }

     test.c

    1. void game()
    2. {
    3. 	char mine[ROWS][COLS] = { 0 };//放置雷的数组
    4. 	char show[ROWS][COLS] = { 0 };//排查雷信息的数组
    5. 	InitBoard(mine, ROWS, COLS, '0');
    6. 	InitBoard(show, ROWS, COLS, '*');
    7. 	
    8. }

     接下来我们做一个显示棋盘函数观察初始化是否成功。

    5. 显示棋盘DisplayBoard函数

    game.h 

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

     game.c

    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. 	for ( i = 0; i <= col; i++) //打印列号 注意这里的i是从0开始
    8. 	{
    9. 		printf("%d ", i);
    10. 	}
    11. 	printf("\n");
    12.  
    13. 	for ( i = 1; i <= row; i++)
    14. 	{
    15. 		printf("%d ", i); //打印行号
    16. 		for ( j = 1; j <= col; j++)
    17. 		{
    18. 			printf("%c ", board[i][j]);
    19. 		}
    20. 		printf("\n");
    21. 	}
    22. 	printf("--------扫雷--------\n");
    23.  
    24. }

    test.c 

    真正需要打印的区域是中间的9*9区域，因此DisplayBoard函数传参是ROW，COL。 

    1. void game()
    2. {
    3. 	char mine[ROWS][COLS] = { 0 };//放置雷的数组
    4. 	char show[ROWS][COLS] = { 0 };//排查雷信息的数组
    5. 	InitBoard(mine, ROWS, COLS, '0');
    6. 	InitBoard(show, ROWS, COLS, '*');
    7. 	DisplayBoard(show, ROW, COL);
    8. 	DisplayBoard(mine, ROW, COL);
    9. }

    此时调用一下显示棋盘函数观察一下初始化是否完成。 

    可以发现初始化完成，一个为全*一个为全0。

    6. 布置雷SetMine函数

        将雷布置到棋盘mine数组中。

        这里布置雷的策列是让雷随机排布，这就需要使用到随机数，而随机数的获取又涉及到srand函数、rand函数以及time函数，关于srand函数、rand函数和time函数之间的知识点，我在往期的博客中有进行讲解，感兴趣的可以前往：【C语言】猜数字小游戏——深度刨析rand函数生成随机数_Hacynn的博客-CSDN博客icon-default.png?t=N7T8https://blog.csdn.net/zzzzzhxxx/article/details/132635456?spm=1001.2014.3001.5502查看，在这里就不过多赘述。

        使用srand和rand需要包含 stdlib.h 头文件，使用time需要包含 time.h 头文件。并且在main函数中调用srand生成随机种子，这样rand函数便可以生成随机数。

     game.h

    1. #include 
    2. #include 
    3. #include 
    4.  
    5. #define EASY_COUNT 10
    6.  
    7. //布置雷
    8. void SetMine(char mine[ROWS][COLS], int row, int col);

     game.c

    使用ESAY_COUNT来表示雷数，用while循环遍历布置，并且每当放入1个雷时count就减1，直到为0时退出循环。

    1. //布置雷
    2. void SetMine(char mine[ROWS][COLS], int row, int col)
    3. {
    4. 	int count = EASY_COUNT;
    5. 	while (count)
    6. 	{
    7. 		int x = rand() % row + 1; //0~8+1 = 1~9
    8. 		int y = rand() % col + 1; //0~8+1 = 1~9
    9. 		if (mine[x][y] == '0')
    10. 		{
    11. 			mine[x][y] = '1';
    12. 			count--;
    13. 		}
    14. 	}
    15. }

    test.c 

    真正需要布置雷的区域是中间的9*9区域，因此SetMine函数传参依然是ROW，COL。 

    布置完雷之后使用DisplayBoard函数打印mine棋盘，布置雷部分便完成。

    1. void game()
    2. {
    3. 	char mine[ROWS][COLS] = { 0 };//放置雷的数组
    4. 	char show[ROWS][COLS] = { 0 };//排查雷信息的数组
    5. 	InitBoard(mine, ROWS, COLS, '0');
    6. 	InitBoard(show, ROWS, COLS, '*');
    7. 	DisplayBoard(show, ROW, COL);
    8.  
    9. 	//布置雷
    10. 	SetMine(mine, ROW, COL);
    11. }

     7. 统计雷个数GetMineCount函数

    假设排查(x,y)坐标，如果不是雷，则需要统计(x,y)周围8个区域的雷数。接下来我将用一张图来解释如何返回。

    上图的x，y就是排查的坐标，那么(1,1)区域就是(x-1,y-1)，(1,2)区域就是(x-1,y)，其他同理。所以只需要将8个区域的值相加，则可以得出雷的个数。

    game.c 

    1. //统计x，y坐标周围有几个雷
    2. int GetMineCount(char mine[ROWS][COLS], int x, int y)
    3. {
    4. 	return mine[x - 1][y - 1] + 
    5. 		mine[x - 1][y] + 
    6. 		mine[x - 1][y + 1] + 
    7. 		mine[x][y - 1] + 
    8. 		mine[x][y + 1] + 
    9. 		mine[x + 1][y - 1] + 
    10. 		mine[x + 1][y] + 
    11. 		mine[x + 1][y + 1] - 8 * '0';
    12. }

    但是需要注意的是，因为mine数组中存放的是字符类型，所以返回的值不能直接使用，需要减去一个字符‘0’才能等于对应的数字（例如下图），所以一共要减去8个'0'，从而实现从char类型到int类型的转变。

     8. 排查雷FindMine函数

    排查雷涉及到两个数组。在棋盘mine数组中排查雷的个数，并在棋盘show数组中展示个数，因此FindMine函数传参时需要传入两个数组。

     game.h

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

     game.c

    首先使用while循环嵌套排查操作部分，当排查到雷时，则提示被炸死了并打印棋盘mine。

    当排查到不是雷时，则需要返回周围8个区域的雷个数，此时需要调用GetMineCount函数，然后打印棋盘show显示雷数，此时的数为int类型，在传入show数组前需要将它与‘0’相加从而得到对应的char类型。

    1. //排查雷
    2. void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
    3. {
    4. 	int x = 0;
    5. 	int y = 0;
    6. 	int win = 0;  //排查成功次数
    7. 	while (win < row * col - EASY_COUNT)
    8. 	{
    9. 		printf("请输入要排查的坐标:>");
    10. 		scanf("%d %d", &x, &y);
    11. 		if (x >= 1 && x <= row && y >= 1 && y <= col)
    12. 		{
    13. 			if (mine[x][y] == '1')
    14. 			{
    15. 				printf("很遗憾，你被炸死了！\n");
    16. 				DisplayBoard(mine, ROW, COL);
    17. 				break;
    18. 			}
    19. 			else
    20. 			{
    21. 				int c = GetMineCount(mine, x, y);
    22. 				show[x][y] = c + '0'; //int转char
    23. 				DisplayBoard(show, ROW, COL);
    24. 				win++;
    25. 			}
    26. 		}
    27. 		else
    28. 		{
    29. 			printf("坐标非法，重新输入！\n");
    30. 		}
    31. 	}
    32. 	if (win == row * col - EASY_COUNT)
    33. 	{
    34. 		printf("恭喜你，排雷成功！\n");
    35. 		DisplayBoard(mine, ROW, COL);
    36. 	}
    37. }

    test.c

    1. void game()
    2. {
    3. 	char mine[ROWS][COLS] = { 0 };//放置雷的数组
    4. 	char show[ROWS][COLS] = { 0 };//排查雷信息的数组
    5. 	InitBoard(mine, ROWS, COLS, '0');
    6. 	InitBoard(show, ROWS, COLS, '*');
    7. 	DisplayBoard(show, ROW, COL);
    8.  
    9. 	//布置雷
    10. 	SetMine(mine, ROW, COL);
    11.  
    12. 	//排查雷
    13. 	FindMine(mine, show, ROW, COL);
    14. }

    四、扫雷完整代码

     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. //初始化棋盘
    14. void InitBoard(char board[ROWS][COLS], int rows, int cols, char set);
    15.  
    16. //显示棋盘
    17. void DisplayBoard(char board[ROWS][COLS], int row, int col);
    18.  
    19. //布置雷
    20. void SetMine(char mine[ROWS][COLS], int row, int col);
    21.  
    22. //排查雷
    23. 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. //初始化棋盘
    6. void InitBoard(char board[ROWS][COLS], int rows, int cols, char set)
    7. {
    8. 	int i = 0;
    9. 	int j = 0;
    10. 	for ( i = 0; i < rows; i++)
    11. 	{
    12. 		for ( j = 0; j < cols; j++)
    13. 		{
    14. 			board[i][j] = set;
    15. 		}
    16. 	}
    17. }
    18.  
    19. //显示棋盘
    20. void DisplayBoard(char board[ROWS][COLS], int row, int col)
    21. {
    22. 	int i = 0;
    23. 	int j = 0;
    24. 	printf("--------扫雷--------\n");
    25. 	for ( i = 0; i <= col; i++) //打印列号 注意这里的i是从0开始
    26. 	{
    27. 		printf("%d ", i);
    28. 	}
    29. 	printf("\n");
    30.  
    31. 	for ( i = 1; i <= row; i++)
    32. 	{
    33. 		printf("%d ", i); //打印行号
    34. 		for ( j = 1; j <= col; j++)
    35. 		{
    36. 			printf("%c ", board[i][j]);
    37. 		}
    38. 		printf("\n");
    39. 	}
    40. 	printf("--------扫雷--------\n");
    41.  
    42. }
    43.  
    44. //布置雷
    45. void SetMine(char mine[ROWS][COLS], int row, int col)
    46. {
    47. 	int count = EASY_COUNT;
    48. 	while (count)
    49. 	{
    50. 		int x = rand() % row + 1; //0~8+1 = 1~9
    51. 		int y = rand() % col + 1; //0~8+1 = 1~9
    52. 		if (mine[x][y] == '0')
    53. 		{
    54. 			mine[x][y] = '1';
    55. 			count--;
    56. 		}
    57. 	}
    58. }
    59.  
    60. //统计x，y坐标周围有几个雷
    61. int GetMineCount(char mine[ROWS][COLS], int x, int y)
    62. {
    63. 	return mine[x - 1][y - 1] + 
    64. 		mine[x - 1][y] + 
    65. 		mine[x - 1][y + 1] + 
    66. 		mine[x][y - 1] + 
    67. 		mine[x][y + 1] + 
    68. 		mine[x + 1][y - 1] + 
    69. 		mine[x + 1][y] + 
    70. 		mine[x + 1][y + 1] - 8 * '0';
    71. }
    72.  
    73. //排查雷
    74. void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
    75. {
    76. 	int x = 0;
    77. 	int y = 0;
    78. 	int win = 0; //排查成功次数
    79. 	while (win < row * col - EASY_COUNT)
    80. 	{
    81. 		printf("请输入要排查的坐标:>");
    82. 		scanf("%d %d", &x, &y);
    83. 		if (x >= 1 && x <= row && y >= 1 && y <= col)
    84. 		{
    85. 			if (mine[x][y] == '1')
    86. 			{
    87. 				printf("很遗憾，你被炸死了！\n");
    88. 				DisplayBoard(mine, ROW, COL);
    89. 				break;
    90. 			}
    91. 			else
    92. 			{
    93. 				int c = GetMineCount(mine, x, y);
    94. 				show[x][y] = c + '0'; //int转char
    95. 				DisplayBoard(show, ROW, COL);
    96. 				win++;
    97. 			}
    98. 		}
    99. 		else
    100. 		{
    101. 			printf("坐标非法，重新输入！\n");
    102. 		}
    103. 	}
    104. 	if (win == row * col - EASY_COUNT)
    105. 	{
    106. 		printf("恭喜你，排雷成功！\n");
    107. 		DisplayBoard(mine, ROW, COL);
    108. 	}
    109. }

    test.c

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

    此次扫雷小游戏的内容就到此为止了，相信大家也能够做出属于自己的三子棋小游戏，这个游戏最重要的是代码思维而不是代码本身，理解代码思维能够得到更大的提升。

    如果觉得作者写的不错，求给作者一个大大的点赞支持一下，你们的支持是我更新的最大动力！

  • 相关阅读:
    ctfshow MengXIn misc1
    利用jenkins直接构件docker镜像并发布
    kafka副本机制
    蓝桥杯 子矩阵 （找大小为a*b的矩阵的最大最小值的乘积，queue）
    SpringSecurity Oauth2实战 - 04 自定义AuthProvider实现认证登录
    CentOS7自有服务和软件包
    【MYSQL】表的增删查改
    622.设计循环队列（LeetCode）
    原型模型（clone()和拷贝构造器之间的选择）
    08.29xpath 和css选择器元素定位练习
  • 原文地址：https://blog.csdn.net/zzzzzhxxx/article/details/132747003