我和姨母,雷神宫殿钥匙有什么用,免费送qq
android实战打飞机游戏子弹生成，新建子弹类
我要评论
public class bullet {
// 子弹图片资源
public bitmap bmpbullet;
// 子弹的坐标
public int bulletx, bullety;
// 子弹的速度
public int speed;
// 子弹的种类以及常量
public int bullettype;
// 主角的
public static final int bullet_player = -1;
// 鸭子的
public static final int bullet_duck = 1;
// 苍蝇的
public static final int bullet_fly = 2;
// boss的
public static final int bullet_boss = 3;
// 子弹是否超屏， 优化处理
public boolean isdead;
// boss疯狂状态下子弹相关成员变量
private int dir;// 当前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 = bmpbullet;
this.bulletx = bulletx;
this.bullety = bullety;
this.bullettype = bullettype;
// 不同的子弹类型速度不一
switch (bullettype) {
case bullet_player:
speed = 4;
break;
case bullet_duck:
speed = 3;
break;
case bullet_fly:
speed = 4;
break;
case bullet_boss:
speed = 5;
break;
}
}
public void draw(canvas canvas, paint paint) {
canvas.drawbitmap(bmpbullet, bulletx, bullety, paint);
}
// 子弹的逻辑
public void logic() {
// 不同的子弹类型逻辑不一
// 主角的子弹垂直向上运动
switch (bullettype) {
case bullet_player:
bullety -= speed;
if (bullety < -50) {
isdead = true;
}
break;
// 鸭子和苍蝇的子弹都是垂直下落运动
case bullet_duck:
case bullet_fly:
bullety += speed;
if (bullety > mysurfaceview.screenh) {
isdead = true;
}
break;
case bullet_boss:
// boss疯狂状态下的子弹逻辑待实现
// 边界处理
if (bullety > mysurfaceview.screenh || bullety <= -40
|| bulletx > mysurfaceview.screenw || bulletx <= -40) {
isdead = true;
}
break;
}
}
}
在在mysurfacview里面调用 生成子弹主角的和自己的
package com.gsf;
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.surfaceholder.callback;
import android.view.surfaceview;
public class mysurfaceview extends surfaceview implements callback, runnable {
private surfaceholder sfh;
private paint paint;
private thread th;
private boolean flag;
private canvas canvas;
// 1 定义游戏状态常量
public static final int game_menu = 0;// 游戏菜单
public static final int gameing = 1;// 游戏中
public static final int game_win = 2;// 游戏胜利
public static final int game_lost = 3;// 游戏失败
public static final int game_pause = -1;// 游戏菜单
// 当前游戏状态(默认初始在游戏菜单界面)
public static int gamestate = game_menu;
// 声明一个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子弹
public static int screenw;
public static int screenh;
// 声明一个敌机容器
private vector<enemy> vcenemy;
// 每次生成敌机的时间(毫秒)
private int createenemytime = 50;
private int count;// 计数器
// 敌人数组：1和2表示敌机的种类，-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 enemyarrayindex;
// 是否出现boss标识位
private boolean isboss;
// 随机库，为创建的敌机赋予随即坐标
private random random;
//
private gamemenu gamemenu;
private gamebg gamebg;
private player player;
// 敌机子弹容器
private vector<bullet> vcbullet;
// 添加子弹的计数器
private int countenemybullet;
// 主角子弹容器
private vector<bullet> vcbulletplayer;
// 添加子弹的计数器
private int countplayerbullet;
/**
* 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);
}
/**
* surfaceview视图创建，响应此函数
*/
@override
public void surfacecreated(surfaceholder holder) {
screenw = this.getwidth();
screenh = this.getheight();
initgame();
flag = true;
// 实例线程
th = new thread(this);
// 启动线程
th.start();
}
/**
* 加载游戏资源
*/
private void initgame() {
// 加载游戏资源
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);
// 菜单类实例化
gamemenu = new gamemenu(bmpmenu, bmpbutton, bmpbuttonpress);
// 实例游戏背景
gamebg = new gamebg(bmpbackground);
// 实例主角
player = new player(bmpplayer, bmpplayerhp);
//敌机子弹容器实例
vcbullet = new vector<bullet>();
//主角子弹容器实例
vcbulletplayer = new vector<bullet>();
// 实例敌机容器
vcenemy = new vector<enemy>();
// 实例随机库
random = new random();
}
/**
* 游戏绘图
*/
public void mydraw() {
try {
canvas = sfh.lockcanvas();
if (canvas != null) {
canvas.drawcolor(color.white);
// 绘图函数根据游戏状态不同进行不同绘制
switch (gamestate) {
case game_menu:
gamemenu.draw(canvas, paint);
break;
case gameing:
gamebg.draw(canvas, paint);
player.draw(canvas, paint);
if (isboss == false) {
// 敌机绘制
for (int i = 0; i < vcenemy.size(); i++) {
vcenemy.elementat(i).draw(canvas, paint);
}
//敌机子弹绘制
for (int i = 0; i < vcbullet.size(); i++) {
vcbullet.elementat(i).draw(canvas, paint);
}
} else {
// boss 绘制
}
// 处理主角子弹绘制
for (int i = 0; i < vcbulletplayer.size(); i++) {
vcbulletplayer.elementat(i).draw(canvas, paint);
}
break;
case game_win:
break;
case game_lost:
break;
case game_pause:
break;
default:
break;
}
}
} catch (exception e) {
// todo: handle exception
} finally {
if (canvas != null)
sfh.unlockcanvasandpost(canvas);
}
}
/**
* 触屏事件监听
*/
@override
public boolean ontouchevent(motionevent event) {
switch (gamestate) {
case game_menu:
gamemenu.ontouchevent(event);
break;
case gameing:
break;
case game_win:
break;
case game_lost:
break;
case game_pause:
break;
}
return true;
}
/**
* 按键事件监听
*/
@override
public boolean onkeydown(int keycode, keyevent event) {
switch (gamestate) {
case game_menu:
break;
case gameing:
player.onkeydown(keycode, event);
break;
case game_win:
break;
case game_lost:
break;
case game_pause:
break;
}
return super.onkeydown(keycode, event);
}
@override
public boolean onkeyup(int keycode, keyevent event) {
switch (gamestate) {
case game_menu:
break;
case gameing:
player.onkeyup(keycode, event);
break;
case game_win:
break;
case game_lost:
break;
case game_pause:
break;
}
return super.onkeyup(keycode, event);
}
/**
* 游戏逻辑
*/
private void logic() {
switch (gamestate) {
case game_menu:
break;
case gameing:
gamebg.logic();
player.logic();
// 敌机逻辑
if (isboss == false) {
// 敌机逻辑
for (int i = 0; i < vcenemy.size(); i++) {
enemy en = vcenemy.elementat(i);
// 因为容器不断添加敌机 ，那么对敌机isdead判定，
// 如果已死亡那么就从容器中删除,对容器起到了优化作用；
if (en.isdead) {
vcenemy.removeelementat(i);
} else {
en.logic();
}
}
// 生成敌机
count++;
if (count % createenemytime == 0) {
for (int i = 0; i < enemyarray[enemyarrayindex].length; i++) {
// 苍蝇
if (enemyarray[enemyarrayindex][i] == 1) {
int x = random.nextint(screenw - 100) + 50;
vcenemy.addelement(new enemy(bmpenemyfly, 1, x, -50));
// 鸭子左
} else if (enemyarray[enemyarrayindex][i] == 2) {
int y = random.nextint(20);
vcenemy.addelement(new enemy(bmpenemyduck, 2, -50,
y));
// 鸭子右
} else if (enemyarray[enemyarrayindex][i] == 3) {
int y = random.nextint(20);
vcenemy.addelement(new enemy(bmpenemyduck, 3,
screenw + 50, y));
}
}
// 这里判断下一组是否为最后一组(boss)
if (enemyarrayindex == enemyarray.length - 1) {
isboss = true;
} else {
enemyarrayindex++;
}
}
// 每2秒添加一个敌机子弹
countenemybullet++;
if (countenemybullet % 40 == 0) {
for (int i = 0; i < vcenemy.size(); i++) {
enemy en = vcenemy.elementat(i);
// 不同类型敌机不同的子弹运行轨迹
int bullettype = 0;
switch (en.type) {
// 苍蝇
case enemy.type_fly:
bullettype = bullet.bullet_fly;
break;
// 鸭子
case enemy.type_duckl:
case enemy.type_duckr:
bullettype = bullet.bullet_duck;
break;
}
vcbullet.add(new bullet(bmpenemybullet, en.x + 10,
en.y + 20, bullettype));
}
}
// 处理敌机子弹逻辑
for (int i = 0; i < vcbullet.size(); i++) {
bullet b = vcbullet.elementat(i);
if (b.isdead) {
vcbullet.removeelement(b);
} else {
b.logic();
}
}
//每1秒添加一个主角子弹
countplayerbullet++;
if (countplayerbullet % 20 == 0) {
vcbulletplayer.add(new bullet(bmpbullet, player.x + 15, player.y - 20, bullet.bullet_player));
}
// 处理敌机与主角的碰撞
for (int i = 0; i < vcenemy.size(); i++) {
if (player.iscollsionwith(vcenemy.elementat(i))) {
// 发生碰撞，主角血量-1
player.setplayerhp(player.getplayerhp() - 1);
// 当主角血量小于0，判定游戏失败
if (player.getplayerhp() <= -1) {
gamestate = game_lost;
}
}
}
//处理主角子弹逻辑
for (int i = 0; i < vcbulletplayer.size(); i++) {
bullet b = vcbulletplayer.elementat(i);
if (b.isdead) {
vcbulletplayer.removeelement(b);
} else {
b.logic();
}
}
}
break;
case game_win:
break;
case game_lost:
break;
case game_pause:
break;
}
}
@override
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视图状态发生改变，响应此函数
*/
@override
public void surfacechanged(surfaceholder holder, int format, int width,
int height) {
}
/**
* surfaceview视图消亡时，响应此函数
*/
@override
public void surfacedestroyed(surfaceholder holder) {
flag = false;
}
}
现在子弹碰撞主角 并没有发生事情 需要子弹和主角的碰撞检测
//修改player类 添加碰撞检测
// // 判断碰撞(主角与敌机子弹)
public boolean iscollsionwith(bullet bullet) {
// 是否处于无敌时间
if (iscollision == false) {
int x2 = bullet.bulletx;
int y2 = bullet.bullety;
int w2 = bullet.bmpbullet.getwidth();
int h2 = bullet.bmpbullet.getheight();
if (x >= x2 && x >= x2 + w2) {
return false;
} else if (x <= x2 && x + bmpplayer.getwidth() <= x2) {
return false;
} else if (y >= y2 && y >= y2 + h2) {
return false;
} else if (y <= y2 && y + bmpplayer.getheight() <= y2) {
return false;
}
// 碰撞即进入无敌状态
iscollision = true;
return true;
// 处于无敌状态，无视碰撞
} else {
return false;
}
}
在主界面 mysrufaceview 的逻辑函数中添加 主角和敌机子弹的碰撞
//处理敌机子弹与主角碰撞
for (int i = 0; i < vcbullet.size(); i++) {
if (player.iscollsionwith(vcbullet.elementat(i))) {
//发生碰撞，主角血量-1
player.setplayerhp(player.getplayerhp() - 1);
//当主角血量小于0，判定游戏失败
if (player.getplayerhp() <= -1) {
gamestate = game_lost;
}
}
}
当然 主角的子弹碰撞了敌机 也需要进行碰撞检测 修改 敌机类 enemy
//判断碰撞(敌机与主角子弹碰撞)
public boolean iscollsionwith(bullet bullet) {
int x2 = bullet.bulletx;
int y2 = bullet.bullety;
int w2 = bullet.bmpbullet.getwidth();
int h2 = bullet.bmpbullet.getheight();
if (x >= x2 && x >= x2 + w2) {
return false;
} else if (x <= x2 && x + framew <= x2) {
return false;
} else if (y >= y2 && y >= y2 + h2) {
return false;
} else if (y <= y2 && y + frameh <= y2) {
return false;
}
//发生碰撞，让其死亡
isdead = true;
return true;
}
在主视图中添加逻辑 主角子弹和敌机碰撞的逻辑
//处理主角子弹与敌机碰撞
for (int i = 0; i < vcbulletplayer.size(); i++) {
//取出主角子弹容器的每个元素
bullet blplayer = vcbulletplayer.elementat(i);
for (int j = 0; j < vcenemy.size(); j++) {
//添加爆炸效果 待完成
}
}
上面完成 的效果图
下面完成爆炸的效果
新建一个爆炸类 boom
/**
* 瞬间爆炸 类
* @author liuml
* @time 2016-6-1 上午11:32:56
*/
public class boom {
//爆炸效果资源图
private bitmap bmpboom;
//爆炸效果的位置坐标
private int boomx, boomy;
//爆炸动画播放当前的帧下标
private int cureentframeindex;
//爆炸效果的总帧数
private int totleframe;
//每帧的宽高
private int framew, frameh;
//是否播放完毕，优化处理
public boolean playend;
//爆炸效果的构造函数
public boom(bitmap bmpboom, int x, int y, int totleframe) {
this.bmpboom = bmpboom;
this.boomx = x;
this.boomy = y;
this.totleframe = totleframe;
framew = bmpboom.getwidth() / totleframe;
frameh = bmpboom.getheight();
}
//爆炸效果绘制
public void draw(canvas canvas, paint paint) {
canvas.save();
canvas.cliprect(boomx, boomy, boomx + framew, boomy + frameh);
canvas.drawbitmap(bmpboom, boomx - cureentframeindex * framew, boomy, paint);
canvas.restore();
}
//爆炸效果的逻辑
public void logic() {
if (cureentframeindex < totleframe) {
cureentframeindex++;
} else {
playend = true;
}
}
}
下面就还是老套路了 在主界面 声明爆炸容器 然后绘制 然后是逻辑实现
package com.gsf;
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.surfaceholder.callback;
import android.view.surfaceview;
public class mysurfaceview extends surfaceview implements callback, runnable {
private surfaceholder sfh;
private paint paint;
private thread th;
private boolean flag;
private canvas canvas;
// 1 定义游戏状态常量
public static final int game_menu = 0;// 游戏菜单
public static final int gameing = 1;// 游戏中
public static final int game_win = 2;// 游戏胜利
public static final int game_lost = 3;// 游戏失败
public static final int game_pause = -1;// 游戏菜单
// 当前游戏状态(默认初始在游戏菜单界面)
public static int gamestate = game_menu;
// 声明一个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子弹
public static int screenw;
public static int screenh;
// 声明一个敌机容器
private vector<enemy> vcenemy;
// 每次生成敌机的时间(毫秒)
private int createenemytime = 50;
private int count;// 计数器
// 敌人数组：1和2表示敌机的种类，-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 enemyarrayindex;
// 是否出现boss标识位
private boolean isboss;
// 随机库，为创建的敌机赋予随即坐标
private random random;
//
private gamemenu gamemenu;
private gamebg gamebg;
private player player;
// 敌机子弹容器
private vector<bullet> vcbullet;
// 添加子弹的计数器
private int countenemybullet;
// 主角子弹容器
private vector<bullet> vcbulletplayer;
// 添加子弹的计数器
private int countplayerbullet;
//爆炸效果容器
private vector<boom> vcboom;
/**
* 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);
}
/**
* surfaceview视图创建，响应此函数
*/
@override
public void surfacecreated(surfaceholder holder) {
screenw = this.getwidth();
screenh = this.getheight();
initgame();
flag = true;
// 实例线程
th = new thread(this);
// 启动线程
th.start();
}
/**
* 加载游戏资源
*/
private void initgame() {
// 加载游戏资源
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);
// 菜单类实例化
gamemenu = new gamemenu(bmpmenu, bmpbutton, bmpbuttonpress);
// 实例游戏背景
gamebg = new gamebg(bmpbackground);
// 实例主角
player = new player(bmpplayer, bmpplayerhp);
//敌机子弹容器实例
vcbullet = new vector<bullet>();
//主角子弹容器实例
vcbulletplayer = new vector<bullet>();
// 实例敌机容器
vcenemy = new vector<enemy>();
// 实例随机库
random = new random();
//爆炸效果容器实例
vcboom = new vector<boom>();
}
/**
* 游戏绘图
*/
public void mydraw() {
try {
canvas = sfh.lockcanvas();
if (canvas != null) {
canvas.drawcolor(color.white);
// 绘图函数根据游戏状态不同进行不同绘制
switch (gamestate) {
case game_menu:
gamemenu.draw(canvas, paint);
break;
case gameing:
gamebg.draw(canvas, paint);
player.draw(canvas, paint);
if (isboss == false) {
// 敌机绘制
for (int i = 0; i < vcenemy.size(); i++) {
vcenemy.elementat(i).draw(canvas, paint);
}
//敌机子弹绘制
for (int i = 0; i < vcbullet.size(); i++) {
vcbullet.elementat(i).draw(canvas, paint);
}
//爆炸效果绘制
for (int i = 0; i < vcboom.size(); i++) {
vcboom.elementat(i).draw(canvas, paint);
}
} else {
// boss 绘制
}
// 处理主角子弹绘制
for (int i = 0; i < vcbulletplayer.size(); i++) {
vcbulletplayer.elementat(i).draw(canvas, paint);
}
break;
case game_win:
break;
case game_lost:
break;
case game_pause:
break;
default:
break;
}
}
} catch (exception e) {
// todo: handle exception
} finally {
if (canvas != null)
sfh.unlockcanvasandpost(canvas);
}
}
/**
* 触屏事件监听
*/
@override
public boolean ontouchevent(motionevent event) {
switch (gamestate) {
case game_menu:
gamemenu.ontouchevent(event);
break;
case gameing:
break;
case game_win:
break;
case game_lost:
break;
case game_pause:
break;
}
return true;
}
/**
* 按键事件监听
*/
@override
public boolean onkeydown(int keycode, keyevent event) {
switch (gamestate) {
case game_menu:
break;
case gameing:
player.onkeydown(keycode, event);
break;
case game_win:
break;
case game_lost:
break;
case game_pause:
break;
}
return super.onkeydown(keycode, event);
}
@override
public boolean onkeyup(int keycode, keyevent event) {
switch (gamestate) {
case game_menu:
break;
case gameing:
player.onkeyup(keycode, event);
break;
case game_win:
break;
case game_lost:
break;
case game_pause:
break;
}
return super.onkeyup(keycode, event);
}
/**
* 游戏逻辑
*/
private void logic() {
switch (gamestate) {
case game_menu:
break;
case gameing:
gamebg.logic();
player.logic();
// 敌机逻辑
if (isboss == false) {
// 敌机逻辑
for (int i = 0; i < vcenemy.size(); i++) {
enemy en = vcenemy.elementat(i);
// 因为容器不断添加敌机 ，那么对敌机isdead判定，
// 如果已死亡那么就从容器中删除,对容器起到了优化作用；
if (en.isdead) {
vcenemy.removeelementat(i);
} else {
en.logic();
}
}
// 生成敌机
count++;
if (count % createenemytime == 0) {
for (int i = 0; i < enemyarray[enemyarrayindex].length; i++) {
// 苍蝇
if (enemyarray[enemyarrayindex][i] == 1) {
int x = random.nextint(screenw - 100) + 50;
vcenemy.addelement(new enemy(bmpenemyfly, 1, x, -50));
// 鸭子左
} else if (enemyarray[enemyarrayindex][i] == 2) {
int y = random.nextint(20);
vcenemy.addelement(new enemy(bmpenemyduck, 2, -50,
y));
// 鸭子右
} else if (enemyarray[enemyarrayindex][i] == 3) {
int y = random.nextint(20);
vcenemy.addelement(new enemy(bmpenemyduck, 3,
screenw + 50, y));
}
}
// 这里判断下一组是否为最后一组(boss)
if (enemyarrayindex == enemyarray.length - 1) {
isboss = true;
} else {
enemyarrayindex++;
}
}
// 每2秒添加一个敌机子弹
countenemybullet++;
if (countenemybullet % 40 == 0) {
for (int i = 0; i < vcenemy.size(); i++) {
enemy en = vcenemy.elementat(i);
// 不同类型敌机不同的子弹运行轨迹
int bullettype = 0;
switch (en.type) {
// 苍蝇
case enemy.type_fly:
bullettype = bullet.bullet_fly;
break;
// 鸭子
case enemy.type_duckl:
case enemy.type_duckr:
bullettype = bullet.bullet_duck;
break;
}
vcbullet.add(new bullet(bmpenemybullet, en.x + 10,
en.y + 20, bullettype));
}
}
// 处理敌机子弹逻辑
for (int i = 0; i < vcbullet.size(); i++) {
bullet b = vcbullet.elementat(i);
if (b.isdead) {
vcbullet.removeelement(b);
} else {
b.logic();
}
}
//每1秒添加一个主角子弹
countplayerbullet++;
if (countplayerbullet % 20 == 0) {
vcbulletplayer.add(new bullet(bmpbullet, player.x + 15, player.y - 20, bullet.bullet_player));
}
// 处理敌机与主角的碰撞
for (int i = 0; i < vcenemy.size(); i++) {
if (player.iscollsionwith(vcenemy.elementat(i))) {
// 发生碰撞，主角血量-1
player.setplayerhp(player.getplayerhp() - 1);
// 当主角血量小于0，判定游戏失败
if (player.getplayerhp() <= -1) {
gamestate = game_lost;
}
}
}
//处理主角子弹逻辑
for (int i = 0; i < vcbulletplayer.size(); i++) {
bullet b = vcbulletplayer.elementat(i);
if (b.isdead) {
vcbulletplayer.removeelement(b);
} else {
b.logic();
}
}
//处理敌机子弹与主角碰撞
for (int i = 0; i < vcbullet.size(); i++) {
if (player.iscollsionwith(vcbullet.elementat(i))) {
//发生碰撞，主角血量-1
player.setplayerhp(player.getplayerhp() - 1);
//当主角血量小于0，判定游戏失败
if (player.getplayerhp() <= -1) {
gamestate = game_lost;
}
}
}
//处理主角子弹与敌机碰撞
for (int i = 0; i < vcbulletplayer.size(); i++) {
//取出主角子弹容器的每个元素
bullet blplayer = vcbulletplayer.elementat(i);
for (int j = 0; j < vcenemy.size(); j++) {
//添加爆炸效果
//取出敌机容器的每个元与主角子弹遍历判断
if (vcenemy.elementat(j).iscollsionwith(blplayer)) {
vcboom.add(new boom(bmpboom, vcenemy.elementat(j).x, vcenemy.elementat(j).y, 7));
}
}
}
}
break;
case game_win:
break;
case game_lost:
break;
case game_pause:
break;
}
}
@override
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视图状态发生改变，响应此函数
*/
@override
public void surfacechanged(surfaceholder holder, int format, int width,
int height) {
}
/**
* surfaceview视图消亡时，响应此函数
*/
@override
public void surfacedestroyed(surfaceholder holder) {
flag = false;
}
}
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持移动技术网。
如对本文有疑问，请在下面进行留言讨论，广大热心网友会与你互动！！ 点击进行留言回复
Android studio开发小型对话机器人app(实例代码)
Android通过Java sdk的方式接入OpenCv的方法
Android 通过cmake的方式接入opencv的方法步骤
Android Studio finish()方法的使用与解决app点击“返回”(直接退出)
Android 进度条 ProgressBar的实现代码(隐藏、出现、加载进度)
网友评论