Android开发网

首页|Android开发环境|Android开发教程|Android开发视频|Android游戏开发|Android开发实例|Android开发书籍|鸡啄米博客

Android游戏开发的入门实例

       在Android系统上开发游戏是Android开发学习者所向往的，有成就感也有乐趣，还能取得经济上的报酬。那怎样开发Android游戏呢？下面介绍一个简单的入门实例。

       一、创建新工程　　

       首先，我们在Eclipse中新建一个名为Movement的工程，并且选择合适的Android SDK，在这里，我们选用的API是比较低的1.5版本，这样可以让其适应性更强。接下来，我们新建两个类，一个是UpdateThread类，一个是SurfaceView类，它们在项目中分别是负责处理线程和画面的两个类，在接下来会有详细介绍，如下图，分别建立这两个类，注意选择正确它们继承的父类：
 

Android游戏开发的入门实例

Android游戏开发的入门实例

       在建立完成后，系统的项目结构看上去应该象如下的样子：

Android游戏开发的入门实例

       二、编写Movment.java启动程序

       任何一个Android应用都必须有一个主启动程序来启动，我们这里把这个启动程序命名为Movment,代码很简单如下：

Java代码
  1. public class Movement extends Activity  {   
  2.  @Override  
  3.  public void onCreate(Bundle savedInstanceState) {   
  4.   
  5.      super.onCreate(savedInstanceState);   
  6.      setContentView(new MovementView(this));   
  7.  }   

　　注意的是，我们这个启动程序不象其他程序一样，在启动的时候，在setContentView中传入界面布局文件，而是直接将MovementView的实例传递进来，也就是说，直接启动了MovementView这个类，在这个类中，我们将绘画我们的小球。

       三、什么是SurfaceView

       在Android中，SurfaceView是一个重要的绘图容器，它可以可以直接从内存或者DMA等硬件接口取得图像数据。通常情况程序的View和用户响应都是在同一个线程中处理的，这也是为什么处理长时间事件(例如访问网络)需要放到另外的线程中去(防止阻塞当前UI线程的操作和绘制)。但是在其他线程中却不能修改UI元素，例如用后台线程更新自定义View(调用View的在自定义View中的onDraw函数)是不允许的。

       如果需要在另外的线程绘制界面、需要迅速的更新界面或则渲染UI界面需要较长的时间，这种情况就要使用SurfaceView了。SurfaceView中包含一个Surface对象，而Surface是可以在后台线程中绘制的。

       在本文中，我们将使用它，直接通过代码创建一个小球，并且随着UpdateThread线程的更新，不断改变小球的位置，下面我们开始学习MovementView的编写，先看下如何运用SurfaceView。

       首先导入SurfaceView及绘图的相关库文件，如下所示：

Java代码
  1. package example.movement;   
  2.   
  3. import android.content.Context;   
  4. import android.graphics.Canvas;   
  5. import android.graphics.Color;   
  6. import android.graphics.Paint;   
  7. import android.graphics.Rect;   
  8. import android.view.SurfaceHolder;   
  9. import android.view.SurfaceView;  

　　接着，我们要继承SurfaceView并且实现SurfaceHolder.Callback接口，这是一个SurfaceHolder的内部接口，可以实现该接口获得界面改变的信息，代码如下，并且我们声明了一些成员变量：

Java代码
  1. public class MovementView extends SurfaceView implements SurfaceHolder.Callback {   
  2.     private int xPos;   
  3.     private int yPos;   
  4.   
  5.     private int xVel;   
  6.     private int yVel;   
  7.   
  8.     private int width;   
  9.     private int height;   
  10.   
  11.     private int circleRadius;   
  12.     private Paint circlePaint;   
  13.   
  14.     UpdateThread updateThread;   
  15. }   

        而在MovementView的构造函数中，我们设置了小球的大小和在X,Y方向上的初始坐标，如下：  

Java代码    
  1. 　　public MovementView(Context context) {      
  2.     super(context);      
  3.     getHolder().addCallback(this);      
  4.      
  5.     circleRadius = 10;      
  6.     circlePaint = new Paint();      
  7.     circlePaint.setColor(Color.BLUE);      
  8.      
  9.     xVel = 2;      
  10.     yVel = 2;      
  11. }      
  12.      

       接着我们来看下ondraw方法的编写，在这里，我们将绘画小球，并且每次都把画布Canvas的背景色设置为白色，以重新覆盖之前一帧，代码如下：

Java代码
  1. protected void onDraw(Canvas canvas) {   
  2.   
  3.         canvas.drawColor(Color.WHITE);   
  4.   
  5.         canvas.drawCircle(xPos, yPos, circleRadius, circlePaint);   
  6. }   

       我们再来看下updatePhysics这个方法如何编写。这个方法的作用有两个：一是处理小球的运动，二是更新小球的实时位置，因为小球在屏幕中不断地运动，因此当小球到达比如屏幕绘画区域的顶端后，要被弹回，因此代码如下：

Java代码
  1. public void updatePhysics() {   
  2.   
  3. //更新当前的x,y坐标   
  4.         xPos += xVel;   
  5.         yPos += yVel;   
  6.   
  7.         if (yPos - circleRadius < 0 || yPos + circleRadius > height) {   
  8.   
  9.                
  10.             if (yPos - circleRadius < 0) {   
  11.   
  12.                 //如果小球到达画布区域的上顶端，则弹回   
  13.   
  14.                 yPos = circleRadius;   
  15.             }else{   
  16.   
  17.                 //如果小球到达了画布的下端边界，则弹回   
  18.   
  19.                 yPos = height - circleRadius;   
  20.             }   
  21.   
  22.             // 将Y坐标设置为相反方向   
  23.             yVel *= -1;   
  24.         }   
  25.         if (xPos - circleRadius < 0 || xPos + circleRadius > width) {   
  26.   
  27.                
  28.             if (xPos - circleRadius < 0) {   
  29.   
  30.                 // 如果小球到达左边缘   
  31.   
  32.                 xPos = circleRadius;   
  33.             } else {   
  34.   
  35.                 // 如果小球到达右边缘   
  36.   
  37.                 xPos = width - circleRadius;   
  38.             }   
  39.   
  40.             // 重新设置x轴坐标   
  41.             xVel *= -1;   
  42.         }   
  43.     }   
  44.   

       最后我们看下surfaceCreated这个方法的代码，在这个方法中，主要是取得了可用的SurfaceView的区域的高度和宽度，然后设置了小球的起始坐标(将其设置在屏幕的正中央位置)，并且启动了UpdateThread线程，代码如下：

Java代码
  1. public void surfaceCreated(SurfaceHolder holder) {   
  2.   
  3.         Rect surfaceFrame = holder.getSurfaceFrame();   
  4.         width = surfaceFrame.width();   
  5.         height = surfaceFrame.height();   
  6.   
  7.         xPos = width / 2;   
  8.         yPos = circleRadius;   
  9.   
  10.         updateThread = new UpdateThread(this);   
  11.         updateThread.setRunning(true);   
  12.         updateThread.start();   
  13.     }   

       此外，我们要补上surfaceChanged这个方法，这个方法意思是界面尺寸改变时才调用，在我们这个应用中并没用到，所以我们保留为空的方法实现：

Java代码
  1. public void surfaceChanged(SurfaceHolder holder, int format, int width, int height)   
  2.     {   
  3.   
  4.     }   

       而surfaceDestroyed方法中，主要实现的是界面被销毁时才调用，这里我们停止了当前的线程所处理的任务，这里使用了线程的join方法：

Java代码
  1. public void surfaceDestroyed(SurfaceHolder holder) {   
  2.   
  3.         boolean retry = true;   
  4.   
  5.         updateThread.setRunning(false);   
  6.         while (retry) {   
  7.             try {   
  8.                 updateThread.join();   
  9.                 retry = false;   
  10.             } catch (InterruptedException e) {   
  11.   
  12.             }   
  13.         }   
  14.     }   

       归纳下，完整的MovementView代码如下：

Java代码
  1. 　　package example.movement;   
  2.   
  3. import android.content.Context;   
  4. import android.graphics.Canvas;   
  5. import android.graphics.Color;   
  6. import android.graphics.Paint;   
  7. import android.graphics.Rect;   
  8. import android.view.SurfaceHolder;   
  9. import android.view.SurfaceView;   
  10.   
  11. public class MovementView extends SurfaceView implements SurfaceHolder.Callback {   
  12.   
  13.     private int xPos;   
  14.     private int yPos;   
  15.   
  16.     private int xVel;   
  17.     private int yVel;   
  18.   
  19.     private int width;   
  20.     private int height;   
  21.   
  22.     private int circleRadius;   
  23.     private Paint circlePaint;   
  24.   
  25.     UpdateThread updateThread;   
  26.   
  27.     public MovementView(Context context) {   
  28.   
  29.         super(context);   
  30.         getHolder().addCallback(this);   
  31.   
  32.         circleRadius = 10;   
  33.         circlePaint = new Paint();   
  34.         circlePaint.setColor(Color.BLUE);   
  35.   
  36.         xVel = 2;   
  37.         yVel = 2;   
  38.     }   
  39.     @Override  
  40.     protected void onDraw(Canvas canvas) {   
  41.   
  42.         canvas.drawColor(Color.WHITE);   
  43.         canvas.drawCircle(xPos, yPos, circleRadius, circlePaint);   
  44.     }   
  45.   
  46.     public void updatePhysics() {   
  47.         xPos += xVel;   
  48.         yPos += yVel;   
  49.   
  50.         if (yPos - circleRadius < 0 || yPos + circleRadius > height) {   
  51.             if (yPos - circleRadius < 0) {   
  52.                 yPos = circleRadius;   
  53.             }else{   
  54.                 yPos = height - circleRadius;   
  55.             }   
  56.             yVel *= -1;   
  57.         }   
  58.         if (xPos - circleRadius < 0 || xPos + circleRadius > width) {   
  59.             if (xPos - circleRadius < 0) {   
  60.                 xPos = circleRadius;   
  61.             } else {   
  62.                 xPos = width - circleRadius;   
  63.             }   
  64.             xVel *= -1;   
  65.         }   
  66.     }   
  67.   
  68.     public void surfaceCreated(SurfaceHolder holder) {   
  69.   
  70.         Rect surfaceFrame = holder.getSurfaceFrame();   
  71.         width = surfaceFrame.width();   
  72.         height = surfaceFrame.height();   
  73.   
  74.         xPos = width / 2;   
  75.         yPos = circleRadius;   
  76.   
  77.         updateThread = new UpdateThread(this);   
  78.         updateThread.setRunning(true);   
  79.         updateThread.start();   
  80.     }   
  81.   
  82.     public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {   
  83.     }   
  84.   
  85.     public void surfaceDestroyed(SurfaceHolder holder) {   
  86.   
  87.         boolean retry = true;   
  88.   
  89.         updateThread.setRunning(false);   
  90.         while (retry) {   
  91.             try {   
  92.                 updateThread.join();   
  93.                 retry = false;   
  94.             } catch (InterruptedException e) {   
  95.             }   
  96.         }   
  97.     }   
  98. }   

       四、UpdateThread线程程序

       下面，我们开始着手编写UpdateThread线程程序。这个程序主要是启动一个线程去不断更新当前小球的位置。先看声明及构造函数部分：

Java代码
  1. package licksquid.movement;   
  2.   
  3. import android.graphics.Canvas;   
  4. import android.view.SurfaceHolder;   
  5.   
  6. public class UpdateThread extends Thread {   
  7.     private long time;   
  8.     private final int fps = 20;   
  9.     private boolean toRun = false;   
  10.     private MovementView movementView;   
  11.     private SurfaceHolder surfaceHolder;   
  12.   
  13. }   
  14. public UpdateThread(MovementView rMovementView) {   
  15.         movementView = rMovementView;   
  16.         surfaceHolder = movementView.getHolder();   
  17.     }   
  18. 　public void setRunning(boolean run) {   
  19.         toRun = run;   
  20.     }   

        注意这里的setRunning方法中设置了线程是否应该停止的标记，下面来看重要的方法run:

Java代码
  1. public void run() {   
  2.   
  3.         Canvas c;   
  4.         while (toRun) {   
  5.   
  6.             long cTime = System.currentTimeMillis();   
  7.   
  8.             if ((cTime - time) <= (1000 / fps)) {   
  9.   
  10.                 c = null;   
  11.                 try {   
  12.                     c = surfaceHolder.lockCanvas(null);   
  13.   
  14.                     movementView.updatePhysics();   
  15.                     movementView.onDraw(c);   
  16.                 } finally {   
  17.                     if (c != null) {   
  18.                         surfaceHolder.unlockCanvasAndPost(c);   
  19.                     }   
  20.                 }   
  21.             }   
  22.             time = cTime;   
  23.         }   
  24.     }  

       在run方法中，主要实现了如下几个任务：首先检查是否有允许启动该线程(在开始运行后，由于在MovementView中，启动UpdateThread的时候，已经设置了其值为true,即updateThread.setRunning(true))，接下来检查是否在指定的时间内(这里设置的是每秒20帧)，如果是的话，则调用surfaceHolder的lockCanvas方法，锁定当前的画布绘画区域，并且调用movementView的updatePhysics方法及onDraw方法去画小球并判断小球的运动，最后记得要在finally中调用unlockCanvasAndPost方法。

       五、启动并运行程序

       最后启动并运行程序，可以看到如下的效果，可以看到小球在做各个方向的弹跳运动。

       到此就完成了这个Android游戏开发的入门实例，其实编写Android游戏就是这么简单。

Tags:SurfaceView,线程 | 2012/4/27 | 发表评论

相关文章: