C语言实现扫雷游戏详解

175 阅读 0 评论 116 点赞

我是靠谱客的博主合适硬币，这篇文章主要介绍C语言实现扫雷游戏详解，现在分享给大家，希望可以做个参考。

本文实例为大家分享了C语言实现扫雷游戏的具体代码，供大家参考，具体内容如下

功能设计

扫雷大家应该都玩过，这是一个十分经典的游戏，今天我将给大家讲解如何用C语言实现扫雷，我的这个扫雷有如下几个功能：

1、显示该点周围雷的个数
2、第一次下子，不炸死
3、坐标周围没雷，可以实现展开
4、游戏结束后展示玩家用时

效果展示

话不多说，先附上效果图：

设计思路

我们只要输入坐标就可以扫雷了，是不是很有趣？

其实要想实现这也不难，我们要用几个算法模块来模拟游戏规则，需要用函数来调用各个模块使游戏跑起来。
那么第一步我们就要构思一个棋盘，看见上面第一张图没，在开始游戏的界面我打印了两个棋盘，有0和1的棋盘是给我们设计者看的，它可以显示出当前雷的真实分布，这有利于我们测试代码的正确性，而全是 * 的棋盘是给玩家扫雷用的。

那我们就需要用二维数组来打印两个棋盘，假如我们要打印10X10的棋盘，那我们的二维数组元素也要为10X10个吗？，不能，因为我们在设计算法时需要统计坐标周围8个方位雷的个数，假如要统计边界坐标周围雷的个数，那么就会有数组越界的问题，那我们就要在10X10的边界多上一圈元素，也就要定义12X12的数组元素，这些元素我们不要打印出来，心里有数就行，如下图：

复制代码

1
2
3
4
#define row 12
#define col 12
show_mine[row][col];//玩家数组
real_mine[row][col];//设计者数组

我们在一个项目里建立三个源文件，如下:

1、我们打印设计者棋盘要用数组real_mine,打印玩家棋盘要用数组show_mine,两个数组在开始必须要初始化，在设计者棋盘中字符0代表不是雷，字符1代表雷，先初始化两个数组

代码如下：

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
void init_mine()//初始化两个雷阵
{
 int i = 0;
 int j = 0;
 for (int i = 0; i < row; i++) 
 {
 for (j = 0; j < col; j++)
 {
 show_mine[i][j] = '*';
 real_mine[i][j] = '0';
 }
 }
}

2、打印两个雷阵（不要忘了打印横竖序号以便确定坐标）

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
void print_player()//打印玩家棋盘
{
 int i = 0;
 int j = 0;
 printf("0 ");
 for (i = 1; i <row-1; i++)
 {
 printf("%d ", i);//打印横标（0--10）
 }
 printf("n");
 for (i = 1; i <row-2; i++)//打印竖标（1--10）
 {
 printf("%d ", i);
 for (j = 1; j < col-1; j++)
 {
 printf("%c ", show_mine[i][j]);//玩家棋盘数组
 }
 printf("n");
 }
 printf("10 ");//开始打印最后一行
 for (i = 1; i < row-1; i++)
 {
 printf("%c ", show_mine[10][i]);
 }
 printf("n");
}


void print_mine()//打印设计者棋盘
{
 int i = 0;
 int j = 0;
 printf("0 ");
 for (i = 1; i <row - 1; i++)
 {
 printf("%d ", i);//打印横标（0--10）
 }
 printf("n");
 for (i = 1; i <row - 2; i++)//打印竖标（1--10）
 {
 printf("%d ", i);
 for (j = 1; j < col - 1; j++)
 {
 printf("%c ", real_mine[i][j]);
 }
 printf("n");
 }
 printf("10 ");//开始打印最后一行
 for (i = 1; i < row - 1; i++)
 {
 printf("%c ", real_mine[10][i]);
 }
 printf("n");
}

3、我们在每一次玩的时候设计者棋盘中的雷分布都必须不相同，使用随机数生成横竖坐标确定布雷坐标，代码如下：

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
void set_mine()//给设计者棋盘布雷
{
 int x = 0;
 int y = 0;
 int count = COUNT;//雷总数
 while (count)//雷布完后跳出循环
 {
 int x = rand() % 10 + 1;//产生1到10的随机数，在数组下标为1到10的范围内布雷
 int y = rand() % 10 + 1;//产生1到10的随机数，在数组下标为1到10的范围内布雷
 if (real_mine[x][y] == '0')//找不是雷的地方布雷
 {
 real_mine[x][y] = '1';
 count--;
 }
 }
}

4、为了统计当前坐标周围雷的个数，定义一个函数实现：

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
int count_mine(int x, int y)//检测周围8个区域雷的个数
{
 int count = 0;
 if (real_mine[x - 1][y - 1] == '1')
 count++;
 if (real_mine[x - 1][y] == '1')
 count++; 
 if (real_mine[x - 1][y + 1] == '1')
 count++;
 if (real_mine[x][y - 1] == '1')
 count++; 
 if (real_mine[x][y + 1] == '1')
 count++; 
 if (real_mine[x + 1][y - 1] == '1')
 count++; 
 if (real_mine[x + 1][y] == '1')
 count++; 
 if (real_mine[x + 1][y + 1] == '1')
 count++;
 return count;
}

5、为了确保第一次不被雷炸死，我们需要定义个函数来实现，如果第一次选到雷就将这颗雷放在其他不是雷的地方，代码如下：

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
void safe_mine()//避免第一次炸死
{
 int x = 0;
 int y = 0;
 char ch = 0;
 int count = 0;
 int ret = 1;
 printf("输入坐标扫雷n");
 while (1)
 {
 scanf("%d%d", &x, &y);//只能输入1到10，输入错误重新输入
 if ((x >= 1 && x <= 10) && (y >= 1 && y <= 10))//判断输入坐标是否有误
 {
 if (real_mine[x][y] == '1')//第一次踩到雷后补救
 {
 real_mine[x][y] = '0';
 char ch = count_mine(x, y);
 show_mine[x][y] = ch + '0';//数字对应的ASCII值和数字字符对应的ASCII值相差48，即'0'的ASCII值
 open_mine(x, y);
 while (ret)//在其余有空的地方设置一个雷
 {
 int x = rand() % 10 + 1;//产生1到10的随机数，在数组下标为1到10的范围内布雷
 int y = rand() % 10 + 1;//产生1到10的随机数，在数组下标为1到10的范围内布雷
 if (real_mine[x][y] == '0')//找不是雷的地方布雷
 {
 real_mine[x][y] = '1';
 ret--;
 break;
 }
 }break;//跳出此函数 
 }
 if (real_mine[x][y] == '0')
 {
 char ch = count_mine(x, y);
 show_mine[x][y] = ch + '0';//数字对应的ASCII值和数字字符对应的ASCII值相差48，即'0'的ASCII值
 open_mine(x, y);
 break;
 }
 }
 else//坐标错误
 {
 printf("输入错误重新输入n");
 }
 }
}

6、为了实现展开功能，需要展开函数模块（展开的坐标还要显示其坐标周围的雷数），如下：

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
void open_mine(int x, int y)//坐标周围展开函数
{
 if (real_mine[x - 1][y - 1]== '0')
 {
 show_mine[x - 1][y - 1] = count_mine(x - 1, y - 1) + '0';//显示该坐标周围雷数
 }
 if (real_mine[x - 1][y] == '0')
 {
 show_mine[x - 1][y] = count_mine(x - 1, y) + '0';//显示该坐标周围雷数
 }
 if (real_mine[x - 1][y + 1] == '0')
 {
 show_mine[x - 1][y + 1] = count_mine(x - 1, y + 1) + '0';//显示该坐标周围雷数
 }
 if (real_mine[x][y - 1] == '0')
 {
 show_mine[x][y - 1] = count_mine(x, y - 1) + '0';//显示该坐标周围雷数
 }
 if (real_mine[x][y + 1] == '0')
 {
 show_mine[x][y + 1] = count_mine(x, y + 1) + '0';//显示该坐标周围雷数
 }
 if (real_mine[x + 1][y - 1] == '0')
 {
 show_mine[x + 1][y - 1] = count_mine(x + 1, y - 1) + '0';//显示该坐标周围雷数
 }
 if (real_mine[x + 1][y] == '0')
 {
 show_mine[x + 1][y] = count_mine(x + 1, y) + '0';//显示该坐标周围雷数
 }
 if (real_mine[x + 1][y + 1] == '0')
 {
 show_mine[x + 1][y + 1] = count_mine(x + 1, y + 1) + '0';//显示该坐标周围雷数
 }
}

7、扫雷函数是一个重要的模块，代码如下：

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
int sweep_mine()//扫雷函数，踩到雷返回1，没有踩到雷返回0
{
 int x = 0;
 int y = 0;
 int count = 0;
 printf("输入坐标扫雷n");
 scanf("%d%d", &x, &y);//只能输入1到10
 if ((x >= 1 && x <= 10) && (y >= 1 && y <= 10))//判断输入坐标是否有误，输入错误重新输入
 {
 if (real_mine[x][y] == '0')//没踩到雷
 {
 char ch = count_mine(x,y);
 show_mine[x][y] = ch+'0';//数字对应的ASCII值和数字字符对应的ASCII值相差48，即'0'的ASCII值
 open_mine(x, y);
 if (count_show_mine() == COUNT)//判断剩余未知区域的个数，个数为雷数时玩家赢
 {
 print_mine();
 printf("玩家赢！nn");
 return 0;
 }
 }
 else if (real_mine[x][y]=='1')//踩到雷
 {
 return 1;
 }

 }
 else
 {
 printf("输入错误重新输入n");
 }
 return 0;//没踩到雷
}

到最后需要确定游戏胜利的条件，我们要统计当前状态玩家棋盘中显示的剩余 * 的个数，如果个数等于总雷数时说明扫雷完成，游戏胜利，定义一个函数实现：

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
int count_show_mine()//判断剩余未知区域的个数，个数为雷数时玩家赢
{
 int count = 0;
 int i = 0;
 int j = 0;
 for (i = 1; i <= row - 2; i++)
 {
 for (j = 1; j <= col - 2; j++)
 {
 if (show_mine[i][j] == '*')
 {
 count++;
 }
 }

 }
 return count;
}

我们将以上函数的定义放在 game.c 文件中

以上就是我们要实现扫雷的模块，要想把这些模块整合起来运行，就需要一个游戏执行函数来调用这些模块，定义个game()函数实现，代码如下：

复制代码

#define _CRT_SECURE_NO_WARNINGS 1
#include"game.h"
double start, finish;
void game()
{
 
 int ret = 0;
 init_mine();//初始化玩家棋盘和设计者棋盘
 set_mine();//给设计者棋盘布雷
 print_mine();//打印设计者棋盘（可不打印）
 printf("n");
 print_player();//打印玩家棋盘
 start = clock();
 safe_mine();//避免第一次被炸死
 
 if (count_show_mine() == COUNT)//一步就赢的情况
 {
 print_mine();
 printf("玩家赢！nn");
 return ;
 }print_player();打印玩家棋盘
 
 while (1)//循环扫雷
 {
 int ret=sweep_mine();//扫雷,踩到雷返回1，没有踩到雷返回0
 if (count_show_mine() == COUNT)//若玩家棋盘的'*'个数为雷数时，扫雷完成，游戏胜利
 {
 print_mine();//打印设计者棋盘
 printf("玩家赢！nn");
 finish = clock();//取结束时间
 printf("用时%d 秒n",(int) (finish - start) / CLOCKS_PER_SEC);
 break;
 }
 if (ret)//判断是否踩到雷
 {
 printf("被雷炸死t");
 finish = clock();//取结束时间
 printf("用时%d 秒n", (int)(finish - start) / CLOCKS_PER_SEC);
 print_mine();//打印设计者雷阵查看雷的分布
 break;
 }print_player();//打印玩家棋盘
 }
}

int main()
{
 srand((unsigned int)time(NULL));//产生随机数生成器
 int input = 0;
 muen();//菜单
 do
 {
 scanf("%d", &input);
 switch (input)
 {
 case 1:game();
 break;
 case 0:exit(1);//退出游戏
 break;
 default:
 printf("输入错误，重新输入n");
 break;
 }
 muen();
 printf("contiue?n");
 } while (1);//循环玩游戏
 system("pause");
 return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
#define _CRT_SECURE_NO_WARNINGS 1
#include"game.h"
double start, finish;
void game()
{
 
 int ret = 0;
 init_mine();//初始化玩家棋盘和设计者棋盘
 set_mine();//给设计者棋盘布雷
 print_mine();//打印设计者棋盘（可不打印）
 printf("n");
 print_player();//打印玩家棋盘
 start = clock();
 safe_mine();//避免第一次被炸死
 
 if (count_show_mine() == COUNT)//一步就赢的情况
 {
 print_mine();
 printf("玩家赢！nn");
 return ;
 }print_player();打印玩家棋盘
 
 while (1)//循环扫雷
 {
 int ret=sweep_mine();//扫雷,踩到雷返回1，没有踩到雷返回0
 if (count_show_mine() == COUNT)//若玩家棋盘的'*'个数为雷数时，扫雷完成，游戏胜利
 {
 print_mine();//打印设计者棋盘
 printf("玩家赢！nn");
 finish = clock();//取结束时间
 printf("用时%d 秒n",(int) (finish - start) / CLOCKS_PER_SEC);
 break;
 }
 if (ret)//判断是否踩到雷
 {
 printf("被雷炸死t");
 finish = clock();//取结束时间
 printf("用时%d 秒n", (int)(finish - start) / CLOCKS_PER_SEC);
 print_mine();//打印设计者雷阵查看雷的分布
 break;
 }print_player();//打印玩家棋盘
 }
}


int main()
{
 srand((unsigned int)time(NULL));//产生随机数生成器
 int input = 0;
 muen();//菜单
 do
 {
 scanf("%d", &input);
 switch (input)
 {
 case 1:game();
 break;
 case 0:exit(1);//退出游戏
 break;
 default:
 printf("输入错误，重新输入n");
 break;
 }
 muen();
 printf("contiue?n");
 } while (1);//循环玩游戏
 system("pause");
 return 0;
}

在头文件game.h中声明各种函数：

game.h

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#ifndef __GAME_H__
#define __GAME__H__

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<time.h>

#define row 12
#define col 12
#define COUNT 10//棋盘中雷的总数
extern char show_mine[row][col];//展示数组
extern char real_mine[row][col];//布雷数组

void muen();//菜单函数
void init_mine();//初始化数组函数
void set_mine();//布雷函数
int count_mine();//统计周围雷的个数
void print_player();//打印玩家棋盘
void print_mine();//打印设计者棋盘 
int sweep_mine();//扫雷函数
void safe_mine();//避免第一次被雷炸死的函数
void open_mine(int x, int y);//展开函数
int count_show_mine(); ///判断玩家棋盘剩余未知区域的个数

#endif //__GAME_H__

将上面这个函数放在main.c文件中

以上我们便完成了扫雷的所有C语言代码，接下来我们测验一下：

1、检测第一次是否能不被炸死
2、检测周围没雷可以展开

总结

测试显示我们的代码没有问题，我们总结一下，这个程序的难点的就是如何实现展开和和保证第一次不被炸死，如果你仔细理解以上的程序，你就会明白其中的原理，包括为什么要在数组元素周围多一圈元素，这些模块都是游戏的核心，等你掌握了这个程序，你的逻辑思维能力就会有很大的提高！

附game.c文件源码:

复制代码

#define _CRT_SECURE_NO_WARNINGS 1
#include"game.h"
char show_mine[row][col] = { 0 };
char real_mine[row][col] = { 0 };

void muen()
{
 printf("*******************************n");
 printf("*****1.play 0.exit*******n");
 printf("*******************************n");
}

void init_mine()//初始化两个棋盘
{
 int i = 0;
 int j = 0;
 for (int i = 0; i < row; i++) 
 {
 for (j = 0; j < col; j++)
 {
 show_mine[i][j] = '*';
 real_mine[i][j] = '0';
 }
 }
}

void print_player()//打印玩家棋盘
{
 int i = 0;
 int j = 0;
 printf("0 ");
 for (i = 1; i <row-1; i++)
 {
 printf("%d ", i);//打印横标（0--10）
 }
 printf("n");
 for (i = 1; i <row-2; i++)//打印竖标（1--10）
 {
 printf("%d ", i);
 for (j = 1; j < col-1; j++)
 {
 printf("%c ", show_mine[i][j]);//玩家棋盘数组
 }
 printf("n");
 }
 printf("10 ");//开始打印最后一行
 for (i = 1; i < row-1; i++)
 {
 printf("%c ", show_mine[10][i]);
 }
 printf("n");
}

void print_mine()//打印设计者棋盘
{
 int i = 0;
 int j = 0;
 printf("0 ");
 for (i = 1; i <row - 1; i++)
 {
 printf("%d ", i);//打印横标（0--10）
 }
 printf("n");
 for (i = 1; i <row - 2; i++)//打印竖标（1--10）
 {
 printf("%d ", i);
 for (j = 1; j < col - 1; j++)
 {
 printf("%c ", real_mine[i][j]);
 }
 printf("n");
 }
 printf("10 ");//开始打印最后一行
 for (i = 1; i < row - 1; i++)
 {
 printf("%c ", real_mine[10][i]);
 }
 printf("n");
}

void set_mine()//给设计者棋盘布雷
{
 int x = 0;
 int y = 0;
 int count = COUNT;//雷总数
 while (count)//雷布完后跳出循环
 {
 int x = rand() % 10 + 1;//产生1到10的随机数，在数组下标为1到10的范围内布雷
 int y = rand() % 10 + 1;//产生1到10的随机数，在数组下标为1到10的范围内布雷
 if (real_mine[x][y] == '0')//找不是雷的地方布雷
 {
 real_mine[x][y] = '1';
 count--;
 }
 }
}

int count_mine(int x, int y)//检测周围8个区域雷的个数
{
 int count = 0;
 if (real_mine[x - 1][y - 1] == '1')
 count++;
 if (real_mine[x - 1][y] == '1')
 count++; 
 if (real_mine[x - 1][y + 1] == '1')
 count++;
 if (real_mine[x][y - 1] == '1')
 count++; 
 if (real_mine[x][y + 1] == '1')
 count++; 
 if (real_mine[x + 1][y - 1] == '1')
 count++; 
 if (real_mine[x + 1][y] == '1')
 count++; 
 if (real_mine[x + 1][y + 1] == '1')
 count++;
 return count;
}

void safe_mine()//避免第一次炸死
{
 int x = 0;
 int y = 0;
 char ch = 0;
 int count = 0;
 int ret = 1;
 printf("输入坐标扫雷n");
 while (1)
 {
 scanf("%d%d", &x, &y);//只能输入1到10，输入错误重新输入
 if ((x >= 1 && x <= 10) && (y >= 1 && y <= 10))//判断输入坐标是否有误
 {
 if (real_mine[x][y] == '1')//第一次踩到雷后补救
 {
 real_mine[x][y] = '0';
 char ch = count_mine(x, y);
 show_mine[x][y] = ch + '0';//数字对应的ASCII值和数字字符对应的ASCII值相差48，即'0'的ASCII值
 open_mine(x, y);
 while (ret)//在其余有空的地方设置一个雷
 {
 int x = rand() % 10 + 1;//产生1到10的随机数，在数组下标为1到10的范围内布雷
 int y = rand() % 10 + 1;//产生1到10的随机数，在数组下标为1到10的范围内布雷
 if (real_mine[x][y] == '0')//找不是雷的地方布雷
 {
 real_mine[x][y] = '1';
 ret--;
 break;
 }
 }break;//跳出此函数 
 }
 if (real_mine[x][y] == '0')
 {
 char ch = count_mine(x, y);
 show_mine[x][y] = ch + '0';//数字对应的ASCII值和数字字符对应的ASCII值相差48，即'0'的ASCII值
 open_mine(x, y);
 break;
 }
 }
 else//坐标错误
 {
 printf("输入错误重新输入n");
 }
 }
}

int sweep_mine()//扫雷函数，踩到雷返回1，没有踩到雷返回0
{
 int x = 0;
 int y = 0;
 int count = 0;
 printf("输入坐标扫雷n");
 scanf("%d%d", &x, &y);//只能输入1到10
 if ((x >= 1 && x <= 10) && (y >= 1 && y <= 10))//判断输入坐标是否有误，输入错误重新输入
 {
 if (real_mine[x][y] == '0')//没踩到雷
 {
 char ch = count_mine(x,y);
 show_mine[x][y] = ch+'0';//数字对应的ASCII值和数字字符对应的ASCII值相差48，即'0'的ASCII值
 open_mine(x, y);
 if (count_show_mine() == COUNT)//判断剩余未知区域的个数，个数为雷数时玩家赢
 {
 print_mine();
 printf("玩家赢！nn");
 return 0;
 }
 }
 else if (real_mine[x][y]=='1')//踩到雷
 {
 return 1;
 }

}
 else
 {
 printf("输入错误重新输入n");
 }
 return 0;//没踩到雷
}

void open_mine(int x, int y)//坐标周围展开函数
{
 if (real_mine[x - 1][y - 1]== '0')
 {
 show_mine[x - 1][y - 1] = count_mine(x - 1, y - 1) + '0';//显示该坐标周围雷数
 }
 if (real_mine[x - 1][y] == '0')
 {
 show_mine[x - 1][y] = count_mine(x - 1, y) + '0';//显示该坐标周围雷数
 }
 if (real_mine[x - 1][y + 1] == '0')
 {
 show_mine[x - 1][y + 1] = count_mine(x - 1, y + 1) + '0';//显示该坐标周围雷数
 }
 if (real_mine[x][y - 1] == '0')
 {
 show_mine[x][y - 1] = count_mine(x, y - 1) + '0';//显示该坐标周围雷数
 }
 if (real_mine[x][y + 1] == '0')
 {
 show_mine[x][y + 1] = count_mine(x, y + 1) + '0';//显示该坐标周围雷数
 }
 if (real_mine[x + 1][y - 1] == '0')
 {
 show_mine[x + 1][y - 1] = count_mine(x + 1, y - 1) + '0';//显示该坐标周围雷数
 }
 if (real_mine[x + 1][y] == '0')
 {
 show_mine[x + 1][y] = count_mine(x + 1, y) + '0';//显示该坐标周围雷数
 }
 if (real_mine[x + 1][y + 1] == '0')
 {
 show_mine[x + 1][y + 1] = count_mine(x + 1, y + 1) + '0';//显示该坐标周围雷数
 }
}

int count_show_mine()//判断剩余未知区域的个数，个数为雷数时玩家赢
{
 int count = 0;
 int i = 0;
 int j = 0;
 for (i = 1; i <= row - 2; i++)
 {
 for (j = 1; j <= col - 2; j++)
 {
 if (show_mine[i][j] == '*')
 {
 count++;
 }
 }

}
 return count;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
#define _CRT_SECURE_NO_WARNINGS 1
#include"game.h"
char show_mine[row][col] = { 0 };
char real_mine[row][col] = { 0 };


void muen()
{
 printf("*******************************n");
 printf("*****1.play 0.exit*******n");
 printf("*******************************n");
}


void init_mine()//初始化两个棋盘
{
 int i = 0;
 int j = 0;
 for (int i = 0; i < row; i++) 
 {
 for (j = 0; j < col; j++)
 {
 show_mine[i][j] = '*';
 real_mine[i][j] = '0';
 }
 }
}


void print_player()//打印玩家棋盘
{
 int i = 0;
 int j = 0;
 printf("0 ");
 for (i = 1; i <row-1; i++)
 {
 printf("%d ", i);//打印横标（0--10）
 }
 printf("n");
 for (i = 1; i <row-2; i++)//打印竖标（1--10）
 {
 printf("%d ", i);
 for (j = 1; j < col-1; j++)
 {
 printf("%c ", show_mine[i][j]);//玩家棋盘数组
 }
 printf("n");
 }
 printf("10 ");//开始打印最后一行
 for (i = 1; i < row-1; i++)
 {
 printf("%c ", show_mine[10][i]);
 }
 printf("n");
}


void print_mine()//打印设计者棋盘
{
 int i = 0;
 int j = 0;
 printf("0 ");
 for (i = 1; i <row - 1; i++)
 {
 printf("%d ", i);//打印横标（0--10）
 }
 printf("n");
 for (i = 1; i <row - 2; i++)//打印竖标（1--10）
 {
 printf("%d ", i);
 for (j = 1; j < col - 1; j++)
 {
 printf("%c ", real_mine[i][j]);
 }
 printf("n");
 }
 printf("10 ");//开始打印最后一行
 for (i = 1; i < row - 1; i++)
 {
 printf("%c ", real_mine[10][i]);
 }
 printf("n");
}


void set_mine()//给设计者棋盘布雷
{
 int x = 0;
 int y = 0;
 int count = COUNT;//雷总数
 while (count)//雷布完后跳出循环
 {
 int x = rand() % 10 + 1;//产生1到10的随机数，在数组下标为1到10的范围内布雷
 int y = rand() % 10 + 1;//产生1到10的随机数，在数组下标为1到10的范围内布雷
 if (real_mine[x][y] == '0')//找不是雷的地方布雷
 {
 real_mine[x][y] = '1';
 count--;
 }
 }
}


int count_mine(int x, int y)//检测周围8个区域雷的个数
{
 int count = 0;
 if (real_mine[x - 1][y - 1] == '1')
 count++;
 if (real_mine[x - 1][y] == '1')
 count++; 
 if (real_mine[x - 1][y + 1] == '1')
 count++;
 if (real_mine[x][y - 1] == '1')
 count++; 
 if (real_mine[x][y + 1] == '1')
 count++; 
 if (real_mine[x + 1][y - 1] == '1')
 count++; 
 if (real_mine[x + 1][y] == '1')
 count++; 
 if (real_mine[x + 1][y + 1] == '1')
 count++;
 return count;
}

void safe_mine()//避免第一次炸死
{
 int x = 0;
 int y = 0;
 char ch = 0;
 int count = 0;
 int ret = 1;
 printf("输入坐标扫雷n");
 while (1)
 {
 scanf("%d%d", &x, &y);//只能输入1到10，输入错误重新输入
 if ((x >= 1 && x <= 10) && (y >= 1 && y <= 10))//判断输入坐标是否有误
 {
 if (real_mine[x][y] == '1')//第一次踩到雷后补救
 {
 real_mine[x][y] = '0';
 char ch = count_mine(x, y);
 show_mine[x][y] = ch + '0';//数字对应的ASCII值和数字字符对应的ASCII值相差48，即'0'的ASCII值
 open_mine(x, y);
 while (ret)//在其余有空的地方设置一个雷
 {
 int x = rand() % 10 + 1;//产生1到10的随机数，在数组下标为1到10的范围内布雷
 int y = rand() % 10 + 1;//产生1到10的随机数，在数组下标为1到10的范围内布雷
 if (real_mine[x][y] == '0')//找不是雷的地方布雷
 {
 real_mine[x][y] = '1';
 ret--;
 break;
 }
 }break;//跳出此函数 
 }
 if (real_mine[x][y] == '0')
 {
 char ch = count_mine(x, y);
 show_mine[x][y] = ch + '0';//数字对应的ASCII值和数字字符对应的ASCII值相差48，即'0'的ASCII值
 open_mine(x, y);
 break;
 }
 }
 else//坐标错误
 {
 printf("输入错误重新输入n");
 }
 }
}


int sweep_mine()//扫雷函数，踩到雷返回1，没有踩到雷返回0
{
 int x = 0;
 int y = 0;
 int count = 0;
 printf("输入坐标扫雷n");
 scanf("%d%d", &x, &y);//只能输入1到10
 if ((x >= 1 && x <= 10) && (y >= 1 && y <= 10))//判断输入坐标是否有误，输入错误重新输入
 {
 if (real_mine[x][y] == '0')//没踩到雷
 {
 char ch = count_mine(x,y);
 show_mine[x][y] = ch+'0';//数字对应的ASCII值和数字字符对应的ASCII值相差48，即'0'的ASCII值
 open_mine(x, y);
 if (count_show_mine() == COUNT)//判断剩余未知区域的个数，个数为雷数时玩家赢
 {
 print_mine();
 printf("玩家赢！nn");
 return 0;
 }
 }
 else if (real_mine[x][y]=='1')//踩到雷
 {
 return 1;
 }

 }
 else
 {
 printf("输入错误重新输入n");
 }
 return 0;//没踩到雷
}


void open_mine(int x, int y)//坐标周围展开函数
{
 if (real_mine[x - 1][y - 1]== '0')
 {
 show_mine[x - 1][y - 1] = count_mine(x - 1, y - 1) + '0';//显示该坐标周围雷数
 }
 if (real_mine[x - 1][y] == '0')
 {
 show_mine[x - 1][y] = count_mine(x - 1, y) + '0';//显示该坐标周围雷数
 }
 if (real_mine[x - 1][y + 1] == '0')
 {
 show_mine[x - 1][y + 1] = count_mine(x - 1, y + 1) + '0';//显示该坐标周围雷数
 }
 if (real_mine[x][y - 1] == '0')
 {
 show_mine[x][y - 1] = count_mine(x, y - 1) + '0';//显示该坐标周围雷数
 }
 if (real_mine[x][y + 1] == '0')
 {
 show_mine[x][y + 1] = count_mine(x, y + 1) + '0';//显示该坐标周围雷数
 }
 if (real_mine[x + 1][y - 1] == '0')
 {
 show_mine[x + 1][y - 1] = count_mine(x + 1, y - 1) + '0';//显示该坐标周围雷数
 }
 if (real_mine[x + 1][y] == '0')
 {
 show_mine[x + 1][y] = count_mine(x + 1, y) + '0';//显示该坐标周围雷数
 }
 if (real_mine[x + 1][y + 1] == '0')
 {
 show_mine[x + 1][y + 1] = count_mine(x + 1, y + 1) + '0';//显示该坐标周围雷数
 }
}


int count_show_mine()//判断剩余未知区域的个数，个数为雷数时玩家赢
{
 int count = 0;
 int i = 0;
 int j = 0;
 for (i = 1; i <= row - 2; i++)
 {
 for (j = 1; j <= col - 2; j++)
 {
 if (show_mine[i][j] == '*')
 {
 count++;
 }
 }

 }
 return count;
}