devbox
木道寻08
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【C语言】 -- 扫雷（代码+详解）_c语言扫雷代码

作者：木道寻08 | 2024-08-03 03:39:23

赞

踩

c语言扫雷代码

目录

前言：

1、游戏规则

2、创建文件

2.1 头文件

2.2 define定义的行、列、雷的个数

2.3 函数声明

3、游戏测试部分

3.1 主函数

对主函数内容的分析：

3.1.1 menu()函数（菜单函数）

3.1.2 switch语句

3.1.3 do while语句

3.1.4 game()函数

4、游戏功能实现部分

游戏的实现逻辑

4.1 棋盘的创建

4.2 初始化棋盘函数

4.3 打印棋盘函数

4.4 布置雷

4.5 排查雷

前言：

该篇文章是用C语言来实现扫雷的，是对之前的知识灵活运用加以巩固，如何合理的分块来写一个工程性的代码，如果有大佬看到本篇文章并发现哪里要有不对的地方，请您一定要指出来。

1、游戏规则

我们在棋盘格中任意点开一个格子，若这个格子不是雷就排除了这个位置，排除后这个格子会显示将它围起来的几个格子中有几颗雷，如果点开的格子埋有雷则为游戏失败。

2、创建文件

我们需要分块来写不同用途的文件，在实现三子棋我们需要分三个文件，分别是：

我们需要分模块来写不同用途的文件，在实现扫雷时我们需要分三个文件，分别是：

game.h //头文件（包含所有需要的用到的头文件，define定义的常量，函数声明）

注：我们将2.1，2.2，2.3全部写在此文件中目的在于，game.c和test.c中调用这些内容时，只需要对我们自己写的game.h声明一次便可直接使用里面的内容。

game.c //游戏文件（里面分别写入所要用到功能函数）

test.c //测试文件（代码的整合）

2.1 头文件

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <time.h>

2.2 define定义的行、列、雷的个数

优点：如果我们后期需要改棋盘大小以及雷的个数的时候只需要在这里改，一劳永逸，不用在整个程序中修改，提高了效率。

  1. #define ROW 9
  2. #define COL 9
  3.  
  4. #define ROWS ROW + 2
  5. #define COLS COL + 2
  6.  
  7. #define EASY_COUNT 10

2.3 函数声明

  1. //初始化棋盘
  2. void InitBorad(char board[ROWS][COLS], int rows, int cols, char set);
  3.  
  4. //打印棋盘
  5. void DisplayBorad(char board[ROWS][COLS], int row, int col);
  6.  
  7. //布置雷
  8. void SetMine(char mine[ROWS][COLS], int row, int col);
  9.  
  10. //排查雷
  11. void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col);

3、游戏测试部分

3.1 主函数

这部分先写出玩游戏的逻辑

  1. int main()
  2. {
  3. 	int input = 0;
  4. 	srand((unsigned int)time(NULL));
  5. 	do
  6. 	{
  7. 		menu();
  8. 		printf("请选择:>");
  9. 		scanf("%d", &input);
  10. 		switch (input)
  11. 		{
  12. 		case 1:
  13. 			game();
  14. 			break;
  15. 		case 0:
  16. 			printf("退出游戏\n");
  17. 			break;
  18. 		default:
  19. 			printf("选择错误，请重新选择\n");
  20. 			break;
  21. 		}
  22. 	} while (input);
  23.  
  24. 	return 0;
  25. }

对主函数内容的分析：

3.1.1 menu()函数（菜单函数）

  1. void menu()
  2. {
  3. 	printf("*******************\n");
  4. 	printf("\t1.play\n");
  5. 	printf("\t0.exit\n");
  6. 	printf("*******************\n");
  7. }

效果展示：

3.1.2 switch语句

switch语句实现了用户在选择不同菜单的实现

效果展示：

3.1.3 do while语句

这里使用dowhile语句是实现先运行主函数，然后再进行选择，主函数会根据用户的选择进行实现不同的功能。

3.1.4 game()函数

在玩家选择数字 1 便会调用game()函数，实现以下功能。

  1. void game()
  2. {
  3. 	//创建数组
  4. 	//创建雷的数组（mine）	显示数组（show）		两个数组的类型，大小相同
  5. 	char mine[ROWS][COLS];//存放布置的雷的信息
  6. 	char show[ROWS][COLS];//存放排查出雷的信息
  7.  
  8. 	//初始化棋盘
  9. 	InitBorad(mine, ROWS, COLS, '0');//将布置雷的数组初始化为 '0'
  10. 	InitBorad(show, ROWS, COLS, '*');//将排查雷的数组初始化为 '*'
  11.  
  12. 	//打印棋盘
  13. 	DisplayBorad(show, ROW, COL);
  14. 	//布置雷
  15.  
  16. 	SetMine(mine, ROW, COL);
  17. 	//DisplayBorad(mine, ROW, COL);
  18. 	
  19. 	//排查雷
  20. 	FindMine(mine, show, ROW, COL);
  21. }

game()函数中包含了埋雷的数组和展示的数组（这两个数组大小是一样的，分开写这样就不会混淆了），以及初始化棋盘函数、显示棋盘函数、布置雷函数、排查雷函数的调用，这些函数在下面我们展开来分析。

game（）函数的逻辑顺序为：创建棋盘 ——> 初始化棋盘 ——> 打印棋盘 ——> 布置雷 ——> 排查雷

4、游戏功能实现部分

游戏的实现逻辑

4.1 棋盘的创建

  1. //创建数组
  2. 	//创建雷的数组（mine）	显示数组（show）		两个数组的类型，大小相同
  3. 	char mine[ROWS][COLS];//存放布置的雷的信息
  4. 	char show[ROWS][COLS];//存放排查出雷的信息

这里我们需要创建两个类型相同、大小相同的数组。

Q：为什么要创建两个相同的数组呢？

A：因为用户在玩游戏的时候看到的是被覆盖起来的棋盘，看不到哪些地方都埋着雷的，这是显示棋盘。我们还需要一个埋雷的棋盘，这样才能实现玩家在玩游戏时通关或者未通关，将埋雷的点位呈现给玩家。

我们在屏幕上显示的是 9*9的数组，但是创建的时候是 11*11 的数组，并且准备埋进去 10 颗雷。

Q：为什么创建的是 11*11 的数组呢，而不是 9*9 的数组？

A：在扫雷中，我们排查的一个位置上要是显示了数字，就说明在此位置的周围 8 个格子中存在这个数字个雷，那么我们在排四个边上的位置时候格子是不够 8 个的，但是我们的功能在实现的时候还是会去找这 8 个格子的，这样就会造成数组的越界访问问题（此问题我们画图来解释），但是我们现在创建 11*11 的数组，并对这数组都进行初始化为 '0' 的操作，显示棋盘的时候我们打印 9*9 的数组，这样就不会造成数组越界访问的问题，还可以正常的运行游戏。

如图：如果我们用的是 11*11 的数组，打印的是 9*9 的数组（红色区域），功能函数对边上格子进行周围 8 个格子找雷的个数就不会存在越界问题。

4.2 初始化棋盘函数

定义InitBorad（）函数，代码实现：

  1. void InitBorad(char board[ROWS][COLS], int rows, int cols, char set)
  2. {
  3. 	int i = 0;
  4. 	int j = 0;
  5. 	for (i = 0; i < rows; i++)
  6. 	{
  7. 		for (j = 0; j < cols; j++)
  8. 		{
  9. 			board[i][j] = set;
  10. 		}
  11. 	}
  12. }

首先我们对埋雷的数组进行初始化为字符 0 ，（非雷用字符 0 表示，雷用字符 1 表示），对显示棋盘的数组全部用 * 将埋雷的数组覆盖起来，因此在game（）函数里对 InitBorad（）函数调用两次。

4.3 打印棋盘函数

定义DisplayBorad（）函数，代码实现：

  1. void DisplayBorad(char board[ROWS][COLS], int row, int col)
  2. {
  3. 	int i = 0;
  4. 	int j = 0;
  5. 	printf("########扫雷#######\n");
  6. 	for (j = 0; j <= col; j++)
  7. 	{
  8. 		printf("%d ", j);
  9. 	}
  10. 	printf("\n");
  11. 	for (i = 1; i <= row; i++)
  12. 	{
  13. 		printf("%d ", i);
  14. 		for (j = 1; j <= col; j++)
  15. 		{
  16. 			printf("%c ", board[i][j]);
  17. 		}
  18. 		printf("\n");
  19. 	}
  20. }

效果展示：

埋雷棋盘（mine）

展示棋盘（show）

我们可以看见和我们当初构思的是一样的，我们只需要将show棋盘展示给用户就好了。

4.4 布置雷

定义SetMine（）函数，代码实现:

  1. void SetMine(char mine[ROWS][COLS], int row, int col)
  2. {
  3. 	int count = EASY_COUNT;
  4. 	while (count)
  5. 	{
  6. 		int x = rand() % row + 1;
  7. 		int y = rand() % col + 1;
  8. 		if (mine[x][y] == '0')
  9. 		{
  10. 			mine[x][y] = '1';
  11. 			count--;
  12. 		}
  13. 	}
  14. }

代码分析：

Q：我们怎样才能将雷随机的布置在 9*9 棋盘中呢？

A：我们使用 rand 函数，利用时间戳生成随机数，再对生成的随机数取模行、列（9）并加一，就能实现在中间的 9*9 的棋盘里放入 10 颗随机的雷。

  1. int x = rand() % row + 1;//随机数取模于row得到0~8，+1处理后得到的是1~9
  2. int y = rand() % col + 1;//随机数取模于col得到0~8，+1处理后得到的是1~9

我们设定 count 个雷，埋下一个就减一，并进行判断，这个位置是否为字符 '0' ，是就将字符 '0' 改为字符 '1' ,不是字符 '0' 就再生成一个合法的随机位置，使其合法的放入 9*9 的棋盘里面，这样就不会出现重复埋雷了。在使用 while 循环，直到减到 count 为 0 时，while 不在循环，10 颗雷正好埋完。

4.5 排查雷

定义FindMine（）函数，代码实现：

  1. void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
  2. {
  3. 	int x = 0;
  4. 	int y = 0;
  5. 	int win = 0;
  6. 	while (win<row*col-EASY_COUNT)
  7. 	{
  8. 		printf("请输入要排查的坐标:>");
  9. 		scanf("%d %d", &x, &y);
  10. 		if ((x >= 1 && x <= row) && (y >= 1 && y <= col))
  11. 		{
  12. 			if (mine[x][y] == '1')
  13. 			{
  14. 				printf("很遗憾，你被炸死了\n");
  15. 				DisplayBorad(mine, ROW, COL);
  16. 				break;
  17. 			}
  18. 			else
  19. 			{
  20. 				//此坐标不是雷，就要统计此坐标附近雷的个数
  21. 				int count = GetMineCount(mine, x, y);
  22. 				show[x][y] = count + '0';
  23. 				DisplayBorad(show, ROW, COL);
  24. 				win++;
  25. 			}
  26. 		}
  27. 		else
  28. 		{
  29. 			printf("排查的坐标非法，请重新输入\n");
  30. 		}
  31. 	}
  32. 	if (win == row * col - EASY_COUNT)
  33. 	{
  34. 		printf("恭喜你，排雷成功！\n");
  35. 		DisplayBorad(mine, ROW, COL);
  36. 	}
  37.  
  38. }

其中添加了计算附近雷的GetMineCount（）函数，代码实现：

  1. int GetMineCount(char mine[ROWS][COLS], int x, int y)
  2. {
  3. 	return (mine[x - 1][y - 1] +
  4. 		mine[x - 1][y] +
  5. 		mine[x - 1][y + 1] +
  6. 		mine[x][y - 1] +
  7. 		mine[x][y + 1] +
  8. 		mine[x + 1][y - 1] +
  9. 		mine[x + 1][y] +
  10. 		mine[x + 1][y + 1] - 8 * '0');
  11. }

我们对这两段代码进行解析：

首先我们对玩家输入的坐标位置进行判断是否合法，坐标必须在 1~row/col 之间（包含 1 和 row/col），如果不在此范围，代码会走第一个 else 语句，提醒玩家“排查的坐标非法，请重新输入”的字样。

如果合法就会走第一个 if 语句，进去之后我们对该位置进行判断，看是否该位置为字符 '1'，如果是字符 '1' 就是踩到了雷，就会提醒玩家“很遗憾，你被炸死了”的字样，并将雷的分布图给玩家呈现出来

如果是字符 '0' 就走 else 语句，对该位置的周围 8 个格子的雷的个数进行计算并标注出来，这时我们就调用GetMineCount（）函数来计算，我们看一下内容是什么：

  1. return (mine[x - 1][y - 1] +
  2. 		mine[x - 1][y] +
  3. 		mine[x - 1][y + 1] +
  4. 		mine[x][y - 1] +
  5. 		mine[x][y + 1] +
  6. 		mine[x + 1][y - 1] +
  7. 		mine[x + 1][y] +
  8. 		mine[x + 1][y + 1] - 8 * '0');

我们可以看到这是对该坐标周围的 8 个坐标的字符加起来的，我们知道字符 '1' 和字符 '0' 对应的ASCII码值是相连的，因此我们将周围 8 个的字符加起来减去 8 个字符 '0' ，这样我们就可以得到字符 '1' 的个数，也就是雷的个数。

效果展示：

为了能快速看到，我们将雷的部分数组也展示出来，可以直观的看到。

mine棋盘 

show棋盘：

如果我们一步都没有失误，直到整个雷全部排完，就会执行以下代码：

  1. if (win == row * col - EASY_COUNT)
  2. 	{
  3. 		printf("恭喜你，排雷成功！\n");
  4. 		DisplayBorad(mine, ROW, COL);
  5. 	}

排雷成功后，我们会再次对雷的布局图进行打印。我们为了方便展示，布置 80 个雷测试一下。

效果展示：

至此，两个小游戏就全部讲完了。

完整代码在代码仓库，入口在这:>

C语言jy: C语言的初级阶段时期 - Gitee.com

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/木道寻08/article/detail/921244
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号