用简单的c程序编写的扫雷！

1.规则

相信大家都听说过扫雷这个游戏
它的规则很简单
设定好地雷数和棋盘大小，游戏开始
这里我们将棋盘设置为9*9，雷数设置为10

雷区就布置好了
点击一个位置就会排查对应的位置
如果出现了数字，这些数字就表示周围的八个格子雷的个数
比如说这个数字一，表示周围八个格子有一个类，直接锁定了雷的位置。

如果你点到了雷，游戏结束。

如果你点的位置周围八个格子一个雷都没有，会自动帮你拓张
比如，这是第一次排查位置，周围没有雷，就会再帮你排查周围的八个格子，如果有坐标一样没有雷，就继续向外拓展，直到周围格子有雷。

当雷全部排完（也就是雷之外的格子被排空），游戏胜利。

知道了扫雷的基础的规则，我们就根据规则写出相应的代码模块。

2.代码

（1）基础部分

和三子棋一样，有基础的菜单和交互逻辑

void menu()
{
	printf("************************************\n");
	printf("********      1. play      *********\n");
	printf("********      0. exit      *********\n");
	printf("************************************\n");
}
void test()
{
	int input = 0;
	
	do
	{
		menu();
		scanf("%d", &input);
		system("cls");
		switch (input)
		{
		case 1:
			printf("开始游戏\n");
			game();
			break;
		case 0:
			printf("退出游戏\n");
			break;
		default:
			printf("输入错误，请重新输入\n");
			break;
		}
	} while (input);
}
int main()
{
	srand((unsigned int)time(NULL));
	test();
	return 0;
}

有游戏的运行模块，由函数组成

void game()
{
	char board[ROW + 2][COL + 2] = { '\0'};
	char mine[ROW + 2][COL + 2] = { '\0'};
	chushihua(ROW,COL,board,'*');
	chushihua(ROW, COL, mine,'0');
	setmine(ROW, COL, mine);
	//printmine(ROW, COL, mine);
	printboard(ROW, COL, board);
	move(ROW, COL, board,mine);
}

我们将棋盘数据，雷数作为宏定义常量储存。

#define MINE 10
#define ROW 9
#define COL 9

扫雷的雷区数据用二位数组来存储。
因为扫雷不仅需要展示用的棋盘用于玩家操作，也需要一个存放雷区的二维数组。
所以我们创建两个char类型的数组
一个用于展示给玩家让玩家操作，在展示的棋盘上用字符’*'表示未排查的区域，即board数组
一个用于储存雷的数据，即mine数组
在排查雷的时候，因为需要排查周围的八个格子，需要访问周围八个格子的数据。防止数组越界，我们创建数组时，在原本的棋盘上向外拓展一圈，也就是在原本的棋盘数据上加2。

char board[ROW + 2][COL + 2] = { '\0'};
char mine[ROW + 2][COL + 2] = { '\0'};

在创建好了棋盘之后，我们需要创建几个基本的模块

（2）初始化

对储存雷区和展示区的二维数组初始化

void chushihua(int row, int col, char board[ROW + 2][COL + 2],char set)
{
	int a = 0, b = 0;
	for (a = 0; a < row + 2; a++)
	{
		for (b = 0; b < col + 2; b++)
		{
			board[a][b] = set;
		}
	}
}

雷区和展示区的初始化方式是一样的
因此它们可以共用一个函数，通过改变函数参数来达到效果。

（3）布置雷区

利用随机数来进行布置
因为棋盘向外拓展了一圈，所以在去模之后加一

void setmine(int row, int col, char board[ROW + 2][COL + 2])
{
	int a = 0, b = 0,count=0;
	while (1)
	{	
		a = rand()%row+1;
		b = rand()%col+1;
		if (board[a][b] == '0')
		{
			board[a][b] = '1';
			count++;
		}
		if (count == MINE)
		{
			break;
		}
	}
}

打印棋盘
为了便于玩家进行定位，我们将坐标打印出来

void printboard(int row, int col, char board[ROW + 2][COL + 2])
{
	
	int a = 0;
	int b = 0;
	system("cls");
	printf("---------扫雷----------\n  ");
	for (a = 1; a <= col; a++)
	{
		printf("%d ", a);
	}
	printf("\n");
	for (a =1; a <= row; a++)
	{
		printf("%d", a);
		for (b = 1; b <= col; b++)
		{
			printf(" %c", board[a][b]);
		}
		printf("\n");
	}
	printf("---------扫雷----------\n");
	
}

同样原理，我们可以写一个打印雷区的函数，在代码运行的时候方便我们进行调试
（就是开透视）
在代码完成时删掉打印雷区的代码即可

（4）玩家排雷

之前我们说过，雷区之外的区域被排空即视为游戏胜利
我们定义一个变量win
每探出一个雷，win值便加一
那么游戏胜利的条件便是win值达到ROL*COL-MINE
用while循环来表示

while (win < (row * col - MINE))
{

}

接受玩家的坐标之后
我们要对坐标的合法性进行判断
如果发现坐标在雷区对应的元素是雷
说明玩家踩雷，将这个坐标位置改为字符’!'跳出循环，并打印结果

void move(int row, int col, char board[ROW + 2][COL + 2], char mine[ROW + 2][COL + 2])
{
	int x = 0;
	int y = 0;
	int win=0;
	int* pwin = &win;
	while (win < (row * col - MINE))
	{
		scanf("%d %d", &x, &y);
		if (x >= 1 && x <= row && y >= 1 && y <= col)
		{
			if (board[x][y] != '*')
			{
				printf("该坐标被排查过了\n");
				continue;
			}
			if (mine[x][y] == '1')
			{
				printf("很遗憾，你被炸死了\n");
				board[x][y] = '!';
				break;
			}
			else
			{
				
			}
		}
		else
		{
			printf("坐标非法，请重新输入");
		}
	}
}

如果坐标不是雷，说明这一步正确
进入函数pingpu进行是否拓展的判断
首先写一个函数，用于获得周围八个格子雷的个数。
因为棋盘的数据类型为char类型
减去八个字符0，便能得到周围雷的个数了（ASCII码的转换）。

int getminecount(char mine[ROW+2][COL+2], int x, int y)
{
	return (mine[x - 1][y] + mine[x - 1][y - 1] + mine[x][y - 1] +
		mine[x + 1][y - 1] + mine[x + 1][y] + mine[x + 1][y + 1] +
		mine[x][y + 1] + mine[x - 1][y + 1] - 8 * '0');
}

n接受了函数的返回值后，对棋盘对应位置进行赋值

int pingpu(int x, int y, char board[ROW + 2][COL + 2], char mine[ROW + 2][COL + 2])
{
	int j = 0;
	int n = getminecount(mine, x, y);
	board[x][y] = n + '0';
}

如果周围八个格子有雷，则显示数字
如果没有雷，则显示数字并进行拓张。
接收函数的返回值，对坐标进行赋值
如果周围没有雷，该怎么进行拓张呢？
首先用循环寻找周围八个格子（其实是九个格子，包括了自身，但在后面的判断条件中被筛除）

for (int a = x - 1; a <= x+1; a++)
	{
		for (int b = y - 1; b <= y+1; b++)
		{
		}
	}

为了防止数组越界，要对坐标进行限制

if ((a > 0) && (a <= ROW) && (b > 0) && (b <= COL))
{
}

同时，防止在递归的时候排查到的坐标是雷
或者递归的时候重复对一个坐标进行排查
我们对递归设置条件

if((board[a][b] == '*') && (mine[a][b] != '1'))
{
}

条件都满足的话，就进行递归，将得到的坐标作为参数

pingpu(a, b, board, mine);

如何记录排查坐标的个数来判断胜负？
我们用变量j来接受变量的值
同时将j+1作为返回值
这样的话每次函数被调用一次，j的值便加一，
递归完成后返回的值便是排查的坐标的个数
同样，在递归的时候，我们也将递归过程中函数产生的返回值累加起来
综合起来

int pingpu(int x, int y, char board[ROW + 2][COL + 2], char mine[ROW + 2][COL + 2])
{
	int j = 0;
	int n = getminecount(mine, x, y);
	board[x][y] = n + '0';
	if (board[x][y] == '0')
	{
		for (int a = x - 1; a <= x+1; a++)
		{
			for (int b = y - 1; b <= y+1; b++)
			{
				if ((a > 0) && (a <= ROW) && (b > 0) && (b <= COL))
				{
					if((board[a][b] == '*') && (mine[a][b] != '1'))
					{
					j += pingpu(a, b, board, mine);
					}
				}
			}
		}
	}
	return j + 1;
}

同样函数pingpu的返回值也需要有人接收
在函数move中
else内的语句用win接受pingpu的返回值。
其中的x，y参数来自函数move

else
{
	win+=pingpu(x, y, board, mine);
	printboard(ROW, COL,board);
}

让我们把这些元素组合到一起

成功！

下一篇，部分操作符讲解
客官点个赞再走呗