C++扫雷

当然可以！下面是一个简单的C++扫雷（Minesweeper）游戏示例代码。这个简单的实现包括基本的游戏逻辑。请注意，这只是一个基础示例，可能需要进一步的改进和扩展以适应更复杂的功能需求。

```cpp
#include <iostream>
#include <vector>
#include <cstdlib>
#include <ctime>

using namespace std;

const int WIDTH = 10; // 游戏区域宽度
const int HEIGHT = 10; // 游戏区域高度
const int MINES = 10; // 地雷数量

// 游戏区域状态
enum CellState {
    COVERED,
    UNCOVERED,
    FLAGGED
};

// 游戏单元格结构
struct Cell {
    bool hasMine;
    int adjacentMines;
    CellState state;
};

// 游戏区域类型
typedef vector<vector<Cell>> Board;

// 函数声明
Board createBoard();
void placeMines(Board &board);
void calculateAdjacentMines(Board &board);
void displayBoard(const Board &board, bool revealMines);
bool uncoverCell(Board &board, int x, int y);
bool isGameWon(const Board &board);

int main() {
    srand(time(0)); // 随机数种子
    Board board = createBoard();
    displayBoard(board, false);

    while (true) {
        int x, y;
        cout << "输入坐标 (x y): ";
        cin >> x >> y;

        if (x < 0 || x >= WIDTH || y < 0 || y >= HEIGHT) {
            cout << "坐标无效，请输入有效的坐标。" << endl;
            continue;
        }

        if (!uncoverCell(board, x, y)) {
            cout << "你踩到地雷了！游戏结束！" << endl;
            displayBoard(board, true);
            break;
        }

        displayBoard(board, false);

        if (isGameWon(board)) {
            cout << "恭喜你！你赢了！" << endl;
            break;
        }
    }

    return 0;
}

Board createBoard() {
    Board board(HEIGHT, vector<Cell>(WIDTH));
    placeMines(board);
    calculateAdjacentMines(board);
    return board;
}

void placeMines(Board &board) {
    int minesPlaced = 0;
    while (minesPlaced < MINES) {
        int x = rand() % WIDTH;
        int y = rand() % HEIGHT;
        if (!board[y][x].hasMine) {
            board[y][x].hasMine = true;
            minesPlaced++;
        }
    }
}

void calculateAdjacentMines(Board &board) {
    for (int y = 0; y < HEIGHT; y++) {
        for (int x = 0; x < WIDTH; x++) {
            if (board[y][x].hasMine) {
                for (int dy = -1; dy <= 1; dy++) {
                    for (int dx = -1; dx <= 1; dx++) {
                        if (dx == 0 && dy == 0) continue;
                        int newY = y + dy;
                        int newX = x + dx;
                        if (newY >= 0 && newY < HEIGHT && newX >= 0 && newX < WIDTH) {
                            board[newY][newX].adjacentMines++;
                        }
                    }
                }
            }
        }
    }
}

void displayBoard(const Board &board, bool revealMines) {
    cout << "  ";
    for (int x = 0; x < WIDTH; x++) {
        cout << x << " ";
    }
    cout << endl;

    for (int y = 0; y < HEIGHT; y++) {
        cout << y << " ";
        for (int x = 0; x < WIDTH; x++) {
            if (board[y][x].state == COVERED) {
                cout << ". ";
            } else if (board[y][x].state == FLAGGED) {
                cout << "F ";
            } else {
                if (board[y][x].hasMine && revealMines) {
                    cout << "* ";
                } else {
                    cout << board[y][x].adjacentMines << " ";
                }
            }
        }
        cout << endl;
    }
}

bool uncoverCell(Board &board, int x, int y) {
    if (board[y][x].state != COVERED) {
        return true;
    }
    board[y][x].state = UNCOVERED;

    if (board[y][x].hasMine) {
        return false;
    }
    
    if (board[y][x].adjacentMines == 0) {
        for (int dy = -1; dy <= 1; dy++) {
            for (int dx = -1; dx <= 1; dx++) {
                int newY = y + dy;
                int newX = x + dx;
                if (newY >= 0 && newY < HEIGHT && newX >= 0 && newX < WIDTH) {
                    uncoverCell(board, newX, newY);
                }
            }
        }
    }
    
    return true;
}

bool isGameWon(const Board &board) {
    int uncovered = 0;
    for (const auto &row : board) {
        for (const auto &cell : row) {
            if (cell.state == UNCOVERED && !cell.hasMine) {
                uncovered++;
            }
        }
    }
    return (uncovered + MINES) == (WIDTH * HEIGHT);
}
```

### 代码说明：
- `Board`：一个二维数组表示游戏区域，包含每个单元格的信息。
- `createBoard()`：创建游戏板并放置地雷。
- `placeMines()`：随机放置地雷。
- `calculateAdjacentMines()`：计算每个单元格周围地雷的数量。
- `displayBoard()`：显示当前游戏状态。
- `uncoverCell()`：揭开单元格，如果该单元格为地雷则游戏结束。
- `isGameWon()`：检查游戏是否胜利。

### 使用方式：
1. 将代码复制到你的C++开发环境中。
2. 编译并运行程序。
3. 按照提示输入坐标以揭开单元格。

这个示例非常基础，你可以根据需求添加更多的功能，例如标记地雷、实现更多的游戏规则等。希望这对你有帮助！
这条消息由Nova生成 - 免费下载:
https://novaappai.page.link/TiauXquhHEDcdwx4A