C语言实现简易扫雷游戏详解

简介

扫雷游戏是一款非常经典的游戏，最初由微软公司开发。本文将讲解如何使用C语言实现简易版本的扫雷游戏，并给出详细代码及解析。如果你想自己实现一个类似的游戏，本文会帮助你入门。

准备工作

在开始之前，我们需要安装一个C语言编译器。在本文中，我将使用Dev-C++编写代码。你也可以使用其他C语言编译器。

游戏规则

扫雷游戏通常是在一个方格棋盘上进行的，每个单元格可以是地雷或数字。玩家的目的是找出所有非地雷的单元格，避免踩中地雷。

在游戏开始时，玩家需要选择一个难度级别。每个难度级别都具有不同数量的单元格和地雷。一旦选择一个难度级别，游戏板就会被初始化，并在每个非地雷单元格周围显示数字，表示周围八个单元格中地雷的数量。如果没有地雷在这八个单元格中，则该数字将为零。

玩家可以使用鼠标或键盘来翻转单元格。如果玩家选择的单元格是地雷，则游戏结束。否则，游戏会继续进行，直到找出所有非地雷的单元格。如果成功找到所有非地雷的单元格，则游戏过关。

实现思路

实现扫雷游戏需要掌握以下几个基本原理：

• 数组：使用二维数组来表示游戏板。
• 随机数：使用随机数生成地雷。
• 函数：使用函数实现游戏逻辑。
• 循环：游戏需要进行循环，直到找到所有非地雷的单元格。

下面是一个简单的实现思路，供参考：

1. 声明并初始化二维数组，用于存储游戏板。
2. 生成随机地雷，并将其放入游戏板中。
3. 遍历游戏板的每个单元格，计算并在该单元格周围显示数字。
4. 根据玩家选择的单元格进行判断，如果是地雷则游戏结束，否则继续翻转单元格，直到找出所有非地雷的单元格。

代码实现

下面是一个简单的代码实现示例，可以完成初级难度的扫雷游戏。代码中包含了详细的注释，方便读者理解。

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <time.h>

#define ROW 9       // 游戏板行数
#define COL 9       // 游戏板列数
#define MINE_COUNT 10   // 地雷数量

// 游戏板单元格结构体
typedef struct {
    bool is_mine;       // 是否为地雷
    bool is_revealed;   // 是否已翻转
    int num_adj_mines;  // 相邻地雷数量
} cell_t;

// 初始化游戏板
void init_board(cell_t board[][COL]) {
    // 设置所有单元格都不是地雷
    for(int i=0; i<ROW; i++) {
        for(int j=0; j<COL; j++) {
            board[i][j].is_mine = false;
            board[i][j].is_revealed = false;
            board[i][j].num_adj_mines = 0;
        }
    }

    // 随机添加地雷
    int mine_count = MINE_COUNT;
    while(mine_count > 0) {
        int rand_num = rand() % (ROW * COL);
        int rand_row = rand_num / COL;
        int rand_col = rand_num % COL;
        if (!board[rand_row][rand_col].is_mine) {
            board[rand_row][rand_col].is_mine = true;
            mine_count--;
        }
    }

    // 计算每个单元格周围地雷数量
    for(int i=0; i<ROW; i++) {
        for(int j=0; j<COL; j++) {
            if (board[i][j].is_mine) {
                continue;   // 跳过地雷单元格
            }

            // 遍历周围八个单元格
            for(int ii=(i-1); ii<=(i+1); ii++) {
                for(int jj=(j-1); jj<=(j+1); jj++) {
                    // 检查单元格是否存在
                    if(ii>=0 && jj>=0 && ii<ROW && jj<COL) {
                        // 如果周围单元格是地雷，则增加数量
                        if(board[ii][jj].is_mine) {
                            board[i][j].num_adj_mines++;
                        }
                    }
                }
            }
        }
    }
}

// 显示游戏板
void print_board(cell_t board[][COL]) {
    // 显示列号
    printf("  ");
    for(int j=0; j<COL; j++) {
        printf("%d ", j+1);
    }

    // 显示分隔线
    printf("\n");
    printf(" +-");
    for(int j=0; j<COL; j++) {
        printf("--");
    }
    printf("\n");

    // 显示游戏板内容
    for(int i=0; i<ROW; i++) {
        printf("%c| ", i+'A');
        for(int j=0; j<COL; j++) {
            // 如果单元格未翻转，显示占位符
            if (!board[i][j].is_revealed) {
                printf("# ");
            } 
            // 如果单元格是地雷，显示地雷符号
            else if (board[i][j].is_mine) {
                printf("* ");
            }
            // 否则，显示周围地雷数量
            else {
                printf("%d ", board[i][j].num_adj_mines);
            }
        }
        printf("\n");
    }
}

// 翻转单元格
bool reveal_cell(cell_t board[][COL], int row, int col) {
    // 如果单元格已翻转，直接返回
    if (board[row][col].is_revealed) {
        printf("Cell %c%d has already been revealed!\n", row+'A', col+1);
        return true;
    }

    // 如果单元格是地雷，游戏结束
    if (board[row][col].is_mine) {
        printf("BOOM! You hit a mine.\n");
        return false;
    }

    // 翻转单元格，显示周围地雷数量
    board[row][col].is_revealed = true;
    printf("Cell %c%d contained %d adjacent mines.\n", row+'A', col+1, board[row][col].num_adj_mines);

    // 如果周围不存在地雷，则递归翻转周围八个单元格
    if (board[row][col].num_adj_mines == 0) {
        for(int ii=(row-1); ii<=(row+1); ii++) {
            for(int jj=(col-1); jj<=(col+1); jj++) {
                // 检查单元格是否存在
                if(ii>=0 && jj>=0 && ii<ROW && jj<COL) {
                    // 递归翻转相邻的单元格
                    reveal_cell(board, ii, jj);
                }
            }
        }
    }

    return true;
}

int main() {
    // 设置随机数生成器种子
    srand(time(NULL));

    // 初始化游戏板
    cell_t board[ROW][COL];
    init_board(board);
    print_board(board);

    // 进行游戏循环，直到所有非地雷单元格都被翻转
    while(true) {
        // 获取玩家输入
        char input[256];
        printf("Enter cell (row, col) to reveal (e.g. 'A4'):\n");
        fgets(input, sizeof(input), stdin);

        // 提取行列坐标
        int row = input[0] - 'A';
        int col = atoi(&input[1]) - 1;

        // 翻转单元格
        bool success = reveal_cell(board, row, col);

        // 显示游戏板
        print_board(board);

        // 判断游戏是否结束
        if (!success) {
            printf("Game over!\n");
            break;
        }
    }

    return 0;
}

示例说明

示例1：随机添加地雷

代码中通过while循环随机生成地雷的行列坐标，并通过board[rand_row][rand_col].is_mine = true;添加地雷。下面是代码段：

// 随机添加地雷
int mine_count = MINE_COUNT;
while(mine_count > 0) {
    int rand_num = rand() % (ROW * COL);
    int rand_row = rand_num / COL;
    int rand_col = rand_num % COL;
    if (!board[rand_row][rand_col].is_mine) {
        board[rand_row][rand_col].is_mine = true;
        mine_count--;
    }
}

示例2：递归翻转周围单元格

代码中通过递归翻转周围单元格实现展开。如果周围单元格不存在地雷，则继续递归翻转周围八个单元格，直到找到周围有地雷的单元格为止。下面是代码段：

// 如果周围不存在地雷，则递归翻转周围八个单元格
if (board[row][col].num_adj_mines == 0) {
    for(int ii=(row-1); ii<=(row+1); ii++) {
        for(int jj=(col-1); jj<=(col+1); jj++) {
            // 检查单元格是否存在
            if(ii>=0 && jj>=0 && ii<ROW && jj<COL) {
                // 递归翻转相邻的单元格
                reveal_cell(board, ii, jj);
            }
        }
    }
}