300集飞机小游戏

相关要点：

paint函数中的Graphics g的使用

Color c=g.getColor(); //保存当前画笔的颜色
		Font f=g.getFont();//保存当前的字体
		g.drawRect(100, 100, 100, 100);
		g.setColor(Color.green);//修改画笔的颜色
		g.setFont(new Font("宋体",Font.BOLD,50));//修改画笔的字体
		g.drawString("lsy", 300, 300);
		g.fillOval(200, 200, 100, 100);
		g.drawImage(ball, 10, 0, null);

屏幕闪屏问题
关于awt.Frame中的双缓冲问题，可以添加相应的类进行解决
在swing.JFrame 中自动解决了这个问题，所以使用swing.JFrame会使出现屏幕闪烁的问题更小，
但是仍然会出现屏幕闪烁的问题
可以利用双缓冲解决屏幕闪烁的问题——矩形检测原理。
加入一个类即可；

private Image offScreenImage=null;
	public void update(Graphics g) {
		if(offScreenImage==null) {
			offScreenImage=this.createImage(Constant.GAME_WIDTH,Constant.GAME_HEIGHT);//游戏窗口的高度和宽度
		}
		Graphics gOff=offScreenImage.getGraphics();
		paint(gOff);
		g.drawImage(offScreenImage, 0, 0, null);
	}
	

键盘的控制机制：

定义一个内部类，键盘监听类。
在KeyEvent中可以获得虚拟键盘的值：用来判断按键的内容，通过按键对飞机进行移动。

KeyEvent.VK_LEFT
KeyEvent.VK_LEFT
KeyEvent.VK_RIGHT
KeyEvent.VK_DOWN
图片数组的轮播效应：

设置一个数组，存放一组图片，实现图片的轮播效应。

在项目中建立一个包，然候新建一个images文件夹，用来存放图片，在该包下依次建立各个类。

1.游戏的主窗口：

package PlaneGame;
import java.awt.*;
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;
/**
 * 
 * paint函数的使用：
 * 
 * Color c=g.getColor(); //保存当前画笔的颜色
		Font f=g.getFont();//保存当前的字体
		g.drawRect(100, 100, 100, 100);
		g.setColor(Color.green);//修改画笔的颜色
		g.setFont(new Font("宋体",Font.BOLD,50));//修改画笔的字体
		g.drawString("lsy", 300, 300);
		g.fillOval(200, 200, 100, 100);
		g.drawImage(ball, 10, 0, null);
 * 
 * 关于awt.Frame中的双缓冲问题，可以添加相应的类进行解决
 * 在swing.JFrame 中自动解决了这个问题，所以使用swing.JFrame会使出现屏幕闪烁的问题更小，
 * 但是仍然会出现屏幕闪烁的问题
 * 
 * 可以利用双缓冲解决屏幕闪烁的问题——矩形检测原理。
 * 加入一个类即可；
 * 
 * 
 * 键盘的控制机制：
 * 
 * 图片数组的轮播效应：
 * 
 * @author lsy
 *
 */
public class MyGameFrame extends Frame{
	private int images;
	Image plane=GameUtil.getImage("images/plane.png");
	Image bg=GameUtil.getImage("images/ground.jpg");
	public static final  int GAME_WIDTH=800;
	public static final  int GAME_HEIGHT=800;
	
	public static void main(String[] args) {
		MyGameFrame f=new MyGameFrame();
		f.launchFrame();
	}
	
	
	//int plane_x=250;
	//int plane_y=600;
	
	
	//改为飞机的对象
	Plane p1=new Plane(plane,250,600);
	
	//创建炮弹对象,利用数组创建一堆的炮弹
	Shell[] shells=new Shell[50];
	
	Explorer bao;//先申明
	
	
	Date startTime=new Date();//游戏的起始时间
	Date endTime;//游戏的结束时间
	int period;
	
	//初始化窗口
	public void launchFrame(){
		this.setTitle("lsy");
		this.setVisible(true);
		this.setSize(GAME_WIDTH, GAME_HEIGHT);
		this.setLocation(400, 200);
		
		
		
		//监听事件，关闭窗口
		this.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();
		}
	}
	
	
	
	//paint方法是在窗口上画图，自动调用，g相当于一只画笔
	public void paint(Graphics g) {
		
		
		Color c=g.getColor();
		Font f=g.getFont();
		
		
		//加载背景图片
		g.drawImage(bg, 0, 0, null);
		
		
		//传入画笔，画飞机
		p1.drawSelf(g);
		
		
		//画炮弹
		//每画一次炮弹，检测一下是否与飞机相撞
		for(int i=0;i<shells.length;i++){
			//shells[i]=new Shell();
			shells[i].draw(g);
			
			boolean peng=shells[i].getRect().intersects(p1.getRect());
			if(peng) {
				//System.out.println("相撞了");
				//让飞机死掉。
				p1.live=false;
				if(bao==null) {//生成一次爆炸，如果不加if的话，就会一直是一张小图片。
					//因为炮弹是需要经过飞机，所以只需要生成一次的bao对象。
					bao=new Explorer(p1.x,p1.y);
					endTime=new Date();
					period=(int)((endTime.getTime()-startTime.getTime())/1000);
				}
				
				bao.draw(g);
				
				
			}
			
			if(!p1.live)
			{
				g.setFont(new Font("宋体",Font.BOLD,50));
				g.setColor(Color.green);
				g.drawString("时间："+period+"秒", (int)p1.x, (int)p1.y);
			}
			
		}
		
		
		
		g.setColor(c);
		g.setFont(f);
		
	}
	
	
	
	
	//定义一个内部类，键盘监听类；
	class  KeyMonitor extends KeyAdapter{

		@Override
		public void keyPressed(KeyEvent e) {//按下键的事件
			// TODO Auto-generated method stub
			p1.addDirection(e);
			
		}

		@Override
		public void keyReleased(KeyEvent e) {//释放键的事件
			// TODO Auto-generated method stub
			p1.minusDirection(e);
		}
		
	}
	
	
	
	
	//定义一个内部类，可以使用本类中的属性和方法
	//帮助我们重复的画窗口
	class PaintThread extends Thread{
		public void run() {
			while(true)
			{
				//System.out.println("窗口被重画一次");
				repaint();//重画方法
				try {
					Thread.sleep(40);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}//一秒画25次
			}
		}
	}
	
	
	
	//双缓冲解决屏幕闪烁的问题

	private Image offScreenImage=null;
	public void update(Graphics g) {
		if(offScreenImage==null) {
			offScreenImage=this.createImage(GAME_WIDTH,GAME_HEIGHT);//游戏窗口的高度和宽度
		}
		Graphics gOff=offScreenImage.getGraphics();
		paint(gOff);
		g.drawImage(offScreenImage, 0, 0, null);
	}
}

2.在java写一个基本物体类，作为游戏中物体的基类。

package PlaneGame;

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;
	
	//画物体本身
	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() {
		super();
	}
	
	//返回物体所在的矩形，便于后序的碰撞检测。
	//定义一个方法返回矩形类型，因为在java中所有的物体被认为是一个矩形
	public Rectangle getRect() {
		return new Rectangle((int)x,(int)y,width,height);
	}
	
	
	
}

3.工具辅助类，用于图片的加载：

package PlaneGame;

import java.awt.Image;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.net.URL;

import javax.imageio.ImageIO;

//工具类一般是私有的，
//指定路径的图片对象

public class 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.定义飞机类

package PlaneGame;

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

//将飞机对象封装在一个类中，更加方便使用

public class Plane extends GameObject{
	
	
	
	boolean left,right,up,down;//表示飞机的方向
	int speed=3;//即飞机移动的速度。
	
	public Plane(Image img,double x,double y) {
		this.img=img;
		this.x=x;
		this.y=y;
		this.width=img.getWidth(null);
		this.height=img.getHeight(null);
	}
	
	//飞机类画自己
	
	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;
			}
		}
		else
		{
			
		}
	}
	
	
	//按下键盘时，增加飞机的方向
	public void addDirection(KeyEvent e) {
		switch(e.getKeyCode()) {
		case(KeyEvent.VK_LEFT)://表示的虚拟键盘37
			left=true;
			break;
		case(KeyEvent.VK_UP)://38
			up=true;
			break;	
		case(KeyEvent.VK_RIGHT)://39
			right=true;
			break;
		case(KeyEvent.VK_DOWN)://40
			down=true;
			break;
		default:
			break;
		}
	}
	
	
	
	
	//抬起键盘时，取消增加飞机的方向
		public void minusDirection(KeyEvent e) {
			switch(e.getKeyCode()) {
			case(KeyEvent.VK_LEFT)://表示的虚拟键盘37
				left=false;
				break;
			case(KeyEvent.VK_UP)://38
				up=false;
				break;	
			case(KeyEvent.VK_RIGHT)://39
				right=false;
				break;
			case(KeyEvent.VK_DOWN)://40
				down=false;
				break;
			default:
				break;
			}
		}
	
	
	
	
	
}

5.定义炮弹类：以一个随机的方向生成50个炮弹，碰到边界即发生反弹。
关于炮弹在移动过程中的数学原理：

package PlaneGame;

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=10;
		degree=Math.random()*Math.PI*2;//表示的是生成0-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>MyGameFrame.GAME_WIDTH-30)//左右边界
		{
			degree=Math.PI-degree;
		}
		if(y<40||y>MyGameFrame.GAME_HEIGHT-10)//左右边界
		{
			degree=-degree;
		}
		g.setColor(c);
	}
}

6.炮炸时图片的轮播：

package PlaneGame;

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


//爆炸类，实现图片的轮播

public class Explorer {
	double x,y;//爆炸的位置
	static Image[] imgs=new Image[5];//将图片设置为static，只需要将图片加载一次即可。
	//静态初始化块
	static {
		for(int i=0;i<imgs.length;i++) {
			imgs[i]=GameUtil.getImage("images/explode/e"+(i+6)+".gif");
			imgs[i].getWidth(null);
		}
	}
	int count=0;
	public void draw(Graphics g) {
		if(count<=4) {
			g.drawImage(imgs[count], (int)x,(int)y, null);
			count++;
		}
	}
	public Explorer(double x,double y) {
		this.x=x;
		this.y=y;
		
	}
	
}