C语言实现扫雷

~小明学编程

已于 2022-07-28 15:05:28 修改

阅读量2.9k

点赞数 15

分类专栏： C语言基础知识文章标签： c语言开发语言

于 2022-07-04 08:00:00 首次发布

本文链接：https://blog.csdn.net/m0_56911284/article/details/125565111

版权

C语言基础知识专栏收录该内容

25 篇文章 4 订阅

订阅专栏

程序运行效果

话不多说先给大家看代码的运行效果然后再介绍实现过程，不想看实现过程可以直接看最后的源码

首先是进入界面，我们可以选择是否继续游戏，接着选择难度选项。

接下来我们就开始扫雷

我们采用的是输入指定的坐标开始扫雷

下面是扫雷的过程

接着是我们的异常输入的处理，当输入重复坐标或者坐标不合理我们会予以提醒并且重新输入

当我们扫雷成功时会提醒，并且是否继续游戏

实现过程

主函数

我们的主函数只装了个test()测试函数

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

然后就是test()函数，test()函数里面是主要的控制流程，控制我们游戏的循环进行，还包括menu打印游戏的菜单。

void test()
{
	srand((unsigned int)time(NULL));
	int input = 0;
	do 
	{
		menu();
		printf("请输入选项：\n");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			//printf("开始游戏\n");
			game();
			break;
		case 0:
			printf("退出游戏！\n");
			break;
		default:
			printf("您的输入有误，请重新输入！\n");
			break;

		}
	} while (input);
}

void menu()
{
	printf("********欢迎进入扫雷游戏*********\n");
	printf("********     1.play     *********\n");
	printf("********     0.exit     *********\n");
	printf("*********************************\n");

}

游戏函数

这里是我们所用到的头文件和定义的常量

#include<stdio.h>
#define ROW 9
#define COL 9
#define ROWS ROW+2
#define COLS COL+2
#include<time.h>
#include<stdlib.h>
#include<string.h>

当我们选择play时就进入了我们的game函数了，game()函数中就是游戏的主要实现过程

void game()
{
	//布置好的雷的信息
	char mine[ROWS][COLS] = { 0 };
	//排查出的雷的信息
	char show[ROWS][COLS] = { 0 };
	//初始化棋盘
	InitBoard(mine, ROWS, COLS,'0');
	InitBoard(show, ROWS, COLS, '*');
	//打印棋盘
	//DisplayBoard(mine, ROW, COL);
	//布置雷
	SetMine(mine, ROW, COL);
	DisplayBoard(show, ROW, COL);
	//排查雷
	FindMine(mine, show, ROW, COL);

}

棋盘初始化函数

首先我们定义两个字符型数组，一个是我们存放雷的数组也就是mine数组，一个是展示给用户看的数组show,然后我们通过InitBoard函数对数组进行初始化

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

函数实现如上所示就是通过嵌套两个简单的for循环，对数组逐一赋值，当数组初始化完之后我们就可以开始我们的布置雷操作了。

布雷函数

void SetMine(char board[ROWS][COLS], int row, int col)
{

    int count1 = DifGrade();//布置雷的数量
	count = count1;//记录雷的数量
	while (count1)
	{
		int x = rand() % row + 1, y = rand() % col + 1;
		if (board[x][y] == '0')
		{
			board[x][y] = '1';
			count1--;//每布置一个雷就减少1
		}
	}
}

布置雷的函数主要就是通过DifGrade（）函数首先获取雷的数量，然后通过生成随机数分别对x,y进行赋值，最终把随机坐标赋上字符1，也就是我们的雷。这里我们再简单的介绍一下我们的DifGrade（）函数。

难度等级函数

//困难等级函数
int DifGrade()
{
	printf("请选择难度等级（简单，中等，困难）：\n");
	char grade[20] = { 0 };
	while (1)
	{
		scanf("%s", grade);
		if (0 == strcmp("简单",grade))
			return 10;	
		else if (0 == strcmp("中等",grade))
			return 20;
		else if (0 == strcmp("困难",grade))
			return 40;
		else
			printf("输入有误，请重新输入！\n");
		
	}
	

}

实现原理就是用过字符串的匹配返回相应的数字，该数字作为雷的数量。

布置完成之后我们可以通过函数将其打印出来

打印函数

void DisplayBoard(char board[ROWS][COLS], int row, int col)
{
	printf("  ");
	for (int i = 1; i <= row; i++)
	{
		printf("%d ", i);
	}
	printf("\n");
	for (int i = 1; i <= row; i++)
	{
		printf("%d ", i);
		for (int j = 1; j <= col; j++)
		{
			printf("%c ", board[i][j]);
		}
		printf("\n");
	}
}

实现原理就是通过两个for()循环遍历传入的二维数组然后将其每个元素都给打印出来

打印结果如下

打印完之后接着就是开始我们的扫雷了

扫雷函数

void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{
	int x = 0, y = 0, win = row * col;
	while (count < win)
	{
		printf("请输入要排查雷的坐标：\n");

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

		if (x >= 1 && x <= 9 && y >= 1 && y <= 9)
		{
			if (show[x][y] != '*')
			{
				printf("该地方已经排查过，请重新输入坐标！\n");
				continue;
			}
			else
			{
				//踩到雷了
				if (mine[x][y] == '1')
				{
					printf("很遗憾，您踩到雷了，游戏结束！\n");
					DisplayBoard(mine, ROW, COL);
					break;
				}
				//不是雷
				else
				{

					SearchBlock(mine, show, x, y);
					DisplayBoard(show, ROW, COL);
					win = JudgeWin(show, ROW, COL);

				}
			}

		}
		else
		{
			printf("坐标非法，请重新输入！\n");
		}
		if (count == win)
		{
			printf("扫雷成功，恭喜您获得胜利！\n");
		}
	}
}

函数实现原理

递归雷区函数

首先定义坐标，并且从键盘获取数字，然后就是异常处理判断我们的数字是否合法，接着就是判断我们是否踩雷了，如果没有进入我们的判断四周雷数的函数并且以此递归下去。

void SearchBlock(char mine[ROWS][COLS], char show[ROWS][COLS], int x, int y)
{
	if (show[x][y] == '*')//判断当前位置是否已经赋值
	{
		int counts = get_mine_count(mine, x, y);//统计八个方位雷数量之和
		if (counts != 0)
		{
			show[x][y] = counts + '0';//赋值字符雷数
		}
		else
		{
			//若四周雷的数量为0则给其赋值空格并递归下去继续搜索四周
			if ((x > 0 && x <= ROW) && (y > 0 && y <= COL))
				//避免递归从最外围到达不必要的位置造成显示额外空白
			{
				show[x][y] = counts + ' ';
				SearchBlock(mine, show, x, y + 1);
				SearchBlock(mine, show, x, y - 1);
				SearchBlock(mine, show, x + 1, y);
				SearchBlock(mine, show, x - 1, y);
				SearchBlock(mine, show, x + 1, y + 1);
				SearchBlock(mine, show, x + 1, y - 1);
				SearchBlock(mine, show, x - 1, y + 1);
				SearchBlock(mine, show, x - 1, y - 1);
			}
			


		}
	}
	

}

get_mine_count(mine, x, y)函数可以直接返回我们的雷数之和

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

实现原理比较简单就直接返回八个方位的字符数量之和，然后减去8个字符0

然后继续打印一下我们的棋盘

判断输赢函数

接着就是判断输赢，判断游戏是否继续

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

通过搜索字符 '*' 我们首先默认所有位置都是雷将此值赋给win当win的值也就是仅剩的雷与count的值相等时此时棋盘所剩下的就都是雷了，此时玩家获得胜利。

源代码

头文件game.h

#pragma once
#include<stdio.h>
#define ROW 9
#define COL 9
#define ROWS ROW+2
#define COLS COL+2
#include<time.h>
#include<stdlib.h>
#include<string.h>
extern int count;//引用外部变量
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);
int DifGrade();
int get_mine_count(char mine[ROWS][COLS],int x,int y);
void SearchBlock(char mine[ROWS][COLS], char show[ROWS][COLS], int x, int y);
int JudgeWin(char show[ROW][COL], int row, int col);

测试文件test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "game.h"
int count = 0;//全局变量
void game()
{
	//布置好的雷的信息
	char mine[ROWS][COLS] = { 0 };
	//排查出的雷的信息
	char show[ROWS][COLS] = { 0 };
	//初始化棋盘
	InitBoard(mine, ROWS, COLS,'0');
	InitBoard(show, ROWS, COLS, '*');
	//打印棋盘
	//DisplayBoard(mine, ROW, COL);
	//布置雷
	SetMine(mine, ROW, COL);
	DisplayBoard(show, ROW, COL);
	//DisplayBoard(mine, ROW, COL);
	FindMine(mine, show, ROW, COL);

}
void menu()
{
	printf("********欢迎进入扫雷游戏*********\n");
	printf("********     1.play     *********\n");
	printf("********     0.exit     *********\n");
	printf("*********************************\n");

}
void test()
{
	srand((unsigned int)time(NULL));
	int input = 0;
	do 
	{
		menu();
		printf("请输入选项：\n");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			//printf("开始游戏\n");
			game();
			break;
		case 0:
			printf("退出游戏！\n");
			break;
		default:
			printf("您的输入有误，请重新输入！\n");
			break;

		}
	} while (input);
}

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

函数实现文件game.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "game.h"
void InitBoard(char board[ROWS][COLS], int rows, int cols,char set)
{
	for (int i = 0; i < rows; i++)
	{
		for (int j=0; j < cols; j++)
		{
			board[i][j] = set;
		}
	}
}
//打印棋盘
void DisplayBoard(char board[ROWS][COLS], int row, int col)
{
	printf("  ");
	for (int i = 1; i <= row; i++)
	{
		printf("%d ", i);
	}
	printf("\n");
	for (int i = 1; i <= row; i++)
	{
		printf("%d ", i);
		for (int j = 1; j <= col; j++)
		{
			printf("%c ", board[i][j]);
		}
		printf("\n");
	}
}

void SetMine(char board[ROWS][COLS], int row, int col)
{


    int count1 = DifGrade();//布置雷的数量
	count = count1;
	while (count1)
	{
		int x = rand() % row + 1, y = rand() % col + 1;
		if (board[x][y] == '0')
		{
			board[x][y] = '1';
			count1--;
		}
	}
}
//困难等级函数
int DifGrade()
{
	printf("请选择难度等级（简单，中等，困难）：\n");
	char grade[20] = { 0 };
	while (1)
	{
		scanf("%s", grade);
		if (0 == strcmp("简单",grade))
			return 10;	
		else if (0 == strcmp("中等",grade))
			return 20;
		else if (0 == strcmp("困难",grade))
			return 40;
		else
			printf("输入有误，请重新输入！\n");
		
	}
	

}
int get_mine_count(char mine[ROWS][COLS], int x, int y)
{
	return mine[x - 1][y] +
		mine[x + 1][y] +
		mine[x][y - 1] +
		mine[x][y + 1] +
		mine[x - 1][y - 1] +
		mine[x - 1][y + 1] +
		mine[x + 1][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, y = 0, win = row * col;//棋盘格数
	while (count < win)
	{
		printf("请输入要排查雷的坐标：\n");

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

		if (x >= 1 && x <= 9 && y >= 1 && y <= 9)
		{
			if (show[x][y] != '*')
			{
				printf("该地方已经排查过，请重新输入坐标！\n");
				continue;
			}
			else
			{
				//踩到雷了
				if (mine[x][y] == '1')
				{
					printf("很遗憾，您踩到雷了，游戏结束！\n");
					DisplayBoard(mine, ROW, COL);
					break;
				}
				//不是雷
				else
				{

					SearchBlock(mine, show, x, y);
					DisplayBoard(show, ROW, COL);
					win = JudgeWin(show, ROW, COL);

				}
			}

		}
		else
		{
			printf("坐标非法，请重新输入！\n");
		}
		if (count == win)
		{
			printf("扫雷成功，恭喜您获得胜利！\n");
		}
	}
}
	

void SearchBlock(char mine[ROWS][COLS], char show[ROWS][COLS], int x, int y)
{
	if (show[x][y] == '*')//判断当前位置是否已经赋值
	{
		int counts = get_mine_count(mine, x, y);//统计八个方位雷数量之和
		if (counts != 0)
		{
			show[x][y] = counts + '0';//赋值字符雷数
		}
		else
		{
			//若四周雷的数量为0则给其赋值空格并递归下去继续搜索四周
			if ((x > 0 && x <= ROW) && (y > 0 && y <= COL))
				//避免递归从最外围到达不必要的位置造成显示额外空白
			{
				show[x][y] = counts + ' ';
				SearchBlock(mine, show, x, y + 1);
				SearchBlock(mine, show, x, y - 1);
				SearchBlock(mine, show, x + 1, y);
				SearchBlock(mine, show, x - 1, y);
				SearchBlock(mine, show, x + 1, y + 1);
				SearchBlock(mine, show, x + 1, y - 1);
				SearchBlock(mine, show, x - 1, y + 1);
				SearchBlock(mine, show, x - 1, y - 1);
			}
			


		}
	}
	

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

以上就是C语言实现扫雷游戏的过程，如有疑问欢迎私信，感谢支持哈！

游戏中遇到的bug以及解决方法

问题描述

这里我们可以看到在我们输入3 9坐标之后游戏给我们打开了三块空白区域

按理说我们玩扫雷时只会打开第一块空白，但为什么会给我们多打开了两块空白区域呢

接着我们来分析一下我们原来代码中出现的bug

在我们程序进入这个位置的时候我们默认x和y的值是1~9但是x和y实际的取值范围是0~10这就导致了我们的递归从0或者10的行列影响到其它位置

也就是从我们的1号区域通过上面的空白区域递归到我们的2号区域以及3号区域

解决方案

void SearchBlock(char mine[ROWS][COLS], char show[ROWS][COLS], int x, int y)
{
	if (show[x][y] == '*')//判断当前位置是否已经赋值
	{
		int counts = get_mine_count(mine, x, y);//统计八个方位雷数量之和
		if (counts != 0)
		{
			show[x][y] = counts + '0';//赋值字符雷数
		}
		else
		{
			//若四周雷的数量为0则给其赋值空格并递归下去继续搜索四周
			if ((x > 0 && x <= ROW) && (y > 0 && y <= COL))
				//避免递归从最外围到达不必要的位置造成显示额外空白
			{
				show[x][y] = counts + ' ';
				SearchBlock(mine, show, x, y + 1);
				SearchBlock(mine, show, x, y - 1);
				SearchBlock(mine, show, x + 1, y);
				SearchBlock(mine, show, x - 1, y);
				SearchBlock(mine, show, x + 1, y + 1);
				SearchBlock(mine, show, x + 1, y - 1);
				SearchBlock(mine, show, x - 1, y + 1);
				SearchBlock(mine, show, x - 1, y - 1);
			}
			


		}
	}
	

}

这里我们可以看到，通过加了一个if语句判断一下我们x,y的值当我们x,y的值是0或者10的时候我们直接跳过，这样就很好的解决了此bug。