• C语言——扫雷小游戏

            扫雷小游戏：

    游戏最终效果：

    1.先写一下游戏开始的简单界面。

    用一个函数来写一下

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

    这里的功能（说明）：

            输入 1  代表游戏开始；

            输入 0  代表游戏结束，并退出页面；

    既然写扫雷，那地图中的地雷应该是随机出现的，那我们可以用一个srand函数让它随机出现生成地雷。

                srand((unsigned int)time(NULL));   //生成随机数的一个函数

    具体用法可以百度一下，简单的概括就是生成一个随机数字。

    1. int main()
    2. {
    3. 	srand((unsigned int)time(NULL));
    4. 	int input = 0;    //用与while函数循环的选择
    5. 	do {              //也就是刚开始说的界面选择开始或结束的选项
    6. 		menu();
    7. 		printf("请选择>");        
    8. 		scanf("%d", &input);   //这里的input就是游戏开始或结束的选择
    9. 		switch (input)         //再循环里面嵌套一个switch  
    10. 		{
    11. 		case 1:                 //   当输入1的时候，那就进入游戏开始的逻辑
    12. 			printf("游戏开始！\n");
    13. 			system("cls");      // ：这里是系统函数，用于清空控制台的消息与文字
    14. 			game();             //  这个是游戏开始的函数接口
    15. 			break;
    16. 		case 0:                 //   当选择0的时候，即退出游戏退出循环，并程序结束。
    17. 			printf("\n即将退出游戏!\n");
    18. 			break;
    19. 		default :              //因为只有输入0/1，否则就是输入错误，需要重新输入
    20. 			printf("您的选择有误，请重新输入:\n");
    21. 		}
    22. 	} while (input);
    23. 	return 0;
    24. }

    当我们选择play时，我们将进入游戏，之后就是游戏逻辑的代码了。

    1. #define ROW 9   //棋盘  行
    2. #define COL 9	//棋盘  列
    3. #define ROWS ROW+2	//判断-棋盘  行
    4. #define COLS COL+2  //判断-棋盘  列
    5. #define COUNT 10	//地雷个数

    扫雷，我们需要创建两个二维数组，之后的操作与逻辑都是围绕这两个棋盘来写

    一个用来展示覆盖与否的画面（代码中的  show数组）：

    一个用来记载着地雷的位置与判断（代码中的mine数组） ：

    1. void game() 
    2. {
    3. 	char mine[ROWS][COLS];    //注： ROWS COLS  为头文件define出来的行和列
    4. 	char show[ROWS][COLS];
    5.  
    6. 	//初始化数据 
    7. 	Initboard(mine, ROWS, COLS, '0');
    8. 	Initboard(show, ROWS, COLS, '*');
    9.  
    10. 	//棋盘打印
    11. 	Displayboard(show, ROW, COL);
    12.  
    13. 	//布置雷
    14. 	Setmine(mine, ROW, COL);
    15. 	
    16. 	//排查雷
    17.  
    18. 	Findmine(mine, show, ROW, COL);
    19. 	//Displayboard(show, ROW, COL);
    20.  
    21. }

         之后我们需要先把两个二维数组给初始化一下：

    这里我们写一个函数Initboard

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

    我们将mine的二维数组都初始化为’0‘

            将show二维数组都初始化为’*‘

    注：我们展示出来的一般都是show的二维数组
     

    所以我们需要写一个格式函数

    1. //打印棋盘   //并设置格式
    2. void Displayboard(char borad[ROWS][COLS], int row, int col)
    3. {
    4. 	printf("======扫雷游戏======\n");
    5. 	int i = 0;
    6. 	for (i = 0; i <= row; i++)
    7. 	{
    8. 		printf("%d ", i);
    9. 	}
    10. 	printf("\n");
    11.  
    12. 	for (int a = 1; a <=row; a++)
    13. 	{	
    14. 		printf("%d ", a);
    15. 		for (int b = 1; b <= col; b++)
    16. 		{
    17. 			Sleep(10);
    18. 			printf("%c ", borad[a][b]);
    19. 		}
    20. 		printf("\n");
    21. 	}
    22. 	printf("======扫雷游戏======\n");
    23.  
    24. }

    展示出来就是这个样子。

    游戏页面的大概就展示出来了，接下来我们需要写一下游戏判断逻辑了

    首先我们需要埋雷，但雷的位置是随机的，所以我们需要用一下srand函数，把雷随机的放进mine二维数组中，就是随机生成一个坐标

            注：mine二维数组中 “0”代表该位置是安全的坐标

                                             “1”代表该位置是埋有地雷的坐标）

    1. //布置雷
    2. void Setmine(char mine[ROWS][COLS], int row, int col)
    3. {
    4. 	int count = COUNT;    //COUNT代表的雷的个数，可以自己设置
    5. 	while (count)
    6. 	{
    7. 		int x = rand() % row + 1;        //随机生成x坐标
    8. 		int y = rand() % col + 1;        //随机生成y坐标
    9. 		if (mine[x][y] =='0')    
    10. 		{
    11. 			mine[x][y] = '1';            //把mine二维数组的该位置改为1
    12. 			count--;
    13. 		}                                //代表着埋入地雷
    14. 	}
    15. }

    接下来就是输入坐标来排查雷的步骤了

    1. //排查雷 
    2. void Findmine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
    3. {
    4. 	int a = 0;
    5. 	int b= 0;
    6. 	int win = 0;
    7. while(win
    8. 			printf("请输入您的坐标：");
    9. 			scanf("%d", &a);            //输入坐标x和y
    10. 			scanf("%d", &b);
    11. 		if ((a <= row + 1 && a > 0) && (b <= col + 1 && b > 0))   
    12. 		{        //这里需要用if来判断一下x和y的值是否大于坐标，不在这个范围就需要重新输入坐标
    13. 			if (mine[a][b] == '1')    //这里判断的是如果坐标刚好在雷的位置，游戏就结束了
    14. 			{
    15. 				system("cls");    //清空屏幕
    16. 				printf("很抱歉，您被炸死了。\n");
    17. 				Displayboard(mine, ROW, COL);       //当炸死后，这里在打印一下mine的棋盘
    18. 				Sleep(1000);                        //提示一下并答应雷的位置告诉玩家这里是雷
    19. 				break;            //游戏结束后这里需要break一下结束这一层的循环
    20. 			}
    21. 			else
    22. 			{	
    23. 				int count=Getminecount(mine,a,b);//Getminecount函数排查这个坐标周围有多少颗雷
    24. 				show[a][b] = count+'0';
    25. 				system("cls");
    26.  
    27. 				Displayboard(show, ROW, COL);
    28. 				win++;
    29. 			}
    30. 		}
    31. 		else        //当不在取值范围内就需要重新输入一下  并输出一个坐标有误的提示
    32. 		{
    33. 			printf("您输入的坐标有误，请重新输入：\n ");
    34. 		}
    35. 			}
    36.  
    37. 		if (win == row * col - COUNT)    当把雷的排完后，就获胜了！
    38. 		{
    39. 			printf("恭喜你，排雷成功。\n");
    40. 			Displayboard(show, ROW, COL);
    41.  
    42. 		}
    43. }

     该函数用于统计坐标周围有多少颗雷。

    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. }

    下面是全代码： 

    1. #define _CRT_SECURE_NO_WARNINGS 1
    2. #include
    3. #include
    4. #include
    5. #define ROW 9   //棋盘  行
    6. #define COL 9	//棋盘  列
    7. #define ROWS ROW+2	//判断-棋盘  行
    8. #define COLS COL+2  //判断-棋盘  列
    9.  
    10. #define COUNT 10	//地雷个数
    11.  
    12. //初始化棋盘
    13. void Initboard(char borad[ROWS][COLS], int rows, int cols,char set)
    14. {
    15. 	int i = 0;
    16. 	for (i = 0; i < rows; i++)
    17. 	{
    18. 		for (int j = 0; j < cols; j++)
    19. 		{
    20. 			borad[i][j] = set;
    21. 		}
    22. 	}
    23. }
    24.  
    25. //打印棋盘   //并设置格式
    26. void Displayboard(char borad[ROWS][COLS], int row, int col)
    27. {
    28. 	printf("======扫雷游戏======\n");
    29. 	int i = 0;
    30. 	for (i = 0; i <= row; i++)
    31. 	{
    32. 		printf("%d ", i);
    33. 	}
    34. 	printf("\n");
    35.  
    36. 	for (int a = 1; a <=row; a++)
    37. 	{	
    38. 		printf("%d ", a);
    39. 		for (int b = 1; b <= col; b++)
    40. 		{
    41. 			Sleep(10);
    42. 			printf("%c ", borad[a][b]);
    43. 		}
    44. 		printf("\n");
    45. 	}
    46. 	printf("======扫雷游戏======\n");
    47.  
    48. }
    49.  
    50.  
    51. //布置雷
    52. void Setmine(char mine[ROWS][COLS], int row, int col)
    53. {
    54. 	int count = COUNT;
    55. 	while (count)
    56. 	{
    57. 		int x = rand() % row + 1;
    58. 		int y = rand() % col + 1;
    59. 		if (mine[x][y] =='0')
    60. 		{
    61. 			mine[x][y] = '1';
    62. 			count--;
    63. 		}
    64. 	}
    65. }
    66.  
    67. //排查雷 
    68. void Findmine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
    69. {
    70. 	int a = 0;
    71. 	int b= 0;
    72. 	int win = 0;
    73. while(win
    74. 			printf("请输入您的坐标：");
    75. 			scanf("%d", &a);
    76. 			scanf("%d", &b);
    77. 		//	a = a / a * a;
    78. 		//	b = b / b * b;
    79. 		if ((a <= row + 1 && a > 0) && (b <= col + 1 && b > 0))
    80. 		{
    81. 			if (mine[a][b] == '1')
    82. 			{
    83. 				system("cls");
    84. 				printf("很抱歉，您被炸死了。\n");
    85. 				Displayboard(mine, ROW, COL);
    86. 				Sleep(1000);
    87. 				break;
    88. 			}
    89. 			else
    90. 			{	
    91. 				int count=Getminecount(mine,a,b);
    92. 				show[a][b] = count+'0';
    93. 				system("cls");
    94.  
    95. 				Displayboard(show, ROW, COL);
    96. 				win++;
    97. 			}
    98. 		}
    99. 		else
    100. 		{
    101. 			printf("您输入的坐标有误，请重新输入：\n ");
    102. 		}
    103. 			}
    104. 		if (win == row * col - COUNT)
    105. 		{
    106. 			printf("恭喜你，排雷成功。\n");
    107. 			Displayboard(show, ROW, COL);
    108.  
    109. 		}
    110. }
    111.  
    112. //统计周围雷的个数
    113. int Getminecount(char mine[ROWS][COLS], int x, int y)
    114. {
    115. 	return (mine[x - 1][y - 1] +
    116. 		mine[x][y - 1] +
    117. 		mine[x + 1][y - 1] +
    118. 		mine[x + 1][y] +
    119. 		mine[x + 1][y + 1] +
    120. 		mine[x][y + 1] +
    121. 		mine[x - 1][y + 1] +
    122. 		mine[x - 1][y] - 8 * '0');
    123.  
    124. }
    125.  
    126. void menu()
    127. {
    128. 	printf(" ---------------------------- \n");
    129. 	printf("|           1.play           |\n");
    130. 	printf("|           0.exit           |\n");
    131. 	printf(" ---------------------------- \n");
    132.  
    133. }
    134. void game() 
    135. {
    136. 	char mine[ROWS][COLS];
    137. 	char show[ROWS][COLS];
    138. 	//初始化数据 
    139. 	Initboard(mine, ROWS, COLS, '0');
    140. 	Initboard(show, ROWS, COLS, '*');
    141.  
    142. 	//棋盘打印
    143. 	//Displayboard(mine, ROW, COL);
    144. 	Displayboard(show, ROW, COL);
    145.  
    146. 	//布置雷
    147. 	Setmine(mine, ROW, COL);
    148. 	
    149.  
    150. 	//排查雷
    151.  
    152. 	Findmine(mine, show, ROW, COL);
    153. 	//Displayboard(show, ROW, COL);
    154.  
    155. }
    156. int main()
    157. {
    158. 	srand((unsigned int)time(NULL));
    159. 	int input = 0;
    160. 	do {
    161. 		menu();
    162. 		printf("请选择>");
    163. 		scanf("%d", &input);
    164. 		switch (input)
    165. 		{
    166. 		case 1:
    167. 			printf("游戏开始！\n");
    168. 			Sleep(1000);
    169. 			system("cls");
    170. 			game();
    171. 			break;
    172. 		case 0:
    173. 			printf("\n即将退出游戏!\n");
    174. 			break;
    175. 		default :
    176. 			printf("您的选择有误，请重新输入:\n");
    177. 		}
    178. 	} while (input);
    179. 	return 0;
    180. }

     

  • 相关阅读:
    LabVIEW利用以太网开发智能液位检测仪
    【前端】JavaScript
    Worthington核糖核酸酶B历史和化学性质说明
    基于Springboot+vue的玩具销售商城网站 elementui
    .NET Emit 入门教程：第七部分：实战项目1：将 DbDataReader 转实体
    提升文件上传性能的 4 种方式，你会吗？
    Java工程师的就业前景？薪资水平？
    【毕业设计】基于Stm32的人体心率脉搏无线监测系统 - 单片机 物联网
    Android12 展锐sl8541平台USB转串口（pl2303、ch343）以及APP访问权限
    自己写过比较蠢的代码：从失败中学习的经验
  • 原文地址：https://blog.csdn.net/2301_78590609/article/details/139806023