devbox
一键难忘520
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

详解C语言实现扫雷游戏_c语言扫雷

作者：一键难忘520 | 2024-08-03 03:27:43

赞

踩

c语言扫雷

目录

一、摘要

二、文件配置

三、功能实现

1 开始游戏界面

2 游戏主体game()

2.1 初始化

2.2 打印信息

 2.3 设置地雷

2.4 排查地雷

2.4.1 统计该坐标周围八个坐标的雷的个数

2.4.2 展开函数

2.4.3 标记函数

2.4.4 清除标记函数

四、游戏代码

五、代码优缺点总结

一、摘要

扫雷游戏是一款经典的小游戏，网页版或者是windows系统自带的扫雷游戏有分难度，每个难度有不一样的雷的个数以及棋盘大小，比如简单难度：9*9的棋盘里面包含了10个雷。扫雷游戏的规则是在尽量短的时间内依照所点击格子的数字提示，点开所有没有布置过雷的格子，同时避免点到存在雷的格子，如果踩到雷游戏就结束。

如果点击的格子周围8个格子没有雷，则就会向周围展开，如果有雷，就会在格子上显示数字：

 同时我们可以标记或者清除标记，标记的位置不能被探查：

可见，扫雷游戏可实现的功能很多，今天我们要实现的扫雷游戏是9*9大小棋盘含有10个地雷的简单难度的扫雷。

二、文件配置

我们今天的代码就分别放在三个文件：test.c、game.c、game.h中。test.c源文件主要用来测试整个小游戏；game.c源文件主要用来完成小游戏各功能的实现；game.h头文件中则用来包含所有的库函数并声明game.c中的函数。这样分文件书写代码段的好处在于：结构化清晰，便于团队合作；易于维护、修改和功能扩张；代码的可读性高。

三、功能实现

1 开始游戏界面

  1. void menu()
  2. {
  3. 	printf("**********************************\n");
  4. 	printf("*********** 1. play **************\n");
  5. 	printf("*********** 0. exit **************\n");
  6. 	printf("**********************************\n");
  7. }
  8. int main()
  9. {
  10. 	int input = 0;
  11. 	do
  12. 	{
  13. 		menu();
  14. 		printf("请选择:>");
  15. 		scanf("%d", &input);
  16. 		switch (input)
  17. 		{
  18. 		case 1:
  19. 			printf("扫雷\n");
  20. 			game();
  21. 			break;
  22. 		case 0:
  23. 			printf("退出游戏\n");
  24. 			break;
  25. 		default:
  26. 			printf("重新选择\n");
  27. 			break;
  28. 		}
  29. 	} while (input);
  30. 	return 0;
  31. }

我们定义了一个菜单函数，同时在主函数里开始运行，运用switch语句，输入1则进入游戏，输入0则退出游戏，输入其他数字则重新输入，同时我们想：玩一把不过瘾想要继续玩怎么办？用循环结构就好了，我们选择do-while语句先执行后判断，由input控制循环，如果选择了0那正好不符合while的条件退出循环。

2 游戏主体game()

  1. #define ROW 9
  2. #define COL 9
  3. #define ROWS ROW+2
  4. #define COLS COL+2
  5. void game()
  6. {
  7. 	
  8. 	char mine[ROWS][COLS];//存放布置好的雷
  9. 	char show[ROWS][COLS];//存放排查出的雷的信息
  10. 	
  11.     //初始化
  12. 	Initboard(mine, ROWS, COLS,'0');
  13. 	Initboard(show, ROWS, COLS,'*');
  14.  
  15. 	//打印给玩家看
  16.     Printboard(show,ROW,COL);
  17. 	
  18.     //布置雷,将存放雷的数组有雷的位置设为'1'
  19. 	SetMine(mine, ROW, COL);
  20.  
  21. 	//排查雷
  22. 	CheckMine(mine, show, ROW, COL);
  23. }

1）扫雷的棋盘我们很容易想到用二维数组来搭建。

2）扫雷的时候要判断玩家是否踩到雷，然后显示出信息，所以我们用两个二维数组分别承担不同的工作：mine数组用来存放地雷的信息，每次玩家输入想要查看的坐标时都调用mine数组来判断；show数组用来存放排查出的雷的信息，在屏幕上显示给玩家。

3）二维数组的行列大小确定
玩家点击格子，系统会对该格子的周围8个格子进行探查是否存在雷，如果我们点击的四个边的格子，可能会出现越界的现象；

所以我们不妨将mine和show两个数组同时增加一行一列，由原来的9*9变为11*11；

我们用宏定义定义ROW COL为9，ROWS和COLS为ROW+2，这样方便棋盘的扩大和游戏的升级。

2.1 初始化

由于有mine和show两个二维数组，所以我们得同时初始化：

不妨将show数组初始化为'*'号，mine数组初始化为'0'

初始化函数和传参：

  1. void Initboard(char mine[ROWS][COLS], int rows, int cols,char set)
  2. {
  3. 	
  4. 	for (int i = 0; i < rows; i++)
  5. 	{
  6. 		for (int j = 0; j < cols; j++)
  7. 		{
  8. 			mine[i][j] = set;
  9. 		}
  10. 	}
  11. }
  12.  
  13. Initboard(mine, ROWS, COLS,'0');//初始化存放地雷的数组
  14. Initboard(show, ROWS, COLS,'*');//初始化显示信息的数组

注：既可以初始化存放地雷数组，也可以初始化显示信息的数组。

2.2 打印信息

  1. void Printboard(char board[ROWS][COLS], int row, int col)
  2. {
  3. 	int i, j;
  4. 	for (i = 0; i <= col; i++)
  5. 	{
  6. 		printf("%2d ", i);
  7. 	}
  8. 	printf("\n");
  9. 	for (i = 1; i <= row; i++)
  10. 	{
  11. 		printf("%2d ", i);
  12. 		for (j = 1; j <= col; j++)
  13. 		{
  14. 			printf("%2c ", board[i][j]);
  15. 		}
  16. 		printf("\n");
  17. 	}
  18. }

注：既可以打印show数组信息，也可以打印mine数组信息。

效果：

 2.3 设置地雷

设置地雷就需要用到随机数的三个函数：

int rand(void)           void srand(unsigned int seed)         time_t time(time_t* timer)

如果对三个函数的用法不太了解，可以访问我的文章：C语言实现小游戏三字棋_HenryLin1234的博客-CSDN博客里面对于电脑下棋的讲解有关于三个函数的基本用法。

存放地雷的二维数组之前被我们全部初始化为'0'，那么我们就让电脑在9*9的范围内随机更改二维数组的值为'1'，表示放置地雷。

  1. void SetMine(char mine[ROWS][COLS], int row, int col)
  2. {
  3. 	int count = 10;
  4. 	srand((unsigned int)time(NULL));
  5. 	while (count)
  6. 	{
  7. 		int x = rand() % row + 1;//1-9
  8. 		int y = rand() % col + 1;//1-9
  9.  
  10. 		if (mine[x][y] == '0')//存放雷的数组初始为'0'，存放之后设为1
  11. 		{
  12. 			mine[x][y] = '1';
  13. 			count--;
  14. 		}
  15. 	}
  16. }

注：count表示地雷的个数，电脑每设置一个地雷，count就自减，直到count为0时跳出循环，雷就布置好了。

2.4 排查地雷

排查地雷函数是整个游戏的核心代码段，我们的展开，清除标记，设置标记等功能都要在这个函数里面实现。

代码细节讲解：

1）假设我们知道每个地雷的所在位置，排查完所有不是雷的格子之后，系统要判定我们取得胜利，所以我们定义一个全局变量win（为啥不能是在函数内部的局部变量呢？），每次排查操作都让win++，直到win=所有格子数-雷的数量=行*列-雷的数量。在执行完while循环前如果玩家没有触碰雷，就表示玩家排雷成功了，然后我们打印出地雷所在位置的信息。

2）这里我们用宏定义COUNT为10，表示地雷的个数，方便后续地雷数量更改。

3）玩家输入坐标x和y之后，要进行坐标合法性的判定，坐标必须落在9*9的范围内而且没有被标记过（show[x][y] != '?'），然后才能进行后面的操作，否则提示“坐标不在棋盘范围内，请重新输入”。如果该坐标是雷，mine[x][y]=='1'，那么该局游戏结束，将全局变量win置0，break跳出循环；如果该坐标不是雷，就进行展开，玩家选择标记、清除标记的操作。

4）每次调用完展开函数，不是雷的区域都会被我们展开，win会增加，所以我们要判断一下win是否已经满足要求，不过这种情况很少见，一般出现在雷只有1个的情况，调用完展开函数就只会剩下一个雷，那么其实我们就已经赢了。

5）调用完展开函数，我们要让玩家选择标记可疑雷区或者清除标记的操作，在此之前我们要先清空一下缓存区，然后用switch语句，玩家输入'Y'就表示要标记，输入'N'就表示要清除标记，然后分别调用标记函数和清除标记函数即可。

6）游戏结束时将win置0，游戏结束的标志是被炸死或者扫雷成功。

  1. #define COUNT 10
  2. int win = 0;
  3. void CheckMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
  4. {
  5. 	int x = 0, y = 0;
  6. 	char ch = 0;
  7. 	while (win< row * col - COUNT)
  8. 	{
  9. 		printf("请排查雷，坐标:>");
  10. 		scanf("%d %d", &x, &y);
  11. 		if (x >= 1 && x <= ROW && y >= 1 && y <= COL && show[x][y]!='?')
  12. 		{
  13. 			if (mine[x][y] == '1')
  14. 			{
  15. 				printf("你被炸死了\n");
  16. 				Printboard(mine, ROW, COL);//打印地雷信息
  17. 				win = 0;
  18. 				break;
  19. 			}
  20. 			else
  21. 			{
  22. 				Spreadout(show, mine, x, y);//展开函数
  23. 				Printboard(show, ROW, COL);
  24. 				if (win == row * col - COUNT)
  25. 					break;
  26. 				printf("标记地雷：Y，清除标记：N，跳过操作：F\n");
  27. 				while ( ( ch = getchar() ) != '\n');//清空缓存区
  28. 				scanf("%c", &ch);
  29. 				switch (ch)
  30. 				{
  31. 				case'Y':
  32. 					SignMine(show);
  33. 					break;
  34. 				case 'N':
  35. 					ClearSign(show);
  36. 					break;
  37. 				default:
  38. 					break;
  39. 				}
  40. 			}
  41. 		}
  42. 		else
  43. 		{
  44. 			printf("坐标不在棋盘范围内，请重新输入\n");
  45. 		}
  46. 	}
  47. 	if (win == row * col - COUNT)
  48. 	{
  49. 		printf("恭喜你，排雷成功，来看看本局的地雷吧：\n");
  50. 		Printboard(mine, ROW, COL); 
  51.         win = 0;
  52. 	}
  53. }

2.4.1 统计该坐标周围八个坐标的雷的个数

  1. int GetMineCount(char mine[ROWS][COLS], int x, int y)
  2. {
  3. 	return (mine[x - 1][y - 1] + mine[x - 1][y] + mine[x - 1][y + 1] + mine[x][y - 1] + mine[x][y + 1] + mine[x + 1][y - 1] + mine[x + 1][y] + mine[x + 1][y + 1] - 8 * '0');
  4. }

当然我们也可以用for循环，这边为了节省一些时间提高代码效率我就这么写了。

2.4.2 展开函数

  1. void Spreadout(char show[ROWS][COLS],char mine[ROWS][COLS],int x, int y)
  2. {
  3. 	if (x >= 1 && x <= ROW && y >= 1 && y <= COL)
  4. 	{
  5. 		win++;//win自增
  6. 		int count = GetMineCount(mine, x, y);
  7. 		if (count == 0)//该处周围八个格子都不是雷
  8. 		{
  9. 			show[x][y] = ' ';
  10. 			int i = 0, j = 0;
  11. 			for (i = x - 1; i <= x + 1; i++)
  12. 			{
  13. 				for (j = y - 1; j <= y + 1; j++)
  14. 				{
  15. 					if (show[i][j] == '*') //该处没有被展开过
  16. 					{
  17. 						Spreadout(show, mine, i, j);
  18. 					}
  19. 				}
  20. 			}
  21. 		}
  22. 		else//该处周围八个格子有雷，就显示数字
  23. 		{
  24. 			show[x][y] = count + '0';//将数字count转化为字符count
  25. 		}
  26. 	}
  27. }

展开条件：

（1）该坐标本身不是雷：mine[x][y] != '1' 该条件总是满足

（2）该坐标周围没有雷：GetMineCount(mine,x,y)==0 该条件不一定总是满足，所以要判断

（3）该坐标没有被展开过：show[x][y]=='*' 该条件不一定总是满足，所以要判断

每次调用展开函数，win都必须自增一，如果win只是排查地雷函数里的局部变量，展开函数是不认识这个局部变量的，这就是为什么win必须是全局变量。

如果该坐标的周围八个格子有雷，那么该坐标的格子就得显示周围有多少个雷；如果该坐标的周围八个格子没有雷，那么就递归调用展开函数，就能达到“展开”的效果。

2.4.3 标记函数

  1. void SignMine(char show[ROWS][COLS])
  2. {
  3. 	int x = 0, y = 0;
  4. 	int input = 1;
  5. 	do
  6. 	{
  7. 		printf("请输入要标记的坐标:>");
  8. 		scanf("%d %d", &x, &y);
  9. 		if (x >= 1 && x <= ROW && y >= 1 && y <= ROW && show[x][y] == '*')
  10. 		{
  11. 			show[x][y] = '?';
  12. 			Printboard(show, ROW, COL);
  13. 		}
  14. 		else
  15. 			printf("坐标已被标记或者坐标越界，请重新输入\n");
  16. 		printf("继续标记:1,跳过标记:0\n");
  17. 		scanf("%d", &input);
  18. 		switch (input)
  19. 		{
  20. 		case 1:
  21. 			SignMine(show);
  22. 			input = 0;//关键
  23. 			break;
  24. 		default:
  25. 			break;
  26. 		}
  27. 	} while (input);
  28. }

标记函数要在没被标记过或者没被继续展开的地方进行操作，所以在if条件里加了一个show[x][y]=='*'的判断。而且玩家不一定只标记一次，所以我们用do-while循环，由input控制，标记完就提示"继续标记:1,跳过标记:0"。

输入1,表示该层函数的input=1，继续标记递归调用SignMine函数；输入0，表示该层函数的input=0，跳过标记后不满足继续循环的条件，自然跳出标记函数。

  

这里为什么要手动将input置零呢？我们看没有这条代码的结果： 

可以看见，我们选择了标记地雷之后输入了标记坐标，然后选择继续标记，继续标记了之后，我们想跳过标记，但是下一行报"请输入要标记的坐标"，而不是"请选择要排查的坐标"。

原因是：内层函数的input=0，而外层函数的input=1。内层函数表示case1里递归调用的SignMine。所以我们将外层函数的input手动置零，这样外层函数也不满足继续循环的条件。

2.4.4 清除标记函数

  1. void ClearSign(char show[ROWS][COLS])
  2. {
  3. 	int x = 0, y = 0;
  4. 	int input = 0;
  5. 	do
  6. 	{
  7. 		printf("请输入要清除的坐标:>");
  8. 		scanf("%d %d", &x, &y);
  9. 		if (x >= 1 && x <= ROW && y >= 1 && y <= ROW && show[x][y]=='?')
  10. 		{
  11. 			show[x][y] = '*';
  12. 			Printboard(show, ROW, COL);
  13. 		}
  14. 		else
  15. 			printf("坐标已被清除标记或者坐标越界，请重新输入\n");
  16. 		printf("继续清除:1,跳过清除:0\n");
  17. 		scanf("%d", &input);
  18. 		switch (input)
  19. 		{
  20. 		case 1:
  21. 			ClearSign(show);
  22. 			input = 0;//关键
  23. 			break;
  24. 		default:
  25. 			break;
  26. 		}
  27. 	} while (input);
  28. }

清除标记函数要在标记的坐标上进行操作，所以if里有一个show[x][y]=='?'的判断，同时也要将input手动置零。

四、游戏代码

test.c:

  1. #include "game.h"
  2. void game()
  3. {
  4. 	
  5. 	char mine[ROWS][COLS];//存放布置好的雷
  6. 	char show[ROWS][COLS];//存放排查出的雷的信息
  7. 	//初始化棋盘
  8. 	//mine数组一开始全是‘0’
  9. 	//show数组一开始全是‘*’
  10. 	Initboard(mine, ROWS, COLS,'0');
  11. 	Initboard(show, ROWS, COLS,'*');
  12.  
  13. 	Printboard(show,ROW,COL);
  14.  
  15. 	//布置雷,将存放雷的数组有雷的位置设为'1'
  16. 	SetMine(mine, ROW, COL);
  17. 	//Printboard(mine, ROW, COL);
  18. 	
  19. 	//排查雷
  20. 	CheckMine(mine, show, ROW, COL);
  21. }
  22. int main()
  23. {
  24. 	int input = 0;
  25. 	do
  26. 	{
  27. 		menu();
  28. 		printf("请选择:>");
  29. 		scanf("%d", &input);
  30. 		switch (input)
  31. 		{
  32. 		case 1:
  33. 			printf("扫雷\n");
  34. 			game();
  35. 			break;
  36. 		case 0:
  37. 			printf("退出游戏\n");
  38. 			break;
  39. 		default:
  40. 			printf("重新选择\n");
  41. 			break;
  42. 		}
  43. 	} while (input);
  44. 	return 0;
  45. }

game.c:

  1. #include "game.h"
  2.  
  3. void menu()
  4. {
  5. 	printf("**********************************\n");
  6. 	printf("*********** 1. play **************\n");
  7. 	printf("*********** 0. exit **************\n");
  8. 	printf("**********************************\n");
  9. }
  10.  
  11. void Initboard(char mine[ROWS][COLS], int rows, int cols,char set)
  12. {
  13. 	
  14. 	for (int i = 0; i < rows; i++)
  15. 	{
  16. 		for (int j = 0; j < cols; j++)
  17. 		{
  18. 			mine[i][j] = set;
  19. 		}
  20. 	}
  21. }
  22.  
  23. void Printboard(char board[ROWS][COLS], int row, int col)
  24. {
  25. 	int i, j;
  26. 	for (i = 0; i <= col; i++)
  27. 	{
  28. 		printf("%2d ", i);
  29. 	}
  30. 	printf("\n");
  31. 	for (i = 1; i <= row; i++)
  32. 	{
  33. 		printf("%2d ", i);
  34. 		for (j = 1; j <= col; j++)
  35. 		{
  36. 			printf("%2c ", board[i][j]);
  37. 		}
  38. 		printf("\n");
  39. 	}
  40. }
  41.  
  42. void SetMine(char mine[ROWS][COLS], int row, int col)
  43. {
  44. 	int count = 10;
  45. 	srand((unsigned int)time(NULL));
  46. 	while (count)
  47. 	{
  48. 		int x = rand() % row + 1;//1-9
  49. 		int y = rand() % col + 1;//1-9
  50.  
  51. 		if (mine[x][y] == '0')//存放雷的数组初始为'0'，存放之后设为1
  52. 		{
  53. 			mine[x][y] = '1';
  54. 			count--;
  55. 		}
  56. 	}
  57. }
  58.  
  59.  
  60. int win = 0;
  61. void CheckMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
  62. {
  63. 	int x = 0, y = 0;
  64. 	char ch = 0;
  65. 	while (win< row * col - COUNT)
  66. 	{
  67. 		printf("请排查雷，坐标:>");
  68. 		scanf("%d %d", &x, &y);
  69. 		if (x >= 1 && x <= row && y >= 1 && y <= col && show[x][y]!='?')
  70. 		{
  71. 			if (mine[x][y] == '1')
  72. 			{
  73. 				printf("你被炸死了\n");
  74. 				Printboard(mine, ROW, COL);
  75. 				win = 0;
  76. 				break;
  77. 			}
  78. 			else
  79. 			{
  80. 				Spreadout(show, mine, x, y);
  81. 				Printboard(show, ROW, COL);
  82. 				if (win == row * col - COUNT)
  83. 					break;
  84. 				printf("标记地雷：Y，清除标记：N，跳过操作：F\n");
  85. 				//清空缓存区
  86. 				while ( ( ch = getchar() ) != '\n');
  87. 				scanf("%c", &ch);
  88. 				switch (ch)
  89. 				{
  90. 				case'Y':
  91. 					SignMine(show);
  92. 					break;
  93. 				case 'N':
  94. 					ClearSign(show);
  95. 					break;
  96. 				default:
  97. 					break;
  98. 				}
  99. 			}
  100. 		}
  101. 		else
  102. 		{
  103. 			printf("坐标不在棋盘范围内，请重新输入\n");
  104. 		}
  105. 	}
  106. 	if (win == row * col - COUNT)
  107. 	{
  108. 		printf("恭喜你，排雷成功，来看看本局的地雷吧：\n");
  109. 		Printboard(mine, ROW, COL);
  110. 	}
  111. }
  112.  
  113. int GetMineCount(char mine[ROWS][COLS], int x, int y)//统计周边雷的个数
  114. {
  115. 	return (mine[x - 1][y - 1] + mine[x - 1][y] + mine[x - 1][y + 1] + mine[x][y - 1] + mine[x][y + 1] + mine[x + 1][y - 1] + mine[x + 1][y] + mine[x + 1][y + 1] - 8 * '0');
  116. }
  117.  
  118. void Spreadout(char show[ROWS][COLS],char mine[ROWS][COLS],int x, int y)
  119. {
  120. 	//展开函数
  121. 	//1.该坐标不是雷: mine[x][y] != '1'  
  122. 	//2.该坐标周围没有雷: GetMineCount(mine,x,y)==0   
  123. 	//3.该坐标没有被排查过：show[x][y] == '*'
  124. 	if (x >= 1 && x <= ROW && y >= 1 && y <= COL )
  125. 	{
  126. 		win++;
  127. 		int count = GetMineCount(mine, x, y);
  128. 		if (count == 0)
  129. 		{
  130. 			show[x][y] = ' ';
  131. 			int i = 0, j = 0;
  132. 			for (i = x - 1; i <= x + 1; i++)
  133. 			{
  134. 				for (j = y - 1; j <= y + 1; j++)
  135. 				{
  136. 					if (show[i][j] == '*')     
  137. 					{
  138. 						Spreadout(show, mine, i, j);
  139. 					}
  140. 				}
  141. 			}
  142. 		}
  143. 		else
  144. 		{
  145. 			show[x][y] = count + '0';//将数字count转化为字符count
  146. 		}
  147. 	}
  148. }
  149.  
  150. void SignMine(char show[ROWS][COLS])
  151. {
  152. 	int x = 0, y = 0;
  153. 	int input = 1;
  154. 	do
  155. 	{
  156. 		printf("请输入要标记的坐标:>");
  157. 		scanf("%d %d", &x, &y);
  158. 		if (x >= 1 && x <= ROW && y >= 1 && y <= ROW && show[x][y] == '*')
  159. 		{
  160. 			show[x][y] = '?';
  161. 			Printboard(show, ROW, COL);
  162. 		}
  163. 		else
  164. 			printf("坐标已被标记或者坐标越界，请重新输入\n");
  165. 		printf("继续标记:1,跳过标记:0\n");
  166. 		scanf("%d", &input);
  167. 		switch (input)
  168. 		{
  169. 		case 1:
  170. 			SignMine(show);
  171. 			break;
  172. 		default:
  173. 			break;
  174. 		}
  175. 	} while (input);
  176. }
  177.  
  178. void ClearSign(char show[ROWS][COLS])
  179. {
  180. 	int x = 0, y = 0;
  181. 	int input = 0;
  182. 	do
  183. 	{
  184. 		printf("请输入要清除的坐标:>");
  185. 		scanf("%d %d", &x, &y);
  186. 		if (x >= 1 && x <= ROW && y >= 1 && y <= ROW && show[x][y]=='?')
  187. 		{
  188. 			show[x][y] = '*';
  189. 			Printboard(show, ROW, COL);
  190. 		}
  191. 		else
  192. 			printf("坐标已被清除标记或者坐标越界，请重新输入\n");
  193. 		printf("继续清除:1,跳过清除:0\n");
  194. 		scanf("%d", &input);
  195. 		switch (input)
  196. 		{
  197. 		case 1:
  198. 			ClearSign(show);
  199. 			input = 0;//关键
  200. 			break;
  201. 		default:
  202. 			break;
  203. 		}
  204. 	} while (input);
  205. }

game.h:

  1. #pragma once
  2. #define _CRT_SECURE_NO_WARNINGS 1
  3. #include<stdio.h>
  4. #include<stdlib.h>
  5. #include<time.h>
  6. #define ROW 9
  7. #define COL 9
  8. #define COUNT 10
  9. #define ROWS ROW+2
  10. #define COLS COL+2
  11.  
  12. void menu();
  13. //初始化棋盘
  14. void Initboard(char board[ROWS][COLS], int rows, int cols,char set);
  15.  
  16. //打印棋盘
  17. void Printboard(char board[ROWS][COLS], int row, int col);
  18.  
  19. //设置地雷
  20. void SetMine(char board[ROWS][COLS], int row, int col);
  21.  
  22. //检查地雷
  23. void CheckMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col);
  24.  
  25. //统计当前位置周围的雷
  26. int GetMineCount(char mine[ROWS][COLS], int x, int y);
  27.  
  28. //展开函数
  29. void Spreadout(char show[ROWS][COLS], char mine[ROWS][COLS],int x, int y);
  30.  
  31. //标记可疑的区域
  32. void SignMine(char show[ROWS][COLS]);
  33.  
  34. //清除标记
  35. void ClearSign(char show[ROWS][COLS]);

五、代码优缺点总结

优点：实现了扫雷函数的大部分功能，比如展开，标记，清除标记等等。

缺点：游戏难度没办法由玩家手动设置，扫雷过程中标记和清除标记的顺序比较固定，这些交由读者来完善~

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

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

  

闽ICP备14008679号