C语言实现简易的扫雷游戏

 

从玩家角度分析扫雷游戏:

游戏主要分为几个步骤: 运行程序==>开始菜单==>选择开始游戏或者结束游戏==>选择开始==>展示棋盘格==>玩家开始排查雷==>判断排查结果,如果是雷游戏结束,如果不是显示排查坐标周围有几个雷并且递归展开. 然后以此循环往复直到玩家胜利或者被雷炸死==>游戏结束

游戏设计的角度分析:

由于还没学到图形界面,游戏的实现暂时只能使用控制台完成, 为了实现整个游戏逻辑, 列出以下重要组成部分:

1. 需要有可供玩家选择的开始菜单,简单实现 玩游戏或者退出游戏两个主要功能

2. 扫雷的棋盘是9X9的格子, 使用二维数组的方式存储棋盘格信息

3. 初始化棋盘后默认随机布置10个雷

4. 玩家可以输入坐标排查雷

   • 如果位置不是雷,就显示周围有几个雷

   • 如果位置是雷,游戏结束

   • 把所有非雷全部排除出来,玩家获取胜利

游戏的界面:

0	1	2	3	4	5	6	7	8	9
1	*	*	*	*	*	*	*	*	*
2	*	*	*	*	*	*	*	*	*
3	*	*	*	*	*	*	*	*	*
4	*	*	*	*	*	*	*	*	*
5	*	*	*	*	*	*	*	*	*
6	*	*	*	*	*	*	*	*	*
7	*	*	*	*	*	*	*	*	*
8	*	*	*	*	*	*	*	*	*
9	*	*	*	*	*	*	*	*	*

0	1	2	3	4	5	6	7	8	9
1	*	*	*	*	*	*	*	*	*
2	*	*	*	0	0	*	*	*	*
3	*	*	0	0	0	*	*	*	*
4	*	*	*	0	1	0	*	*	*
5	*	*	*	1	*	2	*	*	*
6	*	*	*	0	0	*	*	*	*
7	*	*	*	*	*	*	*	*	*
8	*	*	*	*	*	*	*	*	*
9	*	*	*	*	*	*	*	*	*

扫雷的过程中，布置的雷和排查出的雷的信息都需要存储，所以我们需要⼀定的数据结构来存储这些 信息。 因为我们需要在9 * 9的棋盘上布置雷的信息和排查雷，我们⾸先想到的就是创建⼀个9*9的数组来存放 信息。

如果这个位置布置雷，我们就存放1，没有布置雷就存放0.

创建工程

创建头文件 mine_game.h

源文件 main.c mine_game.c

" referrerpolicy="no-referrer" alt="image-20231206113109339">

搭建游戏框架:

xxxxxxxxxx
28
1
#define _CRT_SECURE_NO_WARNINGS
2

3
#include "game.h"  //引入头文件
4

5
int main()
6
{
7
    int input = 0;
8
    do
9
    {
10
        menu();
11
        printf("输入选择:>");
12
        scanf("%d", &input);
13
        switch (input)
14
        {
15
        case 0:
16
            printf("\n退出游戏\n");
17
            break;
18
        case 1:
19
            game(); //printf("游戏开始\n");
20
            break;
21
        default:
22
            printf("选择错误,请重新输入!!!\n");
23
            break;
24
        }
25
    } while (input);
26

27
    return 0;
28
}

主函数main.c创建运行逻辑,当游戏开始时会调用game()函数

在头文件game.h引入一些必要的头文件库

xxxxxxxxxx
9
1
#pragma once
2

3
#include <stdio.h>
4
#include <stdlib.h> //使用srand 和rand 函数
5
#include <time.h>
6

7
void menu(); //函数声明
8

9
void game();//函数声明

 

创建game.c文件为game.h上声明的函数补全定义

xxxxxxxxxx
11
1
#define _CRT_SECURE_NO_WARNINGS
2

3
#include "game.h"
4

5

6
void menu() {
7
    printf("*****************************\n");
8
    printf("********** 1. Play **********\n");
9
    printf("********** 0. Exit **********\n");
10
    printf("*****************************\n");
11
}

接下来开始构思函数game()的创建

在进入这个函数时,通过srand函数设置rand的随机钟子值,我们通常用time函数获取时间戳作为随机种子值

创建两组字符数组,定义两个字符数组,一组用来存放布置好的雷的信息,另外一组用来显示玩家的游戏进展界面,判断胜负也是由这字符数组判定得来

xxxxxxxxxx
2
1
char mine[ROW][COL] = { 0 };
2
char show[ROW][COL] = { 0 };

对二维数组的初始化就是定义棋盘格子的长宽,使用两个常量来表示ROW COL

所以再回到game.h添加常量的定义,顺便定义了场景中需要雷的个数MINECOUNT

xxxxxxxxxx
3
1
#define ROW 9
2
#define COL 9
3
#define MINECOUNT 10

考虑到游戏过程需要对棋盘格mine和show数组比较，判断玩家排查的地方是不是没有雷，如果有雷的话直接游戏结束。

如果没有雷的话,要遍历当前坐标周围的八个数组,计算出雷的个数, 并把值返回给show数组当前坐标显示给玩家

而如果对边界的坐标求周围雷个数必然会有访问越界的问题, 每一次检测循环加入对边界的检测虽然也能解决问题,但代码的逻辑判断又得增加.

目前的解决办法是给整个二维数组外扩一圈成 11(ROW+2) 11(COL+2)的数组,在这里分别定义ROWS COLS两个常量

x
1
#define ROWS ROW+2
2
#define COLS COL+2

确定好这些后,回到game.c先对两个数组分别初始化

mine 数组所有元素全部初始化为 '0'

show数组所有元素全部初始化为 '*'

定义一个专门用于初始化数组的函数

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

初始化完毕后,给mine数组布置上雷

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

使用DisplayBoard自定义函数查看两个数组的显示,测试运行确认是否无误

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

玩家开始排查雷,定义一个FindMine函数用于排查的整个过程

xxxxxxxxxx
37
1
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS])
2
{
3
    int x = 0;
4
    int y = 0;
5
    int count = ROW * COL - MINECOUNT;
6
    while (count)
7
    {
8
        printf("请输入要排查的坐标:>");
9
        scanf("%d %d", &x, &y);
10
        if (x > 0 && x <= ROW && y > 0 && y <= COL)
11
        {
12
            if (show[x][y] == '*')//是否被排查过 *代表没被排查过
13
            {
14
                if (mine[x][y] == '1') {
15
                    printf("被雷炸死,游戏结束!!!\n");
16
                    DisplayBoard(mine, ROW, COL);
17
                    break;
18
                }
19
                else
20
                {
21
                    ClearAllAround(mine, show, x, y, &count);
22
                    DisplayBoard(show, ROW, COL);
23
                }
24
                
25
            }
26
            else
27
                goto feifa;
28
        }
29
        else {
30
            feifa:
31
                printf("坐标非法, 请重新输入!!\n");
32
        }
33
    }
34
    if (count <= 0) {
35
        printf("玩家胜利!!!再来一局?\n");
36
    }
37
}

ClearAllAround(mine, show, x, y, &count);是自定义的一个函数:

在查询到的位置没有被排查过且不是雷的时候,开始递归向四周不断查询雷的情况,当遇到以下情况才停止递归:

1.当遇到9X9之外的边界的时候

2.到当前show[x][y]的坐标求得周围8个坐标分布至少有一个雷的时候

xxxxxxxxxx
21
1
static void ClearAllAround(char mine[ROWS][COLS], char show[ROWS][COLS], int x, int y, int* count)
2
{
3
    if (show[x][y] == '*') {
4
        int num = GetAroundCount(mine, x, y);
5
        show[x][y] = num;
6
        (*count)--;
7
        if (show[x][y] == '0')//不等于0就不再继续递归
8
        {
9
            for (int i = x - 1; i <= x + 1; i++)
10
            {
11
                for (int j = y - 1; j <= y + 1; j++)
12
                {
13
                    if (i > 0 && j > 0 && i <= ROW && j <= COL)
14
                    {
15
                        ClearAllAround(mine, show, i, j, count);
16
                    }
17
                }
18
            }
19
        }
20
    }
21
}

到这一步 基本就实现了扫雷的功能,game.c的代码如下:

xxxxxxxxxx
150
1
#define _CRT_SECURE_NO_WARNINGS
2

3
#include "game.h"
4

5

6
void menu() {
7
    printf("*****************************\n");
8
    printf("********** 1. Play **********\n");
9
    printf("********** 0. Exit **********\n");
10
    printf("*****************************\n");
11
}
12

13
void init_board(char board[ROWS][COLS], int rows, int cols, char set)
14
{
15
    for (int i = 0; i < rows; i++)
16
    {
17
        for (int j = 0; j < cols; j++)
18
        {
19
            board[i][j] = set;
20
        }
21
    }
22
}
23

24
void DisplayBoard(char board[ROWS][COLS], int row, int col)
25
{   
26
    printf("------扫雷游戏------\n");
27
    int i = 0;
28
    for (i = 0; i <= col; i++)
29
    {
30
        printf("%d ", i);
31
    }
32
    printf("\n");
33
    for (i = 1; i <= row; i++)
34
    {
35
        printf("%d ", i);
36
        for (int j = 1; j <= col; j++)
37
        {
38
            printf("%c ", board[i][j]);
39
        }
40
        printf("\n");
41
    }
42
}
43

44
void setMine(char board[ROWS][COLS], int row, int col)
45
{
46
    int x = 0;
47
    int y = 0;
48
    int count = MINECOUNT;
49
    while (count>0)
50
    {
51
        x = rand() % row + 1;
52
        y = rand() % col + 1;
53
        if (board[x][y] == '0') {
54
            board[x][y] = '1';
55
            count--;
56
        }
57
    }
58
}
59

60
int GetAroundCount(char mine[ROWS][COLS], int x, int y)
61
{
62
    int sum = 0;
63
    for (int i = x - 1; i <= x + 1; i++)
64
    {
65
        for (int j = y - 1; j <= y + 1; j++)
66
        {
67
            sum += mine[i][j] - '0';
68
        }
69
    }
70
    return sum + '0';
71
}
72

73
static void ClearAllAround(char mine[ROWS][COLS], char show[ROWS][COLS], int x, int y, int* count)
74
{
75
    if (show[x][y] == '*') {
76
        int num = GetAroundCount(mine, x, y);
77
        show[x][y] = num;
78
        (*count)--;
79
        if (show[x][y] == '0')//不等于0就不再继续递归
80
        {
81
            for (int i = x - 1; i <= x + 1; i++)
82
            {
83
                for (int j = y - 1; j <= y + 1; j++)
84
                {
85
                    if (i > 0 && j > 0 && i <= ROW && j <= COL)
86
                    {
87
                        ClearAllAround(mine, show, i, j, count);
88
                    }
89
                }
90
            }
91
        }
92
    }
93
}
94

95
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS])
96
{
97
    int x = 0;
98
    int y = 0;
99
    int count = ROW * COL - MINECOUNT;
100
    while (count)
101
    {
102
        printf("请输入要排查的坐标:>");
103
        scanf("%d %d", &x, &y);
104
        if (x > 0 && x <= ROW && y > 0 && y <= COL)
105
        {
106
            if (show[x][y] == '*')//是否被排查过 *代表没被排查过
107
            {
108
                if (mine[x][y] == '1') {
109
                    printf("被雷炸死,游戏结束!!!\n");
110
                    DisplayBoard(mine, ROW, COL);
111
                    break;
112
                }
113
                else
114
                {
115
                    ClearAllAround(mine, show, x, y, &count);
116
                    DisplayBoard(show, ROW, COL);
117
                }
118
                
119
            }
120
            else
121
                goto feifa;
122
        }
123
        else {
124
            feifa:
125
                printf("坐标非法, 请重新输入!!\n");
126
        }
127
    }
128
    if (count <= 0) {
129
        printf("玩家胜利!!!再来一局?\n");
130
    }
131
}
132

133
void game()
134
{
135
    printf("开始游戏!!\n");
136
    srand((unsigned int)time(NULL));
137

138
    char mine[ROWS][COLS] = { 0 };
139
    char show[ROWS][COLS] = { 0 };
140

141
    init_board(mine, ROWS, COLS, '0');
142
    init_board(show, ROWS, COLS, '*');
143

144
    setMine(mine, ROW, COL);//布置雷
145
    //DisplayBoard(mine, ROW, COL);
146
    DisplayBoard(show, ROW, COL);
147
    
148
    FindMine(mine, show);
149
}
150

 

完成扩展:添加标记功能

整个代码结构稍微调整

定义函数PlayerStep:

x
1
void PlayerStep(char mine[ROWS][COLS], char show[ROWS][COLS], int* markNum, int* count)
2
{
3
    int input = 0;
4
    while(1)
5
    {
6
        printf("请选择:1.标记雷 2.排查雷\n:>");
7
        scanf("%d", &input);
8
        if (input==1)
9
        {
10
            if (MarkMine(mine, show, markNum))
11
                break;
12
        }
13
        else if (input == 2)
14
        {
15
            if (FindMine(mine, show, count))
16
                break;
17
        }
18
    }
19

20
}

FindMine放到了该函数内部,并且整个排查雷的循环交给PlayerStep完成

PlayerStep函数通过while循环让玩家选择标记雷或者排查雷,玩家在每一步的开始都要选择排查雷或者标记雷,从而跳转到对应的函数

MarkMine是新创建的标记雷函数,每次运行都会返回整型1或者0用作游戏是否结束的分支判断

FindMine函数修改后如下:

x
45
1
int FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int* count)
2
{
3
    int x = 0;
4
    int y = 0;
5
    
6
    while (1)
7
    {
8
        printf("请输入要排查的坐标:>");
9
        scanf("%d %d", &x, &y);
10
        if (x > 0 && x <= ROW && y > 0 && y <= COL)
11
        {
12
            if (show[x][y] == '*' || show[x][y] == 'M')//是否被排查过 *代表没被排查过
13
            {
14
                if (mine[x][y] == '1') {
15
                    printf("被雷炸死,游戏结束!!!\n");
16
                    DisplayBoard(mine, ROW, COL);
17
                    return 1;
18
                }
19
                else
20
                {
21
                    ClearAllAround(mine, show, x, y, count);
22
                    DisplayBoard(show, ROW, COL);
23
                    //printf("count=%d", *count); debug使用
24
                    break;
25
                }
26

27
            }
28
            else
29
                goto feifa;
30
        }
31
        else {
32
            feifa:
33
                printf("坐标非法, 请重新输入!!\n");
34
        }
35
    }
36
    if (*count <= 0) {
37
        printf("玩家胜利!!!再来一局?\n");
38
        return 1;
39
    }
40
    return 0;
41
}

修改后使函数返回一个整数类型的值

满足游戏胜利或被炸死的条件返回一个整数 1,实现跳出当前PlayerStep的while循环

判定剩余非雷个数的变量count拿到了最外面,因为整个排雷的循环移植到了PlayerStep函数中,如果继续放在FindMine函数体里面的话会造成每一个玩家步数都重置了count的值,现在是通过传指针的方式修改count值

MarkMine函数内容如下:

MarkMine函数功能就是实现玩家对坐标的标记,统一符号为'M'.其内部也是通过一个循环判断玩家输入的坐标是否非法,如果非法,请重新输入. 非法的坐标有以下2点:

1.坐标超出范围

2.坐标对应show[row][col]的值不等于'*'或者'M'

满足以上条件后值为'*'的赋值为'M','M'的赋值为'*'.等于玩家随时可以标记和取消标记

最终判断标记的总量有没有等于雷的总量,如果满足条件执行比较函数compareMarket,当然同时也要限制标记的最大个数需要等同于雷的个数,防止玩家无限标记的方式赢得游戏

函数compareMarket用于比较mine和show数组,判断所有的标记是否都恰好是雷.条件满足则返回布尔值true判定玩家胜利,跳出PlayerStep循环开始下一轮游戏的.

xxxxxxxxxx
1
int MarkMine(char mine[ROWS][COLS], char show[ROWS][COLS], int* markNum)
2
{
3
    int x = 0;
4
    int y = 0;
5

6
    while (1)
7
    {
8
        //DisplayBoard(mine, ROW, COL);//Debug用的
9
        printf("请输入要标记的坐标:>");
10
        scanf("%d %d", &x, &y);
11
        if (x > 0 && x <= ROW && y > 0 && y <= COL)
12
        {
13
            if (show[x][y] == '*')
14
            {   
15
                if ((*markNum) >= MINECOUNT) {
16
                    printf("标记已经超出最大数量限制!!!\n");
17
                    break;
18
                }
19
                show[x][y] = 'M';
20
                (*markNum)++;
21
            }
22
            else if (show[x][y] == 'M')
23
            {
24
                show[x][y] = '*';
25
                (*markNum)--;
26
            }
27
            else {
28
                printf("坐标非法, 请重新输入!!\n");
29
                continue;
30
            }
31
            DisplayBoard(show, ROW, COL);
32
            break;
33
        }
34
        else {
35
            printf("坐标非法, 请重新输入!!\n");
36
            continue;
37
        }
38
    }
39
    if ((*markNum) >= MINECOUNT) {
40
        if (compareMarket(mine, show))
41
        {
42
            printf("已经标记完所有雷,玩家胜利!!!\n");
43
            DisplayBoard(mine, ROW, COL);
44
            return 1;
45
        }
46
        return 0;
47
    }
48
    else
49
        return 0;
50
}
51

52
bool compareMarket(char mine[ROWS][COLS], char show[ROWS][COLS])
53
{
54
    int count = 0;
55
    for (int i = 1; i <= ROW; i++)
56
    {
57
        for (int j = 1; j <= COL; j++)
58
        {
59
            if (show[i][j] == 'M' && mine[i][j] == '1')
60
            {
61
                count++;
62
            }
63
        }
64
    }
65
    if (count == MINECOUNT)
66
        return true;
67
    return false;
68
}

 

 

完整代码如下:

game.h:

xxxxxxxxxx
34
1
#pragma once
2

3

4
#include <stdio.h>
5
#include <stdlib.h>
6
#include <time.h>
7
#include <stdbool.h>
8

9
#define ROW 9
10
#define COL 9
11
#define MINECOUNT 10
12

13
#define ROWS ROW+2
14
#define COLS COL+2
15

16
void menu();
17

18
void game();
19

20
void init_board(char board[ROWS][COLS], int rows, int cols, char set);
21

22
void setMine(char board[ROWS][COLS], int row, int col);
23

24
void DisplayBoard(char board[ROWS][COLS], int row, int col);
25

26
int FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int* count);
27

28
int GetAroundCount(char mine[ROWS][COLS], int x, int y);
29

30
void PlayerStep(char mine[ROWS][COLS], char show[ROWS][COLS], int *markNum, int* count);
31

32
int MarkMine(char mine[ROWS][COLS], char show[ROWS][COLS], int* markNum);
33

34
bool compareMarket(char mine[ROWS][COLS], char show[ROWS][COLS]);

game.c:

x
1
#define _CRT_SECURE_NO_WARNINGS
2

3
#include "game.h"
4

5

6
void menu() {
7
    printf("*****************************\n");
8
    printf("********** 1. Play **********\n");
9
    printf("********** 0. Exit **********\n");
10
    printf("*****************************\n");
11
}
12

13
void init_board(char board[ROWS][COLS], int rows, int cols, char set)
14
{
15
    for (int i = 0; i < rows; i++)
16
    {
17
        for (int j = 0; j < cols; j++)
18
        {
19
            board[i][j] = set;
20
        }
21
    }
22
}
23

24
void DisplayBoard(char board[ROWS][COLS], int row, int col)
25
{   
26
    printf("------扫雷游戏------\n");
27
    int i = 0;
28
    for (i = 0; i <= col; i++)
29
    {
30
        printf("%d ", i);
31
    }
32
    printf("\n");
33
    for (i = 1; i <= row; i++)
34
    {
35
        printf("%d ", i);
36
        for (int j = 1; j <= col; j++)
37
        {
38
            printf("%c ", board[i][j]);
39
        }
40
        printf("\n");
41
    }
42
}
43

44
void setMine(char board[ROWS][COLS], int row, int col)
45
{
46
    int x = 0;
47
    int y = 0;
48
    int count = MINECOUNT;
49
    while (count>0)
50
    {
51
        x = rand() % row + 1;
52
        y = rand() % col + 1;
53
        if (board[x][y] == '0') {
54
            board[x][y] = '1';
55
            count--;
56
        }
57
    }
58
}
59

60
int GetAroundCount(char mine[ROWS][COLS], int x, int y)
61
{
62
    int sum = 0;
63
    for (int i = x - 1; i <= x + 1; i++)
64
    {
65
        for (int j = y - 1; j <= y + 1; j++)
66
        {
67
            sum += mine[i][j] - '0';
68
        }
69
    }
70
    return sum + '0';
71
}
72

73
static void ClearAllAround(char mine[ROWS][COLS], char show[ROWS][COLS], int x, int y, int* count)
74
{
75
    if (show[x][y] == '*') {
76
        int num = GetAroundCount(mine, x, y);
77
        show[x][y] = num;
78
        (*count)--;
79
        if (show[x][y] == '0')//不等于0就不再继续递归
80
        {
81
            for (int i = x - 1; i <= x + 1; i++)
82
            {
83
                for (int j = y - 1; j <= y + 1; j++)
84
                {
85
                    if (i > 0 && j > 0 && i <= ROW && j <= COL)
86
                    {
87
                        ClearAllAround(mine, show, i, j, count);
88
                    }
89
                }
90
            }
91
        }
92
    }
93
}
94
/*
95
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS])
96
{
97
    int x = 0;
98
    int y = 0;
99
    int count = ROW * COL - MINECOUNT;
100
    while (count)
101
    {
102
        printf("请输入要排查的坐标:>");
103
        scanf("%d %d", &x, &y);
104
        if (x > 0 && x <= ROW && y > 0 && y <= COL)
105
        {
106
            if (show[x][y] == '*')//是否被排查过 *代表没被排查过
107
            {
108
                if (mine[x][y] == '1') {
109
                    printf("被雷炸死,游戏结束!!!\n");
110
                    DisplayBoard(mine, ROW, COL);
111
                    break;
112
                }
113
                else
114
                {
115
                    ClearAllAround(mine, show, x, y, &count);
116
                    DisplayBoard(show, ROW, COL);
117
                }
118
                
119
            }
120
            else
121
                goto feifa;
122
        }
123
        else {
124
            feifa:
125
                printf("坐标非法, 请重新输入!!\n");
126
        }
127
    }
128
    if (count <= 0) {
129
        printf("玩家胜利!!!再来一局?\n");
130
    }
131
}
132
*/
133

134
int FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int* count)
135
{
136
    int x = 0;
137
    int y = 0;
138
    
139
    while (1)
140
    {
141
        printf("请输入要排查的坐标:>");
142
        scanf("%d %d", &x, &y);
143
        if (x > 0 && x <= ROW && y > 0 && y <= COL)
144
        {
145
            if (show[x][y] == '*' || show[x][y] == 'M')//是否被排查过 *代表没被排查过
146
            {
147
                if (mine[x][y] == '1') {
148
                    printf("被雷炸死,游戏结束!!!\n");
149
                    DisplayBoard(mine, ROW, COL);
150
                    return 1;
151
                }
152
                else
153
                {
154
                    ClearAllAround(mine, show, x, y, count);
155
                    DisplayBoard(show, ROW, COL);
156
                    //printf("count=%d", *count); debug使用
157
                    break;
158
                }
159

160
            }
161
            else
162
                goto feifa;
163
        }
164
        else {
165
            feifa:
166
                printf("坐标非法, 请重新输入!!\n");
167
        }
168
    }
169
    if (*count <= 0) {
170
        printf("玩家胜利!!!再来一局?\n");
171
        return 1;
172
    }
173
    return 0;
174
}
175

176
bool compareMarket(char mine[ROWS][COLS], char show[ROWS][COLS])
177
{
178
    int count = 0;
179
    for (int i = 1; i <= ROW; i++)
180
    {
181
        for (int j = 1; j <= COL; j++)
182
        {
183
            if (show[i][j] == 'M' && mine[i][j] == '1')
184
            {
185
                count++;
186
            }
187
        }
188
    }
189
    if (count == MINECOUNT)
190
        return true;
191
    return false;
192
}
193

194
int MarkMine(char mine[ROWS][COLS], char show[ROWS][COLS], int* markNum)
195
{
196
    int x = 0;
197
    int y = 0;
198

199
    while (1)
200
    {
201
        //DisplayBoard(mine, ROW, COL);//Debug用的
202
        printf("请输入要标记的坐标:>");
203
        scanf("%d %d", &x, &y);
204
        if (x > 0 && x <= ROW && y > 0 && y <= COL)
205
        {
206
            if (show[x][y] == '*')
207
            {   
208
                if ((*markNum) >= MINECOUNT) {
209
                    printf("标记已经超出最大数量限制!!!\n");
210
                    break;
211
                }
212
                show[x][y] = 'M';
213
                (*markNum)++;
214
            }
215
            else if (show[x][y] == 'M')
216
            {
217
                show[x][y] = '*';
218
                (*markNum)--;
219
            }
220
            else {
221
                printf("坐标非法, 请重新输入!!\n");
222
                continue;
223
            }
224
            DisplayBoard(show, ROW, COL);
225
            break;
226
        }
227
        else {
228
            printf("坐标非法, 请重新输入!!\n");
229
            continue;
230
        }
231
    }
232
    if ((*markNum) >= MINECOUNT) {
233
        if (compareMarket(mine, show))
234
        {
235
            printf("已经标记完所有雷,玩家胜利!!!\n");
236
            DisplayBoard(mine, ROW, COL);
237
            return 1;
238
        }
239
        return 0;
240
    }
241
    else
242
        return 0;
243
}
244

245
void PlayerStep(char mine[ROWS][COLS], char show[ROWS][COLS], int* markNum, int* count)
246
{
247
    int input = 0;
248
    while(1)
249
    {
250
        printf("请选择:1.标记雷 2.排查雷\n:>");
251
        scanf("%d", &input);
252
        if (input==1)
253
        {
254
            if (MarkMine(mine, show, markNum))
255
                break;
256
        }
257
        else if (input == 2)
258
        {
259
            if (FindMine(mine, show, count))
260
                break;
261
        }
262
    }
263

264
}
265

266
void game()
267
{
268
    printf("开始游戏!!\n");
269
    srand((unsigned int)time(NULL));
270

271
    char mine[ROWS][COLS] = { 0 };
272
    char show[ROWS][COLS] = { 0 };
273

274
    init_board(mine, ROWS, COLS, '0');
275
    init_board(show, ROWS, COLS, '*');
276

277
    setMine(mine, ROW, COL);
278
    //DisplayBoard(mine, ROW, COL);
279
    DisplayBoard(show, ROW, COL);
280
    
281
    int markNum = 0;
282
    int count = ROW * COL - MINECOUNT;
283
    PlayerStep(mine, show, &markNum, &count);
284
    
285

286
}

main.c

xxxxxxxxxx
28
1
#define _CRT_SECURE_NO_WARNINGS
2

3
#include "game.h"
4

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

27
    return 0;
28
}