【C语言】数组和函数实践：扫雷游戏

1. 扫雷游戏分析和设计

1.1 扫雷游戏的功能说明

• 使⽤控制台实现经典的扫雷游戏
• 游戏可以通过菜单实现继续玩或者退出游戏
• 扫雷的棋盘是9 * 9的格⼦
• 默认随机布置10个雷
• 可以排查雷
◦ 如果位置不是雷，就显⽰周围有⼏个雷
◦ 如果位置是雷，就炸死游戏结束
◦ 把除10个雷之外的所有⾮雷都找出来，排雷成功，游戏结束

游戏的界⾯：

1.2 游戏的分析和设计

1.2.1 数据结构的分析

扫雷的过程中，布置的雷和排查出的雷的信息都需要存储，所以我们需要⼀定的数据结构来存储这些信息。因为我们需要在9 * 9的棋盘上布置雷的信息和排查雷，我们⾸先想到的就是创建⼀个9 * 9的数组来存放信息。

那如果这个位置布置雷，我们就存放1，没有布置雷就存放0.

假设我们排查(2,5)这个坐标时，我们访问周围的⼀圈8个⻩⾊位置，统计周围雷的个数是1
假设我们排查(8,6)这个坐标时，我们访问周围的⼀圈8个⻩⾊位置，统计周围雷的个数时，最下⾯的三个坐标就会越界，为了防⽌越界，我们在设计的时候，给数组扩⼤⼀圈，雷还是布置在中间的9 * 9的坐标上，周围⼀圈不去布置雷就⾏，这样就解决了越界的问题。所以我们将存放数据的数组创建成11 * 11是⽐较合适。

再继续分析，我们在棋盘上布置了雷，棋盘上雷的信息（1）和⾮雷的信息（0），假设我们排查了某⼀个位置后，这个坐标处不是雷，这个坐标的周围有1个雷，那我们需要将排查出的雷的数量信息记录存储，并打印出来，作为排雷的重要参考信息的。
那这个雷的个数信息存放在哪⾥呢？
如果存放在布置雷的数组中，这样雷的信息和雷的个数信息就可能或产⽣混淆和打印上的困难。 这⾥我们肯定有办法解决，⽐如：雷和⾮雷的信息不要使⽤数字，使⽤某些字符就⾏，这样就避免冲突了，但是这样做棋盘上有雷和⾮雷的信息，还有排查出的雷的个数信息，就⽐较混杂，不够⽅便。
这⾥我们采⽤另外⼀种⽅案，我们专⻔给⼀个棋盘（对应⼀个数组mine）存放布置好的雷的信息，再给另外⼀个棋盘（对应另外⼀个数组show）存放排查出的雷的信息。这样就互不⼲扰了，把雷布置到mine数组，在mine数组中排查雷，排查出的数据存放在show数组，并且打印show数组的信息给后期排查参考。
同时为了保持神秘，show数组开始时初始化为字符 ‘*’，为了保持两个数组的类型⼀致，可以使⽤同⼀套函数处理，mine数组最开始也初始化为字符’0’，布置雷改成’1’。如下：

对应的数组应该是：
char mine[11][11] = {0};//⽤来存放布置好的雷的信息
char show[11][11] = {0};//⽤来存放排查出的雷的个数信息

1.2.2 ⽂件结构设计

之前学习了多⽂件的形式对函数的声明和定义，这⾥我们实践⼀下，我们设计三个⽂件：

test.c //⽂件中写游戏的测试逻辑
game.c //⽂件中写游戏中函数的实现等
game.h //⽂件中写游戏需要的数据类型和函数声明等
(game.c 和game.h：游戏实现的逻辑）

2. 扫雷游戏的代码实现

（1）菜单menu函数

“1”开始游戏，“0”退出游戏
代码：（test.c）

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

（2）设计main函数

1.玩家要做出选择，需要定义变量 input
2.随机数
后期需要随机埋雷，要用到随机数，这里介绍一下。
rand函数
函数原型：
int rand(void);
rand函数会返回一个伪随机数（多次运行后发现每一次的“随机数”相同），这个随机数的范围是在0~RAND_MAX之间，这个RAND_MAX的大小是依赖编译器上实现的，但是大部分编译器上是32767。
其实rand函数是对⼀个叫“种子”的基准值进行运算生成的随机数。之所以每次运行程序产生的随机数序列是一样的，那是因为rand函数生成随机数的默认种子是1。
rand函数的使用需要包含⼀个头文件是：stdlib.h
srand函数
函数原型：
void srand (unsigned int seed);
用于改变前面所说的“种子”，但这样还不够，因为种子一旦确定了，rand函数返回的依旧是“伪随机数”。
time函数
函数原型：
time_t time (time_t* timer);
在程序中我们一般是使用程序运行的时间作为种子的，因为时间时刻在发生变化的。 在C语言中有一个函数叫time，就可以获得这个时间。
time函数会返回当前的日历时间，其实返回的是1970年1月1日0时0分0秒到现在程序运行时间之间的差值，单位是秒。time函数返回的这个时间差也被叫做：时间戳。
time函数的时候需要包含头文件：time.h
3.do…while循环实现玩家选择进入游戏或退出游戏。

代码：（test.c）

int main()
{
    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");
        }
    }while(input);
    return 0;
}

（3）设计game函数

1.创建两个棋盘，即两个11*11字符型二维数组，ROWS表示行数，COLS表示列数
之后会常用到这两个数据，所以在头文件game.h中做如下宏定义

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

2.对两个棋盘进行初始化，打印show棋盘，布置雷，扫雷 全部通过调用函数实现
代码：（test.c）

void game()
{
    char mine[ROWS][COLS];
    char show[ROWS][COLS];
    InitBoard(mine, ROWS, COLS, '0');//初始化mine
    InitBoard(show, ROWS, COLS, '*');//初始化show
    PrintBoard(show, ROW, COL);//打印show
    SetMine(mine, ROW, COL);//在mine布置雷
    FindMine(mine, show, ROW, COL);//扫雷
}

（4）棋盘初始化InitBoard函数

四个形参：字符型二维数组，行，列，初始化的字符
设计思路是：通过双重for循环（行，列）为所有格子赋值，这里我们为mine棋盘所有格子赋值字符‘0’，为show棋盘所有格子赋值字符‘*’。
代码：（game.c）

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

（5）打印棋盘PrintBoard函数

三个形参：字符型二维数组，行，列
设计思路：打印棋盘内层9 * 9格子，为了优化输出效果，可以表明行、列序号，方便查找。另外，还可以在棋盘前面加上"------扫雷游戏------"这样的标头，整洁且直观。
代码：（game.c）

void PrintBoard(char board[ROWS][COLS], int row, int col)
{
    int i = 0, j = 0;
    printf("------扫雷游戏------\n");
    for (i = 0; i <= col; i++)//第一行，列标（‘0’用于空出第一列行标）
    {
        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");
    }
}

（6）布置地雷SetMine函数

三个形参：字符型二维数组，行，列
设计思路：

1.设置地雷个数，现在头文件中宏定义，再在.c文件中定义、初始化一个变量
game.h中#define Mine_Number 10
game.c中int number = Mine_Number;
2.while循环中布置雷，每布置一个，number–，减到零结束循环。
3.制造随机位置：
行列坐标x、y都是随机且独立的（1-9），对随机数函数rand函数进行如下操作，先除以9取余（rand（）%9），这样得到的余数是0-8，再加1（rand（）%9+1），得到1-9的随机数。（函数中，我们对row和col进行取余）
4.布置雷，若随机坐标没有雷，就埋一个雷。

代码（game.h）

#define Mine_Number 10

代码（game.c）

void SetMine(char board[ROWS][COLS], int row, int col)
{
    int number = Mine_Number;
    while(number)
    {
        int x = rand() % row + 1;
        int y = rand() % col + 1;
        if(board[x][y] == '0')
        {
            board[x][y] = '1';
            number--;
        }
    }
}

（7）周围雷个数MineCount函数

三个形参：字符型二维数组，行坐标，列坐标
设计思路：通过双重for循环和if语句，对目标坐标为中心的九宫格进行统计，每有一个雷，变量number++。
注意这是一个int类型函数，最后要返回int类型值number。
代码：（game.c）

int MineCount(char mine[ROWS][COLS], int x, int y)
{
    int number = 0;
    for(int i = x-1; i <= x+1; i++)
    {
        for(int j = y-1; j <= y+1; j++)
        {
            if(mine[i][j] == '1')
                number++;
        }
    }
    return number;
}

（8）排查雷FindMine函数

四个形参：两个字符型二维数组，行，列
设计思路：

1.定义三个变量，x（行坐标），y（列坐标），win（记录已排查数）
2.while循环，保证玩家排查出所有非雷区域后，显示游戏成功，正常退出。
3.玩家输入坐标，判断坐标合法性，若是雷，游戏结束，跳出循环；若不是雷，显示雷个数，继续排查。若坐标非法，让玩家重新输入。循环结束后，判断是成功。
4.需要调用SetMine函数。

代码：（game.c）

void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{
    int x = 0;//行坐标
    int y = 0;//列坐标
    int win = 0;//记录已排查数
    while (win < row*col - Mine_Number)
    {
        printf("请输入要排查的坐标:>");
        scanf("%d %d", &x, &y);
        if(x >= 1 && x <= row && y >= 1 && y <= col)
        {
            if(mine[x][y] == '1')
            {
                printf("嘿嘿嘿，你被炸死了\n");
                PrintBoard(mine, ROW, COL);
                break;
            }
            else
            {
                int count = MineCount(mine, x, y);
                show[x][y] = count + '0';//将个数（整型数字）转换为字符
                PrintBoard(show, ROW, COL);//展示当前状况
                win++;
            }
        }
        else
        {
            PrintBoard(show, ROW, COL);       
            printf("输入坐标错误,请重新输入\n");
        }
    }
    if(win == row*col - Mine_Number)
    {
        printf("666,排雷成功\n");
        PrintBoard(mine, ROW, COL);
    }
}

（9）头文件中函数声明

再头文件game.h中对minesweeper.c需要调用的函数进行声明。
代码：（game.h）

void InitBoard(char board[ROWS][COLS], int rows, int cols, char mark);//初始化
void PrintBoard(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);//扫雷

全部代码（基础版)

game.h

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define EASY_COUNT 10
#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);
//打印棋盘
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);

game.c

#include "game.h"
void InitBoard(char board[ROWS][COLS], int rows, int cols, char set)
{
	 int i = 0;
	 for (i = 0; i < rows; i++)
	 {
	 	int j = 0;
	 	for (j = 0; j < cols; j++)
	 {
	 	board[i][j] = set;
	 }
	 }
}
void DisplayBoard(char board[ROWS][COLS], int row, int col)
{
	 int i = 0;
	 printf("--------扫雷游戏-------\n");
	 for (i = 0; i <= col; i++)
	 {
	 	printf("%d ", i);
	 }
	 printf("\n");
	 for (i = 1; i <= row; i++)
	 {
		 printf("%d ", i);
		 int j = 0;
		 for (j = 1; j <= col; j++)
		 {
		 	printf("%c ", board[i][j]);
		 }
		 printf("\n");
	 }
}
void SetMine(char board[ROWS][COLS], int row, int col)
{
	 //布置10个雷
	 //⽣成随机的坐标，布置雷
	 int count = EASY_COUNT;
	 while (count)
	 {
		 int x = rand() % row + 1;
		 int y = rand() % col + 1;
		 if (board[x][y] == '0')
		 {
			 board[x][y] = '1';
			 count--;
		 }
	 }
}
int GetMineCount(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');//数大了这样麻烦 可以用双层for循环
}
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col)
{
	 int x = 0;
	 int y = 0;
	 int win = 0;
	 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
			 {
				 //该位置不是雷，就统计这个坐标周围有⼏个雷
				 int count = GetMineCount(mine, x, y);
				 show[x][y] = count + '0';
				 DisplayBoard(show, ROW, COL);
				 win++;
			 }
		 }
		 else
		 	printf("坐标⾮法，重新输⼊\n");
	 }
	 if (win == row * col - EASY_COUNT)
	 {
		 printf("恭喜你，排雷成功\n");
		 DisplayBoard(mine, ROW, COL);
	 }
}

test.c

#include "game.h"
void menu()
{
	 printf("***********************\n");
	 printf("***** 1. play *****\n");
	 printf("***** 0. exit *****\n");
	 printf("***********************\n");
}
void game()
{
	 char mine[ROWS][COLS];//存放布置好的雷
	 char show[ROWS][COLS];//存放排查出的雷的信息
	 //初始化棋盘
	 //1. mine数组最开始是全'0'
	 //2. show数组最开始是全'*'
	 InitBoard(mine, ROWS, COLS, '0');
	 InitBoard(show, ROWS, COLS, '*');
	 //打印棋盘
	 //DisplayBoard(mine, ROW, COL);
	 DisplayBoard(show, ROW, COL);
	 //1. 布置雷
	 SetMine(mine, ROW, COL);
	 //DisplayBoard(mine, ROW, COL);
	 //2. 排查雷
	 FindMine(mine, show, ROW, COL);
}
int main()
{
	 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);
	 return 0;
}

3. 扫雷游戏的扩展

• 是否可以选择游戏难度
◦ 简单 9 * 9 棋盘，10个雷
◦ 中等 16 * 16棋盘，40个雷
◦ 困难 30 * 16棋盘，99个雷
• 如果排查位置不是雷，周围也没有雷，可以展开周围的一片
• 是否可以标记雷
• 是否可以加上排雷的时间显示

在线扫雷游戏: http://www.minesweeper.cn/