深圳幻海软件技术有限公司 欢迎您！
更多

C语言实现扫雷(包含递归展开)

2023-05-23

int row mine
目录一：扫雷游戏的基础逻辑二：关于扫雷相关的信息存储三：游戏大体实现逻辑四：具体实现(1)初始化(2)打印(3)布置雷(4)查雷五：全部代码(1)game.h(2)game.c(3)test.c六：实际效果演示一：扫雷游戏的基础逻辑扫雷游戏逻辑如下：1.游戏开始时，玩家将看到一个方格棋盘，每个方格上

目录

一：扫雷游戏的基础逻辑

二：关于扫雷相关的信息存储

三：游戏大体实现逻辑

四：具体实现

(1)初始化

(2)打印

(3)布置雷

(4)查雷

五：全部代码

(1)game.h

(2)game.c

(3)test.c

六：实际效果演示

一：扫雷游戏的基础逻辑

扫雷游戏逻辑如下：

1. 游戏开始时，玩家将看到一个方格棋盘，每个方格上有一个数字或着一个地雷。


2. 玩家需要透过数字来判断周围哪些格子有雷。一个数字所在的方格周围八个格子中，有几个格子有雷就显示几。例如，如果一个格子的数字是2，则周围有两个雷。


3. 如果一个方格上是一个地雷，玩家就输了游戏。如果玩家成功地标记出所有地雷，就赢了游戏。


4. 玩家需要使用自己的推理和猜测技能来确定哪些方格上有地雷而不需要点开它，如果玩家点开了一个没有地雷的方格，那么它会显示一个数字或者显示空白区域，这些数字和空白区域恰好对应周围方格中的地雷数量。

整个游戏的逻辑就是通过不断的推理来确定地雷的位置，在避免踩到地雷的情况下，将整个棋盘的状态揭示出来。

二：关于扫雷相关的信息存储

两个信息，一个是雷的信息，是雷用字符’1’表示，不是用字符’0’表示。

一个是非雷的坐标的雷数信息，我们统计以这个点为中心3x3的区域雷数。
 

因此我们可以设计两个数组来保存这些信息，其中展示数组(show)负责给予玩家雷数提示，雷数组(mine)负责保存雷的位置信息。


用字符’1’来表示雷是因为数字字符的ASCLL码是连续的，我们用'1'-'0'得到的就是1，我们可以把3x3区域的数字字符加起来减去7个'0'，就可以得到雷数(数字字符)。

但是如果我们就设计9x9的区域，边界区域的3x3范围会越界，我们可以设计成11x11的区域并把外围初始化为’0’，计算的时候外围不会影响，为了尽量统一，展示数组也设计成11x11。

但如果这个位置周围没有雷，我们依然要玩家排查周围，游戏效率很低，我们可以在这个位置周围无雷的时候向四周进行展开(后面会讲)，周围无雷的位置展示数组对应修改为空格。

除此之外我们实现标记雷的功能，被标记的位置对应展示数组修改为'!'。

汇总：

雷数组——'0'表示不是雷，'1'表示是雷

展示数组——'*'表示未排查，'!'表示标记但未排查，' '(空格)表示这个位置周围没有雷，数字字符代表这个位置周围雷数。


图解：

 

三：游戏大体实现逻辑

 

 

四：具体实现

 

(1)初始化

初始化，传对应的数组首地址和字符来初始化

代码：

  1. //初始化
  2. void InitBoard(char Board[ROWS][COLS], int row, int col, char set)
  3. {
  4. for (int i = 0; i < row; i++)
  5. {
  6. for (int j = 0; j < col; j++)
  7. {
  8. Board[i][j] = set;
  9. }
  10. }
  11. }

(2)打印

打印，利用双重循环一行一行的打印，在打印内容前打印对应列数（方便看），打印一行前打印对应行数（方便看）。

代码：

  1. //打印
  2. void DisplayBoard(char Board[ROWS][COLS], int row, int col)
  3. {
  4. int i = 0;
  5. //对齐就行
  6. printf("   ");
  7. for (i = 1; i <= col; i++)
  8. {
  9. printf("%d ", i);
  10. }
  11. printf("\n");
  12.  
  13. for (i = 1; i <= row; i++)
  14. {
  15. printf("%d| ", i);
  16. for (int j = 1; j <= col; j++)
  17. {
  18. printf("%c ",Board[i][j]);
  19. }
  20. printf("\n");
  21. }
  22. }

(3)布置雷

布置雷，只给内层9x9布置，我们随机生成坐标，为'0'布置，为'1'（已经布置）就不布置，布置了10个就结束（计数器控制）。

代码：

  1. //布雷
  2. void SetMine(char mine[ROWS][COLS], int row, int col)
  3. {
  4. //雷数
  5. int count = EasyCount;
  6. //随机坐标
  7. int x = 0;
  8. int y = 0;
  9. while (count)
  10. {
  11. x = rand() % row + 1;
  12. y = rand() % row + 1;
  13. //这个位置已经是雷就不修改
  14. if (mine[x][y] == '0')
  15. {
  16. mine[x][y] = '1';
  17. //计数器减1
  18. count--;
  19. }
  20. }
  21. }

(4)查雷

查雷，把两个数组地址都传过去，输入坐标后通过雷数组看是否为雷，是雷跳出结束游戏，不是雷统计周围的雷数并修改展示数组。


游戏胜利的条件是非雷位置全排查完（计数器控制），非雷位置数为(内层行数x内存列数-雷数)。

其中有三个比较重要的点

【1】计算周围的雷数

图解：

代码：

 

  1. //计算周围雷数
  2. int GetMineCount(char mine[ROWS][COLS], int x, int y)
  3. {
  4. return (mine[x - 1][y - 1] + mine[x - 1][y] + mine[x - 1][y + 1]
  5. + mine[x][y - 1] + mine[x][y + 1] + mine[x + 1][y - 1] +
  6. mine[x + 1][y] + mine[x + 1][y + 1] - 7 * '0');
  7. }

【2】展开周围无雷的位置

如果排查位置周围雷数为0，就把周围的信息显示出来，如果周围还有雷数0的位置，就继续展开，依此类推。其中被展开的位置也算被排查了，需要让计数器加1，我们可以传计数器地址来进行修改。

代码：

  1. void unfold(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col, int x, int y,int* win)
  2. {
  3. //合法坐标才展开
  4. if (x >= 1 && x <= row && y >= 1 && y <= col)
  5. {
  6. //计算这个位置周围雷数
  7. int count = GetMineCount(mine, x, y);
  8. //排查计数加1
  9. *win += 1;
  10.  
  11. //如果这个位置周围无雷，向四周展开
  12. if ((count-'0') == 0)
  13. {
  14. //修改周围无雷位置为空格
  15. show[x][y] = ' ';
  16. int i = 0;
  17.  
  18. for (i = x - 1; i <= x + 1; i++)
  19. {
  20. for (int j = y - 1; j <= y + 1; j++)
  21. {
  22. //每一个位置只能展开一次
  23. if (show[i][j] == '*' || show[x][y] == '!')
  24. {
  25. unfold(mine, show, row, col, i, j,win);
  26. }
  27. }
  28. }
  29. }
  30. //如果周围有雷，修改展示数组为雷数
  31. else
  32. {
  33. show[x][y] = count;
  34. }
  35. }
  36. }

【3】玩家标记雷

标记雷，每次排查完都提示一下是否需要记录雷的位置，需要的话修改展示数组为’!’，只是标记不是排查 ，后面排查和展开的时候这个位置依然是合法的。

代码：

  1. //标记雷位置
  2. void SignMine(char show[ROWS][COLS], int row, int col)
  3. {
  4. int x = 0;
  5. int y = 0;
  6. while (1)
  7. {
  8. printf("请输入要标记的坐标：");
  9. scanf("%d %d", &x, &y);
  10.  
  11. if (x >= 1 && x <= row && y >= 1 && y <= col)
  12. {
  13. if (show[x][y] == '*')
  14. {
  15. show[x][y] = '!';
  16. break;
  17. }
  18. else
  19. {
  20. printf("该位置不能被标记，请重新输入：\n");
  21. }
  22. }
  23. else
  24. {
  25. printf("输入坐标非法，请重新输入:\n");
  26. }
  27. }
  28. //清空屏幕再打印
  29. system("cls");
  30. DisplayBoard(show, row, col);
  31. }

查雷的全部代码：

  1. //查雷
  2. void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS],int row,int col)
  3. {
  4. //保存排除了多少个不是雷的位置
  5. int win = 0;
  6. char ch = 0;
  7. while (win < (row*col- EasyCount))
  8. {
  9. int x = 0;
  10. int y = 0;
  11. printf("请输入要排查的坐标,空格隔开:>");
  12. scanf("%d %d", &x, &y);
  13. //坐标合法
  14. if (x >= 1 && x <= row && y >= 1 && y <= col)
  15. {
  16. //改位置有雷
  17. if (mine[x][y] == '1')
  18. {
  19. printf("游戏结束，你被炸死了\n");
  20. //打印雷数组
  21. DisplayBoard(mine, ROW, COL);
  22. break;
  23. }
  24. //无雷
  25. if(show[x][y] == '*' || show[x][y] == '!')
  26. {
  27. //展开
  28. unfold(mine, show, row, col, x, y,&win);
  29. system("cls");
  30. //打印展示数组
  31. DisplayBoard(show, ROW, COL);
  32. printf("需要标注地雷就输入：Y，不需要标注地雷则输入：N\n");
  33. //清空一下缓冲区
  34. while ((ch = getchar()) != '\n');
  35. scanf("%c", &ch);
  36. switch (ch)
  37. {
  38. case 'Y':
  39. //标记雷的位置
  40. SignMine(show, row, col);
  41. break;
  42. default:
  43. break;
  44. }
  45. }
  46. else
  47. {
  48. printf("你已经排查过这个位置了，请重新输入\n");
  49. }
  50. }
  51. else
  52. {
  53. printf("坐标非法，重新输入\n");
  54. }
  55. }
  56.  
  57. //判断是否是排雷结束跳出
  58. if (win == (row * col - EasyCount))
  59. {
  60. printf("恭喜你，你赢了\n");
  61. }
  62. }

五：全部代码

(1)game.h

  1. ​
  2. #pragma once
  3. //可以自行修改行列数和雷的数量
  4. //内层行数和列数
  5. #define ROW 9
  6. #define COL 9
  7. //数组加上外层的实际行列
  8. #define ROWS ROW+2
  9. #define COLS COL+2
  10. //雷数
  11. #define EasyCount 10
  12.  
  13. #include <stdio.h>
  14. #include <stdlib.h>
  15. #include <time.h>
  16.  
  17. //初始化
  18. void InitBoard(char Board[ROWS][COLS], int row, int col, char set);
  19. //打印
  20. void DisplayBoard(char Board[ROWS][COLS], int row,int col);
  21. //布雷
  22. void SetMine(char mine[ROWS][COLS], int row, int col);
  23. //查雷
  24. void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS],int row,int col);
  25.  
  26.  
  27. ​

(2)game.c

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2. #include "game.h"
  3.  
  4. //标记雷位置
  5. void SignMine(char show[ROWS][COLS], int row, int col)
  6. {
  7. int x = 0;
  8. int y = 0;
  9. while (1)
  10. {
  11. printf("请输入要标记的坐标：");
  12. scanf("%d %d", &x, &y);
  13.  
  14. if (x >= 1 && x <= row && y >= 1 && y <= col)
  15. {
  16. if (show[x][y] == '*')
  17. {
  18. show[x][y] = '!';
  19. break;
  20. }
  21. else
  22. {
  23. printf("该位置不能被标记，请重新输入：\n");
  24. }
  25. }
  26. else
  27. {
  28. printf("输入坐标非法，请重新输入:\n");
  29. }
  30. }
  31. //清空屏幕再打印
  32. system("cls");
  33. DisplayBoard(show, row, col);
  34. }
  35.  
  36. //初始化
  37. void InitBoard(char Board[ROWS][COLS], int row, int col, char set)
  38. {
  39. for (int i = 0; i < row; i++)
  40. {
  41. for (int j = 0; j < col; j++)
  42. {
  43. Board[i][j] = set;
  44. }
  45. }
  46. }
  47.  
  48. //打印
  49. void DisplayBoard(char Board[ROWS][COLS], int row, int col)
  50. {
  51. int i = 0;
  52. //对齐就行
  53. printf("   ");
  54. for (i = 1; i <= col; i++)
  55. {
  56. printf("%d ", i);
  57. }
  58. printf("\n");
  59.  
  60. for (i = 1; i <= row; i++)
  61. {
  62. printf("%d| ", i);
  63. for (int j = 1; j <= col; j++)
  64. {
  65. printf("%c ",Board[i][j]);
  66. }
  67. printf("\n");
  68. }
  69. }
  70.  
  71. //布雷
  72. void SetMine(char mine[ROWS][COLS], int row, int col)
  73. {
  74. //雷数
  75. int count = EasyCount;
  76. //随机坐标
  77. int x = 0;
  78. int y = 0;
  79. while (count)
  80. {
  81. x = rand() % row + 1;
  82. y = rand() % row + 1;
  83. //这个位置已经是雷就不修改
  84. if (mine[x][y] == '0')
  85. {
  86. mine[x][y] = '1';
  87. //计数器减1
  88. count--;
  89. }
  90. }
  91. }
  92.  
  93. //计算周围雷数
  94. int GetMineCount(char mine[ROWS][COLS], int x, int y)
  95. {
  96. return (mine[x - 1][y - 1] + mine[x - 1][y] + mine[x - 1][y + 1]
  97. + mine[x][y - 1] + mine[x][y + 1] + mine[x + 1][y - 1] +
  98. mine[x + 1][y] + mine[x + 1][y + 1] - 7 * '0');
  99. }
  100.  
  101. //展开
  102. void unfold(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col, int x, int y,int* win)
  103. {
  104. //合法坐标才展开
  105. if (x >= 1 && x <= row && y >= 1 && y <= col)
  106. {
  107. //计算这个位置周围雷数
  108. int count = GetMineCount(mine, x, y);
  109. //排查计数加1
  110. *win += 1;
  111. //如果这个位置周围无雷，向四周展开
  112. if ((count-'0') == 0)
  113. {
  114. //修改周围无雷位置为空格
  115. show[x][y] = ' ';
  116. int i = 0;
  117. for (i = x - 1; i <= x + 1; i++)
  118. {
  119. for (int j = y - 1; j <= y + 1; j++)
  120. {
  121. //每一个位置只能展开一次
  122. if (show[i][j] == '*' || show[x][y] == '!')
  123. {
  124. unfold(mine, show, row, col, i, j,win);
  125. }
  126. }
  127. }
  128. }
  129. //如果周围有雷，修改展示数组为雷数
  130. else
  131. {
  132. show[x][y] = count;
  133. }
  134. }
  135. }
  136.  
  137. //查雷
  138. void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS],int row,int col)
  139. {
  140. //保存排除了多少个不是雷的位置
  141. int win = 0;
  142. char ch = 0;
  143. while (win < (row*col- EasyCount))
  144. {
  145. int x = 0;
  146. int y = 0;
  147. printf("请输入要排查的坐标,空格隔开:>");
  148. scanf("%d %d", &x, &y);
  149. //坐标合法
  150. if (x >= 1 && x <= row && y >= 1 && y <= col)
  151. {
  152. //改位置有雷
  153. if (mine[x][y] == '1')
  154. {
  155. printf("游戏结束，你被炸死了\n");
  156. //打印雷数组
  157. DisplayBoard(mine, ROW, COL);
  158. break;
  159. }
  160. //无雷
  161. if(show[x][y] == '*' || show[x][y] == '!')
  162. {
  163. //展开
  164. unfold(mine, show, row, col, x, y,&win);
  165. system("cls");
  166. //打印展示数组
  167. DisplayBoard(show, ROW, COL);
  168. printf("需要标注地雷就输入：Y，不需要标注地雷则输入：N\n");
  169. //清空一下缓冲区
  170. while ((ch = getchar()) != '\n');
  171. scanf("%c", &ch);
  172. switch (ch)
  173. {
  174. case 'Y':
  175. //标记雷的位置
  176. SignMine(show, row, col);
  177. break;
  178. default:
  179. break;
  180. }
  181. }
  182. else
  183. {
  184. printf("你已经排查过这个位置了，请重新输入\n");
  185. }
  186. }
  187. else
  188. {
  189. printf("坐标非法，重新输入\n");
  190. }
  191. }
  192.  
  193. //判断是否是排雷结束跳出
  194. if (win == (row * col - EasyCount))
  195. {
  196. printf("恭喜你，你赢了\n");
  197. }
  198. }

(3)test.c

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2. #include "game.h"
  3. //菜单
  4. void menu()
  5. {
  6. printf("****************\n");
  7. printf("**** 1.play ****\n");
  8. printf("**** 0.exit ****\n");
  9. printf("****************\n");
  10. }
  11.  
  12. //游戏主逻辑
  13. void game()
  14. {
  15. //每一轮新游戏开始都清空屏幕
  16. system("cls");
  17. //雷数组
  18. char mine[ROWS][COLS] = { 0 };
  19. //展示数组
  20. char show[ROWS][COLS] = { 0 };
  21.  
  22. //初始化
  23. InitBoard(mine, ROWS, COLS, '0');
  24. InitBoard(show, ROWS, COLS, '*');
  25.  
  26. //开始打印
  27. printf("扫雷游戏--------\n");
  28. DisplayBoard(show, ROW, COL);
  29.  
  30. //布雷
  31. SetMine(mine, ROW, COL);
  33. //查雷
  34. //这里打印雷数组是为了方便查看
  35. //DisplayBoard(mine, ROW, COL);
  36. FindMine(mine, show,ROW,COL);
  37. }
  38.  
  39. int main()
  40. {
  41. int input = 0;
  42. srand((unsigned int)time(NULL));
  43. do
  44. {
  45. menu();
  46. printf("请输入:>");
  47. scanf("%d", &input);
  48. switch (input)
  49. {
  50. case 1:
  51. game();
  52. break;
  53. case 0:
  54. break;
  55. default:
  56. printf("非法输入，重新输入\n");
  57. break;
  58. }
  59. } while (input);
  60. }

六：实际效果演示

 

文章知识点与官方知识档案匹配，可进一步学习相关知识
算法技能树首页概览46879 人正在系统学习中
【算法系列篇】滑动窗口
走进人工智能|深度学习 算法的创世纪