Android游戏开发的入门实例

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

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

一、创建新工程

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

Android游戏开发的入门实例

Android游戏开发的入门实例

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

Android游戏开发的入门实例

二、编写Movment.java启动程序

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

  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及绘图的相关库文件,如下所示:

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

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

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

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

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

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

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

下页将为您带来UpdateThread线程程序 启动并运行程序

#p#

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

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

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

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

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

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

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

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

归纳下,完整的MovementView代码如下:

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

四、UpdateThread线程程序

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

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

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

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

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

五、启动并运行程序

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

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

责任编辑:闫佳明 来源: jizhuomi
相关推荐

2013-05-21 11:26:49

Android游戏开发Sensor感应

2013-05-20 17:51:47

Android游戏开发SurfaceView

2013-05-21 09:56:15

2013-05-20 17:13:17

Android游戏开发CanvasPaint

2013-08-01 14:03:49

JavaScript

2011-06-13 10:54:20

JAVA

2011-04-08 09:24:24

2009-06-30 14:02:00

hibernate入门MyEclipse开发

2013-12-04 16:28:29

Android游戏引擎libgdx教程

2013-05-21 15:28:31

2013-05-21 16:17:13

2015-07-30 09:43:10

独立游戏开发入门

2013-04-08 14:12:03

Android开发googleMap入门SDK

2011-09-09 14:09:17

Android Wid

2009-03-16 15:00:16

阿里软件旺旺软件平台SaaS

2013-02-20 15:29:00

JSONAndroid开发

2011-09-07 17:54:40

Android Wid开发

2013-01-16 14:41:14

Android开发Android SDK

2010-03-03 15:06:52

Android 游戏开

2012-08-09 08:49:30

CoronaCorona SDKCorona SDK游
点赞
收藏

51CTO技术栈公众号