Android打飞机游戏源代码

package com.pg; import android.graphics.Bitmap; import android.graphics.Canvas; import android.graphics.Paint; import android.view.KeyEvent; /** * @author Himi * */ public class Player {     //主角的血量与血量位图     //默认3血     private int 主角的血量 = 3;     private Bitmap 主角的血量位图;     //主角的坐标以及位图     public int 主角的坐标x, 主角的坐标y;     private Bitmap 主角的位图;     //主角移动速度     private int 主角移动速度 = 5;     //主角移动标识（基础章节已讲解，你懂得）     private boolean isUp, isDown, isLeft, isRight;     //碰撞后处于无敌时间     //计时器     private int 无敌计时器 = 0;     //因为无敌时间     private int 无敌时间 = 60;     //是否碰撞的标识位     private boolean 是否碰撞;     //主角的构造函数     public Player(Bitmap bmpPlayer, Bitmap bmpPlayerHp) {         this.主角的位图 = bmpPlayer;         this.主角的血量位图 = bmpPlayerHp;         主角的坐标x = MySurfaceView.screenW / 2 - bmpPlayer.getWidth() / 2;         主角的坐标y = MySurfaceView.screenH - bmpPlayer.getHeight();     }     //主角的绘图函数     public void draw(Canvas canvas, Paint paint) {         //绘制主角         //当处于无敌时间时，让主角闪烁         if (是否碰撞) {             //每2次游戏循环，绘制一次主角             if (无敌计时器 % 2 == 0) {                 canvas.drawBitmap(主角的位图, 主角的坐标x, 主角的坐标y, paint);             }         } else {             canvas.drawBitmap(主角的位图, 主角的坐标x, 主角的坐标y, paint);         }         //绘制主角血量         for (int i = 0; i < 主角的血量; i++) {             canvas.drawBitmap(主角的血量位图, i * 主角的血量位图.getWidth(), MySurfaceView.screenH - 主角的血量位图.getHeight(), paint);         }     }     //实体按键     public void onKeyDown(int keyCode, KeyEvent event) {         if (keyCode == KeyEvent.KEYCODE_DPAD_UP) {             isUp = true;         }         if (keyCode == KeyEvent.KEYCODE_DPAD_DOWN) {             isDown = true;         }         if (keyCode == KeyEvent.KEYCODE_DPAD_LEFT) {             isLeft = true;         }         if (keyCode == KeyEvent.KEYCODE_DPAD_RIGHT) {             isRight = true;         }     }     //实体按键抬起     public void onKeyUp(int keyCode, KeyEvent event) {         if (keyCode == KeyEvent.KEYCODE_DPAD_UP) {             isUp = false;         }         if (keyCode == KeyEvent.KEYCODE_DPAD_DOWN) {             isDown = false;         }         if (keyCode == KeyEvent.KEYCODE_DPAD_LEFT) {             isLeft = false;         }         if (keyCode == KeyEvent.KEYCODE_DPAD_RIGHT) {             isRight = false;         }     }     //主角的逻辑     public void logic() {         //处理主角移动         if (isLeft) {             主角的坐标x -= 主角移动速度;         }         if (isRight) {             主角的坐标x += 主角移动速度;         }         if (isUp) {             主角的坐标y -= 主角移动速度;         }         if (isDown) {             主角的坐标y += 主角移动速度;         }         //判断屏幕X边界         if (主角的坐标x + 主角的位图.getWidth() >= MySurfaceView.screenW) {             主角的坐标x = MySurfaceView.screenW - 主角的位图.getWidth();         } else if (主角的坐标x <= 0) {             主角的坐标x = 0;         }         //判断屏幕Y边界         if (主角的坐标y + 主角的位图.getHeight() >= MySurfaceView.screenH) {             主角的坐标y = MySurfaceView.screenH - 主角的位图.getHeight();         } else if (主角的坐标y <= 0) {             主角的坐标y = 0;         }         //处理无敌状态         if (是否碰撞) {             //计时器开始计时             无敌计时器++;             if (无敌计时器 >= 无敌时间) {                 //无敌时间过后，接触无敌状态及初始化计数器                 是否碰撞 = false;                 无敌计时器 = 0;             }         }     }     //设置主角血量     public void setPlayerHp(int hp) {         this.主角的血量 = hp;     }     //获取主角血量     public int getPlayerHp() {         return 主角的血量;     }     //判断碰撞(主角与敌机)     public boolean isCollsionWith(Enemy en) {         //是否处于无敌时间         if (是否碰撞 == false) {             int x2 = en.敌机坐标x;             int y2 = en.敌机坐标y;             int w2 = en.敌机每帧的宽;             int h2 = en.敌机每帧的高;             if (主角的坐标x >= x2 && 主角的坐标x >= x2 + w2) {                 return false;             } else if (主角的坐标x <= x2 && 主角的坐标x + 主角的位图.getWidth() <= x2) {                 return false;             } else if (主角的坐标y >= y2 && 主角的坐标y >= y2 + h2) {                 return false;             } else if (主角的坐标y <= y2 && 主角的坐标y + 主角的位图.getHeight() <= y2) {                 return false;             }             //碰撞即进入无敌状态             是否碰撞 = true;             return true;             //处于无敌状态，无视碰撞         } else {             return false;         }     }     //判断碰撞(主角与敌机子弹)     public boolean isCollsionWith(Bullet bullet) {         //是否处于无敌时间         if (是否碰撞 == false) {             int x2 = bullet.子弹X;             int y2 = bullet.子弹Y;             int w2 = bullet.子弹图片.getWidth();             int h2 = bullet.子弹图片.getHeight();             if (主角的坐标x >= x2 && 主角的坐标x >= x2 + w2) {                 return false;             } else if (主角的坐标x <= x2 && 主角的坐标x + 主角的位图.getWidth() <= x2) {                 return false;             } else if (主角的坐标y >= y2 && 主角的坐标y >= y2 + h2) {                 return false;             } else if (主角的坐标y <= y2 && 主角的坐标y + 主角的位图.getHeight() <= y2) {                 return false;             }             //碰撞即进入无敌状态             是否碰撞 = true;             return true;             //处于无敌状态，无视碰撞         } else {             return false;         }     } } package com.pg; import android.graphics.Bitmap; import android.graphics.Canvas; import android.graphics.Paint; /** * @author Himi * */ public class GameBg {     //游戏背景的图片资源     //为了循环播放，这里定义两个位图对象，     //其资源引用的是同一张图片     private Bitmap bmp游戏背景的图片1;     private Bitmap bmp游戏背景的图片2;     //游戏背景坐标     private int bg1x, bg1y, bg2x, bg2y;     //背景滚动速度     private int speed = 3;     //游戏背景构造函数     public GameBg(Bitmap bmpBackGround) {         this.bmp游戏背景的图片1 = bmpBackGround;         this.bmp游戏背景的图片2 = bmpBackGround;         //首先让第一张背景底部正好填满整个屏幕         bg1y = -Math.abs(bmp游戏背景的图片1.getHeight() - MySurfaceView.screenH);         //第二张背景图紧接在第一张背景的上方         //+101的原因：虽然两张背景图无缝隙连接但是因为图片资源头尾         //直接连接不和谐，为了让视觉看不出是两张图连接而修正的位置         bg2y = bg1y - bmp游戏背景的图片1.getHeight() + 111;     }     //游戏背景的绘图函数     public void draw(Canvas canvas, Paint paint) {         //绘制两张背景         canvas.drawBitmap(bmp游戏背景的图片1, bg1x, bg1y, paint);         canvas.drawBitmap(bmp游戏背景的图片2, bg2x, bg2y, paint);     }     //游戏背景的逻辑函数     public void logic() {         bg1y += speed;         bg2y += speed;         //当第一张图片的Y坐标超出屏幕，         //立即将其坐标设置到第二张图的上方         if (bg1y > MySurfaceView.screenH) {             bg1y = bg2y - bmp游戏背景的图片1.getHeight() + 111;         }         //当第二张图片的Y坐标超出屏幕，         //立即将其坐标设置到第一张图的上方         if (bg2y > MySurfaceView.screenH) {             bg2y = bg1y - bmp游戏背景的图片1.getHeight() + 111;         }     } } /** * */ package com.pg; import android.graphics.Bitmap; import android.graphics.Canvas; import android.graphics.Paint; /** * Boss * @author Himi * */ public class Boss {     //Boss的血量     public int Boss的血量 = 50;     //Boss的图片资源     private Bitmap Boss的图片;     //Boss坐标     public int Boss坐标x, Boss坐标y;     //Boss每帧的宽高     public int Boss每帧的宽, Boss每帧的高;     //Boss当前帧下标     private int Boss当前帧下标;     //Boss运动的速度     private int Boss运动的速度 = 5;     //Boss的运动轨迹     //一定时间会向着屏幕下方运动，并且发射大范围子弹，（是否狂态）     //正常状态下 ，子弹垂直朝下运动     private boolean 子弹垂直朝下;     //进入疯狂状态的状态时间间隔     private int 进入疯狂状态的状态时间间隔 = 200;     //计数器     private int count;     //Boss的构造函数     public Boss(Bitmap bmpBoss) {         this.Boss的图片 = bmpBoss;         Boss每帧的宽 = bmpBoss.getWidth() / 10;         Boss每帧的高 = bmpBoss.getHeight();         //Boss的X坐标居中         Boss坐标x = MySurfaceView.screenW / 2 - Boss每帧的宽 / 2;         Boss坐标y = 0;     }     //Boss的绘制     public void draw(Canvas canvas, Paint paint) {         canvas.save();         canvas.clipRect(Boss坐标x, Boss坐标y, Boss坐标x + Boss每帧的宽, Boss坐标y + Boss每帧的高);         canvas.drawBitmap(Boss的图片, Boss坐标x - Boss当前帧下标 * Boss每帧的宽, Boss坐标y, paint);         canvas.restore();     }     //Boss的逻辑     public void logic() {         //不断循环播放帧形成动画         Boss当前帧下标++;         if (Boss当前帧下标 >= 10) {             Boss当前帧下标 = 0;         }         //没有疯狂的状态         if (子弹垂直朝下 == false) {             Boss坐标x += Boss运动的速度;             if (Boss坐标x + Boss每帧的宽 >= MySurfaceView.screenW) {                 Boss运动的速度 = -Boss运动的速度;             } else if (Boss坐标x <= 0) {                 Boss运动的速度 = -Boss运动的速度;             }             count++;             if (count % 进入疯狂状态的状态时间间隔 == 0) {                 子弹垂直朝下 = true;                 Boss运动的速度 = 24;             }             //疯狂的状态         } else {             Boss运动的速度 -= 1;             //当Boss返回时创建大量子弹             if (Boss运动的速度 == 0) {                 //添加8方向子弹                                 MySurfaceView.Boss的子弹容器.add(new Bullet(MySurfaceView.bmpBossBullet, Boss坐标x+40, Boss坐标y+10, Bullet.Boss的子弹, Bullet.DIR_UP));                 MySurfaceView.Boss的子弹容器.add(new Bullet(MySurfaceView.bmpBossBullet, Boss坐标x+40, Boss坐标y+10, Bullet.Boss的子弹, Bullet.DIR_DOWN));                 MySurfaceView.Boss的子弹容器.add(new Bullet(MySurfaceView.bmpBossBullet, Boss坐标x+40, Boss坐标y+10, Bullet.Boss的子弹, Bullet.DIR_LEFT));                 MySurfaceView.Boss的子弹容器.add(new Bullet(MySurfaceView.bmpBossBullet, Boss坐标x+40, Boss坐标y+10, Bullet.Boss的子弹, Bullet.DIR_RIGHT));                 MySurfaceView.Boss的子弹容器.add(new Bullet(MySurfaceView.bmpBossBullet, Boss坐标x+40, Boss坐标y+10, Bullet.Boss的子弹, Bullet.DIR_UP_LEFT));                 MySurfaceView.Boss的子弹容器.add(new Bullet(MySurfaceView.bmpBossBullet, Boss坐标x+40, Boss坐标y+10, Bullet.Boss的子弹, Bullet.DIR_UP_RIGHT));                 MySurfaceView.Boss的子弹容器.add(new Bullet(MySurfaceView.bmpBossBullet, Boss坐标x+40, Boss坐标y+10, Bullet.Boss的子弹, Bullet.DIR_DOWN_LEFT));                 MySurfaceView.Boss的子弹容器.add(new Bullet(MySurfaceView.bmpBossBullet, Boss坐标x+40, Boss坐标y+10, Bullet.Boss的子弹, Bullet.DIR_DOWN_RIGHT));             }             Boss坐标y += Boss运动的速度;             if (Boss坐标y <= 0) {                 //恢复正常状态                 子弹垂直朝下 = false;                 Boss运动的速度 = 5;             }         }     }     //判断碰撞(Boss被主角子弹击中)     public boolean isCollsionWith(Bullet bullet) {         int x2 = bullet.子弹X;         int y2 = bullet.子弹Y;         int w2 = bullet.子弹图片.getWidth();         int h2 = bullet.子弹图片.getHeight();         if (Boss坐标x >= x2 && Boss坐标x >= x2 + w2) {             return false;         } else if (Boss坐标x <= x2 && Boss坐标x + Boss每帧的宽 <= x2) {             return false;         } else if (Boss坐标y >= y2 && Boss坐标y >= y2 + h2) {             return false;         } else if (Boss坐标y <= y2 && Boss坐标y + Boss每帧的高 <= y2) {             return false;         }         return true;     }     //设置Boss血量     public void setHp(int hp) {         this.Boss的血量 = hp;     } }=================================================================== package com.pg; import android.graphics.Bitmap; import android.graphics.Canvas; import android.graphics.Paint; /** * @author Himi * */ public class Boom {     //爆炸效果资源图     private Bitmap 爆炸图;     //爆炸效果的位置坐标     private int 爆炸图X, 爆炸图Y;     //爆炸动画播放当前的帧下标     private int 爆炸动画播放当前的帧下标;     //爆炸效果的总帧数     private int 爆炸效果的总帧数;     //每帧的宽高     private int 每帧的宽, 每帧的高;     //是否播放完毕，优化处理     public boolean 是否播放完毕;     //爆炸效果的构造函数     public Boom(Bitmap bmpBoom, int x, int y, int totleFrame) {         this.爆炸图 = bmpBoom;         this.爆炸图X = x;         this.爆炸图Y = y;         this.爆炸效果的总帧数 = totleFrame;         每帧的宽 = bmpBoom.getWidth() / totleFrame;         每帧的高 = bmpBoom.getHeight();     }     //爆炸效果绘制     public void draw(Canvas canvas, Paint paint) {         canvas.save();         canvas.clipRect(爆炸图X, 爆炸图Y, 爆炸图X + 每帧的宽, 爆炸图Y + 每帧的高);         canvas.drawBitmap(爆炸图, 爆炸图X - 爆炸动画播放当前的帧下标 * 每帧的宽, 爆炸图Y, paint);         canvas.restore();     }     //爆炸效果的逻辑     public void logic() {         if (爆炸动画播放当前的帧下标 < 爆炸效果的总帧数) {             爆炸动画播放当前的帧下标++;         } else {             是否播放完毕 = true;         }     } } package com.pg; import android.app.Activity; import android.os.Bundle; import android.view.Window; import android.view.WindowManager; public class MainActivity extends Activity {     public static MainActivity instance;     @Override     public void onCreate(Bundle savedInstanceState) {         super.onCreate(savedInstanceState);         instance = this;         //设置全屏         this.getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);         requestWindowFeature(Window.FEATURE_NO_TITLE);         //显示自定义的SurfaceView视图         setContentView(new MySurfaceView(this));     } } package com.pg; import android.graphics.Bitmap; import android.graphics.Canvas; import android.graphics.Paint; /** * @author Himi * */ public class Bullet {     //子弹图片资源     public Bitmap 子弹图片;     //子弹的坐标     public int 子弹X, 子弹Y;     //子弹的速度     public int 子弹的速度;     //子弹的种类以及常量     public int 子弹的种类;     //主角的     public static final int 主角的子弹 = -1;     //鸭子的     public static final int 鸭子的子弹 = 1;     //苍蝇的     public static final int 苍蝇的子弹 = 2;     //Boss的     public static final int Boss的子弹 = 3;     //子弹是否超屏， 优化处理     public boolean 子弹是否超屏;     //Boss疯狂状态下子弹相关成员变量     private int 当前Boss子弹方向;//当前Boss子弹方向     //8方向常量     public static final int DIR_UP = -1;     public static final int DIR_DOWN = 2;     public static final int DIR_LEFT = 3;     public static final int DIR_RIGHT = 4;     public static final int DIR_UP_LEFT = 5;     public static final int DIR_UP_RIGHT = 6;     public static final int DIR_DOWN_LEFT = 7;     public static final int DIR_DOWN_RIGHT = 8;     //子弹当前方向     public Bullet(Bitmap bmpBullet, int bulletX, int bulletY, int bulletType) {         this.子弹图片 = bmpBullet;         this.子弹X = bulletX;         this.子弹Y = bulletY;         this.子弹的种类 = bulletType;         //不同的子弹类型速度不一         switch (bulletType) {         case 主角的子弹:             子弹的速度 = 4;             break;         case 鸭子的子弹:             子弹的速度 = 3;             break;         case 苍蝇的子弹:             子弹的速度 = 4;             break;         case Boss的子弹:             子弹的速度 = 5;             break;         }     }     /**     * 专用于处理Boss疯狂状态下创建的子弹     * @param bmpBullet     * @param bulletX     * @param bulletY     * @param bulletType     * @param Dir     */     public Bullet(Bitmap bmpBullet, int bulletX, int bulletY, int bulletType, int dir) {         this.子弹图片 = bmpBullet;         this.子弹X = bulletX;         this.子弹Y = bulletY;         this.子弹的种类 = bulletType;         子弹的速度 = 5;         this.当前Boss子弹方向 = dir;     }     //子弹的绘制     public void draw(Canvas canvas, Paint paint) {         canvas.drawBitmap(子弹图片, 子弹X, 子弹Y, paint);     }     //子弹的逻辑     public void logic() {         //不同的子弹类型逻辑不一         //主角的子弹垂直向上运动         switch (子弹的种类) {         case 主角的子弹:             子弹Y -= 子弹的速度;             if (子弹Y < -50) {                 子弹是否超屏 = true;             }             break;         //鸭子和苍蝇的子弹都是垂直下落运动         case 鸭子的子弹:         case 苍蝇的子弹:             子弹Y += 子弹的速度;             if (子弹Y > MySurfaceView.screenH) {                 子弹是否超屏 = true;             }             break;         //Boss疯狂状态下的8方向子弹逻辑         case Boss的子弹:             //Boss疯狂状态下的子弹逻辑待实现             switch (当前Boss子弹方向) {             //方向上的子弹             case DIR_UP:                 子弹Y -= 子弹的速度;                 break;             //方向下的子弹             case DIR_DOWN:                 子弹Y += 子弹的速度;                 break;             //方向左的子弹             case DIR_LEFT:                 子弹X -= 子弹的速度;                 break;             //方向右的子弹             case DIR_RIGHT:                 子弹X += 子弹的速度;                 break;             //方向左上的子弹             case DIR_UP_LEFT:                 子弹Y -= 子弹的速度;                 子弹X -= 子弹的速度;                 break;             //方向右上的子弹             case DIR_UP_RIGHT:                 子弹X += 子弹的速度;                 子弹Y -= 子弹的速度;                 break;             //方向左下的子弹             case DIR_DOWN_LEFT:                 子弹X -= 子弹的速度;                 子弹Y += 子弹的速度;                 break;             //方向右下的子弹             case DIR_DOWN_RIGHT:                 子弹Y += 子弹的速度;                 子弹X += 子弹的速度;                 break;             }             //边界处理             if (子弹Y > MySurfaceView.screenH || 子弹Y <= -40 || 子弹X > MySurfaceView.screenW || 子弹X <= -40) {                 子弹是否超屏 = true;             }             break;         }     } package com.pg; import java.util.Random; import java.util.Vector; import android.content.Context; import android.content.res.Resources; import android.graphics.Bitmap; import android.graphics.BitmapFactory; import android.graphics.Canvas; import android.graphics.Color; import android.graphics.Paint; import android.view.KeyEvent; import android.view.MotionEvent; import android.view.SurfaceHolder; import android.view.SurfaceView; import android.view.SurfaceHolder.Callback; /** * * @author Himi * */ public class MySurfaceView extends SurfaceView implements Callback, Runnable {     private SurfaceHolder sfh;     private Paint paint;     private Thread th;     private boolean flag;     private Canvas canvas;     public static int screenW, screenH;     //定义游戏状态常量     public static final int 游戏菜单 = 0;//游戏菜单     public static final int 游戏中 = 1;//游戏中     public static final int 游戏胜利 = 2;//游戏胜利     public static final int 游戏失败 = 3;//游戏失败     public static final int GAME_PAUSE = -1;//游戏菜单     //当前游戏状态(默认初始在游戏菜单界面)     public static int 当前游戏状态 = 游戏菜单;     //声明一个Resources实例便于加载图片     private Resources res = this.getResources();     //声明游戏需要用到的图片资源(图片声明)     private Bitmap bmpBackGround;//游戏背景     private Bitmap bmpBoom;//爆炸效果     private Bitmap bmpBoosBoom;//Boos爆炸效果     private Bitmap bmpButton;//游戏开始按钮     private Bitmap bmpButtonPress;//游戏开始按钮被点击     private Bitmap bmpEnemyDuck;//怪物鸭子     private Bitmap bmpEnemyFly;//怪物苍蝇     private Bitmap bmpEnemyBoos;//怪物猪头Boos     private Bitmap bmpGameWin;//游戏胜利背景     private Bitmap bmpGameLost;//游戏失败背景     private Bitmap bmpPlayer;//游戏主角飞机     private Bitmap bmpPlayerHp;//主角飞机血量     private Bitmap bmpMenu;//菜单背景     public static Bitmap bmpBullet;//子弹     public static Bitmap bmpEnemyBullet;//敌机子弹     public static Bitmap bmpBossBullet;//Boss子弹     //声明一个菜单对象     private GameMenu 菜单;     //声明一个滚动游戏背景对象     private GameBg 滚动游戏背景对象;     //声明主角对象     private Player 主角;     //声明一个敌机容器     private Vector 敌机容器;     //每次生成敌机的时间(毫秒)     private int 每次生成敌机的时间 = 50;     private int 计数器;//计数器     //敌人数组：1和2

表

关于同志近三年现实表现材料材料类招标技术评分表图表与交易pdf视力表打印pdf用图表说话 pdf

示敌机的种类，-1表示Boss     //二维数组的每一维都是一组怪物     private int enemyArray[][] = { { 1, 2 }, { 1, 1 }, { 1, 3, 1, 2 }, { 1, 2 }, { 2, 3 }, { 3, 1, 3 }, { 2, 2 }, { 1, 2 }, { 2, 2 }, { 1, 3, 1, 1 }, { 2, 1 },             { 1, 3 }, { 2, 1 }, { -1 } };     //当前取出一维数组的下标     private int 当前取出一维数组的下标;     //是否出现Boss标识位     private boolean 是否出现Boss;     //随机库，为创建的敌机赋予随即坐标     private Random random;     //敌机子弹容器     private Vector 敌机子弹容器;     //添加子弹的计数器     private int 添加子弹的计数器;     //主角子弹容器     private Vector 主角子弹容器;     //添加子弹的计数器     private int 主角添加子弹的计数器;     //爆炸效果容器     private Vector 爆炸效果容器;     //声明Boss     private Boss boss;     //Boss的子弹容器     public static Vector Boss的子弹容器;     /**     * SurfaceView初始化函数     */     public MySurfaceView(Context context) {         super(context);         sfh = this.getHolder();         sfh.addCallback(this);         paint = new Paint();         paint.setColor(Color.WHITE);         paint.setAntiAlias(true);         setFocusable(true);         setFocusableInTouchMode(true);         //设置背景常亮         this.setKeepScreenOn(true);     }     /**     * SurfaceView视图创建，响应此函数     */     public void surfaceCreated(SurfaceHolder holder) {         screenW = this.getWidth();         screenH = this.getHeight();         initGame();         flag = true;         //实例线程         th = new Thread(this);         //启动线程         th.start();     }     /*     * 自定义的游戏初始化函数     */     private void initGame() {         //放置游戏切入后台重新进入游戏时，游戏被重置!         //当游戏状态处于菜单时，才会重置游戏         if (当前游戏状态 == 游戏菜单) {             //加载游戏资源             bmpBackGround = BitmapFactory.decodeResource(res, R.drawable.background);             bmpBoom = BitmapFactory.decodeResource(res, R.drawable.boom);             bmpBoosBoom = BitmapFactory.decodeResource(res, R.drawable.boos_boom);             bmpButton = BitmapFactory.decodeResource(res, R.drawable.button);             bmpButtonPress = BitmapFactory.decodeResource(res, R.drawable.button_press);             bmpEnemyDuck = BitmapFactory.decodeResource(res, R.drawable.enemy_duck);             bmpEnemyFly = BitmapFactory.decodeResource(res, R.drawable.enemy_fly);             bmpEnemyBoos = BitmapFactory.decodeResource(res, R.drawable.enemy_pig);             bmpGameWin = BitmapFactory.decodeResource(res, R.drawable.gamewin);             bmpGameLost = BitmapFactory.decodeResource(res, R.drawable.gamelost);             bmpPlayer = BitmapFactory.decodeResource(res, R.drawable.player);             bmpPlayerHp = BitmapFactory.decodeResource(res, R.drawable.hp);             bmpMenu = BitmapFactory.decodeResource(res, R.drawable.menu);             bmpBullet = BitmapFactory.decodeResource(res, R.drawable.bullet);             bmpEnemyBullet = BitmapFactory.decodeResource(res, R.drawable.bullet_enemy);             bmpBossBullet = BitmapFactory.decodeResource(res, R.drawable.boosbullet);             //爆炸效果容器实例             爆炸效果容器 = new Vector();             //敌机子弹容器实例             敌机子弹容器 = new Vector();             //主角子弹容器实例             主角子弹容器 = new Vector();             //菜单类实例             菜单 = new GameMenu(bmpMenu, bmpButton, bmpButtonPress);             //实例游戏背景             滚动游戏背景对象 = new GameBg(bmpBackGround);             //实例主角             主角 = new Player(bmpPlayer, bmpPlayerHp);             //实例敌机容器             敌机容器 = new Vector();             //实例随机库             random = new Random();             //---Boss相关             //实例boss对象             boss = new Boss(bmpEnemyBoos);             //实例Boss子弹容器             Boss的子弹容器 = new Vector();         }     }     /**     * 游戏绘图     */     public void myDraw() {         try {             canvas = sfh.lockCanvas();             if (canvas != null) {                 canvas.drawColor(Color.WHITE);                 //绘图函数根据游戏状态不同进行不同绘制                 switch (当前游戏状态) {                 case 游戏菜单:                     //菜单的绘图函数                     菜单.draw(canvas, paint);                     break;                 case 游戏中:                     //游戏背景                     滚动游戏背景对象.draw(canvas, paint);                     //主角绘图函数                     主角.draw(canvas, paint);                     if (是否出现Boss == false) {                         //敌机绘制                         for (int i = 0; i < 敌机容器.size(); i++) {                             敌机容器.elementAt(i).draw(canvas, paint);                         }                         //敌机子弹绘制                         for (int i = 0; i < 敌机子弹容器.size(); i++) {                             敌机子弹容器.elementAt(i).draw(canvas, paint);                         }                     } else {                         //Boos的绘制                         boss.draw(canvas, paint);                         //Boss子弹逻辑                         for (int i = 0; i < Boss的子弹容器.size(); i++) {                             Boss的子弹容器.elementAt(i).draw(canvas, paint);                         }                     }                     //处理主角子弹绘制                     for (int i = 0; i < 主角子弹容器.size(); i++) {                         主角子弹容器.elementAt(i).draw(canvas, paint);                     }                     //爆炸效果绘制                     for (int i = 0; i < 爆炸效果容器.size(); i++) {                         爆炸效果容器.elementAt(i).draw(canvas, paint);                     }                     break;                 case GAME_PAUSE:                     break;                 case 游戏胜利:                     canvas.drawBitmap(bmpGameWin, 0, 0, paint);                     break;                 case 游戏失败:                     canvas.drawBitmap(bmpGameLost, 0, 0, paint);                     break;                 }             }         } catch (Exception e) {             // TODO: handle exception         } finally {             if (canvas != null)                 sfh.unlockCanvasAndPost(canvas);         }     }     /**     * 触屏事件监听     */     @Override     public boolean onTouchEvent(MotionEvent event) {         //触屏监听事件函数根据游戏状态不同进行不同监听         switch (当前游戏状态) {         case 游戏菜单:             //菜单的触屏事件处理             菜单.onTouchEvent(event);             break;         case 游戏中:             break;         case GAME_PAUSE:             break;         case 游戏胜利:             break;         case 游戏失败:             break;         }         return true;     }     /**     * 按键按下事件监听     */     @Override     public boolean onKeyDown(int keyCode, KeyEvent event) {         //处理back返回按键         if (keyCode == KeyEvent.KEYCODE_BACK) {             //游戏胜利、失败、进行时都默认返回菜单             if (当前游戏状态 == 游戏中 || 当前游戏状态 == 游戏胜利 || 当前游戏状态 == 游戏失败) {                 当前游戏状态 = 游戏菜单;                 //Boss状态设置为没出现                 是否出现Boss = false;                 //重置游戏                 initGame();                 //重置怪物出场                 当前取出一维数组的下标 = 0;             } else if (当前游戏状态 == 游戏菜单) {                 //当前游戏状态在菜单界面，默认返回按键退出游戏                 MainActivity.instance.finish();                 System.exit(0);             }             //表示此按键已处理，不再交给系统处理，             //从而避免游戏被切入后台             return true;         }         //按键监听事件函数根据游戏状态不同进行不同监听         switch (当前游戏状态) {         case 游戏菜单:             break;         case 游戏中:             //主角的按键按下事件             主角.onKeyDown(keyCode, event);             break;         case GAME_PAUSE:             break;         case 游戏胜利:             break;         case 游戏失败:             break;         }         return super.onKeyDown(keyCode, event);     }     /**     * 按键抬起事件监听     */     @Override     public boolean onKeyUp(int keyCode, KeyEvent event) {         //处理back返回按键         if (keyCode == KeyEvent.KEYCODE_BACK) {             //游戏胜利、失败、进行时都默认返回菜单             if (当前游戏状态 == 游戏中 || 当前游戏状态 == 游戏胜利 || 当前游戏状态 == 游戏失败) {                 当前游戏状态 = 游戏菜单;             }             //表示此按键已处理，不再交给系统处理，             //从而避免游戏被切入后台             return true;         }         //按键监听事件函数根据游戏状态不同进行不同监听         switch (当前游戏状态) {         case 游戏菜单:             break;         case 游戏中:             //按键抬起事件             主角.onKeyUp(keyCode, event);             break;         case GAME_PAUSE:             break;         case 游戏胜利:             break;         case 游戏失败:             break;         }         return super.onKeyDown(keyCode, event);     }     /**     * 游戏逻辑     */     private void logic() {         //逻辑处理根据游戏状态不同进行不同处理         switch (当前游戏状态) {         case 游戏菜单:             break;         case 游戏中:             //背景逻辑             滚动游戏背景对象.logic();             //主角逻辑             主角.logic();             //敌机逻辑             if (是否出现Boss == false) {                 //敌机逻辑                 for (int i = 0; i < 敌机容器.size(); i++) {                     Enemy en = 敌机容器.elementAt(i);                     //因为容器不断添加敌机 ，那么对敌机isDead判定，                     //如果已死亡那么就从容器中删除,对容器起到了优化作用；                     if (en.敌机是否已经出屏) {                         敌机容器.removeElementAt(i);                     } else {                         en.logic();                     }                 }                 //生成敌机                 计数器++;                 if (计数器 % 每次生成敌机的时间 == 0) {                     for (int i = 0; i < enemyArray[当前取出一维数组的下标].length; i++) {                         //苍蝇                         if (enemyArray[当前取出一维数组的下标][i] == 1) {                             int x = random.nextInt(screenW - 100) + 50;                             敌机容器.addElement(new Enemy(bmpEnemyFly, 1, x, -50));                             //鸭子左                         } else if (enemyArray[当前取出一维数组的下标][i] == 2) {                             int y = random.nextInt(20);                             敌机容器.addElement(new Enemy(bmpEnemyDuck, 2, -50, y));                             //鸭子右                         } else if (enemyArray[当前取出一维数组的下标][i] == 3) {                             int y = random.nextInt(20);                             敌机容器.addElement(new Enemy(bmpEnemyDuck, 3, screenW + 50, y));                         }                     }                     //这里判断下一组是否为最后一组(Boss)                     if (当前取出一维数组的下标 == enemyArray.length - 1) {                         是否出现Boss = true;                     } else {                         当前取出一维数组的下标++;                     }                 }                 //处理敌机与主角的碰撞                 for (int i = 0; i < 敌机容器.size(); i++) {                     if (主角.isCollsionWith(敌机容器.elementAt(i))) {                         //发生碰撞，主角血量-1                         主角.setPlayerHp(主角.getPlayerHp() - 1);                         //当主角血量小于0，判定游戏失败                         if (主角.getPlayerHp() <= -1) {                             当前游戏状态 = 游戏失败;                         }                     }                 }                 //每2秒添加一个敌机子弹                 添加子弹的计数器++;                 if (添加子弹的计数器 % 40 == 0) {                     for (int i = 0; i < 敌机容器.size(); i++) {                         Enemy en = 敌机容器.elementAt(i);                         //不同类型敌机不同的子弹运行轨迹                         int bulletType = 0;                         switch (en.机的种类) {                         //苍蝇                         case Enemy.苍蝇:                             bulletType = Bullet.苍蝇的子弹;                             break;                         //鸭子                         case Enemy.鸭子:                         case Enemy.鸭子_从右往左运动:                             bulletType = Bullet.鸭子的子弹;                             break;                         }                         敌机子弹容器.add(new Bullet(bmpEnemyBullet, en.敌机坐标x + 10, en.敌机坐标y + 20, bulletType));                     }                 }                 //处理敌机子弹逻辑                 for (int i = 0; i < 敌机子弹容器.size(); i++) {                     Bullet b = 敌机子弹容器.elementAt(i);                     if (b.子弹是否超屏) {                         敌机子弹容器.removeElement(b);                     } else {                         b.logic();                     }                 }                 //处理敌机子弹与主角碰撞                 for (int i = 0; i < 敌机子弹容器.size(); i++) {                     if (主角.isCollsionWith(敌机子弹容器.elementAt(i))) {                         //发生碰撞，主角血量-1                         主角.setPlayerHp(主角.getPlayerHp() - 1);                         //当主角血量小于0，判定游戏失败                         if (主角.getPlayerHp() <= -1) {                             当前游戏状态 = 游戏失败;                         }                     }                 }                 //处理主角子弹与敌机碰撞                 for (int i = 0; i < 主角子弹容器.size(); i++) {                     //取出主角子弹容器的每个元素                     Bullet blPlayer = 主角子弹容器.elementAt(i);                     for (int j = 0; j < 敌机容器.size(); j++) {                         //添加爆炸效果                         //取出敌机容器的每个元与主角子弹遍历判断                         if (敌机容器.elementAt(j).isCollsionWith(blPlayer)) {                             爆炸效果容器.add(new Boom(bmpBoom, 敌机容器.elementAt(j).敌机坐标x, 敌机容器.elementAt(j).敌机坐标y, 7));                         }                     }                 }             } else {//Boss相关逻辑                 //每0.5秒添加一个主角子弹                 boss.logic();                 if (主角添加子弹的计数器 % 10 == 0) {                     //Boss的没发疯之前的普通子弹                     Boss的子弹容器.add(new Bullet(bmpBossBullet, boss.Boss坐标x + 35, boss.Boss坐标y + 40, Bullet.苍蝇的子弹));                 }                 //Boss子弹逻辑                 for (int i = 0; i < Boss的子弹容器.size(); i++) {                     Bullet b = Boss的子弹容器.elementAt(i);                     if (b.子弹是否超屏) {                         Boss的子弹容器.removeElement(b);                     } else {                         b.logic();                     }                 }                 //Boss子弹与主角的碰撞                 for (int i = 0; i < Boss的子弹容器.size(); i++) {                     if (主角.isCollsionWith(Boss的子弹容器.elementAt(i))) {                         //发生碰撞，主角血量-1                         主角.setPlayerHp(主角.getPlayerHp() - 1);                         //当主角血量小于0，判定游戏失败                         if (主角.getPlayerHp() <= -1) {                             当前游戏状态 = 游戏失败;                         }                     }                 }                 //Boss被主角子弹击中，产生爆炸效果                 for (int i = 0; i < 主角子弹容器.size(); i++) {                     Bullet b = 主角子弹容器.elementAt(i);                     if (boss.isCollsionWith(b)) {                         if (boss.Boss的血量 <= 0) {                             //游戏胜利                             当前游戏状态 = 游戏胜利;                         } else {                             //及时删除本次碰撞的子弹，防止重复判定此子弹与Boss碰撞、                             b.子弹是否超屏 = true;                             //Boss血量减1                             boss.setHp(boss.Boss的血量 - 1);                             //在Boss上添加三个Boss爆炸效果                             爆炸效果容器.add(new Boom(bmpBoosBoom, boss.Boss坐标x + 25, boss.Boss坐标y + 30, 5));                             爆炸效果容器.add(new Boom(bmpBoosBoom, boss.Boss坐标x + 35, boss.Boss坐标y + 40, 5));                             爆炸效果容器.add(new Boom(bmpBoosBoom, boss.Boss坐标x + 45, boss.Boss坐标y + 50, 5));                         }                     }                 }             }             //每1秒添加一个主角子弹             主角添加子弹的计数器++;             if (主角添加子弹的计数器 % 20 == 0) {                 主角子弹容器.add(new Bullet(bmpBullet, 主角.主角的坐标x + 15, 主角.主角的坐标y - 20, Bullet.主角的子弹));             }             //处理主角子弹逻辑             for (int i = 0; i < 主角子弹容器.size(); i++) {                 Bullet b = 主角子弹容器.elementAt(i);                 if (b.子弹是否超屏) {                     主角子弹容器.removeElement(b);                 } else {                     b.logic();                 }             }             //爆炸效果逻辑             for (int i = 0; i < 爆炸效果容器.size(); i++) {                 Boom boom = 爆炸效果容器.elementAt(i);                 if (boom.是否播放完毕) {                     //播放完毕的从容器中删除                     爆炸效果容器.removeElementAt(i);                 } else {                     爆炸效果容器.elementAt(i).logic();                 }             }             break;         case GAME_PAUSE:             break;         case 游戏胜利:             break;         case 游戏失败:             break;         }     }     public void run() {         while (flag) {             long start = System.currentTimeMillis();             myDraw();             logic();             long end = System.currentTimeMillis();             try {                 if (end - start < 50) {                     Thread.sleep(50 - (end - start));                 }             } catch (InterruptedException e) {                 e.printStackTrace();             }         }     }     /**     * SurfaceView视图状态发生改变，响应此函数     */     public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {     }     /**     * SurfaceView视图消亡时，响应此函数     */     public void surfaceDestroyed(SurfaceHolder holder) {         flag = false;     } } package com.pg; import android.graphics.Bitmap; import android.graphics.Canvas; import android.graphics.Paint; /** * @author Himi * */ public class Enemy {     //敌机的种类标识     public int 机的种类;     //苍蝇     public static final int 苍蝇 = 1;     //鸭子(从左往右运动)     public static final int 鸭子 = 2;     //鸭子(从右往左运动)     public static final int 鸭子_从右往左运动 = 3;     //敌机图片资源     public Bitmap 敌机图片;     //敌机坐标     public int 敌机坐标x, 敌机坐标y;     //敌机每帧的宽高     public int 敌机每帧的宽, 敌机每帧的高;     //敌机当前帧下标     private int frameIndex;     //敌机的移动速度     private int 敌机的移动速度;     //判断敌机是否已经出屏     public boolean 敌机是否已经出屏;     //敌机的构造函数     public Enemy(Bitmap bmpEnemy, int enemyType, int x, int y) {         this.敌机图片 = bmpEnemy;         敌机每帧的宽 = bmpEnemy.getWidth() / 10;         敌机每帧的高 = bmpEnemy.getHeight();         this.机的种类 = enemyType;         this.敌机坐标x = x;         this.敌机坐标y = y;         //不同种类的敌机血量不同         switch (机的种类) {         //苍蝇         case 苍蝇:             敌机的移动速度 = 25;             break;         //鸭子         case 鸭子:             敌机的移动速度 = 3;             break;         case 鸭子_从右往左运动:             敌机的移动速度 = 3;             break;         }     }     //敌机绘图函数     public void draw(Canvas canvas, Paint paint) {         canvas.save();         canvas.clipRect(敌机坐标x, 敌机坐标y, 敌机坐标x + 敌机每帧的宽, 敌机坐标y + 敌机每帧的高);         canvas.drawBitmap(敌机图片, 敌机坐标x - frameIndex * 敌机每帧的宽, 敌机坐标y, paint);         canvas.restore();     }     //敌机逻辑AI     public void logic() {         //不断循环播放帧形成动画         frameIndex++;         if (frameIndex >= 10) {             frameIndex = 0;         }         //不同种类的敌机拥有不同的AI逻辑         switch (机的种类) {         case 苍蝇:             if (敌机是否已经出屏 == false) {                 //减速出现，加速返回                 敌机的移动速度 -= 1;                 敌机坐标y += 敌机的移动速度;                 if (敌机坐标y <= -200) {                     敌机是否已经出屏 = true;                 }             }             break;         case 鸭子:             if (敌机是否已经出屏 == false) {                 //斜右下角运动                 敌机坐标x += 敌机的移动速度 / 2;                 敌机坐标y += 敌机的移动速度;                 if (敌机坐标x > MySurfaceView.screenW) {                     敌机是否已经出屏 = true;                 }             }             break;         case 鸭子_从右往左运动:             if (敌机是否已经出屏 == false) {                 //斜左下角运动                 敌机坐标x -= 敌机的移动速度 / 2;                 敌机坐标y += 敌机的移动速度;                 if (敌机坐标x < -50) {                     敌机是否已经出屏 = true;                 }             }             break;         }     }     //判断碰撞(敌机与主角子弹碰撞)     public boolean isCollsionWith(Bullet bullet) {         int x2 = bullet.子弹X;         int y2 = bullet.子弹Y;         int w2 = bullet.子弹图片.getWidth();         int h2 = bullet.子弹图片.getHeight();         if (敌机坐标x >= x2 && 敌机坐标x >= x2 + w2) {             return false;         } else if (敌机坐标x <= x2 && 敌机坐标x + 敌机每帧的宽 <= x2) {             return false;         } else if (敌机坐标y >= y2 && 敌机坐标y >= y2 + h2) {             return false;         } else if (敌机坐标y <= y2 && 敌机坐标y + 敌机每帧的高 <= y2) {             return false;         }         //发生碰撞，让其死亡         敌机是否已经出屏 = true;         return true;     } } package com.pg; import android.graphics.Bitmap; import android.graphics.Canvas; import android.graphics.Paint; import android.view.MotionEvent; /** * @author Himi * */ public class GameMenu {     //菜单背景图     private Bitmap 菜单背景图;     //按钮图片资源(按下和未按下图)     private Bitmap 按下图, 未按下图;     //按钮的坐标     private int 按钮的坐标X, 按钮的坐标Y;     //按钮是否按下标识位     private Boolean 按钮是否按下;     //菜单初始化     public GameMenu(Bitmap bmpMenu, Bitmap bmpButton, Bitmap bmpButtonPress) {         this.菜单背景图 = bmpMenu;         this.按下图 = bmpButton;         this.未按下图 = bmpButtonPress;         //X居中，Y紧接屏幕底部         按钮的坐标X = MySurfaceView.screenW / 2 - bmpButton.getWidth() / 2;         按钮的坐标Y = MySurfaceView.screenH - bmpButton.getHeight();         按钮是否按下 = false;     }     //菜单绘图函数     public void draw(Canvas canvas, Paint paint) {         //绘制菜单背景图         canvas.drawBitmap(菜单背景图, 0, 0, paint);         //绘制未按下按钮图         if (按钮是否按下) {//根据是否按下绘制不同状态的按钮图             canvas.drawBitmap(未按下图, 按钮的坐标X, 按钮的坐标Y, paint);         } else {             canvas.drawBitmap(按下图, 按钮的坐标X, 按钮的坐标Y, paint);         }     }     //菜单触屏事件函数，主要用于处理按钮事件     public void onTouchEvent(MotionEvent event) {         //获取用户当前触屏位置         int pointX = (int) event.getX();         int pointY = (int) event.getY();         //当用户是按下动作或移动动作         if (event.getAction() == MotionEvent.ACTION_DOWN || event.getAction() == MotionEvent.ACTION_MOVE) {             //判定用户是否点击了按钮             if (pointX > 按钮的坐标X && pointX < 按钮的坐标X + 按下图.getWidth()) {                 if (pointY > 按钮的坐标Y && pointY < 按钮的坐标Y + 按下图.getHeight()) {                     按钮是否按下 = true;                 } else {                     按钮是否按下 = false;                 }             } else {                 按钮是否按下 = false;             }             //当用户是抬起动作         } else if (event.getAction() == MotionEvent.ACTION_UP) {             //抬起判断是否点击按钮，防止用户移动到别处             if (pointX > 按钮的坐标X && pointX < 按钮的坐标X + 按下图.getWidth()) {                 if (pointY > 按钮的坐标Y && pointY < 按钮的坐标Y + 按下图.getHeight()) {                     //还原Button状态为未按下状态                     按钮是否按下 = false;                     //改变当前游戏状态为开始游戏                     MySurfaceView.当前游戏状态 = MySurfaceView.游戏中;                 }             }         }     } }