C语言实现扫雷

于 2023-05-09 21:15:51 发布
阅读量331 收藏 6
点赞数 7
分类专栏： C语言 文章标签： c语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/li209779/article/details/130579033
版权

在这里插入图片描述

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

前言

相信大家大都玩过扫雷游戏，我们点击一个位置，其会显示一片区域，而其中的数字代表着该点周围8个点中的地雷数，在本期我们就来完成扫雷的实现。

一、游戏的大体思路

在这里我们假设要完成9X9大小，10个地雷的扫雷
首先我们要准备多大的二维数组(棋盘)？
要是准备9X9大小，棋盘最外层的判断就与内层的判断不同，就要分情况讨论，太麻烦了。
如果我们准备10X10大小，棋盘最外层的判断就与内层相同，情况就会简单不少。
如下：
在这里插入图片描述
在这里插入图片描述
解决了棋盘大小问题，那么我们就要来创建棋盘了。
在这里我要创建两个棋盘，一个是mine,一个是show。当然你也可以创建一个棋盘，我这里是为了方便处理。
mine中用来设置雷的位置和个数
show用来展示给用户，告诉用户棋盘的情况

解决了棋盘问题，我们就要开始设置地雷了。
在这里我用 ’ 1’ 代表雷, ’ 0 '代表不是雷。这里用 ’ 1 ’ 和 ’ 0 '是为了方便我们计算一点周围雷的个数。你也可以用其它字符表示雷与不是雷。

设置完地雷的数量和位置，我们就要打印show棋盘给用户。
我用 ‘ * ’表示未知。
打印行号与列号，帮助用户来选择坐标，
打印show中所有的内容。

将要展示给用户的棋盘打印完，我们就要开始让用户来开始游戏。

二、实现的具体思路

1.模拟登录界面

通过menu函数来提示用户选择。
再将输入内容置入循环，使用户玩完还可以再来一次。

enum
{
	EXIT,
	PLAY,
};


void menu()
{
	printf("********************\n");
	printf("*****  1.PLAY  *****\n");
	printf("*****  0.EXIT  *****\n");
	printf("********************\n");

}

int main()
{
	srand((unsigned int)time(NULL));
	int input = 0;
	do
	{
		menu();
		printf("请输入选项:>");
		scanf("%d", &input);
		switch (input)
		{
		case PLAY:
			game();
			break;
		case EXIT:
			printf("退出游戏\n");
			break;
		default:
			printf("输入错误，请从新输入\n");
			break;
		}
	} while (input);
	return 0;
}

2.创建并初始化棋盘

我用game() 来保存游戏的步骤， InitBoard() 来初始化棋盘。
InitBoard()中的 ’ 0 '和 ‘ * ’是我要初始化成的内容。
使用循环遍历每一个数组元素，使其变成我要初始为的内容。
ROW,COL是棋盘的实际行和列
ROW_SHOW,COL_SHOW是棋盘要显示的行和列


#define ROW ROW_SHOW+2
#define COL COL_SHOW+2
#define ROW_SHOW 9
#define COL_SHOW 9

void game()
{

	//创建有雷的棋盘
	char mine[ROW][COL] = { 0 };
	//创建显示的棋盘
	char show[ROW][COL] = { 0 };
	//初始化mine棋盘和show棋盘
	InitBoard(mine, ROW, COL, '0');
	InitBoard(show, ROW, COL, '*');
	//打印show棋盘
	PrintBoard(show, ROW_SHOW, COL_SHOW);
	//PrintBoard(mine, ROW_SHOW, COL_SHOW);
	//随机设下地雷
	SetMine(mine, ROW_SHOW, COL_SHOW);
	//PrintBoard(mine, ROW_SHOW, COL_SHOW);
	//排查雷
	SearchMine(mine, show, ROW_SHOW, COL_SHOW);
}

//初始化棋盘
//遍历初始化每一个元素
void InitBoard(char board[ROW][COL], int row, int col, char set)
{
	int i = 0;
	for (i = 0; i < row; i++)
	{
		int j = 0;
		for (j = 0; j < col; j++)
		{
			board[i][j] = set;
		}
	}
}

3.打印show棋盘

//打印棋盘
//双层循环控制，里层循环打印每行内容，外层循环控制次数
void PrintBoard(char board[ROW][COL], int row_show, int col_show)
{
	printf("---------------------------------\n");
	int i = 0;
	//打印列号
	for (i = 0; i <= col_show; i++)
	{
		printf(" %d ", i);
	}
	printf("\n");

	for (i = 1; i <= row_show; i++)
	{
		//打印行号
		printf(" %d ", i);
		int j = 0;
		for (j = 1; j <= col_show; j++)
		{
			//打印内容
			printf(" %c ", board[i][j]);
		}
		printf("\n");
	}
}

4.随机设置地雷

用宏MINES来表示地雷数
我们使用rand()函数来产生随机数，并将产生的随机数%要显示的行数+1，保证产生的随机数在1~row_show内，再用同样的方式，来保证产生的随机数在1—col_show内。
在检查棋盘中该位置是否未放置雷，如果未放置，则设置为雷，并记录下以放置雷的个数。
如果放置过了，则从新产生随机数。

#include <stdlib.h>
#include <tmie.h>
#define MINES 10

//随机设置地雷
//用rand()产生随机数，作为mine的行和列
//循环控制设置雷的个数
//用'1'代表雷
void SetMine(char board[ROW][COL], int row_show, int col_show)
{
	int count = 0;//记录已经放置雷的数
	for (count = 1; count <= MINES; )
	{
		int i = rand() % row_show + 1;//行
		int j = rand() % col_show + 1;//列
		//检查i和j的和法性
		if (i >= 1 && i <= row_show && j >= 1 && j <= col_show && board[i][j] == '0')
		{
			board[i][j] = '1';
			count++;
		}
	}
}

5.探查地雷（扩散式探查）

  • 扩散式探查

首先我先来讲解重要的探查部分。
我们要完成的是用户输入一个坐标，如果该坐标周围没有雷也就是该坐标返回值是 ‘ 0 ’ ，则再show中该点坐标处设置为 ‘ ’ ，则再探查该8个坐标的周围的8个点，如果满足上述情况，则继续探查周围8个点，直到有点的返回值不是 ‘ 0 ’，则把返回值填入show中该点坐标处。
如下：
在这里插入图片描述
那么像这种大量重复的功能，我们可以使用递归实现。
但这里有几个问题？

  • 问题1
    两个相邻的点如果都是 ‘ 0 ’ 其会互相调用导致死递归。
    如下：
    在这里插入图片描述
    那如何解决？
    这就是我创建两个棋盘的好处了，每次探查一个点，其都会有返回值，并在show中相应位置显示，那么没有被探查的位置其还是 ‘ * ’，那么我们每次要探查一个坐标前只要先检查其是否是 ‘ * ’ ，如果是则可以探查，如果不是则不能探查。
  • 问题2
    这样的探查方式，探查到最外层时，一定会导致越界访问
    如下：
    在这里插入图片描述
    那么如何解决？
    非常简单，其实我们只要限定可以探查的点是在可显示棋盘内部就可以，在可显示外的不用管理即可。
//扩散式查找
//递归实现
//如果该点CountMines结果是0，将show中该点变成' '，则再查找这点的周围8点的个子CountMines的结果是否是0
//如果是则循环上述过程
void Spread(char mine[ROW][COL], char show[ROW][COL], int row_show, int col_show, int x, int y)
{
	int count = 1;
	//检查坐标的合法性
	if (x >= 1 && x <= row_show && y >= 1 && y <= col_show && show[x][y] == '*')
	{
		count = CountMines(mine, x, y);
		if (count == 0)
		{
			show[x][y] = ' ';
			//查找(x,y)周围8点
			int i = 0;
			for (i = x - 1; i <= x + 1; i++)
			{
				int j = 0;
				for (j = y - 1; j <= y + 1; j++)
				{
					Spread(mine, show, row_show, col_show, i, j);
				}
			}
		}//end_if (count == 0)
		else
		{
			show[x][y] = count + '0';
		}
	}//end_if (x >= 1 && x <= row_show && y >= 1 && y <= col_show && show[x][y] == '*')
}
  • 返回雷的数量（CountMines()）
    既然我们已经知道如何实现扩散式探查，那么我们就要考虑要探查点周围8点如何返回雷的数量的问题。
    这里就到了我为什么是用 ‘ 1 ’表示雷，而不是用其它的符号。
    我们要知道在ASCII码表中 ‘ 0 ’ ， ‘ 1 ’ ，‘ 2 ’到字符9是连续排列的。
    如下：
    在这里插入图片描述
    那么我只要让其8个坐标相加在减去8个字符0，就可以得到这8个位置有多少个雷。

如下：

//查找周围雷的数量
//通过ASCII码表转换
int CountMines(char board[ROW][COL], int x, int y)
{
	return (board[x - 1][y - 1] + board[x - 1][y] + board[x - 1][y + 1]
		+ board[x][y - 1] + board[x][y + 1] + board[x + 1][y - 1]
		+ board[x + 1][y] + board[x + 1][y + 1] - 8 * '0');
}
  • 如何判断游戏的状态
    在这里我是想每探查一次就判断在mine中该点是否是雷，如果是则直接结束游戏，如果不是则继续探查，直到探查到雷或show中剩余的‘ * ’ （为探查部分） 与雷的数目相当则代表我们赢了
    也就是说，我们只要数‘ * ’的数目是否与雷的数目相当就可以判断游戏状态。
//查找show中剩余'*'的数量
//遍历show中可显示部分中的'*'的数量
int Counts(char board[ROW][COL], int row_show, int col_show)
{
	int count = 0;
	int i = 0;
	for (i = 1; i <= row_show; i++)
	{
		int j = 0;
		for (j = 1; j <= col_show; j++)
		{
			if (board[i][j] == '*' || board[i][j] == '%')
				count++;
		}
	}
	return count;
}

上述三点合起来就可以完成探查地雷（扩散式探查）
当然我们每次用户探查完一次要打印一次show棋盘
在这里我加入了排除一个点的功能，当然你也可以加入其它更好的功能

//探查雷(完整版)
//加入了一次探查一片的功能
void SearchMine(char mine[ROW][COL], char show[ROW][COL], int row_show, int col_show)
{
	//是否排除
	int k = 0;
	//可排查次数
	int count = MINES - 1;
	//坐标的行列
	int i = 0;
	int j = 0;
	//游戏状态
	//如果show中'*'等于MINES的数量则退出游戏
	int ret = 0;
	//死循环
	//只有探查的点正好是雷结束
	//或剩余未探查的数目等于雷的数目
	while (1) 
	{
		//排除坐标
		while (count)
		{
			printf("可排查次数: %d\n", count);
			printf("1.是   0.否\n");
			printf("是否要排除坐标:>");
			scanf("%d", &k);
			if (k)
			{
				Elimiate(show, row_show, col_show);
				count--;
			}
			break;
		}
		//探查坐标
		printf("请输入要探查的坐标:>");
		scanf("%d %d", &i, &j);
		//坐标合法性的检查
		if (i >= 1 && i <= row_show && j >= 1 && j <= col_show && show[i][j] == '*')
		{
			if (mine[i][j] == '1')
			{
				printf("你被炸死了!!!\n");
				ShowMines(mine, show, row_show, col_show);
				show[i][j] = '&';
				//打印show棋盘
				PrintBoard(show, ROW_SHOW, COL_SHOW);
				break;
			}
			//扩散式查找
			Spread(mine, show, row_show, col_show, i, j);
			//打印show棋盘
			PrintBoard(show, ROW_SHOW, COL_SHOW);
			ret = Counts(show, row_show, col_show);
			if (ret == MINES)
			{
				ShowMines(mine, show, row_show, col_show);
				printf("你赢了！！！\n");
				break;
			}
		}//end_if
		else
		{
			printf("输入错误，请重新输入\n");
		}
	}//end_while
}

三，代码的实现

将上述代码整理为多文件的方式管理
test.c文件用来存放登录界面
game,c文件用来存放游戏的有关函数的实现
game.h文件用来存放这个项目会用到的头文件，定义的宏，函数的声明。

test.c文件

#include "game.h"

void menu()
{
	printf("********************\n");
	printf("*****  1.PLAY  *****\n");
	printf("*****  0.EXIT  *****\n");
	printf("********************\n");

}

int main()
{
	srand((unsigned int)time(NULL));
	int input = 0;
	do
	{
		menu();
		printf("请输入选项:>");
		scanf("%d", &input);
		switch (input)
		{
		case PLAY:
			game();
			break;
		case EXIT:
			printf("退出游戏\n");
			break;
		default:
			printf("输入错误，请从新输入\n");
			break;
		}
	} while (input);
	return 0;
}

game.c文件

#include "game.h"

void game()
{

	//创建有雷的棋盘
	char mine[ROW][COL] = { 0 };
	//创建显示的棋盘
	char show[ROW][COL] = { 0 };
	//初始化mine棋盘和show棋盘
	InitBoard(mine, ROW, COL, '0');
	InitBoard(show, ROW, COL, '*');
	//打印show棋盘
	PrintBoard(show, ROW_SHOW, COL_SHOW);
	//PrintBoard(mine, ROW_SHOW, COL_SHOW);
	//随机设下地雷
	SetMine(mine, ROW_SHOW, COL_SHOW);
	//PrintBoard(mine, ROW_SHOW, COL_SHOW);
	//排查雷
	SearchMine(mine, show, ROW_SHOW, COL_SHOW);
}

//初始化棋盘
//遍历初始化每一个元素
void InitBoard(char board[ROW][COL], int row, int col, char set)
{
	int i = 0;
	for (i = 0; i < row; i++)
	{
		int j = 0;
		for (j = 0; j < col; j++)
		{
			board[i][j] = set;
		}
	}
}


//打印棋盘
//双层循环控制，里层循环打印每行内容，外层循环控制次数
void PrintBoard(char board[ROW][COL], int row_show, int col_show)
{
	printf("---------------------------------\n");
	int i = 0;
	//打印列号
	for (i = 0; i <= col_show; i++)
	{
		printf(" %d ", i);
	}
	printf("\n");

	for (i = 1; i <= row_show; i++)
	{
		//打印行号
		printf(" %d ", i);
		int j = 0;
		for (j = 1; j <= col_show; j++)
		{
			//打印内容
			printf(" %c ", board[i][j]);
		}
		printf("\n");
	}
}


//随机设置地雷
//用rand()产生随机数，作为mine的行和列
//循环控制设置雷的个数
//用'1'代表雷
void SetMine(char board[ROW][COL], int row_show, int col_show)
{
	int count = 0;
	for (count = 1; count <= MINES; )
	{
		int i = rand() % row_show + 1;
		int j = rand() % col_show + 1;
		//检查i和j的和法性
		if (i >= 1 && i <= row_show && j >= 1 && j <= col_show && board[i][j] == '0')
		{
			board[i][j] = '1';
			count++;
		}
	}
}
//探查雷(完整版)
//加入了一次探查一片的功能
//通过用户输入的坐标查找mine中该坐标周围8个坐标是否有雷
//并将雷的个数传给show的该坐标处
void SearchMine(char mine[ROW][COL], char show[ROW][COL], int row_show, int col_show)
{
	//是否排除
	int k = 0;
	//可排查次数
	int count = MINES - 1;
	//坐标的行列
	int i = 0;
	int j = 0;
	//游戏状态
	//如果show中'*'等于MINES的数量则退出游戏
	int ret = 0;

	while (1) 
	{
		while (count)
		{
			printf("可排查次数: %d\n", count);
			printf("1.是   0.否\n");
			printf("是否要排除坐标:>");
			scanf("%d", &k);
			if (k)
			{
				Elimiate(show, row_show, col_show);
				count--;
			}
			break;
		}
		printf("请输入要探查的坐标:>");
		scanf("%d %d", &i, &j);
		//坐标合法性的检查
		if (i >= 1 && i <= row_show && j >= 1 && j <= col_show && show[i][j] == '*')
		{
			if (mine[i][j] == '1')
			{
				printf("你被炸死了!!!\n");
				ShowMines(mine, show, row_show, col_show);
				show[i][j] = '&';
				//打印show棋盘
				PrintBoard(show, ROW_SHOW, COL_SHOW);
				break;
			}
			//扩散式查找
			Spread(mine, show, row_show, col_show, i, j);
			//打印show棋盘
			PrintBoard(show, ROW_SHOW, COL_SHOW);
			ret = Counts(show, row_show, col_show);
			if (ret == MINES)
			{
				ShowMines(mine, show, row_show, col_show);
				printf("你赢了！！！\n");
				break;
			}
		}//end_if
		else
		{
			printf("输入错误，请重新输入\n");
		}
	}//end_while
}


//查找周围雷的数量
//通过ASCII码表转换
int CountMines(char board[ROW][COL], int x, int y)
{
	return (board[x - 1][y - 1] + board[x - 1][y] + board[x - 1][y + 1]
		+ board[x][y - 1] + board[x][y + 1] + board[x + 1][y - 1]
		+ board[x + 1][y] + board[x + 1][y + 1] - 8 * '0');
}


//查找show中剩余'*'的数量
//遍历show中可显示部分中的'*'的数量
int Counts(char board[ROW][COL], int row_show, int col_show)
{
	int count = 0;
	int i = 0;
	for (i = 1; i <= row_show; i++)
	{
		int j = 0;
		for (j = 1; j <= col_show; j++)
		{
			if (board[i][j] == '*' || board[i][j] == '%')
				count++;
		}
	}
	return count;
}

//扩散式查找
//递归实现
//如果该点CountMines结果是0，将show中该点变成' '，则再查找这点的周围8点的个子CountMines的结果是否是0
//如果是则循环上述过程
void Spread(char mine[ROW][COL], char show[ROW][COL], int row_show, int col_show, int x, int y)
{
	int count = 1;
	//检查坐标的合法性
	if (x >= 1 && x <= row_show && y >= 1 && y <= col_show && show[x][y] == '*')
	{
		count = CountMines(mine, x, y);
		if (count == 0)
		{
			show[x][y] = ' ';
			//查找(x,y)周围8点
			int i = 0;
			for (i = x - 1; i <= x + 1; i++)
			{
				int j = 0;
				for (j = y - 1; j <= y + 1; j++)
				{
					Spread(mine, show, row_show, col_show, i, j);
				}
			}
		}//end_if (count == 0)
		else
		{
			show[x][y] = count + '0';
		}
	}//end_if (x >= 1 && x <= row_show && y >= 1 && y <= col_show && show[x][y] == '*')
}

//显示雷的位置在show
//遍历mine查找雷的位置
//在show相同位置设置为'#'
void ShowMines(char mine[ROW][COL], char show[ROW][COL], int row_show, int col_show)
{
	int i = 0;
	for (i = 1; i <= row_show; i++)
	{
		int j = 0;
		for (j = 1; j < row_show; j++)
		{
			if (mine[i][j] == '1')
			{
				show[i][j] = '#';
			}
		}
	}
}

//排除show中的点
//排查用'%'表示
void Elimiate(char show[ROW][COL], int row_show, int col_show)
{
	while(1)
	{
		int i = 0;
		int j = 0;
		printf("请输入要排除的坐标:>");
		scanf("%d %d", &i, &j);
		if (i >= 1 && i <= row_show && j >= 1 && j <= col_show && show[i][j] == '*')
		{
			show[i][j] = '%';
			//打印show棋盘
			PrintBoard(show, ROW_SHOW, COL_SHOW);
			return;
		}
		else
		{
			printf("坐标输入错误，请从新输入\n");
		}
	}
}

game.h文件

#define _CRT_SECURE_NO_WARNINGS 1

#define ROW ROW_SHOW+2
#define COL COL_SHOW+2
#define ROW_SHOW 9
#define COL_SHOW 9
#define MINES 10


#include <stdio.h>
#include <time.h>
#include <stdlib.h>



enum
{
	EXIT,
	PLAY,
};


//游戏的大体步骤
void game();

//初始化棋盘
//对于mine数组初始化为'0'
//对于show数组初始化为'*'
void InitBoard(char board[ROW][COL], int row, int col, char set);

//打印棋盘
void PrintBoard(char board[ROW][COL], int row_show, int col_show);

//随机设置地雷
void SetMine(char board[ROW][COL], int row_show, int col_show);

//排查雷
void SearchMine(char mine[ROW][COL], char show[ROW][COL], int row_show, int col_show);

//查找周围雷的数量
int CountMines(char board[ROW][COL], int x, int y);

//查找show中剩余'*'的数量
int Counts(char board[ROW][COL], int row_show, int col_show);

//扩散式查找
void Spread(char mine[ROW][COL], char show[ROW][COL], int row_show, int col_show, int x, int y);

//显示雷的位置在show中
void ShowMines(char mine[ROW][COL], char show[ROW][COL], int row_show, int col_show);

//排除show中的点
void Elimiate(char show[ROW][COL], int row_show, int col_show);

总结

以上就是我对于用C语言实现扫雷的思路和代码实现

水月梦镜花
关注
  • 7
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
用C语言实现扫雷
12-06
用C语言实现扫雷 让大家都能使用C++做扫雷，这就是我在空余时间编的扫雷，比其他人编的要好的多
C语言扫雷
weixin_43989236的博客
04-01 575
游戏主体 游戏的执行过程, // 玩家看到的地图, 保存有地雷位置的地图, 地图数组的行边界, 地图数组的列边界, 该局生成的地雷数 void Game(char* show_map, char* mine_map, int max_row, int max_col, int number_of_mines) { InitMap(show_map, max_row, max_col); ...
c语言实现扫雷
Freedom_的博客
04-22 190
定义两个二维数组：mine用来布雷、show用来显示扫雷情况、mine初始化为’0’、show初始化为’*’; 开始扫雷输入坐标、如果有雷、提示你踩雷了，本轮游戏结束，如果没雷继续扫直到扫完所有没有雷的地方，没扫一次会提示其周围有几个雷。因为统计四周，边缘位置不好实现，所以把二维数组的行和列都加二，这样无论是否在边缘都可以当做一种情况来实现。1.game.h(声明函数）#ifndef _GAME_...
C语言实现扫雷游戏及其优化
08-25
主要为大家详细介绍了C语言实现扫雷游戏及其优化，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
C语言实现扫雷游戏
08-25
主要为大家详细介绍了C语言实现扫雷游戏，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
C语言实现扫雷程序
08-25
主要为大家详细介绍了C语言实现扫雷程序，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
小白C语言实现扫雷游戏
最新发布
02-17
利用函数和数组的有关知识，C语言实现简单的扫雷游戏，有助于刚学习C语言的新手对于代码和逻辑结构的理解和运用，比较有价值
C语言实现扫雷小游戏
08-25
主要为大家详细介绍了C语言实现扫雷小游戏,文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
c语言 扫雷
07-12
C语言 扫雷 主要特色： 1.彩色界面 2.方向键控制方向，Enter键确认 3.支持多用户登录，存储每个用户的游戏记录，支持用户注册 4.可标记雷区
扫雷(C语言)
03-22
用C加上windows的easyx的图形库编写的一个扫雷游戏。
C语言实现扫雷小游戏(扩展版可选择游戏难度)
08-25
游戏目标是找出所有没有地雷的方格，完成游戏；要是按了有地雷的方格，游戏失败；玩家可标记雷的位置,游戏以完成时间来评高低,并且用户可以选择游戏难度
C语言实现扫雷小游戏（适合初学者）
08-19
主要为大家详细介绍了C语言实现扫雷小游戏，适合初学者练习，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
C语言实现扫雷游戏功能
05-26
C语言实现扫雷游戏
c语言 实现扫雷
weixin_70991473的博客
11-10 878
大家好呀！上篇博客中我们用c语言大致模拟出了三子棋，今天这篇博客又要介绍模拟实现扫雷了！！大家伙都了解扫雷的规则吧?这里简单介绍一下：首先我们有一个棋盘，这个棋盘假设就是9x9的大小,这81个格子里面有10地雷。我们需要找出10个地雷的位置，这样我们就赢得胜利了。当然扫雷也有简单或是相对困难的模式，就是调整棋盘的大小或是地雷的个数。我们看见菜单后选择一个数字，1就是玩扫雷游戏。0就是退出游戏。其他的数字就输入错误，要重新输入。{do{menu();
扫雷自定义最难C语言,C语言实现扫雷小游戏(扩展版可选择游戏难度)
05-26
实现扫雷小游戏涉及到的主要步骤包括生成雷区、处理用户输入、显示游戏界面等。以下是一个简单的扫雷游戏实现，包括自定义难度的扩展版： ```c #include #include #include // 定义雷区的宽度、高度、雷数和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

水月梦镜花

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值