规则先落成清单

控制台程序,菜单能反复开局或退出,棋盘 9×9,随机埋 10 颗雷。输入一个坐标,只有三种结果:

  • 坐标上是雷:炸死,本局结束;
  • 坐标上不是雷:把这一格改成“周围八格有几颗雷”的数字;
  • 除 10 颗雷以外的 71 格全部翻开:排雷成功。

开局界面:上面是菜单,下面 9×9 全是未翻开的星号;表头从 0 印到 9,比可输入的列号多一个 0

菜单、棋盘、提示语,构成一个完整的读-算-写循环。棋盘要能被反复初始化,所以它不能是全局数组,得放在每局都重新执行的 game() 里。

一张棋盘装不下两种信息

先看数据。最直接的想法是一张 9×9 数组:1 表示雷,0 表示空。走两步就撞墙。

玩家点开一格,周围有三颗雷,这个“3”往哪写?只能写回同一张表的同一格。于是这一格既可能是“有雷”,也可能是“没雷但周围三颗雷”。同一个字符 '1' 扛着两种互相矛盾的含义:玩家看到 '1' 分不清是雷还是提示,把整张表打出来又等于直接给答案。

拆成两张表,语义就分开了:

char mine[ROWS][COLS];   /* 只记雷:'1' 是雷,'0' 不是 */
char show[ROWS][COLS];   /* 只记玩家看到的东西:'*' 未翻开,数字是提示 */

mine 数组:中间 9×9 里红色的 '1' 是雷,绿色外圈全是 '0',不会参与布雷

两张表都声明成 char,理由在于 show 需要一个“还没查过”的标记,与省内存无关。'*' 天然适合当这个标记:它既不是数字也不是雷,后面判断“这一格翻过没有”全靠它。

show 数组:整片都是 '*',代表一局刚开始、玩家什么都不知道

课件分析部分的 char mine[11][11] = {0}; 只是示意。{0} 会把整张表清成 0 字节,每格是 '\0' 而不是字符 '0';真拿它去数雷,- 8 * '0' 这步会算出负数。实际代码里两张表都在 game() 内声明,由 InitBoard 填 '0' 和 '*'。

外圈一格,换掉八次越界判断

统计周围雷数时,边缘格是麻烦。9×9 的棋盘上排查最下面一行,八个邻居里有三个在当前数组之外:

排查贴底的一格:黄色邻居越过棋盘下边界,下标直接越界

处理办法有三种。数邻居前逐个判断下标是否合法,八个方向写八个 if,代码立刻臃肿;或者把下标夹到 0 到 8,边缘格会把同一行邻居统计两遍,结果是错的;再或者,把数组开大一圈,真正的雷区放在中间的 9×9,外面那层不布雷。

课件选第三种,数组开成 11×11:

扩成 11×11:绿色是保护圈,永远是 '0';中间的 9×9 才是雷区,任意一格的八个邻居都在表内

代价是 121 字节对 81 字节,收益是“角落格和中心格走同一段代码”。保护圈里全是 '0',加进求和式不影响结果,所以连边界判断都省了。

课件在这里有一处坐标不一致。示意图用的是 0 起始的下标,排查 (8,6) 时邻居越界;后面的代码却把有效区写成 1 到 9,同一个 (8,6) 的八个邻居全在 0 到 10 之间,并不会越界。照图上的数字去敲代码里的坐标,会打进保护圈,得到“周围 0 颗雷”的结果。

三个文件各自负责什么

头文件放“形状”和“常数”,源文件放实现,测试文件放流程:

/* 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);

ROWS 和 COLS 外面这对括号不能省。课件写的是 #define ROWS ROW+2,放在 char mine[ROWS][COLS] 里恰好正确,因为数组声明的方括号先结合;一旦有人写 ROWS * COLS,预处理后变成 ROW + 2 * COL + 2,得到 29 而不是 121。宏是纯文本替换,不认识优先级。

二维数组做形参,列数必须写进类型里。char board[ROWS][COLS] 告诉编译器每一行有多宽,board[i][j] 才能算出偏移;写成 char board[][COLS] 也可以,写成 char board[][] 则编不过。实参传进去的是首行地址,函数里拿到的不是一份数组拷贝。

三个文件的分工是:game.h 只放宏、类型和声明;game.c 只放定义,第一行 #include "game.h";test.c 放 menu、game、main,同样包含 game.h。漏掉 game.c 时三个文件各自都能编过,链接阶段才报 unresolved external symbol,MSVC 叫 LNK2019。

棋盘上的四件事

初始化只是把一整片格子填成同一个字符,两张表传不同的 set:

#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("  ");
    for (j = 1; j <= col; 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");
    }
}

打印只走 1 到 9,保护圈不显示。课件表头写的是 for (i = 0; i <= col; i++),会多印一个 0 号列,而输入范围从 1 开始,这个 0 列永远点不到,读起来容易误导。

布雷用 rand 取坐标,只在空格上落子,落满 10 颗为止:

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

rand() % row + 1 把结果压进 1 到 9。落点重复时 if 不成立,循环多转一次,直到 10 颗填满。

数雷用八邻居求和:

static int GetMineCount(char mine[ROWS][COLS], int x, int y)
{
    int i = 0;
    int j = 0;
    int count = 0;
 
    for (i = -1; i <= 1; i++)
    {
        for (j = -1; j <= 1; j++)
        {
            if (i == 0 && j == 0)
            {
                continue;
            }
            count += mine[x + i][y + j] - '0';
        }
    }
    return count;
}

'0' 是 48,'1' 是 49,八个字符加起来再减八个 '0',剩下的就是雷的个数。字符数字的编码连续,这个减法才成立;char 参与算术时会提升成 int,不会出现“字符加字符还是字符”的情况。函数加了 static,因为它只在 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 - EASY_COUNT)
    {
        printf("请输入要排查的坐标:> ");
        if (scanf("%d %d", &x, &y) != 2)
        {
            int ch = 0;
            while ((ch = getchar()) != '\n' && ch != EOF)
            {
                ;
            }
            if (ch == EOF)
            {
                return;
            }
            printf("要输入两个整数\n");
            continue;
        }
 
        if (x < 1 || x > row || y < 1 || y > col)
        {
            printf("坐标非法,重新输入\n");
            continue;
        }
 
        if (show[x][y] != '*')
        {
            printf("这一格已经查过了\n");
            continue;
        }
 
        if (mine[x][y] == '1')
        {
            printf("很遗憾,你被炸死了\n");
            DisplayBoard(mine, row, col);
            return;
        }
 
        {
            int count = GetMineCount(mine, x, y);
            show[x][y] = (char)(count + '0');
            win++;
            DisplayBoard(show, row, col);
        }
    }
 
    printf("恭喜你,排雷成功\n");
    DisplayBoard(mine, row, col);
}

四个分支按顺序处理:输入失败、坐标越界、重复点格、踩雷。前三个都 continue 回到输入,只有翻开的动作会推进 win。翻开那一段单独加了花括号,只为让 count 的作用域收窄,并到函数顶部声明也一样能跑。

胜负条件 win == row * col - EASY_COUNT 就是 71。这个数不是猜的:棋盘 81 格,10 颗雷,剩下的全是安全格。

课件的版本缺了“重复点格”这道检查,win++ 跟着“输入合法且不是雷”走,而不是跟着“这一格从 '*' 变成数字”走:

else
{
    int count = GetMineCount(mine, x, y);
    show[x][y] = count + '0';
    win++;               /* 同一格点第二次,这里照样加一 */
}

反复输入 1 1,第一次翻开,后面每次屏幕不变但计数照涨,71 次之后程序打印“恭喜你,排雷成功”。棋盘一格没多开。

另一种修法是不维护计数器,每轮重新数一遍已经翻开的格子:

int CountRevealed(char show[ROWS][COLS], int row, int col)
{
    int i = 0;
    int j = 0;
    int n = 0;
 
    for (i = 1; i <= row; i++)
    {
        for (j = 1; j <= col; j++)
        {
            if (show[i][j] != '*')
            {
                n++;
            }
        }
    }
    return n;
}

多扫 81 个字节,换来的是“一次操作翻开多少格都不会算错”。这一点在加空白展开时特别关键:一次点击可能揭开一片,任何“一次输入加一”的计数都会失真。

main 里的循环负责让整局可重来:

#include "game.h"
 
static void menu(void)
{
    printf("***********************\n");
    printf("*****   1. play   *****\n");
    printf("*****   0. exit   *****\n");
    printf("***********************\n");
}
 
void game(void)
{
    char mine[ROWS][COLS];
    char show[ROWS][COLS];
 
    InitBoard(mine, ROWS, COLS, '0');
    InitBoard(show, ROWS, COLS, '*');
 
    SetMine(mine, ROW, COL);
    DisplayBoard(show, ROW, COL);
 
    FindMine(mine, show, ROW, COL);
}
 
int main(void)
{
    int input = 0;
 
    srand((unsigned int)time(NULL));
 
    do
    {
        menu();
        printf("请选择:> ");
        if (scanf("%d", &input) != 1)
        {
            int ch = 0;
            while ((ch = getchar()) != '\n' && ch != EOF)
            {
                ;
            }
            input = -1;
        }
 
        switch (input)
        {
        case 1:
            game();
            break;
        case 0:
            printf("退出游戏\n");
            break;
        default:
            printf("选择错误,重新选择\n");
            break;
        }
    } while (input);
 
    return 0;
}

do-while 保证菜单至少出现一次,while (input) 让 0 成为唯一出口,default 兜住所有非法选项。srand 只在 main 调一次:没调 srand 时 rand 等价于 srand(1),每局都从头播同一个种子,雷的位置会一模一样。放在 game() 里反复播种同样不行,两局间隔不到一秒,time(NULL) 返回同一个值。

扩展:难度、空白展开、标记、计时

课件的扩展清单每一条都要动数据结构:

  • 难度选择。9×9/10、16×16/40、30×16/99 三种尺寸,数组得按最大尺寸声明(例如 char mine[18][32]),行列数和雷数改成运行时参数,而不是宏。
  • 空白展开。翻开的格子周围没有雷时,递归揭开相邻的一片;递归前先判 show[x][y] == '*',否则会在两个空格之间来回调用。
  • 标记雷。show 里加一个 '!' 状态,或者另开一张 mark 数组,输入从“两个整数”变成“坐标加动作”。
  • 计时。clock() 取开始和结束的差值,除以 CLOCKS_PER_SEC 就是秒数。
  • 在线版本 http://www.minesweeper.cn/,可以拿来做行为对照。

空白展开会立刻推翻“win++ 一次加一”的假设,这也是前面那个重复点格检查不能省的原因:状态只能由“格子从关到开”这个事件推动,不能由“用户按了一次回车”推动。