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

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

贪食蛇

贪食蛇是较旧的经典视频游戏。 它最初是在 70 年代后期创建的。 后来它被带到 PC 上。 在这个游戏中，玩家控制蛇。 目的是尽可能多地吃苹果。 蛇每吃一个苹果，它的身体就会长大。 蛇必须避开墙壁和自己的身体。 该游戏有时称为 Nibbles 。

Java 贪食蛇游戏的开发

蛇的每个关节的大小为 10 像素。 蛇由光标键控制。 最初，蛇具有三个关节。 如果游戏结束，则在面板中间显示"Game Over"消息。

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.Image;
  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 javax.swing.ImageIcon;
  15. import javax.swing.JPanel;
  16. import javax.swing.Timer;
  18. public class Board extends JPanel implements ActionListener {
  20.     private final int B_WIDTH = 300;
  21.     private final int B_HEIGHT = 300;
  22.     private final int DOT_SIZE = 10;
  23.     private final int ALL_DOTS = 900;
  24.     private final int RAND_POS = 29;
  25.     private final int DELAY = 140;
  27.     private final int x[] = new int[ALL_DOTS];
  28.     private final int y[] = new int[ALL_DOTS];
  30.     private int dots;
  31.     private int apple_x;
  32.     private int apple_y;
  34.     private boolean leftDirection = false;
  35.     private boolean rightDirection = true;
  36.     private boolean upDirection = false;
  37.     private boolean downDirection = false;
  38.     private boolean inGame = true;
  40.     private Timer timer;
  41.     private Image ball;
  42.     private Image apple;
  43.     private Image head;
  45.     public Board() {
  47.         initBoard();
  48.     }
  50.     private void initBoard() {
  52.         addKeyListener(new TAdapter());
  53.         setBackground(Color.black);
  54.         setFocusable(true);
  56.         setPreferredSize(new Dimension(B_WIDTH, B_HEIGHT));
  57.         loadImages();
  58.         initGame();
  59.     }
  61.     private void loadImages() {
  63.         ImageIcon iid = new ImageIcon("src/resources/dot.png");
  64.         ball = iid.getImage();
  66.         ImageIcon iia = new ImageIcon("src/resources/apple.png");
  67.         apple = iia.getImage();
  69.         ImageIcon iih = new ImageIcon("src/resources/head.png");
  70.         head = iih.getImage();
  71.     }
  73.     private void initGame() {
  75.         dots = 3;
  77.         for (int z = 0; z < dots; z++) {
  78.             x[z] = 50 - z * 10;
  79.             y[z] = 50;
  80.         }
  82.         locateApple();
  84.         timer = new Timer(DELAY, this);
  85.         timer.start();
  86.     }
  88.     @Override
  89.     public void paintComponent(Graphics g) {
  90.         super.paintComponent(g);
  92.         doDrawing(g);
  93.     }
  95.     private void doDrawing(Graphics g) {
  97.         if (inGame) {
  99.             g.drawImage(apple, apple_x, apple_y, this);
  101.             for (int z = 0; z < dots; z++) {
  102.                 if (z == 0) {
  103.                     g.drawImage(head, x[z], y[z], this);
  104.                 } else {
  105.                     g.drawImage(ball, x[z], y[z], this);
  106.                 }
  107.             }
  109.             Toolkit.getDefaultToolkit().sync();
  111.         } else {
  113.             gameOver(g);
  114.         }        
  115.     }
  117.     private void gameOver(Graphics g) {
  119.         String msg = "Game Over";
  120.         Font small = new Font("Helvetica", Font.BOLD, 14);
  121.         FontMetrics metr = getFontMetrics(small);
  123.         g.setColor(Color.white);
  124.         g.setFont(small);
  125.         g.drawString(msg, (B_WIDTH - metr.stringWidth(msg)) / 2, B_HEIGHT / 2);
  126.     }
  128.     private void checkApple() {
  130.         if ((x[0] == apple_x) && (y[0] == apple_y)) {
  132.             dots++;
  133.             locateApple();
  134.         }
  135.     }
  137.     private void move() {
  139.         for (int z = dots; z > 0; z--) {
  140.             x[z] = x[(z - 1)];
  141.             y[z] = y[(z - 1)];
  142.         }
  144.         if (leftDirection) {
  145.             x[0] -= DOT_SIZE;
  146.         }
  148.         if (rightDirection) {
  149.             x[0] += DOT_SIZE;
  150.         }
  152.         if (upDirection) {
  153.             y[0] -= DOT_SIZE;
  154.         }
  156.         if (downDirection) {
  157.             y[0] += DOT_SIZE;
  158.         }
  159.     }
  161.     private void checkCollision() {
  163.         for (int z = dots; z > 0; z--) {
  165.             if ((z > 4) && (x[0] == x[z]) && (y[0] == y[z])) {
  166.                 inGame = false;
  167.             }
  168.         }
  170.         if (y[0] >= B_HEIGHT) {
  171.             inGame = false;
  172.         }
  174.         if (y[0] < 0) {
  175.             inGame = false;
  176.         }
  178.         if (x[0] >= B_WIDTH) {
  179.             inGame = false;
  180.         }
  182.         if (x[0] < 0) {
  183.             inGame = false;
  184.         }
  186.         if (!inGame) {
  187.             timer.stop();
  188.         }
  189.     }
  191.     private void locateApple() {
  193.         int r = (int) (Math.random() * RAND_POS);
  194.         apple_x = ((r * DOT_SIZE));
  196.         r = (int) (Math.random() * RAND_POS);
  197.         apple_y = ((r * DOT_SIZE));
  198.     }
  200.     @Override
  201.     public void actionPerformed(ActionEvent e) {
  203.         if (inGame) {
  205.             checkApple();
  206.             checkCollision();
  207.             move();
  208.         }
  210.         repaint();
  211.     }
  213.     private class TAdapter extends KeyAdapter {
  215.         @Override
  216.         public void keyPressed(KeyEvent e) {
  218.             int key = e.getKeyCode();
  220.             if ((key == KeyEvent.VK_LEFT) && (!rightDirection)) {
  221.                 leftDirection = true;
  222.                 upDirection = false;
  223.                 downDirection = false;
  224.             }
  226.             if ((key == KeyEvent.VK_RIGHT) && (!leftDirection)) {
  227.                 rightDirection = true;
  228.                 upDirection = false;
  229.                 downDirection = false;
  230.             }
  232.             if ((key == KeyEvent.VK_UP) && (!downDirection)) {
  233.                 upDirection = true;
  234.                 rightDirection = false;
  235.                 leftDirection = false;
  236.             }
  238.             if ((key == KeyEvent.VK_DOWN) && (!upDirection)) {
  239.                 downDirection = true;
  240.                 rightDirection = false;
  241.                 leftDirection = false;
  242.             }
  243.         }
  244.     }
  245. }

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

  1. private final int B_WIDTH = 300;
  2. private final int B_HEIGHT = 300;
  3. private final int DOT_SIZE = 10;
  4. private final int ALL_DOTS = 900;
  5. private final int RAND_POS = 29;
  6. private final int DELAY = 140;

B_WIDTH和B_HEIGHT常数确定电路板的大小。 DOT_SIZE是苹果的大小和蛇的点。 ALL_DOTS常数定义了板上可能的最大点数（900 = (300 * 300) / (10 * 10)）。 RAND_POS常数用于计算苹果的随机位置。 DELAY常数确定游戏的速度。

  1. private final int x[] = new int[ALL_DOTS];
  2. private final int y[] = new int[ALL_DOTS];

这两个数组存储蛇的所有关节的 x 和 y 坐标。

  1. private void loadImages() {
  3.     ImageIcon iid = new ImageIcon("src/resources/dot.png");
  4.     ball = iid.getImage();
  6.     ImageIcon iia = new ImageIcon("src/resources/apple.png");
  7.     apple = iia.getImage();
  9.     ImageIcon iih = new ImageIcon("src/resources/head.png");
  10.     head = iih.getImage();
  11. }

在loadImages()方法中，我们获得了游戏的图像。 ImageIcon类用于显示 PNG 图像。

  1. private void initGame() {
  3.     dots = 3;
  5.     for (int z = 0; z < dots; z++) {
  6.         x[z] = 50 - z * 10;
  7.         y[z] = 50;
  8.     }
  10.     locateApple();
  12.     timer = new Timer(DELAY, this);
  13.     timer.start();
  14. }

在initGame()方法中，我们创建蛇，在板上随机放置一个苹果，然后启动计时器。

  1. private void checkApple() {
  3.     if ((x[0] == apple_x) && (y[0] == apple_y)) {
  5.         dots++;
  6.         locateApple();
  7.     }
  8. }

如果苹果与头部碰撞，我们会增加蛇的关节数。 我们称locateApple()方法为随机放置一个新的Apple对象。

在move()方法中，我们有游戏的关键算法。 要了解它，请看一下蛇是如何运动的。 我们控制蛇的头。 我们可以使用光标键更改其方向。 其余关节在链上向上移动一个位置。 第二关节移动到第一个关节的位置，第三关节移动到第二个关节的位置，依此类推。

  1. for (int z = dots; z > 0; z--) {
  2.     x[z] = x[(z - 1)];
  3.     y[z] = y[(z - 1)];
  4. }

该代码将关节向上移动。

  1. if (leftDirection) {
  2.     x[0] -= DOT_SIZE;
  3. }

这条线将头向左移动。

在checkCollision()方法中，我们确定蛇是否击中了自己或撞墙之一。

  1. for (int z = dots; z > 0; z--) {
  3.     if ((z > 4) && (x[0] == x[z]) && (y[0] == y[z])) {
  4.         inGame = false;
  5.     }
  6. }

如果蛇用头撞到其关节之一，则游戏结束。

  1. if (y[0] >= B_HEIGHT) {
  2.     inGame = false;
  3. }

如果蛇击中了棋盘的底部，则游戏结束。

Snake.java

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

这是主要的类。

  1. setResizable(false);
  2. pack();

setResizable()方法会影响某些平台上JFrame容器的插入。 因此，在pack()方法之前调用它很重要。 否则，蛇的头部与右边界和底边界的碰撞可能无法正常进行。

Java 贪食蛇 - 图1

图：贪食蛇

这是 Java 中的贪食蛇游戏。