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

在 Java 2D 游戏教程的这一部分中，我们将使用 Java 创建一个简单的太空侵略者游戏克隆。 源代码和图像可在作者的 Github Java-Space-Invaders 存储库中找到。

太空侵略者是由 Nishikado Tomohiro Nishikado 设计的街机游戏。 它于 1978 年首次发布。

在“太空侵略者”游戏中，玩家控制一门大炮。 他即将拯救地球免遭邪恶太空入侵者的入侵。

用 Java 开发太空侵略者

在我们的 Java 克隆中，我们有 24 个入侵者。 这些外星人重重炮击地面。 当玩家射击导弹时，只有当导弹击中外星人或棋盘顶部时，他才能射击另一枚导弹。 玩家使用空格键射击。 外星人随机发射炸弹。 每个外星人只有在前一个击中底部后才会发射炸弹。

com/zetcode/SpaceInvaders.java

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

这是主要的类。 它设置了应用。

com/zetcode/Commons.java

  1. package com.zetcode;
  3. public interface Commons {
  5.     int BOARD_WIDTH = 358;
  6.     int BOARD_HEIGHT = 350;
  7.     int BORDER_RIGHT = 30;
  8.     int BORDER_LEFT = 5;
  10.     int GROUND = 290;
  11.     int BOMB_HEIGHT = 5;
  13.     int ALIEN_HEIGHT = 12;
  14.     int ALIEN_WIDTH = 12;
  15.     int ALIEN_INIT_X = 150;
  16.     int ALIEN_INIT_Y = 5;
  18.     int GO_DOWN = 15;
  19.     int NUMBER_OF_ALIENS_TO_DESTROY = 24;
  20.     int CHANCE = 5;
  21.     int DELAY = 17;
  22.     int PLAYER_WIDTH = 15;
  23.     int PLAYER_HEIGHT = 10;
  24. }

Commons.java文件具有一些公共常数。 他们是不言自明的。

com/zetcode/sprite/Alien.java

  1. package com.zetcode.sprite;
  3. import javax.swing.ImageIcon;
  5. public class Alien extends Sprite {
  7.     private Bomb bomb;
  9.     public Alien(int x, int y) {
  11.         initAlien(x, y);
  12.     }
  14.     private void initAlien(int x, int y) {
  16.         this.x = x;
  17.         this.y = y;
  19.         bomb = new Bomb(x, y);
  21.         var alienImg = "simg/alien.png";
  22.         var ii = new ImageIcon(alienImg);
  24.         setImage(ii.getImage());
  25.     }
  27.     public void act(int direction) {
  29.         this.x += direction;
  30.     }
  32.     public Bomb getBomb() {
  34.         return bomb;
  35.     }
  37.     public class Bomb extends Sprite {
  39.         private boolean destroyed;
  41.         public Bomb(int x, int y) {
  43.             initBomb(x, y);
  44.         }
  46.         private void initBomb(int x, int y) {
  48.             setDestroyed(true);
  50.             this.x = x;
  51.             this.y = y;
  53.             var bombImg = "simg/bomb.png";
  54.             var ii = new ImageIcon(bombImg);
  55.             setImage(ii.getImage());
  56.         }
  58.         public void setDestroyed(boolean destroyed) {
  60.             this.destroyed = destroyed;
  61.         }
  63.         public boolean isDestroyed() {
  65.             return destroyed;
  66.         }
  67.     }
  68. }

这是Alien子画面。 每个外星人都有一个内部的Bomb类。

  1. public void act(int direction) {
  3.     this.x += direction;
  4. }

从Board类中调用act()方法。 用于在水平方向上定位外星人。

  1. public Bomb getBomb() {
  3.     return bomb;
  4. }

当外星人将要投下炸弹时，将调用getBomb()方法。

com/zetcode/sprite/Player.java

  1. package com.zetcode.sprite;
  3. import com.zetcode.Commons;
  5. import javax.swing.ImageIcon;
  6. import java.awt.event.KeyEvent;
  8. public class Player extends Sprite {
  10.     private int width;
  12.     public Player() {
  14.         initPlayer();
  15.     }
  17.     private void initPlayer() {
  19.         var playerImg = "simg/player.png";
  20.         var ii = new ImageIcon(playerImg);
  22.         width = ii.getImage().getWidth(null);
  23.         setImage(ii.getImage());
  25.         int START_X = 270;
  26.         setX(START_X);
  28.         int START_Y = 280;
  29.         setY(START_Y);
  30.     }
  32.     public void act() {
  34.         x += dx;
  36.         if (x <= 2) {
  38.             x = 2;
  39.         }
  41.         if (x >= Commons.BOARD_WIDTH - 2 * width) {
  43.             x = Commons.BOARD_WIDTH - 2 * width;
  44.         }
  45.     }
  47.     public void keyPressed(KeyEvent e) {
  49.         int key = e.getKeyCode();
  51.         if (key == KeyEvent.VK_LEFT) {
  53.             dx = -2;
  54.         }
  56.         if (key == KeyEvent.VK_RIGHT) {
  58.             dx = 2;
  59.         }
  60.     }
  62.     public void keyReleased(KeyEvent e) {
  64.         int key = e.getKeyCode();
  66.         if (key == KeyEvent.VK_LEFT) {
  68.             dx = 0;
  69.         }
  71.         if (key == KeyEvent.VK_RIGHT) {
  73.             dx = 0;
  74.         }
  75.     }
  76. }

这是Player子画面。 我们用光标键控制大炮。

  1. int START_X = 270;
  2. setX(START_X);
  4. int START_Y = 280;
  5. setY(START_Y);

这些是播放器精灵的初始坐标。

  1. public void keyPressed(KeyEvent e) {
  3.     int key = e.getKeyCode();
  5.     if (key == KeyEvent.VK_LEFT) {
  7.         dx = -2;
  8.     }
  9. ...

如果按左光标键，则dx变量将设置为 -2。 下次调用act()方法时，播放器向左移动。

  1. public void keyReleased(KeyEvent e) {
  3.     int key = e.getKeyCode();
  5.     if (key == KeyEvent.VK_LEFT) {
  7.         dx = 0;
  8.     }
  10.     if (key == KeyEvent.VK_RIGHT) {
  12.         dx = 0;
  13.     }
  14. }

如果释放左或右光标，则dx变量将设置为零。 播放器精灵停止移动。

com/zetcode/sprite/Shot.java

  1. package com.zetcode.sprite;
  3. import javax.swing.ImageIcon;
  5. public class Shot extends Sprite {
  7.     public Shot() {
  8.     }
  10.     public Shot(int x, int y) {
  12.         initShot(x, y);
  13.     }
  15.     private void initShot(int x, int y) {
  17.         var shotImg = "simg/shot.png";
  18.         var ii = new ImageIcon(shotImg);
  19.         setImage(ii.getImage());
  21.         int H_SPACE = 6;
  22.         setX(x + H_SPACE);
  24.         int V_SPACE = 1;
  25.         setY(y - V_SPACE);
  26.     }
  27. }

这是Shot子画面。 用 Space 键触发射击。 H_SPACE和V_SPACE常数用于适当地定位导弹。

com/zetcode/sprite/Sprite.java

  1. package com.zetcode.sprite;
  3. import java.awt.Image;
  5. public class Sprite {
  7.     private boolean visible;
  8.     private Image image;
  9.     private boolean dying;
  11.     int x;
  12.     int y;
  13.     int dx;
  15.     public Sprite() {
  17.         visible = true;
  18.     }
  20.     public void die() {
  22.         visible = false;
  23.     }
  25.     public boolean isVisible() {
  27.         return visible;
  28.     }
  30.     protected void setVisible(boolean visible) {
  32.         this.visible = visible;
  33.     }
  35.     public void setImage(Image image) {
  37.         this.image = image;
  38.     }
  40.     public Image getImage() {
  42.         return image;
  43.     }
  45.     public void setX(int x) {
  47.         this.x = x;
  48.     }
  50.     public void setY(int y) {
  52.         this.y = y;
  53.     }
  55.     public int getY() {
  57.         return y;
  58.     }
  60.     public int getX() {
  62.         return x;
  63.     }
  65.     public void setDying(boolean dying) {
  67.         this.dying = dying;
  68.     }
  70.     public boolean isDying() {
  72.         return this.dying;
  73.     }
  74. }

这是基本的Sprite类。 其他精灵也继承自它。 它具有一些常用功能。

com/zetcode/Board.java

  1. package com.zetcode;
  3. import com.zetcode.sprite.Alien;
  4. import com.zetcode.sprite.Player;
  5. import com.zetcode.sprite.Shot;
  7. import javax.swing.ImageIcon;
  8. import javax.swing.JPanel;
  9. import javax.swing.Timer;
  10. import java.awt.Color;
  11. import java.awt.Dimension;
  12. import java.awt.Font;
  13. import java.awt.Graphics;
  14. import java.awt.Toolkit;
  15. import java.awt.event.ActionEvent;
  16. import java.awt.event.ActionListener;
  17. import java.awt.event.KeyAdapter;
  18. import java.awt.event.KeyEvent;
  19. import java.util.ArrayList;
  20. import java.util.Iterator;
  21. import java.util.List;
  22. import java.util.Random;
  24. public class Board extends JPanel {
  26.     private Dimension d;
  27.     private List<Alien> aliens;
  28.     private Player player;
  29.     private Shot shot;
  31.     private int direction = -1;
  32.     private int deaths = 0;
  34.     private boolean inGame = true;
  35.     private String explImg = "simg/explosion.png";
  36.     private String message = "Game Over";
  38.     private Timer timer;
  40.     public Board() {
  42.         initBoard();
  43.         gameInit();
  44.     }
  46.     private void initBoard() {
  48.         addKeyListener(new TAdapter());
  49.         setFocusable(true);
  50.         d = new Dimension(Commons.BOARD_WIDTH, Commons.BOARD_HEIGHT);
  51.         setBackground(Color.black);
  53.         timer = new Timer(Commons.DELAY, new GameCycle());
  54.         timer.start();
  56.         gameInit();
  57.     }
  59.     private void gameInit() {
  61.         aliens = new ArrayList<>();
  63.         for (int i = 0; i < 4; i++) {
  64.             for (int j = 0; j < 6; j++) {
  66.                 var alien = new Alien(Commons.ALIEN_INIT_X + 18 * j,
  67.                         Commons.ALIEN_INIT_Y + 18 * i);
  68.                 aliens.add(alien);
  69.             }
  70.         }
  72.         player = new Player();
  73.         shot = new Shot();
  74.     }
  76.     private void drawAliens(Graphics g) {
  78.         for (Alien alien : aliens) {
  80.             if (alien.isVisible()) {
  82.                 g.drawImage(alien.getImage(), alien.getX(), alien.getY(), this);
  83.             }
  85.             if (alien.isDying()) {
  87.                 alien.die();
  88.             }
  89.         }
  90.     }
  92.     private void drawPlayer(Graphics g) {
  94.         if (player.isVisible()) {
  96.             g.drawImage(player.getImage(), player.getX(), player.getY(), this);
  97.         }
  99.         if (player.isDying()) {
  101.             player.die();
  102.             inGame = false;
  103.         }
  104.     }
  106.     private void drawShot(Graphics g) {
  108.         if (shot.isVisible()) {
  110.             g.drawImage(shot.getImage(), shot.getX(), shot.getY(), this);
  111.         }
  112.     }
  114.     private void drawBombing(Graphics g) {
  116.         for (Alien a : aliens) {
  118.             Alien.Bomb b = a.getBomb();
  120.             if (!b.isDestroyed()) {
  122.                 g.drawImage(b.getImage(), b.getX(), b.getY(), this);
  123.             }
  124.         }
  125.     }
  127.     @Override
  128.     public void paintComponent(Graphics g) {
  129.         super.paintComponent(g);
  131.         doDrawing(g);
  132.     }
  134.     private void doDrawing(Graphics g) {
  136.         g.setColor(Color.black);
  137.         g.fillRect(0, 0, d.width, d.height);
  138.         g.setColor(Color.green);
  140.         if (inGame) {
  142.             g.drawLine(0, Commons.GROUND,
  143.                     Commons.BOARD_WIDTH, Commons.GROUND);
  145.             drawAliens(g);
  146.             drawPlayer(g);
  147.             drawShot(g);
  148.             drawBombing(g);
  150.         } else {
  152.             if (timer.isRunning()) {
  153.                 timer.stop();
  154.             }
  156.             gameOver(g);
  157.         }
  159.         Toolkit.getDefaultToolkit().sync();
  160.     }
  162.     private void gameOver(Graphics g) {
  164.         g.setColor(Color.black);
  165.         g.fillRect(0, 0, Commons.BOARD_WIDTH, Commons.BOARD_HEIGHT);
  167.         g.setColor(new Color(0, 32, 48));
  168.         g.fillRect(50, Commons.BOARD_WIDTH / 2 - 30, Commons.BOARD_WIDTH - 100, 50);
  169.         g.setColor(Color.white);
  170.         g.drawRect(50, Commons.BOARD_WIDTH / 2 - 30, Commons.BOARD_WIDTH - 100, 50);
  172.         var small = new Font("Helvetica", Font.BOLD, 14);
  173.         var fontMetrics = this.getFontMetrics(small);
  175.         g.setColor(Color.white);
  176.         g.setFont(small);
  177.         g.drawString(message, (Commons.BOARD_WIDTH - fontMetrics.stringWidth(message)) / 2,
  178.                 Commons.BOARD_WIDTH / 2);
  179.     }
  181.     private void update() {
  183.         if (deaths == Commons.NUMBER_OF_ALIENS_TO_DESTROY) {
  185.             inGame = false;
  186.             timer.stop();
  187.             message = "Game won!";
  188.         }
  190.         // player
  191.         player.act();
  193.         // shot
  194.         if (shot.isVisible()) {
  196.             int shotX = shot.getX();
  197.             int shotY = shot.getY();
  199.             for (Alien alien : aliens) {
  201.                 int alienX = alien.getX();
  202.                 int alienY = alien.getY();
  204.                 if (alien.isVisible() && shot.isVisible()) {
  205.                     if (shotX >= (alienX)
  206.                             && shotX <= (alienX + Commons.ALIEN_WIDTH)
  207.                             && shotY >= (alienY)
  208.                             && shotY <= (alienY + Commons.ALIEN_HEIGHT)) {
  210.                         var ii = new ImageIcon(explImg);
  211.                         alien.setImage(ii.getImage());
  212.                         alien.setDying(true);
  213.                         deaths++;
  214.                         shot.die();
  215.                     }
  216.                 }
  217.             }
  219.             int y = shot.getY();
  220.             y -= 4;
  222.             if (y < 0) {
  223.                 shot.die();
  224.             } else {
  225.                 shot.setY(y);
  226.             }
  227.         }
  229.         // aliens
  231.         for (Alien alien : aliens) {
  233.             int x = alien.getX();
  235.             if (x >= Commons.BOARD_WIDTH - Commons.BORDER_RIGHT && direction != -1) {
  237.                 direction = -1;
  239.                 Iterator<Alien> i1 = aliens.iterator();
  241.                 while (i1.hasNext()) {
  243.                     Alien a2 = i1.next();
  244.                     a2.setY(a2.getY() + Commons.GO_DOWN);
  245.                 }
  246.             }
  248.             if (x <= Commons.BORDER_LEFT && direction != 1) {
  250.                 direction = 1;
  252.                 Iterator<Alien> i2 = aliens.iterator();
  254.                 while (i2.hasNext()) {
  256.                     Alien a = i2.next();
  257.                     a.setY(a.getY() + Commons.GO_DOWN);
  258.                 }
  259.             }
  260.         }
  262.         Iterator<Alien> it = aliens.iterator();
  264.         while (it.hasNext()) {
  266.             Alien alien = it.next();
  268.             if (alien.isVisible()) {
  270.                 int y = alien.getY();
  272.                 if (y > Commons.GROUND - Commons.ALIEN_HEIGHT) {
  273.                     inGame = false;
  274.                     message = "Invasion!";
  275.                 }
  277.                 alien.act(direction);
  278.             }
  279.         }
  281.         // bombs
  282.         var generator = new Random();
  284.         for (Alien alien : aliens) {
  286.             int shot = generator.nextInt(15);
  287.             Alien.Bomb bomb = alien.getBomb();
  289.             if (shot == Commons.CHANCE && alien.isVisible() && bomb.isDestroyed()) {
  291.                 bomb.setDestroyed(false);
  292.                 bomb.setX(alien.getX());
  293.                 bomb.setY(alien.getY());
  294.             }
  296.             int bombX = bomb.getX();
  297.             int bombY = bomb.getY();
  298.             int playerX = player.getX();
  299.             int playerY = player.getY();
  301.             if (player.isVisible() && !bomb.isDestroyed()) {
  303.                 if (bombX >= (playerX)
  304.                         && bombX <= (playerX + Commons.PLAYER_WIDTH)
  305.                         && bombY >= (playerY)
  306.                         && bombY <= (playerY + Commons.PLAYER_HEIGHT)) {
  308.                     var ii = new ImageIcon(explImg);
  309.                     player.setImage(ii.getImage());
  310.                     player.setDying(true);
  311.                     bomb.setDestroyed(true);
  312.                 }
  313.             }
  315.             if (!bomb.isDestroyed()) {
  317.                 bomb.setY(bomb.getY() + 1);
  319.                 if (bomb.getY() >= Commons.GROUND - Commons.BOMB_HEIGHT) {
  321.                     bomb.setDestroyed(true);
  322.                 }
  323.             }
  324.         }
  325.     }
  327.     private void doGameCycle() {
  329.         update();
  330.         repaint();
  331.     }
  333.     private class GameCycle implements ActionListener {
  335.         @Override
  336.         public void actionPerformed(ActionEvent e) {
  338.             doGameCycle();
  339.         }
  340.     }
  342.     private class TAdapter extends KeyAdapter {
  344.         @Override
  345.         public void keyReleased(KeyEvent e) {
  347.             player.keyReleased(e);
  348.         }
  350.         @Override
  351.         public void keyPressed(KeyEvent e) {
  353.             player.keyPressed(e);
  355.             int x = player.getX();
  356.             int y = player.getY();
  358.             int key = e.getKeyCode();
  360.             if (key == KeyEvent.VK_SPACE) {
  362.                 if (inGame) {
  364.                     if (!shot.isVisible()) {
  366.                         shot = new Shot(x, y);
  367.                     }
  368.                 }
  369.             }
  370.         }
  371.     }
  372. }

游戏的主要逻辑位于Board类中。

private void gameInit() {

    aliens = new ArrayList<>();

    for (int i = 0; i < 4; i++) {
        for (int j = 0; j < 6; j++) {

            var alien = new Alien(Commons.ALIEN_INIT_X + 18 * j,
                    Commons.ALIEN_INIT_Y + 18 * i);
            aliens.add(alien);
        }
    }

    player = new Player();
    shot = new Shot();
}

在gameInit()方法中，我们创建了 24 个外星人。 外星人图像大小为12x12px。 我们在外星人中间放了 6px 的空间。 我们还创建了播放器和射击对象。

private void drawBombing(Graphics g) {

    for (Alien a : aliens) {

        Alien.Bomb b = a.getBomb();

        if (!b.isDestroyed()) {

            g.drawImage(b.getImage(), b.getX(), b.getY(), this);
        }
    }
}

drawBombing()方法绘制由外星人发射的炸弹。

if (inGame) {

    g.drawLine(0, Commons.GROUND,
            Commons.BOARD_WIDTH, Commons.GROUND);

    drawAliens(g);
    drawPlayer(g);
    drawShot(g);
    drawBombing(g);

} ...

在doDrawing()方法中，我们绘制地面，外星人，玩家，射击和炸弹。

private void update() {

    if (deaths == Commons.NUMBER_OF_ALIENS_TO_DESTROY) {

        inGame = false;
        timer.stop();
        message = "Game won!";
    }
...

在update()方法内，我们检查损坏的行数。 如果我们消灭所有外星人，我们将赢得比赛。

if (alien.isVisible() && shot.isVisible()) {
    if (shotX >= (alienX)
            && shotX <= (alienX + Commons.ALIEN_WIDTH)
            && shotY >= (alienY)
            && shotY <= (alienY + Commons.ALIEN_HEIGHT)) {

        var ii = new ImageIcon(explImg);
        alien.setImage(ii.getImage());
        alien.setDying(true);
        deaths++;
        shot.die();
    }
}

如果玩家触发的射击与外星人发生碰撞，则该外星人的船只将被摧毁。 更确切地说，将设置垂死标记。 我们用它来显示爆炸。 死亡变量增加，射击精灵被破坏。

if (x >= Commons.BOARD_WIDTH - Commons.BORDER_RIGHT && direction != -1) {

    direction = -1;

    Iterator<Alien> i1 = aliens.iterator();

    while (i1.hasNext()) {

        Alien a2 = i1.next();
        a2.setY(a2.getY() + Commons.GO_DOWN);
    }
}

如果外星人到达Board的右端，他们将向下移动并将其方向更改为左侧。

Iterator<Alien> it = aliens.iterator();

    while (it.hasNext()) {

        Alien alien = it.next();

        if (alien.isVisible()) {

            int y = alien.getY();

            if (y > Commons.GROUND - Commons.ALIEN_HEIGHT) {
                inGame = false;
                message = "Invasion!";
            }

            alien.act(direction);
        }
    }

此代码可移动外星人。 如果他们到达最低点，入侵就开始了。

int shot = generator.nextInt(15);
Alien.Bomb bomb = alien.getBomb();

if (shot == Commons.CHANCE && alien.isVisible() && bomb.isDestroyed()) {

    bomb.setDestroyed(false);
    bomb.setX(alien.getX());
    bomb.setY(alien.getY());
}

这是确定外星人是否会投下炸弹的代码。 不得破坏外星人； 即他必须是可见的。 必须设置炸弹的销毁标志。 换句话说，这是外星人的第一枚炸弹掉落，或者是先前投下的炸弹已经落地。 如果满足这两个条件，轰炸就留给了机会。

if (!bomb.isDestroyed()) {

    bomb.setY(bomb.getY() + 1);

    if (bomb.getY() >= Commons.GROUND - Commons.BOMB_HEIGHT) {

        bomb.setDestroyed(true);
    }
}

如果炸弹没有被销毁，它将离地面 1px。 如果到达底部，则设置销毁标志。 外星人现在准备投下另一枚炸弹。

public void keyReleased(KeyEvent e) {

    player.keyReleased(e);
}

此特定KeyEvent的实际处理被委派给播放器精灵。

Java 太空侵略者 - 图1

图：太空侵略者

在 Java 游戏教程的这一部分中，我们创建了太空侵略者。