C语言扫雷小游戏

小灰灰 2023-10-09 23:03 17阅读 0赞

#### 扫雷小游戏 ####

*  一，扫雷游戏的理解和整体思路
 *   *  1. 扫雷游戏的玩法
     *  2.写扫雷小游戏的整体思路
 *  二，函数功能的实现模块
 *   *  1.宏定义
     *  2.打印菜单
     *  3.初始化雷盘
     *  4.打印雷盘
     *  5.布置雷
     *  6.玩家排雷
     *   *  6.1 显示该坐标有几个雷的函数
         *  6.2雷盘展开函数的实现
     *  三.最终扫雷游戏的的实现
     *   *  1.test.c(存放主函数和函数的调用)
         *  2.game.h(存放宏定义和函数的声明)
         *  3.game.c（存放函数功能的实现）
     *  四.展示扫雷
     *   *  扫雷失败：
         *  2.扫雷成功：

## 一，扫雷游戏的理解和整体思路 ##

### 1. 扫雷游戏的玩法 ###

扫雷的玩法：在一个9×9（初级）、16×16（中级）、16×30（高级）或自定义大小的方块矩阵中随机布置一定量的地雷（初级为10个，中级为40个，高级为99个），再由玩家逐个翻开方块，翻开的地方将显示周围八个雷的个数。以找出所有地雷为最终游戏目标。如果玩家翻开的方块有地雷，则游戏结束。

### 2.写扫雷小游戏的整体思路 ###

宏定义——打印菜单选择游戏——初始化雷盘——打印雷盘——布置地雷——玩家排雷——递归展开无雷区域

## 二，函数功能的实现模块 ##

### 1.宏定义 ###

#define MineCount 10 //布置雷的数量
    
    #define ROW 9 // 打印时实际雷盘的行
    #define COL 9 // 打印时实际雷盘的列
    
    #define ROWS ROW+2 //定义雷盘的行
    #define COLS COL+2 //定义雷盘的列

**提示：为什么定义的雷盘行列要比实际打印出的雷盘多2呢？**  
\*\*为了防止数组越界。\*\*在前面扫雷玩法提到，翻到的方格要统计出周围八个方格雷的个数，可是在边界的方格已经无法统计了，因为已经没有多余的方格了，那数组在访问时就会越界，所以我们这样做，比如我们要玩9\*9的雷盘，就创建11 \* 11的雷盘，这样就可以避免了。  
![如图】][30ce5397fb874681bcc5b46508e95fae.png]

![在这里插入图片描述][9223d96d673847f5863982717953516b.png]

### 2.打印菜单 ###

咱们玩一次扫雷游戏肯定是不过瘾的，一次结束后想再来几次，需重复进行的，那就在主函数中用到do while语句，在do while 里面有游戏菜单进行选择玩(1.play)或退出(0.exit)，选择语句我们用switch。

void menu()
    {
        
    	
    	printf("\n*********************\n");
    	printf("******* 1.play ******\n");
    	printf("******* 0.exit ******\n");
    	printf("*********************\n");
    }
    
    int main()
    {
        
    	int input;//定义一个输入的变量
    	srand((unsigned )time(NULL));//这个是后面随机布雷会用到的的rand（）的声明
    	
    	do
    	{
        
    		menu();//打印菜单的内容
    		printf("请选择:>");
    		scanf("%d", &input);
    		
    		
    		switch (input)
    		{
        
    		case 1:
    		{
        
    			game();//进入到游戏中
    			break;
    		}
    		case 0:
    		{
        
    			printf("退出游戏\n");
    			break;
    		}
    		default:
    		{
        
    			printf("输入错误，请重新输入\n");
    			break;
    		}
    
    		}
    		
    	}while (input);
    		return 0;
    }

![在这里插入图片描述][81049944767445f188710f9de5d9b8b5.png]

### 3.初始化雷盘 ###

咱们定义两个数组：  
**1.mine 数组用来存放雷，是可以知道放雷的位置的，全部初始化为0**

创建初始化雷盘及其引用

InitBoard(mine, ROWS, COLS,'0');//传递
    void InitBoard(char board[ROWS][COLS], int rows, int cols, char set);
    //接收                  数组              行         列      初始字符

初始化雷盘的功能

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

\*\*2.show 数组是玩家用来排雷，看不见雷的位置，全部初始化为 \*\*\*

InitBoard(show, ROWS, COLS,'*');
    void InitBoard(char board[ROWS][COLS], int rows, int cols, char set);
    //接收                  数组              行         列      初始字符

以上都是调用同一个函数，只是数组参数不同。

### 4.打印雷盘 ###

咱们将刚刚初始化的两个数组打印出来看看效果

DisplayBoard(show, ROW, COL);//传入show数组，调用打印函数
     DisplayBoard(mine, ROW, COL);//传入mine数组，调用打印函数
    void Displayboard(char board[ROWS][COLS], int row, int col);
    //接收                 数组                 行         列
    //数组还是那个11*11的数组，但是我只显示9*9的数组

打印雷盘函数功能

void DisplayBoard(char board[ROWS][COLS], int row, int col)
    {
        
    	int i = 0;
    	printf("-----扫雷游戏-----\n");//提示是扫雷小游戏
    	for (i = 0; i <= col; i++)//先打印行数，好让玩家直到横坐标
    	{
        
    		printf("%d ", i);
    	}
    	printf("\n");
    	for (i = 1; i <= row; i++)
    	{
        
    		printf("%d ", i);//打印列数，好让玩家知道纵坐标
    		int j = 0;
    		for (j = 1; j <= col; j++)
    		{
        
    			printf("%c ", board[i][j]);//打印出每一个数组元素
    
    		}
    		printf("\n");
    
    	}
    }

![在这里插入图片描述][048727f2bcfc499dba4f775fb6a63029.png]

### 5.布置雷 ###

我们之前说用mine数组（全部初始化为0的数组）来存放雷，放雷的位置是随机的，具体函数用到随机srand（）和rand（）来放雷，我们用rand（）的返回值（0~10）来作为数组中的坐标，再把这个坐标的字符 0 替换成字符 1 ，就可以表示这个坐标有雷。

SetMine(mine, ROW, COL);
    void SetMine(char board[ROWS][COLS], int row, int col);

void SetMine(char board[ROWS][COLS], int row, int col)
    {
        
    	int count = MineCount;//雷的个数在宏定义中定义
    	//假定MineCount是十个雷,随机放到mine数组中
    	while (count)
    	{
        
    
    		int x = rand() % row + 1;//横坐标
    		int y = rand() % col + 1;//纵坐标
    		//得到横纵坐标就可以替换了
    		if (board[x][y] == '0')//如果这个坐标为'0'，就替换'1'，反之不用
    		{
        
    			board[x][y] = '1';//进行替换
    			count--;
    		}
    	}
    }

![在这里插入图片描述][8410087e43034bab82312bdf3c5a00e8.png]

### 6.玩家排雷 ###

具体思路：玩家输入坐标，同时对应show和mine数组，先进入mine数组(’ \* ‘)，再判断show数组（’ 1 ’ 或 ’ 0 ‘）上该坐标是否为’ 1 ‘,如果是，就打印被雷炸死，然后再打印mine数组告诉他雷的位置，然后退出游戏。如果不是，就用递归拓展开，将该坐标没有雷的位置拓展开（将’ 0 '替换成 ‘空格’）直到踩到雷或排完雷游戏结束。

排雷函数的创建和引用

FindMine(mine, show, ROW, COL);//传入两个数组和行列参数
    void FindMine(char show[ROWS][COLS],char mine[ROWS][COLS],int row, int col)
                  //接收show数组    //接收mine数组          接收行     接收列

排雷函数功能的实现

void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
    {
        
    	int x = 0, y = 0;//代表要输入的坐标
    	int win = 0;//表示不是雷的个数，比如说在9*9的雷盘里，有10雷，那不是雷的个数就是9*9 - 10 = 71个
    
    	while (win<row*col-MineCount)//就是还有可以排除的雷，游戏继续
    	{
        
    		
    		printf("请输入排雷的坐标,中间用空格;>");
    		scanf("%d %d", &x, &y);//输入坐标
    		if (show[x][y] == '*')//先判断show数组中是否为'*'
    		{
        
    			if (x >= 1 && x <= row && y >= 1 && y <= col)//确保输入的是该雷盘的坐标
    			{
        
    
    				if (mine[x][y] == '1')//恭喜你踩到雷了
    				{
        
    					system("cls");//先清屏一下
    					printf("很遗憾，你被炸死了\n");
    					DisplayBoard(show, ROW, COL);//告诉你雷放的位置
    					printf("这是雷的分布图\n");
    					DisplayBoard(mine, ROW, COL);
    					
    					break;
    
    				}
    				else//当你没踩到雷时，进来
    				{
        
    					expand(mine, show, x, y, &win);//调用拓展开该坐标没有雷时的函数
    					DisplayBoard(show, row, col);
    					printf("--------------还需翻开%d格--------------\n", row * col - MineCount - win);//打印拓展后剩余的方格
    
    										
    				}
    			}
    			else
    			{
        
    				printf("坐标非法，请重新输入\n");//输入的坐标不输入雷盘的
    			}
    		}
    		else
    		{
        
    			printf("该坐标已经排查，");//该坐标已经替换成' '
    		}
    	}
    	if (win == row * col - MineCount)//已排查完雷，游戏结束
    	{
        
    		printf("恭喜你，排雷成功\n");
    		DisplayBoard(mine, ROW, COL);//调用放雷的位置给你康康
    	}
    
    }

#### 6.1 显示该坐标有几个雷的函数 ####

具体思路：你输入一个坐标（x,y）,然后调用GetMineCount函数来统计该坐标周围中雷的个数。那如何统计呢？是这样的，（x,y）是你输入的坐标，所以我们就可以知道它周围的八个坐标，如下图，我们对周围八个坐标进行相加（比如0+0+0+1+1+0+0+1+0 = 3）。**但是要注意的是，我们这里进行的是字符的相加，不是数字的相加，字符转换数字要 - ’0‘，刚刚我们计算的有8个字符，所以要减去8个字符’0‘，才得到数字，再返回这个数字替换（x，y)，就可以显示雷的个数**  
![在这里插入图片描述][533647281a0e468eba2902573a836760.png]

统计雷的个数函数的创建及引用

int count = GetMineCount(mine, x, y);//传入mine数组和输入的该坐标
    int  GetMineCount(char mine[ROWS][COLS], int x, int y)
    //                       接收mine     接收坐标  x   y

统计雷的个数的函数功能

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

#### 6.2雷盘展开函数的实现 ####

具体思路:用递归来展开雷盘，雷盘展开的条件有：  
1.该坐标不是雷  
2.该坐标周围没有雷  
3.坐标没有被排查过

雷盘展开函数的创建及引用

expand(mine, show, x, y, &win);//传入两个数组，坐标，不是雷的个数参数
    void expand(char mine[ROWS][COLS], char show[ROWS][COLS], int x, int y, int* win);

雷盘展开函数的功能(递归实现)

void expand(char mine[ROWS][COLS], char show[ROWS][COLS], int x, int y, int* win)
    {
        
    
    	if (x >= 1 && x <= ROW && y >= 1 && y <= COL) //限制在棋盘内展开，防止越界
    	{
        
    		int count = GetMineCount(mine, x, y);//获取雷数
    
    		if (count == 0) //四周没雷，进入递归展开
    		{
        
    			show[x][y] = ' ';//四周没雷的改为 空格  ' '
    
    
    			int i = 0;
    			//向四周共8个位置递归
    			for (i = x - 1; i <= x + 1; i++)
    			{
        
    				int j = 0;
    				for (j = y - 1; j <= y + 1; j++)
    				{
        
    
    					//只对 '*' 进行展开，防止死循环
    					if (show[i][j] == '*')
    					{
        
    						expand(mine, show, i, j, win);//再调用
    					}
    
    				}
    			}
    		}
    		else   //四周有雷显示雷数
    		{
        
    			show[x][y] = count + '0';
    		}
    
    		//记录展开的数量
    		(*win)++;
    	}
    }

> 展开的例子

![在这里插入图片描述][01967a7f73584f4abf0c1a3d773db95f.png]

### 三.最终扫雷游戏的的实现 ###

#### 1.test.c(存放主函数和函数的调用) ####

#define _CRT_SECURE_NO_WARNINGS 1
    #include"game.h"
    
    void game()
    {
        
    	char mine[ROWS][COLS];
    	char show[ROWS][COLS];
    	//初始化棋盘
    	//1.mine数组最开始是全0；
    	//2.show数组最开始是全*；
    	InitBoard(mine, ROWS, COLS,'0');
    	InitBoard(show, ROWS, COLS, '*');
    	//打印棋盘
    	//DisplayBoard(mine, ROW, COL);//想看雷放的位置可以解掉该注释
    	DisplayBoard(show, ROW, COL);
    	//1.布置雷
    	SetMine(mine, ROW, COL);//放雷
    	DisplayBoard(mine, ROW, COL);
    	
    	//排查雷
    	FindMine(mine, show, ROW, COL);//排雷
    
    }
    
    
    
    void menu()
    {
        
    	
    	printf("\n*********************\n");
    	printf("******* 1.play ******\n");
    	printf("******* 0.exit ******\n");
    	printf("*********************\n");
    }
    
    int main()
    {
        
    	int input;
    	srand((unsigned )time(NULL));
    	
    	do
    	{
        
    		menu();
    		printf("请选择:>");
    		scanf("%d", &input);
    		
    		
    		switch (input)
    		{
        
    		case 1: //选择1进行游戏，进入到game，
    		{
        
    			game();
    			break;
    		}
    		case 0:
    		{
        
    			printf("退出游戏\n");
    			break;
    		}
    		default:
    		{
        
    			printf("输入错误，请重新输入\n");
    			break;
    		}
    
    		}
    		
    	}while (input);
    		return 0;
    }

#### 2.game.h(存放宏定义和函数的声明) ####

#pragma once
    #include<stdio.h>
    #include<stdlib.h>
    #include<math.h>
    #include<time.h>
    #include<Windows.h>
    
    #define MineCount 10 //布置雷的数量
    
    #define ROW 9 // 打印时实际雷盘的行
    #define COL 9 // 打印时实际雷盘的列
    #define ROWS ROW+2 //定义雷盘的行
    #define COLS COL+2 //定义雷盘的列
    
    
    //初始化棋盘
    void InitBoard(char board[ROWS][COLS], int rows, int cows, char set);
    
    //展示棋盘
    void Displayboard(char board[ROWS][COLS], int row, int col);//数组还是那个11*11的数组，但是我显示显示9*9的数组
    
    //布置雷
    void SetMine(char board[ROWS][COLS], int row, int col);
    
    //排雷
    void FindMine(char show[ROWS][COLS],char mine[ROWS][COLS],int row, int col);
    
    //递归扩展空白处
    void expand(char mine[ROWS][COLS], char show[ROWS][COLS], int x, int y, int* win);

#### 3.game.c（存放函数功能的实现） ####

#define _CRT_SECURE_NO_WARNINGS 1
    #include"game.h"
    
    void InitBoard(char board[ROWS][COLS], int rows, int cols, char set)
    {
        
    	
    	int i = 0;
    	for (i = 0; i < rows; i++)
    	{
        
    		int j = 0;
    		for (j = 0; j < cols; j++)
    		{
        
    			board[i][j] = set;
    		}
    
    	}
    
    }
    
    void DisplayBoard(char board[ROWS][COLS], int row, int col)
    {
        
    	int i = 0;
    	printf("-----扫雷游戏-----\n");
    	for (i = 0; i <= col; i++)
    	{
        
    		printf("%d ", i);
    	}
    	printf("\n");
    	for (i = 1; i <= row; i++)
    	{
        
    		printf("%d ", i);
    		int j = 0;
    		for (j = 1; j <= col; j++)
    		{
        
    			printf("%c ", board[i][j]);
    
    		}
    		printf("\n");
    
    	}
    }
    
    void SetMine(char board[ROWS][COLS], int row, int col)
    {
        
    	int count = MineCount;
    	//布置是十个雷,随机放到mine数组中
    	while (count)
    	{
        
    
    		int x = rand() % row + 1;
    		int y = rand() % col + 1;
    		if (board[x][y] == '0')
    		{
        
    			board[x][y] = '1';
    			count--;
    		}
    	}
    }
    
    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');
    }
    
    void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
    {
        
    	int x = 0, y = 0;
    	int win = 0;
    
    	while (win<row*col-MineCount)
    	{
        
    		
    		printf("请输入排雷的坐标,中间用空格;>");
    		scanf("%d %d", &x, &y);
    		if (show[x][y] == '*')
    		{
        
    			if (x >= 1 && x <= row && y >= 1 && y <= col)
    			{
        
    
    				if (mine[x][y] == '1')
    				{
        
    					system("cls");
    					printf("很遗憾，你被炸死了\n");
    					DisplayBoard(show, ROW, COL);
    					printf("这是雷的分布图\n");
    					DisplayBoard(mine, ROW, COL);
    					
    					break;
    
    				}
    				else
    				{
        
    					expand(mine, show, x, y, &win);
    
    					//system("cls");//清屏
    					DisplayBoard(show, row, col);
    					printf("--------------还需翻开%d格--------------\n", row * col - MineCount - win);
    
    						
    					//该坐标不是雷，就统计这个坐标周围有几个雷
    					/*int count = GetMineCount(mine, x, y);
    					show[x][y] = count + '0';
    					DisplayBoard(show, ROW, COL);*/
    					
    				}
    			}
    			else
    			{
        
    				printf("坐标非法，请重新输入\n");
    			}
    		}
    		else
    		{
        
    			printf("该坐标已经排查，");
    		}
    	}
    	if (win == row * col - MineCount)
    	{
        
    		printf("恭喜你，排雷成功\n");
    		DisplayBoard(mine, ROW, COL);
    	}
    
    }
    
    //递归展开
    
    void expand(char mine[ROWS][COLS], char show[ROWS][COLS], int x, int y, int* win)
    {
        
    
    	if (x >= 1 && x <= ROW && y >= 1 && y <= COL) //限制在棋盘内展开，防止越界
    	{
        
    		int count = GetMineCount(mine, x, y);//获取雷数
    
    		if (count == 0) //四周没雷，进入递归展开
    		{
        
    			show[x][y] = ' ';//四周没雷的改为 空格  ' '
    
    
    			int i = 0;
    			//向四周共8个位置递归
    			for (i = x - 1; i <= x + 1; i++)
    			{
        
    				int j = 0;
    				for (j = y - 1; j <= y + 1; j++)
    				{
        
    
    					//只对 '*' 进行展开，防止死循环
    					if (show[i][j] == '*')
    					{
        
    						expand(mine, show, i, j, win);
    					}
    
    				}
    			}
    		}
    		else   //四周有雷显示雷数
    		{
        
    			show[x][y] = count + '0';
    		}
    
    		//记录展开的数量
    		(*win)++;
    	}
    }

### 四.展示扫雷 ###

#### 扫雷失败： ####

![在这里插入图片描述][5492ef7fcae541568ac5682aa48d5d63.png]  
![在这里插入图片描述][fd81944812294f6e8b3adfff6f272bb2.png]  
![在这里插入图片描述][4d1c39291939490cafe60d8d13717536.png]

![在这里插入图片描述][f0dca69c1e824765af7894bb51607781.png]

#### 2.扫雷成功： ####

![在这里插入图片描述][d8e7e49bd16f4bfb8ff13c3bcf4ea8f9.png]  
创作不易，小小三连支持一下呗~  
![在这里插入图片描述][1f1bd2a284284684ae8521b182b6e7ff.png]

[30ce5397fb874681bcc5b46508e95fae.png]: https://img-blog.csdnimg.cn/30ce5397fb874681bcc5b46508e95fae.png
[9223d96d673847f5863982717953516b.png]: https://img-blog.csdnimg.cn/9223d96d673847f5863982717953516b.png
[81049944767445f188710f9de5d9b8b5.png]: https://img-blog.csdnimg.cn/81049944767445f188710f9de5d9b8b5.png
[048727f2bcfc499dba4f775fb6a63029.png]: https://img-blog.csdnimg.cn/048727f2bcfc499dba4f775fb6a63029.png
[8410087e43034bab82312bdf3c5a00e8.png]: https://img-blog.csdnimg.cn/8410087e43034bab82312bdf3c5a00e8.png
[533647281a0e468eba2902573a836760.png]: https://img-blog.csdnimg.cn/533647281a0e468eba2902573a836760.png
[01967a7f73584f4abf0c1a3d773db95f.png]: https://img-blog.csdnimg.cn/01967a7f73584f4abf0c1a3d773db95f.png
[5492ef7fcae541568ac5682aa48d5d63.png]: https://img-blog.csdnimg.cn/5492ef7fcae541568ac5682aa48d5d63.png
[fd81944812294f6e8b3adfff6f272bb2.png]: https://img-blog.csdnimg.cn/fd81944812294f6e8b3adfff6f272bb2.png
[4d1c39291939490cafe60d8d13717536.png]: https://img-blog.csdnimg.cn/4d1c39291939490cafe60d8d13717536.png
[f0dca69c1e824765af7894bb51607781.png]: https://img-blog.csdnimg.cn/f0dca69c1e824765af7894bb51607781.png
[d8e7e49bd16f4bfb8ff13c3bcf4ea8f9.png]: https://img-blog.csdnimg.cn/d8e7e49bd16f4bfb8ff13c3bcf4ea8f9.png
[1f1bd2a284284684ae8521b182b6e7ff.png]: https://img-blog.csdnimg.cn/1f1bd2a284284684ae8521b182b6e7ff.png