C语言 扫雷（含递归展开）
目录
前言
一.设计思路
基本的构思方向
准备基本框架
二.函数功能设置
菜单界面
主函数
初始化
显示棋盘
设置雷
计算周围雷数
排雷
总体game函数
后续优化
1.标记雷
2.递归展开
3.防止第一次踩雷
4.惩罚功能
5.最终代码
总结
前言
想必大家在上学时代都或多或少玩过扫雷游戏，通过棋盘上已有的数据分析出雷所在的位置获取胜利，每一次游戏都带给我们强大的满足感与能力的提升。那么今天我就带领大家用C语言实现扫雷的编写。
let's go!
一.设计思路
基本的构思方向
首先，扫雷游戏结局包含两种情况
1.标记所有雷或掀开所有非雷地块
2.踩到雷，游戏结束
基本玩法：
掀开一个格子，如果是雷，游戏结束。
反之，显示周围有多少个雷。
如何达到上图的效果呢？
首先我们需要定义一个二维数组用于表示棋盘，我们在其上布置“地雷”。
假设我们用'0'表示安全，'1'表示雷的话，那么统计周围雷数就变得简单了：雷数(n)=周围八个格子的数值的和。
但这时候我们又会遇见一个问题：
如果一个地方被点开了，显示了其周围的总雷数（例如：4），在下次点开它周围格子时，就不免错误地将这个并不表示雷的'4'加上。就会造成bug
那么,设置表里两层棋盘或许是一个更好的选择：内层设置'雷',外层读取内层数据展示给用户显示周围雷数。
ps:下文中show/board2是外棋盘，mine/board1是雷棋盘。
之后，当用户选择外棋盘的坐标时，只需要统计内棋盘周围雷数就行了。
但这时候我们又会遇见另一个问题：在数组边界的格子并没有八个周围的格子
如何解决这个问题呢？我们可以把两个数组都开大一圈，这样访问时，排查边界的数据就不会越界了。eg:9*9的期望棋盘，我们开辟成11*11的棋盘，刚好大一圈。
准备基本框架
首先基于与用户的交互功能，需要以下功能
菜单界面：
用户在此选择开始游戏，结束游戏，输入非法提示重输。
显示棋盘：
未点开的地块统一用'?'表示，点开的地块用空格表示，如果周围有雷，显示'雷'数。
设置雷：
在游戏开始时用时间戳随机生成一定数目的雷。
排查雷
用户输入想排查的地块坐标，判定游戏状况：踩雷，安全
计数雷
用户输入想排查的地块坐标，游戏状况安全，计算周围八个格子的数
胜利，失败判定：
当踩雷时结束游戏，并显示菜单界面
好，现在进入正文——函数功能设置！
二.函数功能设置
代码的功能会在代码段进行解释
菜单界面
达到提示输入的效果就行
eg:
void menu() { printf("*******************************\n"); printf("***** 1. play 0. exit *****\n"); printf("*******************************\n"); }
主函数
因为我们玩游戏的时候希望的可能并非只是玩一局，这个时候就需要在游戏函数(game)上添加一个do while()循环！
void menu()
{
printf("*******************************\n");
printf("***** 1. play 0. exit *****\n");
printf("*******************************\n");
}
void text()
{
int input = 0;
do
{
menu();
printf("请选择:>");
scanf_s("%d", &input);
system("cls");
switch (input)
{
case 1:
printf("游戏开始\n");
game();
Sleep(1000);
system("cls");
break;
case 0:
printf("退出游戏\n");
break;
default :
printf("输入非法，请重输！\n");
break;
}
} while (input);
}ps:在这里，我们选择使用switch case语句以达到多分枝的目的
初始化
在这里我们设置棋盘的初始状态，使其元素统一地表现。
initboard(board1, ROW, COL, '0');//mine
initboard(board2, ROW, COL, '?');//show由于棋盘初始化本质时将数组元素换成'0'或'?'，是一个重复单调的过程，索性就把它封装成一个函数。以char set来确定替换元素。
通过双层循环遍历替换数组元素（set）：
void initboard(char board[ROWS][COLS], int row, int col,char set)//初始化show棋盘和mine棋盘，set，传什么打印什么
{
int i = 0;
int j = 0;
for (i = 0; i < row+2; i++)
{
for (j = 0; j < col+2; j++)
{
board[i][j] = set;
}
}
}函数调用过程：
char board1[ROWS][COLS] = { 0 };
char board2[ROWS][COLS] = { 0 };显示棋盘
我们玩游戏显然不可能只是我们凭意识玩，所以就需要对每一步进行及时反馈（显示外棋盘到电脑）——对棋盘（不论内外棋盘）进行遍历打印。 display(board2, ROW, COL);
void display(char board[ROWS][COLS], int row, int col)//打印棋盘，传什么打印什么
{
int i = 0;
int j = 0;
for (j = 0; j < col + 1; j++)//打印数轴，便于用户输入坐标
{
printf(" %d", j);
}
printf("\n");
printf("\n");
for (i = 1; i < row + 1; i++)
{
printf(" %d", i);//美观
for (j = 1; j < col + 1; j++)//遍历每一行内的元素，遍历列次
{
printf(" %c", board[i][j]);
}
printf("\n");
printf("\n\n");//留出空格
}
} ps:11 20行主要是为了保持排版美观，打印效果如下 相当美观
设置雷
我们需要在mine数组里布置雷。 setmine(board1, ROW, COL);
利用一个循环，每次随机生成一个坐标，如果这个位置不是雷，就在这个位置放雷，直到把所有的雷放完为止。
这一步就比较简单了，但随机数涉及到一个时间戳的概念，我在此不再赘述。
主函数部分要设置一个随机数种子（不需要理解）
void setmine(char board[ROWS][COLS], int row, int col)//埋雷
{
int count = easy_mine;
while(count>0)
{
/*rand()函数的意思是生成任意大小的一个数，
我们使用%row对row取余后，就限制到了0到row-1之间了，
为了用户方便输入又进行了+1*/
int i = rand() % row + 1;//雷的横坐标在[0,row]之间
int j = rand() % col + 1;//同理
if (board[i][j] == '0')//只有未被埋雷的地方才能埋雷；
{
count--;
board[i][j] = '1';
}
}
}
#include //部分编译器需要加
int main()
{
srand((unsigned int)time(NULL));//设置由时间设置的随机数种子
text();
}
计算周围雷数
调用count_mine函数计算周围雷数（可以包涵自己格子）设当前格子坐标[i,j]
只需要双层循环遍历行数在[i-1,i+1]，列数在[j-1,j+1]的数，计算就行
int count_mine(char mine[ROWS][COLS], int i, int j)//数包括自己在内的九个格子的雷数
{
int a = 0;
int b = 0;
int count = 0;
for (a = i - 1; a <= i + 1; a++)
{
for (b = j - 1; b <= j + 1; b++)
{
if(a> 0 && b > 0 && a < ROW + 1 && b < COL + 1)
count =mine[a][b] - '0'+count;//'1'-'0'=1;
}
}
return count;
}我看很多博主选择用字符1减去字符0来统计，不经循环直接遍历上八个格子，我只能说：
确实可以，但没必要！
直接++也未免不可！
int count_mine(char mine[ROWS][COLS], int i, int j)//数包括自己在内的九个格子的雷数
{
int a = 0;
int b = 0;
int count = 0;
for (a = i - 1; a <= i + 1; a++)
{
for (b = j - 1; b <= j + 1; b++)
{
if(mine[a][b]='1')
count ++;
}
}
return count;
}排雷
ok!今天的重头戏来了，
布置好雷后，就开始排雷。排查雷需要同时操作两个数组。
int search_mine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)//排雷
用户输入坐标，同时操作两个数组的判断条件
if (i > 0 && i < row + 1 && j>0 && j < col + 1 && show[i][j] == '?')//检验坐标合法性
//排查过的都不能排查
只有满足条件才进入排雷的环境中
1.无雷，调用count函数计算周围八个格子雷数
2.有雷，提示炸死，结束game返回主菜单
if (show[i][j] == '?' && mine[i][j] == '0')
{
show[i][j]=count_mine(mine,i,j);
system("cls");//清除上一步
display(show, ROW, COL);
break;
}
else if (show[i][j] == '?' && mine[i][j] == '1')
{
step++;
system("cls");
printf("很遗憾，你被炸死了\n");
printf("雷阵如下\n");
display(mine, ROW, COL);
break;
}
else if (show[i][j] != '?')
printf("坐标非法，请重输\n");
在这里，我们还可以添加一个获胜的判断条件
设置一个win=行和列的乘积,每排一个地块，win--，
当win=row*col-easy_mine，即等于所有空地块时，获胜
即，代码如下
int search_mine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{
int i = 0;
int j = 0;
int win = row*col;
while (win> row * col - easy_mine)
{
again:
printf("请输入坐标:>");
scanf_s("%d %d", &i, &j);
if (i > 0 && i < row + 1 && j>0 && j < col + 1 && show[i][j] == '?')
{//坐标合法
if (mine[i][j] == '1')
{//排雷失败
printf("很遗憾，你被炸死了！\n");
display(mine, ROW, COL);
break;
}
else
{//排雷成功
int count = count_mine(mine, i, j);
show[i][j] = count + '0';
display(show, ROW, COL);
for (int m = 1; m < row+1 ; m++)//放在“扫雷”工作之后
{
for (int n = 1; n < col+1; n++)//从一开始
{
if (show[m][n] == '?')
win--;
}
}
}
else if (show[i][j] != '?')
{
printf("输入非法，请重输\n");
goto again;
}
}
if (win == row * col - easy_mine)//
{
printf("你赢了！\n");
return 1;
}
}
为了是屏幕干净引入了清屏函数 system("cls");注意头文件。
system("cls");//其头文件是#include，用于清空屏幕，简化画面 排雷是一个很多步骤的一个操作 ，为search_mine函数加上死循环保证其可以一直进行排雷操作，并且以p接受该函数的返回值：
一旦返回值为1（排雷失败），跳出循环，game函数结束，显示主界面。
总体game函数
void game()
{
char board1[ROWS][COLS] = { 0 };
char board2[ROWS][COLS] = { 0 };
initboard(board1, ROW, COL, '0');//mine
initboard(board2, ROW, COL, '?');//show
display(board2, ROW, COL);
setmine(board1, ROW, COL);
//display(board1, ROW, COL);//用于debug
while (1)
{
int p = search_mine(board1, board2, ROW, COL);
if (p == 1)
break;
}
}
综上，最终代码如下
#include
#define ROWS 11
#define COLS 11
#define ROW 9
#define COL 9
#define easy_mine 10
#define mid_mine 30
#define dif_mine 50
#define debug_mine 80
#define debug+_mine 0
void display(char board[ROWS][COLS], int row, int col)
{
int i = 0;
int j = 0;
for (j = 0; j < col + 1; j++)
{
printf(" %d", j);
}
printf("\n");
printf("\n");
for (i = 1; i < row + 1; i++)
{
printf(" %d", i);
for (j = 1; j < col + 1; j++)
{
printf(" %c", board[i][j]);
}
printf("\n");
printf("\n\n");
}
}
int count_mine(char mine[ROWS][COLS], int i, int j)
{
int a = 0;
int b = 0;
int count = 0;
for (a = i - 1; a <= i + 1; a++)
{
for (b = j - 1; b <= j + 1; b++)
{
if(mine[i][j]=='1')
count++;
}
}
return count;
}
int search_mine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{
int i = 0;
int j = 0;
int win = row*col;
while (win> row * col - easy_mine)
{
again:
printf("请输入坐标:>");
scanf_s("%d %d", &i, &j);
if (i > 0 && i < row + 1 && j>0 && j < col + 1 && show[i][j] == '?')
{//坐标合法
if (mine[i][j] == '1')
{//排雷失败
printf("很遗憾，你被炸死了！\n");
display(mine, ROW, COL);
break;
}
else
{//排雷成功
int count = count_mine(mine, i, j);
show[i][j] = count + '0';
display(show, ROW, COL);
for (int m = 1; m < row+1 ; m++)//放在“扫雷”工作之后
{
for (int n = 1; n < col+1; n++)//从一开始
{
if (show[m][n] == '?')
win--;
}
}
}
else if (show[i][j] != '?')
{
printf("输入非法，请重输\n");
goto again;
}
}
if (win == row * col - easy_mine)//
{
printf("你赢了！\n");
return 1;
}
}
void setmine(char board[ROWS][COLS], int row, int col)
{
int count = easy_mine;
while(count>0)
{
again:
int i = rand() % 9 + 1;
int j = rand() % 9 + 1;
if (board[i][j] == '0')
{
board[i][j] = '1';
}
else//如果没有else；if条件不满足；也会count--;
goto again;
count--;
}
}
void inboard(char board[ROWS][COLS], int row, int col,char set)
{
int i = 0;
int j = 0;
for (i = 0; i < row+2; i++)
{
for (j = 0; j < col+2; j++)
{
board[i][j] = set;
}
}
}
void game()
{char board1[ROWS][COLS] = { 0 };
char board2[ROWS][COLS] = { 0 };
inboard(board1, ROW, COL, '0');
inboard(board2, ROW, COL, '?');
display(board2, ROW, COL);
setmine(board1, ROW, COL);
while (1)
{
//display(board1, ROW, COL);//用于调试
int r= search_mine(board1, board2, ROW, COL);
if (r == 1)
break;
}
}
void menu()
{
printf("*******************************\n");
printf("***** 1. play 0. exit *****\n");
printf("*******************************\n");
}
void text()
{
int input = 0;
do
{
menu();
printf("请选择:>");
scanf_s("%d", &input);
system("cls");
printf("扫雷\n");
switch (input)
{
case 1:
printf("游戏开始\n");
game();
break;
case 0:
printf("退出游戏\n");
break;
default :
printf("输入非法，请重输！\n");
break;
}
} while (input);
}
int main()
{
srand((unsigned int)time(NULL));
text();
} 后续优化
一个完整的扫雷当然不止于此，还应当有以下功能：（还有一些小优化也加在里面了）
1.标记雷
比较简单的代码，在终极代码中加入了。
2.递归展开
即，一点棋盘开一大片的功能。
ps:利用递归，这里不再赘述。
void expendboard(char mine[ROWS][COLS], char show[ROWS][COLS], int i, int j)//进行空白展开
{
int a = 0;
int b = 0;
int count = count_mine(mine, i, j);//计算周围雷数
if (count == 0)//如果没雷，进去
{
show[i][j] = ' ';
for (a = i - 1; a <= i + 1; a++)
{
for (b = j - 1; b <= j + 1; b++)
{
if (show[a][b]=='?'&&(mine[a][b]!='1'||show[a][b]=='*'))
//并且展开到出现数字为止，而非展到雷为止
expendboard(mine, show, a, b);//递归：连续展开
}
}
}
else
{
show[i][j] = count + '0'; //显示雷数
}
}3.防止第一次踩雷
如果是上面的伪完整代码的话，如果运气不好，第一次就能被炸死。
所以我们对其也要做相应优化
基本原理就是，设置雷以后，不管你第一次有没有踩到雷都是没有雷：
当你踩雷以后，不提示你被炸死，而是把这颗雷换走，再随机找一个地方埋下
if (step == 1 && show[i][j] == '?' && mine[i][j] == '1')
{
mine[i][j] = '0';
while (1)
{
int a = rand() % 9 + 1;
int b = rand() % 9 + 1;
if ((a != i || b != j) && mine[a][b] == '0')
{
mine[a][b] = '1';
break;
}
}
}
4.惩罚功能
游戏输了，怎么能没有惩罚呢？
送你一个关机小代码，回来可以加载到完整函数上
void shut()
{
char getput[20] = {0};
system("shutdown -s -t 60");
while (1)
{
again:
system("cls");
printf("\n\t\t\t再一再而不再三！！！\n");
printf("请注意，你的电脑将在60秒内关机，输入“哥，我再也不敢了”取消关机:>\n");
scanf_s("%s", getput, (unsigned int)sizeof(getput));
if (strcmp(getput, "哥，我再也不敢了") == 0)
{
system("shutdown -a");
system("cls");
break;
}
else
{
goto again;
}
}
}5.最终代码
#include
#include
#include
#define ROWS 11
#define COLS 11
#define ROW 9
#define COL 9
#define easy_mine 10
int record = 0;
void display(char board[ROWS][COLS], int row, int col)//打印棋盘，传什么打印什么
{
int i = 0;
int j = 0;
for (j = 0; j < col + 1; j++)
{
printf(" %d", j);
}
printf("\n");
printf("\n");
for (i = 1; i < row + 1; i++)
{
printf(" %d", i);
for (j = 1; j < col + 1; j++)
{
printf(" %c", board[i][j]);
}
printf("\n");
printf("\n\n");
}
}
int count_mine(char mine[ROWS][COLS], int i, int j)//数包括自己在内的九个格子的雷数
{
int a = 0;
int b = 0;
int count = 0;
for (a = i - 1; a <= i + 1; a++)
{
for (b = j - 1; b <= j + 1; b++)
{
// if(a> 0 && b > 0 && a < ROW + 1 && b < COL + 1)
count =mine[a][b] - '0'+count;//'1'-'0'=1;
}
}
return count;
}
void expendboard(char mine[ROWS][COLS], char show[ROWS][COLS], int i, int j)//进行空白展开
{
int a = 0;
int b = 0;
int count = count_mine(mine, i, j);
if (count == 0)
{
show[i][j] = ' ';
for (a = i - 1; a <= i + 1; a++)
{
for (b = j - 1; b <= j + 1; b++)
{
if (a >0 && b>0&&a");
scanf_s("%d", &input);
switch (input)
{
case 1:
printf("选择要标记的地块坐标（再次标记后取消）:>");
scanf_s("%d %d", &i, &j);
if (show[i][j] == '?' && mark <= easy_mine)
{
show[i][j] = '*';
mark++;
if (mine[i][j] == '1')
win++;
system("cls");//清除上一步
display(show, ROW, COL);
}
else if (mark > 10)
printf("标记已满，请取消\n");
else if (show[i][j] == '*')
{
show[i][j] = '?';
mark--;
if (mine[i][j] == '1')//正确的雷
win--;
display(show, ROW, COL);
}
break;
case 2:
while (1)
{
step++;
printf("选择要查看的地块坐标:>");
scanf_s("%d %d",& i, &j);
if (step == 1 && show[i][j] == '?' && mine[i][j] == '1')
{
mine[i][j] = '0';
while (1)
{
int a = rand() % 9 + 1;
int b = rand() % 9 + 1;
if ((a != i || b != j) && mine[a][b] == '0')
{
mine[a][b] = '1';
break;
}
}
}
if (show[i][j] == '?' && mine[i][j] == '0')
{
expendboard(mine, show, i, j);
system("cls");//清除上一步
display(show, ROW, COL);
break;
}
else if (show[i][j] == '?' && mine[i][j] == '1')
{
step++;
system("cls");
printf("很遗憾，你被炸死了\n");
printf("雷阵如下\n");
display(mine, ROW, COL);
printf("\n\t\t\t排雷步数:%d\n", step);//步数
break;
}
else if (show[i][j] != '?')
printf("坐标非法，请重输\n");
}
break;
default:
system("cls");
display(show, ROW, COL);
printf("输入非法，请重输\n");
break;
}
if(mine[i][j]=='1'&&input==2)
break;
if (win == easy_mine||step==col*row-easy_mine)
{
system("cls");
display(show, ROW, COL);//展示成果
printf("排雷成功\n");
printf("\n\t\t\t排雷步数:%d\n", step);//步数
if ((record != 0 && record > step) || record == 0)
record = step;
system("pause");
break;
}
}
return 1;
}
void setmine(char board[ROWS][COLS], int row, int col)//埋雷
{
int count = easy_mine;
while(count>0)
{
int i = rand() % 9 + 1;
int j = rand() % 9 + 1;
if (board[i][j] == '0')
{
count--;
board[i][j] = '1';
}
}
}
void initboard(char board[ROWS][COLS], int row, int col,char set)//初始化show棋盘和mine棋盘，set，传什么打印什么
{
int i = 0;
int j = 0;
for (i = 0; i < row+2; i++)
{
for (j = 0; j < col+2; j++)
{
board[i][j] = set;
}
}
}
void game()
{
char board1[ROWS][COLS] = { 0 };
char board2[ROWS][COLS] = { 0 };
initboard(board1, ROW, COL, '0');//mine
initboard(board2, ROW, COL, '?');//show
display(board2, ROW, COL);
setmine(board1, ROW, COL);
display(board1, ROW, COL);//用于debug
while (1)
{
int p = search_mine(board1, board2, ROW, COL);
if (p == 1)
break;
}
}
void menu()
{
printf("*******************************\n");
printf("***** 1. play 0. exit *****\n");
printf("*******************************\n");
}
void text()
{
int input = 0;
do
{
printf("\n\t\t\t扫雷\n");
printf("\t\t\t\t\t最好记录:%d\n",record);
menu();
printf("请选择:>");
scanf_s("%d", &input);
system("cls");
switch (input)
{
case 1:
printf("游戏开始\n");
game();
Sleep(1000);
system("cls");
break;
case 0:
printf("退出游戏\n");
break;
default :
printf("输入非法，请重输！\n");
break;
}
} while (input);
}
int main()
{
srand((unsigned int)time(NULL));//设置由时间设置的随机数种子
text();
}
总结
一万两千多字，码了四个多小时，求三连！