C语言实现扫雷小游戏(扩展版可选择游戏难度)

游戏简介

扫雷，是一款益智类小游戏。
游戏目标是找出所有没有地雷的方格，完成游戏；要是按了有地雷的方格，游戏失败；玩家可标记雷的位置。游戏以完成时间来评高低。有不同的游戏难度可选择。

实现的功能介绍

1.计时
2.初始化雷盘
3.打印雷盘
4.随机设置雷的分布，可选择游戏难易程度
5.统计坐标位置周围的雷数
6.第一次排雷不会被炸死
7.扩展式排雷，展开周围的非雷区
8.给所选坐标位置做标记，或取消标记

该程序分为三个文件：

1.game.h ：包含头文件的引用、函数的声明和宏定义
2.game.c ：包含游戏各功能函数的具体实现
3.pro.c ：各功能函数的调用（程序的流程）
PS:文章末尾附完整代码 及 游戏效果图

因为排雷时要计算每个位置周围八个位置的雷数，所以在创建数组时要多一圈，即行列都要加2。给用户显示的数组不需要加。

游戏功能代码详解

1.计时

运用clock函数,该函数需要的头文件为 “time.h”
函数原型：clock_t clock(void);
功能：程序从启动到函数调用占用CPU的时间
这个函数返回从“开启这个程序进程”到“程序中调用clock()函数”时之间的CPU时钟计时单元（clock tick）数，在MSDN中称之为挂钟时间；若挂钟时间不可取，则返回-1。其中clock_t是用来保存时间的数据类型。

1. void set_time()//计时
2. {
3. printf("用时:%u 秒\n", clock() / CLOCKS_PER_SEC);
4. }

2.初始化雷盘
这里我用到的是memset函数,需要的头文件为“memory.h”或“string.h”
函数原型：void *memset(void *s, int ch, size_t n);
功能：将s中当前位置后面的n个字节 （typedef unsigned int size_t ）用 ch 替换并返回 s 。在一段内存块中填充某个给定的值。

1. void init_board(char board[ROWS][COLS], int row, int col, char c)//初始化雷盘
2. {
3. memset(board, c, row*col*sizeof(board[0][0]));
4. }

3.打印雷盘
运用两个循环体实现雷盘数组的赋值、行号、列号的打印。正式游戏时可以加上system(“CLS”); 清屏语句，每次调用时都清屏一次，使游戏画面更简洁清晰。
我们把计时函数放在里面，每次打印雷盘时就可以显示所用的时间。

1. void disp_board(char board[ROWS][COLS], int row, int col)//打印雷盘
2. {
3. int i = 0;
4. int j = 0;
5. //system("CLS");//清屏
6. for (i = 0; i <= row; i++)
7. {
8. printf("%2d ", i);//打印行号
9. }
10. printf("\n");
11. for (i = 1; i <= row; i++)
12. {
13. printf("%2d ", i);//打印列号
14. for (j = 1; j <= col; j++)
15. {
16. printf("%2c ", board[i][j]);
17. }
18. printf("\n");
19. }
20. printf("\n");
21. set_time();//打印所用的时间
22. }

4.随机设置雷的分布，可选择游戏难易程度
放置雷必须是随机的，这里用到了rand函数,它和srand函数配合使用产生随机数。srand(time(NULL))放在主函数中调用一次，通过系统时间提供的种子值，使rand函数生成不同的伪随机数序列。

1. void set_mine(char board[ROWS][COLS], int row, int col,int count)//置雷
2. {
3. int x = 0;
4. int y = 0;
5. while (count)
6. {
7. x = rand() % row + 1;//随机位置范围1~row
8. y = rand() % col + 1;//随机位置范围1~col
9. if (board[x][y] == '0')//判断是否已有雷
10. {
11. board[x][y] = '1';//有雷的位置赋为1
12. count--;
13. }
14. }
15. }

5.统计坐标位置周围的雷数 及 未扫的位置的个数
当扫到一个没有雷的位置时，会显示这个位置周围一圈八个位置的含雷的总数，所以我们要写一个“数雷”函数来数。

1. int count_mine(char mine[ROWS][COLS], int x, int y)//数雷
2. {
3. return mine[x - 1][y] + mine[x - 1][y + 1] + mine[x][y + 1] + mine[x + 1][y + 1] + mine[x + 1][y] +
4. mine[x + 1][y - 1] + mine[x][y - 1] + mine[x - 1][y - 1] - 8 * '0';//数周围一圈八个位置的雷数
5. }
6.  
7. int count_print(char print[ROWS][COLS], int row, int col)//数未扫位置
8. {
9. int count = 0;
10. int i = 0;
11. for (i = 1; i <= row; i++)
12. {
13. int j = 0;
14. for (j = 1; j <= col; j++)
15. {
16. if (print[i][j] == '@' ||print[i][j] == '*')
17. {
18. count++;
19. }
20. }
21. }
22. return count;
23. }

6.第一次排雷不会被炸死
为了增加游戏的可玩性，加入“第一次排雷不被炸死”这个函数。当第一次排就遇到雷时，我们把雷偷偷挪走，随机放在一个原本无雷的位置。

1. void safe_mine(char mine[ROWS][COLS],char print[ROWS][COLS],int x,int y,int row,int col)//第一次排雷不炸死
2. {
3. char ch = 0;
4. int ret = 1;
5. int number = 0;
6. if (mine[x][y] == '1')//第一次踩到雷后补救
7. {
8. mine[x][y] = '0';
9. char ch = count_mine(mine, x, y);
10. print[x][y] = ch + '0';//数字对应的ASCII值和数字字符对应的ASCII值相差48，即'0'的ASCII值
11. extend_board(mine, print, x, y);
12. while (ret)//在其余有空的地方设置一个雷
13. {
14. int x = rand() % row + 1;//产生1到row的随机数，在数组下标为1到10的范围内布雷
15. int y = rand() % col + 1;//产生1到col的随机数，在数组下标为1到10的范围内布雷
16. if (mine[x][y] == '0')//找不是雷的地方布雷
17. {
18. mine[x][y] = '1';
19. disp_board(print, row, col);
20. //disp_board(mine, row, col);
21. ret--;
22. break;
23. }
24. }
25. }
26. }

7.扩展式排雷，展开周围的非雷区
当游戏中排到一个周围一圈都无雷的位置时，运用递归，实现扩展展开周围的一片无雷区。

1. void extend_board(char mine[ROWS][COLS], char print[ROWS][COLS], int x, int y)//运用递归扩展周围
2. {
3. int n = 0;
4. n = count_mine(mine, x, y);
5. if (n == 0)//当该位置周围雷数为0时扩展
6. {
7. print[x][y] = ' ';//扩展的位置变为“空格”打印出来
8. if (mine[x - 1][y] == '0' && print[x - 1][y] == '@')
9. {
10. extend_board(mine, print, x - 1, y);//递归
11. }
12. if (mine[x + 1][y] == '0' && print[x + 1][y] == '@')
13. {
14. extend_board(mine, print, x + 1, y);
15. }
16. if (mine[x][y + 1] == '0' && print[x][y + 1] == '@')
17. {
18. extend_board(mine, print, x, y + 1);
19. }
20. if (mine[x - 1][y + 1] == '0' && print[x - 1][y + 1] == '@')
21. {
22. extend_board(mine, print, x - 1, y + 1);
23. }
24. if (mine[x + 1][y + 1] == '0' && print[x + 1][y + 1] == '@')
25. {
26. extend_board(mine, print, x + 1, y + 1);
27. }
28. if (mine[x][y - 1] == '0' && print[x][y - 1] == '@')
29. {
30. extend_board(mine, print, x, y - 1);
31. }
32. if (mine[x + 1][y - 1] == '0' && print[x + 1][y -1] == '@')
33. {
34. extend_board(mine, print, x + 1, y - 1);
35. }
36. if (mine[x - 1][y - 1] == '0' && print[x - 1][y - 1] == '@')
37. {
38. extend_board(mine, print, x - 1, y - 1);
39. }
40. }
41. else
42. print[x][y] = n + '0';
43. }
44.  
45. int find_mine(char mine[ROWS][COLS], char print[ROWS][COLS], int row, int col,int count)//排雷
46. {
47. int x = 0;
48. int y = 0;
49. int number = 0;
50. int ret = 0;
51. while (1)
52. {
53. printf("输入坐标扫雷\n");
54. scanf("%d%d", &x, &y);//玩家输入扫雷的坐标位置
55. if ((x >= 1 && x <= row) && (y >= 1 && y <= col))//判断输入坐标是否有误，输入错误重新输入
56. {
57. if (mine[x][y] == '0')//没踩到雷
58. {
59. number++;//记录扫雷的次数
60. char ch = count_mine(mine, x, y);//数雷数
61. print[x][y] = ch + '0';//数字对应的ASCII值和数字字符对应的ASCII值相差48，即'0'的ASCII值
62. extend_board(mine, print, x, y);
63. disp_board(mine, row, col);
64. disp_board(print, row, col);
65. if (count_print(print, row, col) == count)//剩余未扫位置=雷数 时胜利
66. {
67. return 0;
68. }
69. to_sign(print);//判断是否标记
70. disp_board(print, row, col);
71. }
72. else if (mine[x][y] == '1')//踩到雷
73. {
74. if (ret == 0 && number == 0)
75. {
76. ret++;
77. safe_mine(mine,print,x,y,row,col);
78. }
79. else
80. return 1;
81. }
82. }
83. else
84. {
85. printf("输入错误!请重新输入\n");
86. }
87. }
88. }

8.给所选坐标位置做标记，或取消标记
扫雷游戏还有一个功能：可以给你认为是雷的位置标记，或者取消标记。
我通过三个函数来实现，一个判断用户是否需要标记；一个实现标记功能，将@标记成* ；一个实现取消标记功能，将* 改回@。

1. void to_sign(char board[ROWS][COLS])//判断是否标记
2. {
3. int chose_b = 0;
4. int x = 0;
5. int y = 0;
6. printf("是否需要标记/取消标记:>\n(1.标记 ；2.取消标记 ；3.跳过该步骤) :>");
7. scanf("%d", &chose_b);
8. do{
9. switch (chose_b)
10. {
11. case 1:
12. {
13. printf("请输入需要标记的位置坐标:>\n");
14. scanf("%d%d", &x, &y);
15. sign(board, x, y);
16. break;
17. }
18. case 2:
19. {
20. printf("请输入取消标记的位置坐标:>\n");
21. scanf("%d%d", &x, &y);
22. unsign(board, x, y);
23. break;
24. }
25. case 3:
26. {
27. printf("跳过此步骤。\n");
28. chose_b = 0;
29. break;
30. }
31. default:
32. { printf("输入错误！\n");
33. chose_b = 0;
34. break;
35. }
36. }
37. chose_b = 0;
38. } while (chose_b);
39. }
40. void sign(char board[ROWS][COLS], int x, int y)//用‘*'标记雷
41. {
42. if (board[x][y] == '@')
43. {
44. board[x][y] = '*';
45. }
46. }
47.  
48. void unsign(char board[ROWS][COLS], int x, int y)//取消标记
49. {
50. if (board[x][y] == '*')
51. {
52. board[x][y] = '@';
53. }
54. }

附：完整代码

game.h

1. #ifndef _GAME_H_
2. #define _GAME_H_
3. //用到的头文件
4. #include<stdio.h>
5. #include<stdlib.h>
6. #include<time.h>
7. #include<string.h>
8. #include<windows.h>
9. //定义打印的雷盘行、列
10. #define _ROW 9
11. #define _COL 9
12. #define ROW 16
13. #define COL 16
14. //定义数组的行、列
15. #define _ROWS _ROW+2
16. #define _COLS _COL+2
17. #define ROWS ROW+2
18. #define COLS COL+2
19. //定义难、易程度雷数
20. #define EASY_COUNT 10
21. #define HARD_COUNT 40
22. //定义游戏中的函数
23. void init_board(char board[ROWS][COLS],int row, int col, char c);//初始化
24. void disp_board(char board[ROWS][COLS],int row,int col);//打印
25. void set_mine(char board[ROWS][COLS], int row, int col,int count);//置雷
26. void safe_mine(char mine[ROWS][COLS], char print[ROWS][COLS], int x, int y, int row, int col);//第一次排雷不炸死
27. int find_mine(char mine[ROWS][COLS], char print[ROWS][COLS], int row, int col,int count);//排雷
28. int count_mine(char mine[ROWS][COLS], int x, int y);//数雷
29. void extend_board(char mine[ROWS][COLS], char print[ROWS][COLS], int x, int y);//扩展
30. void to_sign(char board[ROWS][COLS]);//判断是否标记
31. void sign(char board[ROWS][COLS], int x, int y);//标记
32. void unsign(char board[ROWS][COLS], int x, int y);//取消标记
33. int count_print(char print[ROWS][COLS], int row, int col);//数未扫位置
34.  
35. #endif//_GAME_H_

game.c

1. #define _CRT_SECURE_NO_WARNINGS
2. #include "game.h"
3.  
4. void set_time()//计时
5. {
6. printf("用时:%u 秒\n", clock() / CLOCKS_PER_SEC);
7. }
8. void init_board(char board[ROWS][COLS], int row, int col, char c)//初始化雷盘
9. {
10. memset(board, c, row*col*sizeof(board[0][0]));
11. }
12.  
13. void disp_board(char board[ROWS][COLS], int row, int col)//打印雷盘
14. {
15. int i = 0;
16. int j = 0;
17. system("CLS");//清屏
18. for (i = 0; i <= row; i++)//加行号
19. {
20. printf("%2d ", i);
21. }
22. printf("\n");
23. for (i = 1; i <= row; i++)//加列号
24. {
25. printf("%2d ", i);
26. for (j = 1; j <= col; j++)
27. {
28. printf("%2c ", board[i][j]);
29. }
30. printf("\n");
31. }
32. printf("\n");
33. set_time();//打印所用的时间
34. }
35.  
36. void set_mine(char board[ROWS][COLS], int row, int col,int count)//置雷
37. {
38. int x = 0;
39. int y = 0;
40. while (count)
41. {
42. x = rand() % row + 1;//随机位置范围1~row
43. y = rand() % col + 1;//随机位置范围1~col
44. if (board[x][y] == '0')//判断是否已有雷
45. {
46. board[x][y] = '1';
47. count--;
48. }
49. }
50. }
51.  
52. void safe_mine(char mine[ROWS][COLS],char print[ROWS][COLS],int x,int y,int row,int col)//第一次排雷不炸死
53. {
54. char ch = 0;
55. int ret = 1;
56. int number = 0;
57. if (mine[x][y] == '1')//第一次踩到雷后补救
58. {
59. mine[x][y] = '0';
60. char ch = count_mine(mine, x, y);
61. print[x][y] = ch + '0';//数字对应的ASCII值和数字字符对应的ASCII值相差48，即'0'的ASCII值
62. extend_board(mine, print, x, y);
63. while (ret)//在其余有空的地方设置一个雷
64. {
65. int x = rand() % row + 1;//产生1到row的随机数，在数组下标为1到10的范围内布雷
66. int y = rand() % col + 1;//产生1到col的随机数，在数组下标为1到10的范围内布雷
67. if (mine[x][y] == '0')//找不是雷的地方布雷
68. {
69. mine[x][y] = '1';
70. disp_board(print, row, col);
71. //disp_board(mine, row, col);
72. ret--;
73. break;
74. }
75. }
76. }
77. }
78.  
79. int count_mine(char mine[ROWS][COLS], int x, int y)//数雷
80. {
81. return mine[x - 1][y] + mine[x - 1][y + 1] + mine[x][y + 1] + mine[x + 1][y + 1] + mine[x + 1][y] +
82. mine[x + 1][y - 1] + mine[x][y - 1] + mine[x - 1][y - 1] - 8 * '0';//数周围一圈八个位置的雷数
83. }
84.  
85. int count_print(char print[ROWS][COLS], int row, int col)//数未扫位置
86. {
87. int count = 0;
88. int i = 0;
89. for (i = 1; i <= row; i++)
90. {
91. int j = 0;
92. for (j = 1; j <= col; j++)
93. {
94. if (print[i][j] == '@' ||print[i][j] == '*')
95. {
96. count++;
97. }
98. }
99. }
100. return count;
101. }
102.  
103. void extend_board(char mine[ROWS][COLS], char print[ROWS][COLS], int x, int y)//运用递归扩展周围
104. {
105. int n = 0;
106. n = count_mine(mine, x, y);
107. if (n == 0)//当该位置周围雷数为0时扩展
108. {
109. print[x][y] = ' ';//扩展的位置变为“空格”打印出来
110. if (mine[x - 1][y] == '0' && print[x - 1][y] == '@')
111. {
112. extend_board(mine, print, x - 1, y);//递归
113. }
114. if (mine[x + 1][y] == '0' && print[x + 1][y] == '@')
115. {
116. extend_board(mine, print, x + 1, y);
117. }
118. if (mine[x][y + 1] == '0' && print[x][y + 1] == '@')
119. {
120. extend_board(mine, print, x, y + 1);
121. }
122. if (mine[x - 1][y + 1] == '0' && print[x - 1][y + 1] == '@')
123. {
124. extend_board(mine, print, x - 1, y + 1);
125. }
126. if (mine[x + 1][y + 1] == '0' && print[x + 1][y + 1] == '@')
127. {
128. extend_board(mine, print, x + 1, y + 1);
129. }
130. if (mine[x][y - 1] == '0' && print[x][y - 1] == '@')
131. {
132. extend_board(mine, print, x, y - 1);
133. }
134. if (mine[x + 1][y - 1] == '0' && print[x + 1][y -1] == '@')
135. {
136. extend_board(mine, print, x + 1, y - 1);
137. }
138. if (mine[x - 1][y - 1] == '0' && print[x - 1][y - 1] == '@')
139. {
140. extend_board(mine, print, x - 1, y - 1);
141. }
142. }
143. else
144. print[x][y] = n + '0';
145. }
146.  
147. int find_mine(char mine[ROWS][COLS], char print[ROWS][COLS], int row, int col,int count)//排雷
148. {
149. int x = 0;
150. int y = 0;
151. int number = 0;
152. int ret = 0;
153. while (1)
154. {
155. printf("输入坐标扫雷\n");
156. scanf("%d%d", &x, &y);//玩家输入扫雷的坐标位置
157. if ((x >= 1 && x <= row) && (y >= 1 && y <= col))//判断输入坐标是否有误，输入错误重新输入
158. {
159. if (mine[x][y] == '0')//没踩到雷
160. {
161. number++;//记录扫雷的次数
162. char ch = count_mine(mine, x, y);//数雷数
163. print[x][y] = ch + '0';//数字对应的ASCII值和数字字符对应的ASCII值相差48，即'0'的ASCII值
164. extend_board(mine, print, x, y);
165. // disp_board(mine, row, col);
166. disp_board(print, row, col);
167. if (count_print(print, row, col) == count)//剩余未扫位置=雷数 时胜利
168. {
169. return 0;
170. }
171. to_sign(print);//判断是否标记
172. disp_board(print, row, col);
173. }
174. else if (mine[x][y] == '1')//踩到雷
175. {
176. if (ret == 0 && number == 0)
177. {
178. ret++;
179. safe_mine(mine,print,x,y,row,col);
180. }
181. else
182. return 1;
183. }
184. }
185. else
186. {
187. printf("输入错误!请重新输入\n");
188. }
189. }
190. }
191.  
192. void sign(char board[ROWS][COLS], int x, int y)//用‘*'标记雷
193. {
194. if (board[x][y] == '@')
195. {
196. board[x][y] = '*';
197. }
198. }
199.  
200. void unsign(char board[ROWS][COLS], int x, int y)//取消标记
201. {
202. if (board[x][y] == '*')
203. {
204. board[x][y] = '@';
205. }
206. }
207. void to_sign(char board[ROWS][COLS])//判断是否标记
208. {
209. int chose_b = 0;
210. int x = 0;
211. int y = 0;
212. printf("是否需要标记/取消标记:>\n(1.标记 ；2.取消标记 ；3.跳过该步骤) :>");
213. scanf("%d", &chose_b);
214. do{
215. switch (chose_b)
216. {
217. case 1:
218. {
219. printf("请输入需要标记的位置坐标:>\n");
220. scanf("%d%d", &x, &y);
221. sign(board, x, y);
222. break;
223. }
224. case 2:
225. {
226. printf("请输入取消标记的位置坐标:>\n");
227. scanf("%d%d", &x, &y);
228. unsign(board, x, y);
229. break;
230. }
231. case 3:
232. {
233. printf("跳过此步骤。\n");
234. chose_b = 0;
235. break;
236. }
237. default:
238. { printf("输入错误！\n");
239. chose_b = 0;
240. break;
241. }
242. }
243. chose_b = 0;
244. } while (chose_b);
245. }

pro.c

1. #define _CRT_SECURE_NO_WARNINGS
2. #include "game.h"
3.  
4. void menu()
5. {
6. printf("+---------------------------------+\n");
7. printf("+ Welcome to 扫雷世界 ！ +\n");
8. printf("+ ο(=>ω<=)ρ⌒☆ +\n");
9. printf("+ 1、play +\n");
10. printf("+ 0、exit +\n");
11. printf("+---------------------------------+\n");
12. }
13.  
14. void game()
15. {
16. char mine[ROWS][COLS] = { 0 };
17. char print[ROWS][COLS] = { 0 };
18. int chose_m = 0;
19. int ret = 0;
20. printf("请选择模式（1、简单 2、困难）:>");//选择游戏难易程度，产生不同大小的棋盘和雷数
21. scanf("%d", &chose_m);
22. switch (chose_m)
23. {
24. case 1:
25. {
26. init_board(mine, ROWS, COLS, '0');//初始化雷盘
27. init_board(print, ROWS, COLS, '@');
28. set_mine(mine, _ROW, _COL, EASY_COUNT);//布雷
29. // disp_board(mine, _ROW, _COL);//打印雷盘
30. disp_board(print, _ROW, _COL);
31. int ret = find_mine(mine, print, _ROW, _COL, EASY_COUNT);//扫雷,踩到雷返回1，没有踩到雷返回0
32. while (1)//循环扫雷
33. {
34. if (ret == 0)//若返回0则胜利
35. {
36. disp_board(print, _ROW, _COL);
37. printf("WOW~ YOU WIN！\n\n");
38. break;
39. }
40. if (ret)//若返回1则失败
41. {
42. disp_board(mine, _ROW, _COL);//打印雷盘
43. printf("GAME OVER!\n");
44. break;
45. }
46. disp_board(print, _ROW, _COL);//打印玩家棋盘
47. }
48. break;
49. }
50. case 2:
51. {
52. init_board(mine, ROWS, COLS, '0');//初始化雷盘
53. init_board(print, ROWS, COLS, '@');
54. set_mine(mine, ROW, COL, HARD_COUNT);//布雷
55. // disp_board(mine, ROW, COL);//打印雷盘
56. disp_board(print, ROW, COL);
57. while (1)//循环扫雷
58. {
59. int ret = find_mine(mine, print, ROW, COL, HARD_COUNT);//扫雷,踩到雷返回1，没有踩到雷返回0
60. if (ret == 0)//若返回0胜利
61. {
62. disp_board(print, ROW, COL);
63. printf("WOW~ YOU WIN！\n\n");
64. break;
65. }
66. if (ret)//若返回1失败
67. {
68. disp_board(mine, ROW, COL);//打印雷盘
69. printf("GAME OVER!\n");
70. break;
71. }
72. disp_board(print, ROW, COL);//打印玩家棋盘
73. }
74. break;
75. }
76. default:
77. {
78. printf("输入错误！\n");
79. break;
80. }
81. }
82. }
83. void text()
84. {
85. srand((unsigned int)time(NULL));//产生随机值发生器
86. int chose = 0;//选择是否开始游戏
87. do
88. {
89. menu();//菜单
90. printf("请选择:>");
91. scanf("%d", &chose);
92. switch (chose)
93. {
94. case 1:
95. game();//开始游戏
96. break;
97. case 0:
98. printf("退出游戏\n");
99. break;
100. default:
101. printf("输入错误，没有该选项\n");
102. break;
103. }
104. } while (chose);
105. }
106. int main()
107. {
108. text();
109. system("pause");
110. return 0;
111. }

游戏效果图

①开始选择菜单、难易模式选择

②两种难度扫雷
↓9×9雷盘 10颗雷

↓16×16雷盘 40颗雷

③演示标记


④GAME OVER 玩家失败演示

⑤WIN 玩家成功演示

 

原文链接：https://blog.csdn.net/sillyxue/article/details/80467532