关键词搜索

源码搜索 ×
×

扫雷C语言初阶版

发布2022-11-19浏览860次

详情内容

  扫雷代码思路：           1、游戏页面的建立                   2、 构思棋局的建立方法     

        3、  选择清扫的位置             4、  判断位置是否为雷                5、  显示位置的信息  

扫雷游戏思路： 

                                          

 游戏思路和代码思路介绍完毕了。现在开始我们的正题-----扫雷游戏

第一步 创建三个文件

                             1.game.h----游戏函数的声明

                             2.text.c------测试游戏

                             3.game.c------游戏函数的实现

 第二步  代码实现

代码实现分为四步，分别为创建菜单、创建雷盘、布置雷、排查雷、判断是否雷。

在代码实现之前，我们可以创建一个头文件,包含了代码需要的行数。

  1. #include <time.h>
  2.  
  3. #define ROW 9    //棋盘的行
  4. #define COL 9    //棋盘的列
  5.  
  6. #define ROWS ROW+2
  7. #define COLS COL+2
  8.  
  9. #define EASY_COUNT 9  //雷数目
  10.  
  11. //初始化棋盘
  12. void InitBoard(char board[ROWS][COLS], int rows, int cols, char set);
  13.  
  14. //打印棋盘
  15. void DisplayBoard(char board[ROW][COL], int row, int col);
  16.  
  17. //布置雷
  18. void SetMine(char mine[ROW][COL], int row, int col);
  19.  
  20. //排查雷
  21. void FindMine(char mine[ROW][COL], char show[ROW][COL], int row, int col);

第一小步----创建菜单

       在玩游戏前，我们可以想想，是不是应该需要一个菜单，让我们选择开始游戏又或者退出游戏，最主要的是，我们可以用循环来，这样可以重复玩很多盘。在text.c文件里创建

  1. #include<stdio.h>
  2. int main()
  3. {
  4. 	srand((unsigned int)time(NULL));  //之后用于随机生成雷
  5. 	int input = 0;
  6. 	do
  7. 	{
  8. 	    printf("************************************\n");
  9. 	    printf("********      1. play      *********\n");
  10. 	    printf("********      0. exit      *********\n");
  11. 	    printf("************************************\n");
  12. 		printf("请选择:>");
  13. 		scanf("%d", &input);
  14. 		switch (input)
  15. 		{
  16. 		case 1:
  17. 			game();    //用于之后的游戏代码
  18. 			break;
  19. 		case 0:
  20. 			printf("退出游戏\n");
  21. 			break;
  22. 		default:
  23. 			printf("选择错误，重新选择!\n");  //防止玩家乱选错误选项
  24. 			break;
  25. 		}
  26. 	} while (input);
  27. 	return 0;
  28. }

函数game()，则是正式进入游戏的各个步骤的代码。

  1. void game()
  2. {
  3. 	//1. 需要存放布置好的雷的信息，存放排查出的雷的信息，我们需要2个二维数组
  4. 	/https://files.jxasp.com/image/2. 排查坐标的时候，为了防止坐标越界，我们给数组的行增加2行，列增加了2列
  5. 	char mine[ROWS][COLS] = { 0 };//布置好的雷的信息
  6. 	char show[ROWS][COLS] = { 0 };//排查出的雷的信息
  7. 	//初始化棋盘
  8. 	InitBoard(mine, ROWS, COLS, '0');  //雷盘，1为雷，初始化为0，则无雷
  9. 	InitBoard(show, ROWS, COLS, '*');  //展示盘，每一格为*
  10. 	
  11.     //打印棋盘
  12. 	DisplayBoard(show, ROW, COL);
  13. 	
  14.     //布雷
  15. 	SetMine(mine, ROW, COL);
  16. 	printf("\n");
  17. 	DisplayBoard(mine, ROW, COL);
  18.  
  19. 	//查雷
  20. 	FindMine(mine, show, ROW, COL);
  21. 	DisplayBoard(show, ROW, COL);
  22. }

第二小步-------创建雷盘

        创建9*9雷盘，我们需要利用二维数组，而且还需要2个雷盘，一个用于放雷的，一个用于展示的。或许你不太明白什么意思，但是你想想，如果只有一个棋盘，当布雷的时候，就直接显示在棋盘上了，压根无法进行。  换一个说话，我们需要用相同的坐标去判断布雷的棋盘，是否为雷，再展示的棋盘展示。

       当选定了一个坐标之后，需要计算上下左右的格子雷的数量，所以需要将两个二维数组数组的范围加2，但是展示的雷盘还是只有9*9；

 我们需要创建一个初始化的二维数组，并且打印一个未知的棋盘，也就是展示的棋盘

  1. void InitBoard(char board[ROWS][COLS], int rows, int cols, char set)
  2. {                                        //传过来的set，就是让二维数组全为set
  3. 	int i = 0;
  4. 	for (i = 0; i < rows; i++)
  5. 	{
  6. 		int j = 0;
  7. 		for (j = 0; j < cols; j++)
  8. 		{
  9. 			board[i][j] = set;
  10. 		}
  11. 	}
  12. }
  13.  
  14. void DisplayBoard(char board[ROW][COL], int row, int col)
  15. {
  16. 	for (int c = 0; c < 10; c++)
  17. 	{
  18. 		printf("%d ", c);
  19. 	}
  20. 	printf("\n");
  21. 	for (int d = 1; d < 10; d++)
  22. 	{
  23. 		printf("%d ", d);
  24. 		for (int y = 1; y < 10; y++)          //棋盘得从二维数组的[1][1]开始打印
  25. 		{
  26. 			printf("%c ", board[d][y]);
  27. 		}
  28. 		printf("\n");
  29. 	}
  30.  
  31. }

 第三小步------布置雷

布置雷，应该是随机布置的，所以我们使用随机数rand()

  1. void SetMine(char mine[ROW][COL], int row, int col)
  2. {
  3. 	int num = EASY_COUNT;   //常量，在头文件里定义为9，布置9个雷
  4. 	while (num > 0)
  5. 	{
  6. 		int a = rand() % 9 + 1;
  7. 		int b = rand() % 9 + 1;
  8. 		if (mine[a][b] == '0')
  9. 		{
  10. 			mine[a][b] = '1';num--;
  11. 		}		
  12. 	}
  13. }

 第四小步-----探雷

玩家输入坐标，判断是否为雷，若是雷则游戏结束，并且显示雷的位置，若不是雷，则显示周围雷的数量，并且进行下一次排雷。直到雷排完 或者 被炸死游戏结束 为止。

  1. //计算周围雷数量
  2. int thundernum(char mine[ROW][COL],int a,int b)
  3. {
  4. 	return (mine[a - 1][b] + mine[a + 1][b] + mine[a][b + 1]
  5. 		+ mine[a][b - 1] + mine[a - 1][b - 1] + mine[a - 1][b + 1]
  6. 		+ mine[a + 1][b + 1] + mine[a + 1][b - 1] -8*'0');
  7. }
  8.  
  9.  
  10. void FindMine(char mine[ROW][COL], char show[ROW][COL], int row, int col)
  11. {
  12. 	int a=0,b=0,sum=0;
  13. 	while (sum < row*col-EASY_COUNT)
  14. 	{
  15. 		printf("输入坐标：");
  16. 		scanf("%d %d", &a, &b);
  17. 		if (a >= 1 && a <= row && b >= 1 && b <= col)
  18. 		{
  19. 			if (show[a][b] != '*')
  20. 				printf("输入错误，重新输入\n");
  21. 			if (mine[a][b] == '0')
  22. 			{
  23. 				show[a][b] = '0' + thundernum(mine, a, b);  //周围雷的数量
  24. 				DisplayBoard(show, ROW, COL);
  25. 				sum++;
  26. 			}
  27. 			else if (mine[a][b] == '1')     //坐标的内容为1，则炸死
  28. 			{
  29. 				DisplayBoard(show, ROW, COL);
  30. 				printf("你被炸死了\n");
  31. 				break;
  32. 			}
  33. 			
  34. 		}
  35. 		else printf("坐标非法\n");
  36. 	}
  37. 	if (sum == row * col - EASY_COUNT)
  38. 	{
  39. 		printf("排雷成功");
  40. 	}
  41.  
  42. }

第三步     整合代码

先在头文件创建一个game.h文件，并且定义函数和常量还有标准库头文件。

 其次在源文件里定义一个text.c，放置的是代码实现顺序。

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2. #include"game.h"
  3.  
  4. void game()
  5. {
  6. 	//1. 需要存放布置好的雷的信息，存放排查出的雷的信息，我们需要2个二维数组
  7. 	/https://files.jxasp.com/image/2. 排查坐标的时候，为了防止坐标越界，我们给数组的行增加2行，列增加了2列
  8. 	char mine[ROWS][COLS] = { 0 };//布置好的雷的信息
  9. 	char show[ROWS][COLS] = { 0 };//排查出的雷的信息
  10. 	//初始化棋盘
  11. 	InitBoard(mine, ROWS, COLS, '0');
  12. 	InitBoard(show, ROWS, COLS, '*');
  13. 	//打印棋盘
  14. 	DisplayBoard(show, ROW, COL);
  15. 	//布雷
  16. 	SetMine(mine, ROW, COL);
  17. 	printf("\n");
  18. 	DisplayBoard(mine, ROW, COL);
  19.  
  20. 	//查雷
  21. 	FindMine(mine, show, ROW, COL);
  22. 	DisplayBoard(show, ROW, COL);
  23. }
  24.  
  25. 	
  26.  
  27.  
  28. void test()
  29. {
  30. 	srand((unsigned int)time(NULL));
  31. 	int input = 0;
  32. 	do
  33. 	{   
  34.         printf("************************************\n");
  35. 	    printf("********      1. play      *********\n");
  36. 	    printf("********      0. exit      *********\n");
  37. 	    printf("************************************\n");
  38. 		printf("请选择:>");
  39. 		scanf("%d", &input);
  40. 		switch (input)
  41. 		{
  42. 		case 1:
  43. 			game();
  44. 			break;
  45. 		case 0:
  46. 			printf("退出游戏\n");
  47. 			break;
  48. 		default:
  49. 			printf("选择错误，重新选择!\n");
  50. 			break;
  51. 		}
  52. 	} while (input);
  53. }
  54.  
  55. int main()
  56. {
  57. 	test();
  58. 	return 0;
  59. }

最后则是游戏代码实现的函数，在源文件里再创建一个game.c文件

  1. #include"game.h"
  2. void InitBoard(char board[ROWS][COLS], int rows, int cols, char set)
  3. {
  4. 	int i = 0;
  5. 	for (i = 0; i < rows; i++)
  6. 	{
  7. 		int j = 0;
  8. 		for (j = 0; j < cols; j++)
  9. 		{
  10. 			board[i][j] = set;
  11. 		}
  12. 	}
  13. }
  14.  
  15. void DisplayBoard(char board[ROW][COL], int row, int col)
  16. {
  17. 	for (int c = 0; c < 10; c++)
  18. 	{
  19. 		printf("%d ", c);
  20. 	}
  21. 	printf("\n");
  22. 	for (int d = 1; d < 10; d++)
  23. 	{
  24. 		printf("%d ", d);
  25. 		for (int y = 1; y < 10; y++)
  26. 		{
  27. 			printf("%c ", board[d][y]);
  28. 		}
  29. 		printf("\n");
  30. 	}
  31.  
  32. }
  33.  
  34. void SetMine(char mine[ROW][COL], int row, int col)
  35. {
  36. 	int num = EASY_COUNT;
  37. 	while (num > 0)
  38. 	{
  39. 		int a = rand() % 9 + 1;
  40. 		int b = rand() % 9 + 1;
  41. 		if (mine[a][b] == '0')
  42. 		{
  43. 			mine[a][b] = '1';num--;
  44. 		}		
  45. 	}
  46. }
  47.  
  48. int thundernum(char mine[ROW][COL],int a,int b)
  49. {
  50. 	return (mine[a - 1][b] + mine[a + 1][b] + mine[a][b + 1]
  51. 		+ mine[a][b - 1] + mine[a - 1][b - 1] + mine[a - 1][b + 1]
  52. 		+ mine[a + 1][b + 1] + mine[a + 1][b - 1] -8*'0');
  53. }
  54.  
  55.  
  56. void FindMine(char mine[ROW][COL], char show[ROW][COL], int row, int col)
  57. {
  58. 	int a=0,b=0,sum=0;
  59. 	while (sum < row*col-EASY_COUNT)
  60. 	{
  61. 		printf("输入坐标：");
  62. 		scanf("%d %d", &a, &b);
  63. 		if (a >= 1 && a <= row && b >= 1 && b <= col)
  64. 		{
  65. 			if (show[a][b] != '*')
  66. 				printf("输入错误，重新输入\n");
  67. 			if (mine[a][b] == '0')
  68. 			{
  69. 				show[a][b] = '0' + thundernum(mine, a, b);
  70. 				DisplayBoard(show, ROW, COL);
  71. 				sum++;
  72. 			}
  73. 			else if (mine[a][b] == '1')
  74. 			{
  75. 				DisplayBoard(show, ROW, COL);
  76. 				printf("你被炸死了\n");
  77. 				break;
  78. 			}
  79. 			
  80. 		}
  81. 		else printf("坐标非法\n");
  82. 	}
  83. 	if (sum == row * col - EASY_COUNT)
  84. 	{
  85. 		printf("排雷成功");
  86. 	}
  87.  
  88. }

 以上便是扫雷的三个文件代码。

扫雷初阶代码重点：

    1.需要存放布置好的雷的信息，存放排查出的雷的信息，我们需要2个二维数组
    2. 排查坐标的时候，为了防止坐标越界，我们给数组的行增加2行，列增加了2列                                                                                                                                                                                    个人小提示：

    1.在敲代码的时候，一定要分清布雷的二维数组和排雷的二维数组，千万不要搞混了。                     2.复制粘贴永远没有自己敲出的那么熟悉了解。

     

若是不太明白，可以先看一下简单一点的三子棋实现代码：CSDN

如果明白了，可以下载easyX图形库，使改装一下自己代码，实现更好的页面和游戏体验哦。

                                                                                              还有问题，评论私信都可以哦。

相关技术文章

最新源码

下载排行榜
点击QQ咨询
开通会员
返回顶部
×
微信扫码支付 元
微信扫码支付
确定支付下载
请使用微信描二维码支付
×

提示信息

×

选择支付方式

  • 微信支付
  • 支付宝付款
确定支付下载