C语言第十一课(上)：编写扫雷游戏（综合练习2）

C语言第十一课(上)：编写扫雷游戏（综合练习2）
目录

前言：

一、文件建立：

        1.头文件game.h：

2.函数定义文件game.c：

        3.工程测试文件test.c：

二、编写井字棋游戏：

1.程序整体执行思路：

        2.menu菜单：

        3.game游戏函数逻辑：

4.game函数中各项功能的实现：

①.头文件game.h内容：

②.棋盘的初始化InitBoard：

③.打印棋盘DisplayBoard：

④.布置“地雷”SetMine：

⑤.统计雷get_mine_count：

⑥.排雷FindMine：

三、完整程序代码：

1.gam.h：

2.game.c：

3.test.c：

四、总结：

前言：

前面两篇文章中，各位小伙伴们写出了自己在C语言写学习中的第一个小游戏井字棋，阿銮在这里恭喜各位小伙伴辣！本文我们将进行更加复杂的阶段编程练习——编写扫雷游戏。

一、文件建立：

同样的，我们在编写扫雷游戏时，也使用模块化开发的方式，将整段编程代码划分为game.h、game.c与test.c三个文件进行编写：

        1.头文件game.h：

        该文件用于包含宏与其它头文件，并存放功能实现函数的函数声明：

2.函数定义文件game.c：

         该文件用于书写所有的程序功能实现的函数定义：

        3.工程测试文件test.c：

        该文件用于书写我们的程序主体部分：

二、编写井字棋游戏：

1.程序整体执行思路：

与之前写过的井字棋游戏整体执行思路相同，首先我们自定义两个函数，menu为菜单函数，负责向玩家打印游戏菜单；game为游戏函数，负责实现整个游戏的逻辑实现。当程序开始编译运行后，将会按照顺序，先执行menu函数打印出游戏菜单，接着执行game函数让玩家们进行游戏：
```
#define _CRT_SECURE_NO_WARNINGS 1
 
#include"game.h"
 
//游戏逻辑：
void game()
{
	...
}
 
void test()
{
    menu();
    game();
    ...
}
 
int main()
{
	test();
 
	return 0;
}
```
同时，与井字棋游戏相同，大多数时候玩家往往会选择多次进行游戏，所以我们通过在数函数部分结合我们在之前介绍过的的循环和分支语句很容易实现该目的：
```
void test()
{
	int input = 0;
	do
	{
		menu();
		printf("请选择：");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			game();
			break;
		case 0:
			printf("退出游戏...\n");
			break;
		default:
			printf("输入错误，请重新选择！\n");
			break;
		}
	} while (input);
}
```
这些步骤与井字棋游戏的整体运行逻完全相同，这里不再进行运行演示。

2.menu菜单：

与扫雷游戏相同，仅使用 printf 函数进行屏幕打印即可：
```
void menu()
{
	printf("******************************\n");
	printf("******************************\n");
	printf("*****  欢迎来到扫雷游戏  *****\n");
	printf("*****       1.play       *****\n");
	printf("*****       0.exit       *****\n");
	printf("******************************\n");
	printf("******************************\n");
}
```
且编译运行结果与井字棋相同，不再进行过多阐述。

3.game游戏函数逻辑：

（注：此处我们同样只关心实现逻辑，具体功能实现后面会逐一进行研究说明）

我们同样从扫雷游戏的游戏规则与胜利条件开始研究。扫雷游戏其本质为推理判断游戏，它有9×9标准游戏界面，在游戏开始时，所有方格中的内容将会被隐藏，玩家不清楚每个格子的内容，但在所有格子中，部分格子中被布置下了“地雷”，玩家需要在判断放个安全的情况下进行扫雷，在安全的格子上，若以该方格为中心的九宫格内有危险的“地雷”，该中心方格上将会显示中心九宫格内“地雷”的数量，玩家可以通过选择该位置来进行排雷，若判断失误，选择的位置上为“地雷”，则玩家输掉了该局游戏，直到玩家将全部的地雷全部排查出来，即可获得游戏的胜利。

梳理了游戏的规则，我们开始尝试编写该游戏。

在游戏函数中，首先我们进行棋盘的初始化。与井字棋游戏不同的是，在这里我们需要定义并初始化两个棋盘。需要两个棋盘原因是，我们对“安全”与“地雷”的区分将会使用到' 0 '和' 1 '两个字符，其中' 0 表示“安全”而' 1 '则表示“地雷”，如果我们仅仅只定义并初始化一个棋盘，当进行地雷判断时，我们将无法确定' 1 '是表示周围中心九宫格内地雷的数量还是表示该方格内为“地雷，造成我们对游戏情况判断的歧义”：
```
void game()
{
	char mine[ROWS][COLS] = { 0 };
	//存放布置的雷的信息
	char show[ROWS][COLS] = { 0 };
	//存放查出的雷的信息
}
```
接着我们对这两个棋盘进行初始化。mine数组中用于存放布置的地雷的信息，故首先将其全部初始化为“安全”，而show数组用于打印向玩家反馈当前扫雷情况，故刚开局时全部位置均未未知，初始化为象征性占位符' * '，并在棋盘初始化完成后将反馈棋盘show进行打印：

（mine数组中存放实际布雷信息，游戏实际为操作mine数组，show数组仅供反馈排雷情况使用）
```
void game()
{
	char mine[ROWS][COLS] = { 0 };
	//存放布置的雷的信息
	char show[ROWS][COLS] = { 0 };
	//存放查出的雷的信息
	//初始化棋盘
	InitBoard(mine, ROWS, COLS, '0');
	InitBoard(show, ROWS, COLS, '*');
    //打印棋盘
	DisplayBoard(show, ROW, COL);
}
```
在棋盘定义并初始化完成后，我们需要在我们定义的全“安全”棋盘中，放入一定数量随机位置的“地雷”：

（注：此处初始化与定义的棋盘，与进行实际操作的行与列不同，后文实现过程将会进行说明）
```
void game()
{
	char mine[ROWS][COLS] = { 0 };
	//存放布置的雷的信息
	char show[ROWS][COLS] = { 0 };
	//存放查出的雷的信息
	//初始化棋盘
	InitBoard(mine, ROWS, COLS, '0');
	InitBoard(show, ROWS, COLS, '*');
	//打印棋盘
	DisplayBoard(show, ROW, COL);
	//布置雷
	SetMine(mine, ROW, COL);
}
```
在放置好“地雷”后，就可以让玩家开始进行“扫雷”了：
```
void game()
{
    //定义棋盘
	char mine[ROWS][COLS] = { 0 };
	//存放布置的雷的信息
	char show[ROWS][COLS] = { 0 };
	//存放查出的雷的信息
	//初始化棋盘
	InitBoard(mine, ROWS, COLS, '0');
	InitBoard(show, ROWS, COLS, '*');
	//打印棋盘
	DisplayBoard(show, ROW, COL);
	//布置雷
	SetMine(mine, ROW, COL);
	//扫雷
	FindMine(mine, show, ROW, COL);
}
```
至此，扫雷游戏的游戏整体逻辑我们就理清楚了，而接下来就是各项功能的实现了。

4.game函数中各项功能的实现：

①.头文件game.h内容：

在我们的头文件中，存放着宏定义、引用头文件与函数的声明。

首先我们来看宏定义：
```
#define ROW 9
#define COL 9
#define ROWS ROW+2
#define COLS ROW+2
#define EASY_COUNT 10
```
可以看到，在这个游戏中，我们一共定义了五个宏常量。其中行ROW和列COL定义为9，而行ROWS和列COLS定义为11。那么同样是棋盘的行和列，为什么要定义两组不同的行和列呢？这样定义的原因是为了避免出现越界，同时便于进行操作。

我们向玩家展示的棋盘是9×9的棋盘，但是当我们后面需要统计中心九宫格中地雷的数量时，倘若在操作最上或最下行(第一、九行)与最左或最右(第一、九列)时，若只定义9×9的棋盘，在对一、九行、列方格周围进行“地雷”的计数时，将会造成数组越界的错误，所以我们在定义时应当在第一行之上、第九行之下、第一列之左和第九列之右各添加一行/列，总计定义11×11的棋盘数组。（即实际定义11×11数组，展示中间的9×9数组）

我们还定义了宏常量EASY_COUNT，用于表示在我们的一局游戏中添加的“地雷”的数量。

接着是头文件的引用：
```
#include
#include
#include
```
整个游戏中多次使用了输入scanf 与输出printf 函数，需引用头文件stdio.h；在进行布雷时，我们需要生成随机数作为“地雷”的下标，这时需要使用srand函数来确定随机数的起点，需引用头文件stdlib.h；在确定随机数起点时，我们采用根据时间戳来确定的方式，需引用头文件time.h。

最后就是扫雷游戏所要用到的全部功能函数的函数声明了：

（此处为本游戏中全部的函数声明，函数定义将在后面逐一研究）
```
void menu();
void game();
void InitBoard(char board[ROWS][COLS], int rows, int cols, char set);
void DisplayBoard(char board[ROWS][COLS], int row, int col);
void SetMine(char mine[ROWS][ROWS], int row, int col);
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col);
int get_mine_count(char mine[ROWS][COLS], int x, int y);
```
②.棋盘的初始化InitBoard：

我们前面已经定义好了两个棋盘，这里的初始化也很简单，我们采用循环遍历的方式，将每一个位置上的数据都初始化为相应符号。对于mine数组来说，该数组用于存放地雷信息，故初始化为全' 0 '；而对于show数组来说，该数组用于展示，需要隐藏方格中的信息，故全部初始化为' * '：
```
void InitBoard(char board[ROWS][COLS], int rows, int cols, char set)
{
	int i = 0;
	for (i = 0; i < rows; i++)
	{
		int j = 0;
		for (j = 0; j < cols; j++)
		{
			board[i][j] = set;
		}
	}
}
```
③.打印棋盘DisplayBoard：

我们在将棋盘初始化完成以及每一次排雷，乃至最终反馈游戏结果时，都需要将我们当前的排雷情况进行打印，反馈给玩家。同时，为了界面更加的美观，我们可以在打印棋盘前先打印一行列号，并在每一行打印前先打印一个行号。棋盘界面的打印我们同样通过遍历思想来实现：
```
void DisplayBoard(char board[ROWS][COLS], int row, int col)
{
	printf("  --------扫雷--------\n");
	int i = 0;
	printf("| \\ 1 2 3 4 5 6 7 8 9 |\n");
    //第一列为列号，在列号最上方打印"\"时，一定注意代码应写为\\，否则\将被视为转义字符而不生效
	for (i = 1; i <= row; i++)
	{
		int j = 0;
		printf("| %d ", i);
		for (j = 1; j <= col; j++)
		{
			printf("%c ", board[i][j]);
		}
		printf("|\n");
	}
	printf("  --------扫雷--------\n");
}
```
我们将其编译运行起来，看看棋盘的打印效果：

可以看到棋盘的打印已经按照我们规定的格式完成了打印操作。

④.布置“地雷”SetMine：

布置地雷也很好理解，在中心的9×9棋盘中，通过使用时间戳来确定随机数的起点，取随机数作为雷的下标，并放置在mine数组中：
```
void SetMine(char mine[ROWS][ROWS], int row, int col)
{
	int count = EASY_COUNT;
	while (count)
	{
		//生成随机下标：
		int x = rand() % row + 1;
		int y = rand() % col + 1;
		//布置雷：
		if (mine[x][y] == '0')
		{
			mine[x][y] = '1';
			count--;
		}
	}
}
```
由于我们需要生成不止一个“地雷”，故需要进行循环，循环的判断条件我们就设置为初值等于宏常量地雷数的自定义变量count，并在每次布雷后执行减一操作，当其不为零时便判断为真不断执行循环布雷，直至最后一次布雷后变为零，判断为假循环停止。

同时，细心的小伙伴们可能会有疑问了，我们定义的棋盘为11×11，那我们怎样去确定“地雷”都被布置在中间的9×9的部分呢？首先我们看到，在我们取随机下标时，是对传入的行数和列数求余后加一，求余后保证下标从零开始，再加一即保证了从和数组的第一列(0+1)开始算起，同时在传参时我们传入的是展示的行与列数：
```
//布置雷
SetMine(mine, ROW, COL);
```
传入参数的值为9，则随机下标的上限即被限制为为9(0+9)。这样就实现了从第一行到第九行，从第一列到第九列，即中心9×9棋盘的范围限制。

⑤.统计雷get_mine_count：

我们还需要一个函数来统计我们排雷位置周围的地雷数量：
```
//统计雷：
int get_mine_count(char mine[ROWS][COLS], int x, int y)
{
	return (mine[x - 1][y - 1] + mine[x][y - 1] + mine[x + 1][y - 1] + mine[x - 1][y] + mine[x + 1][y] + mine[x - 1][y + 1] + mine[x][y + 1] + mine[x + 1][y + 1] - 8 * '0'); 
}
```
其原理很好理解，将该坐标周围八个位置上的数据加在一起即可。但由于我们定义的是字符型数组，其中存放的是字符' 0 '和字符' 1 '！而不是整形1和0！在打印时若直接进行相加计算，则不会得到我们想要的结果！所以我们在计算时，应当根据其ASCII码值进行计算，将周围八个位置上的字符进行相加后，减去8个字符' 0 '，才是我们想要的得到结果，并将结果返回。

⑥.排雷FindMine：

在排雷时，我们同样是根据坐标进行排雷，而在输入坐标时，我们需要对坐标的合理性进行判断。我们首先要循环对行坐标进行判断，当输入坐标在中心9×9棋盘中时，我们进行下一步，否则提示玩家“您输入的行号有误，请重新输入”：
```
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{
	printf("请输入您想要排查的坐标：\n");
	int x = 0;
	int y = 0;
	while (1)
	{
		printf("您想排查哪一行：");
		scanf("%d", &x);
		if (x >= 1 && x <= row)
		{
			;
		}
		else
		{
			printf("您输入的行号有误，请重新输入！\n");
		}
	}
}
```
接着我们用同样的方式对列坐标进行判断：
```
 
while (1)
{
    printf("您想排查哪一列：");
	scanf("%d", &y);
	if (y >= 1 && y <= col)
	{
	    //执行排查
		break;
	}
	else
	{
		printf("您输入的列数有误，请重新输入！\n");
	}
}
```
当行与列均判断合理后进行后续操做，操作完成后使用一个break语句跳出当前坐标的操作，并进行下一次判断与操作。

当确定坐标在范围内后，我们还需要进行一次判断，内容是要去判断此时我们要进行操作的坐标是否在之前已经被操作过，如果操作过则重新选择坐标，没有操作过才进行接下来的排雷操作：
```
if (show[x][y] != '*')
{
	printf("该坐标已被排查过！\n");
	DisplayBoard(show, ROW, COL);
	break;
}
```
在确定了坐标合理且没有进行过操作后，我们就可以对该坐标进行排雷了：
```
if (mine[x][y] == '1')
{
	DisplayBoard(mine, ROW, COL);
	printf("很遗憾，您死了！\n");
	reak;
}
else
{
    int n = get_mine_count(mine, x, y);
	show[x][y] = n + '0';
	DisplayBoard(show, ROW, COL);
	break;
}
```
我们进行判断，若该坐标内存放的是' 1 '，则说明该位置放置的为“地雷”，根据游戏规则，此时玩家就输掉了这场游戏，应提示玩家“很遗憾，您死了”并退出游戏；若为' 0 '，则说明此处没有“地雷”，玩家在该位置上的排雷成功。

接下来，应当在本次成功排雷的坐标上显示出以该坐标为中心的九宫格内的“地雷”数量，我们定义一个变量n来接收计数函数返回的“地雷”数量统计结果。这里同样需要注意，我们的n接收到的是经过处理的ASCII码值，我们在进行使用时，应当对该值进行逆处理，即将该结果加上字符' 0 '，才是我们期望中要打印在该坐标处的内容。

将它们组合在一起就能实现目的了吗？我们来看：
```
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{
	printf("请输入您想要排查的坐标：\n");
	int x = 0;
	int y = 0;
	while (1)
	{
		printf("您想排查哪一行：");
		scanf("%d", &x);
		if (x >= 1 && x <= row)
		{
			while (1)
			{
				printf("您想排查哪一列：");
				scanf("%d", &y);
				if (y >= 1 && y <= col)
				{
					if (show[x][y] != '*')
					{
						printf("该坐标已被排查过！\n");
						DisplayBoard(show, ROW, COL);
						break;
					}
					if (mine[x][y] == '1')
					{
						DisplayBoard(mine, ROW, COL);
						printf("很遗憾，您死了！\n");
						break;
					}
					else
					{
						int n = get_mine_count(mine, x, y);
						show[x][y] = n + '0';
						DisplayBoard(show, ROW, COL);
						break;
					}
				}
				else
				{
					printf("您输入的列数有误，请重新输入！\n");
				}
			}
		}
		else
		{
			printf("您输入的行数有误，请重新输入！\n");
		}
	}
}
```
我们运行后发现，程序出现了问题，即使在我们“踩到地雷”后，程序仍没有结束，仍在提示我们输入下一个坐标，这是为什么呢？我们研究我们的代码后发现，我们最内层的break在执行时并没有结束最外层的循环，导致程序无休止的执行下去而不会终结。那我们该如何处理呢？

我们的思路是，既然它现在影响不到最外层循环，那我们就想办法让它去影响最外层的循环。我们的解决方案是，在最外层循环的控制表达式上下功夫：
```
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{
	printf("请输入您想要排查的坐标：\n");
	int x = 0;
	int y = 0;
	int win = 0;
	while (win < (row * col - EASY_COUNT))
	{
		printf("您想排查哪一行：");
		scanf("%d", &x);
		if (x >= 1 && x <= row)
		{
			while (1)
			{
				printf("您想排查哪一列：");
				scanf("%d", &y);
				if (y >= 1 && y <= col)
				{
					if (show[x][y] != '*')
					{
						printf("该坐标已被排查过！\n");
						DisplayBoard(show, ROW, COL);
						break;
					}
					if (mine[x][y] == '1')
					{
						DisplayBoard(mine, ROW, COL);
						printf("很遗憾，您死了！\n");
						win = 0;
						break;
					}
					else
					{
						int n = get_mine_count(mine, x, y);
						show[x][y] = n + '0';
						DisplayBoard(show, ROW, COL);
						win++;
						break;
					}
				}
				else
				{
					printf("您输入的列数有误，请重新输入！\n");
				}
			}
		}
		else
		{
			printf("您输入的行数有误，请重新输入！\n");
		}
	}
}
```
我们定义一个变量win，当win小于空着的格子，即排雷没有全部排完时，就不断进行循环排雷，若期间“踩到地雷”，便修改win = row * col - EASY_COUNT + 1，即破坏循环条件使判断判定为假而跳出循环。若没有“踩到地雷”则将执行替换的同时将变量win加一，直至全部排完游戏胜利退出循环。

那么为什么我们在“踩到地雷”时不让win = row * col - EASY_COUNT呢？这样不也可以破坏循环条件没？原因是，在所有的安全坐标都排完以后，此时的变量win是等于row * col - EASY_COUNT的，我们需要根据这个条件来进行胜利条件判断：
```
if (win == (row * col - EASY_COUNT))
{
	printf("恭喜您排雷成功，获得胜利！\n");
	DisplayBoard(mine, ROW, COL);
}
```
若“踩到地雷”时也执行这样的修改，则会造成程序语句歧义而产生错误的执行结果。

则总结排雷函数FindMine代码应当为：
```
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{
	printf("请输入您想要排查的坐标：\n");
	int x = 0;
	int y = 0;
	int win = 0;
	while (win < (row * col - EASY_COUNT))
	{
		printf("您想排查哪一行：");
		scanf("%d", &x);
		if (x >= 1 && x <= row)
		{
			while (1)
			{
				printf("您想排查哪一列：");
				scanf("%d", &y);
				if (y >= 1 && y <= col)
				{
					if (show[x][y] != '*')
					{
						printf("该坐标已被排查过！\n");
						DisplayBoard(show, ROW, COL);
						break;
					}
					if (mine[x][y] == '1')
					{
						DisplayBoard(mine, ROW, COL);
						printf("很遗憾，您死了！\n");
						win = row * col - EASY_COUNT + 1;
						break;
					}
					else
					{
						int n = get_mine_count(mine, x, y);
						show[x][y] = n + '0';
						DisplayBoard(show, ROW, COL);
						win++;
						break;
					}
				}
				else
				{
					printf("您输入的列数有误，请重新输入！\n");
				}
			}
		}
		else
		{
			printf("您输入的行数有误，请重新输入！\n");
		}
	}
	if (win == (row * col - EASY_COUNT))
	{
		printf("恭喜您排雷成功，获得胜利！\n");
		DisplayBoard(mine, ROW, COL);
	}
}
```
至此，扫雷游戏的最基础游戏功能就得到了实现。

三、完整程序代码：

1.gam.h：
```
#pragma once
 
#define ROW 9
#define COL 9
#define ROWS ROW+2
#define COLS ROW+2
#define EASY_COUNT 10
 
#include
#include
#include
 
void menu();
void game();
void InitBoard(char board[ROWS][COLS], int rows, int cols, char set);
void DisplayBoard(char board[ROWS][COLS], int row, int col);
void SetMine(char mine[ROWS][ROWS], int row, int col);
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col);
int get_mine_count(char mine[ROWS][COLS], int x, int y);
```
2.game.c：
```
#define _CRT_SECURE_NO_WARNINGS 1
 
#include"game.h"
 
//打印菜单：
void menu()
{
	printf("******************************\n");
	printf("******************************\n");
	printf("*****  欢迎来到扫雷游戏  *****\n");
	printf("*****       1.play       *****\n");
	printf("*****       0.exit       *****\n");
	printf("******************************\n");
	printf("******************************\n");
}
 
//初始化棋盘：
void InitBoard(char board[ROWS][COLS], int rows, int cols, char set)
{
	int i = 0;
	for (i = 0; i < rows; i++)
	{
		int j = 0;
		for (j = 0; j < cols; j++)
		{
			board[i][j] = set;
		}
	}
}
 
//打印棋盘：
void DisplayBoard(char board[ROWS][COLS], int row, int col)
{
	printf("  --------扫雷--------\n");
	int i = 0;
	printf("| \\ 1 2 3 4 5 6 7 8 9 |\n");
	for (i = 1; i <= row; i++)
	{
		int j = 0;
		printf("| %d ", i);
		for (j = 1; j <= col; j++)
		{
			printf("%c ", board[i][j]);
		}
		printf("|\n");
	}
	printf("  --------扫雷--------\n");
}
 
//布置雷：
void SetMine(char mine[ROWS][ROWS], int row, int col)
{
	int count = EASY_COUNT;
	while (count)
	{
		//生成随机下标：
		int x = rand() % row + 1;
		int y = rand() % col + 1;
		//布置雷：
		if (mine[x][y] == '0')
		{
			mine[x][y] = '1';
			count--;
		}
	}
}
 
//统计雷：
int get_mine_count(char mine[ROWS][COLS], int x, int y)
{
	return (mine[x - 1][y - 1] + mine[x][y - 1] + mine[x + 1][y - 1] + mine[x - 1][y] + mine[x + 1][y] + mine[x - 1][y + 1] + mine[x][y + 1] + mine[x + 1][y + 1] - 8 * '0'); 
}
 
//排雷：
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{
	printf("请输入您想要排查的坐标：\n");
	int x = 0;
	int y = 0;
	int win = 0;
	while (win < (row * col - EASY_COUNT))
	{
		printf("您想排查哪一行：");
		scanf("%d", &x);
		if (x >= 1 && x <= row)
		{
			while (1)
			{
				printf("您想排查哪一列：");
				scanf("%d", &y);
				if (y >= 1 && y <= col)
				{
					if (show[x][y] != '*')
					{
						printf("该坐标已被排查过！\n");
						DisplayBoard(show, ROW, COL);
						break;
					}
					if (mine[x][y] == '1')
					{
						DisplayBoard(mine, ROW, COL);
						printf("很遗憾，您死了！\n");
						win = row * col - EASY_COUNT + 1;
						break;
					}
					else
					{
						int n = get_mine_count(mine, x, y);
						show[x][y] = n + '0';
						DisplayBoard(show, ROW, COL);
						win++;
						break;
					}
				}
				else
				{
					printf("您输入的列数有误，请重新输入！\n");
				}
			}
		}
		else
		{
			printf("您输入的行数有误，请重新输入！\n");
		}
	}
	if (win == (row * col - EASY_COUNT))
	{
		printf("恭喜您排雷成功，获得胜利！\n");
		DisplayBoard(mine, ROW, COL);
	}
}
```
3.test.c：
```
#define _CRT_SECURE_NO_WARNINGS 1
 
#include"game.h"
 
//游戏逻辑：
void game()
{
	char mine[ROWS][COLS] = { 0 };
	//存放布置的雷的信息
	char show[ROWS][COLS] = { 0 };
	//存放查出的雷的信息
	//初始化棋盘
	InitBoard(mine, ROWS, COLS, '0');
	InitBoard(show, ROWS, COLS, '*');
	//打印棋盘
	DisplayBoard(show, ROW, COL);
	//布置雷
	SetMine(mine, ROW, COL);
	//扫雷
	FindMine(mine, show, ROW, COL);
}
 
void test()
{
	srand((unsigned int)time(NULL));
	int input = 0;
	do
	{
		menu();
		printf("请选择：");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			game();
			break;
		case 0:
			printf("退出游戏...\n");
			break;
		default:
			printf("输入错误，请重新选择！\n");
			break;
		}
	} while (input);
}
 
int main()
{
	test();
 
	return 0;
}
```
四、总结：

以上就是基础版扫雷游戏的各项功能实现了，但是它也和之前我们写的井字棋游戏一样，存在着很多的缺陷，例如它并不能像我们电脑里的扫雷游戏一样，选择一个坐标会打开一片，还有同样存在着界面不够美观的问题。而诸如此类这些问题我们在下文中将会一一进行处理。

以上就是今天我为大家介绍的基础版扫雷的知识啦！既然我已经踏上这条道路，那么，任何东西都不应妨碍我沿着这条路走下去！

新人初来乍到，辛苦各位小伙伴们动动小手，三连走一走 ~ ~ ~ 最后，本文仍有许多不足之处，欢迎各位看官老爷随时私信批评指正！
相关阅读:
Swift学习内容精选（一）
Web基础与HTTP协议
 FFmpeg介绍
 动态规划进阶——LeetCode53. 最大子数组的和
 spring5（二）：IOC容器概述
 git的使用场景
 JVS三方登录配置说明（钉钉扫码登录介绍）
uniapp跳转方式
 vscode怎么拷贝插件到另一台电脑
 第二周学习报告
原文地址：https://blog.csdn.net/weixin_59392935/article/details/127950075

前言：

一、文件建立：

1.头文件game.h：

2.函数定义文件game.c：

3.工程测试文件test.c：

二、编写井字棋游戏：

1.程序整体执行思路：

2.menu菜单：

3.game游戏函数逻辑：

4.game函数中各项功能的实现：

①.头文件game.h内容：

②.棋盘的初始化InitBoard：

③.打印棋盘DisplayBoard：

④.布置“地雷”SetMine：

⑤.统计雷get_mine_count：

⑥.排雷FindMine：

三、完整程序代码：

1.gam.h：

2.game.c：

3.test.c：

四、总结：