C语言-扫雷

新建工程项目文件，按照项目需求拆分成以下三个文件：

test.c 扫雷游戏的测试
game.c 游戏的函数实现
game.h 游戏的函数声明

首先同C语言-井字棋一样先完善游戏主体菜单逻辑，为了实现游戏可以不断进行下一轮，我们采用do……while循环，与上节思想类似，当input输入为1的时候，while进入下一轮循环（即下一轮游戏）。

首先定义一个简易的菜单函数menu，当输入为1的时候，运行游戏，当输入为其他值时，重新选择并给出错误提示。当输入为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
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

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

int main() {
	int input = 0;
	do {
		menu();
		printf("请选择:>");
		scanf("%d", &input);
		switch (input) {
		case 1:
			printf("扫雷游戏\n");
			break;
		case 0:
			printf("退出游戏\n");
			break;
		default:
			printf("选择错误\n");
			break;
		}
	} while (input);
	return 0;
}

image-20240422205221345

实现逻辑是当input输入不为0时，对于while判断来说都为真，进行下一轮循环，由此实现输入1进行下一轮游戏和输入其他数字重新选择。

经测试逻辑符合所需，主体代码设计完成，接下来设计具体游戏部分。

  1. 布置雷
  2. 排查雷

首先，我们可以通过二维数组存放9*9初级棋盘里雷的数量和位置，达到布置雷的目的。可以假设，在二维数组里，有雷的位置设为1，而没有雷的位置值设为0。

那么第一步布置雷假设完成了，到第二步排查雷的时候我们就会发现，如果这个坐标是1，那么这个是雷？还是排查出3*3周围中其他雷的信息？

所以我们可以再创建一个数组，用于存放排查雷的信息，这样两个数组不会互相干扰。

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
"test.c"
void game() {
	char mine[ROWS][COLS] = { 0 }; // 存放雷的信息
	char show[ROWS][COLS] = { 0 }; // 存放展示给用户的信息
	// 初始化
	InitBoard(mine, ROWS, COLS, '0');
	InitBoard(show, ROWS, COLS, '*');
}

"game.h"
#define ROW 9
#define COL 9

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

void InitBoard(char board[ROWS][COLS], int rows, int cols, char set);

"game.c"
void InitBoard(char board[ROWS][COLS], int rows, int cols, char set) {
	int i = 0;
	int j = 0;
	for (i = 0; i < rows; i++) {
			for (j = 0; j < cols; j++) {
				board[i][j] = set;
			}
		}
}

为什么使用ROWS和COLS作为数组的大小呢？这样在排查雷的时候就不用考虑棋盘边界越界问题。

接下来就是打印棋盘，看一下棋盘是否如我们最初设想的一样，0、1代表是否有雷，*代表棋盘还没有被排查。

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

image-20240423000427440

优化一下棋盘打印：

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

image-20240423183632215

布置雷，通过rand随机数随机设置一个位置布置雷，通过if语句判断是否被占用从布置雷，并使count--,以便10个雷布置完毕跳出循环。

1
2
3
4
5
6
7
8
9
10
11
void SetMine(char board[ROWS][COLS], int row, int col, int count) {
	// 在棋盘上布置雷
	while (count) {
			int x = rand() % row + 1;
			int y = rand() % col + 1;
			if (board[x][y] == '0') {
				board[x][y] = '1';
				count--;
			}
		}
}

image-20240423185212066

打印棋盘可以看到中间9*9的棋盘中随机布置了10个雷。

接下来就是排查雷：

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
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col) {
	// 1.输入排查的坐标
	// 2.判断坐标是不是雷
	//   2.1 如果是雷，游戏结束
	//   2.2 如果不是雷，统计周围雷的个数
	// 3.展示给用户
	int x = 0;
	int y = 0;
	int count = 0;
	while (1) {
		printf("请输入排查的坐标:>");
		scanf("%d %d", &x, &y); // 坐标范围 x: 1-9 y: 1-9
		// 判断坐标合法性
		if (x >= 1 && x <= row && y >= 1 && y <= col) {
			if (mine[x][y] == '1') {
				printf("很遗憾，你被炸死了\n");
				DisplayBoard(mine, ROW, COL);
				break;
			}
			else {
				// 不是雷的情况下，统计周围雷的个数
				count = mine[x - 1][y - 1] +
					mine[x - 1][y] +
					mine[x - 1][y + 1] +
					mine[x][y - 1] +
					mine[x][y + 1] +
					mine[x + 1][y - 1] +
					mine[x + 1][y] +
					mine[x + 1][y + 1] - 8 * '0';
				show[x][y] = count + '0';
				// 显示排查的信息
				DisplayBoard(show, ROW, COL);
			}
		}
		else {
			printf("坐标非法,请重新输入\n");
		}
	}	
}

先定义x，y，count三个局部变量，使用while循环进行排查雷的实现，首先判断输入坐标的合法性，然后再根据输入坐标是否为1判断是否踩雷。

如果再不是雷的情况下，统计坐标所在的周围八个位置有几个雷，实现方法是将周围的数字都加起来（如果是雷，应该是1，不是雷，则是0），但因为都是文本格式，所以加起来的会是ASCII码值，所以要减去8*'0'，最后在坐标的位置显示周围几个雷。

接下来测试一下：

image-20240423191750338

image-20240423191800683

最后优化一下实现游戏结束判断：

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 FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col) {
	// 1.输入排查的坐标
	// 2.判断坐标是不是雷
	//   2.1 如果是雷，游戏结束
	//   2.2 如果不是雷，统计周围雷的个数
	// 3.展示给用户
	int x = 0;
	int y = 0;
	int count = 0;
	int win = 0;
	while (win<row*col-EASY_COUNT) {
		printf("请输入排查的坐标:>");
		scanf("%d %d", &x, &y); // 坐标范围 x: 1-9 y: 1-9
		// 判断坐标合法性
		if (x >= 1 && x <= row && y >= 1 && y <= col) {
			if (mine[x][y] == '1') {
				printf("很遗憾，你被炸死了\n");
				DisplayBoard(mine, ROW, COL);
				break;
			}
			else {
				// 不是雷的情况下，统计周围雷的个数
				count = mine[x - 1][y - 1] +
					mine[x - 1][y] +
					mine[x - 1][y + 1] +
					mine[x][y - 1] +
					mine[x][y + 1] +
					mine[x + 1][y - 1] +
					mine[x + 1][y] +
					mine[x + 1][y + 1] - 8 * '0';
				show[x][y] = count + '0';
				win++;
				// 显示排查的信息
				DisplayBoard(show, ROW, COL);
			}
		}
		else {
			printf("坐标非法,请重新输入\n");
		}

		if (win == row * col - EASY_COUNT)
			printf("恭喜你，排雷成功\n");
			DisplayBoard(mine, ROW, COL);
	}	
}

接下来有很大的优化空间，比如说这个坐标不是雷，周围八个坐标也没有雷的情况下，可以展开一片。再看周围八个坐标的八个坐标，直到有雷的情况下。

或者比如说可以标记雷的位置，也是一个可以优化的点，后续代码有待优化~

完整代码已上传到GitHub.