从前慢现在也慢

这个屌丝很懒，什么也没留下！

热门标签

C语言——扫雷小游戏（可展开一片）_扫雷小游戏代码优化

作者：从前慢现在也慢 | 2024-06-23 04:43:35

踩

扫雷小游戏代码优化

1.前言

扫雷游戏想必大家都玩过吧，但是玩过自己设计的扫雷游戏吗？本文对扫雷游戏的C语言代码的创建以及部分游戏优化进行了详细的介绍。

2.扫雷游戏的实现

2.1扫雷游戏的功能说明

通过控制台来实现扫雷游戏。
游戏可以通过菜单决定继续玩还是退出游戏。
扫雷的棋盘是9*9的格子。（可以改变）
默认随机布置10个雷。（可以改变）
可以排查雷：

如果位置不是雷，就显示周围有几个雷
如果位置是雷，就炸死游戏结束
把除10个雷之外的所有雷都找出来，排雷成功，游戏结束

2.2游戏的分析与设计

2.2.1游戏代码的主体构建

我们运行代码后，需要弹出一个菜单来让我们选择玩还是不玩。这里需要我们构建一个菜单menu，为了能让我们可以一直玩，这就需要循环结构，而且要先执行一次让我们玩过之后再进行选择，所以我们就使用do...while语句；输入“1”进行游戏；输入“0”退出游戏；输入错误则要重新输入·。这是要实现多分支语句，所以要使用switch语句。

代码如下：


#include<stdio.h>
void menu()
{
	printf("\n**********************************\n");
	printf("\n*****      1. 进行游戏       *****\n");
	printf("\n*****      0. 退出游戏       *****\n");
	printf("\n**********************************\n");
}
int main()
{
	int input = 0;
	do
	{
		menu();
		scanf("%d", &input);
		switch (input)
		{
		case 1:printf("进行游戏\n");
			break;
		case 0:printf("退出游戏\n");
			break;
		default:printf("输入错误，请重新输入\n");
			break;
		}
	} 
	while (input);
 
	return 0;
}

运行结果为：

2.2.3 数据结构的分析

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

因为我们做的是9*9的棋盘，所以我们首先想的是创立一个9*9的二维数组来存放信息。

如果这个地方布置雷，就存放 1，如果不是雷，就存放 0.

假如我们排查坐标（1,2），我们访问周围一圈黄色部分，统计雷的数量为1.

假如我们排查坐标（4,8），我们访问周围一圈黄色部分，会发现访问越界了。为了防止越界，我们在设计的时候，给数组扩大⼀圈，雷还是布置在中间的9*9的坐标上，周围⼀圈不去布置雷就行，这样就解决了越界的问题。所以我们将存放数据的数组创建成11*11是比较合适。

再继续分析，我们发现坐标（1,2）周围有一个雷，然后坐标（1,2）会填入1，你这个信息放在哪里呢？如果放进布置雷信息的数组里，这样雷的信息和雷的个数信息就可能或产生混淆和打印上的困难。

怎么解决呢?

我们专门给⼀个棋盘（对应⼀个数组mine）存放布置好的雷的信息，再给另外⼀个棋盘（对应另外⼀个数组show）存放排查出的雷的信息。把雷布置到mine数组，在mine数组中排查雷，排查出的数据存放在show数组，并且打印show数组的信息给后期排查参考。

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

对应的数组是：

2.2.4 多个文件的设计

在函数中，我们了解了多文件的形式对函数的声明和定义。因为要实现扫雷游戏的代码太多，如果放在一个文件里，会让代码变得臃肿，难以理解。所以我们要按照代码的不同功能放在不同的文件里，分模块化进行编写，这样不仅使我们的代码变得简洁明了，会便于后期代码的维护。

我们这里设计三个文件：

2.2.5棋盘初始化

我们使用宏定义来定义棋盘行数（ROW）和列数（COL）。

这样做的好处：

方便程序的修改，不用对整个程序进行修改，只需对宏定义上进行修改。
提高程序的运行效率，更加方便模块化。

代码如下：


#include"game.h"
void Initbroad(char board[ROWS][COLS], int rows, int cols, char ret)
{
	int i = 0;
	int j = 0;
	for (i = 0; i < rows; i++)
	{
		for (j = 0; j < cols; j++)
		{
			board[i][j] = ret;
         }
		printf("\n");
	}
}

2.2.6打印棋盘

为了更好地看清棋盘，我们打印上一些分割线，代码如下：


void Displaybroad(char broad[ROWS][COLS], int row, int col)
{
	printf("\n*********扫雷游戏*********\n");
	int i = 0;
	for (i = 0; i <= row; i++)
	{
		printf("%d ", i);
		if (i == 0)
		{
			printf("|");
		}
	}
	printf("\n");
	
	for (i = 0; i <= row; i++)
	{
		printf("--");
		if (i == 0)
		{
			printf("|");
		}
	}
	
	printf("\n");
	
	for (i = 1; i <= row; i++)
	{
		printf("%d |", i);
		int j = 0;
		for (j = 1; j <= col; j++)
		{
			
			printf("%c ", broad[i][j]);
		}
		printf("\n");
	}
	printf("\n*********扫雷游戏*********\n");
 
}

效果如下：

2.2.7布置雷

因为我们需要雷是随机出现的，所以这里我们需要使用rand函数来生成随机的坐标来布置雷，并把雷的布置信息储存在mine数组中。（关于rand函数生成随机数，我在猜数字游戏里总结了，不会的小伙伴可以看一下）

现在我们设计一个函数Set_mine来布置雷，基本流程如下：

代码如下：


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

2.2.8排查雷

我们设计一个函数Find_mine来排查雷，基本流程如下：

代码如下：


int Get_mine_count(char broad[ROWS][COLS], int x, int y)
{
	int count = broad[x - 1][y - 1] + broad[x - 1][y] + broad[x - 1][y + 1] + broad[x][y - 1] + broad[x][y + 1] + broad[x + 1][y - 1] + broad[x + 1][y] + broad[x + 1][y + 1] - 8 * '0';
	return count;
}
void Find_mine(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 > 0 && x <= row) && (y > 0 && y <= col))
		{
			if (mine[x][y] == '1')
			{
				printf("很遗憾，你被炸死了！！！\n");
				Displaybroad(mine, ROW, COL);
				break;
			}
			else
			{
				int count = Get_mine_count(mine, x, y);
				show[x][y] = '0' + count;
				Displaybroad(show, ROW, COL);
				win++;
			}
		}
		else
			printf("输入非法，请重新输入");
	}
	if (win == (ROW * COL - EASY_COUNT))
	{
		printf("恭喜你，排雷成功！\n");
		Displaybroad(mine, ROW, COL);
	}
}

2.3游戏的测试

游戏的代码我们已经编写完成了，现在来测试一下这些程序的功能是否能达到我们的预期。

运行结果如下：

不过10个雷测试太麻烦了，我直接设置了80个雷了进行测试，运行结果如下：

所以我们的程序运行成功了。

3.游戏的优化

我们通过游戏测试发现，我们设计的扫雷游戏跟我们之前玩的不太一样。

我们设计的扫雷游戏：

电脑上的扫雷游戏：

通过对比我们发现电脑的扫雷游戏一点就展开一片的，而我们的则没有。

那怎么让我们设计的扫雷游戏跟电脑的一样，一点就展开一片呢？

通过仔细观察上面的图我们会发现，如果我们点的格子（x,y）不是雷，那么就依次对它周围的八个格子进行排查操作，所以我们要创造一个Openbroad函数，在对我们选择的格子排查完之后，再对该格子的周围八个格子进行查雷，如此反复调用此函数。

但是这里存在了一个问题：对我们选择坐标（x，y）后，如果该坐标不是雷，那就对它周围格子进行查雷，也就是到了（x-1,y-1）,如果该坐标还不是雷，那又需要对它周围的格子进行查雷，这时候又查到了（x,y）,这就让函数走不出来了。

为了防止函数陷入死循环，我们使用两个棋盘，具体流程如下：

如图所示

：我们点击（x,y）坐标，如果坐标不是雷并且周围八个坐标都不是雷，那就把这个坐标置为空，然后在排查周围八个坐标的周围八个坐标。排查到1号坐标，该坐标周围也没有雷，就将1号坐标置为空，然后再排查1号坐标周围的八个坐标，排查的2号坐标，该坐标周围有一个雷，那么2号坐标就不能置为空，然后显示该坐标周围雷的个数，递归停止。

每个位置按上述过程进行判断一次，就可以展开一片了。

代码如下：


int win = 0;
void Openbroad(char mine[ROWS][COLS], char show[ROWS][COLS], int x, int y)
{
	int i = 0;
	int j = 0;
	int count = 0;
	for (i = x - 1; i <= x + 1; i++)
	{
		for (j = y - 1; j <= y + 1; j++)
		{
			if (mine[i][j] == '1')
			{
				count++;
			}
		}
	}
	if (count == 0)
	{
		show[x][y] = ' ';
		win++;
	}
	else
	{
		show[x][y] = count + '0';
		win++;
	}
	if (show[x][y] == ' ')
	{
		for (i = x - 1; i <= x + 1; i++)
		{
			for (j = y - 1; j <= y + 1; j++)
			{
				if ((mine[i][j] != '1' && show[i][j] == '*') && (i >= 1 && i <= ROW) && (j >= 1 && j <= COL))
				{
					Openbroad(mine, show, i, j);
				}
			}
		}
	}
}

4.完成代码

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 Initbroad(char board[ROWS][COLS], int rows, int cols, char ret);
void Displaybroad(char broad[ROWS][COLS], int row, int col);
void Set_mine(char mine[ROWS][COLS],  int row, int col);
void Find_mine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col);
//int Get_mine_count(char broad[ROWS][COLS], int x, int y);
void Openbroad(char mine[ROWS][COLS], char show[ROWS][COLS], int x, int y);

test.c


#include"game.h"
void menu()
{
	printf("\n**********************************\n");
	printf("\n*****      1. 进行游戏       *****\n");
	printf("\n*****      0. 退出游戏       *****\n");
	printf("\n**********************************\n");
}
 
void game()
{
	char show[ROWS][COLS];
	char mine[ROWS][COLS];
	//初始化棋盘
	Initbroad(show, ROWS, COLS, '*');
	Initbroad(mine, ROWS, COLS, '0');
	//打印棋盘
	Displaybroad(show, ROW, COL);
	//Displaybroad(mine, ROW, COL);
	//布置雷
	Set_mine(mine, ROW, COL);
	//Displaybroad(mine, ROW, COL);
	//排查雷
	Find_mine(mine,show, ROW, COL);
 
}
int main()
{
	int input = 0;
	srand((unsigned int)time(NULL));
	do
	{
		menu();
		scanf("%d", &input);
 
		switch (input)
		{
		case 1:game();
			break;
		case 0:printf("退出游戏\n");
			break;
		default:printf("输入错误，请重新输入\n");
			break;
		}
	} 
	while (input);
 
	return 0;
}

game.c


#define _CRT_SECURE_NO_WARNINGS 1
#include"game.h"
void Initbroad(char board[ROWS][COLS], int rows, int cols, char ret)
{
	int i = 0;
	int j = 0;
	for (i = 0; i < rows; i++)
	{
		for (j = 0; j < cols; j++)
		{
			board[i][j] = ret;
         }
		
	}
}
void Displaybroad(char broad[ROWS][COLS], int row, int col)
{
	printf("\n*********扫雷游戏*********\n");
	int i = 0;
	for (i = 0; i <= row; i++)
	{
		printf("%d ", i);
		if (i == 0)
		{
			printf("|");
		}
	}
	printf("\n");
	
	for (i = 0; i <= row; i++)
	{
		printf("--");
		if (i == 0)
		{
			printf("|");
		}
	}
	
	printf("\n");
	
	for (i = 1; i <= row; i++)
	{
		printf("%d |", i);
		int j = 0;
		for (j = 1; j <= col; j++)
		{
			
			printf("%c ", broad[i][j]);
		}
		printf("\n");
	}
	printf("\n*********扫雷游戏*********\n");
 
}
void Set_mine(char broad[ROWS][COLS], int row, int col)
{
	int count = EASY_COUNT;
	
	while (count)
	{
		int x = rand() % row + 1;
		int y = rand() % col + 1;
		if (broad[x][y] == '0')
		{
			broad[x][y] = '1';
			count--;
		}
 
		
	}
	
}
//int Get_mine_count(char broad[ROWS][COLS], int x, int y)
//{
//	int count = broad[x - 1][y - 1] + broad[x - 1][y] + broad[x - 1][y + 1] + broad[x][y - 1] + broad[x][y + 1] + broad[x + 1][y - 1] + broad[x + 1][y] + broad[x + 1][y + 1] - 8 * '0';
//	return count;
//}
int win = 0;
void Openbroad(char mine[ROWS][COLS], char show[ROWS][COLS], int x, int y)
{
	int i = 0;
	int j = 0;
	int count = 0;
	for (i = x - 1; i <= x + 1; i++)
	{
		for (j = y - 1; j <= y + 1; j++)
		{
			if (mine[i][j] == '1')
			{
				count++;
			}
		}
	}
	if (count == 0)
	{
		show[x][y] = ' ';
		win++;
	}
	else
	{
		show[x][y] = count + '0';
		win++;
	}
	if (show[x][y] == ' ')
	{
		for (i = x - 1; i <= x + 1; i++)
		{
			for (j = y - 1; j <= y + 1; j++)
			{
				if ((mine[i][j] != '1' && show[i][j] == '*') && (i >= 1 && i <= ROW) && (j >= 1 && j <= COL))
				{
					Openbroad(mine, show, i, j);
				}
			}
		}
	}
}
void Find_mine(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 > 0 && x <= row) && (y > 0 && y <= col))
		{
			if (mine[x][y] == '1')
			{
				printf("很遗憾，你被炸死了！！！\n");
				Displaybroad(mine, ROW, COL);
				break;
			}
			else
			{
				//int count = Get_mine_count(mine, x, y);
				/*show[x][y] = '0' + count;
				Displaybroad(show, ROW, COL);
				win++;*/
				Openbroad(mine, show, x ,y);
				Displaybroad(show, ROW, COL);
			}
		}
		else
			printf("输入非法，请重新输入\n");
	}
	if (win == (ROW * COL - EASY_COUNT))
	{
		printf("恭喜你，排雷成功！\n");
		Displaybroad(mine, ROW, COL);
	}
}

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/748679