日志文章

2019-12-16 aflfte2011

飞机游戏实例练习

1、利用AWT画出游戏窗口
package cn.sxt.game;
/*加载所需的外部类*/
import javax.swing.JFrame;//加载JFrame技术类用于绘制窗口
import java.awt.event.WindowAdapter;//窗口监听方法
import java.awt.event.WindowEvent;
 /*end*/
public class MyGameFrame extends JFrame {//建立主窗口类并继承JFrame类进行调用
    public void launchFrame(){//新建绘制窗口方法，设置窗口属性
        //在游戏窗口打印标题
        setTitle("尚学堂学员_程序猿作品");
        //窗口默认不可见，设为可见
        setVisible(true);
        //窗口大小：宽度500，高度500
        setSize(500, 500);
        //窗口左上角顶点的坐标位置
        setLocation(300, 300);
         
        //增加关闭窗口监听，这样用户点击右上角关闭图标，可以关闭游戏程序
        addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
    }
     
    public static void main(String[] args) {
        MyGameFrame f = new MyGameFrame();
        f.launchFrame();//调取窗口方法
    }
}
2、在窗口中绘制图形
//paint方法作用是：画出整个窗口及内部内容。被系统自动调用。
@Override
public void paint(Graphics g) {  //利用paint方法进行窗口内容的绘制
    //从坐标点(100,50)到(400,400)画出直线
    g.drawLine(100, 50, 400, 400); 
    //画出矩形。矩形左上角顶点坐标(100,50)，宽度300，高度300
    g.drawRect(100, 50, 300, 300);  
    //画出椭圆。椭圆外切矩形为：左上角顶点(100,50),宽度300，高度300
    g.drawOval(100, 50, 300, 300);  
}
3、创建图片加载工具类方便使用
package cn.sxt.game;
 
import java.awt.Image;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.net.URL;
import javax.imageio.ImageIO;
 
public class GameUtil {//新建GameUtil图片加载工具类
    // 工具类最好将构造器私有化。
    private GameUtil() {
     
    } 
 
    public static Image getImage(String path) {
        BufferedImage bi = null;
        try {
            URL u = GameUtil.class.getClassLoader().getResource(path);
            bi = ImageIO.read(u);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return bi;
    }
}
4、利用GameUtil类加载图片并在窗口中显示
//将背景图片与飞机图片定义为成员变量
    Image bgImg = GameUtil.getImage("images/bg.jpg");
    Image planeImg = GameUtil.getImage("images/plane.png");
 
    //paint方法作用是：画出整个窗口及内部内容。被系统自动调用。
    @Override
    public void paint(Graphics g) {  
        g.drawImage(bgImg, 0, 0, null);
        g.drawImage(planeImg, 200, 200, null);
    }
5、创建重画窗口PaintThread内部线程类进行窗口重画实现动画效果
class PaintThread extends Thread {
        public void run(){
            while(true){
                repaint();
                try {
                    Thread.sleep(40); //1s = 1000ms
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }   
            }
        }
    }  
}
在launchFrame窗口方法中加入线程启动代码
    new PaintThread().start();  //启动重画线程
6、利用变量值改变实现飞机的动画效果
public class MyGameFrame extends Frame {
    Image bgImg = GameUtil.getImage("images/bg.jpg");
    Image planeImg = GameUtil.getImage("images/plane.png");
    //将飞机的坐标设置为变量，初始值为（200,200）
    int planeX=200;
    int planeY=200;
     
    static int count = 0;
     
    //paint方法作用是：画出整个窗口及内部内容。被系统自动调用。
    @Override
    public void paint(Graphics g) {  
        g.drawImage(bgImg, 0, 0, null);
        System.out.println("调用paint，重画窗口，次数："+(count++));
        //不再是写死的位置
        g.drawImage(planeImg, planeX, planeY, null);
        //每次画完以后改变飞机的x坐标
        planeX +=3;
    }  
}
7、创建游戏中物体的父类GameObject方便开发中物体的定义与调用
package cn.sxt.game;
 
import java.awt.Graphics;
import java.awt.Image;
import java.awt.Rectangle;
 
public class GameObject {
    Image img; //该物体对应的图片对象
    double x,y;    //该物体的坐标
    int speed; //该物体的运行速度
    int width,height;  //该物体所在矩形区域的宽度和高度
     
    /**
     * 怎么样绘制本对象
     * @param g
     */
    public void drawMySelf(Graphics  g){
        g.drawImage(img, (int)x, (int)y, null);
    }
     //创建构造器方法
    public GameObject(Image img, double x, double y) {
        this.img = img;
        this.x = x;
        this.y = y;
        if(img!=null){
            this.width = img.getWidth(null);
            this.height = img.getHeight(null);
        }
    }
     
    public GameObject(Image img, double x, double y, int speed, int width,
            int height) {
        this.img = img;
        this.x = x;
        this.y = y;
        this.speed = speed;
        this.width = width;
        this.height = height;
    }
     
    public GameObject() {
    }
     
    /**
     * 返回物体对应矩形区域，便于后续在碰撞检测中使用
     * @return
     */
    public Rectangle getRect(){
        return  new Rectangle((int)x,(int) y, width, height);
    }  
}
8、创建游戏当中的飞机类
package cn.sxt.game;
 
import java.awt.Graphics;
import java.awt.Image;
 
public class Plane  extends GameObject {
    @Override
    public void drawMySelf(Graphics g) {
        g.drawImage(img, (int)x, (int)y, null);
        this.x +=3;//飞机水平飞，我们也可以调整x、y算法，按照我们指定的路径飞行
    }
     
    public Plane(Image img, double x, double y) {//飞机调用的构造器
        this.img=img;
       this.x=x;
        this.y=y;
        this.speed=3;//设置飞机移动的速度
        this.width=img.getWidth(null);//设置飞机宽度与图片宽度相同
        this.height=img.getHeight(null);//设置飞机高度与图片高度相同
    }
}
9、然后在窗口类当中画出飞机
public class MyGameFrame extends JFrame {
    Plane plane = new Plane(planeImg,300,300);//新建飞机构造器
    public void paint(Graphics g) {  
        plane.drawMySelf(g);    //画出飞机本身
    }  
}
10、利用键盘监听实现键盘控制飞机移动

    boolean left, up, right, down;//新建四个方向判断变量
    boolean live = true;//新建飞机是判断飞机生存变量//true表示飞机还活着；false表示飞机已经不存在了
 
    // 按下上下左右键，则改变方向值。
    // 比如：按下上键，则e.getKeyCode()的值就是VK_UP，那么置：up=true;
    public void addDirection(KeyEvent e) {
        switch (e.getKeyCode()) {
        case KeyEvent.VK_LEFT:
            left = true;
            break;
        case KeyEvent.VK_UP:
            up = true;
            break;
        case KeyEvent.VK_RIGHT:
            right = true;
            break;
        case KeyEvent.VK_DOWN:
            down = true;
            break;
        default:
            break;
        }
    }
 
    // 松开上下左右键，则改变方向值。
    // 比如：松开上键，则e.getKeyCode()的值就是VK_UP，那么置：up=false;
    public void minusDirection(KeyEvent e) {
        switch (e.getKeyCode()) {
        case KeyEvent.VK_LEFT:
            left = false;
            break;
        case KeyEvent.VK_UP:
            up = false;
            break;
        case KeyEvent.VK_RIGHT:
            right = false;
            break;
        case KeyEvent.VK_DOWN:
            down = false;
            break;
        default:
            break;
        }
    }
 
    @Override
    public void drawMySelf(Graphics g) {
        if(live){//判断飞机是不是活着
        g.drawMySelf(g);
        // 根据方向，计算飞机新的坐标
        if (left) {
            x -= speed;
        }
        if (right) {
            x += speed;
        }
        if (up) {
            y -= speed;
        }
        if (down) {
            y += speed;
        }
        }
    }
11、在MyGameFrame类当中增加键盘监听内部类
//定义为内部类，可以方便的使用外部类的普通属性
    class KeyMonitor extends KeyAdapter {
        @Override
        public void keyPressed(KeyEvent e) {
            plane.addDirection(e);
        }
 
        @Override
        public void keyReleased(KeyEvent e) {
            plane.minusDirection(e);
        }
    }
12、在窗口方法当中起动键盘监听
addKeyListener(new KeyMonitor());//启动键盘的监听
13、创建Constant窗口类定义窗口宽度和高度
public class Constant {
public static final int GAME_WIDH=500;
public static final int GAME_HEIGHT=500;
}

14、创建炮弹类Shell
package cn.sxt.game;
 
import java.awt.Color;
import java.awt.Graphics;
 
public class Shell extends GameObject {
    double degree;
     
    public Shell(){
        degree = Math.random()*Math.PI*2;
        x = 200;
        y = 200;
        width = 10;
        height = 10;
        speed = 3;
    }
     
    public void draw(Graphics g){
        //将外部传入对象g的状态保存好
        Color c = g.getColor();//保存画笔原有颜色
        g.setColor(Color.yellow);//修改画笔颜色
 
        g.fillOval((int)x, (int)y, width, height);//画出炮弹
         
        //炮弹沿着任意角度飞行
        x += speed*Math.cos(degree);
        y += speed*Math.sin(degree);
         
        //如下代码，用来实现碰到边界，炮弹反弹回来(原理和打台球游戏一样)
        if(y>Constant.GAME_HEIGHT-height||y<30){
            degree = -degree;
        }
        if(x<0||x>Constant.GAME_WIDTH-width){
            degree = Math.PI-degree;
        }
        //返回给外部，变回以前的颜色
        g.setColor(c);
    }
}
15、在窗口当中画出一个炮弹
Shell shell=new Shell();//与画飞机方法相同
16、利用数组实现画出50个炮弹
Shell[] shells=new Shell[50];//建立炮弹数组

//利用for循环在launchFrame()方法中生成50个炮弹
for(int i=0;i<shells.length;i++) {//初始化数组
shells[i]=new Shell();
}
/利用for循环在Paint方法当中画出炮弹
for(int i=0;i<shells.length;i++) {
shells[i].draw(g);
}
16、利用java提供的Rectangle类进行矩形检测判断炮弹是否击中飞机实现飞机死亡的动作
//飞机和所有炮弹对象进行矩形检测
boolean peng = b.getRect().intersects(plane.getRect());
if(peng){//如果撞到
 plane.live = false;   //飞机死掉,画面不显示
}
17、实现飞死后的爆炸动作
设计一组飞机爆炸图片并命名为e1、e2、e3......这里设计有16张图片
创建爆炸类Explode
package cn.sxt.game;
 
import java.awt.Graphics;
import java.awt.Image;
 
/*
 * 爆炸类
 */
public class Explode {
    double x,y;
    static Image[] imgs = new Image[16];//建立数组加载爆炸图片
    static {
        for(int i=0;i<16;i++){
            imgs[i] = GameUtil.getImage("images/explode/e"+(i+1)+".gif");
            imgs[i].getWidth(null);
        }
    }
     
    int count;//声明计数变量
     
    public void draw(Graphics g){//画出爆炸效果
        if(count<=15){
            g.drawImage(imgs[count], (int)x, (int)y, null);
            count++;
        }
    }
     
    public Explode(double x,double y){//声明爆炸构造器方法
        this.x = x;
        this.y = y;
    }
}
在主窗口 MyGameFrame 类声明爆炸类
Peng bao;
将爆炸类在飞机死亡时调用爆炸
if(bao==null) {
bao=new Peng(feiji.x, feiji.y);
}
bao.draw(g);
18、最后实现游戏的计时功能
//在主窗口MyGameFrame类下面声名时间变量
Date startTime = new Date();    //游戏起始时刻
Date endTime;  //游戏结束时刻
//创建文字信息打印类printInfo
public void printInfo(Graphics g,String str,int size,int x,int y,Color color){
        Color c = g.getColor();
        g.setColor(color);
        Font f = new Font("宋体",Font.BOLD,size);
        g.setFont(f);
        g.drawString(str,x,y);
        g.setColor(c);
    }  
//在飞机死亡时给结束时间进行付值再进行计算游戏玩的时间是多少
if(!plane.live){
if(endTime==null){
endTime = new Date();
}
int period = (int)((endTime.getTime()-startTime.getTime())/1000);
 printInfo(g, "时间："+period+"秒", 50, 120, 260, Color.white);
}
完整代码为：
主窗口类GameFrame.java
package com.aflfte.game;

import java.awt.Color;
import java.awt.Font;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.util.Date;

import javax.swing.JFrame;

/**
 * 飞机游戏练习项目
 *
 * @author jinhao
 *
 */
public class GameFrame extends Frame {
Date startTime=new Date();
Date endTime;
Image bg=ImageInto.getImage("images/bg.jpg");//利用工具类加载图片
Image plane=ImageInto.getImage("images/plane.png");

public void ck() {//建立调用窗口方法
setTitle("飞机游戏练习");//窗口标题设定
setVisible(true);//窗口可见设置默认为false需要设置为true才能让窗口出现
setSize(Ck.GAME_WIDH,Ck.GAME_HEIGHT);//设置窗口显示的大小参数
setLocation(100,100);//设置窗口出现的位置坐标
//设置关闭窗口的监听，当关闭窗口时关闭游戏程序运行
addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
new PaintThread().start();//启动重画线程
addKeyListener(new KeyMonitor());//给窗口加载键盘的监听

//生成50个炮弹
for(int i=0;i<shells.length;i++) {
shells[i]=new Shell();

}
}
Plane feiji=new Plane(plane,250,250);
//Shell shell=new Shell();
Shell[] shells=new Shell[50];
Peng bao;

public void paint(Graphics g) {//paint方法为画图方法可被系统直接调用；参数g相当于画笔可根据Graphics方法和参数画出图形
//g.drawLine(100, 100, 400, 300);//drawLine为线形绘制方法参数为(起始坐标X，起始坐标Y，终点坐标X，终点坐标Y)利用设置坐标画制直线
//g.drawRect(20, 120, 150, 120);//drawRect为空心距形绘制方法能参数（起始x,起始y,矩形宽度，矩形高度），
//g.drawRoundRect(100, 100, 50, 80, 20, 30);//drawRoundRect绘制圆角矩形
//g.drawRect(100, 150, 300, 400);//椭圆绘制
g.drawImage(bg, 0, 0, null);//绘制图片
feiji.drawSelf(g);//画飞机
for(int i=0;i<shells.length;i++) {
shells[i].draw(g);
boolean peng=shells[i].getRect().intersects(feiji.getRect());
if(peng==true) {
feiji.live=false;
if(bao==null) {
bao=new Peng(feiji.x, feiji.y);
}
bao.draw(g);
}
}
if(!feiji.live) {
if(endTime==null) {
endTime=new Date();
}
int period =(int)((endTime.getTime()-startTime.getTime())/1000);
printInfo(g,"游戏时间为"+period+"秒",50,120,260,Color.white);
}
//shell.draw(g);
}
class PaintThread extends Thread{//新建一个线程内部类方便使用方法
@Override
public void run() {
while(true) {//实现不断重画窗口
repaint();//重画窗口动作
try {
Thread.sleep(40);
} catch (InterruptedException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}//设定重画频率
}
}
}
class KeyMonitor extends KeyAdapter{//建立一个键盘监听的内部类

@Override
public void keyPressed(KeyEvent e) {
feiji.addDirection(e);
}

@Override
public void keyReleased(KeyEvent e) {
feiji.minusDrection(e);
}

}
public static void main(String[] args) {
GameFrame fr=new GameFrame();
fr.ck();
}
private Image offScreenImage = null;
 
public void update(Graphics g) {
    if(offScreenImage == null)
        offScreenImage = this.createImage(Ck.GAME_WIDH,Ck.GAME_HEIGHT);//这是游戏窗口的宽度和高度
     
    Graphics gOff = offScreenImage.getGraphics();
    paint(gOff);
    g.drawImage(offScreenImage, 0, 0, null);
} 
public void printInfo(Graphics g,String srt,int size,int x,int y, Color color) {
Color c=g.getColor();
g.setColor(color);
Font f=new Font("宋体",Font.BOLD,size);
g.setFont(f);
g.drawString(srt, x, y);
g.setColor(c);
}
}
窗口参数类：Ck.java
package com.aflfte.game;

public class Ck {
public static final int GAME_WIDH=500;
public static final int GAME_HEIGHT=500;
}

游戏物体父类GameObject.java
package com.aflfte.game;

import java.awt.Graphics;
import java.awt.Image;
import java.awt.Rectangle;

/**
 * 游戏物体的父类
 * @author jinhao
 *
 */
public class GameObject {
Image img;
double x,y;
int speed;
int width,height;

public void drawSelf(Graphics g) {
g.drawImage(img, (int)x, (int)y, null);
}

public GameObject(Image img, double x, double y, int speed, int width, int height) {
super();
this.img = img;
this.x = x;
this.y = y;
this.speed = speed;
this.width = width;
this.height = height;
}

public GameObject(Image img, double x, double y) {
super();
this.img = img;
this.x = x;
this.y = y;
}
public GameObject() {

}
public Rectangle getRect() {//返回物体所在的矩形，便于以后的碰撞检测
return new Rectangle((int)x,(int)y,width,height);
}
}
图片加载处理类ImageInto.java
package com.aflfte.game;
/**
 * 图片加载工具类
 */
import java.awt.Image;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.net.URL;

import javax.imageio.ImageIO;

public class ImageInto {
private ImageInto() {

}
public static Image getImage(String path) {
BufferedImage bi=null;
try {
URL u=ImageInto.class.getClassLoader().getResource(path);
bi=ImageIO.read(u);
}catch(IOException e) {
e.printStackTrace();
}
return bi;
}
}
飞机类Plane.java
package com.aflfte.game;

import java.awt.Graphics;
import java.awt.Image;
import java.awt.event.KeyEvent;

public class Plane extends GameObject {
int speed=3;
boolean left,up,right,down;
boolean live=true;

public void drawSelf(Graphics g) {
if(live) {
g.drawImage(img, (int)x, (int)y, null);
if(left) {
x-=speed;
}
if(right) {
x+=speed;
}
if(up) {
y-=speed;
}
if(down) {
y+=speed;
}
}

}
public Plane(Image img,double x,double y) {
this.img=img;
this.x=x;
this.y=y;
this.speed=3;
this.width=img.getWidth(null);
this.height=img.getHeight(null);
}
public void addDirection(KeyEvent e) {//监听键盘按下某个键增加相应的方向
switch (e.getKeyCode()) {
case KeyEvent.VK_LEFT:
left=true;
break;
case KeyEvent.VK_UP:
up=true;
break;
case KeyEvent.VK_RIGHT:
right=true;
break;
case KeyEvent.VK_DOWN:
down=true;
break;
}
}
public void minusDrection(KeyEvent e) {
switch (e.getKeyCode()) {
case KeyEvent.VK_LEFT:
left=false;
break;
case KeyEvent.VK_UP:
up=false;
break;
case KeyEvent.VK_RIGHT:
right=false;
break;
case KeyEvent.VK_DOWN:
down=false;
break;
}
}
}
炮弹类Shell.java
package com.aflfte.game;

import java.awt.Color;
import java.awt.Graphics;

public class Shell extends GameObject {//建立炮弹类
double degree;
public Shell() {
x=200;
y=200;
width=10;
height=10;
speed=3;
degree=Math.random()*Math.PI*2;//生成随机角度

}
public void draw(Graphics g) {
Color c=g.getColor();//保存默认画笔颜色
g.setColor(Color.YELLOW);//设置画笔颜色
g.fillOval((int)x, (int)y, width, height);//画出实心球形炮弹
x+=speed*Math.cos(degree);//让炮弹按任何角度飞
y+=speed*Math.sin(degree);
if(x<0||x>Ck.GAME_WIDH-width) {
degree=Math.PI-degree;
}
if(y<30||y>Ck.GAME_HEIGHT-height) {
degree=-degree;
}
g.setColor(c);
}

}
爆炸类Peng.java
package com.aflfte.game;

import java.awt.Graphics;
import java.awt.Image;

/**
 * 爆炸类
 * @author jinhao
 *
 */
public class Peng {
double x,y;
static Image[] imgs=new Image[16];
static {
for(int i=0;i<16;i++) {
imgs[i]=ImageInto.getImage("images/peng/e"+(i+1)+".gif");
imgs[i].getWidth(null);
}
}
int count;
public void draw(Graphics g) {
if(count<=15) {
g.drawImage(imgs[count], (int)x, (int)y, null);
count++;
}
}
public Peng(double x,double y) {
this.x=x;
this.y=y;
}
}

« 实现移动角度计算方法 | 数组的初始化方式»