繁依Fanyi0

这个屌丝很懒，什么也没留下！

热门标签

【用C语言轻松实现】- 扫雷【超详细教程】_扫雷怎么生成才能确保通过

作者：繁依Fanyi0 | 2024-08-03 03:35:09

踩

扫雷怎么生成才能确保通过

一、游戏规则

扫雷就是要将所有非地雷的格子揭开即胜利，踩到地雷格子就算失败。游戏是由很多个方格组成，用鼠标随机点击一个方格，若格子被打开后没有地雷，即方格会被打开并显示出其周围 8 个方格隐藏地雷的个数。所以若想顺利过关就需要利用好这些显示出来的数字提示。

二、文件的创建

test.c（实现游戏的整体思路，用于测试扫雷游戏的逻辑）
game.c（游戏的实现）
game.h（声明 .c 文件的函数，包含所有需要用到的头文件以及 define 定义的常量）

三、初始页面的实现

1、实现主菜单页面

// test.c

（1）menu()


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

效果图如下：

（2）test()：


void test()
{
	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);
}

注：这里使用 do while() 循环可以保证至少会进行一次选择。如果选择 0，会被判定为假，则跳出循环，退出游戏；如果输入选择则不会退出游戏，可以1保证游戏能够重复游玩。

srand((unsigned int)time(NULL)) 利用时间戳，形成随机数，主要目的是实现游戏中地雷的随机埋放。

（3）main()：


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

2、在 game.h 中引用所需要的文件和必要的定义

// game.h


#pragma once
 
// 9*9
#define ROW 9// 行
#define COL 9// 列
 
// 11*11
#define ROWS ROW+2
#define COLS COL+2
 
#define EASY_COUNT 10// 地雷的数量
 
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

四、棋盘函数的声明、创建和实现（打印棋盘函数同理）

1、声明棋盘的函数（附加打印棋盘函数）

// game.h


//初始化排雷界面
void InitBoard(char board[ROWS][COLS], int rows, int cols, char set);
 
//打印棋盘
void DisplayBoard(char board[ROWS][COLS], int row, int col);

2、棋盘函数的创建（附加打印功能）

// test.c


void game()
{
    // 扫雷游戏的实现
	char mine[ROWS][COLS] = { 0 };// 布置地雷的信息 // '0'
	char show[ROWS][COLS] = { 0 };// 排查地雷的信息 // '*'
 
    // 初始化棋盘
	InitBoard(mine, ROWS, COLS, '0');
	InitBoard(show, ROWS, COLS, '*');
 
    // 打印棋盘
	DisplayBoard(mine, ROW, COL);
	DisplayBoard(show, ROW, COL);
}

char mine[ROWS][COLS] '1' -- 雷 '0' -- 非雷
char show[ROWS][COLS] '*‘ -- 未排查数组字符 -- 已排查

注：初始化两个棋盘，一个为 mine，一个为 show，其中在 mine 数组中我们定义有雷为 '1'，没有雷为 '0'。由扫雷规则可知：当我们输入一个坐标时，会在该坐标上出现一个数字，表示在该坐标周围 8 个格子有多少个地雷，但是当四周只有一个雷的时候所出现的 ‘1’ 不是会与有雷的 '1' 混淆吗？所以我们创建了另外一个数组 show，show 数组中不表示雷，只打印数值，这样就解决了 '1' 的混淆问题。为什么要用 '1' 来代替地雷呢？后面会有介绍到。

首先对埋雷的数组进行初始化为字符 '0'（非雷用字符 '0' 表示，地雷用字符 '1' 表示），对显示棋盘的数组全部用 '*'，将埋雷的数组覆盖起来，因此在 game() 函数里对 InitBorad() 函数调用两次。

1、为什么要创建两个相同的数组呢？

答：因为我们在玩游戏时首先在屏幕上看到的是一个初始化的棋盘，并不清楚哪里埋放着地雷。如果我们触碰到地雷结束游戏，需要给玩家呈现这局游戏所有地雷位置的情况，这样以便于玩家清楚所有雷都在哪个位置，因此我们在屏幕上显示的是 9*9 的数组，但是创建的时候是 11*11 的数组，所以需要两个棋盘才能完成这项任务。其中一个隐藏在暗处用来存放这些地雷、数字的信息，玩家是看不见的；另一个则是专门向玩家展示的棋盘。

2、显示 9*9 大小的棋盘，为什么要创建 11*11 大小的棋盘？

答：这是因为在排雷的过程中，会显示其周围 8 个格子地雷的个数。如果创建一个 9*9 的棋盘，那当我们选择边角方格的时候，我们周围的格子不足 8 个，但是我们还要访问周围 8 个格子，这时候必然会造成数组越界的问题。如果创建 11*11 的棋盘，对 11*11 的棋盘都初始化为字符 '0'，我们只显示内部的 9*9 的格子，这样就解决了数组越界的问题，游戏正常运行。

3、棋盘函数的实现（附加打印棋盘函数的实现）

// game.c


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]);// 要用%c打印 否则打印结果会出现问题
		}
		printf("\n");
	}
}

注：因为游戏要重复进行，所以每次都要先对数组进行初始化，防止因上次游戏的干扰。

我们对第一块 mine 棋盘全部初始化为字符 '0' ，对第二块 show 棋盘全部初始化为字符 '*' ，最终玩家会先看到一个全是字符 '*' 的棋盘，这样也符合游戏规则。

打印效果如下：（只需要将show棋盘展示给游戏用户）

（1）布置棋盘（mine）：

（2）展示棋盘（show）：

五、布置地雷

// game.h


// 布置地雷
void SetMine(char board[ROWS][COLS], int row, int col);

// game.c


void SetMine(char board[ROWS][COLS], int row, int col)
{
	int count = EASY_COUNT;// 在 9*9 棋盘里随机布置10个雷
	while (count)
	{
		int x = rand() % row + 1;// 1~9
		int y = rand() % col + 1;// 1~9
		if (board[x][y] == '0')// 如果没有雷就布置雷
		{
			board[x][y] = '1';
			count--;// 布置完一个雷，雷数-1
		}
	}
}

如何实现随机布雷？

答：创建 rand 函数，利用时间戳生成随机数。因为我们创建的棋盘大小是 9*9 大小的，所以只需要给生成的随机数模上 row/col ，即可得到 0~row-1，因此我们再 +1，即可得到一个在 0~row(col) 的随机数，从而实现随机布雷的效果。一共设定 count 个雷，如果我们埋下一颗雷，就 count -1，同时将初始化的字符 '0' 变成字符 '1'，只有我们识别到目标方格是字符 '0' 时才会埋雷，这也解决了在同一位置重复埋雷的问题。在使用 while() 循环，直到减到 count 为 0 时，while 不再循环，count 颗雷正好布置完成。

六、排查地雷

// game.h


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

注：为什么 FindMine 传的参数是 ROW COL 而不是 ROWS COLS ？原因：首先要明白，要打印 9*9 的棋盘，如果定义棋盘大小只有 9*9，那么当我们检查边界坐标的周围时就会出现越界访问的问题。所以排雷时就只需要将 ROW COL 传过去就好了。

//game.c


int get_mine_count(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';
}
 
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{
	int x = 0;
	int y = 0;
	int win = 0; //9*9-10=71 //判断雷是否都被排查干净
	while (win < row * col - EASY_COUNT)
	{
		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);
				break;
			}
			else//不是雷
			{
				//计算x，y坐标周围有几个雷
				int count = get_mine_count(mine, x, y);
				show[x][y] = count + '0';
                //必须加上'0'（实际上是 count 返回的整型值加上0的ASCII值后，再转化为字符）
				DisplayBoard(show, row, col);
				win++;
			}
		}
		else
		{
			printf("输入坐标非法，请重新输入！\n");
		}
	}
	if (win == row * col - EASY_COUNT)
	{
		printf("恭喜你，排雷成功\n");
		DisplayBoard(mine, row, col);
	}
}

注：将周围 8 个格子的字符全部加起来，如果是字符 '0' 和字符 '1' 所对应的 ASCII 码值相差1，我们可以通过 ASCII 码值来进行判断。将周围 8 个字符相加，然后再减去8个字符 '0' 的和，就可以得到周围 8 个格子中有多少个字符 '1' 的格子，也就是雷的个数。

当我们输入正确的坐标时，我们需要对这个坐标下所对应的字符进行判断，如果是字符 '1' ，说明踩中地雷，游戏结束，这时再将完整的棋盘打印出来，玩家也可以了解本局游戏的情况。如果是字符 '0'，说明玩家没有踩中地雷，根据游戏规则，我们需要显示这个格子周围 8个格子中存在地雷的个数，所以调用了get_mine_count函数。

七、代码整合

1、// test.c


#include "game.h"
 
void menu()
{
	printf("***********************************\n");
	printf("**********    1.paly     **********\n");
	printf("**********    0.exit     **********\n");
	printf("***********************************\n");
}
 
void game()
{
	//布置雷的信息
	char mine[ROWS][COLS] = { 0 };// '0'
	//排查出雷的信息
	char show[ROWS][COLS] = { 0 };// '*'
 
	//两个棋盘的初始化
	InitBoard(mine, ROWS, COLS, '0');
	InitBoard(show, ROWS, COLS, '*');
 
	//棋盘的打印
	//DisplayBoard(mine, ROW, COL);
	DisplayBoard(show, ROW, COL);
 
	//布置雷
	SetMine(mine, ROW, COL);
 
	//排查地雷
	FindMine(mine, show, ROW, COL);
}
 
void test()
{
	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);
}
 
int main()
{
	test();
	return 0;
}

2、// game.c


#include "game.h"
 
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;
	printf("--------扫雷--------\n");
	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]);// 要用%c打印 否则打印结果会出现问题
		}
		printf("\n");
	}
	printf("--------扫雷--------\n");
}
 
void DisplayBoard(char board[ROWS][COLS], int row, int col)
{
	printf("   ");// 考虑到y轴占3格
	for (int j = 1; j <= col; j++)// 打印x轴坐标
	{
		printf(" %d  ", j);
	}
	printf("\n");
	printf("  |");
	for (int j = 0; j < col; j++)// 打印棋盘封顶
	{
		printf("---|");
	}
	printf("\n");
	for (int i = 1; i <= row; i++)
	{
		for (int j = 0; j <= col; j++)
		{
			if (j == 0)
			{
				printf("%2d|", i);// 顺带打印y轴坐标
			}
			else
				printf(" %c |", board[i][j]);// 打印数据
		}
		printf("\n");
		for (int j = 1; j <= col+1; j++)// 注意这里col应该+1
		{
			if (j == 1)
				printf("  |");
			else
				printf("---|");
		}
		printf("\n");
	}
}
 
void SetMine(char board[ROWS][COLS], int row, int col)
{
	int count = EASY_COUNT;// 在 9*9 棋盘里随机布置10个雷
	while (count)
	{
		int x = rand() % row + 1;// 1~9
		int y = rand() % col + 1;// 1~9
		if (board[x][y] == '0')// 如果没有雷就布置雷
		{
			board[x][y] = '1';
			count--;// 布置完一个雷，雷数-1
		}
	}
}
 
int get_mine_count(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';
}
 
炸金花式展开函数
//void explode_spread(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col, int x, int y)
//{
//	// 限制非法坐标的展开
//	if (x >= 1 && x <= row && y >= 1 && y <= col)
//	{
//		// 计算该位置附近四周地雷的个数
//		int count = get_mine_count(mine, x, y);
//		// 若四周没有一个地雷，则需要向该位置的四周展开，直到展开到某个位置附近存在地雷为止
//		if (count == 0)
//		{
//			// 把附近没有地雷的位置变成字符' '
//			show[x][y] = '0';
//			int i = 0;
//			// 向四周共8个位置递归调用
//			for (i = x - 1; i <= x + 1; i++)
//			{
//				int j = 0;
//				for (j = y - 1; j <= y + 1; j++)
//				{
//					// 限制对点位置的重复展开调用，使得每一个位置只能向四周展开一次
//					if (show[i][j] == '*')
//					{
//						explode_spread(mine, show, row, col, i, j);
//					}
//				}
//			}
//		}
//		// 若四周存在地雷则应该在这个位置上标注上地雷的个数
//		else
//		{
//			show[x][y] = count + '0';
//		}
//	}
//}
 
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{
	int x = 0;
	int y = 0;
	int win = 0; //9*9-10=71 //判断雷是否都被排查干净
	while (win < row * col - EASY_COUNT)
	{
		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);
				break;
			}
			else//不是雷
			{
				//explode_spread(mine, show, row, col, x, y);
				//计算x，y坐标周围有几个雷
				int count = get_mine_count(mine, x, y);
				show[x][y] = count + '0';
				//必须加上'0'（实际上是 count 返回的整型值加上0的ASCII值后，再转化为字符）
				DisplayBoard(show, row, col);
				win++;
			}
		}
		else
		{
			printf("输入坐标非法，请重新输入！\n");
		}
	}
	if (win == row * col - EASY_COUNT)
	{
		printf("恭喜你，排雷成功\n");
		DisplayBoard(mine, row, col);
	}
}

3、//game.h


#pragma once
 
// 9*9
#define ROW 9// 行
#define COL 9// 列
 
// 11*11
#define ROWS ROW+2
#define COLS COL+2
 
#define EASY_COUNT 10// 地雷的数量
 
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
 
// 初始化排雷界面
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);
 
// 排查地雷
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col);

八、程序展示

运行效果图：

九、改进建议

1、棋盘优化


void DisplayBoard(char board[ROWS][COLS], int row, int col)
{
	printf("   ");// 考虑到y轴占3格
	for (int j = 1; j <= col; j++)// 打印x轴坐标
	{
		printf(" %d  ", j);
	}
	printf("\n");
	printf("  |");
	for (int j = 0; j < col; j++)// 打印棋盘封顶
	{
		printf("---|");
	}
	printf("\n");
	for (int i = 1; i <= row; i++)
	{
		for (int j = 0; j <= col; j++)
		{
			if (j == 0)
			{
				printf("%2d|", i);// 顺带打印y轴坐标
			}
			else
				printf(" %c |", board[i][j]);// 打印数据
		}
		printf("\n");
		for (int j = 1; j <= col+1; j++)// 注意这里col应该+1
		{
			if (j == 1)
				printf("  |");
			else
				printf("---|");
		}
		printf("\n");
	}
}

运行效果图如下：（增加了棋盘边界线）

2、炸金花式展开函数

这是一个递归函数，该函数实现的功能为：如果排查的位置周围没有雷，则向四周爆炸式展开，直至遇到周围有地雷的坐标时才停下来。那该怎么实现该递归函数呢？当排查的位置没有雷且该位置周围没有雷时，就展开其周围一圈的 8 个坐标，然后看这 8 个坐标是否可以再逐个向其自身周围接着展开，这样一次就递归调用函数自身 8 次的展开速度就像爆炸了一样，所以称其为：炸金花式展开（深度优先遍历）。

注：会发现不管先展开哪一个位置都将陷入死递归当中。当要展开 (x,y) 坐标周围的一圈坐标时，假如其首先会从 (x-1,y+1) 位置开始，然后又由该坐标向其自身周围的一圈展开时，你会发现坐标 (x,y) 也在需要展开的范围内。这样不就会重复要求再次展开坐标(x,y)，然后再由 (x,y) 要求展开(x-1,y+1)，两个坐标相互疯狂调用。若每次判断一个坐标上没有雷且该坐标周围一圈同样没有雷时，则将向我们展示的棋盘上表示未知的字符 '*' 改成 ' '。然后在之后每次递归调用前给一个判断：如果这个将要被递归调用的坐标在展示的棋盘上存放的是字符 '*' 时才能进行下一步，否则将直接跳过此次递归。

如若发生向外扩张的递归，那拓展出来最外围的一圈坐标完全无法起到限制的作用，无法阻止炸金花式的向外展开。因此只能在每次进入递归函数后加一条限制。


//炸金花式展开函数
void explode_spread(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col, int x, int y)
{
	// 限制非法坐标的展开
	if (x >= 1 && x <= row && y >= 1 && y <= col)
	{
		// 计算该位置附近四周地雷的个数
		int count = get_mine_count(mine, x, y);
		// 若四周没有一个地雷，则需要向该位置的四周展开，直到展开到某个位置附近存在地雷为止
		if (count == 0)
		{
			// 把附近没有地雷的位置变成字符' '
			show[x][y] = ' ';
			int i = 0;
			// 向四周共8个位置递归调用
			for (i = x - 1; i <= x + 1; i++)
			{
				int j = 0;
				for (j = y - 1; j <= y + 1; j++)
				{
					// 限制对点位置的重复展开调用，使得每一个位置只能向四周展开一次
					if (show[i][j] == '*')
					{
						explode_spread(mine, show, row, col, i, j);
					}
				}
			}
		}
		// 若四周存在地雷则应该在这个位置上标注上地雷的个数
		else
		{
			show[x][y] = count + '0';
		}
	}
}

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/繁依Fanyi0/article/detail/921230

【用C语言轻松实现】- 扫雷【超详细教程】_扫雷怎么生成才能确保通过

一、游戏规则

二、文件的创建

三、初始页面的实现

1、实现主菜单页面

（1）menu()

（2）test()：

（3）main()：

2、在 game.h 中引用所需要的文件和必要的定义

四、棋盘函数的声明、创建和实现（打印棋盘函数同理）

1、声明棋盘的函数（附加打印棋盘函数）

2、棋盘函数的创建 （附加打印功能）

1、为什么要创建两个相同的数组呢？

2、显示 9*9 大小的棋盘，为什么要创建 11*11 大小的棋盘？

3、棋盘函数的实现（附加打印棋盘函数的实现）

（1）布置棋盘（mine）：

（2）展示棋盘（show）：

五、布置地雷

如何实现随机布雷？

六、排查地雷

七、代码整合

1、// test.c

2、// game.c

3、//game.h

八、程序展示

九、改进建议

1、棋盘优化

2、炸金花式展开函数

2、棋盘函数的创建（附加打印功能）

**2、显示 99 大小的棋盘，为什么要创建 1111 大小的棋盘？**