怎么使用C語言代碼實現掃雷游戲

怎么使用C語言代碼實現掃雷游戲

目錄

1. 引言
2. 掃雷游戲的基本規則
3. 項目結構設計
4. 數據結構設計
5. 核心功能實現
   • 初始化游戲
   • 生成雷區
   • 計算周圍雷數
   • 顯示游戲界面
   • 處理玩家輸入
   • 遞歸展開空白區域
   • 判斷游戲勝利
6. 完整代碼實現
7. 測試與調試
8. 優化與擴展
9. 總結

引言

掃雷游戲是一款經典的益智游戲，最早由微軟在1990年代推出。游戲的目標是在不觸雷的情況下，揭開所有非雷的方塊。本文將詳細介紹如何使用C語言實現一個簡單的掃雷游戲，涵蓋從數據結構設計到核心功能實現的完整過程。

掃雷游戲的基本規則

1. 游戲界面：游戲界面通常是一個矩形網格，每個格子可以是雷或非雷。
2. 雷的數量：游戲開始時，雷的數量是固定的，隨機分布在網格中。
3. 玩家操作：玩家可以點擊某個格子，如果該格子是雷，則游戲結束；如果是非雷，則顯示周圍8個格子中雷的數量。
4. 勝利條件：當所有非雷的格子都被揭開時，玩家獲勝。

項目結構設計

在開始編寫代碼之前，我們需要設計項目的結構。一個典型的掃雷游戲可以分為以下幾個模塊：

1. 游戲初始化：初始化游戲界面，生成雷區。
2. 游戲邏輯：處理玩家輸入，更新游戲狀態。
3. 界面顯示：顯示當前游戲狀態。
4. 游戲結束判斷：判斷游戲是否結束，并顯示結果。

數據結構設計

為了實現掃雷游戲，我們需要設計合適的數據結構來存儲游戲狀態。以下是我們將使用的主要數據結構：

#define ROWS 10
#define COLS 10
#define MINES 10

typedef struct {
    int is_mine;        // 是否是雷
    int is_revealed;    // 是否被揭開
    int is_flagged;     // 是否被標記
    int adjacent_mines; // 周圍雷的數量
} Cell;

Cell board[ROWS][COLS];

• is_mine：表示該格子是否是雷。
• is_revealed：表示該格子是否被揭開。
• is_flagged：表示該格子是否被標記為雷。
• adjacent_mines：表示該格子周圍8個格子中雷的數量。

核心功能實現

初始化游戲

在游戲開始時，我們需要初始化游戲界面，生成雷區。以下是初始化游戲的代碼：

void initialize_game() {
    // 初始化所有格子
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            board[i][j].is_mine = 0;
            board[i][j].is_revealed = 0;
            board[i][j].is_flagged = 0;
            board[i][j].adjacent_mines = 0;
        }
    }

    // 隨機生成雷
    int mines_placed = 0;
    while (mines_placed < MINES) {
        int x = rand() % ROWS;
        int y = rand() % COLS;
        if (!board[x][y].is_mine) {
            board[x][y].is_mine = 1;
            mines_placed++;
        }
    }

    // 計算每個格子周圍的雷數
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            if (!board[i][j].is_mine) {
                board[i][j].adjacent_mines = count_adjacent_mines(i, j);
            }
        }
    }
}

生成雷區

在初始化游戲時，我們需要隨機生成雷區。以下是生成雷區的代碼：

void place_mines() {
    int mines_placed = 0;
    while (mines_placed < MINES) {
        int x = rand() % ROWS;
        int y = rand() % COLS;
        if (!board[x][y].is_mine) {
            board[x][y].is_mine = 1;
            mines_placed++;
        }
    }
}

計算周圍雷數

在生成雷區后，我們需要計算每個格子周圍8個格子中雷的數量。以下是計算周圍雷數的代碼：

int count_adjacent_mines(int x, int y) {
    int count = 0;
    for (int i = -1; i <= 1; i++) {
        for (int j = -1; j <= 1; j++) {
            int new_x = x + i;
            int new_y = y + j;
            if (new_x >= 0 && new_x < ROWS && new_y >= 0 && new_y < COLS && board[new_x][new_y].is_mine) {
                count++;
            }
        }
    }
    return count;
}

顯示游戲界面

在游戲過程中，我們需要顯示當前游戲狀態。以下是顯示游戲界面的代碼：

void display_board() {
    printf("  ");
    for (int j = 0; j < COLS; j++) {
        printf("%d ", j);
    }
    printf("\n");

    for (int i = 0; i < ROWS; i++) {
        printf("%d ", i);
        for (int j = 0; j < COLS; j++) {
            if (board[i][j].is_revealed) {
                if (board[i][j].is_mine) {
                    printf("* ");
                } else {
                    printf("%d ", board[i][j].adjacent_mines);
                }
            } else if (board[i][j].is_flagged) {
                printf("F ");
            } else {
                printf(". ");
            }
        }
        printf("\n");
    }
}

處理玩家輸入

在游戲過程中，玩家可以輸入坐標來揭開格子或標記雷。以下是處理玩家輸入的代碼：

void process_input() {
    int x, y;
    char action;
    printf("Enter action (r to reveal, f to flag) and coordinates (x y): ");
    scanf(" %c %d %d", &action, &x, &y);

    if (x < 0 || x >= ROWS || y < 0 || y >= COLS) {
        printf("Invalid coordinates!\n");
        return;
    }

    if (action == 'r') {
        if (board[x][y].is_mine) {
            printf("Game Over! You hit a mine.\n");
            exit(0);
        } else {
            reveal_cell(x, y);
        }
    } else if (action == 'f') {
        board[x][y].is_flagged = !board[x][y].is_flagged;
    } else {
        printf("Invalid action!\n");
    }
}

遞歸展開空白區域

當玩家揭開一個空白格子時，我們需要遞歸展開所有相鄰的空白格子。以下是遞歸展開空白區域的代碼：

void reveal_cell(int x, int y) {
    if (x < 0 || x >= ROWS || y < 0 || y >= COLS || board[x][y].is_revealed) {
        return;
    }

    board[x][y].is_revealed = 1;

    if (board[x][y].adjacent_mines == 0) {
        for (int i = -1; i <= 1; i++) {
            for (int j = -1; j <= 1; j++) {
                reveal_cell(x + i, y + j);
            }
        }
    }
}

判斷游戲勝利

當所有非雷的格子都被揭開時，玩家獲勝。以下是判斷游戲勝利的代碼：

int check_win() {
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            if (!board[i][j].is_mine && !board[i][j].is_revealed) {
                return 0;
            }
        }
    }
    return 1;
}

完整代碼實現

以下是完整的掃雷游戲代碼實現：

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

#define ROWS 10
#define COLS 10
#define MINES 10

typedef struct {
    int is_mine;
    int is_revealed;
    int is_flagged;
    int adjacent_mines;
} Cell;

Cell board[ROWS][COLS];

void initialize_game() {
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            board[i][j].is_mine = 0;
            board[i][j].is_revealed = 0;
            board[i][j].is_flagged = 0;
            board[i][j].adjacent_mines = 0;
        }
    }

    int mines_placed = 0;
    while (mines_placed < MINES) {
        int x = rand() % ROWS;
        int y = rand() % COLS;
        if (!board[x][y].is_mine) {
            board[x][y].is_mine = 1;
            mines_placed++;
        }
    }

    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            if (!board[i][j].is_mine) {
                board[i][j].adjacent_mines = count_adjacent_mines(i, j);
            }
        }
    }
}

int count_adjacent_mines(int x, int y) {
    int count = 0;
    for (int i = -1; i <= 1; i++) {
        for (int j = -1; j <= 1; j++) {
            int new_x = x + i;
            int new_y = y + j;
            if (new_x >= 0 && new_x < ROWS && new_y >= 0 && new_y < COLS && board[new_x][new_y].is_mine) {
                count++;
            }
        }
    }
    return count;
}

void display_board() {
    printf("  ");
    for (int j = 0; j < COLS; j++) {
        printf("%d ", j);
    }
    printf("\n");

    for (int i = 0; i < ROWS; i++) {
        printf("%d ", i);
        for (int j = 0; j < COLS; j++) {
            if (board[i][j].is_revealed) {
                if (board[i][j].is_mine) {
                    printf("* ");
                } else {
                    printf("%d ", board[i][j].adjacent_mines);
                }
            } else if (board[i][j].is_flagged) {
                printf("F ");
            } else {
                printf(". ");
            }
        }
        printf("\n");
    }
}

void process_input() {
    int x, y;
    char action;
    printf("Enter action (r to reveal, f to flag) and coordinates (x y): ");
    scanf(" %c %d %d", &action, &x, &y);

    if (x < 0 || x >= ROWS || y < 0 || y >= COLS) {
        printf("Invalid coordinates!\n");
        return;
    }

    if (action == 'r') {
        if (board[x][y].is_mine) {
            printf("Game Over! You hit a mine.\n");
            exit(0);
        } else {
            reveal_cell(x, y);
        }
    } else if (action == 'f') {
        board[x][y].is_flagged = !board[x][y].is_flagged;
    } else {
        printf("Invalid action!\n");
    }
}

void reveal_cell(int x, int y) {
    if (x < 0 || x >= ROWS || y < 0 || y >= COLS || board[x][y].is_revealed) {
        return;
    }

    board[x][y].is_revealed = 1;

    if (board[x][y].adjacent_mines == 0) {
        for (int i = -1; i <= 1; i++) {
            for (int j = -1; j <= 1; j++) {
                reveal_cell(x + i, y + j);
            }
        }
    }
}

int check_win() {
    for (int i = 0; i < ROWS; i++) {
        for (int j = 0; j < COLS; j++) {
            if (!board[i][j].is_mine && !board[i][j].is_revealed) {
                return 0;
            }
        }
    }
    return 1;
}

int main() {
    srand(time(NULL));
    initialize_game();

    while (1) {
        display_board();
        process_input();
        if (check_win()) {
            printf("Congratulations! You won!\n");
            break;
        }
    }

    return 0;
}

測試與調試

在完成代碼編寫后，我們需要對游戲進行測試和調試，以確保其功能的正確性。以下是一些測試用例：

1. 測試雷區生成：確保雷的數量和位置正確。
2. 測試玩家輸入：確保玩家輸入坐標和動作后，游戲狀態正確更新。
3. 測試遞歸展開：確保揭開空白格子時，所有相鄰的空白格子都被正確展開。
4. 測試游戲結束：確保觸雷時游戲結束，并顯示正確的游戲結果。

優化與擴展

在基本功能實現后，我們可以對游戲進行優化和擴展，例如：

1. 增加難度選擇：允許玩家選擇不同的難度級別，調整雷的數量和網格大小。
2. 添加計時器：記錄玩家完成游戲所用的時間。
3. 保存游戲進度：允許玩家保存和加載游戲進度。
4. 圖形界面：使用圖形庫（如SDL）為游戲添加圖形界面。

總結

通過本文的介紹，我們詳細講解了如何使用C語言實現一個簡單的掃雷游戲。從數據結構設計到核心功能實現，我們逐步構建了一個完整的游戲程序。希望本文能幫助你理解掃雷游戲的實現原理，并激發你進一步優化和擴展游戲的興趣。