C语言实现扫雷代码

下面是“C语言实现扫雷代码”的完整攻略：

1. 设计数据结构

在扫雷游戏中，我们需要用到以下数据结构：

1.1 格子（Cell）

每一个格子有一个横坐标、一个纵坐标，以及一个当前状态（未打开、已标记、已揭开）和一个值（0 - 8代表周围8个格子中地雷的数量，9代表该格子本身就是地雷）。

struct Cell {
    int x; // 横坐标
    int y; // 纵坐标
    int status; // 当前状态（0 - 未打开，1 - 已标记，2 - 已揭开）
    int value; // 格子的值（0 - 8代表周围8个格子中地雷的数量，9代表该格子本身就是地雷）
};

1.2 游戏面板（Board）

游戏面板由若干个格子组成，可以通过二维数组来表示。

struct Board {
    int width; // 面板宽度
    int height; // 面板高度
    int numMines; // 地雷数量
    int numMarked; // 标记数量
    int numOpened; // 揭开数量
    struct Cell cells[MAX_WIDTH][MAX_HEIGHT]; // 面板格子
};

2. 游戏初始化

在游戏开始时，需要进行以下初始化操作：

2.1 初始化游戏面板（函数名：initBoard）

初始化游戏面板，包括设置面板宽度、高度、地雷数量，以及调用函数生成地雷。

void initBoard(struct Board* board, int width, int height, int numMines) {
    board->width = width;
    board->height = height;
    board->numMines = numMines;
    board->numMarked = 0;
    board->numOpened = 0;
    initCells(board);

    // 生成地雷
    generateMines(board);
}

2.2 初始化格子（函数名：initCells）

初始化所有的格子，包括格子的横纵坐标、当前状态和值。

void initCells(struct Board* board) {
    int x, y;
    for (x = 0; x < board->width; x++) {
        for (y = 0; y < board->height; y++) {
            struct Cell* cell = &board->cells[x][y];
            cell->x = x;
            cell->y = y;
            cell->status = UNOPENED;
            cell->value = 0;
        }
    }
}

2.3 生成地雷（函数名：generateMines）

随机生成指定数量的地雷，并在对应的格子上将value设为9。

void generateMines(struct Board* board) {
    int numMines = board->numMines;
    int count = 0;
    while (count < numMines) {
        int x = rand() % board->width;
        int y = rand() % board->height;
        struct Cell* cell = &board->cells[x][y];
        if (cell->value != CELL_MINE) { // 避免重复
            cell->value = CELL_MINE;
            count++;
        }
    }

    // 更新周围格子的值
    updateAllValues(board);
}

2.4 更新周围格子的值（函数名：updateAllValues）

根据当前格子是不是地雷，更新周围格子的value（周围8个格子中地雷的数量）。

void updateAllValues(struct Board* board) {
    int x, y;
    for (x = 0; x < board->width; x++) {
        for (y = 0; y < board->height; y++) {
            struct Cell* cell = &board->cells[x][y];
            if (cell->value == CELL_MINE) {
                updateAroundValues(board, x, y, 1);
            }
        }
    }
}

2.5 更新某个格子周围格子的值（函数名：updateAroundValues）

根据传入的坐标，更新周围8个格子的value（周围8个格子中地雷的数量）。

void updateAroundValues(struct Board* board, int x, int y, int count) {
    int i, j;
    for (i = x - 1; i <= x + 1; i++) {
        for (j = y - 1; j <= y + 1; j++) {
            if (i >= 0 && i < board->width && j >= 0 && j < board->height) {
                struct Cell* cell = &board->cells[i][j];
                if (cell->value != CELL_MINE) {
                    cell->value += count;
                }
            }
        }
    }
}

3. 游戏逻辑

3.1 执行操作（函数名：doAction）

在游戏中，玩家可以选择标记格子、揭开格子或者还原游戏到初始状态。具体实现步骤如下：

void doAction(struct Board* board, int action, int x, int y) {
    struct Cell* cell = &board->cells[x][y];
    switch (action) {
        case ACTION_MARK: // 标记格子
            if (cell->status == UNOPENED && board->numMarked < board->numMines) {
                cell->status = MARKED;
                board->numMarked++;
            }
            break;
        case ACTION_OPEN: // 揭开格子
            openCell(board, cell);
            break;
        case ACTION_RESTART: // 还原游戏到初始状态
            initBoard(board, board->width, board->height, board->numMines);
            break;
        default:
            break;
    }

    if (board->numMarked == board->numMines) { // 游戏胜利
        printf("Congratulations! You won!\n");
    }
}

3.2 揭开格子（函数名：openCell）

如果该格子已经被揭开或者被标记，则不做任何操作。否则，根据格子的value的值来决定：

如果该格子本身就是地雷，则游戏结束。
如果该格子周围没有地雷，则递归揭开周围8个格子。
如果该格子周围有地雷，则将该格子的状态设置为已揭开，并显示value的值。

void openCell(struct Board* board, struct Cell* cell) {
    if (cell->status == UNOPENED) {
        if (cell->value == CELL_MINE) { // 游戏结束
            printf("Oops! You hit the mine!\n");
            exit(0);
        } else if (cell->value == CELL_EMPTY) { // 递归揭开周围的格子
            cell->status = OPENED;
            board->numOpened++;
            int i, j;
            for (i = cell->x - 1; i <= cell->x + 1; i++) {
                for (j = cell->y - 1; j <= cell->y + 1; j++) {
                    if (i >= 0 && i < board->width && j >= 0 && j < board->height) {
                        struct Cell* aroundCell = &board->cells[i][j];
                        openCell(board, aroundCell);
                    }
                }
            }
        } else { // 显示value的值
            cell->status = OPENED;
            board->numOpened++;
        }
    }
}

示例说明

示例 1

假设有一张5X5的扫雷游戏面板，其中包含3个地雷。我们可以使用如下代码来创建并初始化该面板：

struct Board board;
initBoard(&board, 5, 5, 3);

接着，我们可以选择揭开一个格子:

doAction(&board, ACTION_OPEN, 1, 2);

这个格子周围没有地雷，因此它的值为0，我们会看到它周围的8个格子都被递归揭开。

接下来，我们可以选择标记一个格子：

doAction(&board, ACTION_MARK, 2, 3);

这个格子被标记为已标记，它旁边还有2个地雷没有被标记。

最后，我们可以将游戏还原到初始状态：

doAction(&board, ACTION_RESTART, 0, 0);

示例 2

假设有一张8X8的扫雷游戏面板，其中包含10个地雷。我们可以使用如下代码来创建并初始化该面板：

struct Board board;
initBoard(&board, 8, 8, 10);

接着，我们可以选择揭开一个格子：

doAction(&board, ACTION_OPEN, 2, 4);

这个格子周围有1个地雷，因此它的值为1，我们会看到它的状态变为已揭开，并显示数字1。