devbox
我家自动化
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C语言基础：扫雷游戏的C语言实现（超详图解+源码）_扫雷c语言程序设计

作者：我家自动化 | 2024-08-03 03:31:52

赞

踩

扫雷c语言程序设计

友友们好，今天和大家一起做一个简单的C语言小游戏——扫雷小游戏。

  游戏规则如下：

       扫雷的规则很简单。盘面上有许多方格，方格中随机分布着一些雷。你的目标是避开雷，打开其他所有格子。一个非雷格中的数字表示其相邻8格中的雷数，你可以利用这个信息推导出安全格和雷的位置。打开所有安全格将被判定为胜利，打开雷将被判定为失败。

目录

实现思路

一、制作一个游戏菜单

二、构建游戏的基本逻辑结构

三、进入游戏的制作

1、定义两个一样的数组

​编辑

2、初始化数组

3、打印盘面

4、布置雷

5、排查雷

·这个坐标不是雷，提示周围有几个雷

·这个坐标是雷，游戏结束   

·所有非雷位置都找到了，游戏胜利

6、game函数的实现

四、扫雷游戏的实现

实现思路

       首先，制作一个游戏菜单，而后构建整个游戏的基本逻辑结构，然后进入游戏的制作。首先要在盘面上随机给出10个雷的位置； 然后玩家需要在盘面的合法位置排雷，如果在非法位置，应给出相应提示；在排雷的同时要判断游戏是否结束，如果结束需要判断胜负。

       接下来我们就以这个基本思路来进行代码的实现。

一、制作一个游戏菜单

首先，我们要制作一个游戏菜单。我们用一个简易的函数来实现他。

  1. void menu()
  2. {
  3. 	printf("*********************************\n");
  4. 	printf("*******   扫雷小游戏    *********\n");
  5. 	printf("*******     1、play     *********\n");
  6. 	printf("*******     0、exit     *********\n");
  7. 	printf("*********************************\n");
  8. }

我们在主函数中可以调用这个函数来实现打印菜单的目的。

二、构建游戏的基本逻辑结构

制作完菜单后，我们需要构建这个游戏的基本逻辑结构。

首先需要明确我们的需求： 1、我们可以通过输入 1 / 0 来选择开始或结束游戏

                                            2、如果一把玩完不过瘾，我们可以通过选择来再玩一把

· 我们运用分支语句的知识来实现第一个需求。

       在这里我使用switch语句，定义一个整型来存放输入的数字，如果输入的数字是 1 ，则提示“开始游戏”；如果输入的数字是 0 ，则提示“结束游戏”；如果输入了 1/0 以外的数字，则我们提醒他输错了，重新输入。

· 我们通过循环来实现第二个需求。

       在这里使用do... while() 循环，将定义的整型放在（） 里作为判断条件。当我们输入 1 ，为非0，判断为真，游戏继续；当我们输入 0 ，判断为假，游戏结束；当我们输入 1/0  以外的数字，为非0，判断为真，可以继续循环让我们重新判断。

  1. int main()
  2. {
  3. 	int input;
  4. 	//先输入一个input判断要不要进入游戏，将其也设为循环的判断条件
  5.  
  6. 	do {
  7. 		menu();
  8. 		printf("请输入->");
  9. 		scanf("%d", &input);
  10. 		switch (input)
  11. 		{
  12. 		case 1:
  13. 			printf("开始游戏\n");
  14. 			game();
  15. 			//如果输入1，说明要玩游戏，封装一个game函数来包含游戏内容
  16. 			break;
  17. 		case 0:
  18. 			printf("退出游戏\n");
  19. 			break;
  20. 		default:
  21. 			printf("输错啦，请重新输入\n");
  22. 			break;
  23. 		}
  24. 	} while (input);
  25.  
  26. 	return 0;
  27. }


从代码运行结果来看，满足了我们提出的两点需求。

三、进入游戏的制作

1、定义两个一样的数组

两个数组，一个展示，一个放雷

  所以我们需要定义两个 11*11的数组，一个用来存放雷的数据，一个用来显示。

 为了后期调试的方便，我们可以将数组参数使用#define标识符替换列表中的参数。

  1. #include<stdio.h>
  2. #include<stdlib.h>   //srand函数的头文件
  3. #include<time.h>     //time函数的头文件
  4.  
  5. #define ROW 9    //实际使用的行
  6. #define COL 9    //实际使用的列
  7.  
  8. #define ROWS 11    //数组使用的行
  9. #define COLS 11    //数组使用的列
  10.  
  11. #define COUNT_EASY 10
  12. //简单版本有10个雷

2、初始化数组

       首先我们封装一个game函数，将实现游戏的内容都放在game函数中。定义两个字符型的二维数组，将二者初始化。

  1. //初始化数组
  2.  
  3. void InitBoard(char board[ROWS][COLS], int rows, int cols, char ret)
  4. {
  5. 	int x = 0;
  6. 	int y = 0;
  7. 	for (x = 0; x < rows; x++)
  8. 	{
  9. 		for (y = 0; y < cols; y++)
  10. 		{
  11. 			board[x][y] = ret;
  12. 		}
  13. 	}
  14. }
  15.  
  16.  
  17. void game()
  18. {
  19. 	//为了方便，把两个数组定义成完全一样的
  20. 	char mine[ROWS][COLS] = { 0 };
  21. 	char show[ROWS][COLS] = { 0 };
  22.  
  23.     //初始化两个数组，传对应的参数进去
  24.     //将雷盘先全都定义为0
  25.     //将显示盘定义为*
  26.     InitBoard(mine, ROWS, COLS, '0');
  27. 	InitBoard(show, ROWS, COLS, '*');
  28.  
  29. }

3、打印盘面

我们先清楚盘面的格式为：11 * 11 的正方形；其中只需打印中间的9*9，所以我们传ROW与COL进去即可；为了格式好看与查找方便，我们还可以添加一些表头与分隔。

            

  1. //打印棋盘
  2. void DisplayBoard(char board[ROWS][COLS], int row, int col)
  3. {
  4. 	int x = 0;
  5. 	int y = 0;
  6. 	printf("--------扫雷---------\n");
  7. 	for (x = 0; x <= row; x++)
  8. 	{
  9. 		printf(" %d", x);    //打印坐标提示行
  10. 	}
  11. 	printf("\n");
  12. 	for (x = 1; x <= row; x++)
  13. 	{
  14. 		printf(" %d", x);    //打印坐标提示列
  15. 		for (y = 1; y <= col; y++)
  16. 		{
  17. 			printf(" %c", board[x][y]);
  18. 		}
  19. 		printf("\n");
  20. 	}
  21. 	printf("---------------------\n");
  22. }
  23.  
  24.  
  25.  
  26. //打印的时候传过去的数组还是11*11的，数组是不会变的,不会因为你想打印的是9*9的就变成9*9的数组
  27. //因为我们只想打印出9*9的格子，所以传过去的是ROW和COL

4、布置雷

       简易版的9*9盘面内有10个雷，我们可以用rand函数来生成随机值来作为雷生成的坐标。生成雷时需要注意，雷的坐标需要是一个合法坐标，我们可以将生成坐标的过程放进循环里，当雷的坐标为合法坐标时跳出循环。注意将坐标适当处理。我们封装一个函数，在game函数中调用来实现该功能。

  1. //布置雷
  2. void Setmine(char board[ROWS][COLS], int row, int col)
  3. {
  4. 	int x = 0;
  5. 	int y = 0;
  6. 	int count = COUNT_EASY;  //雷的数量
  7. 	while (count)//当没布置完雷之前都继续循环
  8. 	{
  9. 		x = rand() % row + 1;     //生成数%row后范围是0~8 我们需要的是1~9
  10. 		y = rand() % col + 1;
  11. 		if (board[x][y] == '0')
  12. 		{
  13. 			board[x][y] = '1';
  14. 			count--;
  15. 		}
  16. 	}
  17. }

  注意：

       C语言中提供了一个rand函数可以帮我们生成随机数，返回值为int 整型，返回的值就是一个随机数。但rand函数生成的是伪随机数，返回的随机值并不完全随机。

                        

       rand函数在生成随机数之前，要使用srand函数设置随机数的生成器。srand()括号中放置类似于生成随机数的种子，种子固定了生成的随机数也是固定的。所以我们要使括号中的值为随机变化的，才能使产生的数值为随机值。

       在我们的计算机中，时间是时刻在发生变化的，如果能将时间传入srand中，那么就可以实现真正的随机。这个时候我们可以使用time函数来解决这个问题。

   

       time函数可以返回一个时间戳，时间戳是一串数字， 是随着时间在不断变化的 。在使用时我们需要调用二者的头文件。time函数的返回类型是time_t，在srand中要使用他需要强制类型转换为（unsigned int）

所以在主函数中：

  1. //记得引用头文件
  2. #include<stdio.h>
  3. #include<stdlib.h>   //srand函数的头文件
  4. #include<time.h>     //time函数的头文件
  5.  
  6. int main()
  7. {
  8. 	srand((unsigned int)time(NULL));
  9. 	int input = 0;
  10. 	do {
  11. 		menu();
  12. 		printf("请输入->");
  13. 		scanf("%d", &input);
  14.  
  15. 		switch (input)
  16. 		{
  17. 		case 1:
  18. 			printf("开始游戏\n");
  19. 			game();
  20. 			break;
  21. 		case 0:
  22. 			printf("退出游戏\n");
  23. 			break;
  24. 		default:
  25. 			printf("输错了，请重新输入\n");
  26. 			break;
  27. 		}
  28. 	} while (input);
  29. 	return 0;
  30. }
  31.

这样就能实现随机布置雷：

     

5、排查雷

       首先玩家排查雷需要在盘面中的合法位置，如果排查位置在盘外或者排查的位置已被占用，我们需要给出相应的提示。然后玩家给出的是盘面的坐标位置，因为我们盘面坐标刚好和数组位置对应，所以可以不用再进行操作。我们封装一个函数，在game函数中调用来实现该功能。

       并且在排查的过程中，可能出现以下几种情况：1、这个坐标不是雷，提示周围有几个雷

                                                                                   2、这个坐标是雷，游戏结束   

                                                                                   3、所有非雷位置都找到了，游戏胜利

       如果找到的坐标位置为非雷，那么我们就需要继续排查，所以我们将排查过程放到循环中进行，踩到雷或者排查结束才跳出循环。

·这个坐标不是雷，提示周围有几个雷

所以我们可以通过以下代码来实现功以上功能：

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

       然后在game函数中调用，实现函数功能。

·这个坐标是雷，游戏结束   

       当踩到雷时，我们给出相应提示后直接跳出循环结束游戏即可。

·所有非雷位置都找到了，游戏胜利

       我们可以设置一个整型变量，其大小为非雷的位置个数。如果成功排除一个雷就将其减一，将他作为循环的判断条件，当他减为0时刚好也能跳出循环，并给出相应提示表示排雷成功。

  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 = row * col - COUNT_EASY;
  7. 	while (win )
  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 if (show[x][y] != '*')
  20. 			{
  21. 				printf("排查过该坐标，请重新输入\n");
  22. 			}
  23. 			else if (mine[x][y] == '0')
  24. 			{
  25. 				int ret = 0;
  26. 				ret = GetMineCount(mine, x, y);
  27. 				show[x][y] = ret + '0';
  28.  
  29. 				DisplayBoard(show, ROW, COL);
  30. 				win--;
  31. 			}
  32. 		}
  33. 		else
  34. 		{
  35. 			printf("输入坐标非法，请重新输入\n");
  36. 		}
  37. 	}
  38.     //跳出循环有两种可能，一个是踩雷退出，一个是排雷完成退出
  39.     //需要判断是不是排雷成功，然后给出提示
  40. 	if(win==0)
  41. 		printf("恭喜你，排雷成功！ \n");
  42. }
  43.

6、game函数的实现

  1. void game()
  2. {
  3. 	//为了方便，把两个数组定义成完全一样的
  4. 	char mine[ROWS][COLS] = { 0 };
  5. 	char show[ROWS][COLS] = { 0 };
  6.  
  7. 	//初始化两个数组
  8. 	InitBoard(mine, ROWS, COLS, '0');
  9. 	InitBoard(show, ROWS, COLS, '*');
  10.  
  11. 	//打印棋盘
  12. 	//DisplayBoard(mine, ROW, COL);
  13. 	//对应雷的数组不需要给玩家看
  14. 	DisplayBoard(show, ROW, COL);
  15.  
  16. 	//布置雷
  17. 	Setmine(mine, ROW, COL);
  18. 	//DisplayBoard(mine, ROW, COL);
  19.  
  20. 	//排查雷
  21. 	Findmine(mine, show, ROW, COL);
  22. }

四、扫雷游戏的实现

将上面的代码汇总成一个完整的扫雷游戏：

  1. #include<stdio.h>
  2. #include<stdlib.h>
  3. #include<time.h>
  4.  
  5. #define ROW 9
  6. #define COL 9
  7. #define ROWS 11
  8. #define COLS 11
  9.  
  10. #define COUNT_EASY 10
  11. //简单版本有10个雷
  12.  
  13. void menu()
  14. {
  15. 	printf("*********************************\n");
  16. 	printf("*******   扫雷小游戏    *********\n");
  17. 	printf("*******     1、play     *********\n");
  18. 	printf("*******     0、exit     *********\n");
  19. 	printf("*********************************\n");
  20. }
  21.  
  22.  
  23. //初始化数组
  24. void InitBoard(char board[ROWS][COLS], int rows, int cols, char ret)
  25. {
  26. 	int x = 0;
  27. 	int y = 0;
  28. 	for (x = 0; x < rows; x++)
  29. 	{
  30. 		for (y = 0; y < cols; y++)
  31. 		{
  32. 			board[x][y] = ret;
  33. 		}
  34. 	}
  35. }
  36.  
  37.  
  38. //打印棋盘
  39. void DisplayBoard(char board[ROWS][COLS], int row, int col)
  40. {
  41. 	int x = 0;
  42. 	int y = 0;
  43. 	printf("--------扫雷---------\n");
  44. 	for (x = 0; x <= row; x++)
  45. 	{
  46. 		printf(" %d", x);
  47. 	}
  48. 	printf("\n");
  49. 	for (x = 1; x <= row; x++)
  50. 	{
  51. 		printf(" %d", x);
  52. 		for (y = 1; y <= col; y++)
  53. 		{
  54. 			printf(" %c", board[x][y]);
  55. 		}
  56. 		printf("\n");
  57. 	}
  58. 	printf("---------------------\n");
  59. }
  60.  
  61.  
  62. //布置雷
  63. void Setmine(char board[ROWS][COLS], int row, int col)
  64. {
  65. 	int x = 0;
  66. 	int y = 0;
  67. 	int count = COUNT_EASY;
  68. 	while (count)
  69. 	{
  70. 		x = rand() % row + 1;
  71. 		y = rand() % col + 1;
  72. 		if (board[x][y] == '0')
  73. 		{
  74. 			board[x][y] = '1';
  75. 			count--;
  76. 		}
  77. 	}
  78. }
  79.  
  80.  
  81. //数周围有几个雷
  82. int GetMineCount(char mine[ROWS][COLS], int x, int y)
  83. {
  84. 	return  (mine[x - 1][y - 1] +
  85. 		mine[x][y - 1] +
  86. 		mine[x + 1][y - 1] +
  87. 		mine[x + 1][y] +
  88. 		mine[x + 1][y + 1] +
  89. 		mine[x][y + 1] +
  90. 		mine[x - 1][y + 1] +
  91. 		mine[x - 1][y]) - (8 * '0');
  92. }
  93.  
  94.  
  95.  
  96. //排查雷
  97. void Findmine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
  98. {
  99. 	int x = 0;
  100. 	int y = 0;
  101. 	int win = row * col - COUNT_EASY;
  102. 	while (win )
  103. 	{
  104. 		printf("请输入要排查的坐标->");
  105. 		scanf("%d %d", &x, &y);
  106. 		if (x >= 1 && x <= row && y >= 1 && y <= col)
  107. 		{
  108. 			if (mine[x][y] == '1')
  109. 			{
  110. 				printf("踩到雷啦！爆炸！\n");
  111. 				DisplayBoard(mine, row, col);
  112. 				break;
  113. 			}
  114. 			else if (show[x][y] != '*')
  115. 			{
  116. 				printf("排查过该坐标，请重新输入\n");
  117. 			}
  118. 			else if (mine[x][y] == '0')
  119. 			{
  120. 				int ret = 0;
  121. 				ret = GetMineCount(mine, x, y);
  122. 				show[x][y] = ret + '0';
  123.  
  124. 				DisplayBoard(show, ROW, COL);
  125. 				win--;
  126. 			}
  127. 		}
  128. 		else
  129. 		{
  130. 			printf("输入坐标非法，请重新输入\n");
  131. 		}
  132. 	}
  133. 	if(win==0)
  134. 		printf("恭喜你，排雷成功！ \n");
  135. }
  136.  
  137.  
  138.  
  139.  
  140. void game()
  141. {
  142. 	//为了方便，把两个数组定义成完全一样的
  143. 	char mine[ROWS][COLS] = { 0 };
  144. 	char show[ROWS][COLS] = { 0 };
  145. 	//初始化两个数组
  146. 	InitBoard(mine, ROWS, COLS, '0');
  147. 	InitBoard(show, ROWS, COLS, '*');
  148.  
  149. 	//打印棋盘
  150. 	//DisplayBoard(mine, ROW, COL);
  151. 	//对应雷的数组不需要给玩家看
  152. 	DisplayBoard(show, ROW, COL);
  153.  
  154. 	//布置雷
  155. 	Setmine(mine, ROW, COL);
  156. 	//DisplayBoard(mine, ROW, COL);
  157.  
  158. 	//排查雷
  159. 	Findmine(mine, show, ROW, COL);
  160. }
  161.  
  162.  
  163. int main()
  164. {
  165. 	srand((unsigned int)time(NULL));
  166. 	int input = 0;
  167. 	do {
  168. 		menu();
  169. 		printf("请输入->");
  170. 		scanf("%d", &input);
  171.  
  172. 		switch (input)
  173. 		{
  174. 		case 1:
  175. 			printf("开始游戏\n");
  176. 			game();
  177. 			break;
  178. 		case 0:
  179. 			printf("退出游戏\n");
  180. 			break;
  181. 		default:
  182. 			printf("输错了，请重新输入\n");
  183. 			break;
  184. 		}
  185. 	} while (input);
  186. 	return 0;
  187. }

大家也可以将其封装为多个文件看上去更简洁明了，我这里为了表达方便将其放在一个文件里。

以上就是  C语言基础：扫雷游戏的C语言实现（超详图解+源码）的全部内容啦，希望能对你有所帮助！

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家自动化/article/detail/921219
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号