扫雷游戏在C语言的实现

已于 2024-05-26 20:20:13 修改
阅读量1k 收藏 16
点赞数 26
文章标签： 游戏 c语言 算法
于 2024-05-26 19:05:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2303_80894057/article/details/139076004
版权

目录

一   扫雷游戏介绍

二  分析如何运用C语言实现简单扫雷

三   分多个文件进行代码编写

四  扫雷代码的具体实现

五 底层逻辑

六  C语言扫雷游戏的全部代码 

 七 运行结果

 八 制作不易，城谢三联（点赞，收藏，评论）

一   扫雷游戏介绍

扫雷游戏，一款十几年前的经典游戏，他的玩法简单，但比较考验排查能力和计算思维，是一款不错的益智游戏。本篇博客将手把手教会你如何使用C语言程序完成扫雷程序。

首先，说明一下什么是扫雷游戏。见下图：

c4b6a30830124db0bfa9302b93761a06.png

扫雷的核心界面就在这张图上，这个棋盘是9*9，在这个区域里进行扫雷。在这9*9的棋盘上布置雷，接下来就是扫雷，即点击任意一个空格，如果点到雷就炸死了,如下图。

c4d802dae05c4f46898977d43c0b4b84.png

黑色图案的是雷，如果点击到黑色的雷，就炸死了，游戏结束。如果没踩到雷，则会点击空格的部分会显示一个数字，这个数字X的意思是以X为中心，周围的8个坐标有X个雷，如下图：

58809ed92f7b4d3ab8cd4811c779d43a.png

空格显示数字2，则周围8个空格有2个雷。然后重复此操作，将不是雷的位置都找到，则剩下的就是雷了，游戏就结束了。   

想要实现这个程序，首先得布置雷，并且让代码记录下雷的位置。

42de3d37359e407b96d509b189e11d24.png

要布置雷，就先把棋盘定义好。一个九宫格棋盘可用二维数组进行定义（9*9），以此来制作一个C语言的简易扫雷。我们以*表示空格，可以事先将雷安好在棋盘上。

二  分析如何运用C语言实现简单扫雷

因为我们需要在9*9的棋盘上布置雷的信息和排查雷，我们⾸先想到的就是创建⼀个9*9的数组来存放 信息。                                                                                                                                      

b54ed045039f49cea887c27ebbba6ae1.png

那如果这个位置布置雷，我们就存放1，没有布置雷就存放0.

61a66c1dc8c04d71916c5b7747999919.png

假设我们排查(2,5)这个坐标时，我们访问周围的⼀圈8个⻩⾊位置，统计周围雷的个数是1 假设我们排查(8,6)这个坐标时，我们访问周围的⼀圈8个⻩⾊位置，统计周围雷的个数时，最下⾯的三 个坐标就会越界，为了防⽌越界，我们在设计的时候，给数组扩⼤⼀圈，雷还是布置在中间的9*9的坐 标上，周围⼀圈不去布置雷就⾏，这样就解决了越界的问题。所以我们将存放数据的数组创建成11*11 ，如下图所示：

ebc24b8073b04298923a1aea00d7163c.png

再继续分析，我们在棋盘上布置了雷，棋盘上雷的信息（1）和⾮雷的信息（0），假设我们排查了某 ⼀个位置后，这个坐标处不是雷，这个坐标的周围有1个雷，那我们需要将排查出的雷的数量信息记录 存储，并打印出来，作为排雷的重要参考信息的。那这个雷的个数信息存放在哪⾥呢？如果存放在布 置雷的数组中，这样雷的信息和雷的个数信息就可能或产⽣混淆和打印上的困难。 如下图：

7d1ee2fde7904a038e9f6ac922601b7a.png

很显然，中间的0不是雷，但是周围存在1个雷，所以会显示1。那么问题就来了，这个1到底是表示周围有1个雷，还是表示踩到雷的代表数字1了？此时就会产生混淆。这⾥我们肯定有办法解决，⽐如：雷和⾮雷的信息不要使⽤数字，使⽤某些字符就⾏，这样就避免冲 突了，但是这样做棋盘上有雷和⾮雷的信息，还有排查出的雷的个数信息，就⽐较混杂，不够⽅便。如下图：

3de9f100494e4be381a7c83cd030a7d3.png

图中包含信息太多，用#表示没有雷，*表示有雷。与此同时，#与*又不能打印出来，即扫雷游戏肯定不能显示雷在哪。最后打印的是数字   *————雷，#————不是雷，数字————雷的个数，打印数字时还要判断是不是*，#才打印，使用起来非常麻烦，所以也不使用这种方法。

这⾥我们采取这种办法解决，即：雷和⾮雷的信息不要使⽤数字，使⽤某些字符就⾏，这样就避免冲 突了，但是这样做棋盘上有雷和⾮雷的信息，还有排查出的雷的个数信息，就⽐较混杂，不够⽅便。 这⾥我们采⽤另外⼀种⽅案，我们专⻔给⼀个棋盘（对应⼀个数组mine）存放布置好的雷的信息，再 给另外⼀个棋盘（对应另外⼀个数组show）存放排查出的雷的信息。这样就互不⼲扰了，把雷布置到 mine数组，在mine数组中排查雷，排查出的数据存放在show数组，并且打印show数组的信息给后期 排查参考。 同时为了保持神秘，show数组开始时初始化为字符'*'，为了保持两个数组的类型⼀致，可以使⽤同⼀ 套函数处理，mine数组最开始也初始化为字符'0'，布置雷改成'1'。如下图：

92568422bd9b449ba1acb984d8b9967e.png

对应的数组：

1 char mine[11][11] = {0};//⽤来存放布置好的雷的信息

2 char show[11][11] = {0};//⽤来存放排查出的雷的个数信息

三   分多个文件进行代码编写

在企业实际代码的编写中，代码往往不会全在一个源文件上进行编写，而是会分开成多个源文件头文件进行编写，将一整个大程序分成不同个小程序，分别写在不同的文件，这样可以让多个人参与代码的编写，使得效率大大提高，而且也使得代码更加简洁。以VS2022为例：先新建一个源文件。

b86cf2170efe4cb69d1193e9c849dfce.png

然后点击头文件，在右键添加新建项，如下图：

8427f679cb694d9d80732e9af9fa7d5f.png

   将其命名为game.h后添加。

3214c1f7fb5949919ea62632909e262e.png

aa696a36fb2c405c8653d8173fda1ff9.png同理，在源文件中添加一个game.c的源文件。

a308bf0dde394151b31c765466f4096c.png在这三个不同的文件中，可以将扫雷拆分成多个函数，分别放在这三个文件当中，不同文件的函数调用，只需要加个后缀即可，比如在test.h的源文件中，想要调用game.h的函数，则这个test.h中加上头文件#include "game.h"即可。

 #include "game.h"           

如一个简单的求和函数的实现：

ed8f325415d54d8fba72302a9675ca5b.png e5aab00aa7024d128891be530a8dc246.png

#define  _CRT_SECURE_NO_WARNINGS 1

 这个语句放在第一行，目的是让VS2020使用scanf语句不报错，使得scanf语句够能正常使用。

四  扫雷代码的具体实现

三个不同的文件放不同的代码

test.c——整个游戏的逻辑运行

game.h——游戏相关的函数的声明

game.c——游戏相关的函数的实现

在test.h上制作一个简易菜单，用来测试能否进行选择之后进入游戏。

#define  _CRT_SECURE_NO_WARNINGS 1
//本代码文件为test.c//
#include <stdio.h>

void meau()
{
	printf("*******************\n");
	printf("*******************\n");
	printf("**** 1 . play   ***\n");
	printf("**** 2.  exit   ***\n");
	printf("*******************\n");
	printf("*******************\n");
	printf("*******************\n");
}

int main()
{
	int input = 0;
	do
	{
	
		meau();
		printf("请选择:>");
		scanf("%d", &input);
		switch (input)
		{
		case 1 :
			printf("扫雷\n");
				break;
		case 2 :
			printf("退出游戏\n");
					break;
		default :
			printf("选择错误，请重新选择\n");
			break;
		}
	} while (input);


	return 0;
}

运行结果如下：

ea31f3089c744fdea3412a00131bbdd7.png

 主菜单界面就完成了，输入1进入游戏，输入2退出游戏。接下来就是编写扫雷的底层代码，把printf("扫雷")换成 game()函数，由game（）函数完成扫雷游戏的整个过程。由二分析得，需要定义两个字符数组mine和show,mine字符数组用来布置雷的信息，show字符数组用来存放排查出的雷的信息 。

//本文件为test.c//

char mine[11][11];//存放布置好的雷

char show[11][11];//存放排查出的雷的信息                                                                                                                                                         

这里的9*9棋盘，加上外围两行，很显然是11*11，但是如char mine [] 空格里直接写成11，后面的一系列代码都要用到mine [11],如果想要修改11变成12，后续的代码都要修改会非常麻烦，所以不采用这种直接写成11的方式，而是让数组[]空格里的值为变量，然后进行宏定义，这样修改只需要修改宏定义的值就行，不用将所用后续的mine []空格里的值全部修改，非常高效，这也是宏定义的一个重要作用。

#include "game.h"//引用game.h文件里的函数

char mine[ROWS][COLS] = {0};//存放布置好的雷 ,等于0进行数组初始化
char show[ROWS][COLS] = {0};//存放排查出的雷的信息 ,等于0进行数组初始化

再在game.h文件上完成定义，ROW+2表示外围的棋盘。

game.h

#define  _CRT_SECURE_NO_WARNINGS 1
//本代码文件为game.h//
#include <stdio.h>

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

然后将棋盘进行初始化。最开始时，先不布置雷，所以在布置雷的数组中全放0，由于是字符数组，所以放置字符'0',布置雷则放字符'1'即可。另外一个数组，为了保持神秘感，只需要全部打印成*号即可，全部打印成*来还原扫雷游戏开始时全是空格的界面。（没有被排查过的部位全是*号，刚开始没有任何排查，所以全是*号）用一个函数来实现。把数组的数组名，行和列进行传参，再传递一个要初始化的值，即要全部放什么的值（'0'和'*'）在test.c文件进行声明，在game.c文件进行函数的定义。

test.c

//本文件为test,c//

//初始化棋盘 
//1. mine数组最开始是全'0' 
//2. show数组最开始是全'*' 
InitBoard(mine, ROWS, COLS, '0');
InitBoard(show, ROWS, COLS, '*');

#define  _CRT_SECURE_NO_WARNINGS 1
//本代码文件为test.c//
#include <stdio.h>
#include "game.h"//引用自己编写的头文件用双引号""

void meau()
{
	printf("*******************\n");
	printf("*******************\n");
	printf("**** 1 . play   ***\n");
	printf("**** 2.  exit   ***\n");
	printf("*******************\n");
	printf("*******************\n");
	printf("*******************\n");
}
//完成扫雷游戏的整个过程
void game()
{
	char mine[ROWS][COLS];//存放布置好的雷 
	char show[ROWS][COLS];//存放排查出的雷的信息 
	//初始化棋盘 
 //1. mine数组最开始是全'0' 
 //2. show数组最开始是全'*' 
	InitBoard(mine, ROWS, COLS, '0');
	InitBoard(show, ROWS, COLS, '*');



}
int main()
{
	int input = 0;
	do
	{
	
		meau();
		printf("请选择:>");
		scanf("%d", &input);
		switch (input)
		{
		case 1 :
			 game();
				break;
		case 2 :
			printf("退出游戏\n");
					break;
		default :
			printf("选择错误，请重新选择\n");
			break;
		}
	} while (input);


	return 0;
}

game.c

#define  _CRT_SECURE_NO_WARNINGS 1
//本代码文件为game.c//
#include "game.h"
void InitBoard(char board[ROWS][COLS], int rows, int cols, char set)
{
	int i = 0;
	for (i = 0; i < rows; i++)
	{
		int j = 0;
		for (j = 0; j < cols; j++)
		{
			board[i][j] = set;//set为自己想要全部换成的字符，这里为
			//'*'号或字符'0'
		}

	}
}

初始化的值已经赋好，接下来就是打印出整个扫雷游戏的棋盘，这里虽然定义了11*11的棋盘，但是显示出来的是9*9，多出来的2行是为了解决越界问题，并不会显示，所以不打印。因为mine数组是用来布置雷的，而show数组是用来显示雷的信息，即呈现在玩家视野的，所以打印字符数组show，不打印字符数组mine.在打印时最好把行的数字和列的数字也一并打印了，呈现的效果如下图：

50811da575cd4d0e8c7a4fb4240406f5.png

所以额外加个打印的循环语句。

声明函数

//本代码文件为test.c//

//打印棋盘 //

DisplayBoard(show, ROW, COL);

定义函数

#define  _CRT_SECURE_NO_WARNINGS 1
//本代码文件为game.c//
#include "game.h"
void InitBoard(char board[ROWS][COLS], int rows, int cols, char set)
{
	int i = 0;
	for (i = 0; i < rows; i++)
	{
		int j = 0;
		for (j = 0; j < cols; j++)
		{
			board[i][j] = set;//set为自己想要全部换成的字符，这里为
			//'*'号或字符'0'
		}

	}
}
void DisplayBoard(char board[ROWS][COLS], int row, int col)
{
//打印行数和列数
	int i = 0;
	printf("--------扫雷游戏-------\n");
	for (i = 0; i <= col; i++)
	{
		printf("%d ", i);
	}
//到这结束打印行数和列数
	printf("\n");
	for (i = 1; i <= row; i++)
	{
		printf("%d ", i);
		int j = 0;
		for (j = 1; j <= col; j++)
		{
			printf("%c ", board[i][j]);
		}
		printf("\n");//打印完一行之后换行再继续打印
	}
}

运行结果：

46524cbc66554998a18d94b2f89575ef.png

因为这时没有布置雷，如果把雷全部打印出来（实际不打印，只是为了检查是否有问题），则全是0（字符'0'表示没有雷，字符'1'表示有雷）

//打印棋盘 
DisplayBoard(mine, ROW, COL);//上帝视角把雷全部打印出来
DisplayBoard(show, ROW, COL);//打印棋盘 

9ef4d5bf2ce54dd6a4706e7da9d9cdbc.png 然后进行布置雷的操作，编写布置雷的函数SetMine。因为雷是布置到mine数组上，所以把mine传进函数，又因为雷也是在9*9棋盘上布置，所以用ROW，COL进行传参。

//test.c文件

SetMine(mine, ROW, COL);//此代码为使用SetMine函数，mine为实参数组名，ROW,COL也均为实参

//DisplayBoard(mine, ROW, COL);当布置好雷之后，取消此行代码的注解，让此行代码运行，以上帝视角用来检验雷的布置效果

 定义函数时，这里用board作为形参数值组名，小写字母row,col作为形参。然后布置雷的个数，用EASY_COUNT表示雷，9*9的棋盘采用10个雷布置下去，但为了方便修改，依旧采用宏定义的方式。宏定义均放在game.h文件当中。

#define EASY_COUNT 10

 由于我们多定义了两行的缘故，所以数组下标与行列数完全重合了。

f8f12bea32ae46bba4cea9602713e62b.png

所以行1~9，列1~9。雷是随机分布的，所以要产生随机数来作为数组坐标。用rand产生随机数（具体如何实现的请见博主主页的猜数字游戏），rand%9产生0~8的数，则rand%9 +1产生1~9的随机数 。又用的是row = 9,同样为了后续修改雷的个数，用rand()%row +1来布置雷。要生成完全随机数，用代码srand。

本代码文件为test.h

int main()
{
    int input = 0;
    srand((unsigned int)time(NULL));
 

然后使用此库函数需要头文件#include <stdlib.h> 和#include<time.h>

本代码文件为game.h

#include <stdlib.h>

#include<time.h>

如此雷就布置好了 ，然后取消代码//DisplayBoard(mine, ROW, COL);的注解，检验雷的布置效果。

91e055ae57374884ac61d75c41395fd3.png

雷布置好了，接下来就是排查雷。在第一个数组mine进行排查之后，将排查结果放到第二个数组show里。涉及两个数组，则传递两个数组形参。但这两个数组操作的都是9*9的棋盘，所以传递ROW和COL两个实参。

本代码文件为test.c

FindMine(mine, show, ROW, COL);

然后在game文件里进行函数定义。排查过程不会一下就排查完，所以用循环语句进行排查。 

​
本代码文件为game.c
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{
	int x = 0;//x为行的坐标
	int y = 0;//y为列的坐标
	int win = 0;
	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
			{
				//该位置不是雷，就统计这个坐标周围有⼏个雷 
				int count = GetMineCount(mine, x, y);
				show[x][y] = count + '0';
				DisplayBoard(show, ROW, COL);//展示出九宫格周围有几个雷
				win++;//win来统计玩家目前排查出的不是雷的个数
	          
			}
		}
		else//如果不在范围内，则给出提示，让玩家重新输入
		{
			printf("坐标⾮法，重新输⼊\n");
		}
	}
	if (win == row * col - EASY_COUNT)//当玩家排查出的不是雷的个数等于
		//整个游戏内所有不是雷的个数时，那么剩下的就全是雷，扫雷成功
		//游戏成功并游戏结束
	{
		printf("恭喜你，排雷成功\n");
		DisplayBoard(mine, ROW, COL);
	}
}

​

最后需要解决的是当玩家输入坐标，且该坐标不是雷时，如何给出周围有几个雷的个数的反馈，即统计mine数组的x,y坐标周围8个坐标中有几个雷。 如周维有2个雷，则给出2，3个雷，则给出3.这里用GetMineCount(mine, x, y);函数来实现。

前面我们一直坚持用1表示雷，用0表示没用雷。好处在这个函数的处理就很明显了，周围有几个雷，那就显示数字几。因为1表示雷，若周围3个雷，则周围有3个1，加起来就等1于3，于是输出数字3即可。

 但是mine是字符数字，最开始放的不是数字1或0而是字符'1'或'0',所以我们需要将字符'0'或字符'1'变成数字0或数字1，用ASCII码值可以实现。字符'0'的ASCII码值为48，字符'1'为49，字符2为50 。  字符'2'的ASCII码值 —字符'0'的 ASCII码值 == 2；字符 '1'的ASCII码值 —字符'0'的 ASCII码值 == 1；所字符以转换为数字很简单，只需要 字符'x'  —字符'0' 就转换成了数字。所以先让九宫格周围8个字符相加，再减去8个字符'0'即可。即八个字符之和—8 * '0'。x，y为中心，九宫格周围8个字符它们对应的坐标如下图：

a5305c272e284f1c9dae5ca629d76c2c.png

具体代码如下：

本代码文件为game.h
此块函数放再FindMine之前
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][y1] + mine[x + 1][y] +

		mine[x + 1][y + 1] + mine[x][y + 1] + mine[x - 1][y + 1] - 8 * '0');
}

游戏的程序已经基本完成。

然后进行测试 ，取消代码//DisplayBoard(mine, ROW, COL);的注解，检验排查的显示效果。

29543c63269646d1b6c942c413c0ddfa.png

可以看到在原来的位置上*变成了1。

但是如果坐标合法，某个位置不是雷也得显示排查过没，所以再加上语句

本代码文件为game.h

if(show[x][y] != '*' )

{

printf("该坐标已排查过，无需再排查");

}


本代码文件为game.c
else
{
	if (show[x][y] != '*')

	{

		printf("该坐标已排查过，无需再排查\n");

	}
	else
	{
		//该位置不是雷，就统计这个坐标周围有⼏个雷 
		int count = GetMineCount(mine, x, y);
		show[x][y] = count + '0';
		DisplayBoard(show, ROW, COL);//展示出九宫格周围有几个雷
		win++;//win来统计玩家目前排查出的不是雷的个数
	}
}

​

 我们在校准时,看游戏是否能正常结束。先把雷让它打印出来，然后对着雷进行排查，把不是雷的坐标排查完后通过。但是这样校准需要输入71个坐标，所以换种方式进行校准。

快速测试：将雷设置为80，并打印雷

#define EASY_COUNT 80

8a07260250f546459ddfd358930e89e1.png

游戏能正常结束，此时就校准完成了。用上帝视角照着雷的位置进行排雷。

再把打印雷的代码关掉（标上注解）。此时扫雷就基本完成了

15f4769b16f64aeaa4f36d0bb0d36871.png

五 底层逻辑

将所有运用到的函数名定义到复制到game.h文件上，扫雷的底层代码逻辑就很清晰可见了。它1由不同的函数分别实现不同的功能，然后汇在一起完了扫雷。

​
本代码文件为game.h
#define  _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define EASY_COUNT 10//雷的个数
#define ROW 9//扫雷棋盘的行
#define COL 9//扫雷棋盘的列
#define ROWS ROW+2//扫雷棋盘的外围的两行，防止坐标越界
#define COLS COL+2//扫雷棋盘的外围的两列，防止坐标越界
//初始化棋盘 
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);

六  C语言扫雷游戏的全部代码 

真正运行，为了简易，可将雷的个数根据自己喜好来修改

本代码文件为game.h

#define EASY_COUNT 10

game.h

#define  _CRT_SECURE_NO_WARNINGS 1
//本代码文件为game.h//
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define EASY_COUNT 10
#define ROW 9
#define COL 9
#define ROWS ROW+2
#define COLS COL+2
//初始化棋盘 
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);

game.c

#define  _CRT_SECURE_NO_WARNINGS 1
//本代码文件为game.c//
#include "game.h"
#include <stdlib.h>
#include<time.h>
void InitBoard(char board[ROWS][COLS], int rows, int cols, char set)
{
	int i = 0;
	for (i = 0; i < rows; i++)
	{
		int j = 0;
		for (j = 0; j < cols; j++)
		{
			board[i][j] = set;//set为自己想要全部换成的字符，这里为
			//'*'号或字符'0'
		}

	}
}
void DisplayBoard(char board[ROWS][COLS], int row, int col)
{
	//打印行号和列号
	int i = 0;
	printf("--------扫雷游戏-------\n");
	for (i = 0; i <= col; i++)
	{
		printf("%d ", i);
	}
	printf("\n");
	//结束打印
	for (i = 1; i <= row; i++)
	{
		printf("%d ", i);
		int j = 0;
		for (j = 1; j <= col; j++)
		{
			printf("%c ", board[i][j]);
		}
		printf("\n");//打印完一行之后换行再继续打印
	}
}

void SetMine(char board[ROWS][COLS], int row, int col)
{
	//布置10个雷 
	//?成随机的坐标，布置雷 
	int count = EASY_COUNT;
	while (count)
	{
		int x = rand() % row + 1;
		int y = rand() % col + 1;
		if (board[x][y] == '0')//当这个位置不是雷时，进行布置
		{
			board[x][y] = '1';//'0'表示不是雷，'1'表示雷
			count--;//成功布置雷后，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');
}
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{
	int x = 0;//x为行的坐标
	int y = 0;//y为列的坐标
	int win = 0;
	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
			{
				if (show[x][y] != '*')

				{

					printf("该坐标已排查过，无需再排查\n");

				}
				else
				{
					//该位置不是雷，就统计这个坐标周围有?个雷 
					int count = GetMineCount(mine, x, y);
					show[x][y] = count + '0';
					DisplayBoard(show, ROW, COL);//展示出九宫格周围有几个雷
					win++;//win来统计玩家目前排查出的不是雷的个数
				}
			}
		}
		else//如果不在范围内，则给出提示，让玩家重新输入
		{
			printf("坐标不合法，请重新输入\n");
		}
	}
	if (win == row * col - EASY_COUNT)//当玩家排查出的不是雷的个数等于
		//整个游戏内所有不是雷的个数时，那么剩下的就全是雷，扫雷成功
		//游戏成功并游戏结束
	{
		printf("恭喜你，排雷成功\n");
		DisplayBoard(mine, ROW, COL);
	}
}

 test.c

#define  _CRT_SECURE_NO_WARNINGS 1
//本代码文件为test.c//
#include <stdio.h>
#include "game.h"//引用自己编写的头文件用双引号""

void meau()
{
	printf("*******************\n");
	printf("*******************\n");
	printf("**** 1 . play   ***\n");
	printf("**** 2.  exit   ***\n");
	printf("*******************\n");
	printf("*******************\n");
	printf("*******************\n");
}
//完成扫雷游戏的整个过程
void game()
{
	char mine[ROWS][COLS];//存放布置好的雷 
	char show[ROWS][COLS];//存放排查出的雷的信息 
	//初始化棋盘 
 //1. mine数组最开始是全'0' 
 //2. show数组最开始是全'*' 
	InitBoard(mine, ROWS, COLS, '0');
	InitBoard(show, ROWS, COLS, '*');
	//打印棋盘 
 //DisplayBoard(mine, ROW, COL);//上帝视角把雷全部打印出来
	DisplayBoard(show, ROW, COL);//打印棋盘 
	//1. 布置雷 
	SetMine(mine,ROW,COL);
	//DisplayBoard(mine, ROW, COL);
	//2. 排查雷 
	FindMine(mine, show, ROW, COL);

}
int main()
{
	int input = 0;
	srand((unsigned int)time(NULL));

	do
	{
	
		meau();
		printf("请选择:>");
		scanf("%d", &input);
		switch (input)
		{
		case 1 :
			 game();
				break;
		case 2 :
			printf("退出游戏\n");
					break;
		default :
			printf("选择错误，请重新选择\n");
			break;
		}
	} while (input);


	return 0;
}

 七 运行结果

横行竖列，在进行游戏时，先输入的是行x,然后空格 ，再输y

x（行的坐标）   y（列的坐标）enter（运行）

6de079c3663f48d780b040df8186b238.png

 八 制作不易，诚谢三联（点赞，关注，评论）

最后扫雷游戏游戏网页版如下:

http://www.minesweeper.cn/

一座矿山
关注
C语言实现扫雷 附带源代码
暴躁小吕的博客
08-04 3561
C语言实现扫雷小游戏 附带源代码 包教包会
扫雷源代码
weixin_44502312的博客
01-23 4852
import java.awt.BorderLayout; import java.awt.Container; import java.awt.Font; import java.awt.GridLayout; import java.awt.Insets; import java.awt.event.ActionEvent; import java.awt.event.ActionListen...
C语言实现扫雷完整算法详解~（附完整代码~）
热门推荐
weixin_51669924的博客
05-07 1万+
扫雷是一个常见小游戏，那么如何用C语言实现扫雷呢？学习了二维数组之后，我们可将扫雷的网格区域存储为二维数组，从而使用C语言实现扫雷。 目录 1.算法基本思路 2.算法详解 1.初始化数组与打印数组 2.设置雷 3.排查与标记 4.CountMine函数计算周围雷的个数 5.ExpandMine函数递归展开周围所有安全区域 3.完整代码！！！ 1.test.c源文件 2.game.h头文件 3.game.c源文件 完结撒花！！！ 1.算法基本思路 首先，用一个二维数组存.
扫雷游戏（C语言实现）
2301_77282627的博客
05-12 1096
游戏还有一点需要改进，当被查看位置不是雷，且它周围的八个坐标也不是雷，应该展开可以使用递归，等后续我自己验证了，再进行更新。
扫雷游戏——C语言实现
2301_80029060的博客
09-07 525
扫雷游戏的C语言实现，我看看怎么事儿！
C语言基础：扫雷游戏的C语言实现（超详图解+源码）
linsc_05的博客
08-01 7617
友友们好，今天和大家一起做一个简单的——扫雷小游戏。如下：扫雷的规则很简单。盘面上有许多方格，方格中随机分布着一些雷。你的目标是避开雷，打开其他所有格子。一个非雷格中的数字表示其相邻8格中的雷数，你可以利用这个信息推导出安全格和雷的位置。打开所有安全格将被判定为胜利，打开雷将被判定为失败。
扫雷游戏【C语言实现】
d123458rh的博客
01-21 351
目录 前言： 一：扫雷游戏规则介绍 二：进行环境配置 三：编写思路 四：实现各种功能并处理逻辑关系 4.1主函数部分 4.1-1打印菜单 4.1-2选择是否继续游戏 4.2游戏函数部分 4.2-1定义数组部分 4.2-2初始化棋盘函数 4.2-3打印棋盘函数 4.2-4布置雷函数 4.2-5排查雷函数 五：各文件中所有代码 5.1 test.c文件中代码
详解C语言实现扫雷游戏
weixin_73053512的博客
05-13 2182
优点实现了扫雷函数的大部分功能，比如展开，标记，清除标记等等。游戏难度没办法由玩家手动设置，扫雷过程中标记和清除标记的顺序比较固定，这些交由读者来完善~
c语言编程模拟扫雷游戏,C语言实现简单扫雷游戏
weixin_29050829的博客
05-18 439
本文实例为大家分享了C语言实现简单扫雷游戏的具体代码，供大家参考，具体内容如下步骤1.首先打印游戏选择菜单2.地图及初始化1)、展示给玩家的地图(show_map)2)、地雷的图(mine_map可知地雷的位置)3.打印地图4.用户输入坐标，并检查坐标的合理性5.判断当前位置是否有地雷，没有则出现数字(表示周围格子中有几个地雷)6.打印新的地图7.重复3~6步骤，直到踩雷游戏结束，或胜利。8重新继...
C语言实现简单扫雷小游戏
01-01
本文实例为大家分享了C语言实现扫雷小游戏的具体代码，供大家参考，具体内容如下 #define _CRT_SECURE_NO_WARNINGS #include #include #include /* 用 C 语言写一个简单的扫雷游戏 */ // 1.写一个游戏菜单 Menu...
扫雷游戏的c语言实现
04-26
经典游戏扫雷的c语言实现，有初级和高级两种难度，可以标记地雷，查验地雷，初级关10个地雷，高级关40个地雷，雷盘随机生成
C语言结合Easyx库实现扫雷小游戏
03-26
本项目以“扫雷”为蓝本，利用C语言结合Easyx图形库来实现一个可视化的扫雷游戏。本文将深入探讨这个项目的核心知识点，包括C语言基础、Easyx库的使用以及游戏逻辑的设计。 首先，C语言是程序设计的基础，它以其...
C语言实现扫雷游戏及其优化
08-25
C语言实现扫雷游戏及其优化 本文将详细介绍C语言实现扫雷游戏及其优化，具体包括游戏的设计思想、实现代码和优化方法。 游戏设计思想 扫雷游戏的设计思想是使用两个二维数组，一个用于显示，一个用于后台雷的布置...
C语言实现扫雷小游戏(扩展版可选择游戏难度)
12-31
扫雷，是一款益智类小游戏。 游戏目标是找出所有没有地雷的方格，完成游戏；要是按了有地雷的方格，游戏失败；玩家可标记雷的位置。游戏以完成时间来评高低。有不同的游戏难度可选择。 实现的功能介绍 1.计时 2....
JS 实现游戏流畅移动与按键立即响应
最新发布
a1309602336的博客
11-14 123
【代码】JS 实现游戏流畅移动与按键立即响应。
Unity3D 帧同步定点数物理引擎解决方案详解
Thomas_YXQ的博客
11-11 814
在Unity3D开发中，帧同步技术对于实现多人在线游戏至关重要，它能确保所有玩家在同一时间看到相同的游戏状态。帧同步定点数物理引擎解决方案是这一技术的重要组成部分，它通过结合定点数和物理引擎计算，来确保不同客户端之间游戏状态的精确同步。对惹，这里有一个游戏开发交流小组，希望大家可以点击进来一起交流一下开发经验呀！
Unity常见问题合集（一）
我与岁月的森林的博客
11-10 263
Unity常见问题合集（一）
【日志】Unity——Roll-A-Ball（二）
wacanda的博客
11-13 326
是的这个发现就在这里，正常的玩家应该是按照R星设置的游戏流程开始赚$，但是呢，我发现大部分玩家都在想着快速赚$，省去这些重复且又枯燥前置步骤。我在想，是啊，通过正常手段来赚$可是要玩好久的，假设用铁人三项来赚$（平均每次1W的话），来购买一个游戏中赚$效率最高的虎鲸资产（220W）。不过关说赚$似乎差点意思，我在其中感觉感受到的自由，不仅是因为这个游戏想做什么就做什么，而是我可以不服就干，什么道德与发直都没法约束我。是的，没错，有钱的就是大佬，他想带你赚$，那可是比你自己去赚$可更多更快。
[AI] 从游戏到现实：强化学习的应用与挑战
每日出拳老爷子的博客
11-13 105
强化学习作为一种通过奖励机制引导智能体自主学习的技术，在游戏中已展现出巨大的潜力。其核心在于通过状态、动作和奖励的交互关系，实现智能体在特定环境中的策略优化。然而，RL在现实世界应用中仍面临跨域迁移的挑战，尤其是当环境复杂度提高时，模拟学习的局限性愈加明显。尽管如此，随着技术的进步，RL在机器人、自动驾驶、金融市场等领域依然拥有广阔前景。未来，通过不断改进算法和优化智能体的适应性，强化学习或将实现其在现实世界中的更大突破。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值