原文： http://zetcode.com/gui/javaswt/nibbles/

在 Java SWT 教程的这一部分中，我们创建了贪食蛇游戏克隆。

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

开发

蛇的每个关节的大小为 10 像素。 蛇由光标键控制。 最初，蛇具有三个关节。 游戏立即开始。 游戏结束后，窗口中央将显示"Game Over"消息。

Board.java

  1. package com.zetcode;
  3. import org.eclipse.swt.SWT;
  4. import org.eclipse.swt.graphics.Color;
  5. import org.eclipse.swt.graphics.Font;
  6. import org.eclipse.swt.graphics.GC;
  7. import org.eclipse.swt.graphics.Image;
  8. import org.eclipse.swt.graphics.ImageData;
  9. import org.eclipse.swt.graphics.Point;
  10. import org.eclipse.swt.widgets.Canvas;
  11. import org.eclipse.swt.widgets.Display;
  12. import org.eclipse.swt.widgets.Event;
  13. import org.eclipse.swt.widgets.Shell;
  15. public class Board extends Canvas {
  17.     private final int WIDTH = 300;
  18.     private final int HEIGHT = 300;
  19.     private final int DOT_SIZE = 10;
  20.     private final int ALL_DOTS = 900;
  21.     private final int RAND_POS = 29;
  22.     private final int DELAY = 140;
  24.     private int x[] = new int[ALL_DOTS];
  25.     private int y[] = new int[ALL_DOTS];
  27.     private int dots;
  28.     private int apple_x;
  29.     private int apple_y;
  31.     private boolean left = false;
  32.     private boolean right = true;
  33.     private boolean up = false;
  34.     private boolean down = false;
  35.     private boolean inGame = true;
  37.     private Image ball;
  38.     private Image apple;
  39.     private Image head;
  41.     private Display display;
  42.     private Shell shell;
  43.     private Runnable runnable;
  45.     public Board(Shell shell) {
  46.         super(shell, SWT.NULL);
  48.         this.shell = shell;
  50.         initBoard();
  51.     }
  53.     private void initBoard() {
  55.         display = shell.getDisplay();
  57.         addListener(SWT.Paint, event -> doPainting(event));
  58.         addListener(SWT.KeyDown, event -> onKeyDown(event));
  60.         addListener(SWT.Dispose, event -> {
  62.             ball.dispose();
  63.             apple.dispose();
  64.             head.dispose();
  65.         });
  67.         Color col = new Color(shell.getDisplay(), 0, 0, 0);
  69.         setBackground(col);
  70.         col.dispose();
  72.         loadImages();
  74.         initGame();
  75.     }
  77.     private void loadImages() {
  79.         ImageData iib = new ImageData("dot.png");
  80.         ball = new Image(display, iib);
  82.         ImageData iia = new ImageData("apple.png");
  83.         apple = new Image(display, iia);
  85.         ImageData iih = new ImageData("head.png");
  86.         head = new Image(display, iih);
  87.     }
  89.     private void initGame() {
  91.         dots = 3;
  93.         for (int z = 0; z < dots; z++) {
  94.             x[z] = 50 - z * 10;
  95.             y[z] = 50;
  96.         }
  98.         locateApple();
  100.         runnable = new Runnable() {
  101.             @Override
  102.             public void run() {
  104.                 if (inGame) {
  105.                     checkApple();
  106.                     checkCollision();
  107.                     move();
  109.                 }
  111.                 display.timerExec(DELAY, this);
  112.                 redraw();
  113.             }
  114.         };
  116.         display.timerExec(DELAY, runnable);
  117.     };
  119.     private void doPainting(Event e) {
  121.         GC gc = e.gc;
  123.         Color col = new Color(shell.getDisplay(), 0, 0, 0);
  124.         gc.setBackground(col);
  125.         col.dispose();
  127.         gc.setAntialias(SWT.ON);
  129.         if (inGame) {
  130.             drawObjects(e);
  131.         } else {
  132.             gameOver(e);
  133.         }
  134.     }
  136.     private void drawObjects(Event e) {
  138.         GC gc = e.gc;
  140.         gc.drawImage(apple, apple_x, apple_y);
  142.         for (int z = 0; z < dots; z++) {
  143.             if (z == 0) {
  144.                 gc.drawImage(head, x[z], y[z]);
  145.             } else {
  146.                 gc.drawImage(ball, x[z], y[z]);
  147.             }
  148.         }
  149.     }
  151.     private void gameOver(Event e) {
  153.         GC gc = e.gc;
  155.         String msg = "Game Over";
  157.         Font font = new Font(e.display, "Helvetica", 12, SWT.NORMAL);
  158.         Color whiteCol = new Color(e.display, 255, 255, 255);
  160.         gc.setForeground(whiteCol);
  161.         gc.setFont(font);
  163.         Point size = gc.textExtent(msg);
  165.         gc.drawText(msg, (WIDTH - size.x) / 2, (HEIGHT - size.y) / 2);
  167.         font.dispose();
  168.         whiteCol.dispose();
  170.         display.timerExec(-1, runnable);
  171.     }
  173.     private void checkApple() {
  175.         if ((x[0] == apple_x) && (y[0] == apple_y)) {
  176.             dots++;
  177.             locateApple();
  178.         }
  179.     }
  181.     private void move() {
  183.         for (int z = dots; z > 0; z--) {
  184.             x[z] = x[(z - 1)];
  185.             y[z] = y[(z - 1)];
  186.         }
  188.         if (left) {
  189.             x[0] -= DOT_SIZE;
  190.         }
  192.         if (right) {
  193.             x[0] += DOT_SIZE;
  194.         }
  196.         if (up) {
  197.             y[0] -= DOT_SIZE;
  198.         }
  200.         if (down) {
  201.             y[0] += DOT_SIZE;
  202.         }
  203.     }
  205.     public void checkCollision() {
  207.         for (int z = dots; z > 0; z--) {
  209.             if ((z > 4) && (x[0] == x[z]) && (y[0] == y[z])) {
  210.                 inGame = false;
  211.             }
  212.         }
  214.         if (y[0] > HEIGHT - DOT_SIZE) {
  215.             inGame = false;
  216.         }
  218.         if (y[0] < 0) {
  219.             inGame = false;
  220.         }
  222.         if (x[0] > WIDTH - DOT_SIZE) {
  223.             inGame = false;
  224.         }
  226.         if (x[0] < 0) {
  227.             inGame = false;
  228.         }
  229.     }
  231.     public void locateApple() {
  233.         int r = (int) (Math.random() * RAND_POS);
  234.         apple_x = ((r * DOT_SIZE));
  235.         r = (int) (Math.random() * RAND_POS);
  236.         apple_y = ((r * DOT_SIZE));
  237.     }
  239.     private void onKeyDown(Event e) {
  241.         int key = e.keyCode;
  243.         if ((key == SWT.ARROW_LEFT) && (!right)) {
  244.             left = true;
  245.             up = false;
  246.             down = false;
  247.         }
  249.         if ((key == SWT.ARROW_RIGHT) && (!left)) {
  250.             right = true;
  251.             up = false;
  252.             down = false;
  253.         }
  255.         if ((key == SWT.ARROW_UP) && (!down)) {
  256.             up = true;
  257.             right = false;
  258.             left = false;
  259.         }
  261.         if ((key == SWT.ARROW_DOWN) && (!up)) {
  262.             down = true;
  263.             right = false;
  264.             left = false;
  265.         }
  266.     }
  267. }

首先，我们将定义一些在游戏中使用的全局变量。

WIDTH和HEIGHT常数确定电路板的大小。 DOT_SIZE是苹果的大小和蛇的点。 ALL_DOTS常数定义了板上可能的最大点数。 RAND_POS常数用于计算苹果的随机位置。 DELAY常数确定游戏的速度。

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

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

initGame()方法初始化变量，加载图像并启动超时功能。

  1. runnable = new Runnable() {
  2.     @Override
  3.     public void run() {
  5.         if (inGame) {
  6.             checkApple();
  7.             checkCollision();
  8.             move();
  10.         }
  12.         display.timerExec(DELAY, this);
  13.         redraw();
  14.     }
  15. };

每隔DELAY ms，将调用run()方法。 如果我们参与了游戏，我们将调用三种构建游戏逻辑的方法。

  1. if (inGame) {
  2.     drawObjects(e);
  3. } else {
  4.     gameOver(e);
  5. }

在doPainting()方法内部，我们检查inGame变量。 如果是真的，我们将绘制对象-苹果和蛇关节。 否则，我们显示"Game Over"文本。

  1. private void drawObjects(Event e) {
  3.     GC gc = e.gc;
  5.     gc.drawImage(apple, apple_x, apple_y);
  7.     for (int z = 0; z < dots; z++) {
  8.         if (z == 0) {
  9.             gc.drawImage(head, x[z], y[z]);
  10.         } else {
  11.             gc.drawImage(ball, x[z], y[z]);
  12.         }
  13.     }
  14. }

drawObjects()方法绘制苹果和蛇的关节。 蛇的第一个关节是其头部，用红色圆圈表示。

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

checkApple()方法检查蛇是否击中了苹果对象。 如果是这样，我们添加另一个蛇形关节并调用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 (left) {
  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] > HEIGHT - DOT_SIZE) {
  2.     inGame = false;
  3. }

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

locateApple()方法在板上随机放置一个苹果。

  1. int r = (int) (Math.random() * RAND_POS);

我们得到一个从 0 到RAND_POS-1的随机数。

  1. apple_x = ((r * DOT_SIZE));
  2. ...
  3. apple_y = ((r * DOT_SIZE));

这些行设置了apple对象的 x 和 y 坐标。

在onKeyDown()方法中，我们确定按下的键。

  1. if ((key == SWT.ARROW_LEFT) && (!right)) {
  2.     left = true;
  3.     up = false;
  4.     down = false;
  5. }

如果按左光标键，则将left变量设置为true。 在move()方法中使用此变量来更改蛇对象的坐标。 还要注意，当蛇向右行驶时，我们不能立即向左转。

Nibbles.java

  1. package com.zetcode;
  3. import org.eclipse.swt.SWT;
  4. import org.eclipse.swt.layout.FillLayout;
  5. import org.eclipse.swt.widgets.Display;
  6. import org.eclipse.swt.widgets.Shell;
  8. /**
  9.  * ZetCode Java SWT tutorial
  10.  *
  11.  * In this code example, we create
  12.  * a Nibbles game clone
  13.  *
  14.  * Author: Jan Bodnar
  15.  * Website: zetcode.com
  16.  * Last modified: June 2015
  17.  */
  19. public class Nibbles {
  21.     private final int WIDTH = 300;
  22.     private final int HEIGHT = 300;
  24.     public Nibbles(Display display) {
  26.         initUI(display);
  27.     }
  29.     @SuppressWarnings("unused")
  30.     private void initUI(Display display) {
  32.         Shell shell = new Shell(display, SWT.SHELL_TRIM | SWT.CENTER);
  34.         FillLayout layout = new FillLayout();
  35.         shell.setLayout(layout);
  37.         Board board = new Board(shell);        
  39.         shell.setText("Nibbles");
  40.         int borW = shell.getSize().x - shell.getClientArea().width;
  41.         int borH = shell.getSize().y - shell.getClientArea().height;
  42.         shell.setSize(WIDTH + borW, HEIGHT + borH);
  44.         shell.open();
  46.         while (!shell.isDisposed()) {
  47.           if (!display.readAndDispatch()) {
  48.             display.sleep();
  49.           }
  50.         }
  51.     }
  53.     @SuppressWarnings("unused")
  54.     public static void main(String[] args) {
  56.         Display display = new Display();
  57.         Nibbles ex = new Nibbles(display);
  58.         display.dispose();
  59.     }
  60. }

在这个类中，我们设置了贪食蛇游戏。

  1. int borW = shell.getSize().x - shell.getClientArea().width;
  2. int borH = shell.getSize().y - shell.getClientArea().height;
  3. shell.setSize(WIDTH + borW, HEIGHT + borH);

在设置外壳大小时，我们还需要考虑窗口装饰。

Java SWT 中的贪食蛇 - 图1

图：贪食蛇

这是使用 SWT 库和 Java 编程语言编程的贪食蛇电脑游戏。