贪吃蛇游戏的MIDP实现

概述

  相信大家都玩过Nokia手机上的贪吃蛇游戏。在该游戏中，玩家操纵一条贪吃的蛇在迷宫里行走，贪吃蛇按玩家所按的方
向键折行，蛇头吃到各种食物(比如大力丸)后，会有各种反应(比如蛇身变长)，如果贪吃蛇碰上墙壁或者自身的话，就GameOver了(当然也可能是减去
一条生命)。要实现该游戏其实并不麻烦，关键就是要找到一个合适的核心算法。本文就给出一个参考实现,你可以基于该demo做扩展。要说明的一点是:本文
只演示最核心的算法，要实现一个完整的游戏，你还需要做很多的扩展，重构。

实例代码

  该程序包括3个java文件。一个是SnakeMIDlet,另外2个分别是一个Canvas(SnakeCanvas)和一个代表贪吃蛇的类Snake

SnakeMIDlet.java

  1. import javax.microedition.lcdui.Display;
  2. import javax.microedition.midlet.MIDlet;
  3. import javax.microedition.midlet.MIDletStateChangeException;
  6. /**
  7.  * @author Jagie
  8.  */
  9. public class SnakeMIDlet extends MIDlet {
  11.     
  12.     protected void startApp() throws MIDletStateChangeException {
  13.         // TODO Auto-generated method stub
  14.         Display.getDisplay(this).setCurrent(new SnakeCanvas());
  16.     }
  18.     /* (non-Javadoc)
  19.      * @see javax.microedition.midlet.MIDlet#pauseApp()
  20.      */
  21.     protected void pauseApp() {
  22.         // TODO Auto-generated method stub
  24.     }
  26.     /* (non-Javadoc)
  27.      * @see javax.microedition.midlet.MIDlet#destroyApp(boolean)
  28.      */
  29.     protected void destroyApp(boolean arg0) throws MIDletStateChangeException {
  30.         // TODO Auto-generated method stub
  32.     }
  34. }

SnakeCanvas.java

  1. import javax.microedition.lcdui.Canvas;
  2. import javax.microedition.lcdui.Graphics;
  5. /**
  6.  * @author Jagie
  7.  *
  8.  */
  9. public class SnakeCanvas extends Canvas implements Runnable {
  12.     
  13.     Snake snake=new Snake();
  14.     SnakeCanvas(){
  15.         snake.init();
  16.         new Thread(this).start();
  17.     }
  19.     protected void paint(Graphics g) {
  20.         
  21.         g.setColor(0);
  22.         g.fillRect(0,0,this.getWidth(),this.getHeight());
  23.         
  24.         snake.paint(g);
  26.     }
  27.     
  28.     /**
  29.      * 游戏主线程，驱动蛇移动
  30.      */
  31.     
  32.     public void run(){
  33.         while(true){
  34.             
  35.             snake.move();
  36.             repaint();
  37.             
  38.             try {
  39.                 Thread.sleep(50);
  40.             } catch (InterruptedException e) {
  41.                 // TODO Auto-generated catch block
  42.                 e.printStackTrace();
  43.             }
  44.         }
  45.     }
  47.     /**
  48.      * 按键相应,产生新蛇头
  49.      */
  50.     protected void keyPressed(int c) {
  51.         int ga=this.getGameAction(c);
  52.         
  53.         switch (ga) {
  54.         case Canvas.UP:
  55.             snake.breakInto(1);
  56.             break;
  58.         case Canvas.DOWN:
  59.             snake.breakInto(3);
  60.             break;
  61.         case Canvas.LEFT:
  62.             snake.breakInto(4);
  63.             break;
  64.         case Canvas.RIGHT:
  65.             snake.breakInto(2);
  66.             break;
  67.         }
  68.     }
  69. }

Snake.java

  2. import java.util.Vector;
  5. import javax.microedition.lcdui.Graphics;
  7. /**
  8.  * 
  9.  * @author Jagie
  10.  * 贪吃蛇
  11.  */
  12. public class Snake {
  13.     //蛇环节，每个环节为一个int[] sec
  14.     //sec[0]:环节起点x,sec[1]:环节起点y,sec[2]:环节方向,sec[3]:环节长度
  15.     Vector sections = new Vector();
  16.     
  17.     /**
  18.      * 初始化sections
  19.      * 开始的时候，整条蛇只有一段。
  20.      *
  21.      */
  22.     public void init() {
  23.         int[] head = { 10, 10, 2, 50 };
  24.         sections.addElement(head);
  25.     }
  26.     
  27.     /**
  28.      * 绘制
  29.      * @param g
  30.      */
  31.     public synchronized void paint(Graphics g) {
  32.         if (sections.isEmpty()) {
  33.             return;
  34.         }
  35.         g.setColor(0, 255, 0);
  36.         for (int i = 0; i < sections.size(); i++) {
  37.             int[] sec = (int[]) sections.elementAt(i);
  38.             //sec[0]:起点x,sec[1]:起点y,sec[2]:方向,sec[3]:长度
  39.             switch (sec[2]) {
  40.             case 1:
  41.                 g.drawLine(sec[0], sec[1], sec[0], sec[1] – sec[3]);
  42.                 break;
  43.             case 2:
  44.                 g.drawLine(sec[0], sec[1], sec[0] + sec[3], sec[1]);
  45.                 break;
  46.             case 3:
  47.                 g.drawLine(sec[0], sec[1], sec[0], sec[1] + sec[3]);
  48.                 break;
  49.             case 4:
  50.                 g.drawLine(sec[0], sec[1], sec[0] – sec[3], sec[1]);
  51.                 break;
  52.             }
  54.         }
  55.     }
  57.     /**
  58.      * 
  59.      * @author Jagie
  60.      *
  61.      * 蛇的爬行。本质上是蛇头长度++,蛇尾长度–.同时移动蛇尾起点。如果蛇尾长度小于0,则去掉蛇尾。
  62.      */
  63.     public synchronized void move() {
  64.         if (sections.isEmpty()) {
  65.             return;
  66.         }
  67.         //蛇尾
  68.         int[] tail = (int[]) sections.elementAt(sections.size() – 1);
  69.         //蛇头
  70.         int[] head = (int[]) sections.elementAt(0);
  71.         //根据蛇尾环节的方向移动蛇尾。
  72.         switch (tail[2]) {
  73.         case 1:
  74.             tail[1]–;
  75.             break;
  76.         case 2:
  77.             tail[0]++;
  78.             break;
  79.         case 3:
  80.             tail[1]++;
  81.             break;
  82.         case 4:
  83.             tail[0]–;
  84.             break;
  85.         }
  86.         //蛇尾缩短
  87.         tail[3]–;
  88.         //蛇头增长
  89.         head[3]++;
  90.         //蛇尾<0,则去掉蛇尾
  91.         if (tail[3] <= 0) {
  92.             sections.removeElement(tail);
  93.         }
  94.     }
  95.     
  96.     /**
  97.      * 蛇分段
  98.      * @param dir 新蛇头的方向
  99.      */
  101.     public synchronized void breakInto(int dir) {
  102.         if (sections.isEmpty()) {
  103.             return;
  104.         }
  105.         int[] head = (int[]) sections.elementAt(0);
  106.         //新蛇头方向和旧蛇头方向一致，则无反应。
  107.         //TODO 可以考虑加速。
  108.         if (dir == head[2]) {
  109.             return;
  110.         }
  111.         //增加新蛇头
  112.         int[] newhead=new int[4];
  113.         //新蛇头的起始位置，与旧蛇头的运动方向有关。
  114.         switch (head[2]) {
  115.         case 1:
  116.             newhead[0]=head[0];
  117.             newhead[1]=head[1]-head[3];
  118.             newhead[2]=dir;
  119.             newhead[3]=0;
  120.             //蛇头总是第一个元素
  121.             sections.insertElementAt(newhead, 0);
  122.             break;
  123.         case 2:
  124.             newhead[0]=head[0]+head[3];
  125.             newhead[1]=head[1];
  126.             newhead[2]=dir;
  127.             newhead[3]=0;
  128.             sections.insertElementAt(newhead, 0);
  129.             break;
  130.         case 3:
  131.             newhead[0]=head[0];
  132.             newhead[1]=head[1]+head[3];
  133.             newhead[2]=dir;
  134.             newhead[3]=0;
  135.             sections.insertElementAt(newhead, 0);
  136.             break;
  137.         case 4:
  138.             newhead[0]=head[0]-head[3];
  139.             newhead[1]=head[1];
  140.             newhead[2]=dir;
  141.             newhead[3]=0;
  142.             sections.insertElementAt(newhead, 0);
  143.             break;
  144.         }
  145.         
  147.     }
  149. }

小结

本文给出了一个简单的贪吃蛇的例子，演示了贪吃蛇游戏核心的一种参考算法

作者简介

陈万飞,网名Jagie,培训师,爱好java技术.可通过chen_cwf@163.com与他联系.

相关文章