目录
前言
游戏实现
一、游戏的开始与退出的实现
二、初始化并打印雷区
三、在雷区中随机产生雷
四、玩家排雷
五、清除周围没有雷的坐标
代码汇总
一、game.h———函数的声明，头文件引用，标识符常量的定义
二、game.c———包含函数的实现
三、test.c———包含主函数与游戏实现
前言
扫雷曾是一个火遍大江南北的游戏，在国内上线后获得众多好评，但如今win10已不在自带扫雷游戏了，想玩怎么办？今天我将用c语言带你重温扫雷游戏！
游戏实现
扫雷曾是一个火遍大江南北的游戏，在国内上线后获得众多好评，但如今win10已不在自带扫雷游戏了，想玩怎么办？今天我将用c语言带你重温扫雷游戏！
一、游戏的开始与退出的实现
void meau()//菜单函数
{
printf("*********************************n");
printf("****** 1. play ************n");
printf("*********************************n");
printf("****** 0. exit ************n");
printf("*********************************n");
}
int main()
{
int input = 0;//输入选项的变量
srand((unsigned int)time(NULL));//srand函数可以确定rand函数的随机值下限
do
{
meau();//打印菜单
printf("请输入选项>:");
scanf("%d", &input);
switch (input)
{
case 1:
game();
break;
case 0:
printf("游戏结束n");
break;
default:
printf("输入错误，请重新输入n");
break;
}
} while (input);//如果input输入的值为0，循环会停止
return 0;
}
二、初始化并打印雷区
void InitBoard(char board[ROWS][COLS], int row, int col, char set)//第四个参数为期望把数组设置成的字符
{
int i = 0;
int j = 0;
for (i = 0; i < row; i++)
{
for (j = 0; j < col; j++)
{
board[i][j] = set;
}
}
}
void PrintBoard(char board[ROWS][COLS], int row, int col)
{
int i = 0;
int j = 0;
for (j = 0; j <= row; 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");
}
}
三、在雷区中随机产生雷
void SetMine(char mine[ROWS][COLS], int row, int col)
{
int count = EASY_COUNT;//雷的数目
while (count)
{
int x = rand() % row + 1;//产生1到row的随机数
int y = rand() % col + 1;//产生1到col的随机数
if (mine[x][y] == '0')//如果该坐标没有被设置过地雷则将其设置为地雷
{
mine[x][y] = '1';//地雷用字符1来表示
count--;
}
}
}
四、玩家排雷
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{
int win = 0;
while (win < row*col - EASY_COUNT)//row*col - EASY_COUNT为需要有效扫雷的次数，每一次没扫到雷都会使win+1
{
int x = 0;
int y = 0;
printf("请输入排查的坐标>:");
scanf("%d %d", &x, &y);
if (x >= 1 && x <= row && y >= 1 && y <= col)//判断坐标是否合法
{
if (show[x][y] == '*')//判断坐标是否被扫过，防止重复扫相同位置导致win多加了
{
if (mine[x][y] == '1')//判断坐标在地雷数组里是否为雷
{
printf("GAME OVERn");
PrintBoard(mine, ROW, COL);
break;
}
else
{
remove_NoMine(mine,show, x, y);//显示周围雷的个数
PrintBoard(show, ROW, COL);
win++;//每一次扫到的不是雷都会使win++
}
}
else
printf("该坐标已被排除，不能重复排除n");
}
else
printf("输入坐标非法，请重新输入n");
}
if (win == row * col - EASY_COUNT)//当win++到等于要扫的次数时，则游戏胜利
{
printf("恭喜你扫雷成功n");
PrintBoard(show, ROW, COL);
}
}
五、清除周围没有雷的坐标
char get_mine_count(char mine[ROWS][COLS], int x, int y)//求周围有多少雷的函数
{
int i = 0;
int j = 0;
char count = 0;
for (i = -1; i <= 1; i++)
{
for (j = -1; j <= 1; j++)
{//因为字符在内存中以ascii码的形式存储，所以如果周围有雷则可以用字符1减去字符0，得到ascii码值为1
//然后将这些ascii码相加得到一个值
count += mine[x + i][y + j] - '0';
}
}
return count;//返回这个值
}
//链式反应，如果输入坐标周围没有雷，则清除该坐标
void remove_NoMine(char mine[ROWS][COLS],char show[ROWS][COLS], int x, int y)
{
if (x >= 1 && x <= ROW && y >= 1 && y <= COL)//判断坐标是否合法
{
int i = 0;
int j = 0;
show[x][y] = get_mine_count(mine, x, y) + '0';//将展示的数组里坐标更改为周围雷的个数
if (show[x][y] == '0')
{
show[x][y] = ' ';//如果周围雷的个数为0,则设置此坐标为“空格”
//判断此坐标周围坐标是否还有可设为空格的坐标
for (i = -1; i <= 1; i++)
{
for (j = -1; j <= 1; j++)
{
if (show[x+i][y+j] == '*')
remove_NoMine(mine, show, x + i, y + j);//递归
}
}
}
}
}
代码汇总
一、game.h———函数的声明，头文件引用，标识符常量的定义
#include
#include
#include
#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 row, int col, char set);//初始化两个二维数组
void PrintBoard(char board[ROWS][COLS], int row, int col);//打印数组
void SetMine(char mine[ROWS][COLS], int row, int col);//放置雷
char get_mine_count(char mine[ROWS][COLS], int x, int y);//获取一个坐标周围雷的个数
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col);//玩家找雷
void remove_NoMine(char mine[ROWS][COLS], char show[ROWS][COLS], int x, int y);//链式反应，如果输入坐标周围没有雷，则清除该坐标
二、game.c———包含函数的实现
#include "game.h"
void InitBoard(char board[ROWS][COLS], int row, int col, char set)//第四个参数为期望把数组设置成的字符
{
int i = 0;
int j = 0;
for (i = 0; i < row; i++)
{
for (j = 0; j < col; j++)
{
board[i][j] = set;
}
}
}
void PrintBoard(char board[ROWS][COLS], int row, int col)
{
int i = 0;
int j = 0;
for (j = 0; j <= row; 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");
}
}
void SetMine(char mine[ROWS][COLS], int row, int col)
{
int count = EASY_COUNT;//雷的数目
while (count)
{
int x = rand() % row + 1;//产生1到row的随机数
int y = rand() % col + 1;//产生1到col的随机数
if (mine[x][y] == '0')//如果该坐标没有被设置过地雷则将其设置为地雷
{
mine[x][y] = '1';//地雷用字符1来表示
count--;
}
}
}
char get_mine_count(char mine[ROWS][COLS], int x, int y)//求周围有多少雷的函数
{
int i = 0;
int j = 0;
char count = 0;
for (i = -1; i <= 1; i++)
{
for (j = -1; j <= 1; j++)
{//因为字符在内存中以ascii码的形式存储，所以如果周围有雷则可以用字符1减去字符0，得到ascii码值为1
//然后将这些ascii码相加得到一个值
count += mine[x + i][y + j] - '0';
}
}
return count;//返回这个值
}
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{
int win = 0;
while (win < row*col - EASY_COUNT)//row*col - EASY_COUNT为需要有效扫雷的次数，每一次没扫到雷都会使win+1
{
int x = 0;
int y = 0;
printf("请输入排查的坐标>:");
scanf("%d %d", &x, &y);
if (x >= 1 && x <= row && y >= 1 && y <= col)//判断坐标是否合法
{
if (show[x][y] == '*')//判断坐标是否被扫过，防止重复扫相同位置导致win多加了
{
if (mine[x][y] == '1')//判断坐标在地雷数组里是否为雷
{
printf("GAME OVERn");
PrintBoard(mine, ROW, COL);
break;
}
else
{
remove_NoMine(mine,show, x, y);//显示周围雷的个数
PrintBoard(show, ROW, COL);
win++;//每一次扫到的不是雷都会使win++
}
}
else
printf("该坐标已被排除，不能重复排除n");
}
else
printf("输入坐标非法，请重新输入n");
}
if (win == row * col - EASY_COUNT)//当win++到等于要扫的次数时，则游戏胜利
{
printf("恭喜你扫雷成功n");
PrintBoard(show, ROW, COL);
}
}
//链式反应，如果输入坐标周围没有雷，则清除该坐标
void remove_NoMine(char mine[ROWS][COLS],char show[ROWS][COLS], int x, int y)
{
if (x >= 1 && x <= ROW && y >= 1 && y <= COL)//判断坐标是否合法
{
int i = 0;
int j = 0;
show[x][y] = get_mine_count(mine, x, y) + '0';//将展示的数组里坐标更改为周围雷的个数
if (show[x][y] == '0')
{
show[x][y] = ' ';//如果周围雷的个数为0,则设置此坐标为“空格”
//判断此坐标周围坐标是否还有可设为空格的坐标
for (i = -1; i <= 1; i++)
{
for (j = -1; j <= 1; j++)
{
if (show[x+i][y+j] == '*')
remove_NoMine(mine, show, x + i, y + j);//递归
}
}
}
}
}
三、test.c———包含主函数与游戏实现
#include "game.h"
void meau()//菜单函数
{
printf("*********************************n");
printf("****** 1. play ************n");
printf("*********************************n");
printf("****** 0. exit ************n");
printf("*********************************n");
}
void game()
{
char mine[ROWS][COLS] = { 0 };//地雷数组
char show[ROWS][COLS] = { 0 };//展示时的数组
InitBoard(mine, ROWS, COLS,'0');//地雷数组初始化为字符0
InitBoard(show, ROWS, COLS, '*');//展示时的数组初始化为字符*
SetMine(mine, ROW, COL);//放置雷到地雷数组
printf("--------扫雷-----------n");
PrintBoard(show, ROW, COL);
FindMine(mine,show, ROW, COL);//玩家找雷
}
int main()
{
int input = 0;//输入选项的变量
srand((unsigned int)time(NULL));//srand函数可以确定rand函数的随机值下限
do
{
meau();//打印菜单
printf("请输入选项>:");
scanf("%d", &input);
switch (input)
{
case 1:
game();
break;
case 0:
printf("游戏结束n");
break;
default:
printf("输入错误，请重新输入n");
break;
}
} while (input);//如果input输入的值为0，循环会停止
return 0;
}
void InitBoard(char board[ROWS][COLS], int row, int col, char set)//第四个参数为期望把数组设置成的字符
{
int i = 0;
int j = 0;
for (i = 0; i < row; i++)
{
for (j = 0; j < col; j++)
{
board[i][j] = set;
}
}
}
void PrintBoard(char board[ROWS][COLS], int row, int col)
{
int i = 0;
int j = 0;
for (j = 0; j <= row; 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");
}
}
三、在雷区中随机产生雷
void SetMine(char mine[ROWS][COLS], int row, int col)
{
int count = EASY_COUNT;//雷的数目
while (count)
{
int x = rand() % row + 1;//产生1到row的随机数
int y = rand() % col + 1;//产生1到col的随机数
if (mine[x][y] == '0')//如果该坐标没有被设置过地雷则将其设置为地雷
{
mine[x][y] = '1';//地雷用字符1来表示
count--;
}
}
}
四、玩家排雷
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{
int win = 0;
while (win < row*col - EASY_COUNT)//row*col - EASY_COUNT为需要有效扫雷的次数，每一次没扫到雷都会使win+1
{
int x = 0;
int y = 0;
printf("请输入排查的坐标>:");
scanf("%d %d", &x, &y);
if (x >= 1 && x <= row && y >= 1 && y <= col)//判断坐标是否合法
{
if (show[x][y] == '*')//判断坐标是否被扫过，防止重复扫相同位置导致win多加了
{
if (mine[x][y] == '1')//判断坐标在地雷数组里是否为雷
{
printf("GAME OVERn");
PrintBoard(mine, ROW, COL);
break;
}
else
{
remove_NoMine(mine,show, x, y);//显示周围雷的个数
PrintBoard(show, ROW, COL);
win++;//每一次扫到的不是雷都会使win++
}
}
else
printf("该坐标已被排除，不能重复排除n");
}
else
printf("输入坐标非法，请重新输入n");
}
if (win == row * col - EASY_COUNT)//当win++到等于要扫的次数时，则游戏胜利
{
printf("恭喜你扫雷成功n");
PrintBoard(show, ROW, COL);
}
}
五、清除周围没有雷的坐标
char get_mine_count(char mine[ROWS][COLS], int x, int y)//求周围有多少雷的函数
{
int i = 0;
int j = 0;
char count = 0;
for (i = -1; i <= 1; i++)
{
for (j = -1; j <= 1; j++)
{//因为字符在内存中以ascii码的形式存储，所以如果周围有雷则可以用字符1减去字符0，得到ascii码值为1
//然后将这些ascii码相加得到一个值
count += mine[x + i][y + j] - '0';
}
}
return count;//返回这个值
}
//链式反应，如果输入坐标周围没有雷，则清除该坐标
void remove_NoMine(char mine[ROWS][COLS],char show[ROWS][COLS], int x, int y)
{
if (x >= 1 && x <= ROW && y >= 1 && y <= COL)//判断坐标是否合法
{
int i = 0;
int j = 0;
show[x][y] = get_mine_count(mine, x, y) + '0';//将展示的数组里坐标更改为周围雷的个数
if (show[x][y] == '0')
{
show[x][y] = ' ';//如果周围雷的个数为0,则设置此坐标为“空格”
//判断此坐标周围坐标是否还有可设为空格的坐标
for (i = -1; i <= 1; i++)
{
for (j = -1; j <= 1; j++)
{
if (show[x+i][y+j] == '*')
remove_NoMine(mine, show, x + i, y + j);//递归
}
}
}
}
}
代码汇总
一、game.h———函数的声明，头文件引用，标识符常量的定义
#include
#include
#include
#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 row, int col, char set);//初始化两个二维数组
void PrintBoard(char board[ROWS][COLS], int row, int col);//打印数组
void SetMine(char mine[ROWS][COLS], int row, int col);//放置雷
char get_mine_count(char mine[ROWS][COLS], int x, int y);//获取一个坐标周围雷的个数
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col);//玩家找雷
void remove_NoMine(char mine[ROWS][COLS], char show[ROWS][COLS], int x, int y);//链式反应，如果输入坐标周围没有雷，则清除该坐标
二、game.c———包含函数的实现
#include "game.h"
void InitBoard(char board[ROWS][COLS], int row, int col, char set)//第四个参数为期望把数组设置成的字符
{
int i = 0;
int j = 0;
for (i = 0; i < row; i++)
{
for (j = 0; j < col; j++)
{
board[i][j] = set;
}
}
}
void PrintBoard(char board[ROWS][COLS], int row, int col)
{
int i = 0;
int j = 0;
for (j = 0; j <= row; 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");
}
}
void SetMine(char mine[ROWS][COLS], int row, int col)
{
int count = EASY_COUNT;//雷的数目
while (count)
{
int x = rand() % row + 1;//产生1到row的随机数
int y = rand() % col + 1;//产生1到col的随机数
if (mine[x][y] == '0')//如果该坐标没有被设置过地雷则将其设置为地雷
{
mine[x][y] = '1';//地雷用字符1来表示
count--;
}
}
}
char get_mine_count(char mine[ROWS][COLS], int x, int y)//求周围有多少雷的函数
{
int i = 0;
int j = 0;
char count = 0;
for (i = -1; i <= 1; i++)
{
for (j = -1; j <= 1; j++)
{//因为字符在内存中以ascii码的形式存储，所以如果周围有雷则可以用字符1减去字符0，得到ascii码值为1
//然后将这些ascii码相加得到一个值
count += mine[x + i][y + j] - '0';
}
}
return count;//返回这个值
}
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{
int win = 0;
while (win < row*col - EASY_COUNT)//row*col - EASY_COUNT为需要有效扫雷的次数，每一次没扫到雷都会使win+1
{
int x = 0;
int y = 0;
printf("请输入排查的坐标>:");
scanf("%d %d", &x, &y);
if (x >= 1 && x <= row && y >= 1 && y <= col)//判断坐标是否合法
{
if (show[x][y] == '*')//判断坐标是否被扫过，防止重复扫相同位置导致win多加了
{
if (mine[x][y] == '1')//判断坐标在地雷数组里是否为雷
{
printf("GAME OVERn");
PrintBoard(mine, ROW, COL);
break;
}
else
{
remove_NoMine(mine,show, x, y);//显示周围雷的个数
PrintBoard(show, ROW, COL);
win++;//每一次扫到的不是雷都会使win++
}
}
else
printf("该坐标已被排除，不能重复排除n");
}
else
printf("输入坐标非法，请重新输入n");
}
if (win == row * col - EASY_COUNT)//当win++到等于要扫的次数时，则游戏胜利
{
printf("恭喜你扫雷成功n");
PrintBoard(show, ROW, COL);
}
}
//链式反应，如果输入坐标周围没有雷，则清除该坐标
void remove_NoMine(char mine[ROWS][COLS],char show[ROWS][COLS], int x, int y)
{
if (x >= 1 && x <= ROW && y >= 1 && y <= COL)//判断坐标是否合法
{
int i = 0;
int j = 0;
show[x][y] = get_mine_count(mine, x, y) + '0';//将展示的数组里坐标更改为周围雷的个数
if (show[x][y] == '0')
{
show[x][y] = ' ';//如果周围雷的个数为0,则设置此坐标为“空格”
//判断此坐标周围坐标是否还有可设为空格的坐标
for (i = -1; i <= 1; i++)
{
for (j = -1; j <= 1; j++)
{
if (show[x+i][y+j] == '*')
remove_NoMine(mine, show, x + i, y + j);//递归
}
}
}
}
}
三、test.c———包含主函数与游戏实现
#include "game.h"
void meau()//菜单函数
{
printf("*********************************n");
printf("****** 1. play ************n");
printf("*********************************n");
printf("****** 0. exit ************n");
printf("*********************************n");
}
void game()
{
char mine[ROWS][COLS] = { 0 };//地雷数组
char show[ROWS][COLS] = { 0 };//展示时的数组
InitBoard(mine, ROWS, COLS,'0');//地雷数组初始化为字符0
InitBoard(show, ROWS, COLS, '*');//展示时的数组初始化为字符*
SetMine(mine, ROW, COL);//放置雷到地雷数组
printf("--------扫雷-----------n");
PrintBoard(show, ROW, COL);
FindMine(mine,show, ROW, COL);//玩家找雷
}
int main()
{
int input = 0;//输入选项的变量
srand((unsigned int)time(NULL));//srand函数可以确定rand函数的随机值下限
do
{
meau();//打印菜单
printf("请输入选项>:");
scanf("%d", &input);
switch (input)
{
case 1:
game();
break;
case 0:
printf("游戏结束n");
break;
default:
printf("输入错误，请重新输入n");
break;
}
} while (input);//如果input输入的值为0，循环会停止
return 0;
}
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{
int win = 0;
while (win < row*col - EASY_COUNT)//row*col - EASY_COUNT为需要有效扫雷的次数，每一次没扫到雷都会使win+1
{
int x = 0;
int y = 0;
printf("请输入排查的坐标>:");
scanf("%d %d", &x, &y);
if (x >= 1 && x <= row && y >= 1 && y <= col)//判断坐标是否合法
{
if (show[x][y] == '*')//判断坐标是否被扫过，防止重复扫相同位置导致win多加了
{
if (mine[x][y] == '1')//判断坐标在地雷数组里是否为雷
{
printf("GAME OVERn");
PrintBoard(mine, ROW, COL);
break;
}
else
{
remove_NoMine(mine,show, x, y);//显示周围雷的个数
PrintBoard(show, ROW, COL);
win++;//每一次扫到的不是雷都会使win++
}
}
else
printf("该坐标已被排除，不能重复排除n");
}
else
printf("输入坐标非法，请重新输入n");
}
if (win == row * col - EASY_COUNT)//当win++到等于要扫的次数时，则游戏胜利
{
printf("恭喜你扫雷成功n");
PrintBoard(show, ROW, COL);
}
}
五、清除周围没有雷的坐标
char get_mine_count(char mine[ROWS][COLS], int x, int y)//求周围有多少雷的函数
{
int i = 0;
int j = 0;
char count = 0;
for (i = -1; i <= 1; i++)
{
for (j = -1; j <= 1; j++)
{//因为字符在内存中以ascii码的形式存储，所以如果周围有雷则可以用字符1减去字符0，得到ascii码值为1
//然后将这些ascii码相加得到一个值
count += mine[x + i][y + j] - '0';
}
}
return count;//返回这个值
}
//链式反应，如果输入坐标周围没有雷，则清除该坐标
void remove_NoMine(char mine[ROWS][COLS],char show[ROWS][COLS], int x, int y)
{
if (x >= 1 && x <= ROW && y >= 1 && y <= COL)//判断坐标是否合法
{
int i = 0;
int j = 0;
show[x][y] = get_mine_count(mine, x, y) + '0';//将展示的数组里坐标更改为周围雷的个数
if (show[x][y] == '0')
{
show[x][y] = ' ';//如果周围雷的个数为0,则设置此坐标为“空格”
//判断此坐标周围坐标是否还有可设为空格的坐标
for (i = -1; i <= 1; i++)
{
for (j = -1; j <= 1; j++)
{
if (show[x+i][y+j] == '*')
remove_NoMine(mine, show, x + i, y + j);//递归
}
}
}
}
}
代码汇总
一、game.h———函数的声明，头文件引用，标识符常量的定义
#include
#include
#include
#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 row, int col, char set);//初始化两个二维数组
void PrintBoard(char board[ROWS][COLS], int row, int col);//打印数组
void SetMine(char mine[ROWS][COLS], int row, int col);//放置雷
char get_mine_count(char mine[ROWS][COLS], int x, int y);//获取一个坐标周围雷的个数
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col);//玩家找雷
void remove_NoMine(char mine[ROWS][COLS], char show[ROWS][COLS], int x, int y);//链式反应，如果输入坐标周围没有雷，则清除该坐标
二、game.c———包含函数的实现
#include "game.h"
void InitBoard(char board[ROWS][COLS], int row, int col, char set)//第四个参数为期望把数组设置成的字符
{
int i = 0;
int j = 0;
for (i = 0; i < row; i++)
{
for (j = 0; j < col; j++)
{
board[i][j] = set;
}
}
}
void PrintBoard(char board[ROWS][COLS], int row, int col)
{
int i = 0;
int j = 0;
for (j = 0; j <= row; 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");
}
}
void SetMine(char mine[ROWS][COLS], int row, int col)
{
int count = EASY_COUNT;//雷的数目
while (count)
{
int x = rand() % row + 1;//产生1到row的随机数
int y = rand() % col + 1;//产生1到col的随机数
if (mine[x][y] == '0')//如果该坐标没有被设置过地雷则将其设置为地雷
{
mine[x][y] = '1';//地雷用字符1来表示
count--;
}
}
}
char get_mine_count(char mine[ROWS][COLS], int x, int y)//求周围有多少雷的函数
{
int i = 0;
int j = 0;
char count = 0;
for (i = -1; i <= 1; i++)
{
for (j = -1; j <= 1; j++)
{//因为字符在内存中以ascii码的形式存储，所以如果周围有雷则可以用字符1减去字符0，得到ascii码值为1
//然后将这些ascii码相加得到一个值
count += mine[x + i][y + j] - '0';
}
}
return count;//返回这个值
}
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{
int win = 0;
while (win < row*col - EASY_COUNT)//row*col - EASY_COUNT为需要有效扫雷的次数，每一次没扫到雷都会使win+1
{
int x = 0;
int y = 0;
printf("请输入排查的坐标>:");
scanf("%d %d", &x, &y);
if (x >= 1 && x <= row && y >= 1 && y <= col)//判断坐标是否合法
{
if (show[x][y] == '*')//判断坐标是否被扫过，防止重复扫相同位置导致win多加了
{
if (mine[x][y] == '1')//判断坐标在地雷数组里是否为雷
{
printf("GAME OVERn");
PrintBoard(mine, ROW, COL);
break;
}
else
{
remove_NoMine(mine,show, x, y);//显示周围雷的个数
PrintBoard(show, ROW, COL);
win++;//每一次扫到的不是雷都会使win++
}
}
else
printf("该坐标已被排除，不能重复排除n");
}
else
printf("输入坐标非法，请重新输入n");
}
if (win == row * col - EASY_COUNT)//当win++到等于要扫的次数时，则游戏胜利
{
printf("恭喜你扫雷成功n");
PrintBoard(show, ROW, COL);
}
}
//链式反应，如果输入坐标周围没有雷，则清除该坐标
void remove_NoMine(char mine[ROWS][COLS],char show[ROWS][COLS], int x, int y)
{
if (x >= 1 && x <= ROW && y >= 1 && y <= COL)//判断坐标是否合法
{
int i = 0;
int j = 0;
show[x][y] = get_mine_count(mine, x, y) + '0';//将展示的数组里坐标更改为周围雷的个数
if (show[x][y] == '0')
{
show[x][y] = ' ';//如果周围雷的个数为0,则设置此坐标为“空格”
//判断此坐标周围坐标是否还有可设为空格的坐标
for (i = -1; i <= 1; i++)
{
for (j = -1; j <= 1; j++)
{
if (show[x+i][y+j] == '*')
remove_NoMine(mine, show, x + i, y + j);//递归
}
}
}
}
}
三、test.c———包含主函数与游戏实现
#include "game.h"
void meau()//菜单函数
{
printf("*********************************n");
printf("****** 1. play ************n");
printf("*********************************n");
printf("****** 0. exit ************n");
printf("*********************************n");
}
void game()
{
char mine[ROWS][COLS] = { 0 };//地雷数组
char show[ROWS][COLS] = { 0 };//展示时的数组
InitBoard(mine, ROWS, COLS,'0');//地雷数组初始化为字符0
InitBoard(show, ROWS, COLS, '*');//展示时的数组初始化为字符*
SetMine(mine, ROW, COL);//放置雷到地雷数组
printf("--------扫雷-----------n");
PrintBoard(show, ROW, COL);
FindMine(mine,show, ROW, COL);//玩家找雷
}
int main()
{
int input = 0;//输入选项的变量
srand((unsigned int)time(NULL));//srand函数可以确定rand函数的随机值下限
do
{
meau();//打印菜单
printf("请输入选项>:");
scanf("%d", &input);
switch (input)
{
case 1:
game();
break;
case 0:
printf("游戏结束n");
break;
default:
printf("输入错误，请重新输入n");
break;
}
} while (input);//如果input输入的值为0，循环会停止
return 0;
}
一、game.h———函数的声明，头文件引用，标识符常量的定义
#include
#include
#include
#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 row, int col, char set);//初始化两个二维数组
void PrintBoard(char board[ROWS][COLS], int row, int col);//打印数组
void SetMine(char mine[ROWS][COLS], int row, int col);//放置雷
char get_mine_count(char mine[ROWS][COLS], int x, int y);//获取一个坐标周围雷的个数
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col);//玩家找雷
void remove_NoMine(char mine[ROWS][COLS], char show[ROWS][COLS], int x, int y);//链式反应，如果输入坐标周围没有雷，则清除该坐标
二、game.c———包含函数的实现
#include "game.h"
void InitBoard(char board[ROWS][COLS], int row, int col, char set)//第四个参数为期望把数组设置成的字符
{
int i = 0;
int j = 0;
for (i = 0; i < row; i++)
{
for (j = 0; j < col; j++)
{
board[i][j] = set;
}
}
}
void PrintBoard(char board[ROWS][COLS], int row, int col)
{
int i = 0;
int j = 0;
for (j = 0; j <= row; 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");
}
}
void SetMine(char mine[ROWS][COLS], int row, int col)
{
int count = EASY_COUNT;//雷的数目
while (count)
{
int x = rand() % row + 1;//产生1到row的随机数
int y = rand() % col + 1;//产生1到col的随机数
if (mine[x][y] == '0')//如果该坐标没有被设置过地雷则将其设置为地雷
{
mine[x][y] = '1';//地雷用字符1来表示
count--;
}
}
}
char get_mine_count(char mine[ROWS][COLS], int x, int y)//求周围有多少雷的函数
{
int i = 0;
int j = 0;
char count = 0;
for (i = -1; i <= 1; i++)
{
for (j = -1; j <= 1; j++)
{//因为字符在内存中以ascii码的形式存储，所以如果周围有雷则可以用字符1减去字符0，得到ascii码值为1
//然后将这些ascii码相加得到一个值
count += mine[x + i][y + j] - '0';
}
}
return count;//返回这个值
}
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{
int win = 0;
while (win < row*col - EASY_COUNT)//row*col - EASY_COUNT为需要有效扫雷的次数，每一次没扫到雷都会使win+1
{
int x = 0;
int y = 0;
printf("请输入排查的坐标>:");
scanf("%d %d", &x, &y);
if (x >= 1 && x <= row && y >= 1 && y <= col)//判断坐标是否合法
{
if (show[x][y] == '*')//判断坐标是否被扫过，防止重复扫相同位置导致win多加了
{
if (mine[x][y] == '1')//判断坐标在地雷数组里是否为雷
{
printf("GAME OVERn");
PrintBoard(mine, ROW, COL);
break;
}
else
{
remove_NoMine(mine,show, x, y);//显示周围雷的个数
PrintBoard(show, ROW, COL);
win++;//每一次扫到的不是雷都会使win++
}
}
else
printf("该坐标已被排除，不能重复排除n");
}
else
printf("输入坐标非法，请重新输入n");
}
if (win == row * col - EASY_COUNT)//当win++到等于要扫的次数时，则游戏胜利
{
printf("恭喜你扫雷成功n");
PrintBoard(show, ROW, COL);
}
}
//链式反应，如果输入坐标周围没有雷，则清除该坐标
void remove_NoMine(char mine[ROWS][COLS],char show[ROWS][COLS], int x, int y)
{
if (x >= 1 && x <= ROW && y >= 1 && y <= COL)//判断坐标是否合法
{
int i = 0;
int j = 0;
show[x][y] = get_mine_count(mine, x, y) + '0';//将展示的数组里坐标更改为周围雷的个数
if (show[x][y] == '0')
{
show[x][y] = ' ';//如果周围雷的个数为0,则设置此坐标为“空格”
//判断此坐标周围坐标是否还有可设为空格的坐标
for (i = -1; i <= 1; i++)
{
for (j = -1; j <= 1; j++)
{
if (show[x+i][y+j] == '*')
remove_NoMine(mine, show, x + i, y + j);//递归
}
}
}
}
}
三、test.c———包含主函数与游戏实现
#include "game.h"
void meau()//菜单函数
{
printf("*********************************n");
printf("****** 1. play ************n");
printf("*********************************n");
printf("****** 0. exit ************n");
printf("*********************************n");
}
void game()
{
char mine[ROWS][COLS] = { 0 };//地雷数组
char show[ROWS][COLS] = { 0 };//展示时的数组
InitBoard(mine, ROWS, COLS,'0');//地雷数组初始化为字符0
InitBoard(show, ROWS, COLS, '*');//展示时的数组初始化为字符*
SetMine(mine, ROW, COL);//放置雷到地雷数组
printf("--------扫雷-----------n");
PrintBoard(show, ROW, COL);
FindMine(mine,show, ROW, COL);//玩家找雷
}
int main()
{
int input = 0;//输入选项的变量
srand((unsigned int)time(NULL));//srand函数可以确定rand函数的随机值下限
do
{
meau();//打印菜单
printf("请输入选项>:");
scanf("%d", &input);
switch (input)
{
case 1:
game();
break;
case 0:
printf("游戏结束n");
break;
default:
printf("输入错误，请重新输入n");
break;
}
} while (input);//如果input输入的值为0，循环会停止
return 0;
}
#include "game.h"
void InitBoard(char board[ROWS][COLS], int row, int col, char set)//第四个参数为期望把数组设置成的字符
{
int i = 0;
int j = 0;
for (i = 0; i < row; i++)
{
for (j = 0; j < col; j++)
{
board[i][j] = set;
}
}
}
void PrintBoard(char board[ROWS][COLS], int row, int col)
{
int i = 0;
int j = 0;
for (j = 0; j <= row; 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");
}
}
void SetMine(char mine[ROWS][COLS], int row, int col)
{
int count = EASY_COUNT;//雷的数目
while (count)
{
int x = rand() % row + 1;//产生1到row的随机数
int y = rand() % col + 1;//产生1到col的随机数
if (mine[x][y] == '0')//如果该坐标没有被设置过地雷则将其设置为地雷
{
mine[x][y] = '1';//地雷用字符1来表示
count--;
}
}
}
char get_mine_count(char mine[ROWS][COLS], int x, int y)//求周围有多少雷的函数
{
int i = 0;
int j = 0;
char count = 0;
for (i = -1; i <= 1; i++)
{
for (j = -1; j <= 1; j++)
{//因为字符在内存中以ascii码的形式存储，所以如果周围有雷则可以用字符1减去字符0，得到ascii码值为1
//然后将这些ascii码相加得到一个值
count += mine[x + i][y + j] - '0';
}
}
return count;//返回这个值
}
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{
int win = 0;
while (win < row*col - EASY_COUNT)//row*col - EASY_COUNT为需要有效扫雷的次数，每一次没扫到雷都会使win+1
{
int x = 0;
int y = 0;
printf("请输入排查的坐标>:");
scanf("%d %d", &x, &y);
if (x >= 1 && x <= row && y >= 1 && y <= col)//判断坐标是否合法
{
if (show[x][y] == '*')//判断坐标是否被扫过，防止重复扫相同位置导致win多加了
{
if (mine[x][y] == '1')//判断坐标在地雷数组里是否为雷
{
printf("GAME OVERn");
PrintBoard(mine, ROW, COL);
break;
}
else
{
remove_NoMine(mine,show, x, y);//显示周围雷的个数
PrintBoard(show, ROW, COL);
win++;//每一次扫到的不是雷都会使win++
}
}
else
printf("该坐标已被排除，不能重复排除n");
}
else
printf("输入坐标非法，请重新输入n");
}
if (win == row * col - EASY_COUNT)//当win++到等于要扫的次数时，则游戏胜利
{
printf("恭喜你扫雷成功n");
PrintBoard(show, ROW, COL);
}
}
//链式反应，如果输入坐标周围没有雷，则清除该坐标
void remove_NoMine(char mine[ROWS][COLS],char show[ROWS][COLS], int x, int y)
{
if (x >= 1 && x <= ROW && y >= 1 && y <= COL)//判断坐标是否合法
{
int i = 0;
int j = 0;
show[x][y] = get_mine_count(mine, x, y) + '0';//将展示的数组里坐标更改为周围雷的个数
if (show[x][y] == '0')
{
show[x][y] = ' ';//如果周围雷的个数为0,则设置此坐标为“空格”
//判断此坐标周围坐标是否还有可设为空格的坐标
for (i = -1; i <= 1; i++)
{
for (j = -1; j <= 1; j++)
{
if (show[x+i][y+j] == '*')
remove_NoMine(mine, show, x + i, y + j);//递归
}
}
}
}
}
