C语言：扫雷游戏的思路和具体方法（扩展：难度选择、标记地雷、周围无雷展开、清屏）

最新推荐文章于 2025-04-28 12:27:13 发布
最新推荐文章于 2025-04-28 12:27:13 发布
阅读量1k 收藏 32
点赞数 25
文章标签： c语言 游戏
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79284360/article/details/138923635
版权

目录

使用工具：Visual Studio 2022

前言：对扫雷的数据结构分析略讲，并主要讲解具体代码和代码的逻辑

1. 分析和设计

1.1 扫雷游戏的功能和玩法

1.1.1 功能

  • 使⽤控制台实现经典的扫雷游戏
  • 游戏可以通过菜单实现继续玩或者退出游戏
  • 扫雷的棋盘是9*9的格⼦
  • 默认随机布置有10个地雷
  • 可以排查地雷
  • 扩展：有难度选择：简单 99 棋盘、10个雷，中等 1616棋盘、40个雷，困难 30*16棋盘，99个雷；可以标记地雷；排查位置不是雷，周围也没有雷，可以展开周围的⼀⽚。

1.1.2 玩法

  • 输入坐标，如果位置不是雷，就显⽰周围有⼏个雷，如果位置是雷，就炸死游戏结束
  • 把除10个雷之外的所有⾮雷都找出来，排雷成功，游戏结束
  • 扩展：输入0 0进行标记

1.2 游戏界面

1.3 数据结构的分析

扫雷的过程中，布置的雷和排查出的雷的信息都需要存储，所以我们需要⼀定的数据结构来存储这些信息。
如果创建⼀个99的数组来存放信息，在最外围的一圈进行地雷排查时会出现越界的情况，所以创建1111的数组进行信息存储。
创建两个字符数组，一个数组（mine）存储雷和非雷的信息：雷用'1'非雷用'0'，另⼀个数组（show）存放排查出的雷的信息，show数组开始时初始化为字符 ‘*’。

1.4 设计三个⽂件

1.4.1 test.c部分（游戏的测试逻辑）

  1. 创建main函数= =>创建test函数（开始与退出游戏）= =>创建game函数（实现游戏）+扩展：创建select函数（选择游戏难度）
  2. game函数：InitBoard函数（初始化棋盘）= =>DisplayBoard函数（打印棋盘） = =>SetMine函数（布置地雷）= =>FindMine函数（排查地雷）

在这里插入图片描述

1.4.2 game.c部分（游戏中函数的实现）

  1. 创建InitBoard函数= =>创建DisplayBoard 函数= =>创建SetMine函数= =>创建FindMine函数= =>{创建GetMineCount函数（获取地雷个数）}+扩展：创建MarkMine函数（标记地雷）= =>{创建Mark函数（进行标记）= =>创建Unmark函数（取消标记）} = =>创建SpreadMine函数（排查周围，不是雷，进行扩展）= =>创建WinMine函数（游戏胜利所需要的值）
    在这里插入图片描述

1.4.3 game.h部分（游戏需要的数据类型和函数声明）

  1. 定义 EASY_COUNT（地雷个数）、定义ROW（棋盘行数）、定义COL（棋盘列数）、定义ROWS（实际行数）、定义COLS（实际列数）、在game.c创建函数的声明+扩展：分别定义三种难度的地雷个数、棋盘行列数、实际行列数
    在这里插入图片描述

2. 具体代码讲解

将所有库函数引用的头文件放入game.h文件中，直接在test.c和game.c文件中引用：#include “game.h”

2.1 test.c部分

2.1.1 main函数

int main()
{
	test();//在主函数外另封装一个函数进行具体的游戏测试
	return 0;
}

2.1.2 test函数

在控制台打印菜单，选择是否开始游戏，用switch语句进行菜单选择，do-while循环让游戏可以重复游玩

void menu1()
{
	printf("********************\n");
	printf("*****  1.paly  *****\n");
	printf("*****  0.exit  *****\n");
	printf("********************\n");
}
void test()
{
	int input = 0;
	srand((unsigned int)time(NULL));
	do
	{
		menu1();
		printf("请选择>:");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			game();
			break;
		case 0:
			printf("退出游戏\n");
			break;
		default:
			printf("选择错误，请重新选择\n");
			break;
		}
	} while (input);
}

2.1.3 game函数

四个变量ROW、COL、ROWS、COLS在game.h文件中被定义，剩余函数在game.h文件中声明，在game.c文件中定义

void game()
{
	char mine[ROWS][COLS];//存放布置好的雷
	char show[ROWS][COLS];//存放排查出的雷的信息
	//初始化面板（棋盘）
	//初始化数组mine中全为字符0
	//初始化数组show中全为字符*
	InitBoard(mine, ROWS, COLS, '0');
	InitBoard(show, ROWS, COLS, '*');
	//展示面板（打印棋盘）
	DisplayBoard(show, ROW, COL);
	//DisplayBoard(mine, ROW, COL);
	
	//布置地雷
	SetMine(mine, ROW, COL);
	//DisplayBoard(mine, ROW, COL);
	
	//排查显示地雷的信息
	FindMine(mine,show, ROW, COL);
}

2.2 game.c部分

2.2.1 InitBoard函数

对数组mine和数组show进行初始化，mine全部初始化为'0'，show全部初始化为'*'

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;
		}
	}
}

2.2.2 DisplayBoard函数

对数组内容进行打印，以9*9棋盘的形式打印

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

2.2.3 SetMine函数

⽣成a~b的随机数： a + rand()%(b-a+1)
变量EASY_COUNT在game.h文件中被定义，为简单模式下地雷个数
用Board[x][y] = '1’表示埋下地雷

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

2.2.4 FindMine函数

要对输入坐标进行判断，因为输入的坐标可能会超出棋盘的界限；而在界限内的坐标如果踩雷（当输入坐标所得mine[x][y] == '1’时），没有踩雷则对周围八个坐标中雷的个数进行统计，并让show[x][y]等于所统计个数，使用GetMineCount函数统计

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("请输入坐标>:");
		scanf("%d %d", &x, &y);
		if (x > 0 && x <= row && y > 0 && y <= col)
		{
			if (mine[x][y] == '1')
			{
				DisplayBoard(mine, row, col);
				printf("游戏失败\n");
				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);
	}
}

2.2.5GetMineCount函数

此函数应该放在FindMine函数前，它只在game.c文件中被FindMine函数引用

int GetMineCount(char mine[ROWS][COLS], int x, int y)
{
	int i = 0;
	int j = 0;
	int count = 0;
	for (i = -1; i <= 1; i++)
	{
		for (j = -1; j <= 1; j++)
		{
			count += (mine[x + i][y + j] - '0');//数组mine是字符型数组，返回的ASCII值减去0的ASCII值为字符本身所表示的数字
		}
	}
	return count;
}

2.3 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);

3. 扩展：清屏、难度选择、标记地雷、周围无雷展开

3.1 清屏

包含头文件 #include <stdlib.h>
所用库函数system( );

system("cls");

因为使用后会直接清屏，所以需要一些技巧

  1. 在test.c文件中的test函数
    在这里插入图片描述
  2. 在game.c文件中的FindMine函数
    在这里插入图片描述
    清屏代码的具体位置可以在末尾的成品展示中查找

3.2 难度选择

位置：test.c文件
所用函数：Select函数、menu2函数、WinMine函数、FindMine函数（改）

因为新的难度需要更多的行数和地雷实现，所以行数、地雷个数要增加定义，而二维数组，因为定义数组设置大小只能用常量，所以为了避免越界，我们将棋盘大小设为三种难度中棋盘最大的那一个

#define EASY_COUNT 10
#define EASY_ROW 9
#define EASY_COL 9
#define EASY_ROWS EASY_ROW+2
#define EASY_COLS EASY_COL+2

#define MID_COUNT 40
#define MID_ROW 16
#define MID_COL 16
#define MID_ROWS MID_ROW+2
#define MID_COLS MID_COL+2

#define DIF_COUNT 99
#define DIF_ROW 16
#define DIF_COL 30
#define DIF_ROWS DIF_ROW+2
#define DIF_COLS DIF_COL+2

之前数组的全部名称都要由char name[ROWS][COLS]变为char name[DIF_ROWS][DIF_COLS]

3.2.1 menu2函数

void menu2()
{
	printf("********************\n");
	printf("*****  1.简单  *****\n");
	printf("*****  2.中等  *****\n");
	printf("*****  3.困难  *****\n");
	printf("********************\n");
}

3.2.2 select函数

void select()
{
	int input = 0;
	int i = 0;
	do
	{
		menu2();
		printf("请选择>:");
		scanf("%d", &input);
		system("cls");
		switch (input)
		{
		case 1:
			ROW = EASY_ROW;
			COL = EASY_COL;
			ROWS = EASY_ROWS;
			COLS = EASY_COLS;
			count = EASY_COUNT;
			i = 0;
			break;
		case 2:
			ROW = MID_ROW;
			COL = MID_COL;
			ROWS = MID_ROWS;
			COLS = MID_COLS;
			count = MID_COUNT;
			i = 0;
			break;
		case 3:
			ROW = DIF_ROW;
			COL = DIF_COL;
			ROWS = DIF_ROWS;
			COLS = DIF_COLS;
			count = DIF_COUNT;
			i = 0;
			break;
		default:
			printf("选择错误，请重新选择\n");
			i = 1;
			break;
		}
	} while (i);
}

3.2.3 WinMine函数

WinMine函数返回的值是row * col - count，其中row、col、count分别为不同难度中的行、列、地雷个数；同时WinMine函数应该在FindMine函数前运行

int WinMine(char show[DIF_ROWS][DIF_COLS], int row, int col)
{
	int i = 0;
	int j = 0;
	int win = 0;
	for (i = 1; i <= row; i++)
	{
		for (j = 1; j <= col; j++)
		{
			if(show[i][j] !='*'&& show[i][j] != '!')
			    win++;
		}
	}
	return win;
}

3.2.4 FindMine函数

void FindMine(char mine[DIF_ROWS][DIF_COLS], char show[DIF_ROWS][DIF_COLS], int row, int col, int count)
{
	int x = 0;
	int y = 0;
	int i = 0;
	while (WinMine(show,row,col) < row * col - count)
	{
		printf("请输入坐标>:");
		scanf("%d %d", &x, &y);
		system("cls");
		if (x > 0 && x <= row && y > 0 && y <= col)
		{
			if (mine[x][y] == '1')
			{
				DisplayBoard(show, row, col);
				printf("请输入坐标>:%d %d", x, y);
				DisplayBoard(mine, row, col);
				printf("游戏失败\n");
				printf("输入1继续>");
				scanf("%d", &i);
				system("cls");
				break;
			}
			else
			{
				int count = GetMineCount(mine, x, y);
				show[x][y] = count + '0';
				//DisplayBoard(mine, row, col);
				DisplayBoard(show, row, col);
			}
		}
		else
		{
			DisplayBoard(show, row, col);
			printf("输入错误，请重新输入\n");
		}
	}
	if (WinMine(show, row, col) == row * col - count)
	{
		printf("恭喜你，成功了\n");
		DisplayBoard(mine, row, col);
		printf("输入1继续>");
		scanf("%d", &i);
		system("cls");
	}
}

3.3 标记地雷

位置：game.c文件
所用函数：MarkMine函数、Mark函数、Unmark函数、FindMine函数（2改）

3.3.1 FindMine函数

在FindMine函数运行时（即排查地雷输入坐标时），输入0 0，进入标记地雷的函数

void FindMine(char mine[DIF_ROWS][DIF_COLS], char show[DIF_ROWS][DIF_COLS], int row, int col, int count)
{
	int x = 0;
	int y = 0;
	int i = 0;
	while (WinMine(show,row,col) < row * col - count)
	{
		printf("输入0 0进行标记\n");
		printf("请输入坐标>:");
		scanf("%d %d", &x, &y);
		system("cls");
		if (x > 0 && x <= row && y > 0 && y <= col)
		{
			if (mine[x][y] == '1')
			{
				DisplayBoard(show, row, col);
				printf("请输入坐标>:%d %d", x, y);
				DisplayBoard(mine, row, col);
				printf("游戏失败\n");
				printf("输入1继续>");
				scanf("%d", &i);
				system("cls");
				break;
			}
			else
			{
				int count = GetMineCount(mine, x, y);
				show[x][y] = count + '0';
				//DisplayBoard(mine, row, col);
				DisplayBoard(show, row, col);
			}
		}
		else if (x == 0 && y == 0)
		{
			MarkMine(mine, show, row, col);
		}
		else
		{
			DisplayBoard(show, row, col);
			printf("输入错误，请重新输入\n");
		}
	}
	if (WinMine(show, row, col) == row * col - count)
	{
		printf("恭喜你，成功了\n");
		DisplayBoard(mine, row, col);
		printf("输入1继续>");
		scanf("%d", &i);
		system("cls");
	}
}

3.3.2 MarkMine函数

在选择1时进入Mark函数，选择2时进入Unmark函数，所以这两个函数要在MarkMine函数前

void MarkMine(char mine[DIF_ROWS][DIF_COLS], char show[DIF_ROWS][DIF_COLS], int row, int col)
{
	int input = 0;
	int i = 0;
	do
	{
		DisplayBoard(show, row, col);
		printf("1.进行标记\n2.取消标记\n0.退出标记\n");
		printf("请选择>:");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			Mark(show, row, col);
			break;
		case 2:
			Unmark(show, row, col);
			break;
		case 0:
			system("cls");
			DisplayBoard(show, row, col);
			break;
		default:
			printf("选择错误，请重新选择\n");
			printf("输入1继续>");
			scanf("%d", &i);
			system("cls");
			break;
		}
	} while (input);
}

3.3.3 Mark函数

要对已标记，已排查的坐标进行说明，同时要有退出的功能

void Mark(char show[DIF_ROWS][DIF_COLS], int row, int col)
{
	int x = 0;
	int y = 0;
	int i = 0;
	while(1)
	{
		system("cls");
		DisplayBoard(show, row, col);
		printf("正在进行标记，输入0 0退出\n");
		printf("请输入要标记的坐标>:");
		scanf("%d %d", &x, &y);
		if (x > 0 && x <= row && y > 0 && y <= col)
		{
			if (show[x][y] == '*')
			{
				show[x][y] = '!';
				system("cls");
				break;
			}
			else if (show[x][y] == '!')
			{
				printf("已标记，请重新输入\n");
				printf("输入1确定>");
				scanf("%d", &i);
				system("cls");
			}
			else
			{
				printf("已排查，请重新输入\n");
				printf("输入1确定>");
				scanf("%d", &i);
				system("cls");
			}
		}
		else if (x == 0 && y == 0)
		{
			system("cls");
			break;
		}
		else
			printf("输入错误，请重新输入\n");
	}
}

3.3.4 Unmark函数

要对未标记，已排查的坐标进行说明，同时要有退出的功能，不然在游戏还未进行标记时，会出现无法退出的情况

void Unmark(char show[DIF_ROWS][DIF_COLS], int row, int col)
{
	int x = 0;
	int y = 0;
	int i = 0;
	while (1)
	{
		system("cls");
		DisplayBoard(show, row, col);
		printf("正在取消标记，输入0 0退出\n");
		printf("请输入要取消标记的坐标>:");
		scanf("%d %d", &x, &y);
		if(x > 0 && x <= row && y > 0 && y <= col)
		{
			if (show[x][y] == '!')
			{
				show[x][y] = '*';
				system("cls");
				break;
			}
			else if (show[x][y] == '*')
			{
				printf("未标记，请重新输入\n");
				printf("输入1确定>");
				scanf("%d", &i);
				system("cls");
			}
			else
			{
				printf("已排查，请重新输入\n");
				printf("输入1确定>");
				scanf("%d", &i);
				system("cls");
			}
		}
		else if (x == 0 && y == 0)
		{
			system("cls");
			break;
		}
		else
			printf("输入错误，请重新输入\n");
	}
}

3.4 周围无雷展开

位置：game.c文件
所用函数：SpreadMine函数、FindMine函数（2改）

会用到递推函数

3.4.1 FindMine函数

在这里插入图片描述

3.4.2 SpreadMine函数

注意：这里的show[m][n] == '*'不能改写为show[m][n] != '0'，因为我们创建的二维数组行列数比实际棋盘的行列数均多出两行，而多出的两行初始化均为字符0

void SpreadMine(char mine[DIF_ROWS][DIF_COLS], char show[DIF_ROWS][DIF_COLS], int row, int col, int x, int y)
{

	if (GetMineCount(mine, x - 1, y) == 0 && show[x - 1][y] == '*')
	{
		show[x - 1][y] = '0';
		//x = x - 1;
		SpreadMine(mine, show, row, col, x - 1, y);
	}
	if (GetMineCount(mine, x + 1, y) == 0 && show[x + 1][y] == '*')
	{
		show[x + 1][y] = '0';
		//x = x + 1;
		SpreadMine(mine, show, row, col, x + 1, y);
	}
	if (GetMineCount(mine, x, y - 1) == 0 && show[x][y - 1] == '*')
	{
		show[x ][y - 1] = '0';
		//y = y - 1;
		SpreadMine(mine, show, row, col, x, y - 1);
	}
	if (GetMineCount(mine, x, y + 1) == 0 && show[x][y + 1] == '*')
	{
		show[x][y + 1] = '0';
		//y = y + 1;
		SpreadMine(mine, show, row, col, x, y + 1);
	}
}

4. 最终成品展示

4.1 游戏界面

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

4.2 test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "game.h"

int ROW = 0;
int COL = 0;
int ROWS = 0;
int COLS = 0;
int count = 0;
//菜单1
void menu1()
{
	printf("********************\n");
	printf("*****  1.paly  *****\n");
	printf("*****  0.exit  *****\n");
	printf("********************\n");

}
//菜单2
void menu2()
{
	printf("********************\n");
	printf("*****  1.简单  *****\n");
	printf("*****  2.中等  *****\n");
	printf("*****  3.困难  *****\n");
	printf("********************\n");
}
//难度选择
void select()
{
	int input = 0;
	int i = 0;
	do
	{
		menu2();
		printf("请选择>:");
		scanf("%d", &input);
		system("cls");
		switch (input)
		{
		case 1:
			ROW = EASY_ROW;
			COL = EASY_COL;
			ROWS = EASY_ROWS;
			COLS = EASY_COLS;
			count = EASY_COUNT;
			i = 0;
			break;
		case 2:
			ROW = MID_ROW;
			COL = MID_COL;
			ROWS = MID_ROWS;
			COLS = MID_COLS;
			count = MID_COUNT;
			i = 0;
			break;
		case 3:
			ROW = DIF_ROW;
			COL = DIF_COL;
			ROWS = DIF_ROWS;
			COLS = DIF_COLS;
			count = DIF_COUNT;
			i = 0;
			break;
		default:
			printf("选择错误，请重新选择\n");
			i = 1;
			break;
		}
	} while (i);
}
//游戏运行
void game()
{

	select();
	char mine[DIF_ROWS][DIF_COLS];//存放布置好的雷
	char show[DIF_ROWS][DIF_COLS];//存放排查出的雷的信息
	//初始化面板（棋盘）
	//初始化数组mine中全为字符0
	//初始化数组show中全为字符*
	InitBoard(mine, ROWS, COLS, '0');
	InitBoard(show, ROWS, COLS, '*');


	//展示面板（打印棋盘）
	DisplayBoard(show, ROW, COL);
	//DisplayBoard(mine, ROW, COL);

	//布置地雷
	SetMine(mine, ROW, COL, count);
	//DisplayBoard(show, ROW, COL);
	//DisplayBoard(mine, ROW, COL);
	//排查显示地雷的信息
	FindMine(mine,show, ROW, COL, count);
	
	
}
//选择开始
void test()
{
	int input = 0;
	srand((unsigned int)time(NULL));
	do
	{
		menu1();
		printf("请选择>:");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			system("cls");
			game();
			break;
		case 0:
			printf("退出游戏\n");
			break;
		default:
			printf("选择错误，请重新选择\n");
			break;
		}
	} while (input);
}

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

4.3 game.c

#define _CRT_SECURE_NO_WARNINGS 1

#include "game.h"
//初始化面板
void InitBoard(char Board[DIF_ROWS][DIF_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[DIF_ROWS][DIF_COLS], int row, int col)
{
	int i = 0;
	int j = 0;
	printf("\n-------------扫雷-------------\n");
	
	for (i = 0; i <= col; i++)
	{
		printf("%2d ", i);
	}
	printf("\n");
	for (i = 1; i <= row; i++)
	{
		printf("%2d ", i);
		for (j = 1; j <= col; j++)
		{
			printf("%2c ", Board[i][j]);
		}
		printf("\n");
	}
}
//布置地雷
void SetMine(char Board[DIF_ROWS][DIF_COLS], int row, int col, int count)
{
	int x = 0;
	int y = 0;
	while (count)
	{
		x = rand() % row + 1;
		y = rand() % col + 1;
		if (Board[x][y] != '1')
		{
			Board[x][y] = '1';
			count--;
		}
	}
}
//得到输入坐标周围地雷个数
int GetMineCount(char mine[DIF_ROWS][DIF_COLS], int x, int y)
{
	int i = 0;
	int j = 0;
	int count = 0;
	for (i = -1; i <= 1; i++)
	{
		for (j = -1; j <= 1; j++)
		{
			count += (mine[x + i][y + j] - '0');
		}
	}
	return count;
}
//排查周围，不是雷，进行扩展
void SpreadMine(char mine[DIF_ROWS][DIF_COLS], char show[DIF_ROWS][DIF_COLS], int row, int col, int x, int y)
{

	if (GetMineCount(mine, x - 1, y) == 0 && show[x - 1][y] == '*')
	{
		show[x - 1][y] = '0';
		//x = x - 1;
		SpreadMine(mine, show, row, col, x - 1, y);
	}
	if (GetMineCount(mine, x + 1, y) == 0 && show[x + 1][y] == '*')
	{
		show[x + 1][y] = '0';
		//x = x + 1;
		SpreadMine(mine, show, row, col, x + 1, y);
	}
	if (GetMineCount(mine, x, y - 1) == 0 && show[x][y - 1] == '*')
	{
		show[x ][y - 1] = '0';
		//y = y - 1;
		SpreadMine(mine, show, row, col, x, y - 1);
	}
	if (GetMineCount(mine, x, y + 1) == 0 && show[x][y + 1] == '*')
	{
		show[x][y + 1] = '0';
		//y = y + 1;
		SpreadMine(mine, show, row, col, x, y + 1);
	}
}
//进行标记
void Mark(char show[DIF_ROWS][DIF_COLS], int row, int col)
{
	int x = 0;
	int y = 0;
	int i = 0;
	while(1)
	{
		system("cls");
		DisplayBoard(show, row, col);
		printf("正在进行标记，输入0 0退出\n");
		printf("请输入要标记的坐标>:");
		scanf("%d %d", &x, &y);
		if (x > 0 && x <= row && y > 0 && y <= col)
		{
			if (show[x][y] == '*')
			{
				show[x][y] = '!';
				system("cls");
				break;
			}
			else if (show[x][y] == '!')
			{
				printf("已标记，请重新输入\n");
				printf("输入1确定>");
				scanf("%d", &i);
				system("cls");
			}
			else
			{
				printf("已排查，请重新输入\n");
				printf("输入1确定>");
				scanf("%d", &i);
				system("cls");
			}
		}
		else if (x == 0 && y == 0)
		{
			system("cls");
			break;
		}
		else
			printf("输入错误，请重新输入\n");
	}
}
//取消标记
void Unmark(char show[DIF_ROWS][DIF_COLS], int row, int col)
{
	int x = 0;
	int y = 0;
	int i = 0;
	while (1)
	{
		system("cls");
		DisplayBoard(show, row, col);
		printf("正在取消标记，输入0 0退出\n");
		printf("请输入要取消标记的坐标>:");
		scanf("%d %d", &x, &y);
		if(x > 0 && x <= row && y > 0 && y <= col)
		{
			if (show[x][y] == '!')
			{
				show[x][y] = '*';
				system("cls");
				break;
			}
			else if (show[x][y] == '*')
			{
				printf("未标记，请重新输入\n");
				printf("输入1确定>");
				scanf("%d", &i);
				system("cls");
			}
			else
			{
				printf("已排查，请重新输入\n");
				printf("输入1确定>");
				scanf("%d", &i);
				system("cls");
			}
		}
		else if (x == 0 && y == 0)
		{
			system("cls");
			break;
		}
		else
			printf("输入错误，请重新输入\n");
	}
}
//标记地雷
void MarkMine(char mine[DIF_ROWS][DIF_COLS], char show[DIF_ROWS][DIF_COLS], int row, int col)
{
	int input = 0;
	int i = 0;
	do
	{
		DisplayBoard(show, row, col);
		printf("1.进行标记\n2.取消标记\n0.退出标记\n");
		printf("请选择>:");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			Mark(show, row, col);
			break;
		case 2:
			Unmark(show, row, col);
			break;
		case 0:
			system("cls");
			DisplayBoard(show, row, col);
			break;
		default:
			printf("选择错误，请重新选择\n");
			printf("输入1继续>");
			scanf("%d", &i);
			system("cls");
			break;
		}
	} while (input);
}
//游戏胜利所需要的值
int WinMine(char show[DIF_ROWS][DIF_COLS], int row, int col)
{
	int i = 0;
	int j = 0;
	int win = 0;
	for (i = 1; i <= row; i++)
	{
		for (j = 1; j <= col; j++)
		{
			if(show[i][j] !='*'&& show[i][j] != '!')
			    win++;
		}
	}
	return win;
}
//排查显示地雷的信息
void FindMine(char mine[DIF_ROWS][DIF_COLS], char show[DIF_ROWS][DIF_COLS], int row, int col, int count)
{
	int x = 0;
	int y = 0;
	int i = 0;
	while (WinMine(show,row,col) < row * col - count)
	{
		printf("输入0 0进行标记\n");
		printf("请输入坐标>:");
		scanf("%d %d", &x, &y);
		system("cls");
		if (x > 0 && x <= row && y > 0 && y <= col)
		{
			if (mine[x][y] == '1')
			{
				DisplayBoard(show, row, col);
				printf("请输入坐标>:%d %d", x, y);
				DisplayBoard(mine, row, col);
				printf("游戏失败\n");
				printf("输入1继续>");
				scanf("%d", &i);
				system("cls");
				break;
			}
			else
			{
				int count = GetMineCount(mine, x, y);
				show[x][y] = count + '0';
				SpreadMine(mine, show, row, col, x, y);
				//DisplayBoard(mine, row, col);
				DisplayBoard(show, row, col);
			}
		}
		else if (x == 0 && y == 0)
		{
			MarkMine(mine, show, row, col);
		}
		else
		{
			DisplayBoard(show, row, col);
			printf("输入错误，请重新输入\n");
		}
	}
	if (WinMine(show, row, col) == row * col - count)
	{
		printf("恭喜你，成功了\n");
		DisplayBoard(mine, row, col);
		printf("输入1继续>");
		scanf("%d", &i);
		system("cls");
	}
}

4.4 game.h

#pragma once
#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

#define EASY_COUNT 10
#define EASY_ROW 9
#define EASY_COL 9
#define EASY_ROWS EASY_ROW+2
#define EASY_COLS EASY_COL+2

#define MID_COUNT 40
#define MID_ROW 16
#define MID_COL 16
#define MID_ROWS MID_ROW+2
#define MID_COLS MID_COL+2

#define DIF_COUNT 99
#define DIF_ROW 16
#define DIF_COL 30
#define DIF_ROWS DIF_ROW+2
#define DIF_COLS DIF_COL+2

void InitBoard(char Board[DIF_ROWS][DIF_COLS], int rows, int cols, char set);
void DisplayBoard(char Board[DIF_ROWS][DIF_COLS], int row, int col);
void SetMine(char Board[DIF_ROWS][DIF_COLS], int row, int col, int count);
void FindMine(char mine[DIF_ROWS][DIF_COLS], char show[DIF_ROWS][DIF_COLS], int row, int col, int count);
无声目
关注
Win7扫雷的H5完整复刻实现（一） / js扫雷算法的初次鉴定与地图初始化实现
lANcElOT的博客
07-18 1508
学校实训最后布置的一个答辩作业，周围同学都是在用资源做简单动画，突然想起大一的时候想用C语言模拟的扫雷，虽然做H5游戏比较少，但是还是较完美的复刻了WIN7扫雷的大部分算法和UI。 简单扫雷本身的实现难度不算太高，若是想要完美复刻win7的扫雷，还是需要费一番功夫的，这份无聊之作（装逼之作）是用两天时间写出来的，某些地方略有缺陷，但无伤大雅。 虽然本作是用JS语言实现逻辑，但是其他语言仍有互通...
纯C语言基础语法实现简单的扫雷游戏-支持扩展空白区域(附代码以及详细讲解)
qq_59959075的博客
04-28 3926
学习C语言也有一段时间了，相较于数媒专业的同学来说， C语言的确是有点枯燥的，因为学习这么长时间来看好像并没有做出来什么能被其他专业同学认可的东西，和学PS或者Ar的同学不一样，他们学习一节课之后立马可以自己实践出可见的效果。 学习写代码，拿回家给阿姨看：“啊？这什么啊？有什么用啊？” 但是数媒就不一样了：“哇，修的这个照片真好看”。 这就是区别呐。 所以今天咱们尝试用C语言实现一个简单小游戏，也能让学习C语言一段时间的同学们感到自己的成果。 C语言需要学习到什...
C语言实现扫雷(扩展版)
weixin_51062241的博客
08-18 683
用C语言实现扫雷游戏，主要有二维数组、分支结构、函数的定义和使用这几个知识点，我们用两个源文件(test.c和game.c)和一个头文件(game.h)来实现。 目录 一、打印菜单 二、设计游戏部分 1.创建两个雷盘并初始化、打印 1.1 初始化棋盘函数 1.2 打印棋盘函数 2.布置地雷 3.获取周围雷数的函数 4.保证第一次不是雷的函数 5.展开函数 6.扫雷函数 三、代码展示 一、打印菜单 void menu() { printf("************...
控制台实现扫雷游戏（C语言、空白区展开、自定义设置、标记地雷,超级详细哦）
ZHIYU0707的博客
08-03 1623
/******************mine_clearance.c中******************////自定义游戏设置int CustomizeSettings() //（mine_clearance.c中）int MINES;printf(">>自定义游戏设置
扫雷自定义最难C语言,C语言实现扫雷小游戏(扩展版可选择游戏难度)
weixin_28309723的博客
05-17 1126
游戏简介扫雷，是一款益智类小游戏。游戏目标是找出所有没有地雷的方格，完成游戏；要是按了有地雷的方格，游戏失败；玩家可标记雷的位置。游戏以完成时间来评高低。有不同的游戏难度可选择。实现的功能介绍1.计时2.初始化雷盘3.打印雷盘4.随机设置雷的分布，可选择游戏难易程度5.统计坐标位置周围的雷数6.第一次排雷不会被炸死7.扩展式排雷，展开周围的非雷区8.给所选坐标位置做标记，或取消标记该程序分为三个文...
C语言：扫雷小游戏(空白展开和标记雷点)
m0_74068921的博客
05-12 526
相信大多数人都玩过扫雷游戏–微软自带扫雷游戏。在一个9×9（初级）、16×16（中级）、16×30（高级）或自定义大小的方块矩阵中随机布置一定量的地雷（初级为10个，中级为40个，高级为99个），再由玩家逐个翻开方块，以找出所有地雷为最终游戏目标。玩家根据数字(数字代表周围8个格子有多少个雷)来依次排除雷；当点击到空白位置时，区域就会自动展开；你知道雷位置之后，也可以标记这个雷；当然，老玩家都知道，如果标记正确的话，点击已经开过的位置时，它还会自动展开。标记雷和空白展开，当然扫雷的基本特性也会实现。
C语言实现扫雷小游戏（扩展版）
酸奶的博客
05-28 5715
游戏简介 扫雷，是一款益智类小游戏。 游戏目标是找出所有没有地雷的方格，完成游戏；要是按了有地雷的方格，游戏失败；玩家可标记雷的位置。游戏以完成时间来评高低。有不同的游戏难度可选择。 实现的功能介绍 1.初始化雷盘 2.打印雷盘 3.随机设置雷的分布，可选择游戏难易程度 4.统计坐标位置周围的雷数 5.扩展式排雷，展开周围的非雷区 6.给所选坐标位置做标记，或取消...
c语言简易坐标式扫雷小尝试
2401_87546898的博客
11-17 868
教你如何做坐标式扫雷
C语言：作用域、链接与存储期
前进，才知道自己的渺小
04-27 416
作用域(Scope)描述程序中标识符的生效区域（可访问区域），一个C语言变量的作用域可以是块作用域、函数作用域、函数原型作用域、文件作用域。
C语言标准库函数setlocale用法详解
simple的博客
04-25 975
C语言标准库函数setlocale定义在头文件中（在C++编程中，这个头文件又等价于或。
自由学习记录（57）
red_redemption的博客
04-24 385
蓝噪声是一种在频域中低频成分较少、高频成分较多的噪声类型。​与白噪声相比，蓝噪声在视觉上更为均匀，适合用于图像处理中的抖动（dithering）和采样，能够减少明显的图案和伪影。时空蓝噪声是在传统蓝噪声的基础上，增加了时间维度（即帧序列）的考虑，使得噪声在空间和时间上都具有蓝噪声的特性。​这意味着：​空间蓝噪声：​在每一帧中，噪声在图像的二维平面上均匀分布。时间蓝噪声：​在连续的帧之间，噪声在时间轴上也均匀分布，避免了闪烁和不稳定的视觉效果。​。
Unity3D仿星露谷物语开发38之浇水动画2
benben044的专栏
04-26 392
当角色浇水的时候，不仅会显示浇水动作的动画，同时地面还会显示浇水后的颜色。隔一天之后，地面又会恢复成原貌。
游戏引擎学习第239天:通过 OpenGL 渲染游戏
虾球
04-22 1230
OpenGL 渲染逻辑成功嵌入平台层；已可运行测试，无重大崩溃；基础渲染结构已具备；已知限制：纹理尚未处理。下一步是继续观察输出验证绘制是否生效，然后逐步补上纹理相关支持，让图像完整显示。整个 OpenGL 接入工作已经完成了关键节点，逐步迈入功能扩展阶段。屏幕上确实只能看到一些基本的纯色图形由于当前还未集成纹理处理功能，因此大多数画面内容（如贴图、字体、图标等）都无法正确渲染。只要不是纯色矩形或简单形状，现阶段都不会显示。说明系统确实进入了 OpenGL 渲染路径。
[贪心_7] 最优除法 | 跳跃游戏 II | 加油站
一个人知道自己为什么而活，他就能够接收任何一种生活
04-25 1079
对步数 实现双指针 区间的维护模拟，来看 要走多少步 利用单调性：i=i+step 发现有一个起点点都跑不到某个位置，那中间的都不用在考虑了，不用在枚举了。
WebXR教学 06 项目4 跳跃小游戏
teacherchen90的博客
04-28 145
【代码】WebXR教学 06 项目4 跳跃小游戏。
游戏打击感实现
最新发布
vtheshow
04-28 140
重攻击低频大幅震动快攻高频小幅震动。
Python自我娱乐小游戏
qq_57737603的博客
04-28 215
Python实现自我娱乐小游戏
本土网盟推广孟加拉slot游戏出海营销优势
04-25 216
总的来说，本土网盟推广孟加拉游戏出海营销能够充分利用本地资源和优势，帮助游戏开发商更快速、更有效地进入孟加拉市场，实现出海游戏营销的成功。本土市场了解：本土网盟对孟加拉市场有深入的了解，能够帮助游戏开发商了解当地用户的喜好、文化特点和消费习惯，从而制定更有效的营销策略。文化包装：孟加拉是一个具有悠久历史和丰富文化的国家，本土网盟可以帮助游戏开发商对游戏进行文化包装，使之更具吸引力和亲和力。语言优势：本土网盟了解孟加拉语言的特点和表达习惯，可以帮助游戏开发商进行本地化翻译和内容创作，更好地与当地用户沟通。
CI/CD解决方案TeamCity在游戏开发中的应用价值与优势分析
weixin_49715102的博客
04-27 212
【CI/CD】游戏开发离不开高效的CI/CD工具。TeamCity作为最流行的CI/CD工具之一，受到各种规模的团队和公司（包括独立开发者、3A工作室、游戏发行商）的青睐。无论您在制作流程中使用何种工具，TeamCity都支持您为任何的工作流程设置全面的构建-测试-发布管道。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值