Java第十一课——多线程实现飞机大战

Java第十一课——多线程实现飞机大战

一、补充讲解一下线程

在第九课的基础上补充两点:
1、启动线程使用start()方法而不直接使用rin()方法,因为线程是一直重复执行的,调用run方法只会执行一次,所以用start方法启动线程
2、当小球跑的很远,跑出窗体时,便可以把小球移出去,用remove()方法

list.remove(ball)

可以给小球加入一个getX()方法获取小球的x坐标,当x大于窗体长度时移除。因为小球是放在队列里面的,所以队列里可能有很多小球,那么可以用遍历的方式获取到要移除的小球在队列里的位置。值得一提的是:先放进去的小球在队列的前面,就像排队一样

for (int i = listmybullet.size() - 1; i > 0; i--){
	Ball b = list.get(i);
	if (b.getX() > frame.getWidth()){
		list.remove(i);
	}
}

二、飞机大战的实现思路

在完成飞机大战之前先明确要什么组件?或者说飞机大战有什么对象:需要有一个背景,自己的飞机,敌机,子弹,道具,Boss等等。还可能需要哪些方法?移动的方法,绘制图片的方法,获取坐标的方法(用于判断碰撞),碰撞了怎么处理的方法…
不难发现,几乎所有的对象都要用到以上的方法,于是可以写一个接口,包含以上所有方法,让所有组件的类连到这个接口就可以了
然后就确定哪些可以利用线程来更方便的实现。举个例子,我机只有一架,那实现的时候就只要创建一个对象,写他的移动方法和绘制方法就好了。但我机的子弹,假设是每过1秒自动发射1颗子弹,那么就可以利用第九节课讲的:利用队列实现,每过一秒给队列放进一个小球,最后启动。
另外,之前讲过的Timer和TimerTask可以用来实现一些比较简单的线程。举个例子:敌军飞机出现的数量会受到Boss的影响,Boss出现后肯定要减少敌机出现的数量。而道具,道具的出现与场上的情况没有什么联系,而且道具也是可以重复出现的。那么道具就可以用Timer来实现

三、飞机大战的具体实现

1、先创建一个接口:Entity,并在里面写所需要的方法

public interface Entity {
	public void move();

	public void draw(Graphics g);

	public int getX();

	public void getY();

	public void hit(int i);
}

这里的hit方法里的形参 i 是用于移除列队的。当子弹撞击后,获取到这个子弹在队列里的位置,然后用remove方法,敌机也是同理。
2、窗体
移动飞机的方式一般用键盘,所以我在这里我就和监听器就放在一起写了

public class Frame implements KeyListener {
	public void UI(){
		JFrame frame=new JFrame();
		frame.setSize(500, 1000);
		
		frame.setVisible(true);
		Graphics g=frame.getGraphics();
		
		frame.addKeyListener(this);
	}
	
	public static void main(String[] args) {
		new Frame().UI();
	}
	
	public void keyPressed(KeyEvent e) {
		int code = e.getKeyCode();
		//获取到按下的按钮后传给我机的move()
	}
	
	public void keyTyped(KeyEvent e) {}
	
	public void keyReleased(KeyEvent e) {}
}

这个窗体只是一个小框架,还缺了很多东西(启动线程),等创建好每个类后再回来修改
在窗体上有个很重要的东西:缓存。有了缓存画布之后就不会卡顿了,不然对象太多会非常卡
在UI()方法里:

public void UI(){
	...
	frame.addKeyListener(this);

	//创建缓存图片对象
	BufferedImage bufferImage = new BufferedImage(frame.getWidth(), 2 * frame.getHeight(), BufferedImage.TYPE_INT_RGB);

	//从缓存图片获取画布对象
	Graphics bufferedG=bufferImage.getGraphics();

	//在所有元素没有画完前,不显示
	//这里要把所有对象都找出来,调用他们的draw方法,同时move方法也可以在这里一起调用
	
	//把缓存图片显示出来
	g.drawImage(bufferImage, 0, -1000, null);
	try {
		Thread.sleep(20);
	} catch (InterruptedException e) {
	}
}

这段代码也缺失了一部分(找出所有对象调用draw(Graphics g))在最后会补全
另外,可以看到,缓存图片的高度是窗体的两倍高,原因是可以使背景和敌机从最顶上出现,也就是使敌机和背景可以无缝的进入窗体中而不是突然出现,同时他们出现的位置也得是负的,用move方法使他们"滑"进来,所以显示图片时从-1000开始画
3、背景
背景就需要一张图片,这里有飞机大战的素材库:
http://www.aigei.com/view/71627.html?order=down
在里面找一张背景图,可以根据背景来修改窗体参数,把图片复制进环境,可以用Image来获取复制进来的图片
新建一个背景类,并实现Entity接口。接口的move和draw方法可以帮助我们实现背景的动态效果。
draw方法里,只要当图片的坐标大于图片的高度时,把坐标清零就可以了,换句话说就是当图片画出窗体时重新在原点绘制一张。
move方法可以定义背景的移动速度,也可以根据场景来定义速度。另外因为飞机是从下往上飞的,但实际上,我们不控制飞机时,飞机在窗体上是不动的,动的是背景,所以背景是向下动的,那就要使 y+ > 0。

public class Background implements Entity {
	Image image = new ImageIcon("planebg.png").getImage();
	int x,y;
	public void move() {
		y += 2;
	}

	public void draw(Graphics g) {
		if (y - image.getHeight(null) >= 0) {
			y = 0;
		}
		g.drawImage(image, x, y, null);
		g.drawImage(image, x, y + image.getHeight(null), null);
	}
	
	public int getX() {
		return x;
	}

	public int getY() {
		return y;
	}

	public void hit(int i) {}
}

背景的坐标是相对缓存画布而定的,创建全局变量之后被初始化为0,这个0相对Frame是-1000,所以两个drawImage方法相互配合,初始化时一张图片在窗体上,另一张图片在窗体外,两张图片一起向下动,下面的图片画完了就会跑到上面重现画,上面的图片向下填补
背景类写完之后,就可以在Frame的把背景画进缓存

public class Frame implements KeyListener {
	Background bg=new Background();
	public void UI(){
		...
		while(true){
			...
			//在所有元素没有画完前,不显示
			bg.draw(bufferedG);
			bg.move();
			...
		}
	}
}

要注意的是:背景的对象不能在缓存线程(while(true))里面创建,因为背景只有一个,不能在线程里一直创建
4、我机
和背景一样实现Entity接口。
在素材库里找一张我机的图片,但这里和背景不同的是,我机是要控制大小的,不可能我机和背景一样大,可以通过这个方法来控制大小:
drawImage(Image img, int x, int y, int width, int height, ImageObserver observer)
如:把大小控制在90×90

g.drawImage(image, x, y, 90, 90, null);

我机也是要控制出现位置的:比如初始化时想让我机出现在正中间,就要算好我机的尺寸来调整
draw方法只要把图片绘制上去就可以了。当然会有个问题,飞机可以飞出窗体,那就可以写if语句来控制(下面的代码没有限制飞机能否飞出去)
move方法就要结合监听器来写,在Frame方法里获取到了code来控制我机移动,但要注意的是,move方法里不能带形参(Entity接口里move方法没有形参),所以code不能通过move方法的形参来传递。那可以另外写一个带形参的move方法,或是直接传值(下面的方法是直接赋值的)

public class Myplane implements Entity{
	int x=250;
	int y=1850;
	int speed=10;
	int code;//用于KeyListener的检测
	Image image=new ImageIcon("myplane.png").getImage();
	public void move() {
		if(code==KeyEvent.VK_UP){
			y -=speed;
		}
		if(code==KeyEvent.VK_DOWN){
			y+=speed;
		}
		if(code==KeyEvent.VK_LEFT){
			x-=speed;
		}
		if(code==KeyEvent.VK_RIGHT){
			x+=speed;
		}
	}
	
	public void draw(Graphics g) {
		g.drawImage(image, x-44, y, null);
	}
	
	public int getX() {
		return x;
	}
	
	public int getY() {
		return y;
	}
	
	public void hit(int i){}
}

这里要注意初始y坐标是大于窗体的高度的,因为这里的坐标是相对缓存画布而定的,而缓存画布是两倍的窗体高度。另外x,y坐标和g.drawImage(image, x-44, y, null)里面的值都是根据自己的飞机大小定的。hit方法在后面来补充
在窗体里:

public class Frame implements KeyListener {
	Background bg=new Background();
	Myplane mp=new Myplane();
	public void UI(){
		...
		while(true){
			...
			//在所有元素没有画完前,不显示
			bg.draw(bufferedG);
			bg.move();

			mp.draw(bufferedG);
			...
		}
	}
	...
	public void keyPressed(KeyEvent e) {
		int code = e.getKeyCode();
		//获取到按下的按钮后传给我机的move()
		mp.code=code;
		mp.move();
	}
	...
}

5、敌机
实现Entity接口
敌机的变化可以比较多,出现的位置,移动的方向,移动的速度,能否发射子弹等等,所以不太适合用Timer和TimerTask来用,下面的代码里我只写了一些简单的敌机条件
draw方法直接画出即可
move方法加了敌机不同的移动速度,用Random来实现随机。
另外敌机的位置坐标用构造方法来随机生成

public class Enemyplane implements Entity{
	int x;
	int y=600;
	Random rand=new Random();
	int a=rand.nextInt(2);//敌机速度判定 
	Image image=new ImageIcon("enemyplane.png").getImage();
	public Enemyplane() {
		Random randy=new Random();
		this.x=randy.nextInt(340)+80;
	}
	
	public void move() { 
		if(a==0){
			y+=2;
		}else if(a==1){
			y+=4;
		}
	}

	public void draw(Graphics g) {
		g.drawImage(image, x, y, 90, 90, null); 
	}

	public int getX() {
		return x;
	}

	public int getY() {
		return y;
	}
}

敌机和背景、我机不同的是,敌机有很多架,那需要一个队列来实现出现敌机的多线程
先在Frame里创建队列:

ArrayList<Entity> listenemy =new ArrayList<Entity>();

另外写一个类用来控制小球的移动并继承Thread重写run方法

public class EnemyplaneMove extends Thread {
	private ArrayList<Entity> listenemy;
	public EnemyplaneMove (ArrayList<Entity> listenemy) {
		this.listenemy=listenemy;
	}

	public void run(){
		while(true){
			Enemyplane ep=new Enemyplane();
			listenemy.add(ep);
		}
		
		try{
			Thread.sleep(1000);//敌机出现的间隔
		}catch(Exception e){
		}
	}
}

然后在窗体里启动:

public class Frame implements KeyListener {
	ArrayList<Entity> listenemy =new ArrayList<Entity>();

	Myplane mp=new Myplane();
	Background bg=new Background();
	public void UI(){
		...
		Graphics g=frame.getGraphics();
		
		EnemyplaneMove em=new EnemyplaneMove(listenemy);
		em.start();

		while(true){
			...
			//在所有元素没有画完前,不显示
			bg.draw(bufferedG);
			bg.move();
			//找到所有的敌机
			for(int i=0;i<listenemy.size();i++){
				Entity entity=listenemy.get(i);   
				entity.draw(bufferedG);
				entity.move();
			}
			
			mp.draw(bufferedG);
			...
		}
	}
}

6、子弹
子弹可以有一些变化:比如不同颜色子弹的威力不同,飞行方向不同,飞行速度不同等等。而子弹在不同的对象上的表现也不同,比如我机的子弹可以有较多的变化:多方向,连发,而敌机的子弹变化肯定会比我机少,而Boss的子弹也会有很多变化。所以子弹类可以只有一个,用来专门处理子弹的不同,子弹的移动就需要根据不同对象来写多个不同的移动方法。
子弹类:实现Entity接口
draw方法和move方法都很简单,毕竟子弹类只管子弹本身的特性,不管是谁发出的。换句话说,子弹的飞行轨迹,威力,大小,颜色都是子弹自己的性质,从哪里飞出去,什么时候可以发射子弹,发射多少颗子弹,向哪个方向发射子弹就是子弹移动类管的事了

public class Bullet implements Entity{
	int m;//0表示子弹向上飞,1表示子弹向左上飞,2表示子弹向右上飞
	int x;
	int y;
	Image image=new ImageIcon("bullet1.png").getImage();
	public void move() {
		if(m==0){
			y-=9;
		}else if(m==1){
			y-=7;
			x-=2
		}else if(m==2){
			y-=7;
			x+=2;
		}
	}
	
	public void draw(Graphics g) {
		g.drawImage(image, x, y, null);  
	}
	
	public int getX() {  
		return x;
	}

	public int getY() {  
		return y;
	}

	public void hit(int i){}
}

然后在Frame类创建子弹的队列

ArrayList<Entity> listmybullet =new ArrayList<Entity>();

创建控制我机子弹移动的类,继承Thread。
我机的子弹是从我机身上发出的,那么就要获取到我机的坐标,再根据子弹的大小调整子弹发射时的位置。可以利用构造方法来获取我机的对象

public class MyBulletMove extends Thread{
	private Myplane mp;
	private ArrayList<Entity> listmybullet;
	public MyBulletMove (ArrayList<Entity> listmybullet, Myplane mp){
		this.listmybullet=listmybullet;
		this.mp=mp;
 	}
 	public void run(){
		while(true){
			Bullet upbullet=new Bullet();
			upbullet.m=0;//向上飞
			upbullet.x=mp.x-11-mp.a;
			upbullet.y=mp.y;

			listmybullet.add(upbullet);

			try{
				Thread.sleep(400);//子弹发射的间隔
			}catch(Exception e){
			}
		}
	}
}

然后就是在窗体里启动,并在缓存里获取所有对象

public class Frame implements KeyListener {	
	ArrayList<Entity> listenemy =new ArrayList<Entity>();
	ArrayList<Entity> listmybullet =new ArrayList<Entity>();

	Myplane mp=new Myplane();
	Background bg=new Background();
	public void UI(){
		...
		Graphics g=frame.getGraphics();

		EnemyplaneMove em=new EnemyplaneMove(listenemy);
		em.start();

		MyBulletMove bm=new MyBulletMove(listmybullet, mp);
		bm.start();
		
		while(true){
			...
			//在所有元素没有画完前,不显示
			bg.draw(bufferedG);
			bg.move();
			//找到所有的敌机
			for(int i=0;i<listenemy.size();i++){
				Entity entity=listenemy.get(i);
				   
				entity.draw(bufferedG);
				entity.move();
			}
			//找到所有我机子弹
   			for(int i=0;i<listmybullet.size();i++){
				Entity entity=listmybullet.get(i);
				
				entity.draw(bufferedG);
				entity.move();
			}
			
			mp.draw(bufferedG);
			...
		}
	}
}

7、碰撞判断
碰撞判断也是一个线程,每过多少秒就检测碰撞,这个类需要的对象有我机,所有子弹,所有敌机,通过构造方法获取我机,两个队列。

public class Checkforcrash extends Thread{
	private ArrayList<Entity> listmybullet;
	private ArrayList<Entity> listenemy;
	private Myplane mp;
	public Checkforcrash(ArrayList<Entity> listenemy,ArrayList<Entity> listmybullet, Myplane mp) {
		this.listenemy=listenemy;
		this.listmybullet=listmybullet;
		this.mp=mp;
	}
	
	public void run() {
		while (true) {
			for (int i = listmybullet.size() - 1; i > 0; i--) {
				Entity temA = listmybullet.get(i);
				for (int j = 0; j < listenemy.size(); j++) {
					Entity temB = listenemy.get(j);
					if (Tools.enemymycrash(temB, mp)) {
						temA.hit(j);
						mp.hit(j);
					}
					if (Tools.bulletenemycrash(temA, temB)) {
						temA.hit(i);
						temB.hit(j);
					}
				}
			}
		}
	}
 }

这里有另外一个类Tools来辅助判断,因为判断条件包括x和y的坐标差的绝对值,比较长,直接放进去可读性比较低,另外,Tools类可以与当前类配合实现道具的拾取。
在判断绝对值时,先要根据对象的图片大小来确定图片中心点,然后再确定二者相差多少时为撞上了

public class Tools {
	// 敌机我机碰撞
	public static boolean enemymycrash(Entity e, Myplane mp) {
		if (Math.abs((e.getX() + 45) - (mp.getX() - 1)) < 40 && Math.abs((e.getY() + 45) - (mp.getY() + 55)) < 40) {
			return true;
		} else {
			return false;
		}
	}
	
	// 敌机子弹相撞
	public static boolean bulletenemycrash(Entity ea, Entity eb) {
		if ((ea instanceof Enemyplane) && (eb instanceof Bullet)) {
			if (Math.abs((ea.getX() + 45) - (eb.getX() + 10)) < 20 && Math.abs((ea.getY() + 45) - eb.getY()) < 20) {
				return true;
			}
		} else if ((ea instanceof Bullet) && (eb instanceof Enemyplane)) {
			if (Math.abs((ea.getX() + 10) - (eb.getX() + 45)) < 20 && Math.abs(ea.getY() - (eb.getY() + 45)) < 20) {
				return true;
			}
		}
		return false;
	}
}

A instanceof B 用于判断A是否是B类的对象
最后便是实现各自的hit方法:
(1)子弹:

public class Bullet implements Entity{
	...
	ArrayList<Entity> list;
	...
	public void hit(int i){
		//移除队列
		list.remove(i);
	}
}

(2)子弹移动:

public class MyBulletMove extends Thread{
	...
	public void run(){
		while(true){
			Bullet upbullet=new Bullet();
			...   
			upbullet.list=listmybullet;
			listmybullet.add(upbullet);
			...
		}
	}
}

upbullet.list=listmybullet;也可以用构造方法
(3)敌机

public class Enemyplane implements Entity{
	...
	ArrayList<Entity> list;
	
	public void hit(int i) {
		list.remove(i);
	}
}

(4)敌机移动

public class EnemyplaneMove extends Thread {
	...
	public void run(){
		while(true){
			Enemyplane ep=new Enemyplane();
			listenemy.add(ep);
			ep.list=listenemy;
		...
		}
	}
}

(5)我机
可以找一张飞机残骸的图片,把image换掉

public class Myplane implements Entity{
	...
	public void hit(int i) {
		image = new ImageIcon("brokenplane.png").getImage();
	}
}

到这里飞机大战的雏形就结束了!道具的Boss同上类似,可以自己添加
PS:文章篇幅较长,可能会有一些错误,望指正(抱拳)

©️2020 CSDN 皮肤主题: 游动-白 设计师:上身试试 返回首页