devbox
小桥流水78
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C语言——扫雷小游戏

作者：小桥流水78 | 2024-06-23 04:39:39

赞

踩

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<row*col-COUNT){                     
  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<stdio.h>
  3. #include<stdlib.h>
  4. #include<windows.h>
  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<row*col-COUNT){
  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. }

 

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

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

  

闽ICP备14008679号