C语言实现扫雷游戏(含有完整代码,小白也能轻松看懂)

C++忠实粉丝

已于 2024-05-03 18:35:23 修改

阅读量1k

点赞数 43

分类专栏： C语言学习文章标签：游戏 c语言开发语言

于 2024-05-03 18:33:27 首次发布

本文链接：https://blog.csdn.net/wer24_25/article/details/138402271

版权

C语言学习专栏收录该内容

15 篇文章 0 订阅

订阅专栏

引言

扫雷这款游戏想必大家都游玩过,界面是一个方格,我们每走一个地方,就会显示周围雷的数量,走到雷的位置,游戏就结束了.如下图所示:

大家可以先去这个网页版的扫雷游戏体验一下--在线扫雷游戏：http://www.minesweeper.cn/

今天我就用C语言来实现这么一个简单的游戏,后面会有这个游戏的详细代码,点赞关注我们直接开始

1. 扫雷游戏分析和设计

1.1 扫雷游戏的功能说明

• 使⽤控制台实现经典的扫雷游戏

• 游戏可以通过菜单实现继续玩或者退出游戏

• 扫雷的棋盘是9*9的格⼦ •

默认随机布置10个雷

• 可以排查雷

◦ 如果位置不是雷，就显⽰周围有⼏个雷

◦ 如果位置是雷，就炸死游戏结束

◦ 把除10个雷之外的所有⾮雷都找出来，排雷成功，游戏结束

游戏界面:

1.2 游戏的分析和设计

1.2.1 数据结构的分析

扫雷的过程中，布置的雷和排查出的雷的信息都需要存储，所以我们需要⼀定的数据结构来存储这些信息。

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

如果这个位置布置雷，我们就存放1，没有布置雷就存放0.如下图所示:

但这么做的话会存在两个问题

问题一:

我们排完一个雷后,需要显示这个位置雷的数量,这不就与0或1的显示重合和吗?

问题二:

我们排完一个雷后,需要显示这个位置雷的数量,需要遍历这个位置一周是否有雷,假设这个位置在边界处,我们遍历的范围不就会超出数组边界吗?

如下图所示:

假设我们排查(2,5)这个坐标时，我们访问周围的⼀圈8个⻩⾊位置，统计周围雷的个数是1

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

再继续分析，我们在棋盘上布置了雷，棋盘上雷的信息（1）和⾮雷的信息（0），假设我们排查了某⼀个位置后，这个坐标处不是雷，这个坐标的周围有1个雷，那我们需要将排查出的雷的数量信息记录存储，并打印出来，作为排雷的重要参考信息的。

那这个雷的个数信息存放在哪⾥呢？如果存放在布置雷的数组中，这样雷的信息和雷的个数信息就可能或产⽣混淆和打印上的困难。这⾥我们肯定有办法解决，⽐如：雷和⾮雷的信息不要使⽤数字，使⽤某些字符就⾏，这样就避免冲突了，但是这样做棋盘上有雷和⾮雷的信息，还有排查出的雷的个数信息，就⽐较混杂，不够⽅便。这⾥我们采⽤另外⼀种⽅案，我们专⻔给⼀个棋盘（对应⼀个数组mine）存放布置好的雷的信息，再给另外⼀个棋盘（对应另外⼀个数组show）存放排查出的雷的信息。这样就互不⼲扰了，把雷布置到 mine数组，在mine数组中排查雷，排查出的数据存放在show数组，并且打印show数组的信息给后期排查参考。

同时为了保持神秘，show数组开始时初始化为字符'*'，为了保持两个数组的类型⼀致，可以使⽤同⼀套函数处理，mine数组最开始也初始化为字符'0'，布置雷改成'1'。如下图：

对应的数组应该是：

1.2.2 ⽂件结构设计

扫雷游戏的实现不是一个简单的小程序,而是一个项目,如果把所有代码都放在一个文件上,那代码的可读性会大打折扣,所以我们可以把代码分为三个部分:

1.头文件:game.h 文件中写游戏需要的数据类型和函数声明

2.源文件:

源文件里面包含两个文件,分别是:

game.c 文件中写游戏中的函数实现

text.c 文件中写游戏中的测试逻辑

2.扫雷游戏的代码实现

2.1游戏界面的设置

作为一个游戏,肯定得有一个界面,也就是菜单.这个需要直接打印出来,让用户看到.

这里我直接在测试代码里定义了两个函数,一个是测试函数,一个是菜单函数,在测试函数中,首先会调用菜单函数打印菜单,再让用户进行选择,因为用户一定要进行一次选择,所以这里使用do-while循环,使用switch-case这种结构对用户的选择进行匹配.

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

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

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

2.2游戏的实现

2.2.1头文件中声明函数

首先,我们需要在游戏的头文件中声明数据和函数,如下图:

#pragma once

#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

//声明函数
//棋盘初始化
void InitBoard(char arr[ROWS][COLS], int rows, int cols, char l);
//打印棋盘
void DisPlayBoard(char arr[ROWS][COLS], int row, int col);

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

这里首先利用define定义棋盘的大小(分为内圈和外圈)(ROW,COL)和雷的个数(EASY_COUNT),再对一些函数进行声明.

注意:

这里使用define定义ROW,COL,而不是直接arr[11][11],这样是为了后面需要更改时,能更加方便,只需要返回头文件将ROW,COL进行更改,而不需要更改其他地方.

2.2.2源文件中实现函数

注意:

我们要在源文件中使用刚刚我们在头文件定义的数据和函数,需要引入我们自己的头文件:
#include "game.h"

2.2.2.1棋盘的初始化

我们由两个棋盘,第一个棋盘是展示的棋盘,应该初始化为'*',还有一个棋盘为有无雷的棋盘,我们先初始化为'0',后面在随机放入雷.

注意:

这里为了保持类型的一致性,我们的两个棋盘(数组)均为char类型

//棋盘的初始化
void InitBoard(char arr[ROWS][COLS], int rows, int cols, char l)
{
	int i = 0;
	for (i = 0; i < rows; i++)
	{
		int j = 0;
		for (j = 0; j < cols; j++)
		{
			arr[i][j] = l;
		}
	}
}

2.2.2.2棋盘的打印

用户开始游戏后,需要打印棋盘,而这个棋盘是我们的展示的棋盘,不可能让用户可以直接看到有雷的棋盘,打印时,可以打印出行号和列号,让用户排雷时更加方便,并适当调整一下间距,让整个棋盘更加美观

//棋盘的打印
void DisPlayBoard(char arr[ROWS][COLS], int row, int col)
{
	int i = 0;
	//打印列号
	printf("-----------扫雷游戏-----------\n");
	for (i = 0; i <= row; i++)
	{
		printf("%2d ", i);
	}
	printf("\n");
	for (i = 1; i <= row; i++)
	{
		int j = 0;
		printf("%2d ", i);//打印行号
		for (j = 1; j <= col; j++)
		{
			printf("%2c ", arr[i][j]);
		}
		printf("\n");
	}
}

2.2.2.3布置雷

用户每开一把,雷的位置都不一样,应该时随机的,所以这里需要调用rand函数返回随机值,因为随机数的属性，所以rand函数在一些简易的游戏程序中非常常见，如三子棋，扫雷等游戏都可以利用这个函数进行一些随机生成的玩法。代码如下:

//布置雷
void SetMine(char arr[ROWS][COLS], int row, int col)
{
	int count = EASY_COUNT;
	while (count)
	{
		int x = rand() % row + 1;
		int y = rand() % col + 1;
		if (arr[x][y] == '0')
		{
			arr[x][y] = '1';
			count--;
		}
	}
}

这里需要说一下,rand的函数会返回一个范围在0到32767之间的伪随机数(整数),所以这里我们将得到的随机值取模一下我们定义的行号和列号,假设我们这里取模的是9,我们得到是0-8的范围随机数,这不符合我们的需求,所以需要在取模之后进行加一处理.

注意:

在调用rand()函数之前,我们可以使用srand()函数设置随机数种子,如果没有设置随机数种子,rand()函数在调用时,自动设计随机数种子为1。随机种子相同,每次产生的随机数也会相同。(这里需要在测试文件中设置)

2.2.2.4排查雷

我们在实现排查雷的操作之前,需要判断这个位置是否和法(即在我们的数组之内),接着,得判断这个位置是否为雷,是雷得话,游戏直接结束,反之,返回周围一圈雷得数量.而结束我们这个循环得条件为:win >= row*col-EASY_COUNT,我们每次排完一个雷后,win都会加加,知道win得个数等于row*col-EASY_COUNT,这就说明,棋盘中只剩雷的位置,扫雷成功!

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

//排查雷
void FindMine(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_COUNT)
	{
		printf("请输入要排查的坐标:\n");
		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++;
			}
		}
		else
		{
			printf("坐标非法,请重新输入\n");
		}
	}
	if (win == row * col - EASY_COUNT)
	{
		printf("恭喜你!排雷成功!\n");
		DisPlayBoard(mine,ROW,COL);
	}
}

注意:

我们返回周围雷的数量的操作中,有两种方法,第一种为直接枚举,将除自己之外的8个位置的雷的数量进行相加,第二种是两层循环进行遍历

返回时需要注意:我们之前定义的字符类型,返回的数据类型时整数类型,这里需要类型转换在进行返回.

2.2.3编写测试代码

这里也需要引入头文件,将我们在源文件实现的函数直接调用

#define _CRT_SECURE_NO_WARNINGS 1

#include "game.h"

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

void game()
{
	//完成扫雷游戏
	//mine数组中存放布置好的雷的信息
	char mine[ROWS][COLS] = { 0 };//数组全部初始化为'0'
	//show数组中存放排查出的雷的信息
	char show[ROWS][COLS] = { 0 };//数组全部初始化为'*'
	//初始化棋盘
	InitBoard(mine, ROWS, COLS, '0');
	InitBoard(show, ROWS, COLS, '*');

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

	//布置雷
	//就是在9*9的棋盘上随机布置10个雷
	SetMine(mine, ROW, COL);
	//DisPlayBoard(mine, ROW, COL);

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

void text()
{
	int input = 0;
	srand((unsigned int)time(NULL));
	do
	{
		menu();
		printf("请选择:>");
		scanf("%d", &input);//1 0 x
		switch (input)
		{
		case 1:
			game();
			break;
		case 0:
			printf("游戏结束,退出游戏\n");
			break;
		default:
			printf("选择错误,请重新选择\n");
			break;
		}
	} while (input);
}

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

3.测试结果

因为篇幅有限,下面是一个不完整的测试结果:

后面有完整代码,有兴趣的宝子们可以自己去测试一下

4.小结

这其实是一个很简单的C语言游戏项目,大家可以通过这个项目,看看自己C语言知识的掌握程度,如果你有什么问题的话,可以打在评论区,大家一起学习进步,后面我也会更新用C语言实现贪吃蛇,喜欢的宝子们记得点赞关注哦!

5.完整代码

text.c

#define _CRT_SECURE_NO_WARNINGS 1

#include "game.h"

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

void game()
{
	//完成扫雷游戏
	//mine数组中存放布置好的雷的信息
	char mine[ROWS][COLS] = { 0 };//数组全部初始化为'0'
	//show数组中存放排查出的雷的信息
	char show[ROWS][COLS] = { 0 };//数组全部初始化为'*'
	//初始化棋盘
	InitBoard(mine, ROWS, COLS, '0');
	InitBoard(show, ROWS, COLS, '*');

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

	//布置雷
	//就是在9*9的棋盘上随机布置10个雷
	SetMine(mine, ROW, COL);
	//DisPlayBoard(mine, ROW, COL);

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

void text()
{
	int input = 0;
	srand((unsigned int)time(NULL));
	do
	{
		menu();
		printf("请选择:>");
		scanf("%d", &input);//1 0 x
		switch (input)
		{
		case 1:
			game();
			break;
		case 0:
			printf("游戏结束,退出游戏\n");
			break;
		default:
			printf("选择错误,请重新选择\n");
			break;
		}
	} while (input);
}

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

game.c

#define _CRT_SECURE_NO_WARNINGS 1

#include "game.h"
//棋盘的初始化
void InitBoard(char arr[ROWS][COLS], int rows, int cols, char l)
{
	int i = 0;
	for (i = 0; i < rows; i++)
	{
		int j = 0;
		for (j = 0; j < cols; j++)
		{
			arr[i][j] = l;
		}
	}
}
//棋盘的打印
void DisPlayBoard(char arr[ROWS][COLS], int row, int col)
{
	int i = 0;
	//打印列号
	printf("-----------扫雷游戏-----------\n");
	for (i = 0; i <= row; i++)
	{
		printf("%2d ", i);
	}
	printf("\n");
	for (i = 1; i <= row; i++)
	{
		int j = 0;
		printf("%2d ", i);//打印行号
		for (j = 1; j <= col; j++)
		{
			printf("%2c ", arr[i][j]);
		}
		printf("\n");
	}
}

//布置雷
void SetMine(char arr[ROWS][COLS], int row, int col)
{
	int count = EASY_COUNT;
	while (count)
	{
		int x = rand() % row + 1;
		int y = rand() % col + 1;
		if (arr[x][y] == '0')
		{
			arr[x][y] = '1';
			count--;
		}
	}
}

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

//排查雷
void FindMine(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_COUNT)
	{
		printf("请输入要排查的坐标:\n");
		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++;
			}
		}
		else
		{
			printf("坐标非法,请重新输入\n");
		}
	}
	if (win == row * col - EASY_COUNT)
	{
		printf("恭喜你!排雷成功!\n");
		DisPlayBoard(mine,ROW,COL);
	}
}

game.h

#pragma once

#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

//声明函数
//棋盘初始化
void InitBoard(char arr[ROWS][COLS], int rows, int cols, char l);
//打印棋盘
void DisPlayBoard(char arr[ROWS][COLS], int row, int col);

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

6.扫雷游戏的扩展

这里我写的跟实际上的扫雷游戏还是有些不同的,因为我实现的是最简单的版本,你们可以在我这个基础上进行这些优化:

是否可以选择游戏难度

◦ 简单9*9棋盘，10个雷

◦ 中等16*16棋盘，40个雷

◦ 困难30*16棋盘，99个雷

• 如果排查位置不是雷，周围也没有雷，可以展开周围的⼀⽚

• 是否可以标记雷

• 是否可以加上排雷的时间显⽰

后面我可能会更新优化后的扫雷

C++忠实粉丝

关注

43
点赞
踩
14

收藏

觉得还不错? 一键收藏
1
评论
C语言实现扫雷游戏(含有完整代码,小白也能轻松看懂)

我们在实现排查雷的操作之前,需要判断这个位置是否和法(即在我们的数组之内),接着,得判断这个位置是否为雷,是雷得话,游戏直接结束,反之,返回周围一圈雷得数量.而结束我们这个循环得条件为:win >= row*col-EASY_COUNT,我们每次排完一个雷后,win都会加加,知道win得个数等于row*col-EASY_COUNT,这就说明,棋盘中只剩雷的位置,扫雷成功!我们返回周围雷的数量的操作中,有两种方法,第一种为直接枚举,将除自己之外的8个位置的雷的数量进行相加,第二种是两层循环进行遍历。
复制链接

扫一扫