devbox
我家自动化
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C语言扫雷（递归展开）（详细注释）（完整代码）_扫雷代码

作者：我家自动化 | 2024-05-21 14:07:27

赞

踩

扫雷代码

目录

一、功能实现

1.雷盘初始化与打印

雷盘定义

初始化雷盘

打印雷盘

随机布置雷

2.玩家排查雷

获取坐标周围雷数

递归展开

胜负判断

显示雷位置

二、游戏试玩

三、游戏完整代码

game.h 

test.c

game.c

      扫雷大家应该都知道，翻开一个格子，显示的数字就是周围 8 格所含的雷数。例如，红色框框里的1周围8格就只有一个雷。

      我们定义两个数组来实现，show数组存放玩家看到的棋盘，mine数组存放隐藏的雷盘

这两个数组搭配使用，就能计算某个位置周围的雷数，并且修改show数组来显示这个位置的雷数。

但是如果计算边缘格子周围的雷数时，数组会越界。

我们只要在周围留一圈就能解决这个问题

如下图所示，假设我们要玩 9x9 的大小，我们的数组大小就定义为 11x11

一、功能实现

1.雷盘初始化与打印

  • 雷盘定义

  • 初始化雷盘

初始化show，mine两个数组，show 存放 '*' , mine存放 '0'

  1. void init_board(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. }

  • 打印雷盘

  1. //打印show雷盘
  2.  
  3. void display_board(char board[ROWS][COLS], int row, int col)
  4. {
  5. 	int i = 0;
  6. 	int j = 0;
  7.  
  8. 	//这里打印上面一行数字
  9. 	printf("|");
  10. 	for (j = 0; j <= col; j++)
  11. 	{
  12. 		printf(" %-2d |", j);
  13. 	}
  14. 	printf("\n");
  15.  
  16.  
  17. 	for (i = 1; i <= row; i++)
  18. 	{
  19. 		printf("|");
  20. 		for (j = 0; j <= col; j++)
  21. 		{
  22. 			printf("----|");//打印两行之间的分割线
  23. 		}
  24. 		printf("\n");
  25.  
  26. 		printf("|");
  27. 		printf(" %-2d |", i);//打印左边一列数字
  28.  
  29. 		for (j = 1; j <= col; j++)
  30. 		{
  31. 			printf(" %2c |",board[i][j]);//打印show数组
  32. 	
  33. 		}
  34. 		printf("\n");
  35. 	}
  36. }

 效果图：

  • 随机布置雷

随机布置雷，将mine中的 '0' 改为 '1'

  1. //随机布置雷，在mine数组里随机设置COUNT个雷
  2.  
  3. void set_mine(char mine[ROWS][COLS], int row, int col)
  4. {
  5. 	int count = COUNT;
  6. 	while (count)
  7. 	{
  8. 		int x = rand() % row + 1;
  9. 		int y = rand() % col + 1;
  10.  
  11. 		if (mine[x][y] == '0')
  12. 		{
  13. 			mine[x][y] = '1';  //地雷设置为 '1'
  14. 			count--;
  15. 		}
  16. 	}
  17. }

2.玩家排查雷

  • 获取坐标周围雷数

计算该坐标在mine中 周围 '1'的个数

  1. //获取一个格子周围的雷数
  2.  
  3. int get_mine_count(char mine[ROWS][COLS], int x, int y)  
  4. {
  5. 	//mine 中存放的是字符'0' 和 '1'
  6. 		return (mine[x][y + 1] +
  7. 			mine[x - 1][y + 1] +
  8. 			mine[x - 1][y] +
  9. 			mine[x - 1][y - 1] +
  10. 			mine[x][y - 1] +
  11. 			mine[x + 1][y - 1] +
  12. 			mine[x + 1][y] +
  13. 			mine[x + 1][y + 1] - 8 * '0');
  14. }

  • 递归展开

我们玩扫雷时，翻开一个格子会展开一片，如上图所示，翻开黑格子，展开紫色区域。

我们可以用递归来实现

当这个格子周围没雷时，显示空白，然后继续递归它周围的八个格子

有雷时，显示雷数，停止递归。

  1. //递归展开
  2.  
  3. void expand(char mine[ROWS][COLS], char show[ROWS][COLS], int x, int y, int* win)
  4. {
  5.  
  6. 	if (x >= 1 && x <= ROW && y >= 1 && y <= COL) //限制在棋盘内展开，防止越界
  7. 	{
  8. 		int count = get_mine_count(mine, x, y);//获取雷数
  9.  
  10. 		if (count == 0) //四周没雷，进入递归展开
  11. 		{
  12. 			show[x][y] = ' ';//四周没雷的改为 空格  ' '
  13. 			
  14.  
  15. 			int i = 0;
  16. 			//向四周共8个位置递归
  17. 			for (i = x - 1; i <= x + 1; i++)
  18. 			{
  19. 				int j = 0;
  20. 				for (j = y - 1; j <= y + 1; j++)
  21. 				{
  22.  
  23. 					//只对 '*' 进行展开，防止死循环
  24. 					if (show[i][j] == '*')
  25. 					{
  26. 						expand(mine, show, i, j, win);
  27. 					}
  28.  
  29. 				}
  30. 			}
  31. 		}
  32. 		else   //四周有雷显示雷数
  33. 		{
  34. 			show[x][y] = count + '0';
  35. 		}
  36. 	
  37. 		//记录展开的数量
  38. 		(*win)++;
  39. 	}
  40. }

  • 胜负判断

这里定义了一个 win 来表示翻开的格子数，当翻开的格子数量 = 行 x 列 - 雷数 ===> 排雷成功。

  1. //玩家排查雷
  2.  
  3. void find_mine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
  4. {
  5. 	int x = 0;
  6. 	int y = 0;
  7. 	int win = 0;//初始化 翻开的格子数量
  8.  
  9. 	while (win < row * col - COUNT)//当翻开的格子数量 = 行 x 列 - 雷数 ===> 排雷成功
  10. 	{
  11. 		printf("请输入要排查的坐标:>");
  12. 		scanf("%d %d", &x, &y);
  13.  
  14. 		//检查坐标是否越界
  15. 		if (x >= 1 && x <= row && y >= 1 && y <= col)
  16. 		{
  17.  
  18. 			//检查坐标是否排查过了
  19. 			if (show[x][y] == '*')
  20. 			{
  21.  
  22. 				if (mine[x][y] == '1')
  23. 				{
  24. 					system("cls");
  25. 					show_mine(mine, show, row, col);
  26. 					printf("-----------很遗憾，你被炸死了-----------\n");
  27. 					break;
  28. 				}
  29. 				else
  30. 				{
  31. 					//展开
  32. 					expand(mine, show, x, y, &win);
  33.  
  34. 					system("cls");//清屏
  35. 					display_board(show, row, col);
  36. 					printf("--------------还需翻开%d格--------------\n", row * col - COUNT - win);
  37. 				}
  38. 			}
  39. 			else
  40. 			{
  41. 				printf("该坐标已排查，请重新输入\n");
  42. 			}
  43. 		}
  44. 		else
  45. 		{
  46. 			printf("坐标非法，请重新输入\n");
  47. 		}
  48. 	}
  49.  
  50.     if (win == row* col - COUNT)
  51. 	{
  52. 		system("cls");
  53. 	    show_mine(mine, show, row, col);//展示地雷位置
  54. 	    printf("------------恭喜你，排雷成功-----------\n");
  55. 	}	
  56. }

  • 显示雷位置

  1. //显示地雷位置，排雷成功或被炸死后 向玩家展示地雷位置
  2.  
  3. void show_mine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
  4. {
  5. 	int i = 0;
  6. 	for (i = 1; i <= row; i++)
  7. 	{
  8. 		int j = 0;
  9. 		for (j = 1; j <= COL; j++)
  10. 		{
  11. 			if (mine[i][j] == '1')
  12. 			{
  13. 				show[i][j] = '@';    //将地雷改成 '@'
  14. 			}
  15. 		}
  16. 	}
  17. 	display_board(show, row, col);   //打印
  18. }

二、游戏试玩

游戏设置    10 行 ，10 列  ，15个雷

 排雷成功

 排雷失败

三、游戏完整代码

game.h 

头文件   常量定义，函数声明

  1. #pragma once
  2.  
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <time.h>
  6.  
  7.  
  8. //玩家看到的大小
  9. #define ROW 10
  10. #define COL 10
  11.  
  12.  
  13. //实际数组大小，防止越界
  14. #define ROWS ROW+2
  15. #define COLS COL+2
  16.  
  17.  
  18. #define COUNT 10//雷数
  19.  
  20. //初始化棋盘
  21. void init_board(char board[ROWS][COLS], int rows, int cols, char set);
  22.  
  23. //打印棋盘
  24. void display_board(char board[ROWS][COLS], int row, int col);
  25.  
  26. //随机布置雷
  27. void set_mine(char mine[ROWS][COLS], int row, int col);
  28.  
  29. //获取坐标周围地雷数
  30. int get_mine_count(char mine[ROWS][COLS], int x, int y);
  31.  
  32. //显示地雷位置并打印
  33. void show_mine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col);
  34.  
  35. //递归展开
  36. void expand(char mine[ROWS][COLS], char show[ROWS][COLS], int x, int y, int* win);
  37.  
  38. //排查雷
  39. void find_mine(char mine[ROWS][COLS],char show[ROWS][COLS],int row, int col);

test.c

游戏测试文件

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2.  
  3. #include "game.h"
  4.  
  5.  
  6. //菜单
  7. void menu()
  8. {
  9. 	printf("======================\n");
  10. 	printf("||       扫雷       ||\n");
  11. 	printf("||    1-开始游戏    ||\n");
  12. 	printf("||    0-退出游戏    ||\n");
  13. 	printf("======================\n");
  14. }
  15.  
  16.  
  17. //游戏流程
  18. void game()
  19. {
  20. 	char mine[ROWS][COLS] = { 0 };//存放布置的雷(隐藏的)
  21. 	char show[ROWS][COLS] = { 0 };//存放排查的雷(游戏看到的)
  22. 	
  23.  
  24. 	//初始化棋盘
  25. 	//mine 全为'0'
  26. 	//show 全为'*'
  27. 	init_board(mine, ROWS, COLS, '0');
  28. 	init_board(show, ROWS, COLS, '*');
  29.  
  30. 	//随机布置雷
  31. 	set_mine(mine,ROW,COL);
  32.  
  33. 	//打印棋盘
  34. 	//display_board(mine, ROW, COL);
  35. 	display_board(show, ROW, COL);
  36. 	printf("--------------需要翻开%d格--------------\n", ROW * COL - COUNT);
  37.  
  38. 	//排查雷(游戏开始)
  39. 	find_mine(mine, show, ROW, COL);
  40. }
  41.  
  42.  
  43.  
  44.  
  45. int main()
  46. {
  47. 	int input = 0;
  48. 	srand((unsigned int)time(NULL));
  49.  
  50. 	do
  51. 	{
  52. 		menu();
  53. 		printf("请选择:>");
  54. 		scanf("%d", &input);
  55. 		switch (input)
  56. 		{
  57. 		case 1:
  58. 			system("cls");
  59. 			game();
  60. 			break;
  61. 		case 0:
  62. 			printf("退出游戏\n");
  63. 			break;
  64. 		default:
  65. 			printf("选择错误，请重新输入\n");
  66. 			break;
  67. 		}
  68. 	} while (input);
  69.  
  70. 	return 0;
  71. }

game.c

函数定义

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2.  
  3. #include "game.h"
  4.  
  5.  
  6. //将两个数组初始化，show全为'*' ，mine全为'0'
  7.  
  8. void init_board(char board[ROWS][COLS], int rows, int cols, char set)
  9. {
  10. 	int i = 0;
  11. 	int j = 0;
  12. 	for (i = 0; i < rows; i++)
  13. 	{
  14. 		for (j = 0; j < cols; j++)
  15. 		{
  16. 			board[i][j] = set;
  17. 		}
  18. 	}
  19. }
  20.  
  21.  
  22. //打印show棋盘
  23.  
  24. void display_board(char board[ROWS][COLS], int row, int col)
  25. {
  26. 	int i = 0;
  27. 	int j = 0;
  28.  
  29. 	//这里打印上面一行数字
  30. 	printf("|");
  31. 	for (j = 0; j <= col; j++)
  32. 	{
  33. 		printf(" %-2d |", j);
  34. 	}
  35. 	printf("\n");
  36.  
  37.  
  38. 	for (i = 1; i <= row; i++)
  39. 	{
  40. 		printf("|");
  41. 		for (j = 0; j <= col; j++)
  42. 		{
  43. 			printf("----|");//打印两行之间的分割线
  44. 		}
  45. 		printf("\n");
  46.  
  47. 		printf("|");
  48. 		printf(" %-2d |", i);//打印左边一列数字
  49.  
  50. 		for (j = 1; j <= col; j++)
  51. 		{
  52. 			printf(" %2c |",board[i][j]);//打印show数组
  53. 	
  54. 		}
  55. 		printf("\n");
  56. 	}
  57. }
  58.  
  59.  
  60. //随机设置雷，在mine数组里随机设置COUNT个雷
  61.  
  62. void set_mine(char mine[ROWS][COLS], int row, int col)
  63. {
  64. 	int count = COUNT;
  65. 	while (count)
  66. 	{
  67. 		int x = rand() % row + 1;
  68. 		int y = rand() % col + 1;
  69.  
  70. 		if (mine[x][y] == '0')
  71. 		{
  72. 			mine[x][y] = '1';  //地雷设置为 '1'
  73. 			count--;
  74. 		}
  75. 	}
  76. }
  77.  
  78.  
  79. //获取一个格子周围的雷数
  80.  
  81. int get_mine_count(char mine[ROWS][COLS], int x, int y)  
  82. {
  83. 	//mine 中存放的是字符'0' 和 '1'
  84. 		return (mine[x][y + 1] +
  85. 			mine[x - 1][y + 1] +
  86. 			mine[x - 1][y] +
  87. 			mine[x - 1][y - 1] +
  88. 			mine[x][y - 1] +
  89. 			mine[x + 1][y - 1] +
  90. 			mine[x + 1][y] +
  91. 			mine[x + 1][y + 1] - 8 * '0');
  92. }
  93.  
  94.  
  95. //递归展开
  96.  
  97. void expand(char mine[ROWS][COLS], char show[ROWS][COLS], int x, int y, int* win)
  98. {
  99.  
  100. 	if (x >= 1 && x <= ROW && y >= 1 && y <= COL) //限制在棋盘内展开，防止越界
  101. 	{
  102. 		int count = get_mine_count(mine, x, y);//获取雷数
  103.  
  104. 		if (count == 0) //四周没雷，进入递归展开
  105. 		{
  106. 			show[x][y] = ' ';//四周没雷的改为 空格  ' '
  107. 			
  108.  
  109. 			int i = 0;
  110. 			//向四周共8个位置递归调用
  111. 			for (i = x - 1; i <= x + 1; i++)
  112. 			{
  113. 				int j = 0;
  114. 				for (j = y - 1; j <= y + 1; j++)
  115. 				{
  116.  
  117. 					//只对 '*' 进行展开，防止死循环
  118. 					if (show[i][j] == '*')
  119. 					{
  120. 						expand(mine, show, i, j, win);
  121. 					}
  122.  
  123. 				}
  124. 			}
  125. 		}
  126. 		else   //四周有雷显示雷数
  127. 		{
  128. 			show[x][y] = count + '0';
  129. 		}
  130. 		
  131. 		//记录展开的数量
  132. 		(*win)++;
  133. 	}
  134. }
  135.  
  136.  
  137. //显示地雷位置，排雷成功或被炸死后 向玩家展示地雷位置
  138.  
  139. void show_mine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
  140. {
  141. 	int i = 0;
  142. 	for (i = 1; i <= row; i++)
  143. 	{
  144. 		int j = 0;
  145. 		for (j = 1; j <= COL; j++)
  146. 		{
  147. 			if (mine[i][j] == '1')
  148. 			{
  149. 				show[i][j] = '@';    //将地雷改成 '@'
  150. 			}
  151. 		}
  152. 	}
  153. 	display_board(show, row, col);   //打印
  154. }
  155.  
  156.  
  157. //玩家排查雷
  158.  
  159. void find_mine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
  160. {
  161. 	int x = 0;
  162. 	int y = 0;
  163. 	int win = 0;//初始化 翻开的格子数量
  164.  
  165. 	while (win < row * col - COUNT)//当翻开的格子数量 = 行 x 列 - 雷数 ===> 排雷成功
  166. 	{
  167. 		printf("请输入要排查的坐标:>");
  168. 		scanf("%d %d", &x, &y);
  169.  
  170. 		//检查坐标是否越界
  171. 		if (x >= 1 && x <= row && y >= 1 && y <= col)
  172. 		{
  173.  
  174. 			//检查坐标是否排查过了
  175. 			if (show[x][y] == '*')
  176. 			{
  177.  
  178. 				if (mine[x][y] == '1')
  179. 				{
  180. 					system("cls");
  181. 					show_mine(mine, show, row, col);
  182. 					printf("-----------很遗憾，你被炸死了-----------\n");
  183. 					break;
  184. 				}
  185. 				else
  186. 				{
  187. 					//展开
  188. 					expand(mine, show, x, y, &win);
  189.  
  190. 					system("cls");//清屏
  191. 					display_board(show, row, col);
  192. 					printf("--------------还需翻开%d格--------------\n", row * col - COUNT - win);
  193. 				}
  194. 			}
  195. 			else
  196. 			{
  197. 				printf("该坐标已排查，请重新输入\n");
  198. 			}
  199. 		}
  200. 		else
  201. 		{
  202. 			printf("坐标非法，请重新输入\n");
  203. 		}
  204. 	}
  205.     
  206.     if (win == row* col - COUNT)
  207. 	{
  208. 		system("cls");
  209. 	    show_mine(mine, show, row, col);//展示地雷位置
  210. 	    printf("------------恭喜你，排雷成功-----------\n");
  211. 	}
  212. }
  213.

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

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

  

闽ICP备14008679号