飞机大战-动

FlyingObject类

//飞行物是airplane,bee，bullet，hero的父类
public abstract class FlyingObject {
protected BufferedImage image;//图片
protected int width;//图片的宽
protected int height;//图片的高
protected int x;//图片在面板中显示的x坐标
protected int y;//图片在面板中显示的y坐标

//飞行物走一步
public abstract void step();//抽象方法只能放到抽象类或接口里
//判断飞行物是否越界
public abstract boolean outOfBounds();
//敌人被子弹撞上了
public boolean shootBy(Bullet b) {//b传过来的子弹
int x1=this.x;//x1:敌人的x坐标
int x2=this.x+this.width;//x2:敌人的坐标x+敌人的宽
int y1=this.y;//y1:敌人的y坐标
int y2=this.y+this.height;//y2:敌人的y+敌人的高
int x=b.x;//x：子弹的x
int y=b.y;//y:子弹的y

return x>x1&&x &&
  y>y1&&y }

}

Award接口

//小蜜蜂的奖励机制
public interface Award {
//接口中定义的属性为常量
public static final int DOUBLE_FIRE=0;//火力值   
public static final int LIFE=1;//命
//获取奖励机制 返回0代表火力值,返回1代表命
public abstract int getType();//抽象方法
}

---

Enemy接口

//小敌机的得分机制
public interface Enemy {
//得分
public int getScore();
}

---

Airplane类

//小敌机:是飞行物  也是敌人
public class Airplane extends FlyingObject implements Enemy {
// protected BufferedImage image;//图片
// protected int width;//图片的宽
// protected int height;//图片的高
// protected int x;//图片在面板中显示的x坐标
// protected int y;//图片在面板中显示的y坐标
private int speed=2;//小敌机的下落速度(走步步数，值越大走的越快)
public Airplane(){
image=ShootGame.airplane;//获取小敌机图片
width=image.getWidth();//获取图片的宽
height=image.getHeight();//获取图片的高
Random rand=new Random();//生成随机数
x=rand.nextInt(ShootGame.WIDTH-this.width);//x: 0到屏幕的宽-敌机图片的宽,在此范围内生成随机数
y=-this.height;//y:-敌机的高
//y=200;
}
//射击一个小敌机加5分
public int getScore() {
// TODO Auto-generated method stub
return 5;
}
@Override
public void step() {
y +=speed;//小敌机向下落

}
//重写outOfBounds(判断小敌机是够越界)
@Override
public boolean outOfBounds() {


return y>=ShootGame.HEIGHT;//小敌机的y坐标大于屏幕的高就越界
}

}

---

Bee类

//小蜜蜂:是飞行物  ,也是奖励
public class Bee extends FlyingObject implements Award{
private int xSpeed=1;//小蜜蜂x轴方向的速度
private int ySpeed=2;//小蜜蜂y轴方向的下落速度
private int awardType;//奖励类型(双倍火力或者加命)
//构造方法
public Bee(){
image=ShootGame.bee;//获取小蜜蜂图片
width=image.getWidth();//获取图片的宽
height=image.getHeight();//获取图片的高
Random rand=new Random();
x=rand.nextInt(ShootGame.WIDTH-this.width);//在0~（ShootGame.WIDTH-this.width）生成随机数
y=-this.height;
//y=200;
awardType=rand.nextInt(2);//生成0或1的随机数
}
//重写getType()
public int getType() {
// TODO Auto-generated method stub
return awardType;//返回奖励类型(0或1)
}
@Override
public void step() {
y +=ySpeed;//竖直方向移动
x +=xSpeed;//水平方向移动
if(x>=ShootGame.WIDTH-this.width){//如果到了右边界速度变成负的
xSpeed=-1;
}
if(x<=0){//如果到了做边界速度变成正的
xSpeed=1;
}

}
//重写outOfBounds(判断小蜜蜂是否越界)
@Override
public boolean outOfBounds() {
// TODO Auto-generated method stub
return y>=ShootGame.HEIGHT;//小蜜蜂的y坐标大于屏幕的高越界
}

}

Bullet类

//子弹：是飞行物
public class Bullet extends FlyingObject{
private int speed=3;//子弹从下往上速度
public Bullet(int x,int y){
image=ShootGame.bullet;//获取子弹的图片
width=image.getWidth();//获取图片的高
height=image.getHeight();//获取图片的宽
//根据英雄机的坐标来相应的计算子弹的坐标
this.x=x;
this.y=y;
}
@Override
public void step() {
y -=speed;//子弹向上移动

}
//重写outOfBounds(判断子弹是否越界)
@Override
public boolean outOfBounds() {
// TODO Auto-generated method stub
return y<=-this.height;//子弹的y<=负的子弹的高,即为越界
}
}

---

Hero类

//英雄机:也是飞行物
public class Hero extends FlyingObject{
// protected BufferedImage image;//图片
// protected int width;//图片的宽
// protected int height;//图片的高
// protected int x;//图片在面板中显示的x坐标
// protected int y;//图片在面板中显示的y坐标
private int life;//命
private int doubleFire;//火力值
private BufferedImage[] images;//英雄机的图片数组
private int index;//图片下标，协助图片切换
public Hero(){
image=ShootGame.hero0;//英雄机的图片
width=image.getWidth();//英雄机的宽
height=image.getHeight();//英雄机的高
//英雄机刚开始出现位置
x=150;
y=400;
life=3;//初始的命数为3
doubleFire=0;//初始的火力值为0(即:单倍火力)
images=new BufferedImage[]{ShootGame.hero0,ShootGame.hero1};//放两张英雄机图片
index=0;//图片下标默认从0开始
}
//英雄机发射子弹
public Bullet[] shoot() {
int xStep=this.width/4;//英雄机宽度的1/4
if(doubleFire>0){//双倍火力
Bullet[] bullets=new Bullet[2];
bullets[0]=new Bullet(this.x+1*xStep,this.y-20);//x:英雄机的x+1/4英雄机的宽  y:英雄机的y-20
bullets[1]=new Bullet(this.x+3*xStep,this.y-20);//x:英雄机的x+3/4英雄机的宽  y:英雄机的y-20
doubleFire -=2;//发射一次双倍火力则火力值减2
return bullets;//返回两个子弹
}else{//单倍子弹
Bullet[] bullets=new Bullet[1];//子弹数组,只有一个元素
bullets[0]=new Bullet(this.x+2*xStep,this.y-20);//x:英雄机的x+2/4英雄机的宽  y:英雄机的y-20
return bullets;//返回一个子弹
}

}
public void moveTo(int x, int y) {
//从英雄机的中心点移到英雄机的左上角
this.x=x-this.width/2;//鼠标的x-1/2英雄机的宽
this.y=y-this.height/2;//鼠标的y-1/2英雄机的高

}
@Override
public void step() {//10毫秒执行一次
image=images[index++/10%images.length];//降速10倍  100毫秒执行一次
/*
* 10 0%2 0 hero0
* 20 1%2 1 hero1
* 30 2%2 0 hero0
* 40 3%2 1 hero1
* 50 4%2 0 hero0
* 60 5%2 1 hero1
*/

/*
* 10  0/10%2  0 hero0
* 20  1/10%2  0 hero0
* 30  2/10%2  0 hero0
* 40  3/10%2  0 hero0
* 50  4/10%2  0 hero0
* 60  5/10%2  0 hero0
* 70  6/10%2  0 hero0
* 80  7/10%2  0 hero0
* 90  8/10%2  0 hero0
* 100 9/10%2  0 hero0
* 110 10/10%2 1 hero1
* 120 11/10%2 1 hero1
*/
}
@Override
public boolean outOfBounds() {
// TODO Auto-generated method stub
return false;
}
public void addLife() {
life++;//命数加1
}
public void addDoubleFire() {
doubleFire +=40;//火力值加40
}
public int getLife() {
// TODO Auto-generated method stub
return life;
}
public void setDoubleFire(int doubleFire) {//int doubleFire=0;
this.doubleFire=doubleFire;//火力值归0 单倍火力

}
//英雄机减命
public void subtractLife() {
life--;

}
public boolean hit(FlyingObject f) {//f代表小敌机或者小蜜蜂
int x1=f.x-this.width/2;//x1:敌人的x-1/2英雄机的宽
int x2=f.x+f.width+this.width/2;//x2:敌人的x+敌人的宽+1/2英雄机的宽
int y1=f.y-this.height/2;//y1:敌人的y-1/2英雄机的高
int y2=f.y+f.height+this.height/2;//y2:敌人的y+敌人的高+1/2英雄机的高
//英雄机的中心点
int x=this.x+this.width/2;//英雄机的x+1/2英雄机的宽
int y=this.y+this.height/2;//英雄机的y+1/2英雄机的高

return x>x1&&x &&
  y>y1&&y }

}

---

ShootGame类

public class ShootGame extends JPanel{//ShootGame is a JPanel  ShootGame是一个面板
public static final int WIDTH=400;//窗口宽400，static final修饰表示常量
public static final int HEIGHT=654;//窗口高654,static final修饰表示常量
public static BufferedImage background;//BufferedImage存储图片  背景图
public static BufferedImage start;//开始图
public static BufferedImage gameover;//结束图
public static BufferedImage pause;//暂停图
public static BufferedImage airplane;//小敌机
public static BufferedImage bee;//小蜜蜂
public static BufferedImage bullet;//子弹
public static BufferedImage hero0;//英雄机0
public static BufferedImage hero1;//英雄机1

private Hero hero=new Hero();//创建一个英雄机
private FlyingObject[] flyings={};//存储小蜜蜂或者小敌机的数组
private Bullet[] bullets={};//存储子弹的数组

public static final int START=0;//开始状态(启动状态，准备状态)
public static final int RUNNING=1;//运行状态
public static final int PAUSE=2;//暂停状态
public static final int GAME_OVER=3;//游戏结束状态
public int state=0;//当前状态(一开始的当前状态为0)


static{//静态代码块，用于初始化图片资源
try {
background=ImageIO.read(ShootGame.class.getResource("background.png"));//读取背景图
start=ImageIO.read(ShootGame.class.getResource("start.png"));//读取开始图片
gameover=ImageIO.read(ShootGame.class.getResource("gameover.png"));//读取结束图
pause=ImageIO.read(ShootGame.class.getResource("pause.png"));//读取暂停图
airplane=ImageIO.read(ShootGame.class.getResource("airplane.png"));//读取小敌机图
bee=ImageIO.read(ShootGame.class.getResource("bee.png"));//读取小蜜蜂图
bullet=ImageIO.read(ShootGame.class.getResource("bullet.png"));//读取子弹图
hero0=ImageIO.read(ShootGame.class.getResource("hero0.png"));//读取英雄机0图
hero1=ImageIO.read(ShootGame.class.getResource("hero1.png"));//读取英雄机1图
} catch (IOException e) {
e.printStackTrace();
}
}

public ShootGame(){
flyings=new FlyingObject[2];
flyings[0]=new Airplane();//0位置放一个小敌机
flyings[1]=new Bee();//1位置放一个小蜜蜂
bullets=new Bullet[1];
bullets[0]=new Bullet(80,100);//0位置放一个子弹，坐标为(80,100)
}
//在ShootGame里画图片
@Override
public void paint(Graphics g) {//g理解画笔
g.drawImage(background,0,0,null);//通过g画背景图   background背景图  0:x坐标为0  0:y坐标为0  null空值无影响
paintHero(g);//画英雄机
paintFlyingEnemy(g);//画敌人(小敌机和小蜜蜂)
paintBullets(g);//画子弹
paintScore(g);//画分数
paintState(g);//画状态
}
//画状态
private void paintState(Graphics g) {
switch (state) {//state根据当前状态画不同的图
case START:
g.drawImage(start, 0, 0, null);//画开始图
break;
case PAUSE:
g.drawImage(pause, 0, 0, null);//画暂停图
break;
case GAME_OVER:
g.drawImage(gameover, 0, 0, null);//画游戏结束图
break;
}

}
//画分数
private void paintScore(Graphics g) {
//画分
g.setColor(new Color(0xFF0000));//0x表示16进制  给画笔设置红色
g.setFont(new Font(Font.SANS_SERIF,Font.BOLD,22));//Font.SANS_SERIF样式(例如宋体) Font.BOLD 粗体  22 字体大小
g.drawString("SCORE: "+score,10,25);//"SCORE: "+score分数  10:x坐标  25：y坐标
//画命
g.drawString("LIFE: "+hero.getLife(),10,45);
}
//画英雄机
private void paintHero(Graphics g) {//g是画笔
g.drawImage(hero.image, hero.x, hero.y,null);//画英雄机对象
}
//画敌人(小敌机和小蜜蜂)
private void paintFlyingEnemy(Graphics g) {
for(int i=0;i FlyingObject f=flyings[i];//获取每一个元素(敌人)
g.drawImage(f.image,f.x,f.y,null);//画每一个敌人
}
}
//画子弹
private void paintBullets(Graphics g) {
for(int i=0;i Bullet b=bullets[i];//获取每一个子弹
g.drawImage(b.image, b.x, b.y, null);//画每一个子弹
}
}
public static void main(String[] args) {
JFrame frame=new JFrame("Fly");//创建窗体(相框)并设置标题Fly
// JPanel panel=new JPanel();//底板(相片)
// panel.setBackground(Color.RED);//设置底板(相片)背景色为红色
// frame.add(panel);//将底板(相片)添加到窗体(相框)中
ShootGame game=new ShootGame();//底板(相片)
frame.add(game);//将底板(相片)添加到窗体(相框)中
frame.setSize(WIDTH,HEIGHT);//设置窗体大小宽400,高654
frame.setLocationRelativeTo(null);//设置相对位置为居中的
frame.setAlwaysOnTop(true);//设置总是在最上面
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//设置默认关闭操作
frame.setVisible(true);//设置可见,即显示窗体,尽快调用paint方法
game.action();
}
//此方法里写一个循环(Timer定时器)
private void action() {
MouseAdapter l=new MouseAdapter() {//创建鼠标监听器,监听鼠标
//鼠标移动事件
@Override
public void mouseMoved(MouseEvent e) {//mouseMoved重写鼠标移动的方法
if(state==RUNNING){//在运行状态下才获取鼠标坐标
int x=e.getX();//获得鼠标的x坐标
int y=e.getY();//获得鼠标的y坐标
hero.moveTo(x,y);//将鼠标坐标传给英雄机(英雄机随着鼠标移动)
}
}
//鼠标点击事件
@Override
public void mouseClicked(MouseEvent e) {
switch (state) {//根据当前状态做不同操作
case START://准备状态下点击进入运行状态
state=RUNNING;//将当前状态变为运行状态
break;
case GAME_OVER://结束状态下点击进入准备状态
state=START;//将当前状态变为准备状态
hero=new Hero();//重新创建一个英雄机
flyings=new FlyingObject[0];//敌人置空
bullets=new Bullet[0];//子弹置空
score=0;//分数置空
break;
}
}
//鼠标移入事件
@Override
public void mouseEntered(MouseEvent e) {
if(state==PAUSE){//暂停状态移入进入运行状态
state=RUNNING;//从暂停状态进入运行状态
}
}
//鼠标移除事件
@Override
public void mouseExited(MouseEvent e) {
if(state==RUNNING){
state=PAUSE;
}
}

};
this.addMouseListener(l);//处理鼠标操作事件
this.addMouseMotionListener(l);//处理鼠标滑动事件
Timer timer=new Timer();//创建定时器
int intervel=10;//时间间隔(以毫秒为单位) 10毫秒
timer.schedule(new TimerTask() {
//此为要执行的任务 每隔10毫秒要干的事
@Override
public void run() {
if(state==RUNNING){//如果是运行状态时,执行if里面的语句块
enterAction();//敌人(小蜜蜂+小敌机)
shootAction();//子弹入场(英雄机发射子弹)
stepAction();//飞行物(英雄机+小蜜蜂+小敌机+子弹)走一步
outOfBoundsAction();//删除越界的敌人和子弹(其实是保留不越界的)
bangAction();//子弹与敌人(小敌机和小蜜蜂)碰撞
checkGameOver();//检查游戏是否结束
}
repaint();//重绘(重新调用paint()方法)
}


},intervel,intervel);

}
//检查游戏是否结束
protected void checkGameOver() {
if(isGameOver()){//如果游戏结束了  isGameOver()为true表示游戏结束
state=GAME_OVER;//如果游戏结束了将状态变为游戏结束状态
}
}
private boolean isGameOver() {
for(int i=0;i FlyingObject f=flyings[i];//获取每一个敌人
if(hero.hit(f)){//为true表示英雄机撞上了敌人
hero.subtractLife();//英雄机减命
hero.setDoubleFire(0);//英雄机火力值归0
//将被撞敌人元素对象与最后一个元素对象进行交换
FlyingObject obj=flyings[i];//被英雄机撞上的敌人
flyings[i]=flyings[flyings.length-1];
flyings[flyings.length-1]=obj;
//缩容，即删除数组中做一个元素(即，被英雄机撞的对象)
flyings=Arrays.copyOf(flyings, flyings.length-1);
}
}
return hero.getLife()<=0;//若命数<=0表示游戏结束
}
int score=0;//打到小敌机得分
//让所有子弹和所有敌人(小蜜蜂和小敌机)碰撞
protected void bangAction() {
for(int i=0;i bang(bullets[i]);//调用方法实现一个子弹与所有敌人的碰撞
}

}
//实现一个子弹与所有敌人的碰撞
private void bang(Bullet b){
int index=-1;//被撞敌人的下标(-1即没撞上)
for(int i=0;i FlyingObject f=flyings[i];//获取一个敌人
if(f.shootBy(b)){//敌人被子弹撞上了
index=i;//记录被撞敌人的下标
break;//这个子弹撞上一个敌人之后不会再撞上其他敌人了
}
}
if(index!=-1){//有撞上，让小敌机或小蜜蜂消失
FlyingObject one=flyings[index];//获取被撞敌人对象 
if(one instanceof Enemy){//被撞敌人是小敌机
Enemy e=(Enemy) one;//向下造型(Enemy接口里有getScore())
score +=e.getScore();//射击一个小敌机加5分
System.out.println("score="+score);
}
if(one instanceof Award){//被撞敌人是小蜜蜂
Award a=(Award) one;//向下造型
int type=a.getType();//获取奖励类型(加火力值0  加命1)
switch (type) {
case Award.DOUBLE_FIRE://若奖励类型为火力值
hero.addDoubleFire();//英雄机加火力值
break;
case Award.LIFE://若奖励类型为加命
hero.addLife();//英雄机加命
break;
default:
break;
}

}

//交换被撞敌人对象与数组中最后一个元素 
FlyingObject t=flyings[index];//获取被撞敌人   
flyings[index]=flyings[flyings.length-1];
flyings[flyings.length-1]=t;
//缩容
flyings=Arrays.copyOf(flyings, flyings.length-1);

}

}
//删除越界的敌人和子弹(其实是保留不越界的)
protected void outOfBoundsAction() {
int index=0;//1，不越界敌人数组的下标 2.不越界敌人的个数
FlyingObject[] flyingLives=new FlyingObject[flyings.length];//不越界敌人数组
for(int i=0;i FlyingObject f=flyings[i];//取得每一个元素(小蜜蜂或小敌机)
if(!f.outOfBounds()){//不越界
flyingLives[index]=f;//将不越界的敌人对象添加到不越界敌人数组中
index++;//1.数组下标加1   2.不越界敌人个数加1
}
}
flyings=Arrays.copyOf(flyingLives,index);//将不越界敌人数组截取不越界的元素到flyings数组中

index=0;//1.不越界的子弹下标  2.不越界的子弹个数
Bullet[] bulletLives=new Bullet[bullets.length];
for(int i=0;i Bullet b=bullets[i];//获取每一个子弹
if(!b.outOfBounds()){//不越界
bulletLives[index]=b;//将不越界的子弹对象添加到不越界的子弹数组中
index++;//1. 子弹数组下标增1   2.不越界子弹个数增1
}
}
bullets=Arrays.copyOf(bulletLives,index);//将不越界的子弹数组赋值到bullets中

}
//飞行物(英雄机+小蜜蜂+小敌机+子弹)走一步
protected void stepAction() {
hero.step();//英雄机走一步(实现喷气效果)
for(int i=0;i flyings[i].step();//敌人(敌机+小蜜蜂)走一步
}
for(int i=0;i bullets[i].step();//子弹走一步
}
}
//敌人(小蜜蜂+小敌机)
int flyingObjectIndex=0;//统计敌人入场次数
protected void enterAction() {//
flyingObjectIndex++;
//1%40=1   2%40=2 ... 39%40=39  40%40=0
//41%40=1 42%40=2 ... 79%40=39  80%40=0
if(flyingObjectIndex%40==0){//降速40倍  原先是10毫秒执行  10*40=400
FlyingObject obj=nextOne();//nextOne()随机生成任意一个小蜜蜂或者小敌机
flyings=Arrays.copyOf(flyings, flyings.length+1);//敌人数组扩容
flyings[flyings.length-1]=obj;//将敌人对象放到flyings数组的最后一个元素上
}

}
private FlyingObject nextOne() {//生成1个蜜蜂时生成19个小敌机
Random rand=new Random();
int type=rand.nextInt(20);//生成[0,20)之间的整数0~19
if(type==0){//如果随机数生成的是0,返回小蜜蜂
return new Bee();
}else{//如果随机数生成的是1~19之间的数，返回小敌机
return new Airplane();
}

}
//子弹入场(英雄机发射子弹)
int shootIndex=0;//子弹入场计数
protected void shootAction() {//10毫秒执行一次
shootIndex++;//10毫秒加1
if(shootIndex%30==0){//300毫秒执行以下if里的语句
Bullet[] bs=hero.shoot();//英雄机发射子弹(可能是单倍火力也可能是双倍火力)
bullets=Arrays.copyOf(bullets,bullets.length+bs.length);//扩容(bs里有几个元素则扩容几个容量)
System.arraycopy(bs,0,bullets,bullets.length-bs.length,bs.length);//bs-->bullets  数组的追加(将bs追加到bullets中)
}
}


}