1.规则
相信大家都听说过扫雷这个游戏
它的规则很简单
设定好地雷数和棋盘大小,游戏开始
这里我们将棋盘设置为9*9,雷数设置为10
雷区就布置好了
点击一个位置就会排查对应的位置
如果出现了数字,这些数字就表示周围的八个格子雷的个数
比如说这个数字一,表示周围八个格子有一个类,直接锁定了雷的位置。
如果你点到了雷,游戏结束。
如果你点的位置周围八个格子一个雷都没有,会自动帮你拓张
比如,这是第一次排查位置,周围没有雷,就会再帮你排查周围的八个格子,如果有坐标一样没有雷,就继续向外拓展,直到周围格子有雷。
当雷全部排完(也就是雷之外的格子被排空),游戏胜利。
知道了扫雷的基础的规则,我们就根据规则写出相应的代码模块。
2.代码
(1)基础部分
和三子棋一样,有基础的菜单和交互逻辑
void menu()
{
printf("************************************\n");
printf("******** 1. play *********\n");
printf("******** 0. exit *********\n");
printf("************************************\n");
}
void test()
{
int input = 0;
do
{
menu();
scanf("%d", &input);
system("cls");
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));
test();
return 0;
}
有游戏的运行模块,由函数组成
void game()
{
char board[ROW + 2][COL + 2] = { '\0'};
char mine[ROW + 2][COL + 2] = { '\0'};
chushihua(ROW,COL,board,'*');
chushihua(ROW, COL, mine,'0');
setmine(ROW, COL, mine);
//printmine(ROW, COL, mine);
printboard(ROW, COL, board);
move(ROW, COL, board,mine);
}
我们将棋盘数据,雷数作为宏定义常量储存。
#define MINE 10
#define ROW 9
#define COL 9
扫雷的雷区数据用二位数组来存储。
因为扫雷不仅需要展示用的棋盘用于玩家操作,也需要一个存放雷区的二维数组。
所以我们创建两个char类型的数组
一个用于展示给玩家让玩家操作,在展示的棋盘上用字符’*'表示未排查的区域,即board数组
一个用于储存雷的数据,即mine数组
在排查雷的时候,因为需要排查周围的八个格子,需要访问周围八个格子的数据。防止数组越界,我们创建数组时,在原本的棋盘上向外拓展一圈,也就是在原本的棋盘数据上加2。
char board[ROW + 2][COL + 2] = { '\0'};
char mine[ROW + 2][COL + 2] = { '\0'};
在创建好了棋盘之后,我们需要创建几个基本的模块
(2)初始化
对储存雷区和展示区的二维数组初始化
void chushihua(int row, int col, char board[ROW + 2][COL + 2],char set)
{
int a = 0, b = 0;
for (a = 0; a < row + 2; a++)
{
for (b = 0; b < col + 2; b++)
{
board[a][b] = set;
}
}
}
雷区和展示区的初始化方式是一样的
因此它们可以共用一个函数,通过改变函数参数来达到效果。
(3)布置雷区
利用随机数来进行布置
因为棋盘向外拓展了一圈,所以在去模之后加一
void setmine(int row, int col, char board[ROW + 2][COL + 2])
{
int a = 0, b = 0,count=0;
while (1)
{
a = rand()%row+1;
b = rand()%col+1;
if (board[a][b] == '0')
{
board[a][b] = '1';
count++;
}
if (count == MINE)
{
break;
}
}
}
打印棋盘
为了便于玩家进行定位,我们将坐标打印出来
void printboard(int row, int col, char board[ROW + 2][COL + 2])
{
int a = 0;
int b = 0;
system("cls");
printf("---------扫雷----------\n ");
for (a = 1; a <= col; a++)
{
printf("%d ", a);
}
printf("\n");
for (a =1; a <= row; a++)
{
printf("%d", a);
for (b = 1; b <= col; b++)
{
printf(" %c", board[a][b]);
}
printf("\n");
}
printf("---------扫雷----------\n");
}
同样原理,我们可以写一个打印雷区的函数,在代码运行的时候方便我们进行调试
(就是开透视)
在代码完成时删掉打印雷区的代码即可
(4)玩家排雷
之前我们说过,雷区之外的区域被排空即视为游戏胜利
我们定义一个变量win
每探出一个雷,win值便加一
那么游戏胜利的条件便是win值达到ROL*COL-MINE
用while循环来表示
while (win < (row * col - MINE))
{
}
接受玩家的坐标之后
我们要对坐标的合法性进行判断
如果发现坐标在雷区对应的元素是雷
说明玩家踩雷,将这个坐标位置改为字符’!'跳出循环,并打印结果
void move(int row, int col, char board[ROW + 2][COL + 2], char mine[ROW + 2][COL + 2])
{
int x = 0;
int y = 0;
int win=0;
int* pwin = &win;
while (win < (row * col - MINE))
{
scanf("%d %d", &x, &y);
if (x >= 1 && x <= row && y >= 1 && y <= col)
{
if (board[x][y] != '*')
{
printf("该坐标被排查过了\n");
continue;
}
if (mine[x][y] == '1')
{
printf("很遗憾,你被炸死了\n");
board[x][y] = '!';
break;
}
else
{
}
}
else
{
printf("坐标非法,请重新输入");
}
}
}
如果坐标不是雷,说明这一步正确
进入函数pingpu进行是否拓展的判断
首先写一个函数,用于获得周围八个格子雷的个数。
因为棋盘的数据类型为char类型
减去八个字符0,便能得到周围雷的个数了(ASCII码的转换)。
int getminecount(char mine[ROW+2][COL+2], 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');
}
n接受了函数的返回值后,对棋盘对应位置进行赋值
int pingpu(int x, int y, char board[ROW + 2][COL + 2], char mine[ROW + 2][COL + 2])
{
int j = 0;
int n = getminecount(mine, x, y);
board[x][y] = n + '0';
}
如果周围八个格子有雷,则显示数字
如果没有雷,则显示数字并进行拓张。
接收函数的返回值,对坐标进行赋值
如果周围没有雷,该怎么进行拓张呢?
首先用循环寻找周围八个格子(其实是九个格子,包括了自身,但在后面的判断条件中被筛除)
for (int a = x - 1; a <= x+1; a++)
{
for (int b = y - 1; b <= y+1; b++)
{
}
}
为了防止数组越界,要对坐标进行限制
if ((a > 0) && (a <= ROW) && (b > 0) && (b <= COL))
{
}
同时,防止在递归的时候排查到的坐标是雷
或者递归的时候重复对一个坐标进行排查
我们对递归设置条件
if((board[a][b] == '*') && (mine[a][b] != '1'))
{
}
条件都满足的话,就进行递归,将得到的坐标作为参数
pingpu(a, b, board, mine);
如何记录排查坐标的个数来判断胜负?
我们用变量j来接受变量的值
同时将j+1作为返回值
这样的话每次函数被调用一次,j的值便加一,
递归完成后返回的值便是排查的坐标的个数
同样,在递归的时候,我们也将递归过程中函数产生的返回值累加起来
综合起来
int pingpu(int x, int y, char board[ROW + 2][COL + 2], char mine[ROW + 2][COL + 2])
{
int j = 0;
int n = getminecount(mine, x, y);
board[x][y] = n + '0';
if (board[x][y] == '0')
{
for (int a = x - 1; a <= x+1; a++)
{
for (int b = y - 1; b <= y+1; b++)
{
if ((a > 0) && (a <= ROW) && (b > 0) && (b <= COL))
{
if((board[a][b] == '*') && (mine[a][b] != '1'))
{
j += pingpu(a, b, board, mine);
}
}
}
}
}
return j + 1;
}
同样函数pingpu的返回值也需要有人接收
在函数move中
else内的语句用win接受pingpu的返回值。
其中的x,y参数来自函数move
else
{
win+=pingpu(x, y, board, mine);
printboard(ROW, COL,board);
}
让我们把这些元素组合到一起
成功!
下一篇,部分操作符讲解
客官点个赞再走呗