上一节中对SurfaceView的分析实际上就是一个简单的游戏框架了。当然这里再强调一下，是简单的游戏框架，高手们不要乱喷哦  ~

       这个Demo是写的一个对图片操作以及按键处理、游戏简单框架的demo，这里放出给大家分享~

Java代码
  1. package com.himi;   
  2. import android.content.Context;   
  3. import android.content.res.Resources;   
  4. import android.graphics.Bitmap;   
  5. import android.graphics.BitmapFactory;   
  6. import android.graphics.Canvas;   
  7. import android.graphics.Color;   
  8. import android.graphics.Paint;   
  9. import android.util.Log;   
  10. import android.view.KeyEvent;   
  11. import android.view.SurfaceHolder;   
  12. import android.view.SurfaceView;   
  13. import android.view.SurfaceHolder.Callback;   
  14. public class MySurfaceView extends SurfaceView implements Callback, Runnable {   
  15.     private Thread th = new Thread(this);   
  16.     private SurfaceHolder sfh;   
  17.     private int SH, SW;   
  18.     private Canvas canvas;   
  19.     private Paint p;   
  20.     private Paint p2;   
  21.     private Resources res;   
  22.     private Bitmap bmp;   
  23.     private int bmp_x = 100, bmp_y = 100;   
  24.     private boolean UP, DOWN, LEFT, RIGHT;   
  25.     private int animation_up[] = { 3, 4, 5 };   
  26.     private int animation_down[] = { 0, 1, 2 };   
  27.     private int animation_left[] = { 6, 7, 8 };   
  28.     private int animation_right[] = { 9, 10, 11 };   
  29.     private int animation_init[] = animation_down;   
  30.     private int frame_count;   
  31.     public MySurfaceView(Context context) {   
  32.         super(context);   
  33.         this.setKeepScreenOn(true);   
  34.         res = this.getResources();   
  35.         bmp = BitmapFactory.decodeResource(res, R.drawable.enemy1);   
  36.         sfh = this.getHolder();   
  37.         sfh.addCallback(this);   
  38.         p = new Paint();   
  39.         p.setColor(Color.YELLOW);   
  40.         p2 = new Paint();   
  41.         p2.setColor(Color.RED);   
  42.         p.setAntiAlias(true);   
  43.         setFocusable(true);  //备注1   
  44.     }   
  45.     public void surfaceCreated(SurfaceHolder holder) {   
  46.         SH = this.getHeight();   
  47.         SW = this.getWidth();   
  48.         th.start();   
  49.     }   
  50.     public void draw() {   
  51.         canvas = sfh.lockCanvas();   
  52.         canvas.drawRect(0, 0, SW, SH, p);   //备注2   
  53.         canvas.save();   //备注3   
  54.         canvas.drawText("Himi", bmp_x-2, bmp_y-10, p2);   
  55.         canvas.clipRect(bmp_x, bmp_y, bmp_x + bmp.getWidth() / 13, bmp_y+bmp.getHeight());   
  56.         if (animation_init == animation_up) {   
  57.             canvas.drawBitmap(bmp, bmp_x - animation_up[frame_count] * (bmp.getWidth() / 13), bmp_y, p);   
  58.         } else if (animation_init == animation_down) {   
  59.             canvas.drawBitmap(bmp, bmp_x - animation_down[frame_count] * (bmp.getWidth() / 13), bmp_y, p);   
  60.         } else if (animation_init == animation_left) {   
  61.             canvas.drawBitmap(bmp, bmp_x - animation_left[frame_count] * (bmp.getWidth() / 13), bmp_y, p);   
  62.         } else if (animation_init == animation_right) {   
  63.             canvas.drawBitmap(bmp, bmp_x - animation_right[frame_count] * (bmp.getWidth() / 13), bmp_y, p);   
  64.         }   
  65.         canvas.restore();  //备注3   
  66.         sfh.unlockCanvasAndPost(canvas);   
  67.     }   
  68.     public void cycle() {   
  69.         if (DOWN) {   
  70.             bmp_y += 5;   
  71.         } else if (UP) {   
  72.             bmp_y -= 5;   
  73.         } else if (LEFT) {   
  74.             bmp_x -= 5;   
  75.         } else if (RIGHT) {   
  76.             bmp_x += 5;   
  77.         }   
  78.         if (DOWN || UP || LEFT || RIGHT) {   
  79.             if (frame_count < 2) {   
  80.                 frame_count++;   
  81.             } else {   
  82.                 frame_count = 0;   
  83.             }   
  84.         }   
  85.         if (DOWN == false && UP == false && LEFT == false && RIGHT == false) {   
  86.             frame_count = 0;   
  87.         }   
  88.     }   
  89.     @Override  
  90.     public boolean onKeyDown(int key, KeyEvent event) {   
  91.         if (key == KeyEvent.KEYCODE_DPAD_UP) {   
  92.             if (UP == false) {   
  93.                 animation_init = animation_up;   
  94.             }   
  95.             UP = true;   
  96.         } else if (key == KeyEvent.KEYCODE_DPAD_DOWN) {   
  97.             if (DOWN == false) {   
  98.                 animation_init = animation_down;   
  99.             }   
  100.             DOWN = true;   
  101.         } else if (key == KeyEvent.KEYCODE_DPAD_LEFT) {   
  102.             if (LEFT == false) {   
  103.                 animation_init = animation_left;   
  104.             }   
  105.             LEFT = true;   
  106.         } else if (key == KeyEvent.KEYCODE_DPAD_RIGHT) {   
  107.             if (RIGHT == false) {   
  108.                 animation_init = animation_right;   
  109.             }   
  110.             RIGHT = true;   
  111.         }   
  112.         return super.onKeyDown(key, event);   
  113.     }   
  114.     /* (non-Javadoc)  
  115.      * @see android.view.View#onKeyUp(int, android.view.KeyEvent)  
  116.      */  
  117.     @Override  
  118.     public boolean onKeyUp(int keyCode, KeyEvent event) {   
  119.         if (DOWN) {   
  120.             DOWN = false;   
  121.         } else if (UP) {   
  122.             UP = false;   
  123.         } else if (LEFT) {   
  124.             LEFT = false;   
  125.         } else if (RIGHT) {   
  126.             RIGHT = false;   
  127.         }   
  128.         return super.onKeyUp(keyCode, event);   
  129.     }   
  130.     @Override  
  131.     public void run() {   
  132.         // TODO Auto-generated method stub   
  133.         while (true) {   
  134.             draw();   
  135.             cycle();   
  136.             try {   
  137.                 Thread.sleep(100);   
  138.             } catch (Exception ex) {   
  139.             }   
  140.         }   
  141.     }   
  142.     @Override  
  143.     public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {   
  144.         // TODO Auto-generated method stub   
  145.     }   
  146.     @Override  
  147.     public void surfaceDestroyed(SurfaceHolder holder) {   
  148.         // TODO Auto-generated method stub   
  149.     }   
  150. }  

       备注1

       此方法是用来响应按键！如果是自己定义一个继承自View的类,重新实现onKeyDown方法后,只有当该View获得焦点时才会调用onKeyDown方法，Actvity中的onKeyDown方法是当所有控件均没有处理该按键事件时,才会调用.

       备注2

       这里也是对屏幕进行刷屏操作，其实这也只是一种，之前文章里我也用到drawRGB的方法同样实现，当然也可以用fillRect等来刷屏。

       那么这里我想说下，在继承view中，因为onDraw方法是系统自动调用的，不像在surfaceview这里这样去在run里面自己去不断调用，在view中我们可以抵用invalidate()/postInvalidate() 这两种方法实现让系统调用onDraw方法，这里也是和surfaceview中的不同之一！

       备注3

       这里canvas.save();和canvas.restore();是两个相互匹配出现的，作用是用来保存画布的状态和取出保存的状态的。这里稍微解释一下，

       当我们对画布进行旋转，缩放，平移等操作的时候其实我们是想对特定的元素进行操作，比如图片，一个矩形等，但是当你用canvas的方法来进行这些操作的时候，其实是对整个画布进行了操作，那么之后在画布上的元素都会受到影响，所以我们在操作之前调用canvas.save()来保存画布当前的状态，当操作之后取出之前保存过的状态，这样就不会对其他的元素进行影响。

       对于canvas.save();和canvas.restore();  还有不少童鞋不懂，OK，我再补充点：

       代码段1：

Java代码
  1. public void draw() {   
  2.   Canvas canvas = sfh.lockCanvas();   
  3.   canvas.drawColor(Color.BLACK);   
  4.   canvas.drawBitmap(bmp1, 0,0,paint);   
  5.   canvas.save();   
  6.   canvas.scale(1.5f, 1.5f);   
  7.   canvas.restore();   
  8.   canvas.drawBitmap(bmp2, 0,0,paint);   
  9.   sfh.unlockCanvasAndPost(canvas);   
  10. }  

       代码段2：

Java代码
  1. public void draw() {   
  2.   Canvas canvas = sfh.lockCanvas();   
  3.   canvas.drawColor(Color.BLACK);   
  4.   canvas.drawBitmap(bmp1, 0,0,paint);   
  5.   canvas.scale(1.5f, 1.5f);   
  6.   canvas.drawBitmap(bmp2, 0,0,paint);   
  7.   sfh.unlockCanvasAndPost(canvas);   
  8. }  

       上面这两个代码片段中我们都假设有两张图片bmp1和bmp2，并且都画在画布上!

       那么代码段1和代码段2的不同：

       代码段1中我们进行画布缩放的之前保存了画布状态，做了缩放操作之后又取出之前保存的状态，这样做是为了保证bmp2正常画出来不受到缩放的影响！

       代码段2里，画了bmp1后就执行了缩放操作，并且没有保存状态！紧接着画了bmp2，那么bmp2也会一样受到缩放的影响！！

       所以我们如果单独处理一张图片的时候，而且不想影响其他部分的绘制，那么应该如下来做：

Java代码
  1. public void draw() {   
  2.     Canvas canvas = sfh.lockCanvas();   
  3.     canvas.drawColor(Color.BLACK);   
  4.     canvas.drawBitmap(bmp1, 0,0,paint);   
  5.     canvas.save();   
  6.     canvas.scale(1.5f, 1.5f);   
  7.     canvas.drawBitmap(bmp2, 0,0,paint);   
  8.     canvas.restore();   
  9.     sfh.unlockCanvasAndPost(canvas);   
  10.   }  
本文发布：Android开发网
本文地址：http://www.jizhuomi.com/android/game/206.html
2012年9月16日
发布:鸡啄米 分类:Android游戏开发 浏览: 评论:0