Android开发飞行射击类游戏-Android-IT72.COM

Android开发飞行射击类游戏

Home / Android MrLee 2015-5-14 2949

1.地图滚动的原理实现
举个简单的例子吧，同学们都坐过火车吧，坐火车的时候都遇到过自己的火车明明是停止的但是旁边铁轨的火车在向后行驶，会有一种错觉感觉自己的火车是在向前行驶吧，呵呵。飞行射击类游戏的地图原理和这个完全一样。玩家在控制飞机在屏幕中飞行的位置，背景图片一直向后滚动从而给玩家一种错觉自己控制的飞机在向前飞行，如下图所示两张地图图片在屏幕背后交替滚动，这样就会给玩家产生向前移动的错觉。
2.触摸屏幕控制主角飞机的移动范围
用手触摸屏幕中的任意一个点，程序可以得到当前点的X ， Y坐标。以当前飞机的X Y坐标为中心计算出当前飞机X,Y坐标点与目标X,Y点的距离。因为飞机不可能直接就飞到目标点所以分别依次对当前坐标X,Y相加一次飞机移动的步长。这里我们须要考虑飞机移动过程中玩家停止触摸屏幕，如果停止触摸飞机将原地停住不在向目标点移动，直到新的目标点出线即玩家新触摸屏幕的X,Y坐标。
3、主角飞机子弹的实现原理与敌机的碰撞
因为子弹的数量会有很多，敌机的数量也会很多，所以每一颗子弹须要用一个对象来记录这当前子弹的X，Y坐标与在屏幕中的绘制区域，每一架敌机也是一个对象，也记录着它的X,Y坐标与在屏幕中的绘制区域，这样在处理碰撞的时候其实就是每一颗子弹的矩形区域与每一架敌机的矩形区域的碰撞。通过遍历子弹对象与敌机对象就可以计算出碰撞的结果，从而拿到碰撞的敌机对象播放死亡爆炸动画。
说到这里有些同学可能会想如果按照这样的思路将会频繁的创建子弹对象与敌机对象这样会造成内存泄漏等严重的问题。仔细想一下屏幕中须要绘制的子弹数量与敌机数量肯定是有限的，我们可以初始化固定的子弹对象与敌机对象只对这些对象进行更新逻辑与绘制，举个例子当前游戏屏幕中我最多须要5架敌机，代码中我就只分配5个敌机对象，分别检测这些对象如果被子弹打中或者向下超过屏幕底边，这时候可以对这个对象进行属性的重置，让这架飞机从新出现在上方的战场上，这样就实现在不增加飞机对象的情况下让玩家感觉有打不完的飞机，子弹对象同理。
简单敌机类实现敌人有两个状态一个是生存状态一个是死亡状态代码中根据当前状态播放动画。

package cn.m15.xys;
import java.io.InputStream;
import java.util.Random;
import android.app.Activity;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.RectF;
import android.os.Bundle;
import android.view.Display;
import android.view.MotionEvent;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.view.Window;
import android.view.WindowManager;
import android.view.SurfaceHolder.Callback;
public class SurfaceViewAcitvity extends Activity {
	AnimView mAnimView = null;
	@Override
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		// 全屏显示窗口
		requestWindowFeature(Window.FEATURE_NO_TITLE);
		getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
				WindowManager.LayoutParams.FLAG_FULLSCREEN);
		// 获取屏幕宽高
		Display display = getWindowManager().getDefaultDisplay();
		// 显示自定义的游戏View
		mAnimView = new AnimView(this, display.getWidth(), display.getHeight());
		setContentView(mAnimView);
	}
	public boolean onTouchEvent(MotionEvent event) {
		// 获得触摸的坐标
		int x = (int) event.getX();
		int y = (int) event.getY();
		switch (event.getAction()) {
		// 触摸屏幕时刻
		case MotionEvent.ACTION_DOWN:
			mAnimView.UpdateTouchEvent(x, y, true);
			break;
		// 触摸并移动时刻
		case MotionEvent.ACTION_MOVE:
			break;
		// 终止触摸时刻
		case MotionEvent.ACTION_UP:
			mAnimView.UpdateTouchEvent(x, y, false);
			break;
		}
		return false;
	}
	public class AnimView extends SurfaceView implements Callback, Runnable {
		/** 屏幕的宽高 **/
		private int mScreenWidth = 0;
		private int mScreenHeight = 0;
		/** 游戏主菜单状态 **/
		private static final int STATE_GAME = 0;
		/** 游戏状态 **/
		private int mState = STATE_GAME;
		Paint mPaint = null;
		/** 记录两张背景图片时时更新的Y坐标 **/
		private int mBitposY0 = 0;
		private int mBitposY1 = 0;
		/** 飞机动画帧数 **/
		final static int PLAN_ANIM_COUNT = 6;
		/** 子弹动画帧数 **/
		final static int BULLET_ANIM_COUNT = 4;
		/** 子弹对象的数量 **/
		final static int BULLET_POOL_COUNT = 15;
		/** 飞机移动步长 **/
		final static int PLAN_STEP = 10;
		/** 没过500毫秒发射一颗子弹 **/
		final static int PLAN_TIME = 50;
		/** 子弹图片向上偏移量处理触屏 **/
		final static int BULLET_UP_OFFSET = 40;
		/** 子弹图片向左偏移量处理触屏 **/
		final static int BULLET_LEFT_OFFSET = 5;
		/** 敌人对象的数量 **/
		final static int ENEMY_POOL_COUNT = 5;
		/** 敌人行走动画帧数 **/
		final static int ENEMY_ALIVE_COUNT = 1;
		/** 敌人行死亡画帧数 **/
		final static int ENEMY_DEATH_COUNT = 6;
		/** 敌人飞机偏移量 **/
		final static int ENEMY_POS_OFF = 65;
		/** 游戏主线程 **/
		private Thread mThread = null;
		/** 线程循环标志 **/
		private boolean mIsRunning = false;
		private SurfaceHolder mSurfaceHolder = null;
		private Canvas mCanvas = null;
		private Context mContext = null;
		/** 飞机动画 **/
		public Animation mAircraft = null;
		/** 飞机在屏幕中的坐标 **/
		public int mAirPosX = 0;
		public int mAirPosY = 0;
		/** 敌人类 **/
		Enemy mEnemy[] = null;
		/** 子弹类 **/
		Bullet mBuilet[] = null;
		Bitmap mBitbullet[] = null;
		/** 初始化发射子弹ID升序 **/
		public int mSendId = 0;
		/** 上一颗子弹发射的时间 **/
		public Long mSendTime = 0L;
		/** 手指在屏幕触摸的坐标 **/
		public int mTouchPosX = 0;
		public int mTouchPosY = 0;
		/** 标志手指在屏幕触摸中 **/
		public boolean mTouching = false;
		/**
		 * 构造方法
		 * 
		 * @param context
		 */
		public AnimView(Context context, int screenWidth, int screenHeight) {
			super(context);
			mContext = context;
			mPaint = new Paint();
			mScreenWidth = screenWidth;
			mScreenHeight = screenHeight;
			/** 获取mSurfaceHolder **/
			mSurfaceHolder = getHolder();
			mSurfaceHolder.addCallback(this);
			setFocusable(true);
			init();
			setGameState(STATE_GAME);
		}
		protected void Draw() {
			switch (mState) {
			case STATE_GAME:
				renderBg();
				updateBg();
				break;
			}
		}
		private void init() {
			/** 游戏背景 **/
			/** 创建主角飞机动画对象 **/
			mAircraft = new Animation(mContext, new int[] { R.drawable.plan_0,
					R.drawable.plan_1, R.drawable.plan_2, R.drawable.plan_3,
					R.drawable.plan_4, R.drawable.plan_5 }, true);
			/** 第一张图片津贴在屏幕00点，第二张图片在第一张图片上方 **/
			mBitposY0 = 0;
			mBitposY1 = -mScreenHeight;
			/** 初始化飞机的坐标 **/
			mAirPosX = 150;
			mAirPosY = 400;
			/** 这里敌人行走动画就1帧 **/
			Bitmap[] bitmap0 = new Bitmap[ENEMY_ALIVE_COUNT];
			bitmap0[0] = ReadBitMap(mContext, R.drawable.e1_0);
			/** 敌人死亡动画 **/
			Bitmap[] bitmap1 = new Bitmap[ENEMY_DEATH_COUNT];
			for (int i = 0; i < ENEMY_DEATH_COUNT; i++) {
				bitmap1[i] = ReadBitMap(mContext, R.drawable.bomb_enemy_0 + i);
			}
			/** 创建敌人对象 **/
			mEnemy = new Enemy[ENEMY_POOL_COUNT];
			for (int i = 0; i < ENEMY_POOL_COUNT; i++) {
				mEnemy[i] = new Enemy(mContext, bitmap0, bitmap1);
				mEnemy[i].init(i * ENEMY_POS_OFF, 0);
			}
			/** 创建子弹类对象 **/
			mBuilet = new Bullet[BULLET_POOL_COUNT];
			mBitbullet = new Bitmap[BULLET_ANIM_COUNT];
			for (int i = 0; i < BULLET_ANIM_COUNT; i++) {
				mBitbullet[i] = ReadBitMap(mContext, i + R.drawable.bullet_0);
			}
			for (int i = 0; i < BULLET_POOL_COUNT; i++) {
				mBuilet[i] = new Bullet(mContext, mBitbullet);
			}
			mSendTime = System.currentTimeMillis();
		}
		private void setGameState(int newState) {
			mState = newState;
		}
		public void renderBg() {
			mCanvas.drawRect(0, 0, mScreenWidth, mScreenHeight, mPaint);
			/** 绘制飞机动画 **/
			mAircraft.DrawAnimation(mCanvas, mPaint, mAirPosX, mAirPosY);
			/** 绘制子弹动画 */
			for (int i = 0; i < BULLET_POOL_COUNT; i++) {
				mBuilet[i].DrawBullet(mCanvas, mPaint);
			}
			/** 绘制敌人动画 **/
			for (int i = 0; i < ENEMY_POOL_COUNT; i++) {
				mEnemy[i].DrawEnemy(mCanvas, mPaint);
			}
		}
		private void updateBg() {
			/** 更新游戏背景图片实现向下滚动效果 **/
			mBitposY0 += 10;
			mBitposY1 += 10;
			if (mBitposY0 == mScreenHeight) {
				mBitposY0 = -mScreenHeight;
			}
			if (mBitposY1 == mScreenHeight) {
				mBitposY1 = -mScreenHeight;
			}
			/** 手指触摸屏幕更新飞机坐标 **/
			if (mTouching) {
				if (mAirPosX < mTouchPosX) {
					mAirPosX += PLAN_STEP;
				} else {
					mAirPosX -= PLAN_STEP;
				}
				if (mAirPosY < mTouchPosY) {
					mAirPosY += PLAN_STEP;
				} else {
					mAirPosY -= PLAN_STEP;
				}
				if (Math.abs(mAirPosX - mTouchPosX) <= PLAN_STEP) {
					mAirPosX = mTouchPosX;
				}
				if (Math.abs(mAirPosY - mTouchPosY) <= PLAN_STEP) {
					mAirPosY = mTouchPosY;
				}
			}
			/** 更新子弹动画 **/
			for (int i = 0; i < BULLET_POOL_COUNT; i++) {
				/** 子弹出屏后重新赋值 **/
				mBuilet[i].UpdateBullet();
			}
			/** 绘制敌人动画 **/
			for (int i = 0; i < ENEMY_POOL_COUNT; i++) {
				mEnemy[i].UpdateEnemy();
				/** 敌机死亡 或者 敌机超过屏幕还未死亡重置坐标 **/
				if (mEnemy[i].mState == Enemy.ENEMY_DEATH_STATE
						|| mEnemy[i].m_posY >= mScreenHeight) {
					mEnemy[i].init(UtilRandom(0, ENEMY_POOL_COUNT)
							* ENEMY_POS_OFF, 0);
				}
			}
			/** 根据时间初始化为发射的子弹 **/
			if (mSendId < BULLET_POOL_COUNT) {
				long now = System.currentTimeMillis();
				if (now - mSendTime >= PLAN_TIME) {
					mBuilet[mSendId].init(mAirPosX - BULLET_LEFT_OFFSET,
							mAirPosY - BULLET_UP_OFFSET);
					mSendTime = now;
					mSendId++;
				}
			} else {
				mSendId = 0;
			}
			// 更新子弹与敌人的碰撞
			Collision();
		}
		public void Collision() {
			// 更新子弹与敌人碰撞
			for (int i = 0; i < BULLET_POOL_COUNT; i++) {
				for (int j = 0; j < ENEMY_POOL_COUNT; j++) {
					if (mBuilet[i].m_posX >= mEnemy[j].m_posX
							&& mBuilet[i].m_posX <= mEnemy[j].m_posX + 20
							&& mBuilet[i].m_posY >= mEnemy[j].m_posY
							&& mBuilet[i].m_posY <= mEnemy[j].m_posY + 20
					) {
						mEnemy[j].mAnimState = Enemy.ENEMY_DEATH_STATE;
					}
				}
			}
		}
		public void UpdateTouchEvent(int x, int y, boolean touching) {
			// 在这里检测按钮按下播放不同的特效
			switch (mState) {
			case STATE_GAME:
				mTouching = touching;
				mTouchPosX = x;
				mTouchPosY = y;
				break;
			}
		}
		/**
		 * 返回一个随机数
		 * 
		 * @param botton
		 * @param top
		 * @return
		 */
		private int UtilRandom(int botton, int top) {
			return ((Math.abs(new Random().nextInt()) % (top - botton)) + botton);
		}
		/**
		 * 读取本地资源的图片
		 * 
		 * @param context
		 * @param resId
		 * @return
		 */
		public Bitmap ReadBitMap(Context context, int resId) {
			BitmapFactory.Options opt = new BitmapFactory.Options();
			opt.inPreferredConfig = Bitmap.Config.RGB_565;
			opt.inPurgeable = true;
			opt.inInputShareable = true;
			// 获取资源图片
			InputStream is = context.getResources().openRawResource(resId);
			return BitmapFactory.decodeStream(is, null, opt);
		}
		/**
		 * 绘制画带阴影的文字
		 * 
		 * @param canvas
		 * @param str
		 * @param color
		 * @param x
		 * @param y
		 */
		public final void drawRimString(Canvas canvas, String str, int color,
				int x, int y) {
			int backColor = mPaint.getColor();
			mPaint.setColor(~color);
			canvas.drawText(str, x + 1, y, mPaint);
			canvas.drawText(str, x, y + 1, mPaint);
			canvas.drawText(str, x - 1, y, mPaint);
			canvas.drawText(str, x, y - 1, mPaint);
			mPaint.setColor(color);
			canvas.drawText(str, x, y, mPaint);
			mPaint.setColor(backColor);
		}
		/**
		 * 绘制一个矩形
		 * 
		 * @param canvas
		 * @param color
		 * @param x
		 * @param y
		 * @param w
		 * @param h
		 */
		public void drawFillRect(Canvas canvas, int color, int x, int y, int w,
				int h) {
			int backColor = mPaint.getColor();
			mPaint.setColor(color);
			canvas.drawRect(x, y, x + w, y + h, mPaint);
			mPaint.setColor(backColor);
		}
		/**
		 * 绘制一个扇形
		 * 
		 * @param canvas
		 * @param color
		 * @param oval
		 * @param startAngle
		 * @param sweepAngle
		 * @param useCenter
		 */
		public void drawFillCircle(Canvas canvas, int color, RectF oval,
				int startAngle, int sweepAngle, boolean useCenter) {
			int backColor = mPaint.getColor();
			mPaint.setColor(color);
			canvas.drawArc(oval, startAngle, sweepAngle, useCenter, mPaint);
			mPaint.setColor(backColor);
		}
		/**
		 * 程序切割图片
		 * 
		 * @param bitmap
		 * @param x
		 * @param y
		 * @param w
		 * @param h
		 * @return
		 */
		public Bitmap BitmapClipBitmap(Bitmap bitmap, int x, int y, int w, int h) {
			return Bitmap.createBitmap(bitmap, x, y, w, h);
		}
		@Override
		public void run() {
			try {
				while (mIsRunning) {
					// 在这里加上线程安全锁
					synchronized (mSurfaceHolder) {
						/** 拿到当前画布 然后锁定 **/
						mCanvas = mSurfaceHolder.lockCanvas();
						Draw();
						/** 绘制结束后解锁显示在屏幕上 **/
						mSurfaceHolder.unlockCanvasAndPost(mCanvas);
					}
					Thread.sleep(10);
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		@Override
		public void surfaceChanged(SurfaceHolder arg0, int arg1, int arg2,
				int arg3) {
			// surfaceView的大小发生改变的时候
		}
		@Override
		public void surfaceCreated(SurfaceHolder arg0) {
			/** 启动游戏主线程 **/
			mIsRunning = true;
			mThread = new Thread(this);
			mThread.start();
		}
		@Override
		public void surfaceDestroyed(SurfaceHolder arg0) {
			// surfaceView销毁的时候
			mIsRunning = false;
		}
	}
}

下载地址:plane

本文链接:https://www.it72.com/2890.htm