飞机大战java

整个游戏窗口

package cn.tedu.shoot;
import javax.swing.JFrame;
import javax.swing.JPanel;
import java.awt.Graphics;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.Timer;
import java.util.TimerTask;
import java.util.Random;
import java.util.Arrays;

/** 整个游戏窗口 */
public class World extends JPanel {
    public static final int WIDTH = 400;  //窗口的宽
    public static final int HEIGHT = 700; //窗口的高
    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 = START;

    private Sky sky = new Sky();         //天空对象
    private Hero hero = new Hero();      //英雄机对象
    private FlyingObject[] enemies = {}; //敌人(小敌机、大敌机、小蜜蜂)数组
    private Bullet[] bullets = {};
    /** 生成敌人(小敌机、大敌机、小蜜蜂)对象 */
    public FlyingObject nextOne(){
        Random rand = new Random(); //随机数对象
        int type = rand.nextInt(20); //0到19之间的随机数
        if(type<5){ //0到4时，返回小蜜蜂对象
            return new Bee();
        }else if(type<13){ //5到12时，返回小敌机对象
            return new Airplane();
        }else{ //13到19时，返回大敌机对象
            return new BigAirplane();
        }
    }

    private int enterIndex = 0; //敌人入场计数
    /** 敌人入场 */
    public void enterAction(){ //每10毫秒走一次
        enterIndex++; //每10毫秒增1
        if(enterIndex%40==0){ //每400(40*10)毫秒走一次
            FlyingObject obj = nextOne(); //获取敌人对象
            enemies = Arrays.copyOf(enemies,enemies.length+1); //扩容
            enemies[enemies.length-1] = obj; //将obj添加到enemies的最后一个元素上
        }
    }
    /** 子弹入场 */
    private int shootIndex = 0;
    public void shootAction(){ //每10毫秒走一次
        shootIndex++; //每10毫秒增1
        if(shootIndex%30==0){ //每300(30*10)毫秒走一次
            Bullet[] bs = hero.shoot(); //获取子弹数组对象
            bullets = Arrays.copyOf(bullets,bullets.length+bs.length); //扩容(bs有几个就扩大几个容量)
            System.arraycopy(bs,0,bullets,bullets.length-bs.length,bs.length); //数组的追加
        }
    }
    /**飞行物移动*/
    public void stepAction(){ //每10毫秒走一次
        sky.step(); //天空动
        for(int i=0;i<enemies.length;i++){ //遍历所有敌人
            enemies[i].step(); //敌人动
        }
        for(int i=0;i<bullets.length;i++){ //遍历所有子弹
            bullets[i].step(); //子弹动
        }
    }
    /** 删除越界的敌人和子弹 */
    public void outOfBoundsAction(){ //每10毫秒走一次
        for(int i=0;i<enemies.length;i++){ //遍历所有敌人
            if(enemies[i].isOutOfBounds()){ //越界了
                enemies[i] = enemies[enemies.length-1]; //将越界敌人替换为enemies的最后一个元素
                enemies = Arrays.copyOf(enemies,enemies.length-1); //缩容
            }
        }

        for(int i=0;i<bullets.length;i++){ //遍历所有子弹
            if(bullets[i].isOutOfBounds()){ //越界了
                bullets[i] = bullets[bullets.length-1]; //将越界子弹替换为bullets的最后一个元素
                bullets = Arrays.copyOf(bullets,bullets.length-1); //缩容
            }
        }
    }
    private int score = 0; //玩家的得分
    /** 子弹与敌人的碰撞 */
    public void bulletBangAction(){ //每10毫秒走一次
        for(int i=0;i<bullets.length;i++){ //遍历所有子弹
            Bullet b = bullets[i]; //获取每一个子弹
            for(int j=0;j<enemies.length;j++){ //遍历所有敌人
                FlyingObject f = enemies[j]; //获取每一个敌人
                if(b.isLive() && f.isLive() && f.isHit(b)){ //若都活着的，并且还撞上了
                    b.goDead(); //子弹去死
                    f.goDead(); //敌人去死
                    if(f instanceof EnemyScore){ //若被撞对象能得分
                        EnemyScore es = (EnemyScore)f; //将被撞对象强转为得分接口
                        score += es.getScore(); //玩家得分
                    }
                    if(f instanceof EnemyAward){ //若被撞对象为奖励
                        EnemyAward ea = (EnemyAward)f; //将被撞对象强转为奖励接口
                        int type = ea.getAwardType(); //获取奖励类型
                        switch (type){ //根据奖励类型来获取不同的奖励
                            case EnemyAward.FIRE: //若为火力值
                                hero.addFire();   //则英雄机增火力
                                break;
                            case EnemyAward.LIFE: //若为命
                                hero.addLife();   //则英雄机增命
                                break;
                        }
                    }
                }
            }
        }
    }
    /** 英雄机与敌人碰撞 */
    public void heroBangAction(){
        for (int i=0;i<enemies.length;i++){
            FlyingObject f = enemies[i];
            if (f.isLive() && hero.isLive() && f.isHit(hero)){
                f.goDead();
                hero.subtractLife();
                hero.clearFire();
            }
        }
    }
    /** 检测游戏结束 */
    public void checkGameOverAction(){
        if (hero.getLife()<=0){
            state = GAME_OVER;

        }
    }
    /** 启动程序的执行 */
    public void action(){
        //鼠标侦听器
        MouseAdapter m = new MouseAdapter(){
            /** 重写mouseMoved()鼠标移动事件 */
            public void mouseMoved(MouseEvent e){
                if(state==RUNNING) { //仅在运行状态下执行
                    int x = e.getX(); //获取鼠标的x坐标
                    int y = e.getY(); //获取鼠标的y坐标
                    hero.moveTo(x, y); //英雄机随着鼠标移动
                }
            }
            /** 重写mouseClicked()鼠标点击事件 */
            public void mouseClicked(MouseEvent e){
                switch(state){ //根据当前状态来做不同的处理
                    case START:          //启动状态时
                        state = RUNNING; //修改为运行状态
                        break;
                    case GAME_OVER:    //游戏结束状态时
                        score = 0;        //清理现场
                        sky = new Sky();
                        hero = new Hero();
                        enemies = new FlyingObject[0];
                        bullets = new Bullet[0];
                        state = START; //修改为启动状态
                        break;
                }
            }
            /** 重写mouseExited()鼠标移出事件 */
            public void mouseExited(MouseEvent e){
                if(state==RUNNING){ //运行状态时
                    state = PAUSE;  //修改为暂停状态
                }
            }
            /** 重写mouseEntered()鼠标移入事件 */
            public void mouseEntered(MouseEvent e){
                if(state==PAUSE){    //暂停状态时
                    state = RUNNING; //修改为运行状态
                }
            }
        };
        this.addMouseListener(m);
        this.addMouseMotionListener(m);

        Timer timer = new Timer(); //定时器对象
        int interval = 10; //定时间隔(以毫秒为单位)
        timer.schedule(new TimerTask(){
            public void run(){ //定时干的事(每10毫秒走一次)
                if(state==RUNNING){ //仅在运行状态下执行
                    enterAction(); //敌人入场
                    shootAction(); //子弹入场
                    stepAction();  //飞行物移动
                    outOfBoundsAction();   //删除越界的敌人和子弹
                    bulletBangAction();    //子弹与敌人的碰撞
                    heroBangAction();      //英雄机与敌人的碰撞
                    checkGameOverAction(); //检测游戏结束
                }
                repaint(); //重画(重新调用paint()方法)
            }
        },interval,interval); //定时计划表
    }
    /** 重写paint()画  g:画笔 */
    public void paint(Graphics g){
        g.drawImage(sky.getImage(),sky.x,sky.y,null); //画天空
        g.drawImage(sky.getImage(),sky.x,sky.getY1(),null); //画天空2
        g.drawImage(hero.getImage(),hero.x,hero.y,null); //画英雄机
        for(int i=0;i<enemies.length;i++){ //遍历所有敌人
            FlyingObject f = enemies[i]; //获取每一个敌人
            g.drawImage(f.getImage(),f.x,f.y,null); //画敌人
        }
        for(int i=0;i<bullets.length;i++){ //遍历所有子弹
            Bullet b = bullets[i]; //获取每一个子弹
            g.drawImage(b.getImage(),b.x,b.y,null); //画子弹
        }
        g.drawString("分数: "+score,10,25); //画分
        g.drawString("命: "+hero.getLife(),10,45); //画命
        switch (state){
            case START:
                g.drawImage(Images.start,0,0,null);
                break;
            case PAUSE:
                g.drawImage(Images.pause,0,0,null);
                break;
            case GAME_OVER:
                g.drawImage(Images.gameover,0,0,null);
                break;
        }
    }
    public static void main(String[] args) {
        JFrame frame = new JFrame();
        World world = new World();
        world.setFocusable(true);
        frame.add(world);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(WIDTH+16,HEIGHT+39);
        frame.setLocationRelativeTo(null);
        frame.setResizable(false);
        frame.setVisible(true); //调用paint()方法
        world.action();
    }
}

Airplane类

package cn.tedu.shoot;
import java.awt.image.BufferedImage;
import java.util.Random;
public class Airplane extends FlyingObject implements EnemyScore {
    private int speed;
    public Airplane(){
       super(48,50);
       speed = 2;
    }
    public void step(){
        y += speed;

    }
    int index = 1; //下标
    /** 重写getImage()获取图片 */
    public BufferedImage getImage(){ //每10毫秒走一次
        if(isLive()){              //若活着的
            return Images.airs[0]; //则直接返回airs[0]图片即可
        }else if(isDead()){ //若死了的
            BufferedImage img = Images.airs[index++]; //获取爆破图
            if(index==Images.airs.length){ //若index为5，则表示到最后一张爆破图了
                state = REMOVE;            //将当前状态修改为REMOVE删除的
            }
            return img; //返回爆破图
               /*
                 执行过程:
                                     index=1
                   10M  img=airs[1]  index=2          返回airs[1]
                   20M  img=airs[2]  index=3          返回airs[2]
                   30M  img=airs[3]  index=4          返回airs[3]
                   40M  img=airs[4]  index=5(REMOVE)  返回airs[4]
                   50M  不返回图片
                */
        }
        return null; //REMOVE状态时，不返回图片
    }
    /** 重写getScore()得分 */
    public int getScore(){
        return 1; //打掉小敌机，玩家得1分
    }
}

Bee类

package cn.tedu.shoot;
import java.awt.image.BufferedImage;
import java.util.Random;
/** 小蜜蜂:是飞行物 */
public class Bee extends FlyingObject implements EnemyAward{
    private int xSpeed; //x坐标移动速度
    private int ySpeed; //y坐标移动速度
    private int awardType; //奖励类型
    /** 构造方法 */
    public Bee(){
        super(60,51);
        xSpeed = 1;
        ySpeed = 2;
        Random rand = new Random(); //随机数对象
        awardType = rand.nextInt(2); //0到1之间随机生成
    }

    /** 重写step()移动 */
    public void step(){
        x+=xSpeed; //x+(向右或向左)
        y+=ySpeed; //y+(向下)
        if(x<=0 || x>=400-width){ //若x<=0或x>=(窗口宽-蜜蜂宽)，表示到两头了
            xSpeed*=-1; //则切换方法(正变负，负变正)
        }
    }

    int index = 1; //下标
    /** 重写getImage()获取图片 */
    public BufferedImage getImage(){ //每10毫秒走一次
        if(isLive()){
            return Images.bees[0];
        }else if(isDead()){
            BufferedImage img = Images.bees[index++];
            if(index==Images.bees.length){
                state = REMOVE;
            }
            return img;
        }
        return null;
    }
    /** 重写getAwardType()获取奖励类型 */
    public int getAwardType(){
        return awardType; //返回奖励类型
    }
}

BigAirplane类

package cn.tedu.shoot;

import java.awt.image.BufferedImage;
import java.util.Random;

public class BigAirplane extends FlyingObject implements EnemyScore{
    private int speed;
    public BigAirplane(){
       super(66,89);
       speed = 2;
    }
    public void step() {
        y += speed;

    }
    int index = 1; //下标
    /** 重写getImage()获取图片 */
    public BufferedImage getImage(){ //每10毫秒走一次
        if(isLive()){
            return Images.bairs[0];
        }else if(isDead()){
            BufferedImage img = Images.bairs[index++];
            if(index==Images.bairs.length){
                state = REMOVE;
            }
            return img;
        }
        return null;
    }
    /** 重写getScore()得分 */
    public int getScore(){
        return 3; //打掉大敌机，玩家得3分
    }
}

Bullet类

package cn.tedu.shoot;

import java.awt.image.BufferedImage;

public class Bullet extends FlyingObject {
    private int speed;
    public Bullet(int x,int y){
        super(8,20,x,y);
        speed = 3;

    }

    public void step() {
        y -= speed;

    }
    /** 重写getImage()获取图片 */
    public BufferedImage getImage(){ //每10毫秒走一次
        if(isLive()){             //若活着的
            return Images.bullet; //则直接返回子弹图片
        }else if(isDead()) { //若死了的
            state = REMOVE;  //则将当前状态修改为REMOVE删除的
        }
        return null; //死了的和删除的，都不返回图片
           /*
             执行过程:
               1)若活着的，返回bullet图片
               2)若死了的，将当前状态修改为REMOVE删除的，同时不返回图片
               3)若删除的，不返回图片
            */
    }
    /** 重写isOutOfBounds()检测子弹是否越界 */
    public boolean isOutOfBounds(){
        return y<=-height; //子弹的y<=负的子弹的高，即为越界了
    }
}

FlyingObject(超类)

package cn.tedu.shoot;
import java.awt.image.BufferedImage;
import java.util.Random;
public abstract class FlyingObject {
    public static final int LIVE = 0;   //活着的
    public static final int DEAD = 1;   //死了的
    public static final int REMOVE = 2; //删除的
    protected int state = LIVE; //当前状态(默认为活着的)
    protected int width;
    protected int height;
    protected int x;
    protected int y;
    public FlyingObject(int width,int height){
        this.width = width;
        this.height = height;
        Random rand = new Random();
        x = rand.nextInt(World.WIDTH-width); //x:0到(窗口宽-敌人宽)之内的随机数
        y = -height;
    }
    public FlyingObject(int width,int height,int x,int y){
        this.width = width;
        this.height = height;
        this.x = x;
        this.y = y;
    }
   public abstract void step();
    /** 获取对象的图片 */
    public abstract BufferedImage getImage();

    /** 判断对象是否是活着的 */
    public boolean isLive(){
        return state==LIVE; //若当前状态为LIVE，表示对象是活着的，返回true，否则返回false
    }
    /** 判断对象是否是死了的 */
    public boolean isDead(){
        return state==DEAD; //若当前状态为DEAD，表示对象是死了的，返回true，否则返回false
    }

    /** 判断对象是否是删除的 */
    public boolean isRemove(){
        return state==REMOVE; //若当前状态为REMOVE，表示对象是删除的，返回true，否则返回false
    }
    public boolean isOutOfBounds(){
        return y>=World.HEIGHT; //敌人的y>=窗口的高，即为越界了
    }
    /** 检测碰撞  this:敌人 other:子弹/英雄机 */
    public boolean isHit(FlyingObject other){
        int x1 = this.x-other.width;  //x1:敌人的x-子弹/英雄机的宽
        int x2 = this.x+this.width;   //x2:敌人的x+敌人的宽
        int y1 = this.y-other.height; //y1:敌人的y-子弹/英雄机的高
        int y2 = this.y+this.height;  //y2:敌人的y+敌人的高
        int x = other.x;              //x:子弹/英雄机的x
        int y = other.y;              //y:子弹/英雄机的y

        return x>=x1 && x<=x2 && y>=y1 && y<=y2; //x在x1与x2之间，并且，y在y1与y2之间，即为撞上了
    }
    /** 飞行物去死 */
    public void goDead(){
        state = DEAD; //将当前状态修改为DEAD死了的
    }
}

Hero类

package cn.tedu.shoot;

import java.awt.image.BufferedImage;

public class Hero extends FlyingObject {
    private int life;
    private int fire;
    public Hero(){
        super(97,139,140,400);
        life = 5;
        fire = 3;

    }

    public void step() {

    }
    int index = 0; //下标
    /** 重写getImage()获取图片 */
    public BufferedImage getImage(){ //每10毫秒走一次
        return Images.heros[index++%Images.heros.length];
    }
    /** 英雄机发射子弹(生成子弹对象) */
    public Bullet[] shoot(){
        int xStep = this.width/4; //1/4英雄机的宽
        int yStep = 20; //固定的20
        if(fire>0){ //双倍
            Bullet[] bs = new Bullet[2]; //2发子弹
            bs[0] = new Bullet(this.x+1*xStep,this.y-yStep); //x:英雄机的x+1/4英雄机的宽  y:英雄机的y-固定的20
            bs[1] = new Bullet(this.x+3*xStep,this.y-yStep); //x:英雄机的x+3/4英雄机的宽  y:英雄机的y-固定的20
            fire-=2; //发射一次双倍火力，则火力值减2
            return bs;
        }else{ //单倍
            Bullet[] bs = new Bullet[1]; //1发子弹
            bs[0] = new Bullet(this.x+2*xStep,this.y-yStep); //x:英雄机的x+2/4英雄机的宽  y:英雄机的y-固定的20
            return bs;
        }
    }
    /** 英雄机移动  x/y:鼠标的x坐标和y坐标 */
    public void moveTo(int x,int y){
        this.x = x-this.width/2;  //英雄机的x=鼠标的x-1/2英雄机的宽
        this.y = y-this.height/2; //英雄机的y=鼠标的y-1/2英雄机的高
    }
    /** 英雄机增命 */
    public void addLife(){
        life++; //命数增1
    }
    /** 获取英雄机的命 */
    public int getLife(){
        return life; //返回命数
    }
    /** 英雄机减命 */
    public void subtractLife(){
        life --;
    }
    /** 英雄机增火力 */
    public void addFire(){
        fire+=40; //火力值增40
    }
    /** 火力值清零 */
    public void clearFire(){
        fire = 0;
    }
}

Images类

package cn.tedu.shoot;
import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
/** 图片工具类 */
public class Images {
    //  公开的  静态的   图片数据类型  变量名
    public static BufferedImage start;    //启动图片
    public static BufferedImage pause;    //暂停图片
    public static BufferedImage gameover; //游戏结束图片
    public static BufferedImage sky;      //天空图片
    public static BufferedImage bullet;   //子弹图片
    public static BufferedImage[] heros;  //英雄机图片数组
    public static BufferedImage[] airs;   //小敌机图片数组
    public static BufferedImage[] bairs;  //大敌机图片数组
    public static BufferedImage[] bees;   //小蜜蜂图片数组

    static { //给图片赋值
        start = readImage("start.png");
        pause = readImage("pause.png");
        gameover = readImage("gameover.png");
        sky = readImage("background.png");
        bullet = readImage("bullet.png");
        heros = new BufferedImage[2]; //2张图片
        heros[0] = readImage("hero0.png");
        heros[1] = readImage("hero1.png");

        airs = new BufferedImage[5]; //5张图片
        bairs = new BufferedImage[5]; //5张图片
        bees = new BufferedImage[5]; //5张图片
        airs[0] = readImage("airplane.png");
        bairs[0] = readImage("bigairplane.png");
        bees[0] = readImage("bee.png");
        for(int i=1;i<airs.length;i++){ //赋值爆破图
            airs[i] = readImage("bom"+i+".png");
            bairs[i] = readImage("bom"+i+".png");
            bees[i] = readImage("bom"+i+".png");
        }
    }

    /** 读取图片  fileName:图片名称 */
    public static BufferedImage readImage(String fileName){
        try{
            BufferedImage img = ImageIO.read(FlyingObject.class.getResource(fileName)); //读取与FlyingObject同包中的图片
            return img;
        }catch(Exception e){
            e.printStackTrace();
            throw new RuntimeException();
        }
    }

    public static void main(String[] args) {
        System.out.println(Images.heros.length); //测试代码只要用到Images类就OK
    }
}

Sky类

package cn.tedu.shoot;

import java.awt.image.BufferedImage;

public class Sky extends FlyingObject {
    private int speed;
    private int y1;
    public Sky(){
        super(400,700,0,0);
        speed = 1;
        y1 = -World.HEIGHT;
    }

    public void step() {
        y += speed;
        y1 += speed;
        if(y>=700){ //若y>=窗口的高，表示移到最下面了
            y=-700; //则将y修改为负的窗口的高，即移到最上面去
        }
        if(y1>=700){ //若y1>=窗口的高，表示移到最下面了
            y1=-700; //则将y1修改为负的窗口的高，即移到最上面去
        }
    }
    /** 重写getImage()获取图片 */
    public BufferedImage getImage(){ //每10毫秒走一次
        return Images.sky; //返回sky图片即可
    }

    /** 获取y1坐标 */
    public int getY1(){
        return y1; //返回y1坐标
    }
}