【用C语言轻松实现】- 扫雷【超详细教程】
一、游戏规则
扫雷就是要将所有非地雷的格子揭开即胜利，踩到地雷格子就算失败。游戏是由很多个方格组成，用鼠标随机点击一个方格，若格子被打开后没有地雷，即方格会被打开并显示出其周围 8 个方格隐藏地雷的个数。所以若想顺利过关就需要利用好这些显示出来的数字提示。
二、文件的创建
- test.c（实现游戏的整体思路，用于测试扫雷游戏的逻辑）
- game.c（游戏的实现）
- game.h（声明 .c 文件的函数，包含所有需要用到的头文件以及 define 定义的常量）
三、初始页面的实现
1、实现主菜单页面
// test.c
（1）menu()
void menu()
{
printf("***********************************\n");
printf("********** 1.paly **********\n");
printf("********** 0.exit **********\n");
printf("***********************************\n");
}效果图如下：
（2）test()：
void test()
{
int input = 0;
srand((unsigned int)time(NULL));
do
{
menu();// 主菜单
printf("请选择：>");
scanf("%d", &input);// 玩家选择
switch (input)// 判断玩家是否进行游戏以及是否输入合法选项
{
case 1:
game();// 游戏
break;
case 0:
printf("退出游戏\n");
break;
default:
printf("选择错误，请重新选择!\n");
break;
}
} while (input);
}注：这里使用 do while() 循环可以保证至少会进行一次选择。如果选择 0，会被判定为假，则跳出循环，退出游戏；如果输入选择则不会退出游戏，可以1保证游戏能够重复游玩。
srand((unsigned int)time(NULL)) 利用时间戳，形成随机数，主要目的是实现游戏中地雷的随机埋放。
（3）main()：
int main()
{
test();
return 0;
}2、在 game.h 中引用所需要的文件和必要的定义
// game.h
#pragma once
// 9*9
#define ROW 9// 行
#define COL 9// 列
// 11*11
#define ROWS ROW+2
#define COLS COL+2
#define EASY_COUNT 10// 地雷的数量
#include
#include
#include 四、棋盘函数的声明、创建和实现（打印棋盘函数同理）
1、声明棋盘的函数（附加打印棋盘函数）
// game.h
//初始化排雷界面
void InitBoard(char board[ROWS][COLS], int rows, int cols, char set);
//打印棋盘
void DisplayBoard(char board[ROWS][COLS], int row, int col);2、棋盘函数的创建 （附加打印功能）
// test.c
void game()
{
// 扫雷游戏的实现
char mine[ROWS][COLS] = { 0 };// 布置地雷的信息 // '0'
char show[ROWS][COLS] = { 0 };// 排查地雷的信息 // '*'
// 初始化棋盘
InitBoard(mine, ROWS, COLS, '0');
InitBoard(show, ROWS, COLS, '*');
// 打印棋盘
DisplayBoard(mine, ROW, COL);
DisplayBoard(show, ROW, COL);
}char mine[ROWS][COLS] '1' -- 雷 '0' -- 非雷
char show[ROWS][COLS] '*‘ -- 未排查 数组字符 -- 已排查
注：初始化两个棋盘，一个为 mine，一个为 show，其中在 mine 数组中我们定义有雷为 '1'，没有雷为 '0'。由扫雷规则可知：当我们输入一个坐标时，会在该坐标上出现一个数字，表示在该坐标周围 8 个格子有多少个地雷，但是当四周只有一个雷的时候所出现的 ‘1’ 不是会与有雷的 '1' 混淆吗？所以我们创建了另外一个数组 show，show 数组中不表示雷，只打印数值，这样就解决了 '1' 的混淆问题。为什么要用 '1' 来代替地雷呢？后面会有介绍到。
首先对埋雷的数组进行初始化为字符 '0'（非雷用字符 '0' 表示，地雷用字符 '1' 表示），对显示棋盘的数组全部用 '*'，将埋雷的数组覆盖起来，因此在 game() 函数里对 InitBorad() 函数调用两次。
1、为什么要创建两个相同的数组呢？
答：因为我们在玩游戏时首先在屏幕上看到的是一个初始化的棋盘，并不清楚哪里埋放着地雷。如果我们触碰到地雷结束游戏，需要给玩家呈现这局游戏所有地雷位置的情况，这样以便于玩家清楚所有雷都在哪个位置，因此我们在屏幕上显示的是 9*9 的数组，但是创建的时候是 11*11 的数组，所以需要两个棋盘才能完成这项任务。其中一个隐藏在暗处用来存放这些地雷、数字的信息，玩家是看不见的；另一个则是专门向玩家展示的棋盘。
2、显示 9*9 大小的棋盘，为什么要创建 11*11 大小的棋盘？
答：这是因为在排雷的过程中，会显示其周围 8 个格子地雷的个数。如果创建一个 9*9 的棋盘，那当我们选择边角方格的时候，我们周围的格子不足 8 个，但是我们还要访问周围 8 个格子，这时候必然会造成数组越界的问题。如果创建 11*11 的棋盘，对 11*11 的棋盘都初始化为字符 '0'， 我们只显示内部的 9*9 的格子，这样就解决了数组越界的问题，游戏正常运行。
3、棋盘函数的实现（附加打印棋盘函数的实现）
// 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;
}
}
}
void DisplayBoard(char board[ROWS][COLS], int row, int col)
{
int i = 0;
int j = 0;
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]);// 要用%c打印 否则打印结果会出现问题
}
printf("\n");
}
}注：因为游戏要重复进行，所以每次都要先对数组进行初始化，防止因上次游戏的干扰。
我们对第一块 mine 棋盘全部初始化为字符 '0' ，对第二块 show 棋盘全部初始化为字符 '*' ，最终玩家会先看到一个全是字符 '*' 的棋盘，这样也符合游戏规则。
打印效果如下：（只需要将show棋盘展示给游戏用户）
（1）布置棋盘（mine）：
（2）展示棋盘（show）：
五、布置地雷
// game.h
// 布置地雷
void SetMine(char board[ROWS][COLS], int row, int col);// game.c
void SetMine(char board[ROWS][COLS], int row, int col)
{
int count = EASY_COUNT;// 在 9*9 棋盘里随机布置10个雷
while (count)
{
int x = rand() % row + 1;// 1~9
int y = rand() % col + 1;// 1~9
if (board[x][y] == '0')// 如果没有雷就布置雷
{
board[x][y] = '1';
count--;// 布置完一个雷，雷数-1
}
}
}如何实现随机布雷？
答：创建 rand 函数，利用时间戳生成随机数。因为我们创建的棋盘大小是 9*9 大小的，所以只需要给生成的随机数模上 row/col ，即可得到 0~row-1，因此我们再 +1，即可得到一个在 0~row(col) 的随机数，从而实现随机布雷的效果。一共设定 count 个雷，如果我们埋下一颗雷，就 count -1，同时将初始化的字符 '0' 变成字符 '1'，只有我们识别到目标方格是字符 '0' 时才会埋雷，这也解决了在同一位置重复埋雷的问题。在使用 while() 循环，直到减到 count 为 0 时，while 不再循环，count 颗雷正好布置完成。
六、排查地雷
// game.h
// 排查地雷
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col);注：为什么 FindMine 传的参数是 ROW COL 而不是 ROWS COLS ？原因：首先要明白，要打印 9*9 的棋盘，如果定义棋盘大小只有 9*9，那么当我们检查边界坐标的周围时就会出现越界访问的问题。所以排雷时就只需要将 ROW COL 传过去就好了。
//game.c
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], int row, int col)
{
int x = 0;
int y = 0;
int win = 0; //9*9-10=71 //判断雷是否都被排查干净
while (win < row * col - EASY_COUNT)
{
printf("请输入排查雷的坐标：>");
scanf("%d%d", &x, &y);
if (x >= 1 && x <= row && y >= 1 && y <= col)
{
//坐标合法
if (mine[x][y] == '1')
{
printf("很遗憾，你被炸死了\n");//踩雷
DisplayBoard(mine, row, col);
break;
}
else//不是雷
{
//计算x，y坐标周围有几个雷
int count = get_mine_count(mine, x, y);
show[x][y] = count + '0';
//必须加上'0'（实际上是 count 返回的整型值加上0的ASCII值后，再转化为字符）
DisplayBoard(show, row, col);
win++;
}
}
else
{
printf("输入坐标非法，请重新输入！\n");
}
}
if (win == row * col - EASY_COUNT)
{
printf("恭喜你，排雷成功\n");
DisplayBoard(mine, row, col);
}
}注：将周围 8 个格子的字符全部加起来，如果是字符 '0' 和字符 '1' 所对应的 ASCII 码值相差1，我们可以通过 ASCII 码值来进行判断。将周围 8 个字符相加，然后再减去8个字符 '0' 的和，就可以得到周围 8 个格子中有多少个字符 '1' 的格子，也就是雷的个数。
当我们输入正确的坐标时，我们需要对这个坐标下所对应的字符进行判断，如果是字符 '1' ，说明踩中地雷，游戏结束，这时再将完整的棋盘打印出来，玩家也可以了解本局游戏的情况。如果是字符 '0'，说明玩家没有踩中地雷，根据游戏规则，我们需要显示这个格子周围 8个格子中存在地雷的个数，所以调用了get_mine_count函数。
七、代码整合
1、// test.c
#include "game.h"
void menu()
{
printf("***********************************\n");
printf("********** 1.paly **********\n");
printf("********** 0.exit **********\n");
printf("***********************************\n");
}
void game()
{
//布置雷的信息
char mine[ROWS][COLS] = { 0 };// '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);
//排查地雷
FindMine(mine, show, ROW, COL);
}
void test()
{
int input = 0;
srand((unsigned int)time(NULL));
do
{
menu();// 主菜单
printf("请选择：> ");
scanf("%d", &input);// 玩家选择
switch (input)// 判断玩家是否进行游戏以及是否输入合法选项
{
case 1:
game();// 游戏
break;
case 0:
printf("退出游戏\n");
break;
default:
printf("选择错误，请重新选择!\n");
break;
}
} while (input);
}
int main()
{
test();
return 0;
}2、// game.c
#include "game.h"
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;
}
}
}
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]);// 要用%c打印 否则打印结果会出现问题
}
printf("\n");
}
printf("--------扫雷--------\n");
}
void DisplayBoard(char board[ROWS][COLS], int row, int col)
{
printf(" ");// 考虑到y轴占3格
for (int j = 1; j <= col; j++)// 打印x轴坐标
{
printf(" %d ", j);
}
printf("\n");
printf(" |");
for (int j = 0; j < col; j++)// 打印棋盘封顶
{
printf("---|");
}
printf("\n");
for (int i = 1; i <= row; i++)
{
for (int j = 0; j <= col; j++)
{
if (j == 0)
{
printf("%2d|", i);// 顺带打印y轴坐标
}
else
printf(" %c |", board[i][j]);// 打印数据
}
printf("\n");
for (int j = 1; j <= col+1; j++)// 注意这里col应该+1
{
if (j == 1)
printf(" |");
else
printf("---|");
}
printf("\n");
}
}
void SetMine(char board[ROWS][COLS], int row, int col)
{
int count = EASY_COUNT;// 在 9*9 棋盘里随机布置10个雷
while (count)
{
int x = rand() % row + 1;// 1~9
int y = rand() % col + 1;// 1~9
if (board[x][y] == '0')// 如果没有雷就布置雷
{
board[x][y] = '1';
count--;// 布置完一个雷，雷数-1
}
}
}
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 explode_spread(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col, int x, int y)
//{
// // 限制非法坐标的展开
// if (x >= 1 && x <= row && y >= 1 && y <= col)
// {
// // 计算该位置附近四周地雷的个数
// int count = get_mine_count(mine, x, y);
// // 若四周没有一个地雷，则需要向该位置的四周展开，直到展开到某个位置附近存在地雷为止
// if (count == 0)
// {
// // 把附近没有地雷的位置变成字符' '
// show[x][y] = '0';
// int i = 0;
// // 向四周共8个位置递归调用
// for (i = x - 1; i <= x + 1; i++)
// {
// int j = 0;
// for (j = y - 1; j <= y + 1; j++)
// {
// // 限制对点位置的重复展开调用，使得每一个位置只能向四周展开一次
// if (show[i][j] == '*')
// {
// explode_spread(mine, show, row, col, i, j);
// }
// }
// }
// }
// // 若四周存在地雷则应该在这个位置上标注上地雷的个数
// else
// {
// show[x][y] = count + '0';
// }
// }
//}
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{
int x = 0;
int y = 0;
int win = 0; //9*9-10=71 //判断雷是否都被排查干净
while (win < row * col - EASY_COUNT)
{
printf("请输入排查雷的坐标：>");
scanf("%d%d", &x, &y);
if (x >= 1 && x <= row && y >= 1 && y <= col)
{
//坐标合法
if (mine[x][y] == '1')
{
printf("很遗憾，你被炸死了\n");//踩雷
DisplayBoard(mine, row, col);
break;
}
else//不是雷
{
//explode_spread(mine, show, row, col, x, y);
//计算x，y坐标周围有几个雷
int count = get_mine_count(mine, x, y);
show[x][y] = count + '0';
//必须加上'0'（实际上是 count 返回的整型值加上0的ASCII值后，再转化为字符）
DisplayBoard(show, row, col);
win++;
}
}
else
{
printf("输入坐标非法，请重新输入！\n");
}
}
if (win == row * col - EASY_COUNT)
{
printf("恭喜你，排雷成功\n");
DisplayBoard(mine, row, col);
}
}3、//game.h
#pragma once
// 9*9
#define ROW 9// 行
#define COL 9// 列
// 11*11
#define ROWS ROW+2
#define COLS COL+2
#define EASY_COUNT 10// 地雷的数量
#include
#include
#include
// 初始化排雷界面
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], int row, int col); 八、程序展示
运行效果图：
九、改进建议
1、棋盘优化
void DisplayBoard(char board[ROWS][COLS], int row, int col)
{
printf(" ");// 考虑到y轴占3格
for (int j = 1; j <= col; j++)// 打印x轴坐标
{
printf(" %d ", j);
}
printf("\n");
printf(" |");
for (int j = 0; j < col; j++)// 打印棋盘封顶
{
printf("---|");
}
printf("\n");
for (int i = 1; i <= row; i++)
{
for (int j = 0; j <= col; j++)
{
if (j == 0)
{
printf("%2d|", i);// 顺带打印y轴坐标
}
else
printf(" %c |", board[i][j]);// 打印数据
}
printf("\n");
for (int j = 1; j <= col+1; j++)// 注意这里col应该+1
{
if (j == 1)
printf(" |");
else
printf("---|");
}
printf("\n");
}
}运行效果图如下：（增加了棋盘边界线）
2、炸金花式展开函数
这是一个递归函数，该函数实现的功能为：如果排查的位置周围没有雷，则向四周爆炸式展开，直至遇到周围有地雷的坐标时才停下来。那该怎么实现该递归函数呢？当排查的位置没有雷且该位置周围没有雷时，就展开其周围一圈的 8 个坐标，然后看这 8 个坐标是否可以再逐个向其自身周围接着展开，这样一次就递归调用函数自身 8 次的展开速度就像爆炸了一样，所以称其为：炸金花式展开（深度优先遍历）。
注：会发现不管先展开哪一个位置都将陷入死递归当中。当要展开 (x,y) 坐标周围的一圈坐标时，假如其首先会从 (x-1,y+1) 位置开始，然后又由该坐标向其自身周围的一圈展开时，你会发现坐标 (x,y) 也在需要展开的范围内。这样不就会重复要求再次展开坐标(x,y)，然后再由 (x,y) 要求展开(x-1,y+1)，两个坐标相互疯狂调用。若每次判断一个坐标上没有雷且该坐标周围一圈同样没有雷时，则将向我们展示的棋盘上表示未知的字符 '*' 改成 ' '。然后在之后每次递归调用前给一个判断：如果这个将要被递归调用的坐标在展示的棋盘上存放的是字符 '*' 时才能进行下一步，否则将直接跳过此次递归。
如若发生向外扩张的递归，那拓展出来最外围的一圈坐标完全无法起到限制的作用，无法阻止炸金花式的向外展开。因此只能在每次进入递归函数后加一条限制。
//炸金花式展开函数
void explode_spread(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col, int x, int y)
{
// 限制非法坐标的展开
if (x >= 1 && x <= row && y >= 1 && y <= col)
{
// 计算该位置附近四周地雷的个数
int count = get_mine_count(mine, x, y);
// 若四周没有一个地雷，则需要向该位置的四周展开，直到展开到某个位置附近存在地雷为止
if (count == 0)
{
// 把附近没有地雷的位置变成字符' '
show[x][y] = ' ';
int i = 0;
// 向四周共8个位置递归调用
for (i = x - 1; i <= x + 1; i++)
{
int j = 0;
for (j = y - 1; j <= y + 1; j++)
{
// 限制对点位置的重复展开调用，使得每一个位置只能向四周展开一次
if (show[i][j] == '*')
{
explode_spread(mine, show, row, col, i, j);
}
}
}
}
// 若四周存在地雷则应该在这个位置上标注上地雷的个数
else
{
show[x][y] = count + '0';
}
}
}