c语言小游戏——扫雷_扫雷的程序代码

扫雷是一款经典的单人益智游戏，玩家需要在一个由许多方块组成的棋盘上找出所有的地雷，而不触发任何一颗地雷。

int input = 0;
	do
	{
		menu();
		printf("请选择:>");
		scanf("%d", &input);//输入1进入游戏，输入0退出游戏，输入其他重新输入
		switch (input)
		{
		case 1:
			game();
			break;
		case 0:
			printf("退出程序\n");
			break;
		default:
			printf("输入错误，请重新输入\n");
			break;
		}
	} while (input);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

这是一个 C 语言程序中的 do-while 循环结构，用于实现一个简单的游戏菜单。以下是代码的解释：

首先，使用 menu() 函数显示游戏菜单，提供了两个选项：“play"和"exit”。
然后，使用 printf() 函数提示用户输入选择，并使用 scanf() 函数从标准输入流中读取用户的选择，并将其存储在 input 变量中。
接着，使用 switch 语句根据用户的选择执行相应的操作。如果用户选择了 1，则调用 game() 函数开始游戏；如果用户选择了 0，则输出一条消息表示程序已退出；否则输出一条错误消息并提示用户重新输入。
最后，使用 do-while 循环结构，重复执行上述步骤，直到用户选择了退出程序（即 input 的值为 0）。
在循环的结尾，程序将退出并结束运行。

void menu()
{
	printf("**************************************\n");
	printf("**********    1.play    **************\n");
	printf("**********    0.exit    **************\n");
	printf("**************************************\n");
}
1
2
3
4
5
6
7

该函数可以在程序中多次调用，以便在不同的场景下显示相同的菜单。在该函数中，使用了 printf() 函数来输出字符串，并使用了转义字符 \n 来表示换行。使用星号 (*) 来装饰菜单选项，使菜单看起来更加美观。

输入1开始游戏

输入0退出程序

输入其他重新输入

void game()
{
	//布置雷的信息
	char mine[ROWS][COLS] = { 0 };
	//排查雷的信息
	char show[ROWS][COLS] = { 0 };
	//初始化棋盘
	InitBoard(mine, ROWS, COLS,'0');
	InitBoard(show, ROWS, COLS,'*');
	//打印棋盘
	//DisplayBoard(mine, ROW, COL);
	DisplayBoard(show, ROW, COL);
	//布置雷
	SetMine(mine, ROW, COL);
	//DisplayBoard(mine, ROW, COL);
	//排查雷
	FindMine(mine, show, ROW, COL);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

这是一个 C 语言函数，用于实现扫雷游戏的核心逻辑。以下是每一行代码的解释：
该函数实现了扫雷游戏的核心逻辑，其中 mine 数组用于存储雷的位置信息，show 数组用于存储玩家排查雷的信息。通过调用 InitBoard() 函数初始化数组，调用 DisplayBoard() 函数打印初始棋盘，调用 SetMine() 函数布置雷，调用 FindMine() 函数排查雷，实现了扫雷游戏的主要逻辑。

//初始化棋盘
void InitBoard(char board[ROWS][COLS], int rows, int cols,char set)
{
	int i = 0;
	for (i = 0; i < rows; i++)
	{
		int j = 0;
		for (j = 0; j < cols; j++)
		{
			board[i][j] = set;
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13

这是一个 C 语言函数，用于初始化一个二维字符数组（即棋盘）。
定义函数 InitBoard()，该函数接收三个参数：一个二维字符数组 board，表示要初始化的棋盘；一个整数 rows，表示棋盘的行数；一个整数 cols，表示棋盘的列数；一个字符 set，表示要将棋盘中的所有元素初始化为该字符。
定义变量 i，用于循环遍历棋盘的行。使用 for 循环遍历棋盘的每一行，从 0 到 rows-1。
定义变量 j，用于循环遍历棋盘的列。使用 for 循环遍历棋盘的每一列，从 0 到 cols-1。
将棋盘中第 i 行、第 j 列的元素赋值为字符 set。
函数执行完毕，返回。

//打印棋盘
void DisplayBoard(char board[ROWS][COLS], int row, int col)
{
	int i = 0;
	int j = 0;
	printf("----------扫雷---------\n");
	for (j = 0; j <= col; j++)
	{
		printf("%d ", j);
	}
	printf("\n");
	for (i = 1; i <=row; i++)
	{
		printf("%d ", i);
		for (j = 1; j<=col; j++)
		{
			printf("%c ", board[i][j]);
		}
		printf("\n");
	}
	printf("----------扫雷---------\n");
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

该函数使用了两个嵌套的 for 循环来遍历棋盘的每一个元素，并使用 printf() 函数将其打印出来。通过调用该函数，可以方便地打印一个二维字符数组，以展示扫雷游戏的当前状态。其中，第一行和最后一行是棋盘的边框，每行的第一个元素是行号或列号，其他元素是棋盘中的内容。

//布置雷
void SetMine(char mine[ROWS][COLS], int row, int col)
{
	int count = EASY_COUNT;
	while (count)
	{
		//生成随机下标
		int x = rand()% row + 1;
		int y = rand() % col + 1;

		//布置雷
		if (mine[x][y] == '0')
		{
			mine[x][y] = '1';
			count--;
		}
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

这是一个 C 语言函数，用于在一个二维字符数组中随机布置指定数量的地雷。该函数使用了 rand() 函数生成随机数，并在随机位置上布置地雷。通过调用该函数，可以在棋盘中随机布置指定数量的地雷，为扫雷游戏的进行打下基础。

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

这是一个 C 语言函数，用于计算一个二维字符数组中指定位置周围的地雷数量。该函数首先将周围 8 个位置的值相加，然后减去 8 个字符 ‘0’ 的 ASCII 码值，得到实际的地雷数量。通过调用该函数，可以计算出指定位置周围的地雷数量，以便判断该位置是否为地雷和在周围的地雷数量。

//排查雷
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], char row, char col)
{
	
	int x = 0;
	int y = 0;
	int win = 0;
	while (win<(row*col-EASY_COUNT))
	{
		printf("请输入要排查的坐标：>");
		scanf("%d %d", &x, &y);
		if (x >= 1 && x <= row && y >= 1 && y <= col)
		{
			if (show[x][y] != '*')
			{
				printf("该坐标被排查过了\n");
				continue;
			}
			if (mine[x][y] == '1')
			{
				printf("很遗憾，你被炸死了\n");
				DisplayBoard(mine, ROW, COL);
				break;
			}
			else
			{
				int n = get_mine_count(mine, x, y);
				show[x][y] = n + '0';
				DisplayBoard(show, ROW, COL);
				win++;
			}
		}
		else
		{
			printf("坐标非法，重新输入\n");
		}
	}
	if (win == (row * col - EASY_COUNT))
	{
		printf("恭喜你，排雷成功\n");
	}
}
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

这是一个 C 语言函数，用于在一个二维字符数组中排查地雷。该函数首先提示玩家输入要排查的坐标，然后读取玩家的输入，并根据输入的坐标判断该位置是否为地雷。如果该位置是地雷，则游戏失败，展示实际的棋盘；否则，计算该位置周围地雷的数量，并将其存储在展示给玩家的棋盘中。通过调用该函数，可以让玩家逐步排查地雷，直到排查成功或者失败。

完整代码如下：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<time.h>
#include<stdlib.h>
#define ROW 9
#define COL 9
#define ROWS ROW+2
#define COLS COL+2
#define EASY_COUNT 10
//初始化棋盘
void InitBoard(char board[ROWS][COLS], int rows, int cols,char set);
//打印棋盘
void DisplayBoard(char board[ROWS][COLS], int row, int col);
//布置雷
void SetMine(char board[ROWS][COLS], int row, int col);
//排查雷
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], char row, char cool);
//初始化棋盘
void InitBoard(char board[ROWS][COLS], int rows, int cols,char set)
{
	int i = 0;
	for (i = 0; i < rows; i++)
	{
		int j = 0;
		for (j = 0; j < cols; j++)
		{
			board[i][j] = set;
		}
	}
}

//打印棋盘
void DisplayBoard(char board[ROWS][COLS], int row, int col)
{
	int i = 0;
	int j = 0;
	printf("----------扫雷---------\n");
	for (j = 0; j <= col; j++)
	{
		printf("%d ", j);
	}
	printf("\n");
	for (i = 1; i <=row; i++)
	{
		printf("%d ", i);
		for (j = 1; j<=col; j++)
		{
			printf("%c ", board[i][j]);
		}
		printf("\n");
	}
	printf("----------扫雷---------\n");
}

//布置雷
void SetMine(char mine[ROWS][COLS], int row, int col)
{
	int count = EASY_COUNT;
	while (count)
	{
		//生成随机下标
		int x = rand()% row + 1;
		int y = rand() % col + 1;

		//布置雷
		if (mine[x][y] == '0')
		{
			mine[x][y] = '1';
			count--;
		}
	}
}

//周围雷的个数
int get_mine_count(char mine[ROWS][COLS], int x, int y)
{
	return (mine[x - 1][y] + mine[x - 1][y - 1] + mine[x][y - 1] +
		mine[x + 1][y - 1] + mine[x + 1][y] + mine[x + 1][y + 1] +
		mine[x][y + 1] + mine[x - 1][y + 1] - 8 * '0');
}
 
//排查雷
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], char row, char col)
{
	
	int x = 0;
	int y = 0;
	int win = 0;
	while (win<(row*col-EASY_COUNT))
	{
		printf("请输入要排查的坐标：>");
		scanf("%d %d", &x, &y);
		if (x >= 1 && x <= row && y >= 1 && y <= col)
		{
			if (show[x][y] != '*')
			{
				printf("该坐标被排查过了\n");
				continue;
			}
			if (mine[x][y] == '1')
			{
				printf("很遗憾，你被炸死了\n");
				DisplayBoard(mine, ROW, COL);
				break;
			}
			else
			{
				int n = get_mine_count(mine, x, y);
				show[x][y] = n + '0';
				DisplayBoard(show, ROW, COL);
				win++;
			}
		}
		else
		{
			printf("坐标非法，重新输入\n");
		}
	}
	if (win == (row * col - EASY_COUNT))
	{
		printf("恭喜你，排雷成功\n");
	}
}
void menu()
{
	printf("**************************************\n");
	printf("**********    1.play    **************\n");
	printf("**********    2.exit    **************\n");
	printf("**************************************\n");
}
void game()
{
	//布置雷的信息
	char mine[ROWS][COLS] = { 0 };
	//排查雷的信息
	char show[ROWS][COLS] = { 0 };
	//初始化棋盘
	InitBoard(mine, ROWS, COLS,'0');
	InitBoard(show, ROWS, COLS,'*');
	//打印棋盘
	//DisplayBoard(mine, ROW, COL);
	DisplayBoard(show, ROW, COL);
	//布置雷
	SetMine(mine, ROW, COL);
	//DisplayBoard(mine, ROW, COL);
	//排查雷
	FindMine(mine, show, ROW, COL);
}
void test()
{
	srand((unsigned int)time(NULL));
	int input = 0;
	do
	{
		menu();
		printf("请选择:>");
		scanf("%d", &input);//输入1进入游戏，输入0退出游戏，输入其他重新输入
		switch (input)
		{
		case 1:
			game();
			break;
		case 0:
			printf("退出程序\n");
			break;
		default:
			printf("输入错误，请重新输入\n");
			break;
		}
	} while (input);
}
int main()
{
	test();
	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
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