用java写一个扫雷小游戏

好的，下面是一个简单的扫雷游戏实现。

先定义一些变量：

int[][] board; // 存储雷区信息的二维数组，0表示无雷，-1表示有雷，其它数字表示周围雷数
int[][] mask; // 存储已翻开方块的信息，0表示未翻开，1表示已翻开，2表示标记为雷
int rows, cols; // 行数和列数
int mines; // 雷数
int openedCount; // 已翻开的方块数
boolean gameOver; // 游戏是否结束

然后是初始化函数，用于创建雷区和掩码：

// 初始化函数，参数为行数、列数和雷数
public void init(int rows, int cols, int mines) {
    this.rows = rows;
    this.cols = cols;
    this.mines = mines;
    this.openedCount = 0;
    this.gameOver = false;

    // 创建雷区和掩码数组
    board = new int[rows][cols];
    mask = new int[rows][cols];

    // 随机放置雷
    Random rand = new Random();
    int count = 0;
    while (count < mines) {
        int r = rand.nextInt(rows);
        int c = rand.nextInt(cols);
        if (board[r][c] != -1) {
            board[r][c] = -1;
            count++;
        }
    }

    // 计算每个方块周围的雷数
    for (int r = 0; r < rows; r++) {
        for (int c = 0; c < cols; c++) {
            if (board[r][c] != -1) {
                int count = 0;
                for (int dr = -1; dr <= 1; dr++) {
                    for (int dc = -1; dc <= 1; dc++) {
                        if (r+dr >= 0 && r+dr < rows && c+dc >= 0 && c+dc < cols && board[r+dr][c+dc] == -1) {
                            count++;
                        }
                    }
                }
                board[r][c] = count;
            }
        }
    }

    // 将掩码数组全部设置为未翻开状态
    for (int r = 0; r < rows; r++) {
        for (int c = 0; c < cols; c++) {
            mask[r][c] = 0;
        }
    }
}

接下来是翻开方块的函数，递归实现：

// 翻开指定位置的方块，返回true表示翻开成功，false表示该位置已经翻开或标记为雷
public boolean open(int r, int c) {
    if (gameOver || mask[r][c] != 0) {
        return false;
    }
    mask[r][c] = 1;
    openedCount++;
    if (board[r][c] == -1) {
        gameOver = true;
        return true;
    } else if (board[r][c] == 0) {
        for (int dr = -1; dr <= 1; dr++) {
            for (int dc = -1; dc <= 1; dc++) {
                if (r+dr >= 0 && r+dr < rows && c+dc >= 0 && c+dc < cols) {
                    open(r+dr, c+dc);
                }
            }
        }
        return true;
    } else {
        return true;
    }
}

标记为雷的函数：

// 标记指定位置的方块为雷，返回true表示标记成功，false表示该位置已经翻开或标记为雷
public boolean mark(int r, int c) {
    if (gameOver || mask[r][c] == 1) {
        return false;
    }
    mask[r][c] = mask[r][c] == 2 ? 0 : 2; // 未标记变为标记，已标记变为未标记
    return true;
}

最后是判断游戏是否胜利的函数：

// 判断游戏是否胜利
public boolean isWin() {
    return openedCount == rows * cols - mines;
}

完整代码如下：

import java.util.Random;

public class Minesweeper {
    int[][] board; // 存储雷区信息的二维数组，0表示无雷，-1表示有雷，其它数字表示周围雷数
    int[][] mask; // 存储已翻开方块的信息，0表示未翻开，1表示已翻开，2表示标记为雷
    int rows, cols; // 行数和列数
    int mines; // 雷数
    int openedCount; // 已翻开的方块数
    boolean gameOver; // 游戏是否结束

    // 初始化函数，参数为行数、列数和雷数
    public void init(int rows, int cols, int mines) {
        this.rows = rows;
        this.cols = cols;
        this.mines = mines;
        this.openedCount = 0;
        this.gameOver = false;

        // 创建雷区和掩码数组
        board = new int[rows][cols];
        mask = new int[rows][cols];

        // 随机放置雷
        Random rand = new Random();
        int count = 0;
        while (count < mines) {
            int r = rand.nextInt(rows);
            int c = rand.nextInt(cols);
            if (board[r][c] != -1) {
                board[r][c] = -1;
                count++;
            }
        }

        // 计算每个方块周围的雷数
        for (int r = 0; r < rows; r++) {
            for (int c = 0; c < cols; c++) {
                if (board[r][c] != -1) {
                    int count = 0;
                    for (int dr = -1; dr <= 1; dr++) {
                        for (int dc = -1; dc <= 1; dc++) {
                            if (r+dr >= 0 && r+dr < rows && c+dc >= 0 && c+dc < cols && board[r+dr][c+dc] == -1) {
                                count++;
                            }
                        }
                    }
                    board[r][c] = count;
                }
            }
        }

        // 将掩码数组全部设置为未翻开状态
        for (int r = 0; r < rows; r++) {
            for (int c = 0; c < cols; c++) {
                mask[r][c] = 0;
            }
        }
    }

    // 翻开指定位置的方块，返回true表示翻开成功，false表示该位置已经翻开或标记为雷
    public boolean open(int r, int c) {
        if (gameOver || mask[r][c] != 0) {
            return false;
        }
        mask[r][c] = 1;
        openedCount++;
        if (board[r][c] == -1) {
            gameOver = true;
            return true;
        } else if (board[r][c] == 0) {
            for (int dr = -1; dr <= 1; dr++) {
                for (int dc = -1; dc <= 1; dc++) {
                    if (r+dr >= 0 && r+dr < rows && c+dc >= 0 && c+dc < cols) {
                        open(r+dr, c+dc);
                    }
                }
            }
            return true;
        } else {
            return true;
        }
    }

    // 标记指定位置的方块为雷，返回true表示标记成功，false表示该位置已经翻开或标记为雷
    public boolean mark(int r, int c) {
        if (gameOver || mask[r][c] == 1) {
            return false;
        }
        mask[r][c] = mask[r][c] == 2 ? 0 : 2; // 未标记变为标记，已标记变为未标记
        return true;
    }

    // 判断游戏是否胜利
    public boolean isWin() {
        return openedCount == rows * cols - mines;
    }
}

使用方法：

Minesweeper game = new Minesweeper();
game.init(10, 10, 10); // 创建一个10x10的雷区，共放置10个雷
game.open(0, 0); // 翻开第一行第一列的方块
game.mark(0, 1); // 标记第一行第二列的方块为雷
if (game.isWin()) {
    System.out.println("你赢了！");
} else if (game.gameOver) {
    System.out.println("你输了！");
} else {
    System.out.println("游戏继续！");
}