C语言实现扫雷——递归展开周围没有雷（realize minesweeping by C - Recursively unfolded if there were no mines around）

 

继续实现 比特C语言视频 中第二个项目实例：扫雷 的升级版本，该版本实现了视频中代码的升级——当周围没有一个雷的时候，递归展开直至有雷

扫雷思路：

1. 初始化存放雷信息的棋盘mine；

2. 初始化存放玩家排查出雷的情况的棋盘show；

3. 随机布置雷的位置；

4. 显示棋盘；

5. 玩家输入坐标排查雷。

 

（1）主代码：test.c 源文件，主要写程序的主要架构

#define _CRT_SECURE_NO_WARNINGS 1
#include "game.h"

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

void game() {
    // 雷的存储信息
    // 1. 存放布置好的雷的信息
    char mine[ROWS][COLS] = { 0 };
    // 2. 存放排查出的雷的信息
    char show[ROWS][COLS] = { 0 };
    // 初始化
    InitBoard(mine, ROWS, COLS, '0');
    InitBoard(show, ROWS, COLS, UserSee);
    // 打印棋盘
    DisplayBoard(show, ROW, COL);
    // 布置雷
    SetMine(mine, ROW, COL);
    DisplayBoard(mine, ROW, COL);
    // 扫雷
    FindMine(mine, show, ROW, COL);
}

void test() {
    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);
}

int main() {
    test();
    return 0;
}

 

（2）game.h 头文件：主要存放和game.c相关的参数以及函数声明

#pragma once 
#include <stdio.h>
#include <stdlib.h>  // 引用srand和rand函数需要
#include <time.h>

#define ROW 9   // 棋盘的行数
#define COL 9   // 棋盘的列数

#define ROWS ROW+2  // 扩展后棋盘的行数（定义这个是为了计算周围8个位置的时候不出边）
#define COLS COL+2  // 扩展后棋盘的列数（定义这个是为了计算周围8个位置的时候不出边）

#define EASY_COUNT 2  // 雷的个数
#define UserSee '*'   // 用户玩游戏的时候可以操作的位置符号

// 初始化棋盘
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);
// 判断游戏是否结束
int if_win(char show[ROWS][COLS], int row, int col);

 

（3）game.c 源文件：主要存放 game() 函数需要调用到的函数

         帮助理解代码的知识   —— 图像的八邻域图 

           

#define _CRT_SECURE_NO_WARNINGS 1
#include "game.h"

// 初始化棋盘信息，把数组中所有值都赋值set。这时传入的要是扩大的rows和cols（初始化需要连扩大的部分一起初始化）
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;
        }
    }
}

// 显示棋盘，这时要传入的是正常的row和col（因为显示用的是正常的尺寸）
void DisplayBoard(char board[ROWS][COLS], int row, int col) {
    int i = 0;
    int j = 0;
    printf("===================================== \n");
    printf("====  ****  =============== **** ==== \n");
    printf("===================================== \n");
    printf("\033[33m共有 %d 个雷\n\033[0m", EASY_COUNT);
    // 打印列号
    for (i = 0;i <= col;i++) {
        printf("\033[36m%d\033[0m ", i);
    }
    printf("\n");
    // 打印行号和每行数据
    for (i = 1;i <= row;i++) {
        printf("\033[36m%d\033[0m ", i);
        for (j = 1;j <= col;j++) {
            printf("%c ", board[i][j]);
        }
        printf("\n");
    }
}

// 把雷通过随机的方式布置在棋盘上，因为布雷的地方是正常的尺寸，不能把雷布在超出正常尺寸的地方，否则玩家看不到
void SetMine(char board[ROWS][COLS], int row, int col) {
    // 指定产生EASY_COUNT个雷，并且位置不重复
    int count = EASY_COUNT;
    while (count)
    {
        int x = rand() % row + 1;  // rand()%row产生的数值是0 ~ row-1, +1之后就可以产生1 ~ row
        int y = rand() % col + 1;  // rand()%col产生的数值是0 ~ col-1, +1之后就可以产生1 ~ col
        if (board[x][y] == '0') {
            board[x][y] = '1';
            count--;
        }
    }
}

// 思路：根据ASCII表可以知道，'0'-'0'= 0（即符号0的ASCII-符号0的ASCII=数字0） 
// 根据ASCII表可以知道，'3' - '0' = 3（即符号3的ASCII - 符号0的ASCII = 数字3）
// 所以这里使用这8个数的ASCII总和减去8个'0'ASCII总和的方法来统计总的雷数，可以保证返回类型是整型
int get_mine_count(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';
}

/*
递归的两个必要条件：
1. 存在限制条件，当满足这个限制条件的时候，递归便不再继续。
2. 每次递归调用之后越来越接近这个限制条件。
*/
// 当玩家点到x,y坐标并且该坐标不是雷，那么就判断该位置是否是可以展开的0的，如果是则通过递归的方法扩展展开，直至没有碰到0为止
// 否则就直接展现数字。写递归一定要注意，一定要给出递归终止的条件。
void get_mine_count_recursion(char board_record[ROWS][COLS], char show[ROWS][COLS], int x, int y) {
    // 如果这个位置的值不是0且等于UserSee（即说明没有显示过），那么show中相应位置就显示它在board_record中的数
    if (board_record[x][y] != '0') {
        if (show[x][y] == UserSee) {
            show[x][y] = board_record[x][y];
        }
    }
    else {  
        // 如果是0，那么show中相应位置先显示0，然后再判断四周8个位置情况
        // 注意，每次的判断一定要加上判断该位置是否等于UserSee（即已经被展开过），如果没有加这条判断，只是在一直判断是否坐标合法，
        // 是否等于0，那么就会陷入死循环中，因为如果四周8个位置已经展开了，那么就算碰到0也不需要再检测
        show[x][y] = '0';
        // 正上方：检测正上方坐标是否合理以及是否没有被检测过，是的或那么就判断该位置是否为'0'，
        // 是的话就继续展开这个正上方这个数的8个位置，否则就直接填上数字
        if (x - 1 >= 1 && x - 1 <= ROW && y >= 1 && y <= COL && show[x - 1][y] == UserSee) {
            if (board_record[x - 1][y] == '0') {
                show[x - 1][y] = '0';
                get_mine_count_recursion(board_record, show, x - 1, y);
            }
            else {
                show[x - 1][y] = board_record[x - 1][y];
            }
        } 
        // 左上角
        if (x - 1 >= 1 && x - 1 <= ROW && y - 1 >= 1 && y - 1 <= COL && show[x - 1][y - 1] == UserSee) {
            if (board_record[x - 1][y - 1] == '0') {
                show[x - 1][y - 1] = '0';
                get_mine_count_recursion(board_record, show, x - 1, y - 1);
            }
            else {
                show[x - 1][y - 1] = board_record[x - 1][y - 1];
            }
        }
        // 正左方
        if (x >= 1 && x <= ROW && y - 1 >= 1 && y - 1 <= COL && show[x][y - 1] == UserSee) {
            if (board_record[x][y - 1] == '0') {
                show[x][y - 1] = '0';
                get_mine_count_recursion(board_record, show, x, y - 1);
            }
            else {
                show[x][y - 1] = board_record[x][y - 1];
            }
        }
        // 左下角
        if (x + 1 >= 1 && x + 1 <= ROW && y - 1 >= 1 && y - 1 <= COL && show[x + 1][y - 1] == UserSee) {
            if (board_record[x + 1][y - 1] == '0') {
                show[x + 1][y - 1] = '0';
                get_mine_count_recursion(board_record, show, x + 1, y - 1);
            }
            else {
                show[x + 1][y - 1] = board_record[x + 1][y - 1];
            }
        }
        // 正下方
        if (x + 1 >= 1 && x + 1 <= ROW && y >= 1 && y <= COL && show[x + 1][y] == UserSee) {
            if (board_record[x + 1][y] == '0') {
                show[x + 1][y] = '0';
                get_mine_count_recursion(board_record, show, x + 1, y);
            }
            else {
                show[x + 1][y] = board_record[x + 1][y];
            }
        }
        // 右下角
        if (x + 1 >= 1 && x + 1 <= ROW && y + 1 >= 1 && y + 1 <= COL && show[x + 1][y + 1] == UserSee) {
            if (board_record[x + 1][y + 1] == '0') {
                show[x + 1][y + 1] = '0';
                get_mine_count_recursion(board_record, show, x + 1, y + 1);
            }
            else {
                show[x + 1][y + 1] = board_record[x + 1][y + 1];
            }
        }
        // 正右方
        if (x >= 1 && x <= ROW && y + 1 >= 1 && y + 1 <= COL && show[x][y + 1] == UserSee) {
            if (board_record[x][y + 1] == '0') {
                show[x][y + 1] = '0';
                get_mine_count_recursion(board_record, show, x, y + 1);
            }
            else {
                show[x][y + 1] = board_record[x][y + 1];
            }
        }
        // 右上角
        if (x - 1 >= 1 && x - 1 <= ROW && y + 1 >= 1 && y + 1 <= COL && show[x - 1][y + 1] == UserSee) {
            if (board_record[x - 1][y + 1] == '0') {
                show[x - 1][y + 1] = '0';
                get_mine_count_recursion(board_record, show, x - 1, y + 1);
            }
            else {
                show[x - 1][y + 1] = board_record[x - 1][y + 1];
            }
        }

    }
}

// 为了判断游戏是否结束，需要统计show中的UserSee的数量，当show中的UserSee的数量等于雷数时，就说明游戏结束，玩家赢
int if_win(char show[ROWS][COLS], int row, int col) {
    int i = 0;
    int j = 0;
    int count = 0;
    for (i = 1;i <= row;i++) {
        for (j = 1;j <= col;j++) {
            if (show[i][j] == UserSee) {
                count++;
            }
        }
    }
    return count;
}

// 玩家寻找雷
void FindMine(char mine[ROWS][COLS], char show[ROWS][COLS], int row, int col) {
    int i = 0;
    int j = 0;
    // 先记录下每个在正常范围内的棋子周围含有的雷数
    char board_record[ROWS][COLS] = { '0' };
    for (i = 1;i <= row;i++) {
        for (j = 1;j <= col;j++) {
            if (mine[i][j] != '1') {
                board_record[i][j] = get_mine_count(mine, i, j) + '0';  // 数字变成字符
            }
            else {
                board_record[i][j] = UserSee;
            }
        }
    }
    DisplayBoard(board_record, row, col);
    int x = 0;
    int y = 0;
    int count = EASY_COUNT + 1;
    while (count != EASY_COUNT) {
        printf("请输入排查雷的坐标： > ");
        scanf("%d%d", &x, &y);
        if (x >= 1 && x <= row && y >= 1 && y <= col) {
            // 坐标合法
            // 1. 踩雷
            if (mine[x][y] == '1') {
                printf("很遗憾，你被炸死了\n");
                DisplayBoard(mine, row, col);
                break;
            }
            else // 不是雷
            {
                // 递归计算x,y坐标周围有几个雷
                get_mine_count_recursion(board_record, show, x, y);
                DisplayBoard(show, row, col);
            }
            // 判断玩家是否赢，或游戏是否结束
            count = if_win(show, ROW, COL);
            printf("\n count=%d \n", count);
        }
        else {
            printf("输入坐标非法，请重新输入！\n");
        }
    }
    // 如果UserSee的数量等于雷数，那么就说明玩家赢了，游戏结束
    if (count == EASY_COUNT) {
        printf("恭喜你，排雷成功 \n");
        DisplayBoard(mine, row, col);
    }
}

由以上三个文件就可以实现以下效果：

若有任何问题，欢迎批评和指正~