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

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

推箱子

推箱子是另一个经典的电脑游戏。 它由 Imabayashi Hiroyuki 于 1980 年创建。 推箱子是日语的仓库管理员。 玩家在迷宫周围推箱子。 目的是将所有盒子放置在指定的位置。

Java 推箱子游戏的开发

我们使用光标键控制推箱子对象。 我们也可以按 R 键重新启动电平。 将所有行李放在目的地区域后，游戏结束。 我们在窗口的左上角绘制"Completed"字符串。

Board.java

  1. package com.zetcode;
  3. import java.awt.Color;
  4. import java.awt.Graphics;
  5. import java.awt.event.KeyAdapter;
  6. import java.awt.event.KeyEvent;
  7. import java.util.ArrayList;
  8. import javax.swing.JPanel;
  10. public class Board extends JPanel {
  12.     private final int OFFSET = 30;
  13.     private final int SPACE = 20;
  14.     private final int LEFT_COLLISION = 1;
  15.     private final int RIGHT_COLLISION = 2;
  16.     private final int TOP_COLLISION = 3;
  17.     private final int BOTTOM_COLLISION = 4;
  19.     private ArrayList<Wall> walls;
  20.     private ArrayList<Baggage> baggs;
  21.     private ArrayList<Area> areas;
  23.     private Player soko;
  24.     private int w = 0;
  25.     private int h = 0;
  27.     private boolean isCompleted = false;
  29.     private String level
  30.             = "    ######\n"
  31.             + "    ##   #\n"
  32.             + "    ##$  #\n"
  33.             + "  ####  $##\n"
  34.             + "  ##  $ $ #\n"
  35.             + "#### # ## #   ######\n"
  36.             + "##   # ## #####  ..#\n"
  37.             + "## $  $          ..#\n"
  38.             + "###### ### #@##  ..#\n"
  39.             + "    ##     #########\n"
  40.             + "    ########\n";
  42.     public Board() {
  44.         initBoard();
  45.     }
  47.     private void initBoard() {
  49.         addKeyListener(new TAdapter());
  50.         setFocusable(true);
  51.         initWorld();
  52.     }
  54.     public int getBoardWidth() {
  55.         return this.w;
  56.     }
  58.     public int getBoardHeight() {
  59.         return this.h;
  60.     }
  62.     private void initWorld() {
  64.         walls = new ArrayList<>();
  65.         baggs = new ArrayList<>();
  66.         areas = new ArrayList<>();
  68.         int x = OFFSET;
  69.         int y = OFFSET;
  71.         Wall wall;
  72.         Baggage b;
  73.         Area a;
  75.         for (int i = 0; i < level.length(); i++) {
  77.             char item = level.charAt(i);
  79.             switch (item) {
  81.                 case '\n':
  82.                     y += SPACE;
  84.                     if (this.w < x) {
  85.                         this.w = x;
  86.                     }
  88.                     x = OFFSET;
  89.                     break;
  91.                 case '#':
  92.                     wall = new Wall(x, y);
  93.                     walls.add(wall);
  94.                     x += SPACE;
  95.                     break;
  97.                 case '$':
  98.                     b = new Baggage(x, y);
  99.                     baggs.add(b);
  100.                     x += SPACE;
  101.                     break;
  103.                 case '.':
  104.                     a = new Area(x, y);
  105.                     areas.add(a);
  106.                     x += SPACE;
  107.                     break;
  109.                 case '@':
  110.                     soko = new Player(x, y);
  111.                     x += SPACE;
  112.                     break;
  114.                 case ' ':
  115.                     x += SPACE;
  116.                     break;
  118.                 default:
  119.                     break;
  120.             }
  122.             h = y;
  123.         }
  124.     }
  126.     private void buildWorld(Graphics g) {
  128.         g.setColor(new Color(250, 240, 170));
  129.         g.fillRect(0, 0, this.getWidth(), this.getHeight());
  131.         ArrayList<Actor> world = new ArrayList<>();
  133.         world.addAll(walls);
  134.         world.addAll(areas);
  135.         world.addAll(baggs);
  136.         world.add(soko);
  138.         for (int i = 0; i < world.size(); i++) {
  140.             Actor item = world.get(i);
  142.             if (item instanceof Player || item instanceof Baggage) {
  144.                 g.drawImage(item.getImage(), item.x() + 2, item.y() + 2, this);
  145.             } else {
  147.                 g.drawImage(item.getImage(), item.x(), item.y(), this);
  148.             }
  150.             if (isCompleted) {
  152.                 g.setColor(new Color(0, 0, 0));
  153.                 g.drawString("Completed", 25, 20);
  154.             }
  156.         }
  157.     }
  159.     @Override
  160.     public void paintComponent(Graphics g) {
  161.         super.paintComponent(g);
  163.         buildWorld(g);
  164.     }
  166.     private class TAdapter extends KeyAdapter {
  168.         @Override
  169.         public void keyPressed(KeyEvent e) {
  171.             if (isCompleted) {
  172.                 return;
  173.             }
  175.             int key = e.getKeyCode();
  177.             switch (key) {
  179.                 case KeyEvent.VK_LEFT:
  181.                     if (checkWallCollision(soko,
  182.                             LEFT_COLLISION)) {
  183.                         return;
  184.                     }
  186.                     if (checkBagCollision(LEFT_COLLISION)) {
  187.                         return;
  188.                     }
  190.                     soko.move(-SPACE, 0);
  192.                     break;
  194.                 case KeyEvent.VK_RIGHT:
  196.                     if (checkWallCollision(soko, RIGHT_COLLISION)) {
  197.                         return;
  198.                     }
  200.                     if (checkBagCollision(RIGHT_COLLISION)) {
  201.                         return;
  202.                     }
  204.                     soko.move(SPACE, 0);
  206.                     break;
  208.                 case KeyEvent.VK_UP:
  210.                     if (checkWallCollision(soko, TOP_COLLISION)) {
  211.                         return;
  212.                     }
  214.                     if (checkBagCollision(TOP_COLLISION)) {
  215.                         return;
  216.                     }
  218.                     soko.move(0, -SPACE);
  220.                     break;
  222.                 case KeyEvent.VK_DOWN:
  224.                     if (checkWallCollision(soko, BOTTOM_COLLISION)) {
  225.                         return;
  226.                     }
  228.                     if (checkBagCollision(BOTTOM_COLLISION)) {
  229.                         return;
  230.                     }
  232.                     soko.move(0, SPACE);
  234.                     break;
  236.                 case KeyEvent.VK_R:
  238.                     restartLevel();
  240.                     break;
  242.                 default:
  243.                     break;
  244.             }
  246.             repaint();
  247.         }
  248.     }
  250.     private boolean checkWallCollision(Actor actor, int type) {
  252.         switch (type) {
  254.             case LEFT_COLLISION:
  256.                 for (int i = 0; i < walls.size(); i++) {
  258.                     Wall wall = walls.get(i);
  260.                     if (actor.isLeftCollision(wall)) {
  262.                         return true;
  263.                     }
  264.                 }
  266.                 return false;
  268.             case RIGHT_COLLISION:
  270.                 for (int i = 0; i < walls.size(); i++) {
  272.                     Wall wall = walls.get(i);
  274.                     if (actor.isRightCollision(wall)) {
  275.                         return true;
  276.                     }
  277.                 }
  279.                 return false;
  281.             case TOP_COLLISION:
  283.                 for (int i = 0; i < walls.size(); i++) {
  285.                     Wall wall = walls.get(i);
  287.                     if (actor.isTopCollision(wall)) {
  289.                         return true;
  290.                     }
  291.                 }
  293.                 return false;
  295.             case BOTTOM_COLLISION:
  297.                 for (int i = 0; i < walls.size(); i++) {
  299.                     Wall wall = walls.get(i);
  301.                     if (actor.isBottomCollision(wall)) {
  303.                         return true;
  304.                     }
  305.                 }
  307.                 return false;
  309.             default:
  310.                 break;
  311.         }
  313.         return false;
  314.     }
  316.     private boolean checkBagCollision(int type) {
  318.         switch (type) {
  320.             case LEFT_COLLISION:
  322.                 for (int i = 0; i < baggs.size(); i++) {
  324.                     Baggage bag = baggs.get(i);
  326.                     if (soko.isLeftCollision(bag)) {
  328.                         for (int j = 0; j < baggs.size(); j++) {
  330.                             Baggage item = baggs.get(j);
  332.                             if (!bag.equals(item)) {
  334.                                 if (bag.isLeftCollision(item)) {
  335.                                     return true;
  336.                                 }
  337.                             }
  339.                             if (checkWallCollision(bag, LEFT_COLLISION)) {
  340.                                 return true;
  341.                             }
  342.                         }
  344.                         bag.move(-SPACE, 0);
  345.                         isCompleted();
  346.                     }
  347.                 }
  349.                 return false;
  351.             case RIGHT_COLLISION:
  353.                 for (int i = 0; i < baggs.size(); i++) {
  355.                     Baggage bag = baggs.get(i);
  357.                     if (soko.isRightCollision(bag)) {
  359.                         for (int j = 0; j < baggs.size(); j++) {
  361.                             Baggage item = baggs.get(j);
  363.                             if (!bag.equals(item)) {
  365.                                 if (bag.isRightCollision(item)) {
  366.                                     return true;
  367.                                 }
  368.                             }
  370.                             if (checkWallCollision(bag, RIGHT_COLLISION)) {
  371.                                 return true;
  372.                             }
  373.                         }
  375.                         bag.move(SPACE, 0);
  376.                         isCompleted();
  377.                     }
  378.                 }
  379.                 return false;
  381.             case TOP_COLLISION:
  383.                 for (int i = 0; i < baggs.size(); i++) {
  385.                     Baggage bag = baggs.get(i);
  387.                     if (soko.isTopCollision(bag)) {
  389.                         for (int j = 0; j < baggs.size(); j++) {
  391.                             Baggage item = baggs.get(j);
  393.                             if (!bag.equals(item)) {
  395.                                 if (bag.isTopCollision(item)) {
  396.                                     return true;
  397.                                 }
  398.                             }
  400.                             if (checkWallCollision(bag, TOP_COLLISION)) {
  401.                                 return true;
  402.                             }
  403.                         }
  405.                         bag.move(0, -SPACE);
  406.                         isCompleted();
  407.                     }
  408.                 }
  410.                 return false;
  412.             case BOTTOM_COLLISION:
  414.                 for (int i = 0; i < baggs.size(); i++) {
  416.                     Baggage bag = baggs.get(i);
  418.                     if (soko.isBottomCollision(bag)) {
  420.                         for (int j = 0; j < baggs.size(); j++) {
  422.                             Baggage item = baggs.get(j);
  424.                             if (!bag.equals(item)) {
  426.                                 if (bag.isBottomCollision(item)) {
  427.                                     return true;
  428.                                 }
  429.                             }
  431.                             if (checkWallCollision(bag,BOTTOM_COLLISION)) {
  433.                                 return true;
  434.                             }
  435.                         }
  437.                         bag.move(0, SPACE);
  438.                         isCompleted();
  439.                     }
  440.                 }
  442.                 break;
  444.             default:
  445.                 break;
  446.         }
  448.         return false;
  449.     }
  451.     public void isCompleted() {
  453.         int nOfBags = baggs.size();
  454.         int finishedBags = 0;
  456.         for (int i = 0; i < nOfBags; i++) {
  458.             Baggage bag = baggs.get(i);
  460.             for (int j = 0; j < nOfBags; j++) {
  462.                 Area area =  areas.get(j);
  464.                 if (bag.x() == area.x() && bag.y() == area.y()) {
  466.                     finishedBags += 1;
  467.                 }
  468.             }
  469.         }
  471.         if (finishedBags == nOfBags) {
  473.             isCompleted = true;
  474.             repaint();
  475.         }
  476.     }
  478.     public void restartLevel() {
  480.         areas.clear();
  481.         baggs.clear();
  482.         walls.clear();
  484.         initWorld();
  486.         if (isCompleted) {
  487.             isCompleted = false;
  488.         }
  489.     }
  490. }

游戏简化了。 它仅提供非常基本的功能。 该代码比容易理解。 游戏只有一个关卡。

  1. private final int OFFSET = 30;
  2. private final int SPACE = 20;
  3. private final int LEFT_COLLISION = 1;
  4. private final int RIGHT_COLLISION = 2;
  5. private final int TOP_COLLISION = 3;
  6. private final int BOTTOM_COLLISION = 4;

墙图片大小为20x20像素。 这反映了SPACE常数。 OFFSET是窗口边界和游戏世界之间的距离。 有四种类型的碰撞。 每个数字都由一个数字常数表示。

  1. private ArrayList<Wall> walls;
  2. private ArrayList<Baggage> baggs;
  3. private ArrayList<Area> areas;

墙壁，行李和区域是特殊的容器，可容纳游戏的所有墙壁，行李和区域。

  1. private String level =
  2.           "    ######\n"
  3.         + "    ##   #\n"
  4.         + "    ##$  #\n"
  5.         + "  ####  $##\n"
  6.         + "  ##  $ $ #\n"
  7.         + "#### # ## #   ######\n"
  8.         + "##   # ## #####  ..#\n"
  9.         + "## $  $          ..#\n"
  10.         + "###### ### #@##  ..#\n"
  11.         + "    ##     #########\n"
  12.         + "    ########\n";

这是游戏的水平。 除空格外，还有五个字符。 井号（#）代表墙。 美元（$）表示要移动的框。 点（.）字符表示我们必须移动框的位置。 at 字符（@）是推箱子。 最后，换行符（\n）开始了世界的新行。

  1. private void initWorld() {
  3.     walls = new ArrayList<>();
  4.     baggs = new ArrayList<>();
  5.     areas = new ArrayList<>();
  7.     int x = OFFSET;
  8.     int y = OFFSET;
  9. ...

initWorld()方法启动游戏世界。 它遍历级别字符串并填充上述列表。

  1. case '$':
  2.     b = new Baggage(x, y);
  3.     baggs.add(b);
  4.     x += SPACE;
  5.     break;

对于美元字符，我们创建一个Baggage对象。 该对象将附加到行李列表。 x 变量相应增加。

  1. private void buildWorld(Graphics g) {
  2. ...

buildWorld()方法在窗口上绘制游戏世界。

  1. ArrayList<Actor> world = new ArrayList<>();
  3. world.addAll(walls);
  4. world.addAll(areas);
  5. world.addAll(baggs);
  6. world.add(soko);

我们创建一个包含游戏所有对象的世界列表。

  1. for (int i = 0; i < world.size(); i++) {
  3.     Actor item = world.get(i);
  5.     if (item instanceof Player || item instanceof Baggage) {
  7.         g.drawImage(item.getImage(), item.x() + 2, item.y() + 2, this);
  8.     } else {
  10.         g.drawImage(item.getImage(), item.x(), item.y(), this);
  11.     }
  12. ...
  13. }

我们遍历世界容器并绘制对象。 播放器和行李图像稍小。 我们在其坐标上添加 2px 以使其居中。

  1. if (isCompleted) {
  3.     g.setColor(new Color(0, 0, 0));
  4.     g.drawString("Completed", 25, 20);
  5. }

如果完成该级别，则在窗口的左上角绘制"Completed"。

  1. case KeyEvent.VK_LEFT:
  3.     if (checkWallCollision(soko,
  4.             LEFT_COLLISION)) {
  5.         return;
  6.     }
  8.     if (checkBagCollision(LEFT_COLLISION)) {
  9.         return;
  10.     }
  12.     soko.move(-SPACE, 0);
  14.     break;

在keyPressed()方法内部，我们检查了按下了哪些键。 我们用光标键控制推箱子对象。 如果按左光标键，我们将检查推箱子是否与墙壁或行李相撞。 如果没有，我们将推箱子向左移动。

  1. case KeyEvent.VK_R:
  3.     restartLevel();
  5.     break;

如果按R键，我们将重新启动该级别。

  1. case LEFT_COLLISION:
  3.     for (int i = 0; i < walls.size(); i++) {
  5.         Wall wall = walls.get(i);
  7.         if (actor.isLeftCollision(wall)) {
  9.             return true;
  10.         }
  11.     }
  13.     return false;

创建checkWallCollision()方法以确保推箱子或行李不会通过墙壁。 有四种类型的碰撞。 上面几行检查是否有左碰撞。

  1. private boolean checkBagCollision(int type) {
  2. ...
  3. }

checkBagCollision()涉及更多。 行李可能会与墙壁，推箱子或其他行李发生碰撞。 仅当行李与推箱子碰撞且不与其他行李或墙壁碰撞时，才可以移动行李。 搬运行李时，该通过调用isCompleted()方法检查水平是否已完成。

  1. for (int i = 0; i < nOfBags; i++) {
  3.     Baggage bag = baggs.get(i);
  5.     for (int j = 0; j < nOfBags; j++) {
  7.         Area area =  areas.get(j);
  9.         if (bag.x() == area.x() && bag.y() == area.y()) {
  11.             finishedBags += 1;
  12.         }
  13.     }
  14. }

isCompleted()方法检查级别是否完成。 我们得到行李数。 我们比较所有行李和目的地区域的 x 和 y 坐标。

  1. if (finishedBags == nOfBags) {
  3.     isCompleted = true;
  4.     repaint();
  5. }

当finishedBags变量等于游戏中的行李数时，游戏结束。

  1. private void restartLevel() {
  3.     areas.clear();
  4.     baggs.clear();
  5.     walls.clear();
  7.     initWorld();
  9.     if (isCompleted) {
  10.         isCompleted = false;
  11.     }
  12. }

如果我们做了一些不好的动作，我们可以重新启动关卡。 我们从列表中删除所有对象，然后再次启动世界。 isCompleted变量设置为false。

Actor.java

  1. package com.zetcode;
  3. import java.awt.Image;
  5. public class Actor {
  7.     private final int SPACE = 20;
  9.     private int x;
  10.     private int y;
  11.     private Image image;
  13.     public Actor(int x, int y) {
  15.         this.x = x;
  16.         this.y = y;
  17.     }
  19.     public Image getImage() {
  20.         return image;
  21.     }
  23.     public void setImage(Image img) {
  24.         image = img;
  25.     }
  27.     public int x() {
  29.         return x;
  30.     }
  32.     public int y() {
  34.         return y;
  35.     }
  37.     public void setX(int x) {
  39.         this.x = x;
  40.     }
  42.     public void setY(int y) {
  44.         this.y = y;
  45.     }
  47.     public boolean isLeftCollision(Actor actor) {
  49.         return x() - SPACE == actor.x() && y() == actor.y();
  50.     }
  52.     public boolean isRightCollision(Actor actor) {
  54.         return x() + SPACE == actor.x() && y() == actor.y();
  55.     }
  57.     public boolean isTopCollision(Actor actor) {
  59.         return y() - SPACE == actor.y() && x() == actor.x();
  60.     }
  62.     public boolean isBottomCollision(Actor actor) {
  64.         return y() + SPACE == actor.y() && x() == actor.x();
  65.     }
  66. }

这是Actor类。 该类是游戏中其他演员的基础类。 它封装了推箱子游戏中对象的基本功能。

  1. public boolean isLeftCollision(Actor actor) {
  3.     return x() - SPACE == actor.x() && y() == actor.y();
  4. }

此方法检查演员是否与左侧的另一个演员（墙壁，行李，推箱子）相撞。

Wall.java

  1. package com.zetcode;
  3. import java.awt.Image;
  4. import javax.swing.ImageIcon;
  6. public class Wall extends Actor {
  8.     private Image image;
  10.     public Wall(int x, int y) {
  11.         super(x, y);
  13.         initWall();
  14.     }
  16.     private void initWall() {
  18.         ImageIcon iicon = new ImageIcon("src/resources/wall.png");
  19.         image = iicon.getImage();
  20.         setImage(image);
  21.     }
  22. }

这是Wall类。 它继承自Actor类。 构建后，它将从资源中加载墙图像。

Player.java

package com.zetcode;

import java.awt.Image;
import javax.swing.ImageIcon;

public class Player extends Actor {

    public Player(int x, int y) {
        super(x, y);

        initPlayer();
    }

    private void initPlayer() {

        ImageIcon iicon = new ImageIcon("src/resources/sokoban.png");
        Image image = iicon.getImage();
        setImage(image);
    }

    public void move(int x, int y) {

        int dx = x() + x;
        int dy = y() + y;

        setX(dx);
        setY(dy);
    }
}

这是Player类。

public void move(int x, int y) {

    int dx = x() + x;
    int dy = y() + y;

    setX(dx);
    setY(dy);
}

move()方法将对象移动到世界内部。

Baggage.java

package com.zetcode;

import java.awt.Image;
import javax.swing.ImageIcon;

public class Baggage extends Actor {

    public Baggage(int x, int y) {
        super(x, y);

        initBaggage();
    }

    private void initBaggage() {

        ImageIcon iicon = new ImageIcon("src/resources/baggage.png");
        Image image = iicon.getImage();
        setImage(image);
    }

    public void move(int x, int y) {

        int dx = x() + x;
        int dy = y() + y;

        setX(dx);
        setY(dy);
    }
}

这是Baggage对象的类。 该对象是可移动的，因此也具有move()方法。

Area.java

package com.zetcode;

import java.awt.Image;
import javax.swing.ImageIcon;

public class Area extends Actor {

    public Area(int x, int y) {
        super(x, y);

        initArea();
    }

    private void initArea() {

        ImageIcon iicon = new ImageIcon("src/resources/area.png");
        Image image = iicon.getImage();
        setImage(image);
    }
}

这是Area类。 这是我们尝试放置行李的对象。

Sokoban.java

package com.zetcode;

import java.awt.EventQueue;
import javax.swing.JFrame;

public class Sokoban extends JFrame {

    private final int OFFSET = 30;

    public Sokoban() {

        initUI();
    }

    private void initUI() {

        Board board = new Board();
        add(board);

        setTitle("Sokoban");

        setSize(board.getBoardWidth() + OFFSET,
                board.getBoardHeight() + 2 * OFFSET);

        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLocationRelativeTo(null);
    }

    public static void main(String[] args) {

        EventQueue.invokeLater(() -> {

            Sokoban game = new Sokoban();
            game.setVisible(true);
        });
    }
}

这是主要的类。

Java 推箱子 - 图1

图：推箱子

这是推箱子游戏。