C语言实现扫雷教学

本篇博客会讲解，如何使用C语言实现扫雷小游戏。

0.思路及准备工作

1. 使用2个二维数组mine和show，分别来存储雷的位置信息和排查出来的雷的信息，前者隐藏，后者展示给玩家。假设盘面大小是9×9，这2个二维数组都要开大一圈，也就是大小是11×11，这是为了更加方便的数边角上雷的个数，防止越界。
2. mine数组中用字符1表示雷，字符0表示非雷。show数组中用*表示该位置没有被排查过，数字字符表示周围一圈（8个位置）有几个雷，空格表示周围一圈没有雷。
3. 如果玩家排查的位置是雷，那么，游戏失败。当玩家把所有非雷的位置找出来后，扫雷成功。

先定义一些符号，后面会用。

// 有效盘面大小
#define ROW 9
#define COL 9
// 实际数组会开大一圈
#define ROWS  (ROW + 2)
#define COLS  (COL + 2)

#define MINE_COUNT 10

2个数组分别是：

char mine[ROWS][COLS] = { 0 };
char show[ROWS][COLS] = { 0 };

1.初始化

我们分别把mine和show数组初始化成全字符0和全*。可以利用二维数组在内存中连续存放的特点，使用memset函数来设置内存中的值。

void InitBoard(char board[ROWS][COLS], int rows, int cols, char set)
{
	memset(&board[0][0], set, rows * cols);
}

2.打印盘面

打印时使用2层循环来遍历二维数组，同时把行标和列标都打印出来。注意打印时，只需打印中间的9×9的位置，为了区分，我用rows和cols来表示多了一圈后的行和列，用row和col表示有效的盘面大小。

void DisplayBoard(char board[ROWS][COLS], int row, int col)
{
	printf("********* 扫雷 *********\n");

	// 列标
	for (int j = 0; j <= row; ++j)
	{
		printf("%d ", j);
	}
	printf("\n");

	for (int i = 1; i <= row; ++i)
	{
		// 行标
		printf("%d ", i);

		for (int j = 1; j <= col; ++j)
		{
			printf("%c ", board[i][j]);
		}
		printf("\n");
	}
}

打印效果：

3.设置雷

可以使用rand函数随机生成10个雷，注意如果该位置已经生成雷，就重新再生成坐标，不能重复。

void SetMine(char mine[ROWS][COLS], int row, int col)
{
	int count = 0; // 已放置的雷的个数
	while (count < MINE_COUNT)
	{
		int x = rand() % row + 1;
		int y = rand() % row + 1;
		if (mine[x][y] == '0')
		{
			mine[x][y] = '1';
			++count;
		}
	}
}

4.排查雷

排查雷的逻辑就相对复杂点了，这里我分以下几点来叙述。

1. 使用GetMineCount函数来获取周围8个位置雷的个数。只需要使用2层循环遍历周围3×3的位置，如果不是x, y本身，并且是雷，就统计进个数。
2. 使用ExpandMine函数来递归展开。展开的思路是正常的前序遍历（因为好想），如果该位置没有越界、自己不是雷、周围没有雷、且没有被排查过，则递归展开上下左右。
3. 为了防止玩家第一次就踩到雷，从而对自己的运气产生一定的怀疑，使用FirstTimeNotMine函数来确保第一次排查的位置不是雷。方法很简单，如果该位置是雷，就随机找一个不是雷的位置，把2个位置交换即可。
4. 使用IsWin函数来判断玩家是否扫雷成功。具体的思路是，判断已经排查过的位置总数是否超过非雷的位置总数，如果把所有非雷的位置都找出来，则扫雷成功。
5. 玩家输入排查的坐标后，需要分别检查是否合法、该位置是否被排查过、该位置是不是雷，如果检查过后不是雷，再进行正常的递归展开等。

// 获取周围雷的个数（不包括x, y自己）
static int GetMineCount(char mine[ROWS][COLS], int x, int y)
{
	int count = 0;
	for (int i = x - 1; i <= x + 1; ++i)
	{
		for (int j = y - 1; j <= y + 1; ++j)
		{
			if ((i != x || j != y) && mine[i][j] == '1')
			{
				++count;
			}
		}
	}
	return count;
}

// 递归展开
static void ExpandMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col, int x, int y)
{
	if (x <= 0 || x > row || y <= 0 || y > col)
	{
		return;
	}

	// 未被排查
	if (show[x][y] != '*')
	{
		return;
	}

	int count = GetMineCount(mine, x, y);
	if (count > 0)
	{
		show[x][y] = '0' + count;
		return;
	}
	else
	{
		show[x][y] = ' ';
	}

	ExpandMine(mine, show, row, col, x - 1, y); // 上
	ExpandMine(mine, show, row, col, x + 1, y); // 下
	ExpandMine(mine, show, row, col, x, y - 1); // 左
	ExpandMine(mine, show, row, col, x, y + 1); // 右
}

static bool IsWin(char show[ROWS][COLS], int row, int col)
{
	// 统计已被排查的位置个数
	int count = 0;
	for (int i = 1; i <= row; ++i)
	{
		for (int j = 1; j <= col; ++j)
		{
			if (show[i][j] != '*')
			{
				++count;
			}
		}
	}

	return count >= ROW * COL - MINE_COUNT;
}

static void FirstTimeNotMine(char mine[ROWS][COLS], int row, int col, int x, int y)
{
	// 把雷和随机非雷位置交换
	while (1)
	{
		int newx = rand() % row + 1;
		int newy = rand() % col + 1;
		if (mine[newx][newy] == '0')
		{
			mine[x][y] = '0';
			mine[newx][newy] = '1';
			break;
		}
	}
}

void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{
	int x = 0;
	int y = 0;
	bool firstTime = true; // 第一次排查
	while (1)
	{
		printf("请输入坐标:>");
		scanf("%d %d", &x, &y);

		if (x < 1 || x > row || y < 1 || y > col)
		{
			printf("坐标非法，请重新输入！\n");
		}
		else if (show[x][y] != '*')
		{
			printf("该坐标已被排查过！\n");
		}
		else if (!firstTime && mine[x][y] == '1')
		{
			printf("你踩到雷了，游戏失败！\n");
			DisplayBoard(mine, row, col);
			break;
		}
		else
		{
			// 防止第一次排查就踩到雷
			if (firstTime && mine[x][y] == '1')
			{
				FirstTimeNotMine(mine, row, col, x, y);
				firstTime = false;
			}

			ExpandMine(mine, show, row, col, x, y);
			DisplayBoard(show, row, col);
			if (IsWin(show, row, col))
			{
				printf("恭喜你，扫雷成功！\n");
				DisplayBoard(mine, row, col);
				break;
			}
		}
	}
}

5.测试

void Menu()
{
	printf("****************************\n");
	printf("******* 1. play      *******\n");
	printf("******* 0. exit      *******\n");
	printf("****************************\n");
}

void Game()
{
	char mine[ROWS][COLS] = { 0 }; // 雷
	char show[ROWS][COLS] = { 0 }; // 展示给玩家

	InitBoard(mine, ROWS, COLS, '0');
	InitBoard(show, ROWS, COLS, '*');

	SetMine(mine, ROW, COL);
	DisplayBoard(show, 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;
}

总结

1. 扫雷小游戏的实现，需要2个二维数组，需要了解二维数组的相关知识，比如在内存中的存储方式。
2. 初始化盘面，利用二维数组在内存中连续存放的特点，使用memset一步到位。
3. 打印盘面以及后面的一部分逻辑，遍历二维数组时使用2层for循环，是一个常见的思路。
4. 设置雷的位置采用随机生成的方式，需要了解C语言如何生成随机数的知识点，我之前写过一篇博客讲解过。
5. 排查雷时，需要通过反复的判断语句，防止玩家输入的坐标不满足需求。
6. 尤其需要重点理解递归的思路，递归有限制条件，如该位置不是雷、周围没有雷、该位置没有越界、该位置没有被排查过等，同时不断趋近于限制条件，递归上下左右时一定会接近边界。
7. 动手写！

感谢大家的阅读！