C语言 - 你一定能看懂的扫雷万字详解（加入了递归展开和手动标雷的功能）

最新推荐文章于 2024-08-19 01:37:08 发布
最新推荐文章于 2024-08-19 01:37:08 发布
阅读量2.1k 收藏 6
点赞数 10
文章标签： c语言 c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_72940975/article/details/127468381
版权

C语言之扫雷详解（包含递归展开和手动标雷功能，非常强大！）

文章目录

一.写在前面

🐶1.扫雷是windows的一款经典益智小游戏，我们在学习编程的时候尝试制作扫雷游戏，不能能激发我们学习编程的兴趣，更能提高我们的编程能力，所以自己尝试着去制作一个扫雷游戏是很有意义的。
🐭2.代码中我采用我使用两个数组，一个数组用来记录某个位置是否有雷（MyBoard数组），另一个数组用来记录这个位置周围有多少雷（NumBoard数组）。
🐹3.代码中我采用了宏定义，将ROW和COL定义为 9 ，将ROW和COL定义为ROW+2和COL+2，不仅易于理解，更便于修改。
🐰4.代码中我加入了清屏函数，在每次打印棋盘之前进行清屏，使得输出更加清爽。
🐺5.另外，我加入了递归展开功能，如果一个坐标周围都没有雷，那么会进入递归，会将这个坐标周围的坐标的周围的雷的数量都会显示出来（就是那个点一下出现一大片的功能）。
🐸6.我还加入手动标雷功能，在已经确定某个坐标处一定有雷后，可以对这个坐标进行标记，使得游戏更加方便。
🐯7.在代码中我加入了大量的注释，这可能使得代码看起来有点长，但是便于理解。

二.效果展示

🔆 游戏菜单
在这里插入图片描述

🔆棋盘展示
在这里插入图片描述

🔆 开始下棋
在这里插入图片描述

三.整体逻辑

1.打印菜单
2.玩家选择
3.定义两个棋盘并对棋盘的元素赋值
4.玩家下棋
5.游戏结束

游戏整体逻辑在game函数中实现，game函数代码如下：

void game()
{
	// 进入游戏，定义棋盘数组
	// 这里需定义两个棋盘数组
	// 一个棋盘是为了显示这个位置有没有雷，另外一个棋盘是为了显示这个位置周围的雷数
	// 每个棋盘的数组大小都要是行和列的数目加2，防止排查周围雷的数量时出现越界现象
	
	// 这个棋盘数组是为了标记这个位置是否有雷，无雷为0，有雷为1
	char MyBoard[ROWS][COLS] = { 0 };   

	// 这个棋盘数组是为了显示这个位置周围有多少雷
	char NumBoard[ROWS][COLS]= { 0 };  

	// 在定义棋盘之后，我们就要对两个数组棋盘的元素进行赋值
	InitBoard(MyBoard, NumBoard, ROW, COL);

	// 在赋值之后，展示棋盘
	DisplayBoard(NumBoard, ROW, COL);

	// 在初始化且展示之后，我们就要开始布雷了
	SetBoard(MyBoard, ROW, COL);

	// 开始扫雷
	Find(MyBoard, NumBoard, ROW, COL);
}

四.详解

1.进入主函数，打印菜单，玩家作出选择

进入主函数后首先打印游戏菜单，用do while语句模拟选择功能。
如果玩家选择 1 ，游戏开始。
如果玩家选择 0 ，游戏结束。
如果玩家输入了其他数字，系统提醒玩家重新输入。
代码如下：

int main()
{
	// 打印游戏菜单，指导玩家作出选择
	menu();
	
	// 利用do while语句模拟玩家的选择
	// 玩家选择 1 进入游戏，游戏结束后跳出循环
	// 玩家选择 0 直接退出循环，表示结束游戏
	// 玩家若选择其他，提醒玩家重新输入
	int input = 0;
	do
	{
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			game();
			break;
		case 0:
			break;
		default:
			printf("输入错误，请重新输入\n");
			break;
		}
	} while (input != 0 && input != 1);
}

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

2.定义棋盘的数组并进行赋值

进入游戏后，为了方便写代码，这里我们需要用到两个数组，并且数组的大小都为11 * 11（以9 * 9的棋盘为例）。
用到两个数组的原因：
我们既要用数组标记某个位置是否有雷，又要用数组记录这个位置周围有多少雷，用一个数组实现的话不太方便，我们最好使用两个数组
数组的大小都为11 * 11的原因：
后期我们为了统计某个位置周围雷的数量，需要遍历这个位置周围的八个位置的雷的情况，如果是9*9的数组的话，在边界时，遍历某个坐标周围的雷的情况，会出现数组越界现象。为了防止数组越界，我们使用的数组大小都要为11 * 11。
代码如下：

	// 进入游戏，定义棋盘数组
	// 这里需定义两个棋盘数组
	// 一个棋盘是为了显示这个位置有没有雷，另外一个棋盘是为了显示这个位置周围的雷数
	// 每个棋盘的数组大小都要是行和列的数目加2，防止排查周围雷的数量时出现越界现象
	
	// 这个棋盘数组是为了标记这个位置是否有雷，无雷为0，有雷为1
	char MyBoard[ROWS][COLS] = { 0 };   

	// 这个棋盘数组是为了显示这个位置周围有多少雷
	char NumBoard[ROWS][COLS]= { 0 };  

	// 在定义棋盘之后，我们就要对两个数组棋盘的元素进行赋值
	InitBoard(MyBoard, NumBoard, ROW, COL);

void InitBoard(char MyBoard[ROWS][COLS], char NumBoard[ROWS][COLS], int row, int col)
{
	// 玩家进入游戏后看不到周围雷的数量，只是看到了坐标
	// 我们规定玩家看到的坐标为星号

	int i = 0;
	int j = 0;

	// 对NumBoard棋盘数组的元素进行赋值
	for (i = 1; i <= row; i++)
	{
		for (j = 1; j <= col; j++)
		{
			MyBoard[i][j] = '0';
		}
	}

	// 对NumBoard棋盘数组的元素进行赋值
	for (i = 1; i <= row; i++)
	{
		for (j = 1; j <= col; j++)
		{
			NumBoard[i][j] = '*';
		}
	}
}

3.棋盘的展示

在定义和打印棋盘之后，我们就要将棋盘展示给玩家看。
为了使得棋盘看起来不那么枯燥，我们也有必要添加一些其他的元素到棋盘中。
棋盘展示的代码如下：

void DisplayBoard(char NumBoard[ROWS][COLS], int row, int col)
{
	// 便于实现后期的标记的标记功能，我们把每行每列都打印上序号
	// 为了使游戏看起来更加清爽，我们在代码中加入清屏函数
	system("cls");
	int i = 0;
	int j = 0;
	// ---|---|---|---
	printf("   |");
	for (i = 1; i <= row; i++)
	{
		printf(" %d |", i);
	}
	printf("\n");
	for (i = 1; i <= row; i++)
	{
		for (j = 0; j <= 9; j++)
		{
			printf("---|");
		}
		printf("\n");
		printf(" %d |", i);
		for (j = 1; j <= col; j++)
		{
			printf(" %c |", NumBoard[i][j]);
		}
		printf("\n");
	}
	for (j = 0; j <= 9; j++)
	{
		printf("---|");
	}
	printf("\n");
}

实现之后的效果如如下；
在这里插入图片描述

4.随机布雷

展示棋盘之后，利用时间戳生成随机数来实现随机布雷的效果。
首先引用头文件：

#include <stdlib.h>
#include <time.h>

在布雷时我们用字符 0 表示无雷，用字符 1 表示有雷。
由于布雷时可能布到已有雷的位置上，造成布雷失败的效果。
所以我们在这里最好采用一个while循环，在布雷成功时跳出循环。在布雷失败时循环继续。
代码如下：

void SetBoard(char MyBoard[ROWS][COLS], int row, int col)
{
	// 我们规定，是几乘几的棋盘，就布几个雷
	// 这里利用时间戳生成随机数模拟随机布雷
	srand((unsigned int)time(NULL));
	int i = 0;
	for (i = 0; i < row; i++)
	{
		// 由于布雷可能失败，所以这里使用一个while循环
		// 在布雷成功时跳出循环，在布雷失败时循环结束
		while (1)
		{
			// 将随机数的范围变为 1 到 9
			int x = rand() % 9 + 1;
			int y = rand() % 9 + 1;
			// 在每次布雷前，都需检查这个位置是否有雷
			if (MyBoard[x][y] == '0')
			{
				MyBoard[x][y] = '1';
				break;
			}
		}
	}
}

5.开始扫雷

我们输入横坐标和纵坐标来表示要扫的坐标。
由于玩家输入的坐标可能不合法或者可能那个坐标已经被占用，且玩家需要多次重复输入坐标所以我们需要用一个 while循环来模拟玩家的重复选择，当所有雷扫完之后或者玩家踩到雷之后游戏结束。
1.如果玩家输入的横坐标和纵坐标都是一到九的数字，那么输入合法，此时如果这个位置有雷，那么跳出循环，游戏结束。如果这个位置没有雷，进入near函数显示这个坐标周围的雷的数量。
在扫雷开始前，我们定义一个全局变量 n ，在每次排雷时 n 都要加一表示排了一个位置，当 n 一直增加到72（以9*9的棋盘为例，9 * 9 - 9 = 72）时，循环结束，游戏胜利。

		if (x >= 1 && x <= 9 && y >= 1 && y <= 9)
		{
			if (NumBoard[x][y] != '*')
			{
				printf("这个位置已排过，请重新输入\n");
			}
			else
			{
				if (MyBoard[x][y] == '0')
				{
					// 说明这个位置没有雷，此时应该找出这个位置周围雷的数量
					// 定义一个函数来找这个位置周围雷的数量
					near(MyBoard, NumBoard, x, y);
					// 每次排雷之后，都展示一下棋盘给玩家看
					DisplayBoard(NumBoard, row, col);

					// 如果此时 n 已经大于或者等于72（81-9）则说明所有位置已经排完，游戏结束
					if (n >= 72)
					{
						printf("恭喜你，你赢了\n");
						break;
					}

				}
				else
				{
					// 游戏结束并打印棋盘（让玩家知道他是怎么死的）
					DisplayBoard(MyBoard, row, col);
					printf("游戏结束，你输了\n");
					break;
				}
			}
		}

在near函数中，我们遍历这个坐标周围的八个坐标，以此来统计这个坐标周围的雷的数量。并且在每次使用near函数时，判断这个位置是否为 *，也就是是否还未排过，如果未排过，将 n 加一，如果排过，结束这个函数。

	// 判断在NumBoard函数中该位置是否为'*'，若是则++
	if (NumBoard[x][y] == '*')
	{
		n++;
	}
	else
	{
		return;
	}
	// 查看这个位置周围的八个位置有几个雷
	int num = 0;
	int i = 0;
	int j = 0;
	for (i = -1; i <= 1; i++)
	{
		for (j = -1; j <= 1; j++)
		{
			if (MyBoard[x + i][y + j] == '1')
			{
				num++;
			}
		}
	}
	// 查找结束后，将NumBoard数组的相应位置的元素改变为雷的个数
	// 并且由于棋盘中打印的是字符，需要将数字转化为字符
	NumBoard[x][y] = num + '0';

递归展开的实现：
如果这个坐标周围雷的数量为零，那么再让玩家输入坐标一个一个去排那岂不是很麻烦？
为了方便玩家，如果这个坐标周围的雷数为零，我们便展开这个坐标周围的坐标。
在展开之后，如果又发现某个坐标周围雷数为零，那么继续展开。
也就是说，在near函数内部如果发现又符合某个条件，继续调用near函数，那么这就需要用到函数递归了。
代码如下：

	// 如果周围雷的数量为0的话，自动显示周围每个位置的周围的雷的数量
	// 采用了递归的方法
	if (num == 0)
	{
		for (i = -1; i <= 1; i++)
		{
			for (j = -1; j <= 1; j++)
			{
				near(MyBoard, NumBoard, x+i, y+j);
			}
		}
	}

near函数的整体代码如下：

void near(char MyBoard[ROWS][COLS], char NumBoard[ROWS][COLS], int x, int y)
{
	// 判断在NumBoard函数中该位置是否为'*'，若是则++
	if (NumBoard[x][y] == '*')
	{
		n++;
	}
	else
	{
		return;
	}
	// 查看这个位置周围的八个位置有几个雷
	int num = 0;
	int i = 0;
	int j = 0;
	for (i = -1; i <= 1; i++)
	{
		for (j = -1; j <= 1; j++)
		{
			if (MyBoard[x + i][y + j] == '1')
			{
				num++;
			}
		}
	}
	// 查找结束后，将NumBoard数组的相应位置的元素改变为雷的个数
	// 并且由于棋盘中打印的是字符，需要将数字转化为字符
	NumBoard[x][y] = num + '0';
	// 如果周围雷的数量为0的话，自动显示周围每个位置的周围的雷的数量
	// 采用了递归的方法
	if (num == 0)
	{
		for (i = -1; i <= 1; i++)
		{
			for (j = -1; j <= 1; j++)
			{
				near(MyBoard, NumBoard, x+i, y+j);
			}
		}
	}
}

手动标记功能的实现：
为了方便玩家进行游戏，我在代码中加入了标记功能，将确定有雷的地方标记为 #。
如何将玩家排雷和玩家标记进行区别？
若玩家输入的坐标是负数，则进行标记。
在标记时，也要区分这个位置是否以及被标记过。若未标记过，对这个位置进行标记。若已经标记过，取消标记。

手动标记功能的代码如下：

		else if (x >= -row && x <= -1 && y >= -col && y <= -1)
		{
			if (NumBoard[-x][-y] == '*')
			{
				NumBoard[-x][-y] = '#';
				DisplayBoard(NumBoard, row, col);
			}
			else if (NumBoard[-x][-y] == '#')
			{
				NumBoard[-x][-y] = '*';
				DisplayBoard(NumBoard, row, col);
			}
		}

排雷函数的整体代码如下：

void Find(char MyBoard[ROWS][COLS], char NumBoard[ROWS][COLS], int row, int col)
{
	int x = 0;
	int y = 0;
	// 使用while循环，如果点到雷或者游戏结束时跳出循环。如果未点到雷循环继续，玩家继续排雷
	while (1)
	{
		// 在输入完成后，判断玩家的输入是否合法
		// 若输入合法，跳出循环；若不合法，循环继续，并提醒玩家重新输入
		// 在这里加入标记功能，如果玩家输入负数则标记某个坐标。

		scanf("%d %d", &x, &y);

		if (x >= 1 && x <= 9 && y >= 1 && y <= 9)
		{
			if (NumBoard[x][y] != '*')
			{
				printf("这个位置已排过，请重新输入\n");
			}
			else
			{
				if (MyBoard[x][y] == '0')
				{
					// 说明这个位置没有雷，此时应该找出这个位置周围雷的数量
					// 定义一个函数来找这个位置周围雷的数量
					near(MyBoard, NumBoard, x, y);
					// 每次排雷之后，都展示一下棋盘给玩家看
					DisplayBoard(NumBoard, row, col);

					// 如果此时 n 已经大于或者等于72（81-9）则说明所有位置已经排完，游戏结束
					if (n >= 72)
					{
						printf("恭喜你，你赢了\n");
						break;
					}

				}
				else
				{
					// 游戏结束并打印棋盘（让玩家知道他是怎么死的）
					DisplayBoard(MyBoard, row, col);
					printf("游戏结束，你输了\n");
					break;
				}
			}
		}

		else if (x >= -row && x <= -1 && y >= -col && y <= -1)
		{
			if (NumBoard[-x][-y] == '*')
			{
				NumBoard[-x][-y] = '#';
				DisplayBoard(NumBoard, row, col);
			}
			else if (NumBoard[-x][-y] == '#')
			{
				NumBoard[-x][-y] = '*';
				DisplayBoard(NumBoard, row, col);
			}
		}

		else
		{
			printf("输入非法，请重新输入\n");
		}

	}
}

至此，扫雷游戏就制作完成了！
不管怎样，自己尝试还是最重要的，快去试着制作一个扫雷游戏吧！

游戏的整体代码如下：

#pragma warning (disable:6031)
#define _CRT_SECURE_NO_WARNINGS 1

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define ROW 9
#define COL 9

#define ROWS ROW+2
#define COLS COL+2

// 定义一个全局变量 n ，用来统计已排的位置的数目
// 在每次进入near函数后，判断在NumBoard函数中该位置是否为'*'，若是则++
int n = 0;

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

void InitBoard(char MyBoard[ROWS][COLS], char NumBoard[ROWS][COLS], int row, int col)
{
	// 玩家进入游戏后看不到周围雷的数量，只是看到了坐标
	// 我们规定玩家看到的坐标为星号

	int i = 0;
	int j = 0;

	// 对NumBoard棋盘数组的元素进行赋值
	for (i = 1; i <= row; i++)
	{
		for (j = 1; j <= col; j++)
		{
			MyBoard[i][j] = '0';
		}
	}

	// 对NumBoard棋盘数组的元素进行赋值
	for (i = 1; i <= row; i++)
	{
		for (j = 1; j <= col; j++)
		{
			NumBoard[i][j] = '*';
		}
	}
}

void DisplayBoard(char NumBoard[ROWS][COLS], int row, int col)
{
	// 便于实现后期的标记的标记功能，我们把每行每列都打印上序号
	// 为了使游戏看起来更加清爽，我们在代码中加入清屏函数
	system("cls");
	int i = 0;
	int j = 0;
	// ---|---|---|---
	printf("   |");
	for (i = 1; i <= row; i++)
	{
		printf(" %d |", i);
	}
	printf("\n");
	for (i = 1; i <= row; i++)
	{
		for (j = 0; j <= 9; j++)
		{
			printf("---|");
		}
		printf("\n");
		printf(" %d |", i);
		for (j = 1; j <= col; j++)
		{
			printf(" %c |", NumBoard[i][j]);
		}
		printf("\n");
	}
	for (j = 0; j <= 9; j++)
	{
		printf("---|");
	}
	printf("\n");
}

void SetBoard(char MyBoard[ROWS][COLS], int row, int col)
{
	// 我们规定，是几乘几的棋盘，就布几个雷
	// 这里利用时间戳生成随机数模拟随机布雷
	srand((unsigned int)time(NULL));
	int i = 0;
	for (i = 0; i < row; i++)
	{
		// 由于布雷可能失败，所以这里使用一个while循环
		// 在布雷成功时跳出循环，在布雷失败时循环结束
		while (1)
		{
			// 将随机数的范围变为 1 到 9
			int x = rand() % 9 + 1;
			int y = rand() % 9 + 1;
			// 在每次布雷前，都需检查这个位置是否有雷
			if (MyBoard[x][y] == '0')
			{
				MyBoard[x][y] = '1';
				break;
			}
		}
	}
}

void near(char MyBoard[ROWS][COLS], char NumBoard[ROWS][COLS], int x, int y)
{
	// 判断在NumBoard函数中该位置是否为'*'，若是则++
	if (NumBoard[x][y] == '*')
	{
		n++;
	}
	else
	{
		return;
	}
	// 查看这个位置周围的八个位置有几个雷
	int num = 0;
	int i = 0;
	int j = 0;
	for (i = -1; i <= 1; i++)
	{
		for (j = -1; j <= 1; j++)
		{
			if (MyBoard[x + i][y + j] == '1')
			{
				num++;
			}
		}
	}
	// 查找结束后，将NumBoard数组的相应位置的元素改变为雷的个数
	// 并且由于棋盘中打印的是字符，需要将数字转化为字符
	NumBoard[x][y] = num + '0';
	// 如果周围雷的数量为0的话，自动显示周围每个位置的周围的雷的数量
	// 采用了递归的方法
	if (num == 0)
	{
		for (i = -1; i <= 1; i++)
		{
			for (j = -1; j <= 1; j++)
			{
				near(MyBoard, NumBoard, x+i, y+j);
			}
		}
	}
}

void Find(char MyBoard[ROWS][COLS], char NumBoard[ROWS][COLS], int row, int col)
{
	int x = 0;
	int y = 0;
	// 使用while循环，如果点到雷或者游戏结束时跳出循环。如果未点到雷循环继续，玩家继续排雷
	while (1)
	{
		// 在输入完成后，判断玩家的输入是否合法
		// 若输入合法，跳出循环；若不合法，循环继续，并提醒玩家重新输入
		// 在这里加入标记功能，如果玩家输入负数则标记某个坐标。

		scanf("%d %d", &x, &y);

		if (x >= 1 && x <= 9 && y >= 1 && y <= 9)
		{
			if (NumBoard[x][y] != '*')
			{
				printf("这个位置已排过，请重新输入\n");
			}
			else
			{
				if (MyBoard[x][y] == '0')
				{
					// 说明这个位置没有雷，此时应该找出这个位置周围雷的数量
					// 定义一个函数来找这个位置周围雷的数量
					near(MyBoard, NumBoard, x, y);
					// 每次排雷之后，都展示一下棋盘给玩家看
					DisplayBoard(NumBoard, row, col);

					// 如果此时 n 已经大于或者等于72（81-9）则说明所有位置已经排完，游戏结束
					if (n >= 72)
					{
						printf("恭喜你，你赢了\n");
						break;
					}

				}
				else
				{
					// 游戏结束并打印棋盘（让玩家知道他是怎么死的）
					DisplayBoard(MyBoard, row, col);
					printf("游戏结束，你输了\n");
					break;
				}
			}
		}

		else if (x >= -row && x <= -1 && y >= -col && y <= -1)
		{
			if (NumBoard[-x][-y] == '*')
			{
				NumBoard[-x][-y] = '#';
				DisplayBoard(NumBoard, row, col);
			}
			else if (NumBoard[-x][-y] == '#')
			{
				NumBoard[-x][-y] = '*';
				DisplayBoard(NumBoard, row, col);
			}
		}

		else
		{
			printf("输入非法，请重新输入\n");
		}

	}
}

void game()
{
	// 进入游戏，定义棋盘数组
	// 这里需定义两个棋盘数组
	// 一个棋盘是为了显示这个位置有没有雷，另外一个棋盘是为了显示这个位置周围的雷数
	// 每个棋盘的数组大小都要是行和列的数目加2，防止排查周围雷的数量时出现越界现象
	
	// 这个棋盘数组是为了标记这个位置是否有雷，无雷为0，有雷为1
	char MyBoard[ROWS][COLS] = { 0 };   

	// 这个棋盘数组是为了显示这个位置周围有多少雷
	char NumBoard[ROWS][COLS]= { 0 };  

	// 在定义棋盘之后，我们就要对两个数组棋盘的元素进行赋值
	InitBoard(MyBoard, NumBoard, ROW, COL);

	// 在赋值之后，展示棋盘
	DisplayBoard(NumBoard, ROW, COL);

	// 在初始化且展示之后，我们就要开始布雷了
	SetBoard(MyBoard, ROW, COL);

	// 开始扫雷
	Find(MyBoard, NumBoard, ROW, COL);
}

int main()
{
	// 打印游戏菜单，指导玩家作出选择
	menu();
	
	// 利用do while语句模拟玩家的选择
	// 玩家选择 1 进入游戏，游戏结束后跳出循环
	// 玩家选择 0 直接退出循环，表示结束游戏
	// 玩家若选择其他，提醒玩家重新输入
	int input = 0;
	do
	{
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			game();
			break;
		case 0:
			break;
		default:
			printf("输入错误，请重新输入\n");
			break;
		}
	} while (input != 0 && input != 1);
}

五.递归展开和手动标记（注意到很多博主未提到这两个功能，所以我把这两个功能单独说一下，希望能帮助到你）

1.递归展开

如果这个坐标周围雷的数量为零，那么再让玩家输入坐标一个一个去排那岂不是很麻烦？
为了方便玩家，如果这个坐标周围的雷数为零，我们便展开这个坐标周围的坐标。
在展开之后，如果又发现某个坐标周围雷数为零，那么继续展开。
也就是说，在near函数内部如果发现又符合某个条件，继续调用near函数，那么这就需要用到函数递归了。
整个near函数代码如下：

void near(char MyBoard[ROWS][COLS], char NumBoard[ROWS][COLS], int x, int y)
{
	// 判断在NumBoard函数中该位置是否为'*'，若是则++
	if (NumBoard[x][y] == '*')
	{
		n++;
	}
	else
	{
		return;
	}
	// 查看这个位置周围的八个位置有几个雷
	int num = 0;
	int i = 0;
	int j = 0;
	for (i = -1; i <= 1; i++)
	{
		for (j = -1; j <= 1; j++)
		{
			if (MyBoard[x + i][y + j] == '1')
			{
				num++;
			}
		}
	}
	// 查找结束后，将NumBoard数组的相应位置的元素改变为雷的个数
	// 并且由于棋盘中打印的是字符，需要将数字转化为字符
	NumBoard[x][y] = num + '0';
	// 如果周围雷的数量为0的话，自动显示周围每个位置的周围的雷的数量
	// 采用了递归的方法
	if (num == 0)
	{
		for (i = -1; i <= 1; i++)
		{
			for (j = -1; j <= 1; j++)
			{
				near(MyBoard, NumBoard, x+i, y+j);
			}
		}
	}
}

2.手动标记

为了方便玩家进行游戏，我在代码中加入了标记功能，将确定有雷的地方标记为 #。
如何将玩家排雷和玩家标记进行区别？
若玩家输入的坐标是负数，则进行标记。
在标记时，也要区分这个位置是否以及被标记过。若未标记过，对这个位置进行标记。若已经标记过，取消标记。

手动标记功能的代码如下：

		else if (x >= -row && x <= -1 && y >= -col && y <= -1)
		{
			if (NumBoard[-x][-y] == '*')
			{
				NumBoard[-x][-y] = '#';
				DisplayBoard(NumBoard, row, col);
			}
			else if (NumBoard[-x][-y] == '#')
			{
				NumBoard[-x][-y] = '*';
				DisplayBoard(NumBoard, row, col);
			}
		}
m0_72940975
关注
C语言——扫雷游戏实现（超详解）
2301_80004913的博客
11-08 7573
扫雷游戏想必大家应该都玩过吧，这个游戏的目标呢就是在一个 9x9 的棋盘上找出所有没有地雷的格子，而不踩到地雷。当然这个9×9只是一个初级玩法，棋盘大小和雷的数量是可以随便设置的，有那种电脑满屏的模式，但是我没去尝试过，一般玩的都是初级9×9的模式，而本篇文章也主要说的是9×9扫雷游戏的实现。扫雷游戏网页版 - Minesweeper。
C语言扫雷
yanghang666666的博客
09-06 115
C语言扫雷详解编码的大致思路头文件（扫雷game.h）（在这里调整变量大小可以调整雷的数量和棋盘的大小）源文件（扫雷game.c）主文件（1.c）说明：我想谈一下在game.c文件中递归函数的创作过程。 编码的大致思路 宏观思路：解读，一个二维数组对应一个棋盘，有两个棋盘（一个为玩家棋盘show[ROWS][COLS]，一个为后台操作棋盘char mine[ROWS][COLS]），先去填这个棋盘（初始化，后台棋盘初始字符’0’,方便后续字符相减计算），打印玩家棋盘，写打印函数（1.通用性，本质上就是变化实
扫雷(C语言)
03-22
用C加上windows的easyx的图形库编写的一个扫雷游戏。
C语言——扫雷
yl_sakura的博客
10-26 7451
扫雷大家应该都应该玩过，这是电脑上一个十分经典的游戏，今天我将给大家讲解如何用C语言来实现扫雷，这个扫雷有如下几个功能： 1.第一次下子，不炸死。 2.坐标周围没雷，可以实现展开。 3.显示该点周围雷的个数。 我们就需要用二维数组来打印棋盘，假如我们要打印10X10的棋盘，那我们的二维数组元素也要为10X10个吗？，不能，因为我们在设计算法时需要统计坐标周围8个方位雷的个数，假如要统计边界坐标周围...
扫雷基础与进阶（全面解析）
最新发布
2301_80030290的博客
08-19 1500
对于基础版扫雷，你需要掌握的知识有：循环与分支、函数基础、二维数组以及随机数函数。对于进阶版扫雷，你还得了解函数递归调用的思想。
扫雷游戏(c语言)
一氧化二氢的执着
04-07 1293
扫雷游戏(c语言) #define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <time.h> #define ROW 9 #define COL 9 #define MAX_MINE 10 void Init(char show_map[ROW][COL], char mine_map[ROW][COL]) ...
C语言基础：扫雷游戏的C语言实现（超详图解+源码）
linsc_05的博客
08-01 6670
友友们好，今天和大家一起做一个简单的——扫雷小游戏。如下：扫雷的规则很简单。盘面上有许多方格，方格中随机分布着一些雷。你的目标是避开雷，打开其他所有格子。一个非雷格中的数字表示其相邻8格中的雷数，你可以利用这个信息推导出安全格和雷的位置。打开所有安全格将被判定为胜利，打开雷将被判定为失败。
C语言扫雷游戏的实现代码
12-20
《C语言实现扫雷游戏详解》 扫雷游戏是一款经典的逻辑推理游戏，它以其简洁的界面和富有挑战性的玩法深受玩家喜爱。本文将详细介绍如何使用C语言在控制台上实现一个扫雷游戏，涵盖随机布雷、扫描、标记及判断游戏...
【C语言】从扫雷玩家到开发者
hi，这里是Ying_526_，欢迎关注
10-18 6047
相信大家都玩过扫雷吧，这里简单介绍一下扫雷的规则：点击某个位置，如果这个位置有雷，玩家就会被炸，展示雷盘中所有雷的位置，游戏结束，如果这个位置没有雷，且以这个位置为中心的九宫格也没有雷，则这个位置被翻开，若以这个位置为中心的九宫格有雷，则统计以这个位置为中心的九宫格中雷的个数，并且显示在九宫格的中心位置，点开所有非雷位置则游戏胜利，在途中点到雷则游戏失败。创建二位数组开辟地图（默认10*10）初始化为0使用随机数给地图布置雷场默认10颗雷（-1为雷）对用户操作进行响应。
详细解析C语言实现扫雷游戏（VS2019）
m0_67683346的博客
04-04 4870
详细解析C语言实现扫雷游戏
c语言 扫雷
07-12
C语言 扫雷 主要特色： 1.彩色界面 2.方向键控制方向，Enter键确认 3.支持多用户登录，存储每个用户的游戏记录，支持用户注册 4.可标记雷区
C语言版扫雷
02-02
扫雷完整代码，玩家第一下不会被炸死，可以选择难度。
扫雷-c语言
04-04
一个用c语言图形库写的扫雷小游戏，当时做的课程设计，供学习交流使用
C语言-扫雷
主营前端方向，技术栈是vue
01-09 1460
C语言-递归实现完整扫雷
《数据结构C语言版》- 后序遍历递归算法详解
"《后序遍历的递归算法-数据结构c语言版严蔚敏》探讨了数据结构中的一个重要概念——后序遍历，并提供了C语言实现的递归算法。该算法适用于二叉树的遍历，以访问根结点、左子树和右子树的顺序进行。在描述中提到了一...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

m0_72940975

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值