JAVA项目：Java实现飞扬的小鸟(Flappy Bird)

r囧r小猫 2022-12-10 08:54 278阅读 0赞

飞扬的小鸟(Flappy Bird)

需求描述

游戏加载完毕点击界面即可开始游戏。

鼠标点击控制小鸟飞行，或者通过键盘控制小鸟的前后上下也可以，不要撞到管道哦！

控制好小鸟越过障碍飞得更远，获得更高的积分。

使用的技术点

  • 变量
  • 分支语句
  • 循环语句
  • 面向对象
  • 异常处理
  • Random随机数
  • StringBuffer字符串操作
  • IO操作
  • 多线程
  • swing组件
  • 。。。。

需求分析

代码实现

1、实现界面背景

step1：首先新建一个class表示背景类BackGround。我们要在该类中，加载背景图片。

创建一个包pics，里面先存放背景图：bg.png。

先定义一个常量类Constant，专门用于存储程序中的常量。

代码实现：

  1. package com.ruby.demo;
  2. ​
  3. /**
  4.  * 常量类
  5.  * @author ruby
  6.  *
  7.  */
  8. public class Constant {
  9. ​
  10.   // 图片路径
  11.   public static String PATH_PIC = "/pics/";
  12. // 背景图片路径
  13.   public static String PATH_BACKGROUND = PATH_PIC + "bg.png";
  15. }
  16. ​

然后创建BackGround类：

代码实现：

  1. package com.ruby.demo;
  2. ​
  3. import java.awt.image.BufferedImage;
  4. import java.io.IOException;
  5. ​
  6. import javax.imageio.ImageIO;
  7. ​
  8. /**
  9.  * step1：背景类：单例模式
  10.  * 
  11.  * @author ruby
  12.  *
  13.  */
  14. public class BackGround {
  15.   public BufferedImage img = null;// 背景图片
  16.   public int width = 0;// 背景的宽度
  17.   public int height = 0;// 背景的高度
  18.   private static BackGround instance = null;
  19. ​
  20.   private BackGround() {
  21.     try {
  22.       // ImageIO用于加载图片资源
  23.       // this.getClass().getResource根据当前路径加载图片
  24.       img = ImageIO.read(this.getClass().getResource(Constant.PATH_BACKGROUND));
  25. ​
  26.       // 获取背景图片长度和高度
  27.       width = img.getWidth();// 获取图片的宽度
  28.       height = img.getHeight();// 获取图片的宽度
  29. ​
  30.       System.out.println("widthBg=" + width + ", heightBg=" + height);
  31. ​
  32.     } catch (IOException e) {
  33.       e.printStackTrace();
  34.     }
  35.   }
  36. ​
  37.   // 实现线程安全的懒汉式
  38.   public static BackGround getInstance() {
  39.     if (instance == null) {
  40.       instance = new BackGround();
  41.     }
  42.     return instance;
  43.   }
  44. }
  45. ​

代码实现：

  1. package com.ruby.demo;
  2. ​
  3. import java.awt.image.BufferedImage;
  4. import java.io.IOException;
  5. ​
  6. import javax.imageio.ImageIO;
  7. ​
  8. /**
  9.  * step1：背景类：单例模式
  10.  * 
  11.  * @author ruby
  12.  *
  13.  */
  14. public class BackGround {
  15.   public BufferedImage img = null;// 背景图片
  16.   public int width = 0;// 背景的宽度
  17.   public int height = 0;// 背景的高度
  18.   private static BackGround instance = null;
  19. ​
  20.   private BackGround() {
  21.     try {
  22.       // ImageIO用于加载图片资源
  23.       // this.getClass().getResource根据当前路径加载图片
  24.       img = ImageIO.read(this.getClass().getResource(Constant.PATH_BACKGROUND));
  25. ​
  26.       // 获取背景图片长度和高度
  27.       width = img.getWidth();// 获取图片的宽度
  28.       height = img.getHeight();// 获取图片的宽度
  29. ​
  30.       System.out.println("widthBg=" + width + ", heightBg=" + height);
  31. ​
  32.     } catch (IOException e) {
  33.       e.printStackTrace();
  34.     }
  35.   }
  36. ​
  37.   // 实现线程安全的懒汉式
  38.   public static BackGround getInstance() {
  39.     if (instance == null) {
  40.       instance = new BackGround();
  41.     }
  42.     return instance;
  43.   }
  44. }
  45. ​

说明：

  • 整个项目只有这一个背景，所以可以设计为单例模式。
  • 通过getResource()方法加载图片资源。

step2：然后创建一个面板类，上面用于实现背景，小鸟等。GamePanel

这里主要重写paint()方法，将背景图片，显示到面板上。

代码实现：

  1. package com.ruby.demo;
  2. ​
  3. import java.awt.Graphics;
  4. import java.awt.Image;
  5. import java.awt.event.MouseAdapter;
  6. import java.awt.event.MouseEvent;
  7. import java.io.IOException;
  8. import java.text.SimpleDateFormat;
  9. import java.util.Date;
  10. ​
  11. import javax.imageio.ImageIO;
  12. import javax.swing.JPanel;
  13. ​
  14. /**
  15.  * step2：自定义JPanel类的子类
  16.  * 
  17.  * @author ruby
  18.  *
  19.  */
  20. ​
  21. public class GamePanel extends JPanel {
  22. ​
  23.   private BackGround bg = null;// 声明背景对象
  24. ​
  25.   /*
  26.    * 构造函数
  27.    */
  28.   public GamePanel() {
  29.     // 单例模式声明背景对象和地面对象
  30.     bg = BackGround.getInstance();
  31.   }
  32. ​
  33.   /**
  34.    * 当前面板中绘制组件（加载图片等）
  35.    * 
  36.    * paint方法会在初始化以及最小和最大化时自动调用该方法（即窗口发生变化时，jvm都会自动调用该方法用于绘制面板）
  37.    */
  38.   @Override
  39.   public void paint(Graphics g) {
  40.     super.paint(g);
  41.     System.out.println("paint方法被调用" + getCurrentTime());
  42.     // Graphics对象绘制背景图案
  43.     g.drawImage(bg.img, 0, 0, null);
  44. ​
  45.   }
  46. ​
  47.   // 获取当前时间
  48.   public String getCurrentTime() {
  49.     Date day = new Date();
  50.     SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
  51.     return df.format(day);
  52.   }
  53. }
  54. ​

step3：创建一个窗体类GameFrame，里面添加刚刚创建的GamePanel对象。

但是首先要在Constant常量类中，设置一些常量：

代码：

  1. // 界面参数
  2.   public static String GAME_TITLE = "飞翔吧小鸟";
  3.   public static int WINDOW_WIDTH = 432;
  4.   public static int WINDOW_HEIGHT = 644;

代码实现：

  1. package com.ruby.demo;
  2. ​
  3. import javax.swing.JFrame;
  4. /**
  5.  * step3：窗体
  6.  * @author ruby
  7.  *
  8.  */
  9. public class GameFrame extends JFrame {
  10. ​
  11.   // 初始化窗体
  12.   public void initFrame() {
  13.     // 设置窗口标题
  14.     setTitle(Constant.GAME_TITLE);
  15.     // 设置窗口大小
  16.     setSize(Constant.WINDOW_WIDTH, Constant.WINDOW_HEIGHT);
  17. ​
  18.     // 添加Panel
  19.     GamePanel panel = new GamePanel();
  20.     add(panel);
  21. ​
  22.     // 设置窗口坐标
  23.     setLocationRelativeTo(null);
  24. ​
  25.     // 设置窗口可见
  26.     setVisible(true);
  27. ​
  28.     // 设置窗口大小不可调整
  29.     setResizable(false);
  31.     // 监听窗口关闭，程序结束
  32.     setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  33.   }
  34. }
  35. ​

step4：创建Main类，表示程序的入口：

代码实现：

  1. package com.ruby.demo;
  2. /**
  3.  * 程序的入口
  4.  * @author ruby
  5.  *
  6.  */
  7. ​
  8. public class Main {
  9. ​
  10.   public static void main(String[] args) {
  11.     GameFrame frame = new GameFrame();
  12.     frame.initFrame();
  13.   }
  14. ​
  15. }
  16. ​

运行效果：

e4d651e22aca708a8044e16903fc4ef0.png

2、实现地面移动

思路：

首先得先在Constant常量类中，添加地面的图片路径，并且将地面图片拷贝到pics资源目录下。

  1. // 地面图片路径
  2.   public static String PATH_GROUND = PATH_PIC + "ground.png";

然后创建Ground类：

然后创建Ground类：

  1. package com.ruby.demo;
  2. ​
  3. import java.awt.image.BufferedImage;
  4. import java.io.IOException;
  5. ​
  6. import javax.imageio.ImageIO;
  7. ​
  8. /**
  9.  * step1：地面类
  10.  * 
  11.  * @author ruby
  12.  *
  13.  */
  14. public class Ground {
  15.   public BufferedImage img = null;// 地面图片
  16.   public int x, y;// 地面绘制的起始坐标
  17.   public int width = 0;// 地面的宽度
  18.   public int height = 0;// 地面的高度
  19.   private static Ground instance = null;
  20. ​
  21.   private Ground() {
  22.     try {
  23.       // 单例模式
  24.       BackGround bg = BackGround.getInstance();
  25.       // ImageIO用于加载图片资源
  26.       // this.getClass().getResource根据当前路径加载图片
  27.       img = ImageIO.read(this.getClass().getResource(Constant.PATH_GROUND));
  28. ​
  29.       // 获取地面图片的长度和高度
  30.       width = img.getWidth();// 获取图片的宽度
  31.       height = img.getHeight();// 获取图片的宽度
  32. ​
  33.       x = 0;
  34.       y = bg.height - height;// 背景高度与地面图片高度的差值就是地面图片的起始Y坐标
  35.       System.out.println("widthGround=" + width + ", heightGround=" + height);
  36.       System.out.println("x=" + x + ", y=" + y);
  37. ​
  38.     } catch (IOException e) {
  39.       e.printStackTrace();
  40.     }
  41.   }
  42. ​
  43.   // 实现懒汉式
  44.   public static Ground getInstance() {
  45.     if (instance == null) {
  46.       instance = new Ground();
  47.     }
  48.     return instance;
  49.   }
  50. }
  51. ​

说明：在该类中要计算出地面的坐标点x和y。

x为0即可，而y的值为背景图片的高度减去地面图片的高度。

然后添加一个地面移动的方法：

  1. // 地面移动
  2.   public void move(BackGround bg) {
  3.     x--;
  4.     if (x == bg.width +9 - width) {// 9为修正值，根据地面移动效果调整该数值，保证图片移动自然流畅。是地面图片中条纹间距的一半数值。
  5.       x = 0;
  6.     }
  7.      System.out.println("x=" + x);
  8.   }

所谓的运动地面，就是就是修改x的值，地面向左侧移动，所以x—。

然后要修改GamePanel中的paint()方法，绘制地面：

  1. @Override
  2.   public void paint(Graphics g) {
  3.     super.paint(g);
  4.     System.out.println("paint方法被调用" + getCurrentTime());
  5.     // Graphics对象绘制背景图案
  6.     g.drawImage(bg.img, 0, 0, null);
  7. ​
  8.     // 绘制地面
  9.     g.drawImage(ground.img, ground.x, ground.y, null);
  10.   }

然后在GamePanel类中添加一个新增的方法action()，表示游戏的动作，我们需要设置一个死循环，来让地面不停的移动。

多久移动一次呢，我们可以设置一个速度，其实就表示游戏的速度，可以初始化一个常量，每当过一关，游戏的速度可以适当的增加。

现在定义一个常量：

  1. public static int MOVE_SPEED = 40;// 地面及柱子移动初始速度。当积分累加，速度会递增

在GamePanel类中添加一个变量speed，表示速度：

  1. private int speed = 0;// 柱子和地面的移动速度

修改GamePanel()构造方法：

  1. // 初始化速度
  2. speed = Constant.MOVE_SPEED;
  3. ​

然后添加一个action()方法，

  1. public void action() {
  2.     // 设置鼠标监听
  3. ​
  4.     // 设置键盘监听
  5. ​
  6.     // 通过监听鼠标事件，监听到state的变化，无限循环，不断切换状态
  7.     while (true) {
  8.       // 地面移动
  9.       ground.move(bg);
  10. ​
  11.       // 线程休眠（因为是无限循环，下一次循环开始需要一段休息时间，这样才能让程序有缓冲的执行时间）
  12.       try {
  13.         Thread.sleep(1000 / speed);// 调节游戏速度
  14.         // 重新绘制（重新调用面板paint方法）
  15.         this.repaint();
  16.       } catch (Exception e) {
  17.         e.printStackTrace();
  18.       }
  19.     }
  20. ​
  21.   }

为了不让地面移动太快，频繁的绘制界面，我们需要让程序睡眠一下，这个睡眠的时间，其实表示游戏的速度，就是地面和柱子移动的速度。

然后在GameFrame的initFrame()方法中，调用action()方法：

  1. // 面板运行
  2. panel.action();

运行效果：

1af0e4eb88a1c828720d8bc49fcc6094.png

3、显示开始和结束

思路：整个游戏分为3个状态：游戏开始前，开始玩，游戏结束。定义一个变量state，0表示未开始，1表示玩ing，2表示game over，游戏结束。

当游戏未开始状态，显示开始图片。

点击开始游戏后，可以玩，当小鸟撞到地面或者天空或者柱子，游戏结束。

游戏结束时，显示结束图片。

在GamePanel类中，添加一个变量state

  1. private static int state = 0;// 游戏状态，0表示游戏未开始，1表示游戏正在进行，2表示游戏结束

然后在构造方法中，初始化state的状态，以及加载开始和结束的图片：

  1. /*
  2.    * 构造函数
  3.    */
  4.   public GamePanel() {
  5. ​
  6.     // 初始化数据
  7. ​
  8.     // 单例模式声明背景对象和地面对象
  9.     bg = BackGround.getInstance();
  10.     ground = Ground.getInstance();
  11.     // state = 0表示游戏未开始
  12.     state = 0;
  13. ​
  14.     try {
  15. ​
  16.       // 加载开始和结束图片
  17.       imgStart = ImageIO.read(this.getClass().getResource(Constant.PATH_START));
  18.       imgOver = ImageIO.read(this.getClass().getResource(Constant.PATH_GAMEOVER));
  19. ​
  20.     } catch (IOException e) {
  21.       e.printStackTrace();
  22.     }
  23. ​
  24.   }

同时将两张图片，添加到pics目录下，并且在Constant类中，添加常量值：

  1. public static String PATH_START = PATH_PIC + "start.png";
  2.   public static String PATH_GAMEOVER = PATH_PIC + "gameover.png";

修改绘图的方法paint()，先绘制背景，然后根据状态不同，绘制不同的图案，最后绘制地面：

  1. @Override
  2.   public void paint(Graphics g) {
  3.     super.paint(g);
  4.     System.out.println("paint方法被调用" + getCurrentTime());
  5.     // Graphics对象绘制背景图案
  6.     g.drawImage(bg.img, 0, 0, null);
  7. ​
  8.     // 根据状态，绘制不同的图案
  9.     if (state == 0) {//游戏未开始
  10.       // 游戏未开始时，绘制开始图案及小鸟
  11.       g.drawImage(imgStart, 0, 0, null);
  12. ​
  13.     } else if (state == 1) {// 游戏开始后
  15.     } else if (state == 2) {// 游戏结束
  16.       // 游戏结束时，绘制结束图案
  17.       g.drawImage(imgOver, 0, 0, null);
  18.     }
  19. ​
  20.     // 绘制地面
  21.     g.drawImage(ground.img, ground.x, ground.y, null);
  22.   }

修改action()方法，添加鼠标事件：

  1. public void action() {
  2.     // 设置鼠标监听
  3.     this.addMouseListener(new MouseAdapter() {
  4.       //点击鼠标后
  5.       @Override
  6.       public void mouseReleased(MouseEvent e) {
  7.         super.mouseReleased(e);
  8.         switch (state) {
  9.         case 0://游戏未开始
  10.           // 切换到状态1时的数据
  11.           state = 1;
  12.           break;
  14.         case 1://开始游戏
  15.           state = 2;//...
  16.           break;
  18.         case 2://游戏结束
  19.           //游戏结束后，更改状态为0，可以继续下一次游戏
  20.           state = 0;
  21.           break;
  22. ​
  23.         default:
  24.           break;
  25.         }
  29.       }
  30.     });
  32.     // 设置键盘监听
  33.   //....
  34. ​
  35.   }
  36. ​

运行效果：

aa7fd617fa0f8a7a8a47df6aabaf25c0.png

点击一下，开始游戏，再点一下结束游戏，效果如图：

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FpYW5mZW5nX2Rhc2h1anU_size_16_color_FFFFFF_t_70

开始游戏的时候，小鸟是灰色的，我们希望小鸟能一直扇动翅膀。

小鸟翅膀扇动，其实就是小鸟的8张图循环轮播。我们可以通过数组来实现。

现在Constant类中定义小鸟的图片数量，以及小鸟的初始位置：

  1. public static int BIRD_PIC_COUNT = 8;// 小鸟皮肤个数
  2. public static int BIRD_POSITION_X = 190;// 小鸟初始化坐标
  3. public static int BIRD_POSITION_Y = 220;

然后创建一个小鸟类Bird：

  1. package com.ruby.demo;
  2. ​
  3. import java.awt.image.BufferedImage;
  4. import java.io.IOException;
  5. ​
  6. import javax.imageio.ImageIO;
  7. ​
  8. /**
  9.  * 小鸟类
  10.  * 
  11.  * @author ruby
  12.  *
  13.  */
  14. public class Bird {
  15.   public BufferedImage img = null;// 小鸟图片
  16.   public BufferedImage imgs[] = new BufferedImage[Constant.BIRD_PIC_COUNT];// 数组，存储所有小鸟图案
  17.   public static int index = 0;// 当前皮肤的序号
  18.   public int x, y;// 初始坐标
  19.   public int width = 0;// 小鸟的宽度
  20.   public int height = 0;// 小鸟的高度
  21. ​
  22.   public Bird() {
  23.     try {
  24.       for (int i = 0; i < 8; i++) {
  25.         imgs[i] = ImageIO.read(getClass().getResource(Constant.PATH_PIC + i + ".png"));
  26.       }
  27.       img = imgs[0];
  28.       // 获取小鸟的宽度和高度
  29.       width = img.getWidth();
  30.       height = img.getHeight();
  31. ​
  32.       // 初始化小鸟的坐标位置
  33.       x = Constant.BIRD_POSITION_X;
  34.       y = Constant.BIRD_POSITION_Y;
  35.     } catch (IOException e) {
  36.       e.printStackTrace();
  37.     }
  38.   }
  39. ​
  41. }
  42. ​

添加一个小鸟扇动翅膀的方法：

  1. // 小鸟飞翔的图片切换
  2.   public void fly() {
  3.     index++;
  4.     // 小鸟图形切换的频率，index/x,x越大，翅膀切换频率越慢
  5.     img = imgs[index / 6 % Constant.BIRD_PIC_COUNT];
  6.     if (index == 6 * Constant.BIRD_PIC_COUNT) {
  7.       index = 0;
  8.     }
  9.   }

然后在GamePanel类中添加小鸟对象，

  1. private Bird bird = null;// 声明小鸟对象

并在构造方法中初始化：

  1. // 声明小鸟对象
  2.     bird = new Bird();

修改paint()方法，在未开始游戏的时候，就要绘制小鸟了：

  1. // 根据状态，绘制不同的图案
  2.     if (state == 0) {// 游戏未开始
  3.       // 游戏未开始时，绘制开始图案及小鸟
  4.       g.drawImage(imgStart, 0, 0, null);
  5.       g.drawImage(bird.img, bird.x, bird.y, null);
  6. ​
  7.     } else if (state == 1) {// 游戏开始后
  8. ​
  9.     } else if (state == 2) {// 游戏结束
  10.       // 游戏结束时，绘制结束图案
  11.       g.drawImage(imgOver, 0, 0, null);
  12.     }

修改action()方法，在循环中，除了移动地面外，还要让小鸟扇动翅膀：

  1. // 通过监听鼠标事件，监听到state的变化，无限循环，不断切换状态
  2.     while (true) {
  3.       // 地面移动
  4.       ground.move(bg);
  5.       bird.fly();
  6. ​
  7.       // 线程休眠（因为是无限循环，下一次循环开始需要一段休息时间，这样才能让程序有缓冲的执行时间）
  8.       try {
  9.         Thread.sleep(1000 / speed);// 调节游戏速度
  10.         // 重新绘制（重新调用面板paint方法）
  11.         this.repaint();
  12.       } catch (Exception e) {
  13.         e.printStackTrace();
  14.       }
  15.     }

运行结果：

c5b84cc4cb6283a541e18e737ad30f94.png

4、游戏开始

游戏开始后，小鸟就要移动了。还要添加上下两根柱子，柱子向左侧移动，通过点击鼠标，让小鸟上下移动，来躲避柱子。

小鸟上下飞动

我们现在实现小鸟的部分：

游戏开始时，小鸟在距离屏幕左侧120左右的位置就可以：

在Constant类中定义，游戏开始时小鸟的位置：

  1. public static int BIRD_FLY_POSITION_X = 120;// 小鸟开始飞翔时初始坐标

首先修改action()中，case 0里，先修改小鸟的位置

  1. public void action() {
  2.     // 设置鼠标监听
  3.     this.addMouseListener(new MouseAdapter() {
  4.       // 点击鼠标后
  5.       @Override
  6.       public void mouseReleased(MouseEvent e) {
  7.         super.mouseReleased(e);
  8.         switch (state) {
  9.         case 0:// 游戏未开始
  10.             // 切换到状态1时的数据
  11.           state = 1;
  12.           bird.x = Constant.BIRD_FLY_POSITION_X;// 小鸟飞的初始x坐标
  13.           break;
  14.           .....
  15. }

然后在paint()方法中，state如果为1，代表游戏开始，应该绘制小鸟和两根柱子，我们先画小鸟：

  1. else if (state == 1) {// 游戏开始后
  2.       //绘制小鸟和两根柱子
  3.       g.drawImage(bird.img, bird.x, bird.y, null);
  4. ​
  5.     }

运行效果：

d4ca8691b678b4949eb9025ac82f26f4.png

小鸟默认会向下掉，要考虑重力加速度。当点击鼠标的时候，会向上移动。

先在Constant提供常量：

  1. public static double GRAVITATIONAL_ACCELERATION = 9.8;
  2. public static double DOWN_TIME = 0.18; // 小鸟自然下降的时长

在小鸟Bird类中，提供一些变量：

  1. public double g = Constant.GRAVITATIONAL_ACCELERATION; // 重力加速度
  2.   public double v = 0;// 下降速度
  3.   public double t = Constant.DOWN_TIME;// 下降时间
  4.   public double h;// 下降的距离

再添加两个方法：down()表示下降

  1. // 小鸟自然下降
  2.   public void down() {
  3.     v = v - g * t; // 末速度Vt＝Vo-gt
  4.     h = v * t - g * t * t / 2; // 位移h＝Vot-gt²/2
  5.     y = y - (int) h;
  6.   }

然后修改action()方法：

  1. while (true) {
  2.       // 地面移动
  3.       ground.move(bg);
  4.       bird.fly();
  5.       if(state == 0){
  7.       }else if(state == 1){
  8.         bird.down();//小鸟下降
  9.       }else if(state == 2){
  11.       }
  13.       // 线程休眠（因为是无限循环，下一次循环开始需要一段休息时间，这样才能让程序有缓冲的执行时间）
  14.       try {
  15.         Thread.sleep(1000 / speed);// 调节游戏速度
  16.         // 重新绘制（重新调用面板paint方法）
  17.         this.repaint();
  18.       } catch (Exception e) {
  19.         e.printStackTrace();
  20.       }
  21.     }

运行结果：

029e080d9840f94382bfd106ec532767.png

当点击鼠标时，小鸟会向上飞，每次向上20。先在Constant中添加一个常量：

  1. public static double UP_SPEED = 20;// 上升的速度

在Bird中，再添加一个方法：

  1. // 上升，点鼠标或点键盘向上键
  2.   public void up() {
  3.     v = Constant.UP_SPEED;
  4.   }

修改action()，在鼠标抬起的事件中，如果state为1，那么要调用up()方法，让小鸟上升：

  1. ...
  2. public void mouseReleased(MouseEvent e) {
  3.         super.mouseReleased(e);
  4.         switch (state) {
  5.         case 0:// 游戏未开始
  6.             // 切换到状态1时的数据
  7.           state = 1;
  8.           bird.x = Constant.BIRD_FLY_POSITION_X;// 小鸟飞的初始x坐标
  9.           break;
  10. ​
  11.         case 1:// 开始游戏
  12.           // 当状态1时，小鸟点击向上移动
  13.           bird.up();
  14.           break;
  15. ...

柱子左右移动

首先在pics下放图片资源pillar.png。然后在Constant类中，添加常量：

  1. // 柱子参数
  2.   public static String PATH_PILLAR = PATH_PIC + "pillar.png";
  3.   public static int PILLAR_GAP = 144;// 柱子通道距离
  4.   public static int PILLAR_DISTANCE = 244;// 柱子间距

然后创建柱子类Pillar类：

  1. package com.ruby.demo;
  2. ​
  3. import java.awt.image.BufferedImage;
  4. import java.io.IOException;
  5. import java.util.Random;
  6. ​
  7. import javax.imageio.ImageIO;
  8. ​
  9. /**
  10.  * 柱子类 其中构造方法中需要背景对象和地面对象
  11.  * 
  12.  * @author ruby
  13.  *
  14.  */
  15. public class Pillar {
  16.   public BufferedImage img;// 图片
  17.   public int x, y;// 坐标
  18.   public int width = 0;// 柱子宽度
  19.   public int height = 0;// 柱子高度
  20.   Random random = new Random();// 一个生成随机数的对象
  21.   private int max, min = 0;// 为了保证柱子通道能够完全显示在屏幕上，所以存在柱子在Y坐标的最大值和最小值
  22. ​
  23.   public Pillar(BackGround bg, Ground ground) {
  24.     try {
  25.       img = ImageIO.read(getClass().getResource(Constant.PATH_PILLAR));
  26.       width = img.getWidth();
  27.       height = img.getHeight();
  28.       System.out.println("柱子width=" + width + ",height=" + height);
  29.       x = bg.width;
  30. ​
  31.       max = (height - Constant.PILLAR_GAP) / 2;
  32.       min = (height - Constant.PILLAR_GAP) / 2 - (bg.height - Constant.PILLAR_GAP - ground.height);
  33.       y = -(min + random.nextInt(max - min));
  34.       // System.out.println("y=" + y);
  35. ​
  36.     } catch (IOException e) {
  37.       e.printStackTrace();
  38.     }
  39.   }
  40. ​
  41. ​
  42. ​
  43. }
  44. ​

小鸟闯关的柱子，每隔244间距，就要再产生一根柱子。柱子的高度通过随机数来产生，先计算出柱子的高度：柱子图片高度-柱子通道距离114，然后除以2。柱子的最小高度，就是柱子的高度减去背景图高度-地面高度-通道距离。

柱子的y坐标，就因该是柱子的高度和柱子最小高度之间的随机数。

再添加一个移动柱子的方法：

  1. // 柱子移动，游戏一旦开始则柱子移动
  2.   public void move(BackGround bg) {
  3.     x--;
  4.     if (x == -width) {
  5.       x = bg.width;
  6.       y = -(min + random.nextInt(max - min));
  7.       // System.out.println("y=" + y);
  8.     }
  9.   }

然后修改GamePanel类，创建2个柱子对象，因为游戏界面中，最多出现2根柱子。然后再构造方法中，实例化两个柱子对象，并设置x坐标，柱子是从游戏界面右侧，移入到游戏界面上，所以第一个柱子的x值为游戏界面的宽度，第二个柱子要再加柱子间距。

  1. // 声明两个柱子，并分别设置柱子的起始X坐标
  2.     p1 = new Pillar(bg, ground);
  3.     p1.x = bg.width;
  4.     p2 = new Pillar(bg, ground);
  5.     p2.x = bg.width + Constant.PILLAR_DISTANCE;
  6. ​

修改paint()方法，游戏开始后，绘制柱子：

  1. else if (state == 1) {// 游戏开始后
  2.       // 绘制小鸟和两根柱子
  3.       g.drawImage(bird.img, bird.x, bird.y, null);
  4.       g.drawImage(p1.img, p1.x, p1.y, null);
  5.       g.drawImage(p2.img, p2.x, p2.y, null);
  6. ​
  7.     }

然后再action()的循环里，调用两个柱子的移动方法：

  1. while (true) {
  2.       // 地面移动
  3.       ground.move(bg);
  4.       bird.fly();
  5.       if (state == 0) {
  6. ​
  7.       } else if (state == 1) {
  8.         // 游戏开始。地面移动、柱子移动、小鸟飞并自然下降
  9.         bird.down();
  10.         p1.move(bg);
  11.         p2.move(bg);
  12.       } else if (state == 2) {
  14.       }
  15. ​
  16.       // 线程休眠（因为是无限循环，下一次循环开始需要一段休息时间，这样才能让程序有缓冲的执行时间）
  17.       try {
  18.         Thread.sleep(1000 / speed);// 调节游戏速度
  19.         // 重新绘制（重新调用面板paint方法）
  20.         this.repaint();
  21.       } catch (Exception e) {
  22.         e.printStackTrace();
  23.       }
  24.     }

运行结果：

5ae5ac4372b01c04cc06cbdc31f4f950.png

5、计算得分

然后在Constant类中，添加和得分相关的常量：

  1. // 得分信息的字体大小及坐标
  2.   public static int FONT_SIZE = 20;
  3.   public static int SCORE_X = 20;
  4.   public static int SCORE_Y = 40;

在GamePanel中定义score，表示分数，然后在paint()方法中，绘制分数：

  1. // 绘制文字
  2.     Font font = new Font(Font.SERIF, Font.ITALIC, Constant.FONT_SIZE);//字体，倾斜，大小
  3.     g.setFont(font);
  4.     g.setColor(Color.white);// 这里font和color导包都导java.awt
  5.     g.drawString("得分：" + score, Constant.SCORE_X, Constant.SCORE_Y);

要想统计分数，得先计算小鸟的各种碰撞，首先在小鸟的类中，添加一个是否碰撞地面的方法，其实就是检测小鸟y的值：

  1. // 碰撞检测
  2.   // 掉落到地面时
  3.   public boolean hitGround(BackGround bg, Ground ground) {
  4.     if (y + height >= (bg.height - ground.height)) {
  5.       return true;
  6.     }
  7.     return false;
  8.   }

再添加一个检测是否碰撞天空的方法，就是游戏界面的顶部：

  1. // 碰撞到舞台顶部时
  2.   public boolean hitSky() {
  3.     if (y <= 0) {
  4.       return true;
  5.     }
  6.     return false;
  7.   }

再添加一个检测碰撞柱子的方法：

  1. // 碰到柱子时的检测
  2.   public boolean hitPillar(Pillar p) {
  3.     // x方向小鸟和柱子碰撞的条件
  4.     if ((x + width) >= p.x && x <= p.x + p.width) {
  5.       if (y <= p.y + (p.height - Constant.PILLAR_GAP) / 2
  6.           || y >= p.y + (p.height + Constant.PILLAR_GAP) / 2 - height) {
  7.         return true;
  8.       }
  9.     }
  10.     return false;
  11.   }

要判断小鸟的横向上，碰撞柱子。

在小鸟类里添加一个方法：

  1. // 碰到柱子时的检测
  2.   public boolean hitPillar(Pillar p) {
  3.     // x方向小鸟和柱子碰撞的条件
  4.     if ((x + width) >= p.x && x <= p.x + p.width) {
  5.       if (y <= p.y + (p.height - Constant.PILLAR_GAP) / 2
  6.           || y >= p.y + (p.height + Constant.PILLAR_GAP) / 2 - height) {
  7.         return true;
  8.       }
  9.     }
  10.     return false;
  11.   }

再添加一个积分的方法：

  1. // 增加积分，通过柱子通道后调用该方法
  2.   public boolean addScore(Pillar p) {
  3.     // System.out.println("x=" + x + ",p.x=" + p.x);
  4.     if (x == p.x + p.width) {
  5.       return true;
  6.     }
  7.     return false;
  8.   }

然后在GamePanel类中修改action()方法：

  1. while (true) {
  2.       if (state == 0) {
  3.         // 游戏未开始。地面移动，小鸟展翅
  4.         ground.move(bg);
  5.         bird.fly();
  6.       } else if (state == 1) {
  7.         // 游戏开始。地面移动、柱子移动、小鸟飞并自然下降
  8.         ground.move(bg);
  9.         p1.move(bg);
  10.         p2.move(bg);
  11.         bird.fly();
  12.         bird.down();
  13.         // 碰到地面、天空、柱子都显示游戏结束。
  14.         if (bird.hitGround(bg, ground) || bird.hitSky() || bird.hitPillar(p1) || bird.hitPillar(p2)) {
  15.           state = 2;
  16.         } else {
  17.           // 小鸟每通过一个竹子通道，累计积分，并提高柱子和地面移动速度。
  18.           if (bird.addScore(p1) || bird.addScore(p2)) {
  19.             score++;
  20.             // 每通过一个柱子，速度会递增
  21.             speed += 2;
  22.             // System.out.println("speed=" + speed);
  23.           }
  24.         }
  25.       }

然后修改鼠标事件的监听：

  1. public void mousePressed(MouseEvent e) {
  2.         // TODO Auto-generated method stub
  3.         super.mousePressed(e);
  4.         switch (state) {
  5.         case 0:
  6.           // 切换到状态1时的数据
  7.           state = 1;
  8.           bird.x = Constant.BIRD_FLY_POSITION_X;// 小鸟飞的初始x坐标
  9.           musicThread = new MusicThread();
  10.           musicThread.start();
  12.           break;
  13.         case 1:
  14.           // 当状态1时，小鸟点击向上移动
  15.           bird.up();
  16.           break;
  17.         case 2:
  18.           // 切换到状态0时的数据
  19.           musicThread.stopBGM();
  20.           state = 0;
  21.           score = 0;
  22.           // 重置小鸟的位置
  23.           bird.x = Constant.BIRD_POSITION_X;
  24.           bird.y = Constant.BIRD_POSITION_Y;
  25.           bird.v = 0;
  26.           // 重置柱子的坐标
  27.           p1.x = bg.width;
  28.           p2.x = bg.width + Constant.PILLAR_DISTANCE;
  29.           // System.out.println("p1==" + p1 + ", p2==" + p2);
  30.           break;
  31.         default:
  32.           break;
  33.         }
  34.       }

当游戏结束的时候，要初始化小鸟和柱子的数据。

6、添加小鸟的键盘事件

在Constant中添加常量：

  1. public static int DISTANCE_PER_PRESS = 10;// 每点一次鼠标或键盘，移动的位置

然后在小鸟类中，添加键盘的上下左右事件方法：

  1. // 后退，点键盘向左键
  2.     public void backward() {
  3.       x -= Constant.DISTANCE_PER_PRESS;
  4.     }
  5. ​
  6.     // 前进，点键盘向右键
  7.     public void foward() {
  8.       x += Constant.DISTANCE_PER_PRESS;
  9.     }
  10. ​
  11.     // 点击键盘下降，点键盘向下键
  12.     public void pressdown() {
  13.       y += Constant.DISTANCE_PER_PRESS;
  14.     }

然后在action()中，添加鼠标事件监听：

  1. // 设置键盘监听事件
  2.     this.addKeyListener(new KeyAdapter() {
  3.       @Override
  4.       public void keyPressed(KeyEvent e) {
  5.         super.keyPressed(e);
  6.         switch (e.getKeyCode()) {
  7.         case KeyEvent.VK_UP:
  8.           bird.up();
  9.           break;
  10.         case KeyEvent.VK_RIGHT:
  11.           bird.foward();
  12.           break;
  13.         case KeyEvent.VK_LEFT:
  14.           bird.backward();
  15.           break;
  16.         case KeyEvent.VK_DOWN:
  17.           bird.pressdown();
  18.           break;
  19.         }
  20.       }
  21.     });

注意，最后要在GameFrame中，可以响应键盘事件：

  1. // 让该Frame中的panel聚焦，可以响应键盘事件
  2.     panel.requestFocus();

7、添加背景音乐

先准备一首背景音乐，然后在src上创建一个音乐的资源目录music，并将音乐文件拷贝进去：

然后倒入音频播放的jar包：

在Constant中添加常量：

  1. //音乐路径
  2.   public static String PATH_MUSIC = "/music/";
  4.   public static String PATH_BGM = PATH_MUSIC + "Ari_Pulkkinen-Funky_Theme.mp3";//music/Ari Pulkkinen-Funky Theme.mp3
  5. ​

然后创建一个线程类，播放音乐，再提供一个停止播放的方法：

  1. package com.ruby.demo;
  2. ​
  3. import java.io.InputStream;
  4. ​
  5. import javazoom.jl.decoder.JavaLayerException;
  6. import javazoom.jl.player.Player;
  7. ​
  8. // 播放音乐
  9. class MusicThread extends Thread {
  10.   Player player = null;
  12.   @Override
  13.   public void run() {
  14.     // 继承线程类后，重写run方法，播放音乐的代码
  15.     // 1.加载音频文件得到输入流
  16.     InputStream inputStream = this.getClass().getResourceAsStream(Constant.PATH_BGM);
  17.     try {
  18.       // 2.创建Player对象，播放音乐
  19.       player = new Player(inputStream);
  20.       player.play();
  22. ​
  23.     } catch (JavaLayerException e) {
  24.       e.printStackTrace();
  25.     }
  26.   }
  29.   public void stopBGM(){
  30.     if(player != null){
  31.       player.close();
  32.     }
  33.   }
  34. }

然后在GamePanel里创建MusicThread对象，用于播放和停止音乐，在action()中修改代码：

  1. this.addMouseListener(new MouseAdapter() {
  2.       // 点击鼠标后
  3.       @Override
  4.       public void mouseReleased(MouseEvent e) {
  5.         super.mouseReleased(e);
  6.         switch (state) {
  7.         case 0:// 游戏未开始
  8.             // 切换到状态1时的数据
  9.           state = 1;
  10.           bird.x = Constant.BIRD_FLY_POSITION_X;// 小鸟飞的初始x坐标
  11. ​
  12.           musicThread = new MusicThread();
  13.           musicThread.start();
  14.           break;
  15. ​
  16.         case 1:// 开始游戏
  17.             // 当状态1时，小鸟点击向上移动
  18.           bird.up();
  19.           break;
  20. ​
  21.         case 2:// 游戏结束
  22.             // 游戏结束后，更改状态为0，可以继续下一次游戏
  23.           musicThread.stopBGM();
  24.           state = 0;
  25. ​
  26.           score = 0;
  27.           // 重置小鸟的位置
  28.           bird.x = Constant.BIRD_POSITION_X;
  29.           bird.y = Constant.BIRD_POSITION_Y;
  30.           bird.v = 0;
  31.           // 重置柱子的坐标
  32.           p1.x = bg.width;
  33.           p2.x = bg.width + Constant.PILLAR_DISTANCE;
  34.           break;
  35. ​
  36.         default:
  37.           break;
  38.         }
  39. ​
  40.       }
  41.     });

在state为0时，开始播放音乐，当时游戏结束state为2时，停止音乐。

发表评论

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

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

相关阅读

    相关 Java飞扬的小鸟游戏

    游戏背景 这款游戏的起源是越南独立开发者开发的手机游戏，短时间竟占领了全球各大AppStore免费排行榜首位。游戏中，玩家控制一只小鸟飞过一个个柱子的间隙。飞得越远分数越

    我就是我我就是我/ 0 赞/ 103 阅读

    相关 用Unity开发Flappy Bird

    之前上过unity的选修课，学了点java。因为过一阵开发VR还是要unity基础的，于是~ 上网找了教程，找了素材。Siki的教程。 现总结下（我是菜鸟，错误的地方望大

    痛定思痛。痛定思痛。/ 0 赞/ 280 阅读

    相关 luogu1941 飞扬的小鸟

    题目 题目描述 Flappy Bird 是一款风靡一时的休闲手机游戏。玩家需要不断控制点击手机屏幕的频率来调节小鸟的飞行高度，让小鸟顺利通过画面右方的管道缝隙。如果

    以你之姓@以你之姓@/ 0 赞/ 347 阅读