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

在 Java Gnome 编程教程的这一部分中，我们将创建一个贪食蛇游戏克隆。

贪食蛇

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

开发

蛇的每个关节的大小为 10px。 蛇由光标键控制。 最初，蛇具有三个关节。 游戏立即开始。 游戏结束后，我们在状态栏小部件中显示"Game Over"消息。

board.java

  1. package com.zetcode;
  3. import java.io.FileNotFoundException;
  5. import java.util.Timer;
  6. import java.util.TimerTask;
  8. import org.freedesktop.cairo.Context;
  10. import org.gnome.gdk.Color;
  11. import org.gnome.gdk.EventExpose;
  12. import org.gnome.gdk.EventKey;
  13. import org.gnome.gdk.Keyval;
  14. import org.gnome.gdk.ModifierType;
  15. import org.gnome.gdk.Pixbuf;
  16. import org.gnome.gtk.DrawingArea;
  17. import org.gnome.gtk.Justification;
  18. import org.gnome.gtk.Label;
  19. import org.gnome.gtk.StateType;
  20. import org.gnome.gtk.Widget;
  22. public class Board extends DrawingArea implements Widget.ExposeEvent {
  24.     private final int WIDTH = 300;
  25.     private final int HEIGHT = 300;
  26.     private final int DOT_SIZE = 10;
  27.     private final int ALL_DOTS = 900;
  28.     private final int RAND_POS = 29;
  29.     private final int DELAY = 140;
  30.     private final int PERIOD = 80;
  32.     private int x[] = new int[ALL_DOTS];
  33.     private int y[] = new int[ALL_DOTS];
  35.     private int dots;
  36.     private int apple_x;
  37.     private int apple_y;
  39.     private boolean left = false;
  40.     private boolean right = true;
  41.     private boolean up = false;
  42.     private boolean down = false;
  43.     private boolean inGame = true;
  45.     private Timer timer;
  47.     private Pixbuf dot;
  48.     private Pixbuf apple;
  49.     private Pixbuf head;
  51.     private Label statusbar;
  53.     public Board(Label statusbar) {
  55.         this.statusbar = statusbar;
  57.         connect(new SnakeKeyListener());
  59.         modifyBackground(StateType.NORMAL, Color.BLACK);
  61.         try {
  62.             dot = new Pixbuf("dot.png");
  63.             apple = new Pixbuf("apple.png");
  64.             head = new Pixbuf("head.png");
  66.         } catch (FileNotFoundException e) {
  67.             e.printStackTrace();
  68.         }
  70.         connect(this);
  71.         setCanFocus(true);
  73.         initGame();
  74.     }
  76.     public Timer getTimer() { return timer; }
  78.     public void initGame() {
  80.         dots = 3;
  82.         for (int z = 0; z < dots; z++) {
  83.             x[z] = 50 - z * 10;
  84.             y[z] = 50;
  85.         }
  87.         locateApple();
  89.         timer = new Timer();
  90.         timer.scheduleAtFixedRate(new ScheduleTask(), DELAY, PERIOD);
  92.     }
  94.     public void drawObjects(Context cr) {
  96.         if (inGame) {
  98.             cr.setSource(apple, apple_x, apple_y);
  99.             cr.paint();
  101.             for (int z = 0; z < dots; z++) {
  102.                 if (z == 0) {
  103.                     cr.setSource(head, x[z], y[z]);
  104.                     cr.paint();
  105.                 } else {
  106.                     cr.setSource(dot, x[z], y[z]);
  107.                     cr.paint();
  108.                 }
  109.             }
  111.         } else {
  112.             gameOver();
  113.         }
  114.     }
  116.     public void gameOver() {
  118.         timer.cancel();
  120.         statusbar.setJustify(Justification.LEFT);
  121.         statusbar.setAlignment(0f, 0.5f);
  122.         statusbar.setLabel("Game Over");
  123.     }
  125.     public void checkApple() {
  127.         if ((x[0] == apple_x) && (y[0] == apple_y)) {
  128.             dots++;
  129.             locateApple();
  130.         }
  131.     }
  133.     public void move() {
  135.         for (int z = dots; z > 0; z--) {
  136.             x[z] = x[(z - 1)];
  137.             y[z] = y[(z - 1)];
  138.         }
  140.         if (left) {
  141.             x[0] -= DOT_SIZE;
  142.         }
  144.         if (right) {
  145.             x[0] += DOT_SIZE;
  146.         }
  148.         if (up) {
  149.             y[0] -= DOT_SIZE;
  150.         }
  152.         if (down) {
  153.             y[0] += DOT_SIZE;
  154.         }
  155.     }
  157.     public void checkCollision() {
  159.         for (int z = dots; z > 0; z--) {
  161.             if ((z > 4) && (x[0] == x[z]) && (y[0] == y[z])) {
  162.                 inGame = false;
  163.             }
  164.         }
  166.         if (y[0] > HEIGHT) {
  167.             inGame = false;
  168.         }
  170.         if (y[0] < 0) {
  171.             inGame = false;
  172.         }
  174.         if (x[0] > WIDTH) {
  175.             inGame = false;
  176.         }
  178.         if (x[0] < 0) {
  179.             inGame = false;
  180.         }
  181.     }
  183.     public void locateApple() {
  184.         int r = (int) (Math.random() * RAND_POS);
  185.         apple_x = ((r * DOT_SIZE));
  186.         r = (int) (Math.random() * RAND_POS);
  187.         apple_y = ((r * DOT_SIZE));
  188.     }
  190.     public boolean onExposeEvent(Widget widget, EventExpose eventExpose) {
  192.         Context cr = new Context(widget.getWindow());
  193.         drawObjects(cr);
  195.         return false;
  196.     }
  198.     class ScheduleTask extends TimerTask {
  200.         public void run() {
  202.             if (inGame) {
  203.                 checkApple();
  204.                 checkCollision();
  205.                 move();
  206.             }
  207.             queueDraw();
  208.         }
  209.     }
  211.     class SnakeKeyListener implements Widget.KeyPressEvent {
  213.         public boolean onKeyPressEvent(Widget widget, EventKey eventKey) {
  215.             final Keyval key;
  216.             final ModifierType mod;
  218.             key = eventKey.getKeyval();
  219.             mod = eventKey.getState();
  221.             if ((key == key.Left) && (!right)) {
  222.                 left = true;
  223.                 up = false;
  224.                 down = false;
  225.             }
  227.             if ((key == key.Right) && (!left)) {
  228.                 right = true;
  229.                 up = false;
  230.                 down = false;
  231.             }
  233.             if ((key == key.Up) && (!down)) {
  234.                 up = true;
  235.                 right = false;
  236.                 left = false;
  237.             }
  239.             if ((key == key.Down) && (!up)) {
  240.                 down = true;
  241.                 right = false;
  242.                 left = false;
  243.             }
  245.             return false;
  246.         }
  247.     }
  248. }

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

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()方法初始化变量，加载图像并启动超时功能。

在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--) {
  2.     if ((z > 4) && (x[0] == x[z]) && (y[0] == y[z])) {
  3.         inGame = false;
  4.     }
  5. }

如果蛇用头撞到关节之一，我们就结束游戏。

  1. if (y[0] > HEIGHT) {
  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 坐标。

在Board类的onKeyPressEvent()方法中，我们确定玩家按下了哪些键。

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

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

nibbles.java

  1. package com.zetcode;
  3. import java.util.Timer;
  5. import org.gnome.gdk.Event;
  6. import org.gnome.gtk.Gtk;
  7. import org.gnome.gtk.Label;
  8. import org.gnome.gtk.VBox;
  9. import org.gnome.gtk.Widget;
  10. import org.gnome.gtk.Window;
  11. import org.gnome.gtk.WindowPosition;
  13. /**
  14.  * ZetCode Java Gnome tutorial
  15.  *
  16.  * This program creates a Nibbles game clone.
  17.  *
  18.  * @author jan bodnar
  19.  * website zetcode.com
  20.  * last modified March 2009
  21.  */
  23. public class GNibbles extends Window {
  25.     Board board;
  26.     Label statusbar;
  28.     public GNibbles() {
  30.         setTitle("Nibbles");
  32.         initUI();
  34.         setDefaultSize(320, 320);
  35.         setPosition(WindowPosition.CENTER);
  37.         showAll();
  38.     }
  40.     public void initUI() {
  42.         VBox vbox = new VBox(false, 0);
  44.         statusbar = new Label("");
  45.         board = new Board(statusbar);
  47.         vbox.packStart(board);
  48.         vbox.packStart(statusbar, false, false, 0);
  50.         add(vbox);
  52.         connect(new Window.DeleteEvent() {
  53.             public boolean onDeleteEvent(Widget source, Event event) {
  54.                 Timer timer = board.getTimer();
  55.                 timer.cancel();
  56.                 Gtk.mainQuit();
  57.                 return false;
  58.             }
  59.         });
  60.     }
  62.     public static void main(String[] args)  {
  63.         Gtk.init(args);
  64.         new GNibbles();        
  65.         Gtk.main();
  66.     }
  67. }

在这个类中，我们设置了贪食蛇游戏。 注意，我们从板上获得了计时器对象。 这是执行干净的退出。

Java Gnome 中的贪食蛇 - 图1

图：贪食蛇

这是使用 Java Gnome 编程库编程的贪食蛇电脑游戏。