扫雷

test.c - 扫雷游戏的测试

game.c - 游戏函数的实现

game.h - 游戏函数的声明

首先讲一讲我们整体的思路框架，我们设计这个游戏，让玩家想玩的时候可以一直玩，所以我们采用do…while循环语句，然后打印菜单，写一个菜单函数，让玩家进行选择，这里我们采用switch分支语句，当我们选择1时进入游戏，此时需要写一个游戏函数，选择0时退出游戏，选择其他时，告诉他选择错误，重新输入，我们发现当选择1和选择错误时我们需要循环继续，退出游戏是我们退出循环的时候，所以我们将while()里的循环条件设置成玩家输入的选择。

int main()
{
	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);
	return 0;
}

我们先来看一下成品展示吧

首先我们在选择玩游戏后，会让你选择简单、普通、困难的三种游戏模式，简单我们设置10个雷，普通我们设置20个雷，困难我们设置30个雷。

然后打印棋盘，让玩家输入排查的坐标，如果没有被炸死，那就让玩家选择是否需要标记雷。

假设我们推理出（1，2）坐标是雷，我们就可以进行标记雷，输入雷的坐标，就会标记雷，标记雷的符号设定为’#’。

如果不进行标记雷，则继续排查。

这就是我们基本游戏的进行流程。

下面我们来设计这个游戏。

首先我们需要有这么一个棋盘来存储数据

我们设定是雷在里面存放1，不是雷我们存放0，我们在排雷时，当这个坐标不是雷时，就显示他周围有几个雷，但是这时问题来了，当这个坐标不是雷，他周围有一个雷时，就会显示1，那么这个1代表的是雷呢还是周围的雷数呢，这时就矛盾了，所以我们用两个数组来存储，一个mine数组来存放雷，一个show数组存放排查出的雷的信息。show数组是展示给玩家看的，mine数组则不能打印。

当这个坐标不是雷时，我们统计他周围的雷数，那么问题来了，边角的怎么统计呢，如果按其他正常的访问，那我们数组会越界访问，怎么解决这个问题呢？

我们需要在外面加一圈就可以了

所以我们在创建数组的时候，创建两个11*11的数组。这样做玩家在输入要排雷的坐标时，刚好就是我们数组的下标位置。

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

我们定义两个行，两个列，我们在使用是只使用里面9*9的数组，初始化数组时都初始化。

1、棋盘初始化

我们该进行对两个数组初始化，为了美观，我们将show数组初始化为字符’*’，所以我们使用字符数组，将mine数组初始化为字符’0’。在初始化棋盘时，我们需要将里面的11行11列全部都初始化，所以传入的是ROWS,COLS。

void InitBoard(char board[ROWS][COLS], int rows, int cols, char set)
{
	int i = 0;
	int j = 0;
	for (i = 0; i < rows; i++)
	{
		for (j = 0; j < cols; j++)
		{
			board[i][j] = set;
		}
	}
}

2、棋盘的打印

我们为了美观，方便玩家进行坐标的输入，将行号和列号打印出来，在打印棋盘时，我们只需要将里面的9*9打印出来，所以传入的是ROW,COL。

void DisplayBoard(char board[ROWS][COLS], int row, int col)
{
	int i = 0;
	int j = 0;
	//列号的打印
	for (i = 0; i <= col; i++)
	{
		printf("%d ", i);
	}
	printf("\n");
	for (i = 1; i <= row; i++)
	{
		//每一行前面的行号
		printf("%d ", i);
		for (j = 1; j <= col; j++)
		{
			printf("%c ", board[i][j]);
		}
		printf("\n");
	}
}

3、难度的选择（选择函数里面又需要实现布置雷和扫雷）

#define EASY_COUNT 10
#define COMMON_COUNT 20
#define HARD_COUNT 30

定义三个难度的常量。

在开头我们说了，我们还要让玩家进行难度的选择，难度选择的整体框架如下:

void menu1()
{
	printf("*********************************\n");
	printf("******    1.EASY_COUNT     ******\n");
	printf("******    2.COMMON_COUNT   ******\n");
	printf("******    3.HARD_COUNT     ******\n");
}

void Choose(char mine[ROWS][COLS], char show[ROWS][COLS])
{
	int count = 0;
	menu1();
	scanf("%d", &count);
	do
	{
		switch (count)
		{
		case 1:
			//1.布置雷 - 数据的存储--->9*9二维数组
			SetMine(mine, ROW, COL, EASY_COUNT);//我们布置雷只给里面的9*9布置，所以传9*9就可以了
			DisplayBoard(show, ROW, COL);
			//2.扫雷
			FindMine(mine, show, ROW, COL, EASY_COUNT);
			break;
		case 2:
			//1.布置雷 - 数据的存储--->9*9二维数组
			SetMine(mine, ROW, COL, COMMON_COUNT);//我们布置雷只给里面的9*9布置，所以传9*9就可以了
			DisplayBoard(show, ROW, COL);
			//2.扫雷
			FindMine(mine, show, ROW, COL, COMMON_COUNT);
			break;
		case 3:
			//1.布置雷 - 数据的存储--->9*9二维数组
			SetMine(mine, ROW, COL, HARD_COUNT);//我们布置雷只给里面的9*9布置，所以传9*9就可以了
			DisplayBoard(show, ROW, COL);
			//2.扫雷
			FindMine(mine, show, ROW, COL, HARD_COUNT);
			break;
		default:
			printf("输入错误，请重新输入\n");
			break;
		}
	} while ((count != 1) && (count != 2) && (count != 3));
}

以上是三个难度选择，玩家选择1，2，3分别进入不同的case语句。

在看完难度选择的框架后，我们再来看看游戏真正的进行

游戏真正的进行有两个步骤：

（1）布置雷

（2）扫雷

4、布置雷

void SetMine(char board[ROWS][COLS], int row, int col, int choose)
{
	//1.随机找坐标布置雷
	//布置多少个雷 - 10
	while (choose)
	{
		//b布置成功一个雷，choose--1

		//生成随机坐标
		int x = rand() % row + 1;//rand()%row - 0到8，+1 - 1到9
		int y = rand() % col + 1;
		//2.布雷
		if (board[x][y] == '0')//该坐标没布置雷
		{
			board[x][y] = '1';
			choose--;
		}
	}
}

我们将玩家选择的难度对应我们需要设置的雷的个数传进来，while循环里我们将要布置雷的个数设置为循环条件，每布置成功一个雷，我们choose–，当choose等于0时，我们循环不进去，所有雷布置成功。

5、扫雷

void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col, int count)
{
	int x = 0;
	int y = 0;
	int win = 0;
again:
	while (1)
	{
		printf("请输入要排查的坐标：>");
		scanf("%d %d", &x, &y);
		if (x >= 1 && x <= row && y >= 1 && y <= col)
		{
			if (mine[x][y] == '1')
			{
				printf("很遗憾，你被炸死了\n");
				DisplayBoard(mine, row, col);
				printf("\n");
				break;
			}
			else
			{
				//如果不是雷，就统计周围有几个雷,周围如果没雷则查看周围位置有几个雷，依次递归实现
				SpreadMind(mine, show, x, y);//可展开的代码
				DisplayBoard(show, row, col);
				win = CheckShow(show, row, col);
				if (win == count)
				{
					break;
				}
			}
		}
		else
		{
			printf("坐标非法,请重新输入\n");
			goto again;
		}
		SignMine(show, row, col);
	}
	if (win == count)
	{
		printf("恭喜你，排雷成功\n");
	}
}

首先我们进入循环后，第一步需要判断玩家输入的坐标是否合法，不合法让他重新输入，合法了就判断，该坐标是不是雷，是雷，游戏结束，break，不是雷，打印周围雷数的坐标，我们这个实现的是可展开的代码，可展开什么意思呢？就是当我们排查时，当这个坐标不是雷，并且他周围没有雷，我们就展开一片，这里我们用递归实现，当这个坐标不是雷时，但是周围有雷，则只显示他自己周围有几个雷。我们还需要写获取周围雷数的函数，判断输赢的函数，还有是否标记雷的代码。

可展开的代码

void SpreadMind(char mine[ROWS][COLS], char show[ROWS][COLS], int x, int y)
{
	int count = GetMineCount(mine, x, y);
	if (count != 0)
	{
		show[x][y] = count + '0';
	}
	else//周围没有雷
	{
		show[x][y] = ' ';//没有雷将他赋为' '
		if (show[x - 1][y] == '*')
			SpreadMind(mine, show, x - 1, y);
		if (show[x - 1][y - 1] == '*')
			SpreadMind(mine, show, x - 1, y - 1);
		if (show[x][y - 1] == '*')
			SpreadMind(mine, show, x, y - 1);
		if (show[x + 1][y - 1] == '*')
			SpreadMind(mine, show, x + 1, y - 1);
		if (show[x + 1][y] == '*')
			SpreadMind(mine, show, x + 1, y);
		if (show[x + 1][y + 1] == '*')
			SpreadMind(mine, show, x + 1, y + 1);
		if (show[x][y + 1] == '*')
			SpreadMind(mine, show, x, y + 1);
		if (show[x - 1][y + 1] == '*')
			SpreadMind(mine, show, x - 1, y + 1);
	}
}

返回周围雷数的函数：

这里有两种写法：

第一种写法依靠的是字符的ASCII码值，首先我们看看ASCII码表

我们可以看到字符0的对应的十进制为48，字符1对应的是49，我们可以得到，如果是雷，则是字符1，‘1’-‘0’=1,得到的是整形数字1，所以我们将周围坐标的字符加起来，减去8*'0’得到的就是周围雷的总数。

第二种写法：

我们直接访问玩家输入坐标周围的数组元素判断是否为雷即可，为雷count++。

//int GetMineCount(char mine[ROWS][COLS], 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';
//}
static int GetMineCount(char mine[ROWS][COLS], int x, int y)
{
	int i = 0;
	int j = 0;
	int count = 0;
	for (i = x - 1; i <= x + 1; i++)
	{
		for (j = y - 1; j <= y + 1; j++)
		{
			if (mine[i][j] == '1')
			{
				count++;
			}
		}
	}
	return count;
}

判断输赢的代码：

我们标记的雷的数目和没展开的格子数加起来等于雷的数，则玩家排雷成功

int CheckShow(char show[ROWS][COLS], int row, int col)
{
	int win = 0;
	int i = 0;
	int j = 0;
	for (i = 1; i <= row; i++)
	{
		for (j = 1; j <= col; j++)
		{
			if (show[i][j] == '*' || show[i][j] == '#')
			{
				win++;
			}
		}
	}
	return win;
}

是否标记雷的代码：

我们让他可以连续选择标记，所以我们用do……while结构，循环里面运用switch语句，需要标记雷时，先判断坐标的合法性，然后再判断是否没有展开，没有展开的话，将他标记，如果展开了判断是否已经被标记，被标记则提示被标记。

static void SignMine(char show[ROWS][COLS], int row, int col)
{
	int input = 0;
	int x = 0;
	int y = 0;
	do
	{
		printf("是否需要标记雷：1.是     0.否\n");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			printf("请输入要标记雷的坐标：>");
			scanf("%d %d", &x, &y);
			if (x >= 1 && x <= row && y >= 1 && y <= col)
			{
				if (show[x][y] == '*')
				{
					show[x][y] = '#';
					DisplayBoard(show, row, col);//打印棋盘
				}
				else if (show[x][y] == '#')
				{
					printf("该坐标已被标记\n");
				}
			}
			else
			{
				printf("坐标非法，请重新输入\n");
			}
		case 0:
			break;
		default:
			printf("输入错误，请重新输入\n");
			break;
		}
	} while (input);
}

test.中的代码：

#include"game.c"
void game()
{
    //需要用到两个数组，一个数组存放雷，一个数组存放排查出的雷的信息
    //1.布置雷
    //怎么布置雷？随机布置 - 得有一个存放雷的棋盘
    //雷   --  1
    //不是雷 --0
    //最开始数组中所有数据存放0，
    //布置10个雷就将10个数组数据改为1
    //2.排查雷
    //排查雷时，如果一个地方不是雷，我们要显示他周围有多少雷，
    //假设周围只有一个雷，显示1，就和他是雷起冲突了，
    //我们额外给一个数组
    //这个数组专门存放排查出雷的信息
    //我们打印时就好操作，三种信息不干扰
    
    //我们给要展示的棋盘界面初始化为*，我们将两个数组定为字符数组
    //如果想实现9*9的棋盘，数组的大小设置成11*11比较好
    
	//真正扫雷的过程
	//两个数组存放数据，一个数组mine存放布置雷，另一个show数组存放所排除雷周围的雷的信息
	char mine[ROWS][COLS] = { 0 };
	char show[ROWS][COLS] = { 0 };
	//数组里存放字符
	//初始化mine数组
	InitBoard(mine, ROWS, COLS, '0');//是雷字符'1',不是雷'0'
	//布置好的雷不能打印
	InitBoard(show, ROWS, COLS, '*');//*表示还没有排查
	Choose(mine, show);
}
void menu()
{
	printf("*****************************\n");
	printf("************1.play***********\n");
	printf("************0.exit***********\n");
	printf("*****************************\n");
}

int main()
{
	int input = 0;
	srand((unsigned int)time(NULL));
	do
	{
		menu();
		printf("请选择：>");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			game();
			break;
		case 0:
			printf("退出游戏\n");
			break;
		default:
			printf("输入有误，请重新输入\n");
			break;
		}
	} while (input);
	return 0;
}

game.h中的代码：

//game.h

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#define ROW 9
#define COL 9
#define ROWS ROW+2
#define COLS COL+2
#define EASY_COUNT 10
#define COMMON_COUNT 20
#define HARD_COUNT 30


//初始化函数声明
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 board[ROWS][COLS], int row, int col, int choose);

void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col, int count);

void SpreadMind(char mine[ROWS][COLS], char show[ROWS][COLS], int x, int y);

void SignMine(char show[ROWS][COLS], int row, int col);

void Choose(char mine[ROWS][COLS], char show[ROWS][COLS]);

game.c中的代码：

//game.c
#include"game.h"


void menu1()
{
	printf("*********************************\n");
	printf("******    1.EASY_COUNT     ******\n");
	printf("******    2.COMMON_COUNT   ******\n");
	printf("******    3.HARD_COUNT     ******\n");
}

void Choose(char mine[ROWS][COLS], char show[ROWS][COLS])
{
	int count = 0;
	menu1();
	scanf("%d", &count);
	do
	{
		switch (count)
		{
		case 1:
			//1.布置雷 - 数据的存储--->9*9二维数组
			SetMine(mine, ROW, COL, EASY_COUNT);//我们布置雷只给里面的9*9布置，所以传9*9就可以了
			DisplayBoard(show, ROW, COL);
			//DisplayBoard(mine, ROW, COL);

			//2.扫雷
			FindMine(mine, show, ROW, COL, EASY_COUNT);
			break;
		case 2:
			//1.布置雷 - 数据的存储--->9*9二维数组
			SetMine(mine, ROW, COL, COMMON_COUNT);//我们布置雷只给里面的9*9布置，所以传9*9就可以了
			DisplayBoard(show, ROW, COL);
			//2.扫雷
			FindMine(mine, show, ROW, COL, COMMON_COUNT);
			break;
		case 3:
			//1.布置雷 - 数据的存储--->9*9二维数组
			SetMine(mine, ROW, COL, HARD_COUNT);//我们布置雷只给里面的9*9布置，所以传9*9就可以了
			DisplayBoard(show, ROW, COL);
			//2.扫雷
			FindMine(mine, show, ROW, COL, HARD_COUNT);
			break;
		default:
			printf("输入错误，请重新输入\n");
			break;
		}
	} while ((count != 1) && (count != 2) && (count != 3));
}
//初始化函数定义
void InitBoard(char board[ROWS][COLS], int rows, int cols, char set)
{
	int i = 0;
	int j = 0;
	for (i = 0; i < rows; i++)
	{
		for (j = 0; j < cols; j++)
		{
			board[i][j] = set;
		}
	}
}

void DisplayBoard(char board[ROWS][COLS], int row, int col)
{
	int i = 0;
	int j = 0;
	//列号的打印
	for (i = 0; i <= col; i++)
	{
		printf("%d ", i);
	}
	printf("\n");
	for (i = 1; i <= row; i++)
	{
		//每一行前面的行号
		printf("%d ", i);
		for (j = 1; j <= col; j++)
		{
			printf("%c ", board[i][j]);
		}
		printf("\n");
	}
}

void SetMine(char board[ROWS][COLS], int row, int col, int choose)
{
	//1.随机找坐标布置雷
	//布置多少个雷 - 10
	while (choose)
	{
		//b布置成功一个雷，choose--1

		//生成随机坐标
		int x = rand() % row + 1;//rand()%row - 0到8，+1 - 1到9
		int y = rand() % col + 1;
		//2.布雷
		if (board[x][y] == '0')//该坐标没布置雷
		{
			board[x][y] = '1';
			choose--;
		}
	}
}

//int GetMineCount(char mine[ROWS][COLS], 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';
//}
static int GetMineCount(char mine[ROWS][COLS], int x, int y)
{
	int i = 0;
	int j = 0;
	int count = 0;
	for (i = x - 1; i <= x + 1; i++)
	{
		for (j = y - 1; j <= y + 1; j++)
		{
			if (mine[i][j] == '1')
			{
				count++;
			}
		}
	}
	return count;
}

void SpreadMind(char mine[ROWS][COLS], char show[ROWS][COLS], int x, int y)
{
	int count = GetMineCount(mine, x, y);
	if (count != 0)
	{
		show[x][y] = count + '0';
	}
	else//周围没有雷
	{
		show[x][y] = ' ';
		if (show[x - 1][y] == '*')
			SpreadMind(mine, show, x - 1, y);
		if (show[x - 1][y - 1] == '*')
			SpreadMind(mine, show, x - 1, y - 1);
		if (show[x][y - 1] == '*')
			SpreadMind(mine, show, x, y - 1);
		if (show[x + 1][y - 1] == '*')
			SpreadMind(mine, show, x + 1, y - 1);
		if (show[x + 1][y] == '*')
			SpreadMind(mine, show, x + 1, y);
		if (show[x + 1][y + 1] == '*')
			SpreadMind(mine, show, x + 1, y + 1);
		if (show[x][y + 1] == '*')
			SpreadMind(mine, show, x, y + 1);
		if (show[x - 1][y + 1] == '*')
			SpreadMind(mine, show, x - 1, y + 1);
	}
}

static void SignMine(char show[ROWS][COLS], int row, int col)
{
	int input = 0;
	int x = 0;
	int y = 0;
	do
	{
		printf("是否需要标记雷：1.是     0.否\n");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			printf("请输入要标记雷的坐标：>");
			scanf("%d %d", &x, &y);
			if (x >= 1 && x <= row && y >= 1 && y <= col)
			{
				if (show[x][y] == '*')
				{
					show[x][y] = '#';
					DisplayBoard(show, row, col);//打印棋盘
				}
				else if (show[x][y] == '#')
				{
					printf("该坐标已被标记\n");
				}
			}
			else
			{
				printf("坐标非法，请重新输入\n");
			}
		case 0:
			break;
		default:
			printf("输入错误，请重新输入\n");
			break;
		}
	} while (input);
}
int CheckShow(char show[ROWS][COLS], int row, int col)
{
	int win = 0;
	int i = 0;
	int j = 0;
	for (i = 1; i <= row; i++)
	{
		for (j = 1; j <= col; j++)
		{
			if (show[i][j] == '*' || show[i][j] == '#')
			{
				win++;
			}
		}
	}
	return win;
}

//扫雷游戏的结束
//1.炸死了
//2.正常排查了所有不是雷的位置
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col, int count)
{
	int x = 0;
	int y = 0;
	int win = 0;
again:
	while (1)
	{
		printf("请输入要排查的坐标：>");
		scanf("%d %d", &x, &y);
		if (x >= 1 && x <= row && y >= 1 && y <= col)
		{
			if (mine[x][y] == '1')
			{
				printf("很遗憾，你被炸死了\n");
				DisplayBoard(mine, row, col);
				printf("\n");
				break;
			}
			else
			{
				//如果不是雷，就统计周围有几个雷,周围如果没雷则查看周围位置有几个雷，依次递归实现
				SpreadMind(mine, show, x, y);//可展开的代码
				DisplayBoard(show, row, col);
				win = CheckShow(show, row, col);
				if (win == count)
				{
					break;
				}
			}
		}
		else
		{
			printf("坐标非法,请重新输入\n");
			goto again;
		}
		SignMine(show, row, col);
	}
	if (win == count)
	{
		printf("恭喜你，排雷成功\n");
	}
}

欢迎大家学习交流