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

在 Java 2D 游戏教程的这一部分中，我们将讨论碰撞检测。

许多游戏都需要处理碰撞，尤其是街机游戏。 简而言之，我们需要检测两个对象何时在屏幕上碰撞。

在下一个代码示例中，我们将扩展上一个示例。 我们添加了一个新的外星人精灵。 我们将检测两种类型的碰撞：当导弹击中外星人的飞船和我们的航天器与外星人相撞时。

射击外星人

在示例中，我们有一个航天器和外星人。 我们可以使用光标键在板上移动航天器。 用空格键发射消灭外星人的导弹。

Sprite.java

  1. package com.zetcode;
  3. import java.awt.Image;
  4. import java.awt.Rectangle;
  5. import javax.swing.ImageIcon;
  7. public class Sprite {
  9.     protected int x;
  10.     protected int y;
  11.     protected int width;
  12.     protected int height;
  13.     protected boolean visible;
  14.     protected Image image;
  16.     public Sprite(int x, int y) {
  18.         this.x = x;
  19.         this.y = y;
  20.         visible = true;
  21.     }
  23.     protected void getImageDimensions() {
  25.         width = image.getWidth(null);
  26.         height = image.getHeight(null);
  27.     }
  29.     protected void loadImage(String imageName) {
  31.         ImageIcon ii = new ImageIcon(imageName);
  32.         image = ii.getImage();
  33.     }
  35.     public Image getImage() {
  36.         return image;
  37.     }
  39.     public int getX() {
  40.         return x;
  41.     }
  43.     public int getY() {
  44.         return y;
  45.     }
  47.     public boolean isVisible() {
  48.         return visible;
  49.     }
  51.     public void setVisible(Boolean visible) {
  52.         this.visible = visible;
  53.     }
  55.     public Rectangle getBounds() {
  56.         return new Rectangle(x, y, width, height);
  57.     }
  58. }

可以由所有子画面（工艺品，外星人和导弹）共享的代码放在Sprite类中。

  1. public Rectangle getBounds() {
  2.     return new Rectangle(x, y, width, height);
  3. }

getBounds()方法返回精灵图像的边界矩形。 在碰撞检测中我们需要边界。

SpaceShip.java

  1. package com.zetcode;
  3. import java.awt.event.KeyEvent;
  4. import java.util.ArrayList;
  5. import java.util.List;
  7. public class SpaceShip extends Sprite {
  9.     private int dx;
  10.     private int dy;
  11.     private List<Missile> missiles;
  13.     public SpaceShip(int x, int y) {
  14.         super(x, y);
  16.         initCraft();
  17.     }
  19.     private void initCraft() {
  21.         missiles = new ArrayList<>();
  22.         loadImage("src/resources/spaceship.png");
  23.         getImageDimensions();
  24.     }
  26.     public void move() {
  28.         x += dx;
  29.         y += dy;
  31.         if (x < 1) {
  32.             x = 1;
  33.         }
  35.         if (y < 1) {
  36.             y = 1;
  37.         }
  38.     }
  40.     public List<Missile> getMissiles() {
  41.         return missiles;
  42.     }
  44.     public void keyPressed(KeyEvent e) {
  46.         int key = e.getKeyCode();
  48.         if (key == KeyEvent.VK_SPACE) {
  49.             fire();
  50.         }
  52.         if (key == KeyEvent.VK_LEFT) {
  53.             dx = -1;
  54.         }
  56.         if (key == KeyEvent.VK_RIGHT) {
  57.             dx = 1;
  58.         }
  60.         if (key == KeyEvent.VK_UP) {
  61.             dy = -1;
  62.         }
  64.         if (key == KeyEvent.VK_DOWN) {
  65.             dy = 1;
  66.         }
  67.     }
  69.     public void fire() {
  70.         missiles.add(new Missile(x + width, y + height / 2));
  71.     }
  73.     public void keyReleased(KeyEvent e) {
  75.         int key = e.getKeyCode();
  77.         if (key == KeyEvent.VK_LEFT) {
  78.             dx = 0;
  79.         }
  81.         if (key == KeyEvent.VK_RIGHT) {
  82.             dx = 0;
  83.         }
  85.         if (key == KeyEvent.VK_UP) {
  86.             dy = 0;
  87.         }
  89.         if (key == KeyEvent.VK_DOWN) {
  90.             dy = 0;
  91.         }
  92.     }
  93. }

此类代表航天器。

  1. private List<Missile> missiles;

航天器发射的所有导弹都存储在missiles列表中。

  1. public void fire() {
  2.     missiles.add(new Missile(x + width, y + height / 2));
  3. }

当我们发射导弹时，新的Missile对象将添加到missiles列表中。 它会保留在列表中，直到与外星人碰撞或离开窗口为止。

Board.java

  1. package com.zetcode;
  3. import java.awt.Color;
  4. import java.awt.Dimension;
  5. import java.awt.Font;
  6. import java.awt.FontMetrics;
  7. import java.awt.Graphics;
  8. import java.awt.Rectangle;
  9. import java.awt.Toolkit;
  10. import java.awt.event.ActionEvent;
  11. import java.awt.event.ActionListener;
  12. import java.awt.event.KeyAdapter;
  13. import java.awt.event.KeyEvent;
  14. import java.util.ArrayList;
  15. import java.util.List;
  16. import javax.swing.JPanel;
  17. import javax.swing.Timer;
  19. public class Board extends JPanel implements ActionListener {
  21.     private Timer timer;
  22.     private SpaceShip spaceship;
  23.     private List<Alien> aliens;
  24.     private boolean ingame;
  25.     private final int ICRAFT_X = 40;
  26.     private final int ICRAFT_Y = 60;
  27.     private final int B_WIDTH = 400;
  28.     private final int B_HEIGHT = 300;
  29.     private final int DELAY = 15;
  31.     private final int[][] pos = {
  32.         {2380, 29}, {2500, 59}, {1380, 89},
  33.         {780, 109}, {580, 139}, {680, 239},
  34.         {790, 259}, {760, 50}, {790, 150},
  35.         {980, 209}, {560, 45}, {510, 70},
  36.         {930, 159}, {590, 80}, {530, 60},
  37.         {940, 59}, {990, 30}, {920, 200},
  38.         {900, 259}, {660, 50}, {540, 90},
  39.         {810, 220}, {860, 20}, {740, 180},
  40.         {820, 128}, {490, 170}, {700, 30}
  41.     };
  43.     public Board() {
  45.         initBoard();
  46.     }
  48.     private void initBoard() {
  50.         addKeyListener(new TAdapter());
  51.         setFocusable(true);
  52.         setBackground(Color.BLACK);
  53.         ingame = true;
  55.         setPreferredSize(new Dimension(B_WIDTH, B_HEIGHT));
  57.         spaceship = new SpaceShip(ICRAFT_X, ICRAFT_Y);
  59.         initAliens();
  61.         timer = new Timer(DELAY, this);
  62.         timer.start();
  63.     }
  65.     public void initAliens() {
  67.         aliens = new ArrayList<>();
  69.         for (int[] p : pos) {
  70.             aliens.add(new Alien(p[0], p[1]));
  71.         }
  72.     }
  74.     @Override
  75.     public void paintComponent(Graphics g) {
  76.         super.paintComponent(g);
  78.         if (ingame) {
  80.             drawObjects(g);
  82.         } else {
  84.             drawGameOver(g);
  85.         }
  87.         Toolkit.getDefaultToolkit().sync();
  88.     }
  90.     private void drawObjects(Graphics g) {
  92.         if (spaceship.isVisible()) {
  93.             g.drawImage(spaceship.getImage(), spaceship.getX(), spaceship.getY(),
  94.                     this);
  95.         }
  97.         List<Missile> ms = spaceship.getMissiles();
  99.         for (Missile missile : ms) {
  100.             if (missile.isVisible()) {
  101.                 g.drawImage(missile.getImage(), missile.getX(), 
  102.                         missile.getY(), this);
  103.             }
  104.         }
  106.         for (Alien alien : aliens) {
  107.             if (alien.isVisible()) {
  108.                 g.drawImage(alien.getImage(), alien.getX(), alien.getY(), this);
  109.             }
  110.         }
  112.         g.setColor(Color.WHITE);
  113.         g.drawString("Aliens left: " + aliens.size(), 5, 15);
  114.     }
  116.     private void drawGameOver(Graphics g) {
  118.         String msg = "Game Over";
  119.         Font small = new Font("Helvetica", Font.BOLD, 14);
  120.         FontMetrics fm = getFontMetrics(small);
  122.         g.setColor(Color.white);
  123.         g.setFont(small);
  124.         g.drawString(msg, (B_WIDTH - fm.stringWidth(msg)) / 2,
  125.                 B_HEIGHT / 2);
  126.     }
  128.     @Override
  129.     public void actionPerformed(ActionEvent e) {
  131.         inGame();
  133.         updateShip();
  134.         updateMissiles();
  135.         updateAliens();
  137.         checkCollisions();
  139.         repaint();
  140.     }
  142.     private void inGame() {
  144.         if (!ingame) {
  145.             timer.stop();
  146.         }
  147.     }
  149.     private void updateShip() {
  151.         if (spaceship.isVisible()) {
  153.             spaceship.move();
  154.         }
  155.     }
  157.     private void updateMissiles() {
  159.         List<Missile> ms = spaceship.getMissiles();
  161.         for (int i = 0; i < ms.size(); i++) {
  163.             Missile m = ms.get(i);
  165.             if (m.isVisible()) {
  166.                 m.move();
  167.             } else {
  168.                 ms.remove(i);
  169.             }
  170.         }
  171.     }
  173.     private void updateAliens() {
  175.         if (aliens.isEmpty()) {
  177.             ingame = false;
  178.             return;
  179.         }
  181.         for (int i = 0; i < aliens.size(); i++) {
  183.             Alien a = aliens.get(i);
  185.             if (a.isVisible()) {
  186.                 a.move();
  187.             } else {
  188.                 aliens.remove(i);
  189.             }
  190.         }
  191.     }
  193.     public void checkCollisions() {
  195.         Rectangle r3 = spaceship.getBounds();
  197.         for (Alien alien : aliens) {
  199.             Rectangle r2 = alien.getBounds();
  201.             if (r3.intersects(r2)) {
  203.                 spaceship.setVisible(false);
  204.                 alien.setVisible(false);
  205.                 ingame = false;
  206.             }
  207.         }
  209.         List<Missile> ms = spaceship.getMissiles();
  211.         for (Missile m : ms) {
  213.             Rectangle r1 = m.getBounds();
  215.             for (Alien alien : aliens) {
  217.                 Rectangle r2 = alien.getBounds();
  219.                 if (r1.intersects(r2)) {
  221.                     m.setVisible(false);
  222.                     alien.setVisible(false);
  223.                 }
  224.             }
  225.         }
  226.     }
  228.     private class TAdapter extends KeyAdapter {
  230.         @Override
  231.         public void keyReleased(KeyEvent e) {
  232.             spaceship.keyReleased(e);
  233.         }
  235.         @Override
  236.         public void keyPressed(KeyEvent e) {
  237.             spaceship.keyPressed(e);
  238.         }
  239.     }
  240. }

这是Board类。

  1. private final int[][] pos = {
  2.     {2380, 29}, {2500, 59}, {1380, 89},
  3.     {780, 109}, {580, 139}, {680, 239},
  4.     {790, 259}, {760, 50}, {790, 150},
  5.     {980, 209}, {560, 45}, {510, 70},
  6.     {930, 159}, {590, 80}, {530, 60},
  7.     {940, 59}, {990, 30}, {920, 200},
  8.     {900, 259}, {660, 50}, {540, 90},
  9.     {810, 220}, {860, 20}, {740, 180},
  10.     {820, 128}, {490, 170}, {700, 30}
  11. };

这些是外星飞船的初始位置。

  1. public void initAliens() {
  3.     aliens = new ArrayList<>();
  5.     for (int[] p : pos) {
  6.         aliens.add(new Alien(p[0], p[1]));
  7.     }
  8. }

initAliens()方法创建一个外星对象列表。 外星人从pos数组中占据初始位置。

  1. @Override
  2. public void paintComponent(Graphics g) {
  3.     super.paintComponent(g);
  5.     if (ingame) {
  7.         drawObjects(g);
  9.     } else {
  11.         drawGameOver(g);
  12.     }
  14.     Toolkit.getDefaultToolkit().sync();
  15. }

在paintComponent()方法内，我们绘制游戏精灵或通过消息编写游戏。 这取决于ingame变量。

  1. private void drawObjects(Graphics g) {
  3.     if (spaceship.isVisible()) {
  4.         g.drawImage(spaceship.getImage(), spaceship.getX(), spaceship.getY(),
  5.                 this);
  6.     }
  7. ...
  8. }

drawObjects()方法在窗口上绘制游戏精灵。 首先，我们绘制工艺精灵。

  1. for (Alien alien : aliens) {
  2.     if (alien.isVisible()) {
  3.         g.drawImage(alien.getImage(), alien.getX(), alien.getY(), this);
  4.     }
  5. }

在这个循环中，我们吸引了所有外星人。 仅在以前未销毁它们的情况下才绘制它们。 通过isVisible()方法检查。

  1. g.setColor(Color.WHITE);
  2. g.drawString("Aliens left: " + aliens.size(), 5, 15);

在窗口的左上角，我们绘制了剩余的外星人数量。

  1. private void drawGameOver(Graphics g) {
  3.     String msg = "Game Over";
  4.     Font small = new Font("Helvetica", Font.BOLD, 14);
  5.     FontMetrics fm = getFontMetrics(small);
  7.     g.setColor(Color.white);
  8.     g.setFont(small);
  9.     g.drawString(msg, (B_WIDTH - fm.stringWidth(msg)) / 2,
  10.             B_HEIGHT / 2);
  11. }

drawGameOver()在窗口中间的消息上方绘制游戏。 该消息显示在游戏结束时，当我们摧毁所有外星飞船或与其中一艘发生碰撞时。

  1. @Override
  2. public void actionPerformed(ActionEvent e) {
  4.     inGame();
  6.     updateShip();
  7.     updateMissiles();
  8.     updateAliens();
  10.     checkCollisions();
  12.     repaint();
  13. }

每个动作事件代表一个游戏周期。 游戏逻辑被纳入特定方法中。 例如，updateMissiles()会移动所有可用的导弹。

  1. private void updateAliens() {
  3.     if (aliens.isEmpty()) {
  5.         ingame = false;
  6.         return;
  7.     }
  9.     for (int i = 0; i < aliens.size(); i++) {
  11.         Alien a = aliens.get(i);
  13.         if (a.isVisible()) {
  14.             a.move();
  15.         } else {
  16.             aliens.remove(i);
  17.         }
  18.     }
  19. }

在updateAliens()方法内部，我们首先检查aliens列表中是否还有任何异物。 如果列表为空，则游戏结束。 如果它不为空，则浏览列表并移动其所有项目。 被摧毁的外星人将从名单中删除。

  1. public void checkCollisions() {
  3.     Rectangle r3 = spaceship.getBounds();
  5.     for (Alien alien : aliens) {
  7.         Rectangle r2 = alien.getBounds();
  9.         if (r3.intersects(r2)) {
  11.             spaceship.setVisible(false);
  12.             alien.setVisible(false);
  13.             ingame = false;
  14.         }
  15.     }
  16. ...
  17. }

checkCollisions()方法检查可能的冲突。 首先，我们检查工艺对象是否与任何外来对象发生碰撞。 我们使用getBounds()方法获得对象的矩形。 intersects()方法检查两个矩形是否相交。

  1. List<Missile> ms = spaceship.getMissiles();
  3. for (Missile m : ms) {
  5.     Rectangle r1 = m.getBounds();
  7.     for (Alien alien : aliens) {
  9.         Rectangle r2 = alien.getBounds();
  11.         if (r1.intersects(r2)) {
  13.             m.setVisible(false);
  14.             alien.setVisible(false);
  15.         }
  16.     }
  17. }

该代码检查导弹与外星人之间的碰撞。

Alien.java

  1. package com.zetcode;
  3. public class Alien extends Sprite {
  5.     private final int INITIAL_X = 400;
  7.     public Alien(int x, int y) {
  8.         super(x, y);
  10.         initAlien();
  11.     }
  13.     private void initAlien() {
  15.         loadImage("src/resources/alien.png");
  16.         getImageDimensions();
  17.     }
  19.     public void move() {
  21.         if (x < 0) {
  22.             x = INITIAL_X;
  23.         }
  25.         x -= 1;
  26.     }
  27. }

这是Alien类。

  1. public void move() {
  3.     if (x < 0) {
  4.         x = INITIAL_X;
  5.     }
  7.     x -= 1;
  8. }

外星人消失在左侧后，他们会返回到右侧的屏幕。

Missile.java

  1. package com.zetcode;
  3. public class Missile extends Sprite {
  5.     private final int BOARD_WIDTH = 390;
  6.     private final int MISSILE_SPEED = 2;
  8.     public Missile(int x, int y) {
  9.         super(x, y);
  11.         initMissile();
  12.     }
  14.     private void initMissile() {
  16.         loadImage("src/resources/missile.png");
  17.         getImageDimensions();        
  18.     }
  20.     public void move() {
  22.         x += MISSILE_SPEED;
  24.         if (x > BOARD_WIDTH)
  25.             visible = false;
  26.     }
  27. }

这是Missile类。

  1. public void move() {
  3.     x += MISSILE_SPEED;
  5.     if (x > BOARD_WIDTH)
  6.         visible = false;
  7. }

导弹只能向一个方向移动。 它们到达右窗口边框后消失。

CollisionEx.java

  1. package com.zetcode;
  3. import java.awt.EventQueue;
  4. import javax.swing.JFrame;
  6. public class CollisionEx extends JFrame {
  8.     public CollisionEx() {
  10.         initUI();
  11.     }
  13.     private void initUI() {
  15.         add(new Board());
  17.         setResizable(false);
  18.         pack();
  20.         setTitle("Collision");
  21.         setLocationRelativeTo(null);
  22.         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  23.     }
  25.     public static void main(String[] args) {
  27.         EventQueue.invokeLater(() -> {
  28.             CollisionEx ex = new CollisionEx();
  29.             ex.setVisible(true);
  30.         });
  31.     }
  32. }

最后，这是主要类。

碰撞检测 - 图1

图：射击外星人

本章是关于碰撞检测的。