Java飞机大战项目

短命女 2022-02-25 11:50 421阅读 0赞

飞机大战游戏是一款十分有趣的射击类小游戏，流畅的画面，高难度的挑战。游戏中，玩家驾驶英雄机，在空中进行战斗。点击并移动自己的英雄机，发射炮弹，打掉敌飞机以及蜜蜂，来获得分数和奖励，打掉一架敌飞机赢得5分，打掉一只蜜蜂赢得1条命或是获得20次双倍火力，如果撞上敌飞机或小蜜蜂，将减少命、双倍火力清零。每撞到一次蜜蜂或是敌飞机命减1，当命数为0时，则游戏结束。游戏界面如下图所示

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hvdWp1bmthbmczNjM_size_16_color_FFFFFF_t_70

下面就是教大家怎么用java来写出这个项目来。

数据建模：使用一个数据模型，描述对象的关系。使用绘图坐标系作为参考模型，英雄机、敌飞机、蜜蜂、子弹都是矩形区域。

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hvdWp1bmthbmczNjM_size_16_color_FFFFFF_t_70 1

类的设计

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hvdWp1bmthbmczNjM_size_16_color_FFFFFF_t_70 2

完整代码：

Airplane类的完整代码如下所示：

  1. package com.itkzhan.shoot;
  3. import java.util.Random;
  5. /** 敌机*/
  6. public class Airplane extends FlyingObject implements Enemy{
  7.     private int speed=2;//走步的步数
  8.     public Airplane(){
  9.         image=ShootGame.airplane;
  10.         width=image.getWidth();
  11.         height=image.getHeight();
  12.         Random rand=new Random();
  13.         x=rand.nextInt(ShootGame.WIDTH-this.width);
  14.         y=-height;//y坐标
  15.     }
  16.     public int getScore() {
  17.         return 5;
  18.     }
  19.     public void step() {
  20.         y+=speed;
  21.     }
  22.     public boolean outBounds() {
  24.         return this.y>ShootGame.HEIGHT;
  25.     }
  27. }

Award类的完整代码如下所示：

  1. package com.itkzhan.shoot;
  2. /** 奖励*/
  3. public interface Award {
  4.     int DOUBLE_FIRE=0;//双倍火力值
  5.     int LIFE=1;//命
  6.     int getType();//得奖励类型（0或1）
  7. }

Bee类的完整代码如下所示：

  1. package com.itkzhan.shoot;
  3. import java.util.Random;
  5. /** 蜜蜂*/
  6. public class Bee extends FlyingObject implements Award{
  7.     private int xSpeed=1;//x坐标走步步数
  8.     private int ySpeed=2;//y坐标走步步数
  9.     private int awardType;//奖励类型
  10.     /** Bee构造方法*/
  11.     public Bee(){
  12.         image=ShootGame.bee;//图片
  13.         width=image.getWidth();//图片的宽
  14.         height=image.getHeight();//图片的高
  15.         Random rand=new Random();
  16.         x=rand.nextInt(ShootGame.WIDTH-this.width);
  17.         y=-this.height;
  18.         awardType=rand.nextInt(2);
  19.     }
  20.     public int getType() {//奖励类型
  21.         return awardType;
  22.     }
  23.     public void step() {
  24.         x+=xSpeed;
  25.         y+=ySpeed;
  26.         if(this.x>=ShootGame.WIDTH-this.width){
  27.             xSpeed=-1;
  28.         }
  29.         if(x<=0){
  30.             xSpeed=1;
  31.         }
  32.     }
  33.     public boolean outBounds() {
  34.         return this.y>ShootGame.HEIGHT;
  35.     }
  37. }

Bullet类的完整代码如下所示：

  1. package com.itkzhan.shoot;
  2. /** 子弹*/
  3. public class Bullet extends FlyingObject{
  4.     private int speed=3;//走步的步数
  5.     /** Bullet构造方法*/
  6.     public Bullet(int x,int y){
  7.         image=ShootGame.bullet;
  8.         width=image.getWidth();
  9.         height=image.getHeight();
  10.         this.x=x;//x坐标
  11.         this.y=y;//y坐标
  12.     }
  13.     public void step() {
  14.         y-=speed;
  16.     }
  17.     public boolean outBounds() {
  18.         return this.y<-height;
  19.     }
  20. }

Enemy类的完整代码如下所示：

  1. package com.itkzhan.shoot;
  3. public interface Enemy {
  4.     int getScore();
  5. }

FlyingObject类的完整代码如下所示：

  1. package com.itkzhan.shoot;
  3. import java.awt.image.BufferedImage;
  5. /**
  6.  * 飞行物
  7.  * @author HP
  8.  *
  9.  */
  10. public abstract class FlyingObject {
  11.     protected int x;
  12.     protected int y;
  13.     protected int width;
  14.     protected int height;
  15.     protected BufferedImage image;
  16.     public int getX() {
  17.         return x;
  18.     }
  19.     public void setX(int x) {
  20.         this.x = x;
  21.     }
  22.     public int getY() {
  23.         return y;
  24.     }
  25.     public void setY(int y) {
  26.         this.y = y;
  27.     }
  28.     public int getWidth() {
  29.         return width;
  30.     }
  31.     public void setWidth(int width) {
  32.         this.width = width;
  33.     }
  34.     public int getHeight() {
  35.         return height;
  36.     }
  37.     public void setHeight(int height) {
  38.         this.height = height;
  39.     }
  40.     public BufferedImage getImage() {
  41.         return image;
  42.     }
  43.     public void setImage(BufferedImage image) {
  44.         this.image = image;
  45.     }
  46.     public abstract void step();
  47.     //敌人被子弹打
  48.     public  boolean shootBy(Bullet bullet){
  49.         int x=bullet.x;//子弹的x
  50.         int y=bullet.y;//子弹的y
  51.         return x>this.x&&x<this.x+this.width
  52.         &&
  53.         y>this.y&&y<this.y+this.height;
  54.     };
  55.     public abstract boolean outBounds();
  56. }

Hero类的完整代码如下所示：

  1. package com.itkzhan.shoot;
  3. import java.awt.image.BufferedImage;
  5. /** 英雄机:是飞行物*/
  6. public class Hero extends FlyingObject{
  7.     private int life;//命
  8.     private int doubleFire;//火力值
  9.     private BufferedImage[] images;//图片
  10.     private int index;//图片切换的频率
  11.     /** Hero构造方法*/
  12.     public Hero(){
  13.         image=ShootGame.hero0;//图片
  14.         width=image.getWidth();//宽
  15.         height=image.getHeight();//高
  16.         x=150;//固定150
  17.         y=400;//固定的400
  18.         life=3;//命值为3
  19.         doubleFire=0;//火力值为0,单倍火力
  20.         images=new BufferedImage[]{ShootGame.hero0,ShootGame.hero1};
  21.         index=0;
  22.     }
  23.     public void step() {
  24.         index++;
  25.         int a=index/10;//每100m b=0,1
  26.         int b=a%2;
  27.         image=images[b];
  28.         image=images[b];
  29.     }
  30.     /** 发射子弹*/
  31.     public Bullet[] shoot(){
  32.         int xStep=this.width/4;//1/4英雄机的宽度
  33.         int yStep=20;//子弹离飞机的距离
  34.         if(doubleFire>0){//双倍火力
  35.             Bullet[] bullets=new Bullet[2];
  36.             bullets[0]=new Bullet(this.x+xStep,this.y-yStep);
  37.             bullets[1]=new Bullet(this.x+3*xStep,this.y-yStep);
  38.             doubleFire-=-2;
  39.             return bullets;
  40.         }else{//单倍火力
  41.             Bullet[] bullets=new Bullet[1];
  42.             bullets[0]=new Bullet(this.x+2*xStep,this.y-yStep);
  43.             return bullets;
  44.         }
  45.     }
  46.     /** 英雄机随着鼠标移动x：鼠标的x坐标 y鼠标的y坐标*/
  47.     public void moveTo(int x,int y){
  48.         this.x=x-this.width/2;
  49.         this.y=y-this.height/2;
  50.     }
  52.     /**获取命*/
  53.     public int getLife(){
  54.         return life;
  55.     }
  56.     /** 减命*/
  57.     public void subtractLife(){
  58.         life--;
  59.     }
  61.     public void addLife(){
  62.         life++;
  63.     }
  64.     /** 增火力值*/
  65.     public void addDoubleFire(){
  66.         doubleFire+=40;
  67.     }
  68.     /** 设置火力值*/
  69.     public void setDoubleFire(int doubleFire){
  70.         this.doubleFire=doubleFire;
  71.     }
  72.     @Override
  73.     public boolean outBounds() {
  74.         return false;//永不越界
  75.     }
  76.     public boolean hit(FlyingObject other){
  77.         int x1=other.x-this.width/2;
  78.         int x2=other.x+other.width+this.width/2;
  79.         int y1=other.y-this.height/2;
  80.         int y2=other.y+other.height/2;
  81.         int hx=this.x+this.width/2;// 
  82.         int hy=this.y+this.height/2;
  83.         return hx>x1 && hx<x2
  84.                &&
  85.                hy>y1 && hy<y2;
  86.     }
  88. }

ShootGame类的完整代码如下所示：

  1. package com.itkzhan.shoot;
  3. import java.awt.Color;
  4. import java.awt.Font;
  5. import java.awt.Graphics;
  6. import java.awt.event.MouseAdapter;
  7. import java.awt.event.MouseEvent;
  8. import java.awt.image.BufferedImage;
  9. import java.util.Arrays;
  10. import java.util.Random;
  11. import java.util.Timer;
  12. import java.util.TimerTask;
  14. import javax.imageio.ImageIO;
  15. import javax.swing.JFrame;
  16. import javax.swing.JPanel;
  18. public class ShootGame extends JPanel{//面板
  19.     public static final int WIDTH=400;
  20.     public static final int HEIGHT=654;
  21.     public static BufferedImage background;
  22.     public static BufferedImage start;
  23.     public static BufferedImage airplane;
  24.     public static BufferedImage bee;
  25.     public static BufferedImage bullet;
  26.     public static BufferedImage hero0;
  27.     public static BufferedImage hero1;
  28.     public static BufferedImage pause;
  29.     public static BufferedImage gameover;
  31.     public Hero hero=new Hero();//英雄机对象
  32.     private FlyingObject[] flyings={};//敌人数组（敌机+蜜蜂）
  33.     private Bullet[] bullets={};//子弹数组
  35.     public static final int START=0;//启动状态
  36.     public static final int RUNNING=1;//运行
  37.     public static final int PAUSE=2;//暂停
  38.     public static final int GAME_OVER=3;//结束
  39.     private int state=0; //存储当前状态
  41.     static { // 静态代码块，初始化图片资源
  42.         try {
  43.             background = ImageIO.read(ShootGame.class
  44.                     .getResource("background.png"));
  45.             start = ImageIO.read(ShootGame.class.getResource("start.png"));
  46.             airplane = ImageIO
  47.                     .read(ShootGame.class.getResource("airplane.png"));
  48.             bee = ImageIO.read(ShootGame.class.getResource("bee.png"));
  49.             bullet = ImageIO.read(ShootGame.class.getResource("bullet.png"));
  50.             hero0 = ImageIO.read(ShootGame.class.getResource("hero0.png"));
  51.             hero1 = ImageIO.read(ShootGame.class.getResource("hero1.png"));
  52.             pause = ImageIO.read(ShootGame.class.getResource("pause.png"));
  53.             gameover = ImageIO
  54.                     .read(ShootGame.class.getResource("gameover.png"));
  56.         } catch (Exception e) {
  57.             e.printStackTrace();
  58.         }
  59.     }
  60.         /** 随机生成敌人对象（敌机、小蜜蜂）*/
  61.         public static FlyingObject nextOne(){
  62.             Random rand=new Random();
  63.             int type=rand.nextInt(20);//生成[0,20)随机数
  64.             if(type==0){
  65.                 return new Bee();//若为0则返回蜜蜂对象
  66.             }else{
  67.                 return new Airplane();//1到19则返回敌机对象
  68.             }
  70.         }
  71.         private Timer timer;//声明定时器对象
  72.         private int intervel=10;//定时器的时间间隔(以毫秒为单位)
  73.         int flyEnteredIndex=0;//敌人入场计数
  74.         /** 敌人入场（敌机、小蜜蜂)*/
  75.         public void enterAction(){//10毫秒走一次
  76.             flyEnteredIndex++;
  77.             if(flyEnteredIndex%40==0){//每400毫秒走一次
  78.                 FlyingObject o=nextOne();
  79.                 flyings=Arrays.copyOf(flyings, flyings.length+1);//扩容
  80.                 flyings[flyings.length-1]=o;//将对象加入到数组中
  81.             }
  83.         }
  84.         /** 飞行物走一步*/
  85.         public void stepAction(){
  86.             hero.step();
  87.             for(FlyingObject f:flyings){
  88.                 f.step();
  89.             }
  90.             for(Bullet b:bullets){
  91.                 b.step();
  92.             }
  93.         }
  94.         int shootIndex=0;//子弹发射计数
  95.         /** 英雄机发射子弹--子弹入场*/
  96.         public void shootAction(){
  97.             shootIndex++;
  98.             if(shootIndex%30==0){
  99.                 Bullet[] bs=hero.shoot();
  100.                 bullets=Arrays.copyOf(bullets, bullets.length+bs.length);
  101.                 System.arraycopy(bs,0,bullets, bullets.length-bs.length,bs.length);
  102.             }
  103.         }
  104.         int score=0;
  105.         /**所有子弹与所有敌人的碰撞 */
  106.         public void bangAction(){
  107.             for(Bullet b:bullets){
  108.                 bang(b);//
  109.             }
  110.         }
  111.         /** 一发子弹和所有敌人的碰撞*/
  112.         public void bang(Bullet bullet){
  113.             int index=-1;
  114.             for(int i=0;i<flyings.length;i++){
  115.                 FlyingObject obj=flyings[i];
  116.                 if(obj.shootBy(bullet)){
  117.                     index=i;
  118.                     break;
  119.                 }
  120.             }
  121.             if(index!=-1){//被撞上了
  122.                 FlyingObject one=flyings[index];
  123.                 if(one instanceof Enemy){//敌机
  124.                     Enemy e=(Enemy)one;
  125.                     score+=e.getScore();
  126.                 }
  127.                 if(one instanceof Award){//奖励
  128.                     Award a=(Award)one;
  129.                     int type=a.getType();
  130.                     switch (type) {
  131.                     case Award.DOUBLE_FIRE:
  132.                         hero.addDoubleFire();
  133.                         break;
  134.                     case Award.LIFE:
  135.                         hero.addLife();
  136.                         break;
  137.                     }
  138.                 }
  139.                 FlyingObject t=flyings[index];
  140.                 flyings[index]=flyings[flyings.length-1];
  141.                 flyings[flyings.length-1]=t;
  142.                 flyings=Arrays.copyOf(flyings, flyings.length-1);//缩容
  143.             }
  144.         }
  146.         public void outOfBoundsAction(){
  147.             //越界飞行物
  148.             FlyingObject[] flyingLives=new FlyingObject[flyings.length];//活着的
  149.             int index=0;
  150.             for(int i=0;i<flyings.length;i++){
  151.                 FlyingObject obj=flyings[i];
  152.                 if(!obj.outBounds()){//不越界
  153.                     flyingLives[index]=obj;//存储在flyingLives
  154.                     index++;
  155.                 }
  156.             }
  157.             flyings=Arrays.copyOf(flyingLives, index);
  158.             index=0;
  159.             Bullet[] bulletLives=new Bullet[bullets.length];
  160.             for(int i=0;i<bullets.length;i++){
  161.                 Bullet b=bullets[i];
  162.                 if(!b.outBounds()){
  163.                     bulletLives[index]=b;
  164.                     index++;
  165.                 }
  166.             }
  167.             bullets=Arrays.copyOf(bulletLives, index);
  168.         }
  169.         /** 检查游戏结束*/
  170.         public void checkGameOverAction(){
  171.             if(isGameOver()){//若游戏结束
  172.                 state=GAME_OVER; 
  173.             }
  174.         }
  175.         /** 判断游戏是否结束*/
  176.         public boolean isGameOver(){
  177.             for(int i=0;i<flyings.length;i++){
  178.                 int index=-1;
  179.                 FlyingObject f=flyings[i]; 
  180.                 if(hero.hit(f)){
  181.                     hero.subtractLife();
  182.                     hero.setDoubleFire(0);
  183.                     index=i;
  184.                 }
  185.                 if(index!=-1){
  186.                     //将被撞的敌人删除
  187.                     FlyingObject t=flyings[index];
  188.                     flyings[index]=flyings[flyings.length-1];
  189.                     flyings[flyings.length-1]=t;
  190.                     flyings=Arrays.copyOf(flyings, flyings.length-1);
  191.                 }
  192.             }
  193.             return hero.getLife()<=0;
  194.         }
  196.         /** 主程序流程控制*/
  197.         public void action(){
  198.             //鼠标操作事件
  199.             MouseAdapter l=new MouseAdapter() {
  200.                 /** 鼠标移动事件*/
  201.                 public void mouseMoved(MouseEvent e) {
  202.                     if(state==RUNNING){
  203.                     int x=e.getX();//获取鼠标的x坐标
  204.                     int y=e.getY();//获取鼠标的y坐标
  205.                     hero.moveTo(x, y);//英雄机随鼠标移动
  206.                     }
  207.                 }
  208.                 public void mouseClicked(MouseEvent e) {//鼠标点击事件
  209.                     switch (state) {//判断当前状态
  210.                     case START:
  211.                         state=RUNNING;
  212.                         break;
  213.                     case GAME_OVER:
  214.                         flyings = new FlyingObject[0]; // 清空飞行物
  215.                         bullets = new Bullet[0]; // 清空子弹
  216.                         hero = new Hero(); // 重新创建英雄机
  217.                         score = 0; // 清空成绩
  218.                         state = START; // 状态设置为启动
  220.                     }
  221.                 }
  222.                 public void mouseExited(MouseEvent e) {//鼠标移开事件
  223.                     if(state==RUNNING){
  224.                         state=PAUSE;
  225.                     }
  226.                 }
  227.                 public void mouseEntered(MouseEvent e) {//移入事件
  228.                     if(state==PAUSE){
  229.                         state=RUNNING;
  230.                     }
  231.                 }
  232.             };
  234.             this.addMouseListener(l);//处理鼠标一般操作
  235.             this.addMouseMotionListener(l);//处理鼠标滑动
  236.             timer=new Timer();//创建定时器对象
  237.             timer.schedule(new TimerTask(){
  238.                 public void run() {
  239.                     if(state==RUNNING){
  240.                     enterAction();//敌人入场
  241.                     stepAction();//飞行物走一步
  242.                     shootAction();//英雄机发子弹
  243.                     bangAction();//子弹和敌人的碰撞
  244.                     outOfBoundsAction();//删除出界对象
  245.                     checkGameOverAction();//检查游戏结束  
  246.                     }
  247.                     repaint();
  248.                 }}, intervel,intervel);//第一个intervel:程序启动到第一次干事的间隔
  249.                                         //第二个intervel:每次干事的间隔
  250.         }
  252.         //g：画笔
  253.         public void paint(Graphics g) {
  254.             g.drawImage(background,0,0,null);//第四个参数不需要管，跟程序无关
  255.             paintHero(g);
  256.             paintFlyingObjects(g);
  257.             paintBullets(g);
  258.             paintScore(g);
  259.             paintState(g);//画状态
  260.         }
  261.         //画子弹
  262.     private void paintBullets(Graphics g) {
  263.             for(Bullet b:bullets){
  264.                 g.drawImage(b.image,b.x,b.y,null);
  265.             }
  267.         }
  268.     //画敌人
  269.     private void paintFlyingObjects(Graphics g) {
  270.             for(FlyingObject f:flyings){
  271.                 g.drawImage(f.image,f.x,f.y,null);
  272.             }
  274.         }
  275.     //画英雄机
  276.     private void paintHero(Graphics g) {
  277.             g.drawImage(hero.image,hero.x,hero.y,null);
  279.         }
  280.     //画分和画命
  281.     private void paintScore(Graphics g){
  282.         g.setColor(new Color(0xFF0000));//设置颜色--红色
  283.         g.setFont(new Font(Font.SANS_SERIF,Font.BOLD,20));//字体,加粗,字号
  284.         g.drawString("SCORE: "+score, 10, 25);
  285.         g.drawString("LIFE: "+hero.getLife(), 10, 45);
  286.     }
  287.     //画状态
  288.     public void paintState(Graphics g){
  289.         switch (state) {//判断状态
  290.         case START:
  291.             g.drawImage(start,0,0,null);
  292.             break;
  293.         case PAUSE:
  294.             g.drawImage(pause,0,0,null);
  295.             break;
  296.         case GAME_OVER: 
  297.             g.drawImage(gameover,0,0,null);
  298.             break;
  299.         }
  300.     }
  301.     public static void main(String[] args) {
  302.         JFrame frame=new JFrame("Fly");
  303.         ShootGame game=new ShootGame();
  304.         frame.add(game);//将面板添加到窗口中
  305.         frame.setSize(WIDTH,HEIGHT);
  306.         frame.setAlwaysOnTop(true);//总是居顶
  307.         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//设置默认关闭操作
  308.         frame.setLocationRelativeTo(null);//设置位置相对与，默认相对位置就是中间点
  309.         frame.setVisible(true);//1.设置窗口可见 2.尽快调用paint()方法
  310.         game.action();//启动执行
  311.     }
  313. }

关注公众号，回复”飞机大战”即可获取视频及图片

" class="reference-link">watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hvdWp1bmthbmczNjM_size_16_color_FFFFFF_t_70 3

发表评论

表情：
评论列表 （有 0 条评论，421人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Java飞机大战项目

    飞机大战游戏是一款十分有趣的射击类小游戏，流畅的画面，高难度的挑战。游戏中，玩家驾驶英雄机，在空中进行战斗。点击并移动自己的英雄机，发射炮弹，打掉敌飞机以及蜜蜂，来获得分数和奖

    短命女短命女/ 0 赞/ 422 阅读