java小游戏-飞翔的小鸟

连接视频

1 游戏窗口的显示

创建Constant类

/**
 * 常量
 */
public class Constant {
    //窗口的大小
    public static final int FRAME_WIDTH = 600;
    public static final int FRAME_HEIGHT = 500;

    //窗口的标题
    public static final String FRAME_TITLE = "飞翔的小鸟";

    //窗口的初始化位置
    public static final int FRAME_X = 200;
    public static final int FRAME_Y = 200;

}

创建GameFrame类

/**
 * 游戏的主窗口，所有的关于游戏中绘制的内容都在此类中完成。
 * 游戏开发：基本都是底层界面的绘制，而不是用jdk通过的各种组件
 */
public class GameFrame extends Frame {

    //构造方法中初始化一些参数
    public GameFrame() {
        //窗口是否可见
        setVisible(true);
        //窗口大小
        setSize(FRAME_WIDTH, FRAME_HEIGHT);
        //窗口标题
        setTitle(FRAME_TITLE);
        //窗口的初始化位置
        setLocation(FRAME_X, FRAME_Y);
        //窗口的大小不可变
        setResizable(false);

        //窗口的关闭事件
        addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(0);//结束程序
            }
        });
    }
    
}

创建GameApp类

public class GameApp {
    public static void main(String[] args) {
        new GameFrame();
    }
}

2 游戏背景添加

先把准备的图片放入项目中

在Constant类添加常量

//图片路径
public static final String BK_IMG_PATH = "birdimg/ground.png";

创建GameUtil类

/**
 * 工具类
 */
public class GameUtil {
    //加载图片
    public static BufferedImage loadBufferedImage(String imgPath){
        try {
            return ImageIO.read(new FileInputStream(imgPath));
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }
}

创建GameBackGround类

/**
 * 游戏背景类
 */
public class GameBackGround {
    //背景需要的资源图片
    private BufferedImage bkimg;

    //构造器初始化资源
    public GameBackGround(){
        bkimg = GameUtil.loadBufferedImage(Constant.BK_IMG_PATH);
    }

    //绘制图片
    public void draw(Graphics g){
        //得到图片的高度和宽度
        int height = bkimg.getHeight();
        int wight = bkimg.getWidth();
        //循环次数
        int count = Constant.FRAME_WIDTH/wight + 1;
        for (int i = 0; i < count; i++) {
            g.drawImage(bkimg,wight*i,Constant.FRAME_HEIGHT-height,null);
        }
    }
}

在GameFrame类添加方法

public class GameFrame extends Frame {

    //实例化gameBackGround类
    private GameBackGround gameBackGround;

    //构造方法中初始化一些参数
    public GameFrame() {
        ...

		//初始化游戏对象
        initGamg();

        new run().start();
    }

    //对游戏中对象初始化
    public void initGamg(){
        gameBackGround = new GameBackGround();
    }

    //创建线程
    class run extends Thread{
        @Override
        public void run() {
            repaint();
            try {
                Thread.sleep(33);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

	 /**
     * 所有我们需要绘制的内容都在此方法中进行调用绘制
     */
    @Override
    public void update(Graphics g){
        gameBackGround.draw(g);
    }

}

3 背景颜色的添加

在Constant类添加常量

//游戏背景颜色
public static final Color BK_COLOR = new Color(0x4B4CF);

在GameBackGround类draw方法添加绘制

//绘制图片
public void draw(Graphics g){
    //填充背景色
    g.setColor(BK_COLOR);
    g.fillRect(0,0,FRAME_WIDTH,FRAME_HEIGHT);
    g.setColor(Color.black);

    //得到图片的高度和宽度
    ...
}

4 屏幕中绘制小鸟

在Constant类中添加常量

//小鸟的图片资源
public static final String[] BIRD_IMG =
        {"birdimg/00.png","birdimg/01.png","birdimg/02.png"};

创建Bird类

/**
 * 小鸟类
 */
public class Bird {
    //存放小鸟图片
    private BufferedImage[] images;
    private static final int BIRD_IMG_COUNT = 3;

    //鸟的状态
    private int state;
    private static final int STATE_NORMAR = 0;//平着飞
    private static final int STATE_UP = 1;//向上飞
    private static final int STATE_DOWN = 2;//向下飞

    //构造方法中对资源初始化
    public Bird(){
        images = new BufferedImage[BIRD_IMG_COUNT];
        for (int i = 0; i < BIRD_IMG_COUNT; i++) {
            images[i] = GameUtil.loadBufferedImage(BIRD_IMG[i]);
        }
    }

    //绘制小鸟
    public void draw(Graphics g){
        g.drawImage(images[state],200,200,null);
    }

}

在GameFrame类中添加bird对象

//实例化Bird类
private Bird bird;

//对游戏中对象初始化
public void initGamg(){
    gameBackGround = new GameBackGround();
    bird = new Bird();
}

/**
 * 所有我们需要绘制的内容都在此方法中进行调用绘制
 */
@Override
public void update(Graphics g){
    gameBackGround.draw(g);
    bird.draw(g);
}

5 实现小鸟上下移动

在Bird类添加小鸟移动参数

//小鸟的位置
private int x = 200, y = 200;

//小鸟移动方向 上下
private boolean up = false, down = false;

//小鸟移动速度
private int speed = 4;
//绘制小鸟
public void draw(Graphics g) {
   flyLogic();
   g.drawImage(images[state], x, y, null);
}

//控制小鸟移动方向
public void flyLogic() {
   if (up) {
       y -= speed;
       if (y < 20) {
           y = 20;
       }
   }
   if (!up) {
       y += speed;
       if (y > 470) {
           y = 470;
       }
   }
}

public void fly(int fly) {
   switch (fly) {
       case 1:
           state = 1;
           up = true;
           break;
       case 5:
           state = 2;
           up = false;
           break;
   }
}

在GameFrame类添加小鸟移动监听事件

//构造方法中初始化一些参数
public GameFrame() {
   	...
	//初始化游戏对象
    initGamg();

    new run().start();
    //添加按键监听事件
    addKeyListener(new KeyAdapter() {
        @Override
        public void keyPressed(KeyEvent e) {
            add(e);
        }

        @Override
        public void keyReleased(KeyEvent e) {
            minu(e);
        }
    });
}

//创建线程
class Run extends Thread {
    @Override
    public void run() {
        while (true) {
            repaint();
            try {
                Thread.sleep(33);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

//按键
public void add(KeyEvent e){
    switch (e.getKeyCode()){
        case KeyEvent.VK_UP:
            bird.fly(1);
            break;
    }
}

//抬键
public void minu(KeyEvent e){
    switch (e.getKeyCode()){
        case KeyEvent.VK_UP:
            bird.fly(5);
            break;
    }
}

6 解决屏幕闪烁问题

在GameFrame类添加缓存图片对象

//存放屏幕图片
private BufferedImage buffimg = new BufferedImage(FRAME_WIDTH, FRAME_HEIGHT, BufferedImage.TYPE_4BYTE_ABGR);

/**
 * 所有我们需要绘制的内容都在此方法中进行调用绘制
 */
@Override
public void update(Graphics g) {
    //得到图片的画笔
    Graphics graphics = buffimg.getGraphics();

    gameBackGround.draw(graphics);
    bird.draw(graphics);

    //一次性的将图片绘制到屏幕中
    g.drawImage(buffimg, 0, 0, null);
}

7 云彩的添加与移动

创建Cloud类

/**
 * 云彩类
 */
public class Cloud {
    //云彩图片
    private BufferedImage img;
    //云彩的速度
    private int speed;
    //云彩的位置
    private int x,y;

    public Cloud(){
    }

    public Cloud(BufferedImage img, int speed, int x, int y) {
        this.img = img;
        this.speed = speed;
        this.x = x;
        this.y = y;
    }

    public void draw(Graphics g){
        x-=speed;
        g.drawImage(img,x,y,null);
    }
}

创建GameFrontGround类

/**
 * 游戏的前景类
 */
public class GameFrontGround {
    //云彩的个数
    private static final int CLOUD_COUNT = 2;
    //存放云彩的容器
    private List<Cloud> clouds;
    //云彩的飞行速度
    private static final int CLOUD_SPEED = 1;
    //使用到的图片资源资源
    private BufferedImage[] images;

    //构造器初始化数据
    public GameFrontGround(){
        clouds = new ArrayList<>();
        images = new BufferedImage[CLOUD_COUNT];

        //容器中添加云彩图片
        for (int i = 0; i < CLOUD_COUNT; i++) {
            images[i] = GameUtil.loadBufferedImage("birdimg/cloud" + i +".png");
        }
    }

    //绘制云彩
    public void draw(Graphics g){
        Cloud cloud = new Cloud(images[1], CLOUD_SPEED, 300, 100);
        clouds.add(cloud);

        clouds.get(0).draw(g);
    }
    
}

在GameFrame类绘制云彩

//实例化GameFrontGround类
private GameFrontGround gameFrontGround;

//对游戏中对象初始化
public void initGamg() {
    gameBackGround = new GameBackGround();
    bird = new Bird();
    gameFrontGround = new GameFrontGround();
}

@Override
public void update(Graphics g) {
    //得到图片的画笔
    Graphics graphics = buffimg.getGraphics();

    gameBackGround.draw(graphics);
    bird.draw(graphics);
    gameFrontGround.draw(graphics);

    //一次性的将图片绘制到屏幕中
    g.drawImage(buffimg, 0, 0, null);
}

8 云彩的自动生成与销毁

在GameFrontGround添加云彩随机数

//用于产生随机数
private Random random;
//构造器初始化数据
public GameFrontGround() {
    clouds = new ArrayList<>();
    images = new BufferedImage[CLOUD_COUNT];

    //容器中添加云彩图片
    for (int i = 0; i < CLOUD_COUNT; i++) {
        images[i] = GameUtil.loadBufferedImage("birdimg/cloud" + i + ".png");
    }

    random = new Random();
}

//绘制云彩
public void draw(Graphics g) {
    logic();
    for (int i = 0; i < clouds.size(); i++) {
        clouds.get(i).draw(g);
    }
}

//用于云彩个数控制
public void logic() {
    if ((500 * Math.random()) < 5) {
        Cloud cloud = new Cloud(images[random.nextInt(CLOUD_COUNT)],CLOUD_SPEED,600,random.nextInt(150));
        clouds.add(cloud);
    }
    for (int i = 0; i < clouds.size(); i++) {
        Cloud cloud = clouds.get(0);
        if (cloud.isOutFrame()) {
            clouds.remove(cloud);
            i--;
            System.out.println("云彩移除：" + cloud);
        }
    }
}

在Cloud类添加判断

//用于判断云彩是否飞出屏幕之外
public boolean isOutFrame(){
    if(x < -50){
        return true;
    }
    return false;
}

9 绘制从上向下的障碍物

在Constant类添加障碍物资源

//障碍物的图片资源
public static final String[] BARRIER_IMG_PATH =
        {"birdimg/barrier.png","birdimg/barrier_up.png","birdimg/barrier_down.png"};

创建Barrier类

/**
 * 障碍物类
 */
public class Barrier {

    //障碍物所需三个图片
    private static BufferedImage[] images;

    static {
        final int COUNT = 3;
        //类加载的时候将三个图片初始化
        images = new BufferedImage[COUNT];
        for (int i = 0; i < COUNT; i++) {
            images[i] = GameUtil.loadBufferedImage(Constant.BARRIER_IMG_PATH[i]);
        }
    }

    //位置
    private int x, y;
    //宽度和高度
    private int width, height;
    //障碍物的类型
    private int type;
    private static final int TYPE_TOP_NORMAL = 0;
    private static final int TYPE_BOTTOM_NORMAL = 2;
    private static final int TYPE_HOVER_NORMAL = 4;

    //获取障碍物的高度和宽度
    public static final int BARRIER_WIDTH = images[0].getWidth();
    public static final int BARRIER_HEIGHT = images[0].getHeight();
    public static final int BARRIER_HEAD_WIDTH = images[1].getWidth();
    public static final int BARRIER_HEAD_HEIGHT = images[1].getHeight();

    public Barrier() {
    }

    public Barrier(int x, int y, int height, int type) {
        this.x = x;
        this.y = y;
        this.width = BARRIER_WIDTH;
        this.height = height;
        this.type = type;
    }

    //根据不同的类型绘制障碍物
    public void draw(Graphics g) {
        drawToNormal(g);
    }

    //绘制从上向下障碍物
    private void drawToNormal(Graphics g) {
        //求出所需要的障碍物的块数
        int count = (height - BARRIER_HEAD_HEIGHT) / BARRIER_HEIGHT + 1;
        //for循环绘制障碍物
        for (int i = 0; i < count; i++) {
            g.drawImage(images[0], x, y + i * BARRIER_HEIGHT, null);
        }
        //绘制头
        int y = height - BARRIER_HEAD_HEIGHT;
        g.drawImage(images[2], x - (BARRIER_HEAD_WIDTH - BARRIER_WIDTH) / 2, y, null);
    }
}

创建GameBarrierLayer类

/**
 * 游戏中的障碍物层
 */
public class GameBarrierLayer {
    //存放障碍物
    private List<Barrier> barriers;

    public GameBarrierLayer(){
        barriers = new ArrayList<>();
    }

    //绘制障碍物
    public void draw(Graphics g){
        Barrier barrier = new Barrier(200, 0, 200, 0);
        barriers.add(barrier);
        barriers.get(0).draw(g);
    }
}

在GameFrame类创建GameBarrierLayer 对象

//实例化GameBarrierLayer类
private GameBarrierLayer gameBarrierLayer;

//对游戏中对象初始化
public void initGamg() {
    gameBackGround = new GameBackGround();
    bird = new Bird();
    gameFrontGround = new GameFrontGround();
    gameBarrierLayer = new GameBarrierLayer();
}

/**
 * 所有我们需要绘制的内容都在此方法中进行调用绘制
 */
@Override
public void update(Graphics g) {
    //得到图片的画笔
    Graphics graphics = buffimg.getGraphics();

    gameBackGround.draw(graphics);
    bird.draw(graphics);
    gameFrontGround.draw(graphics);
    gameBarrierLayer.draw(graphics);

    //一次性的将图片绘制到屏幕中
    g.drawImage(buffimg, 0, 0, null);
}

10 绘制从下往上的障碍物

在Barrier类添加方法

//根据不同的类型绘制障碍物
public void draw(Graphics g) {
    switch (type){
        case TYPE_TOP_NORMAL:
            drawToNormal(g);
            break;
        case TYPE_BOTTOM_NORMAL:
            drawNormalTop(g);
            break;
    }
}

//绘制从下向上的障碍物
public void drawNormalTop(Graphics g) {
    //求出所需要的障碍物的块数
    int count = height / BARRIER_HEIGHT + 1;
    //for循环绘制障碍物
    for (int i = 0; i < count; i++) {
        g.drawImage(images[0], x, Constant.FRAME_HEIGHT - i * BARRIER_HEIGHT, null);
    }
    //绘制头
    int y = Constant.FRAME_HEIGHT - height;
    g.drawImage(images[1], x - (BARRIER_HEAD_WIDTH - BARRIER_WIDTH) / 2, y, null);
}

在GameBarrierLayer类修改draw方法

//绘制障碍物
public void draw(Graphics g){
    Barrier barrier = new Barrier(200, 0, 200, 0);
    barriers.add(barrier);
    barriers.get(0).draw(g);
    Barrier barrier1 = new Barrier(300, 0, 300, 2);
    barriers.add(barrier1);
    barriers.get(1).draw(g);
}

11 障碍物的自动生成

在GameBarrierLayer添加障碍物的自动生成

private Random random = new Random();

//绘制障碍物
public void draw(Graphics g){
    for (int i = 0; i < barriers.size(); i++) {
        Barrier barrier = barriers.get(i);
        barrier.draw(g);
    }
    logic();
}

public void logic(){
    if(barriers.size() == 0){
        ran();
        Barrier top = new Barrier(600,0,numberTop,0);
        barriers.add(top);
        Barrier down = new Barrier(600,500-numberDown,numberDown,2);
        barriers.add(down);
    }else {
        //判断最后一个障碍物是否完全进入屏幕内
        Barrier last = barriers.get(barriers.size() - 1);
        if(last.isInFrame()){
            ran();
            Barrier top = new Barrier(600,0,numberTop,0);
            barriers.add(top);
            Barrier down = new Barrier(600,500-numberDown,numberDown,2);
            barriers.add(down);
        }
    }
}

//上方障碍物高度
private int numberTop;
//下方障碍物高度
private int numberDown;
//产生两个100-500之间的随机高度
public void ran(){
    numberTop = random.nextInt(400) + 100;
    numberDown = random.nextInt(400) + 100;
    //如果管道重合，则重新随机
    if(numberTop + numberDown > 450){
        ran();
    }

}

在Barrier类添加判断

//障碍物移动速度
private int speed = 3;

//绘制从上向下障碍物
private void drawToNormal(Graphics g) {
    //求出所需要的障碍物的块数
    int count = (height - BARRIER_HEAD_HEIGHT) / BARRIER_HEIGHT + 1;
    //for循环绘制障碍物
    for (int i = 0; i < count; i++) {
        g.drawImage(images[0], x, y + i * BARRIER_HEIGHT, null);
    }
    //绘制头
    int y = height - BARRIER_HEAD_HEIGHT;
    g.drawImage(images[2], x - (BARRIER_HEAD_WIDTH - BARRIER_WIDTH) / 2, y, null);
    x-=speed;
}

//绘制从下向上的障碍物
public void drawNormalTop(Graphics g) {
    //求出所需要的障碍物的块数
    int count = height / BARRIER_HEIGHT + 1;
    //for循环绘制障碍物
    for (int i = 0; i < count; i++) {
        g.drawImage(images[0], x, Constant.FRAME_HEIGHT - i * BARRIER_HEIGHT, null);
    }
    //绘制头
    int y = Constant.FRAME_HEIGHT - height;
    g.drawImage(images[1], x - (BARRIER_HEAD_WIDTH - BARRIER_WIDTH) / 2, y, null);
    x-=speed;
}

//判断什么时候绘制下一组障碍物
public boolean isInFrame(){
    return 600-x>150;
}

12 障碍物对象池

创建BarrierPool对象

/**
 * 为了避免反复创建和销毁对象，使用对象池来提前创建一些好的对象。
 * 使用的时候从池子中获取，使用完毕后，归还
 */
public class BarrierPool {
    //用于管理池中所有对象的容器
    private static List<Barrier> pool = new ArrayList<>();
    //池中初始化的对象个数
    public static final int initCount = 16;
    //对象池中最大数
    public static final int maxCount = 20;

    static {
        //初始化池中对象
        for (int i = 0; i < initCount; i++) {
            pool.add(new Barrier());
        }
    }

    //从池中获取一个对象
    public static Barrier getPool(){
        int size = pool.size();
        //如果池中有对象才可以拿
        if(size > 0){
            //移除数据
            System.out.println("拿走一个");
            return pool.remove(size-1);
        }else {
            //池中没有对象 只能new
            System.out.println("新的对象");
            return new Barrier();
        }
    }

    //将对象归还容器中
    public static void setPool(Barrier barrier){
        if(pool.size() < maxCount){
            pool.add(barrier);
            System.out.println("容器归还了");
        }
    }
}

在Barrier类添加get和set方法

public int getX() { return x; }
public void setX(int x) { this.x = x; }
public int getY() { return y; }
public void setY(int y) { this.y = y; }
public int getHeight() { return height; }
public void setHeight(int height) { this.height = height; }
public int getType() { return type; }
public void setType(int type) { this.type = type; }

在GameBarrierLayer类添加对象池方法

public void logic(){
   if(barriers.size() == 0){
       ran();
//            Barrier top = new Barrier(600,0,numberTop,0);
//            barriers.add(top);
//            Barrier down = new Barrier(600,500-numberDown,numberDown,2);
//            barriers.add(down);
       insert(600,0,numberTop,0);
       insert(600,500-numberDown,numberDown,2);
   }else {
       //判断最后一个障碍物是否完全进入屏幕内
       Barrier last = barriers.get(barriers.size() - 1);
       if(last.isInFrame()){
           ran();
//                Barrier top = new Barrier(600,0,numberTop,0);
//                barriers.add(top);
//                Barrier down = new Barrier(600,500-numberDown,numberDown,2);
//                barriers.add(down);
           insert(600,0,numberTop,0);
           insert(600,500-numberDown,numberDown,2);
       }
   }
}
    
//用于从池中获取对象，并把参数封装成barrier，存入barriers数组中
public void insert(int x,int y,int height,int type){
    Barrier pool = BarrierPool.getPool();
    pool.setX(x);
    pool.setY(y);
    pool.setHeight(height);
    pool.setType(type);
    barriers.add(pool);
}

13 障碍物归还对象池

在Barrier类添加存活判断

//障碍物存活状态
private boolean visible;

//绘制从上向下障碍物
private void drawToNormal(Graphics g) {
	....
    x-=speed;
    if(x < -50){
        visible = false;
    }
}

//绘制从下向上的障碍物
private void drawNormalTop(Graphics g) {
	....
    x-=speed;
    if(x < -50){
        visible = false;
    }
}
public boolean isVisible() { return visible; }
public void setVisible(boolean visible) { this.visible = visible; }

在GameBarrierLayer类设置存活状态

//绘制障碍物
public void draw(Graphics g){
    for (int i = 0; i < barriers.size(); i++) {
        Barrier barrier = barriers.get(i);
        if (barrier.isVisible()) {
            barrier.draw(g);
        }else {
            Barrier remove = barriers.remove(i);
            BarrierPool.setPool(remove);
            i--;
        }
    }
    logic();
}

//用于从池中获取对象，并把参数封装成barrier，存入barriers数组中
public void insert(int x,int y,int height,int type){
    Barrier pool = BarrierPool.getPool();
    pool.setX(x);
    pool.setY(y);
    pool.setHeight(height);
    pool.setType(type);
    pool.setVisible(true);
    barriers.add(pool);
}

14 判断小鸟与障碍物发生碰撞

在Bird类添加矩形对象

//小鸟矩形对象
private Rectangle rect;

//构造方法中对资源初始化
public Bird() {
    images = new BufferedImage[BIRD_IMG_COUNT];
    for (int i = 0; i < BIRD_IMG_COUNT; i++) {
        images[i] = GameUtil.loadBufferedImage(BIRD_IMG[i]);
    }
    int w = images[0].getWidth();
    int h = images[0].getHeight();
    rect = new Rectangle(w,h);
}

//绘制小鸟
public void draw(Graphics g) {
    flyLogic();
    g.drawImage(images[state], x, y, null);
    //绘制小鸟的矩形
    g.drawRect(x,y,(int)rect.getWidth(),(int)rect.getHeight());
    rect.x = this.x;
    rect.y = this.y;
}

public Rectangle getRect() {
    return rect;
}

在Barrier类添加矩形对象

//矩形参数
private Rectangle rect;

public Barrier() {
    rect = new Rectangle();
}

//绘制从上向下障碍物
private void drawToNormal(Graphics g) {
    ...
    rect(g);
}

//绘制从下向上的障碍物
public void drawNormalTop(Graphics g) {
   ...
    rect(g);
}

//绘制障碍物碰撞矩形
public void rect(Graphics g){
    int x1 = this.x;
    int y1 = this.y;
    int w1 = images[0].getWidth();
    g.setColor(Color.blue);
    g.drawRect(x1,y1,w1,height);
    setRecyangle(x1,y1,w1,height);
}

//障碍物的碰撞矩形参数
public void setRecyangle(int x,int y,int width,int height){
    rect.x = x;
    rect.y = y;
    rect.width = width;
    rect.height = height;
}

public Rectangle getRect() {
    return rect;
}

在GameBarrierLayer类添加碰撞判断

//绘制障碍物
public void draw(Graphics g,Bird bird){
    for (int i = 0; i < barriers.size(); i++) {
        Barrier barrier = barriers.get(i);
        if (barrier.isVisible()) {
            barrier.draw(g);
        }else {
            Barrier remove = barriers.remove(i);
            BarrierPool.setPool(remove);
            i--;
        }
    }
    collideBird(bird);
    logic();
}

//判断障碍物和小鸟发生碰撞
public boolean collideBird(Bird bird){
    for (int i = 0; i < barriers.size(); i++) {
        Barrier barrier = barriers.get(i);
        //判断是否相交
        if(barrier.getRect().intersects(bird.getRect())){
            System.out.println("碰撞上了");
        }
    }
    return false;
}

在GameFrame 类修改update方法

public void update(Graphics g) {
    //得到图片的画笔
    Graphics graphics = buffimg.getGraphics();

    gameBackGround.draw(graphics);
    bird.draw(graphics);
    gameFrontGround.draw(graphics);
    gameBarrierLayer.draw(graphics,bird);

    //一次性的将图片绘制到屏幕中
    g.drawImage(buffimg, 0, 0, null);
}

15 小鸟与碰撞物碰撞后处理

在Bird类添加小鸟状态

//小鸟的生命
public boolean life = true;

在GameBarrierLayer类修改collideBird方法

//判断障碍物和小鸟发生碰撞
public boolean collideBird(Bird bird){
    for (int i = 0; i < barriers.size(); i++) {
        Barrier barrier = barriers.get(i);
        //判断是否相交
        if(barrier.getRect().intersects(bird.getRect())){
            System.out.println("碰撞上了");
            bird.life = false;
        }
    }
    return false;
}

在GameFrame 类修改update方法

/**
 * 所有我们需要绘制的内容都在此方法中进行调用绘制
 */
@Override
public void update(Graphics g) {
    if (bird.life) {
        //得到图片的画笔
        Graphics graphics = buffimg.getGraphics();

        gameBackGround.draw(graphics);
        bird.draw(graphics);
        gameFrontGround.draw(graphics);
        gameBarrierLayer.draw(graphics,bird);

        //一次性的将图片绘制到屏幕中
        g.drawImage(buffimg, 0, 0, null);
    }else {
        String over = "游戏结束";
        g.setColor(Color.red);
        g.setFont(new Font("微软雅黑",1,60));
        g.drawString(over,300,250);
    }
}

16 计时器

创建GameTime类

/**
 * 游戏计时
 */
public class GameTime {
    //开始
    private long beginTime;
    //结束
    private long endTime;
    //时间差
    private long differ;

    public GameTime(){}

    //开始计时
    public void begin(){
        beginTime = System.currentTimeMillis();
    }

    //计算时间差
    public long differ(){
        endTime = System.currentTimeMillis();
        return differ = (endTime-beginTime) / 1000;
    }

}

在GameBarrierLayer类引用计时对象

private GameTime gameTime;

public GameBarrierLayer(){
    barriers = new ArrayList<>();
    gameTime = new GameTime();
}

 //绘制障碍物
public void draw(Graphics g,Bird bird){
    ....
    logic(g);
}

public void logic(Graphics g){
    if(barriers.size() == 0){
        ran();
        gameTime.begin();
        insert(600,0,numberTop,0);
        insert(600,500-numberDown,numberDown,2);
    }else {
        long differ = gameTime.differ();
        g.setColor(Color.white);
        g.setFont(new Font("微软雅黑",1,20));
        g.drawString("您坚持了：" + differ+"秒",20,50);
        //判断最后一个障碍物是否完全进入屏幕内
        Barrier last = barriers.get(barriers.size() - 1);
        if(last.isInFrame()){
            ran();
            insert(600,0,numberTop,0);
            insert(600,500-numberDown,numberDown,2);
        }
    }
}

17 添加障碍物

在GameBarrierLayer添加中间障碍物

//中间障碍物
private int number;

public void ran(){
    number = random.nextInt(500);
    ...
}

public void logic(Graphics g){
    if(barriers.size() == 0){
        ran();
        gameTime.begin();
        insert(600,0,numberTop,0);
        insert(600,500-numberDown,numberDown,2);
    }else {
        long differ = gameTime.differ();
        g.setColor(Color.white);
        g.setFont(new Font("微软雅黑",1,20));
        g.drawString("您坚持了：" + differ+"秒",20,50);
        //判断最后一个障碍物是否完全进入屏幕内
        Barrier last = barriers.get(barriers.size() - 1);
        if(last.isInFrame()){
            ran();
            if (number < 50) {
                insert(600,32,440,4);
            }else if (number > 450){
                insert(600,125,200,6);
            }else {
                insert(600,0,numberTop,0);
                insert(600,500-numberDown,numberDown,2);
            }
        }
    }
}

在Barrier类添加绘制中间障碍物和移动障碍物

private static final int TYPE_MOBILE = 6;

private boolean mob = true;

//根据不同的类型绘制障碍物
public void draw(Graphics g) {
    switch (type){
        case TYPE_TOP_NORMAL:
            drawToNormal(g);
            break;
        case TYPE_BOTTOM_NORMAL:
            drawNormalTop(g);
            break;
        case TYPE_HOVER_NORMAL:
            drawHoverNormal(g);
            break;
        case TYPE_MOBILE:
            drawMobile(g);
            break;
    }
}

//绘制中间的障碍物
public void drawHoverNormal(Graphics g) {
    //求出所需要的障碍物的块数
    int count = (height - BARRIER_HEAD_HEIGHT)/ BARRIER_HEIGHT;
    //绘制上头
    g.drawImage(images[1],x,y,null);
    //for循环绘制障碍物
    for (int i = 0; i < count; i++) {
        g.drawImage(images[0], x, y+BARRIER_HEAD_HEIGHT+i*BARRIER_HEIGHT, null);
    }
    rect(g);

    //绘制下头
    int y1 = y+height-BARRIER_HEAD_HEIGHT;
    g.drawImage(images[2], x, y1, null);

    x-=speed;
    if(x < -50){
        visible = false;
    }
}

//绘制移动的障碍物
public void drawMobile(Graphics g) {
    //求出所需要的障碍物的块数
    int count = (height - BARRIER_HEAD_HEIGHT)/ BARRIER_HEIGHT;
    //绘制上头
    g.drawImage(images[1],x,y,null);
    //for循环绘制障碍物
    for (int i = 0; i < count; i++) {
        g.drawImage(images[0], x, y+BARRIER_HEAD_HEIGHT+i*BARRIER_HEIGHT, null);
    }
    rect(g);

    //绘制下头
    int y1 = y+height-BARRIER_HEAD_HEIGHT;
    g.drawImage(images[2], x, y1, null);
    x-=speed;
    if(x < -50){
        visible = false;
    }

    if(mob){
        y+=5;
        if(y >= 250){
            mob = false;
        }
    }else if(!mob){
        y-=5;
        if(y <= 100){
            mob = true;
        }
    }
}

18 按下空格键查询开始游戏

在GameBarrierLayer类添加方法

//用于清空障碍物的池子
public void restant(){
    barriers.clear();
}

在Bird类添加方法

//重新绘制小鸟的位置
public void restartDraw(){
    life = true;
    x = 200;
    y = 200;
}

在GameFrame类添加按键事件

@Override
public void update(Graphics g) {
    if (bird.life) {
        //得到图片的画笔
        Graphics graphics = buffimg.getGraphics();

        gameBackGround.draw(graphics);
        bird.draw(graphics);
        gameFrontGround.draw(graphics);
        gameBarrierLayer.draw(graphics,bird);

        //一次性的将图片绘制到屏幕中
        g.drawImage(buffimg, 0, 0, null);
    }else {
        String over = "游戏结束";
        g.setColor(Color.red);
        g.setFont(new Font("微软雅黑",1,60));
        g.drawString(over,300,250);

        String reset = "Space Reset Game";
        g.drawString(reset,25,350);
    }
}

//按键
public void add(KeyEvent e) {
    switch (e.getKeyCode()) {
        case KeyEvent.VK_UP:
            bird.fly(1);
            break;
        case KeyEvent.VK_SPACE:
            if (bird.life == false) {
                restart();
            }
            break;
    }
}

//重置游戏
public void restart(){
    gameBarrierLayer.restant();
    bird.restartDraw();
}

19 记录持久化

先创建一个txt文件，然后写入一条数据

在GameBarrierLayer类创建文件对象

//存储飞行时间
private int txt;

File file = new File("birdimg/bird.txt");
//用于得到文件中数据
public int getTxt(){
    try {
        BufferedReader in = new BufferedReader(new FileReader(file));
        int read = Integer.parseInt(in.readLine());
        in.close();
        return read;
    } catch (IOException e) {
        e.printStackTrace();
    }
    return 0;
}

//用于存储数据
public void setTxt(String str){
    try {
        FileWriter writer = new FileWriter(file);
        writer.write(str);
        writer.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

public void logic(Graphics g){
   if(barriers.size() == 0){
        ran();
        gameTime.begin();
        insert(600,0,numberTop,0);
        insert(600,500-numberDown,numberDown,2);
    }else {
        long differ = gameTime.differ();
        g.setColor(Color.white);
        g.setFont(new Font("微软雅黑",1,20));
        g.drawString("您坚持了：" + differ+"秒",20,50);

        txt = getTxt();
        if(differ <= txt){
            g.drawString("最高成绩：" + txt,200,50);
        }else {
            setTxt(differ+"");
            g.drawString("最高成绩：" + getTxt(),200,50);
        }

        //判断最后一个障碍物是否完全进入屏幕内
        Barrier last = barriers.get(barriers.size() - 1);
        if(last.isInFrame()){
            ran();
            if (number < 50) {
                insert(600,32,440,4);
            }else if (number > 450){
                insert(600,125,200,6);
            }else {
                insert(600,0,numberTop,0);
                insert(600,500-numberDown,numberDown,2);
            }

        }
    }
}

20 游戏优化

在Bird类修改

//小鸟加速度
private int acceleration;

//绘制小鸟
public void draw(Graphics g) {
    flyLogic();
    g.drawImage(images[state], x, y, null);
    //绘制小鸟的矩形
   // g.drawRect(x,y,(int)rect.getWidth(),(int)rect.getHeight());
    rect.x = this.x;
    rect.y = this.y;
}

//控制小鸟移动方向
public void flyLogic() {
    if (up) {
        acceleration--;
        y+=acceleration;
        if(acceleration < -10){
            acceleration = -10;
        }
        if (y < 20) {
            y = 20;
            acceleration = 0;
        }
    }
    if (!up) {
        acceleration++;
        y+=acceleration;
        if(acceleration > 10){
            acceleration=10;
        }
        if (y > 470) {
            y = 470;
            acceleration = 0;
        }
    }
}

在Barrier类修改

//绘制障碍物碰撞矩形
public void rect(Graphics g){
    int x1 = this.x;
    int y1 = this.y;
    int w1 = images[0].getWidth();
//        g.setColor(Color.blue);
//        g.drawRect(x1,y1,w1,height);
    setRecyangle(x1,y1,w1,height);
}