原文： https://zetcode.com/tutorials/javagamestutorial/minesweeper/

在 Java 2D 游戏教程的这一部分中，我们创建一个扫雷游戏克隆。 源代码和图像可以在作者的 Github Java-Minesweeper-Game 存储库中找到。

扫雷

《扫雷》是一款流行的棋盘游戏，默认情况下附带许多操作系统。 游戏的目标是扫雷场中的所有地雷。 如果玩家单击包含地雷的单元格，则地雷会引爆，游戏结束。

单元格可以包含数字，也可以为空白。 该数字表示与该特定单元相邻的地雷数量。 我们通过右键单击在单元格上设置标记。 通过这种方式，我们表明我们相信，有一个地雷。

Java Minesweeper 游戏的开发

游戏包含两个类别：Board和Minesweeper。 src/resources目录中有 13 张图片。

com/zetcode/Board.java

  1. package com.zetcode;
  3. import java.awt.Dimension;
  4. import java.awt.Graphics;
  5. import java.awt.Image;
  6. import java.awt.event.MouseAdapter;
  7. import java.awt.event.MouseEvent;
  8. import java.util.Random;
  9. import javax.swing.ImageIcon;
  10. import javax.swing.JLabel;
  11. import javax.swing.JPanel;
  13. public class Board extends JPanel {
  15.     private final int NUM_IMAGES = 13;
  16.     private final int CELL_SIZE = 15;
  18.     private final int COVER_FOR_CELL = 10;
  19.     private final int MARK_FOR_CELL = 10;
  20.     private final int EMPTY_CELL = 0;
  21.     private final int MINE_CELL = 9;
  22.     private final int COVERED_MINE_CELL = MINE_CELL + COVER_FOR_CELL;
  23.     private final int MARKED_MINE_CELL = COVERED_MINE_CELL + MARK_FOR_CELL;
  25.     private final int DRAW_MINE = 9;
  26.     private final int DRAW_COVER = 10;
  27.     private final int DRAW_MARK = 11;
  28.     private final int DRAW_WRONG_MARK = 12;
  30.     private final int N_MINES = 40;
  31.     private final int N_ROWS = 16;
  32.     private final int N_COLS = 16;
  34.     private final int BOARD_WIDTH = N_COLS * CELL_SIZE + 1;
  35.     private final int BOARD_HEIGHT = N_ROWS * CELL_SIZE + 1;
  37.     private int[] field;
  38.     private boolean inGame;
  39.     private int minesLeft;
  40.     private Image[] img;
  42.     private int allCells;
  43.     private final JLabel statusbar;
  45.     public Board(JLabel statusbar) {
  47.         this.statusbar = statusbar;
  48.         initBoard();
  49.     }
  51.     private void initBoard() {
  53.         setPreferredSize(new Dimension(BOARD_WIDTH, BOARD_HEIGHT));
  55.         img = new Image[NUM_IMAGES];
  57.         for (int i = 0; i < NUM_IMAGES; i++) {
  59.             var path = "src/resources/" + i + ".png";
  60.             img[i] = (new ImageIcon(path)).getImage();
  61.         }
  63.         addMouseListener(new MinesAdapter());
  64.         newGame();
  65.     }
  67.     private void newGame() {
  69.         int cell;
  71.         var random = new Random();
  72.         inGame = true;
  73.         minesLeft = N_MINES;
  75.         allCells = N_ROWS * N_COLS;
  76.         field = new int[allCells];
  78.         for (int i = 0; i < allCells; i++) {
  80.             field[i] = COVER_FOR_CELL;
  81.         }
  83.         statusbar.setText(Integer.toString(minesLeft));
  85.         int i = 0;
  87.         while (i < N_MINES) {
  89.             int position = (int) (allCells * random.nextDouble());
  91.             if ((position < allCells)
  92.                     && (field[position] != COVERED_MINE_CELL)) {
  94.                 int current_col = position % N_COLS;
  95.                 field[position] = COVERED_MINE_CELL;
  96.                 i++;
  98.                 if (current_col > 0) {
  99.                     cell = position - 1 - N_COLS;
  100.                     if (cell >= 0) {
  101.                         if (field[cell] != COVERED_MINE_CELL) {
  102.                             field[cell] += 1;
  103.                         }
  104.                     }
  105.                     cell = position - 1;
  106.                     if (cell >= 0) {
  107.                         if (field[cell] != COVERED_MINE_CELL) {
  108.                             field[cell] += 1;
  109.                         }
  110.                     }
  112.                     cell = position + N_COLS - 1;
  113.                     if (cell < allCells) {
  114.                         if (field[cell] != COVERED_MINE_CELL) {
  115.                             field[cell] += 1;
  116.                         }
  117.                     }
  118.                 }
  120.                 cell = position - N_COLS;
  121.                 if (cell >= 0) {
  122.                     if (field[cell] != COVERED_MINE_CELL) {
  123.                         field[cell] += 1;
  124.                     }
  125.                 }
  127.                 cell = position + N_COLS;
  128.                 if (cell < allCells) {
  129.                     if (field[cell] != COVERED_MINE_CELL) {
  130.                         field[cell] += 1;
  131.                     }
  132.                 }
  134.                 if (current_col < (N_COLS - 1)) {
  135.                     cell = position - N_COLS + 1;
  136.                     if (cell >= 0) {
  137.                         if (field[cell] != COVERED_MINE_CELL) {
  138.                             field[cell] += 1;
  139.                         }
  140.                     }
  141.                     cell = position + N_COLS + 1;
  142.                     if (cell < allCells) {
  143.                         if (field[cell] != COVERED_MINE_CELL) {
  144.                             field[cell] += 1;
  145.                         }
  146.                     }
  147.                     cell = position + 1;
  148.                     if (cell < allCells) {
  149.                         if (field[cell] != COVERED_MINE_CELL) {
  150.                             field[cell] += 1;
  151.                         }
  152.                     }
  153.                 }
  154.             }
  155.         }
  156.     }
  158.     private void find_empty_cells(int j) {
  160.         int current_col = j % N_COLS;
  161.         int cell;
  163.         if (current_col > 0) {
  164.             cell = j - N_COLS - 1;
  165.             if (cell >= 0) {
  166.                 if (field[cell] > MINE_CELL) {
  167.                     field[cell] -= COVER_FOR_CELL;
  168.                     if (field[cell] == EMPTY_CELL) {
  169.                         find_empty_cells(cell);
  170.                     }
  171.                 }
  172.             }
  174.             cell = j - 1;
  175.             if (cell >= 0) {
  176.                 if (field[cell] > MINE_CELL) {
  177.                     field[cell] -= COVER_FOR_CELL;
  178.                     if (field[cell] == EMPTY_CELL) {
  179.                         find_empty_cells(cell);
  180.                     }
  181.                 }
  182.             }
  184.             cell = j + N_COLS - 1;
  185.             if (cell < allCells) {
  186.                 if (field[cell] > MINE_CELL) {
  187.                     field[cell] -= COVER_FOR_CELL;
  188.                     if (field[cell] == EMPTY_CELL) {
  189.                         find_empty_cells(cell);
  190.                     }
  191.                 }
  192.             }
  193.         }
  195.         cell = j - N_COLS;
  196.         if (cell >= 0) {
  197.             if (field[cell] > MINE_CELL) {
  198.                 field[cell] -= COVER_FOR_CELL;
  199.                 if (field[cell] == EMPTY_CELL) {
  200.                     find_empty_cells(cell);
  201.                 }
  202.             }
  203.         }
  205.         cell = j + N_COLS;
  206.         if (cell < allCells) {
  207.             if (field[cell] > MINE_CELL) {
  208.                 field[cell] -= COVER_FOR_CELL;
  209.                 if (field[cell] == EMPTY_CELL) {
  210.                     find_empty_cells(cell);
  211.                 }
  212.             }
  213.         }
  215.         if (current_col < (N_COLS - 1)) {
  216.             cell = j - N_COLS + 1;
  217.             if (cell >= 0) {
  218.                 if (field[cell] > MINE_CELL) {
  219.                     field[cell] -= COVER_FOR_CELL;
  220.                     if (field[cell] == EMPTY_CELL) {
  221.                         find_empty_cells(cell);
  222.                     }
  223.                 }
  224.             }
  226.             cell = j + N_COLS + 1;
  227.             if (cell < allCells) {
  228.                 if (field[cell] > MINE_CELL) {
  229.                     field[cell] -= COVER_FOR_CELL;
  230.                     if (field[cell] == EMPTY_CELL) {
  231.                         find_empty_cells(cell);
  232.                     }
  233.                 }
  234.             }
  236.             cell = j + 1;
  237.             if (cell < allCells) {
  238.                 if (field[cell] > MINE_CELL) {
  239.                     field[cell] -= COVER_FOR_CELL;
  240.                     if (field[cell] == EMPTY_CELL) {
  241.                         find_empty_cells(cell);
  242.                     }
  243.                 }
  244.             }
  245.         }
  247.     }
  249.     @Override
  250.     public void paintComponent(Graphics g) {
  252.         int uncover = 0;
  254.         for (int i = 0; i < N_ROWS; i++) {
  256.             for (int j = 0; j < N_COLS; j++) {
  258.                 int cell = field[(i * N_COLS) + j];
  260.                 if (inGame && cell == MINE_CELL) {
  262.                     inGame = false;
  263.                 }
  265.                 if (!inGame) {
  267.                     if (cell == COVERED_MINE_CELL) {
  268.                         cell = DRAW_MINE;
  269.                     } else if (cell == MARKED_MINE_CELL) {
  270.                         cell = DRAW_MARK;
  271.                     } else if (cell > COVERED_MINE_CELL) {
  272.                         cell = DRAW_WRONG_MARK;
  273.                     } else if (cell > MINE_CELL) {
  274.                         cell = DRAW_COVER;
  275.                     }
  277.                 } else {
  279.                     if (cell > COVERED_MINE_CELL) {
  280.                         cell = DRAW_MARK;
  281.                     } else if (cell > MINE_CELL) {
  282.                         cell = DRAW_COVER;
  283.                         uncover++;
  284.                     }
  285.                 }
  287.                 g.drawImage(img[cell], (j * CELL_SIZE),
  288.                         (i * CELL_SIZE), this);
  289.             }
  290.         }
  292.         if (uncover == 0 && inGame) {
  294.             inGame = false;
  295.             statusbar.setText("Game won");
  297.         } else if (!inGame) {
  299.             statusbar.setText("Game lost");
  300.         }
  301.     }
  303.     private class MinesAdapter extends MouseAdapter {
  305.         @Override
  306.         public void mousePressed(MouseEvent e) {
  308.             int x = e.getX();
  309.             int y = e.getY();
  311.             int cCol = x / CELL_SIZE;
  312.             int cRow = y / CELL_SIZE;
  314.             boolean doRepaint = false;
  316.             if (!inGame) {
  318.                 newGame();
  319.                 repaint();
  320.             }
  322.             if ((x < N_COLS * CELL_SIZE) && (y < N_ROWS * CELL_SIZE)) {
  324.                 if (e.getButton() == MouseEvent.BUTTON3) {
  326.                     if (field[(cRow * N_COLS) + cCol] > MINE_CELL) {
  328.                         doRepaint = true;
  330.                         if (field[(cRow * N_COLS) + cCol] <= COVERED_MINE_CELL) {
  332.                             if (minesLeft > 0) {
  333.                                 field[(cRow * N_COLS) + cCol] += MARK_FOR_CELL;
  334.                                 minesLeft--;
  335.                                 String msg = Integer.toString(minesLeft);
  336.                                 statusbar.setText(msg);
  337.                             } else {
  338.                                 statusbar.setText("No marks left");
  339.                             }
  340.                         } else {
  342.                             field[(cRow * N_COLS) + cCol] -= MARK_FOR_CELL;
  343.                             minesLeft++;
  344.                             String msg = Integer.toString(minesLeft);
  345.                             statusbar.setText(msg);
  346.                         }
  347.                     }
  349.                 } else {
  351.                     if (field[(cRow * N_COLS) + cCol] > COVERED_MINE_CELL) {
  353.                         return;
  354.                     }
  356.                     if ((field[(cRow * N_COLS) + cCol] > MINE_CELL)
  357.                             && (field[(cRow * N_COLS) + cCol] < MARKED_MINE_CELL)) {
  359.                         field[(cRow * N_COLS) + cCol] -= COVER_FOR_CELL;
  360.                         doRepaint = true;
  362.                         if (field[(cRow * N_COLS) + cCol] == MINE_CELL) {
  363.                             inGame = false;
  364.                         }
  366.                         if (field[(cRow * N_COLS) + cCol] == EMPTY_CELL) {
  367.                             find_empty_cells((cRow * N_COLS) + cCol);
  368.                         }
  369.                     }
  370.                 }
  372.                 if (doRepaint) {
  373.                     repaint();
  374.                 }
  375.             }
  376.         }
  377.     }
  378. }

首先，我们定义游戏中使用的常量。

  1. private final int NUM_IMAGES = 13;
  2. private final int CELL_SIZE = 15;

此游戏中使用了十三张图像。 一个牢房最多可被八个地雷包围，因此我们需要一号到八号。 我们需要一个空单元格，一个地雷，一个被遮盖的单元格，一个标记的单元格，最后需要一个错误标记的单元格的图像。 每个图像的大小为15x15像素。

  1. private final int COVER_FOR_CELL = 10;
  2. private final int MARK_FOR_CELL = 10;
  3. private final int EMPTY_CELL = 0;
  4. ...

地雷区是数字数组。 例如，0 表示一个空单元格。 数字 10 用于电池盖和标记。 使用常量可以提高代码的可读性。

  1. private final int MINE_CELL = 9;

MINE_CELL表示包含地雷的单元。

  1. private final int COVERED_MINE_CELL = MINE_CELL + COVER_FOR_CELL;
  2. private final int MARKED_MINE_CELL = COVERED_MINE_CELL + MARK_FOR_CELL;

COVERED_MINE_CELL用于覆盖并包含地雷的区域。 MARKED_MINE_CELL代码是由用户标记的隐蔽地雷单元。

  1. private final int DRAW_MINE = 9;
  2. private final int DRAW_COVER = 10;
  3. private final int DRAW_MARK = 11;
  4. private final int DRAW_WRONG_MARK = 12;

这些竞争因素决定是否绘制地雷，地雷覆盖物，标记和标记错误的单元。

  1. private final int N_MINES = 40;
  2. private final int N_ROWS = 16;
  3. private final int N_COLS = 16;

我们游戏中的雷区有 40 个隐藏的地雷。 该字段中有 16 行和 16 列。 因此，雷场中共有 262 个牢房。

  1. private int[] field;

该字段是数字数组。 字段中的每个单元格都有一个特定的编号。 例如，一个矿井的编号为 9。一个矿井的编号为 2 意味着它与两个矿井相邻。 数字已添加。 例如，一个被覆盖的地雷的编号为 19，地雷的编号为 9，电池盖的编号为 10，依此类推。

  1. private boolean inGame;

inGame变量确定我们是在游戏中还是游戏结束。

  1. private int minesLeft;

minesLeft变量要标记为左侧的地雷数量。

  1. for (int i = 0; i < NUM_IMAGES; i++) {
  3.     var path = "src/resources/" + i + ".png";
  4.     img[i] = (new ImageIcon(path)).getImage();
  5. }

我们将图像加载到图像数组中。 这些图像分别命名为0.png，1.png … 12.png。

newGame()启动扫雷游戏。

  1. allCells = N_ROWS * N_COLS;
  2. field = new int[allCells];
  4. for (int i = 0; i < allCells; i++) {
  6.     field[i] = COVER_FOR_CELL;
  7. }

这些线设置了雷区。 默认情况下覆盖每个单元格。

  1. int i = 0;
  3. while (i < N_MINES) {
  5.     int position = (int) (allCells * random.nextDouble());
  7.     if ((position < allCells)
  8.             && (field[position] != COVERED_MINE_CELL)) {
  10.         int current_col = position % N_COLS;
  11.         field[position] = COVERED_MINE_CELL;
  12.         i++;
  13. ...

在白色周期中，我们将所有地雷随机放置在野外。

  1. cell = position - N_COLS;
  3. if (cell >= 0) {
  4.     if (field[cell] != COVERED_MINE_CELL) {
  5.         field[cell] += 1;
  6.     }
  7. }

每个单元最多可以包围八个单元。 （这不适用于边界单元。）我们为每个随机放置的地雷增加相邻单元的数量。 在我们的示例中，我们向相关单元格的顶部邻居添加 1。

在find_empty_cells()方法中，我们找到了空单元格。 如果玩家单击雷区，则游戏结束。 如果他单击与地雷相邻的单元，则会发现一个数字，该数字指示该单元与地雷相邻的数量。 单击一个空单元格会导致发现许多其他空单元格以及带有数字的单元格，这些数字在空边界的空间周围形成边界。 我们使用递归算法来查找空单元格。

  1. cell = j - 1;
  2. if (cell <= 0) {
  3.     if (field[cell] > MINE_CELL) {
  4.         field[cell] -= COVER_FOR_CELL;
  5.         if (field[cell] == EMPTY_CELL) {
  6.             find_empty_cells(cell);
  7.         }
  8.     }
  9. }

在此代码中，我们检查位于相关空单元格左侧的单元格。 如果不为空，则将其覆盖。 如果为空，则通过递归调用find_empty_cells()方法来重复整个过程。

paintComponent()方法将数字转换为图像。

  1. if (!inGame) {
  2.     if (cell == COVERED_MINE_CELL) {
  3.         cell = DRAW_MINE;
  4.     } else if (cell == MARKED_MINE_CELL) {
  5.         cell = DRAW_MARK;
  6.     } else if (cell > COVERED_MINE_CELL) {
  7.         cell = DRAW_WRONG_MARK;
  8.     } else if (cell > MINE_CELL) {
  9.         cell = DRAW_COVER;
  10.     }
  11. } ...

如果游戏结束并且我们输了，我们将显示所有未发现的地雷（如果有的话），并显示所有错误标记的单元格（如果有）。

  1. g.drawImage(img[cell], (j * CELL_SIZE),
  2.     (i * CELL_SIZE), this);

此代码行绘制了窗口上的每个单元格。

  1. if (uncover == 0 && inGame) {
  3.     inGame = false;
  4.     statusbar.setText("Game won");
  5. } else if (!inGame) {
  7.     statusbar.setText("Game lost");
  8. }

如果没有什么可以发现的，我们就赢了。 如果inGame变量设置为false，我们将丢失。

在mousePressed()方法中，我们对鼠标单击做出反应。 扫雷游戏完全由鼠标控制。 我们对鼠标左键和右键单击做出反应。

  1. int x = e.getX();
  2. int y = e.getY();

我们确定鼠标指针的 x 和 y 坐标。

  1. int cCol = x / CELL_SIZE;
  2. int cRow = y / CELL_SIZE;

我们计算雷区的相应列和行。

  1. if ((x < N_COLS * CELL_SIZE) && (y < N_ROWS * CELL_SIZE)) {

我们检查我们是否位于雷区。

  1. if (e.getButton() == MouseEvent.BUTTON3) {

地雷的发现是通过鼠标右键完成的。

  1. field[(cRow * N_COLS) + cCol] += MARK_FOR_CELL;
  2. minesLeft--;

如果右键单击未标记的单元格，则将MARK_FOR_CELL添加到表示该单元格的数字中。 这导致在paintComponent()方法中绘制带有标记的覆盖单元。

  1. field[(cRow * N_COLS) + cCol] -= MARK_FOR_CELL;
  2. minesLeft++;
  4. var msg = Integer.toString(minesLeft);
  5. statusbar.setText(msg);

如果我们在已经标记的单元格上单击鼠标左键，我们将删除标记并增加要标记的单元格的数量。

  1. if (field[(cRow * N_COLS) + cCol] > COVERED_MINE_CELL) {
  2.     return;
  3. }

如果单击覆盖并标记的单元格，则不会发生任何事情。 必须首先通过另一次右键单击来发现它，然后才可以在其上单击鼠标左键。

  1. field[(cRow * N_COLS) + cCol] -= COVER_FOR_CELL;

左键单击可从单元中移除盖子。

  1. if (field[(cRow * N_COLS) + cCol] == MINE_CELL) {
  2.     inGame = false;
  3. }
  5. if (field[(cRow * N_COLS) + cCol] == EMPTY_CELL) {
  6.     find_empty_cells((cRow * N_COLS) + cCol);
  7. }

万一我们左键单击地雷，游戏就结束了。 如果我们在空白单元格上单击鼠标左键，我们将调用find_empty_cells()方法，该方法递归地找到所有相邻的空白单元格。

  1. if (doRepaint) {
  2.     repaint();
  3. }

如果需要重新粉刷电路板（例如，设置或移除了标记），我们将调用repaint()方法。

com/zetcode/Minesweeper.java

  1. package com.zetcode;
  3. import java.awt.BorderLayout;
  4. import java.awt.EventQueue;
  5. import javax.swing.JFrame;
  6. import javax.swing.JLabel;
  8. /**
  9.  * Java Minesweeper Game
  10.  *
  11.  * Author: Jan Bodnar
  12.  * Website: http://zetcode.com
  13.  */
  15. public class Minesweeper extends JFrame {
  17.     private JLabel statusbar;
  19.     public Minesweeper() {
  21.         initUI();
  22.     }
  24.     private void initUI() {
  26.         statusbar = new JLabel("");
  27.         add(statusbar, BorderLayout.SOUTH);
  29.         add(new Board(statusbar));
  31.         setResizable(false);
  32.         pack();
  34.         setTitle("Minesweeper");
  35.         setLocationRelativeTo(null);
  36.         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  37.     }
  39.     public static void main(String[] args) {
  41.         EventQueue.invokeLater(() -> {
  43.             var ex = new Minesweeper();
  44.             ex.setVisible(true);
  45.         });
  46.     }
  47. }

这是主要的类。

  1. setResizable(false);

窗口大小固定。 为此，我们使用setResizable()方法。

Java 扫雷 - 图1

图：扫雷

在 Java 2D 游戏教程的这一部分中，我们创建了扫雷游戏的 Java 复制版本。