扫雷android studio 扫雷技巧口诀图解

---

文章目录

• 前言
• 一、扫雷的游戏规则
• 二、扫雷设计的大概思路
• 三、扫雷设计的详细思路和代码

• 1.首先定义一个菜单menu函数
• 2.在test函数中调用menu函数
• 3.在main函数中在调用test函数
• 4.以上均在text.c中进行，然后我们需要在text.c文件中调用game函数，然后在game.c的源文件实现其功能，实现game函数的具体思路和代码如下

• 1.定义2个棋盘mine，show的二维数组
• 2.初始化棋盘，其中mine全部初始化为'0'，有雷的地方定为'1'，用0，1是为了方便统计周围雷的数量。show是用来给玩家来玩的，一开始全部初始化为'*'
• 3.打印棋盘mine，show，而实际玩的时候不需要打印出mine棋盘，这里我们把两个棋盘打印出来
• 4.然后就是设置雷，也就是埋雷了，在mine数组中我们用1代表雷，我们在头文件中定义#define EAZY 10代表简单模式下要排的10个雷，这样更方便我们后续更改雷的个数
• 5.设置完雷后便是排查雷了
• 6.由于排查雷的时候我们使用了open(mine, show, x, y)来展开一片空白，接下来我们对open函数进行实现
• 7.由于实现open展开函数的时候用到了统计雷个数函数get_mine,接下来我们需要在这之前实现get_mine(mine, x, y)
• 8.以上就实现了整个扫雷游戏

• 5.总的代码如下

• 四、总结
• 此外

---

前言

我们都知道扫雷分给不同等级

一下操作均以最基础的9*9棋盘，10个雷的难度演示

一、扫雷的游戏规则

1.扫雷的基本规则：找出空的方块和雷区。如果确定该方块为空，可以左键点击一下，如果认为是雷可以右键点击一下插上小旗，右击两次代表不确认。

2.左下角代表游戏时间，右下角代表剩余雷的数量。

3.首先开始我们都不知道哪里是雷，就需要任意选择一个，小编一般喜欢从四个角落开始。

4.游戏中的数字代表周围八个方向雷的数量，如下图中的数字1，周围的空格已经全部打开，只剩下一个方格，那么这一个肯定就是雷了。

5.游戏中要注意各个数字间的配合，仔细一点。

6.有时候可能会遇到无法判断具体哪一个是雷的情况，这样需要我们根据周围的数字去判断最有可能的是哪一个。

二、扫雷设计的大概思路

定义2个棋盘mine，show
其中mine全部初始化为’0’，有雷的地方定为’1’，用0，1是为了方便统计周围雷的数量
show是用来给玩家来玩的，一开始全部初始化为’*‘
初始化
打印棋盘
设置雷
排查雷
展开

三、扫雷设计的详细思路和代码

为了确保程序的独立性
我们创造两个源文件game.c和text.c，一个头文件game.h实现程序的模块化进行
其中game.c用来实现整个游戏的具体操作
text.c用来最终调用game.c来实现运行
这就需要创造一个头文件game.h来实现上述的调用

1.首先定义一个菜单menu函数

代码如下（示例）：

//游戏菜单：选择是否开始玩儿游戏，1：玩儿，0：退出游戏;
void menu()
{
	printf("*************************\n");
	printf("******** 1.play  ********\n");
	printf("******** 0.exit  ********\n");
	printf("*************************\n");
}

2.在test函数中调用menu函数

使用函数调用的方式实现

void text()
{
	int input = 0;
	do
	{
		menu();
		printf("请选择是否进行游戏\n");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			game();
			break;
		case 0:
			printf("退出游戏\n");
			break;
		default:
			printf("选择错误，请重新选择\n");
			break;
		}
	} while (input);
}

3.在main函数中在调用test函数

int main()
{
	test();
	return 0;
}

至此之前的操作和三子棋操作大体相同

4.以上均在text.c中进行，然后我们需要在text.c文件中调用game函数，然后在game.c的源文件实现其功能，实现game函数的具体思路和代码如下

1.定义2个棋盘mine，show的二维数组

虽然我们要打印99的棋盘，但为了后续能更好的统计最外围雷的个数
我们需要在最外围各自在加上一行，相当于以左右上下各加一行，相当于1111的棋盘
后续在其9*9的棋盘上进行操作即可
所以在头文件game.h中,定义后续操作需要用的ROW,COL,ROWS,COLS

#define ROW 9
#define COL 9

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

然后在text.c文件中我们创出两个11*11的二维数组

void game()
{
	char mine[ROWS][COLS] = { 0 };
	char show[ROWS][COLS] = { 0 };
	}

2.初始化棋盘，其中mine全部初始化为’0’，有雷的地方定为’1’，用0，1是为了方便统计周围雷的数量。show是用来给玩家来玩的，一开始全部初始化为’*’

在text.c文件的game函数中

void game()
{
	//定义2个棋盘mine，show
	char mine[ROWS][COLS] = { 0 };
	char show[ROWS][COLS] = { 0 };
	
	//初始化
	//其中mine全部初始化为'0'，有雷的地方定为'1'，用0，1是为了方便统计周围雷的数量
	//show是用来给玩家来玩的，一开始全部初始化为'*'
	init_board(mine, ROWS, COLS,'0');
	init_board(show, ROWS, COLS,'*');
}

其中为使代码更精简，我们用board来接收mine和show，传入的’0‘和’*‘用met接收
因为mine和show的区别只是要初始化的值不同，故这样操作可以一举两得

在头文件game.h中声明两个初始化函数

//初始化棋盘
void init_board(char board[ROWS][COLS], int rows, int cols,int met);

在到game.c文件中具体实现初始化实现nit_board函数

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

3.打印棋盘mine，show，而实际玩的时候不需要打印出mine棋盘，这里我们把两个棋盘打印出来

在text.c文件的game函数中调用print函数，由于我们要打印9*9的棋盘，因此我们传入ROW,COL

void game()
{
	//定义2个棋盘mine，show
	char mine[ROWS][COLS] = { 0 };
	char show[ROWS][COLS] = { 0 };
	
	//初始化
	//其中mine全部初始化为'0'，有雷的地方定为'1'，用0，1是为了方便统计周围雷的数量
	//show是用来给玩家来玩的，一开始全部初始化为'*'
	init_board(mine, ROWS, COLS,'0');
	init_board(show, ROWS, COLS,'*');

	//打印棋盘
	//display_board(mine, ROW, COL);
	display_board(show, ROW, COL);
	}

同样的和初始化一样的思路，为了使代码更加精简，我们用board来接收mine和show，
打印所需的棋盘即可

所以在头文件game.h中定义print函数

//打印棋盘
void display_board(char board[ROWS][COLS], int row, int col);

然后我们到game.c文件中实现print函数

void display_board(char board[ROWS][COLS], int row, int col)
{
	int x = 0;
	int y = 0;
	printf("--------- 扫雷 ---------\n");
	for (y = 0; y <= col; y++)//打印第一行的行标
	{
		printf("%d ", y);
	}
	printf("\n");
	//打印行
	for (x = 1; x <= row; x++)
	{
		printf("%d ", x);//打印第一列的列标
		//打印列
		for (y = 1; y <= col; y++)
		{
			printf("%c ", board[x][y]);
		}
		printf("\n");
	}
	printf("--------- 扫雷 ---------\n");
}

效果如下

4.然后就是设置雷，也就是埋雷了，在mine数组中我们用1代表雷，我们在头文件中定义#define EAZY 10代表简单模式下要排的10个雷，这样更方便我们后续更改雷的个数

在text.c文件的game函数中调用setmine函数

void game()
{
	//定义2个棋盘mine，show
	char mine[ROWS][COLS] = { 0 };
	char show[ROWS][COLS] = { 0 };
	//初始化
	//其中mine全部初始化为'0'，有雷的地方定为'1'，用0，1是为了方便统计周围雷的数量
	//show是用来给玩家来玩的，一开始全部初始化为'*'
	init_board(mine, ROWS, COLS,'0');
	init_board(show, ROWS, COLS,'*');

	//打印棋盘
	//display_board(mine, ROW, COL);
	display_board(show, ROW, COL);

	//设置雷
	setmine(mine, ROW, COL);
	//display_board(show, ROW, COL)
	}

在头文件game.h中声明setmine函数，并定义EAZY 10代表雷的个数

//雷的个数
#define EASY 10
//设置雷
void setmine(char mine[ROWS][COLS], int row, int col);

在game.c中我们实现setmine函数

void setmine(char mine[ROWS][COLS], int row, int col)
{
	int count = EASY;
	int x = 0;
	int y = 0;
	while (count)
	{
		x = rand() % row + 1;
		y = rand() % col + 1;
		if (mine[x][y] == '0')
		{
			mine[x][y] = '1';
			count--;
		}
	}
}

我们使用rand函数随机产生雷,而使用rand需要和srand连用才能产生随机数，所以我们需要在text.c文件的main函数中使用srand

int main()
{
	srand((unsigned int)time(NULL));
	text();
	return 0;
}

使用rand和srand，time库函数需要引用头文件
使用在头文件game.h中

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

至此我们雷已经设置完了，我们打印出来mine棋盘效果如下

5.设置完雷后便是排查雷了

我们在text.c的game函数中调用check函数，并传入mine，show两个数组和ROW,COL

void game()
{
	//定义2个棋盘mine，show
	char mine[ROWS][COLS] = { 0 };
	char show[ROWS][COLS] = { 0 };
	//初始化
	//其中mine全部初始化为'0'，有雷的地方定为'1'，用0，1是为了方便统计周围雷的数量
	//show是用来给玩家来玩的，一开始全部初始化为'*'
	init_board(mine, ROWS, COLS,'0');
	init_board(show, ROWS, COLS,'*');

	//打印棋盘
	//display_board(mine, ROW, COL);
	display_board(show, ROW, COL);

	//设置雷
	setmine(mine, ROW, COL);
	//display_board(mine, ROW, COL);

	//排查雷
	check(mine,show, ROW, COL);
	}

在头文件game.h中声明check

//排查雷
void check(char mine[ROWS][COLS],char show[ROWS][COLS],int row, int col);

在game.c文件中实现

//排查雷
void check(char mine[ROWS][COLS], char show[ROWS][COLS],int row, int col)
{
	int x = 0;
	int y = 0;
	int win = 0;//只要不是雷就+1
	while(win<row*col-EASY)//当win等于除雷外所有的个数证明已经排完所有雷，跳出循环
	{ 
		printf("请输入要排查的坐标");
		scanf("%d%d", &x, &y);
		if (show[x][y] != '*')//防止坐标重复使win加1
		{
			printf("该坐标被查过了");
			continue;
		}
		if (x >= 1 && x <= row && y >= 1 && y <= col)//由于传入的是11*11数组，我们要其中心的9*9数组进行操作，坐标（数组下标）必须在1~9范围上
		{
			if (mine[x][y] == '1')
			{
				printf("很遗憾，你被炸死了\n");
				//把雷的位置打出来给玩家看看
				display_board(mine, ROW, COL);
				break;
			}
			else
			{
			    open(mine, show, x, y);//展开一片空白，我们在下面进行讲解
				display_board(show, ROW, COL);//打印玩家要玩的棋盘
				win++;
			}
		}
		else
		{
			printf("坐标非法，请重新输入\n");
		}
	}
	if (win == (row * col - EASY))//当win等于除雷外所有的个数证明已经排完所有雷，代表游戏胜利
	{
		printf("游戏获胜\n");
		//把所有雷的位置打印出来给玩家看
		display_board(mine, ROW, COL);
	}
}

6.由于排查雷的时候我们使用了open(mine, show, x, y)来展开一片空白，接下来我们对open函数进行实现

在text.c中的game函数中调用open函数

void game()
{
	//定义2个棋盘mine，show
	char mine[ROWS][COLS] = { 0 };
	char show[ROWS][COLS] = { 0 };
	//初始化
	//其中mine全部初始化为'0'，有雷的地方定为'1'，用0，1是为了方便统计周围雷的数量
	//show是用来给玩家来玩的，一开始全部初始化为'*'
	init_board(mine, ROWS, COLS,'0');
	init_board(show, ROWS, COLS,'*');

	//打印棋盘
	//display_board(mine, ROW, COL);
	display_board(show, ROW, COL);

	//设置雷
	setmine(mine, ROW, COL);
	//display_board(mine, ROW, COL);

	//排查雷
	check(mine,show, ROW, COL);

	//展开雷
    open(mine, show, ROW, COL);
}

然后在头文件game.h中我们声明open函数

//展开雷
void open(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col);

最后在game.c文件中实现open函数

//展开雷
void open(char mine[ROWS][COLS], char show[ROWS][COLS], int x, int y)
{
	if (x >= 1 && x <= ROW && y >= 1 && y <= COL)
	{
		int count = get_mine(mine, x, y);//统计一个格子周围雷的个数，并返回个数count
		//如果该格子周围雷的个数不为0，我们就把该格子周围雷的个数传到玩家玩的show棋盘对应的格子中，而如果是0，我们传入空格‘ ’ 
		if (count != 0)
			show[x][y] = count + '0';//由于count返回的是整数，而存入数组中的是字符，我们需要加上‘0’，相当于加上ASCII值48
		else if (show[x][y] != ' ')
		{
			show[x][y] = ' ';
			int i = 0;
			for (i = x - 1; i <= x + 1; i++)
			{
				int j = 0;
				for (j = y - 1; j <= y + 1; j++)
				{
				//利用递归反复进行，知道周围都有雷
					open(mine, show, i, j);
				}
			}
		}
		else
		{
			return ;
		}
	}
}

7.由于实现open展开函数的时候用到了统计雷个数函数get_mine,接下来我们需要在这之前实现get_mine(mine, x, y)

因为get_mine函数在open函数即统一文件中调用，我们不需要在头文件game.c中声明，直接在open函数之前实现即可

而实现get_mine函数又有两种方法如下

方法一

int get_mine(char mine[ROWS][COLS], int x, int y)
{
	return mine[x][y + 1] + mine[x][y - 1] + mine[x - 1][y] + mine[x + 1][y] 
		+ mine[x + 1][y + 1] + mine[x - 1][y - 1] + mine[x + 1][y - 1] +
		mine[x - 1][y + 1]-8*'0';
}

方法二

int get_mine(char mine[ROWS][COLS], int x, int y)
{
	int i = 0;
	int count = 0;
	for (i = x - 1; i <= x + 1; i++)
	{
		int j = 0;
		for (j = y - 1; j <= y + 1; j++)
		{
			if (mine[i][j] == '1')
				count++;
		}
	}
	return count;
 }

我个人认为第二种方法更好

8.以上就实现了整个扫雷游戏

游戏效果如下

5.总的代码如下

text.c

#include "game.h"

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

void game()
{
	//定义2个棋盘mine，show
	char mine[ROWS][COLS] = { 0 };
	char show[ROWS][COLS] = { 0 };
	//初始化
	//其中mine全部初始化为'0'，有雷的地方定为'1'，用0，1是为了方便统计周围雷的数量
	//show是用来给玩家来玩的，一开始全部初始化为'*'
	init_board(mine, ROWS, COLS,'0');
	init_board(show, ROWS, COLS,'*');

	//打印棋盘
	//display_board(mine, ROW, COL);
	display_board(show, ROW, COL);

	//设置雷
	setmine(mine, ROW, COL);
	//display_board(mine, ROW, COL);

	//排查雷
	check(mine,show, ROW, COL);

	//展开雷
    open(mine, show, ROW, COL);
}

void text()
{
	int input = 0;
	do
	{
		menu();
		printf("请选择是否进行游戏\n");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			game();
			break;
		case 0:
			printf("退出游戏\n");
			break;
		default:
			printf("选择错误，请重新选择\n");
			break;
		}
	} while (input);
}

int main()
{
	srand((unsigned int)time(NULL));
	text();
	return 0;
}

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 10

//初始化棋盘
void init_board(char board[ROWS][COLS], int rows, int cols,int met);

//打印棋盘
void display_board(char board[ROWS][COLS], int row, int col);

//设置雷
void setmine(char mine[ROWS][COLS], int row, int col);

//排查雷
void check(char mine[ROWS][COLS],char show[ROWS][COLS],int row, int col);

//展开雷
void open(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col);

game.c

#include "game.h"

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


void display_board(char board[ROWS][COLS], int row, int col)
{
	int x = 0;
	int y = 0;
	printf("--------- 扫雷 ---------\n");
	for (y = 0; y <= col; y++)
	{
		printf("%d ", y);
	}
	printf("\n");
	for (x = 1; x <= row; x++)
	{
		printf("%d ", x);
		for (y = 1; y <= col; y++)
		{
			printf("%c ", board[x][y]);
		}
		printf("\n");
	}
	printf("--------- 扫雷 ---------\n");
}

void setmine(char mine[ROWS][COLS], int row, int col)
{
	int count = EASY;
	int x = 0;
	int y = 0;
	while (count)
	{
		x = rand() % row + 1;
		y = rand() % col + 1;
		if (mine[x][y] == '0')
		{
			mine[x][y] = '1';
			count--;
		}
	}
}

//统计 周围雷的个数
//方法一
//int get_mine(char mine[ROWS][COLS], int x, int y)
//{
//	return mine[x][y + 1] + mine[x][y - 1] + mine[x - 1][y] + mine[x + 1][y] 
//		+ mine[x + 1][y + 1] + mine[x - 1][y - 1] + mine[x + 1][y - 1] +
//		mine[x - 1][y + 1]-8*'0';
//}

//方法二
int get_mine(char mine[ROWS][COLS], int x, int y)
{
	int i = 0;
	int count = 0;
	for (i = x - 1; i <= x + 1; i++)
	{
		int j = 0;
		for (j = y - 1; j <= y + 1; j++)
		{
			if (mine[i][j] == '1')
				count++;
		}
	}
	return count;
 }

//排查雷
void check(char mine[ROWS][COLS], char show[ROWS][COLS],int row, int col)
{
	int x = 0;
	int y = 0;
	int win = 0;
	while(win<row*col-EASY)
	{ 
		printf("请输入要排查的坐标");
		scanf("%d%d", &x, &y);
		if (show[x][y] != '*')
		{
			printf("该坐标被查过了");
			continue;
		}
		if (x >= 1 && x <= row && y >= 1 && y <= col)
		{
			if (mine[x][y] == '1')
			{
				printf("很遗憾，你被炸死了\n");
				//把雷的位置打出来给玩家看看
				display_board(mine, ROW, COL);
				break;
			}
			else
			{
				open(mine, show, x, y);
				display_board(show, ROW, COL);
				win++;
			}
		}
		else
		{
			printf("坐标非法，请重新输入\n");
		}
	}
	if (win == (row * col - EASY))
	{
		printf("游戏获胜\n");
		display_board(mine, ROW, COL);
	}
}
 
//展开雷
void open(char mine[ROWS][COLS], char show[ROWS][COLS], int x, int y)
{
	if (x >= 1 && x <= ROW && y >= 1 && y <= COL)
	{
		int count = get_mine(mine, x, y);
		if (count != 0)
			show[x][y] = count + '0';
		else if (show[x][y] != ' ')
		{
			show[x][y] = ' ';
			int i = 0;
			for (i = x - 1; i <= x + 1; i++)
			{
				int j = 0;
				for (j = y - 1; j <= y + 1; j++)
				{
					open(mine, show, i, j);
				}
			}
		}
		else
		{
			return ;
		}
	}
}

四、总结

提示：这里对文章进行总结： 继三子棋后的扫雷，我会继续坚持的
有不对的请及时指正我！谢谢读者

此外

关于扫雷还可以进行的改进
比如：可以像游戏里的标记雷的位置，创造更难的棋盘等等