这个版本，只能算是一个雏形，把最基本的东西给完成了，不过，后面可添加的也不多。有一点，还是想去实现，那就是敌方坦克自己寻找对手！也就是游戏AI.
emmm, 什么时候可以了解一下这个AI。顺便学学python。
这个帖子只是为了贴上代码，对后续的代码作为优化和添加游戏AI做准备的。
1. 各类接口
package Event;
/*
*具有攻击力的接口
*/
public interface Attackable {
/*
* 校验具有攻击力的实物, 和， 具有被攻击的实物,是否能撞在一起
*
*/
boolean checkAttack(Hitable hit);
}
package Event;
/*
* 具有阻挡功能的实物
*/
public interface Blockable { }
package Event;
/*
* 能被销毁的类
*/
import domain.Blast;
/*
* 销毁接口
*/
public interface Destoryable {
/*
* 判断是否需要销毁
*/
boolean isDestoryable(); /*
* 销毁时，绘制爆炸物
*/
Blast showDestory();
}
package Event; import domain.Blast;
/*
* 能被攻击的类
*/
public interface Hitable {
Blast showAttack();
}
package Event;
/*
* 具有移动功能的事物
*
*/
public interface Moveable {
boolean checkHit(Blockable blockable);
}
2.各类游戏元素的父类
package domain; /*
* 父类：
* 是砖墙，坦克，水墙等所有元素的抽象出来的抽象类
*/
public abstract class Element {
/*
* 属性
* 坐标
*/
protected int x;
protected int y;
//宽高
protected int width;
protected int hight; //构造函数
//空参构造函数
public Element() {super();} //可以不写super()，java会自己调用,也就是调用抽象类的父类 public Element(int x, int y) {
this.x=x; this.y=y;
} /*
* 绘制元素
*/
public abstract void draw(); /*
* 设置元素的渲染级别，数字越高，渲染级别越高
*/
public int getOrder() {return 0;}
}
坦克的父类
package domain; import org.itheima.game.utils.CollisionUtils; import Event.Blockable;
import Event.Destoryable;
import Event.Hitable;
import Event.Moveable;
/*
* 所有坦克的父类\
* 坦克具有移动，阻挡，被攻击，被销毁的功能
*
*/
public abstract class Tank extends Element implements Moveable, Blockable, Hitable,Destoryable{
/*
* 属性
*/
//攻击力
protected int power=1;
//血量
protected int blood=5; //坦克的移动方向
protected Direction direction=Direction.UP; //每次移动的速度
protected int speed=3; //记录最后一颗子弹的发射时间
protected long lastTime; //记录坦克不能移动的方向
protected Direction badDirection; //记录坦克碰撞的最小移动距离
protected int badSpeed; /*
* 构造函数
*/
public Tank() {super();}
public Tank(int x, int y) {super(x, y);} /*
* 绘制坦克
*/
public abstract void draw(); /*
* 发射子弹
*/
public Bullet shot() {
//思路：如歌最后一颗子弹 - 当前发射的时间 > 650ms 就发射子弹
//获取当前时间
long newTime=System.currentTimeMillis();
if(newTime-lastTime<650) {
return null; //不发射子弹
}else {
lastTime=newTime;
return new Bullet(this); //谁调用了就是谁的子弹
}
} /*
* 获取坦克的移动方向
*/
public Direction getDirection() {return direction;} /*
* 校验：移动物(坦克)是否与障碍物是否撞上
*/
public boolean checkHit(Blockable block){
Element e=(Element)block;
int x1=e.x;
int y1=e.y;
int w1=e.width;
int h1=e.hight; //预判坦克的坐标
int x2=x;
int y2=y;
switch (direction) {
case UP:
y2-=speed;
break;
case DOWN:
y2+=speed;
break;
case LEFT:
x2-=speed;
break;
case RIGHT:
x2+=speed;
break;
default:
break;
}
boolean flag=CollisionUtils.isCollsionWithRect(x1, y1, w1, h1, x2, y2, width, hight);
if(flag) {
//说明预判可以撞上,不仅要记录不能移动的方向，还要记录最小间隙
badDirection=direction;
switch (direction) {
case UP:
badSpeed=y-y1-h1;
break;
case DOWN:
badSpeed = y1 - y - hight;
break;
case LEFT:
badSpeed = x - x1 - w1;
break;
case RIGHT:
badSpeed = x1 - w1 - width;
break;
default:
break;
}
}else {
badDirection=null; //没有撞上的话，就没有坏的方向
}
return flag;
} /*
* 销毁的方法
*/
public boolean isDestory() {return blood<=0;} /*
* 被销毁物，在被销毁时的表现。
*/
public Blast showDestory() {return new Blast(this);} }
各种游戏元素
package domain; import java.io.IOException; import org.itheima.game.utils.DrawUtils;
import org.itheima.game.utils.SoundUtils; import Event.Blockable;
import Event.Destoryable;
import Event.Hitable; /*
*
* 爆炸物类
*
*/
public class Blast extends Element implements Destoryable{
/*
* 属性
*/
//1.图片
private String[]arr= {"res/img/blast_1.gif", "res/img/blast_2.gif", "res/img/blast_3.gif", "res/img/blast_4.gif",
"res/img/blast_5.gif", "res/img/blast_6.gif", "res/img/blast_7.gif", "res/img/blast_8.gif"};
//2.定义变量，记录要绘制的图片索引
private int index; //3.定义变量，记录是否需要销毁该爆炸物
//true：销毁， false ：不销毁
private boolean isDestory; /*
* 构造方法
* 爆炸物的坐标依赖墙的坐标
*/
public Blast(Hitable hit) {
this(hit, false);
try {
SoundUtils.play("res/snd/blast.wav");
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/*
* flag :true表示挨打，绘制1~4的图片
* false 说明是销毁，绘制1~8的图片
*/
public Blast(Hitable hit, boolean flag) {
Element element=(Element)hit;
//计算爆炸物的位置
//获取墙的坐标和宽高
int x1=element.x;
int y1=element.y;
int w1=element.width;
int h1=element.hight;
//获取爆炸物的宽度
try {
int size[]=DrawUtils.getSize("res/img/blast_1.gif");
width=size[0]; hight=size[1]; //计算爆炸物的坐标
x=x1+(w1-width)/2;
y=y1+(h1-hight)/2;
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} if(flag) {
arr=new String[] {"res/img/blast_1.gif", "res/img/blast_2.gif", "res/img/blast_3.gif", "res/img/blast_4.gif"};
try {
SoundUtils.play("res/snd/hit.wav");
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
@Override
public void draw() {
// TODO Auto-generated method stub
//定义变量，记录要绘制的图片的路径
String res=arr[index++];
if(index>=arr.length) {
index=0;
//说明爆炸物已经绘制过一次了可以销毁
isDestory=true;
}
try {
DrawUtils.draw(res, x, y);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} /*
* 获取爆炸物的状态
*/
public boolean isDestoryable() {
// TODO Auto-generated method stub
return isDestory;
}
/*
* 销毁时，绘制销毁的爆炸物
*/
public Blast showDestory() {return null;} }
package domain; import java.io.IOException; import org.itheima.game.utils.CollisionUtils;
import org.itheima.game.utils.DrawUtils;
import org.itheima.game.utils.SoundUtils; import Event.Attackable;
import Event.Destoryable;
import Event.Hitable;
import Grame.config; /*
* 子弹类,具有攻击能力，被销毁的能力
*/
public class Bullet extends Element implements Attackable, Destoryable { //记录子弹移动的方向
private Direction direction;
//记录子弹的速度
private int speed=7;
//定义变量，记录子弹所属的坦克
private Tank tank; /*
* 构造函数(non-Javadoc)
* @see Event.Destoryable#isDestoryable()
*/
//子弹的坐标依赖坦克
public Bullet(Tank tank) {
// TODO Auto-generated constructor stub
super();
//用变量tank记录，子弹所属的坦克
this.tank=tank; //获取坦克的坐标，宽高，方向
int tankX=tank.x;
int tankY=tank.y;
int tankWidth=tank.width;
int tankHight=tank.hight;
direction=tank.getDirection(); //获取子弹的宽高
try {
int size[]=DrawUtils.getSize("res/img/bullet_u.gif");
width=size[0]; hight=size[1];
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} //计算子弹的坐标
switch (direction) {
case UP:
x = tankX + (tankWidth - width)/2;
y = tankY - hight / 2;
break;
case DOWN:
x = tankX + (tankWidth - width)/2;
y = tankY + tankHight - hight /2;
break;
case LEFT:
x=tankX-width;
y=tankY+(tankHight-hight)/2;
break;
case RIGHT:
x = tankX + tankWidth - width / 2;
y = tankY + (tankHight - hight)/2;
break;
default:
break;
} try {
SoundUtils.play("res/snd/fire.wav");
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} /* 出边界
* 销毁子弹 true：销毁，false：不销毁(non-Javadoc)
* @see Event.Destoryable#isDestoryable()
*/
@Override
public boolean isDestoryable() {
// TODO Auto-generated method stub
if(x<0||x>config.WIDTH||y<0||y>config.HIGHT) return true;
return false;
} /*
* 子弹销毁时的反映(non-Javadoc)
* @see Event.Destoryable#showDestory()
*/
@Override
public Blast showDestory() {
// TODO Auto-generated method stub
return null;
}
/*校验是否与阻碍物碰上
* (non-Javadoc)
* @see Event.Attackable#checkAttack(Event.Hitable)
*/
@Override
public boolean checkAttack(Hitable hit) {
// TODO Auto-generated method stub
Element e=(Element)hit;
int x1=e.x;
int y1=e.y;
int w1=e.width;
int h1=e.hight;
//第一个矩形：障碍物，第二个撞击物:子弹
return CollisionUtils.isCollsionWithRect(x1, y1, w1, h1, x, y, width, hight);
} /*
* 绘制子弹(non-Javadoc)
* @see domain.Element#draw()
*/
@Override
public void draw() {
// TODO Auto-generated method stub
String res="";
//判断坦克方向
switch (direction) {
case UP:
res = "res/img/bullet_u.gif";
y-=speed;
break;
case DOWN:
res = "res/img/bullet_d.gif";
y += speed;
break;
case LEFT:
res = "res/img/bullet_l.gif";
x -= speed;
break;
case RIGHT:
res = "res/img/bullet_r.gif";
x += speed;
break;
default:
break;
} try {
DrawUtils.draw(res, x, y);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} /*
* 获取子弹所属坦克
*/
public Tank getTank() {
return tank;
}
}
package domain;
/*
* 枚举四个方向
*/
public enum Direction {
UP,DOWN,LEFT,RIGHT;
}
package domain; import java.io.IOException;
import java.util.Random; import org.itheima.game.utils.DrawUtils; import Grame.config; public class EnemyTank extends Tank{ /*
* 属性(non-Javadoc)
* @see Event.Hitable#showAttack()
*/
public EnemyTank(int x, int y) {
super(x, y);
try {
int size[]=DrawUtils.getSize("res/img/enemy_u.gif");
width=size[0]; hight=size[1];
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public EnemyTank() {super();} @Override
public Blast showAttack() {
// TODO Auto-generated method stub
//扣血
blood-=new Mytank().power;
return new Blast(this, true);
} @Override
public boolean isDestoryable() {
// TODO Auto-generated method stub
return blood<=0;
} /*
* 坦克的绘制(non-Javadoc)
* @see domain.Tank#draw()
*/
@Override
public void draw() {
// TODO Auto-generated method stub
String res="";
//判断坦克的方向
switch (direction) {
case UP:
res = "res/img/enemy_u.gif";
break;
case DOWN:
res = "res/img/enemy_d.gif";
break;
case LEFT:
res = "res/img/enemy_l.gif";
break;
case RIGHT:
res = "res/img/enemy_r.gif";
break;
default:
break;
} try {
DrawUtils.draw(res, x, y);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} /*
* 随机获取敌方坦克的方向
*/
public Direction getRandDirection() {
int num=new Random().nextInt(4);
switch (num) {
case 0:
return Direction.UP;
case 1:
return Direction.DOWN;
case 2:
return Direction.LEFT;
case 3:
return Direction.RIGHT;
default:
break;
}
return Direction.UP;
} /*
* 移动
*/
public void move() {
//如果传过来的方向，与坦克不能移动的方向相同，则移动最小距离
if(direction==badDirection) {
switch (direction) {
case UP:
y-=badSpeed;
break;
case DOWN:
y+=badSpeed;
break;
case LEFT:
x-=badSpeed;
break;
case RIGHT:
x+=badSpeed;
break;
default:
break;
}
//不能移动就随机换一下方向
direction=getRandDirection();
return ;
} switch (direction) {
case UP:
y-=speed;
break;
case DOWN:
y+=speed;
break;
case LEFT:
x-=speed;
break;
case RIGHT:
x+=speed;
break;
default:
break;
} //边界处理
if(x<0) {
x=0;
direction=getRandDirection();
}
if(x>config.WIDTH-64) {
x=config.WIDTH-64;
direction=getRandDirection();
}
if(y<0) {
y=0;
direction=getRandDirection();
}
if(y>config.HIGHT-64) {
y=config.HIGHT-64;
direction=getRandDirection();
}
}
}
package domain; import java.io.IOException; import org.itheima.game.utils.DrawUtils;
/*
* 草坪
*/
public class Grass extends Element{ public Grass(int x, int y) {
// TODO Auto-generated constructor stub
super(x, y);
//获取宽高
try {
int size[]=DrawUtils.getSize("res/img/grass.gif");
width=size[0]; hight=size[1];
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
@Override
public void draw() {
// TODO Auto-generated method stub
try {
DrawUtils.draw("res/img/grass.gif", x, y);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} /*
* 修改草坪的渲染级别
*/
public int getOrder() {return 1;}
}
package domain;
import java.io.IOException;
import javax.swing.plaf.DimensionUIResource;
import org.itheima.game.utils.DrawUtils;
import Grame.config;
public class Mytank extends Tank{
public Mytank(int x, int y) {
// TODO Auto-generated constructor stub
super(x, y);
//初始化速度
speed=30; power=2; blood=10;
//获取坦克的宽高
try {
int size[] = DrawUtils.getSize("res/img/tank_u.gif");
width=size[0];
hight=size[1];
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public Mytank() {
// TODO Auto-generated constructor stub
super();
power=2;
}
/*
* 挨打方法(non-Javadoc)
* @see Event.Hitable#showAttack()
*/
@Override
public Blast showAttack() {
// TODO Auto-generated method stub
//扣血
blood-=new EnemyTank().power;
return new Blast(this, true);
}
@Override
public boolean isDestoryable() {
// TODO Auto-generated method stub
return blood<=0;
}
@Override
public void draw() {
// TODO Auto-generated method stub
String res="";
switch (direction) {
case UP:
res = "res/img/tank_u.gif";
break;
case DOWN:
res = "res/img/tank_d.gif";
break;
case LEFT:
res = "res/img/tank_l.gif";
break;
case RIGHT:
res = "res/img/tank_r.gif";
break;
default:
break;
}
try {
DrawUtils.draw(res, x, y);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/*
* 坦克的移动
*/
public void move(Direction direction) {
//如果传过来的方向和坦克不能动的方向一致，则移动最小
if(badDirection==direction) {
//移动最小间距
switch (direction) {
case UP:
y -= badSpeed;
break;
case DOWN:
y += badSpeed;
break;
case LEFT:
x -= badSpeed;
break;
case RIGHT:
x += badSpeed;
break;
default:
break;
}
return ;
}
//刷新方向,用户按下的方向传给坦克：坦克的方向
if(this.direction!=direction)
{
this.direction=direction;
return ;
}
switch (direction) {
case UP:
y -= speed;
break;
case DOWN:
y += speed;
break;
case LEFT:
x -= speed;
break;
case RIGHT:
x += speed;
break;
default:
break;
}
/*
* 边界处理
*/
if(x<0) {x=0;}
if(x>config.WIDTH-64) {x=config.WIDTH-64;}
if(y<0) {y=0;}
if(y>config.HIGHT-64) {y=config.HIGHT-64;}
}
}
package domain; import java.io.IOException; import org.itheima.game.utils.DrawUtils; import Event.Blockable;
import Event.Destoryable;
import Event.Hitable; public class Steel extends Element implements Blockable, Hitable, Destoryable{
/*
* 属性：
*/
//1.血量
private int blood=5; public Steel(int x, int y) {
super(x, y); //获取铁墙的宽高
try {
int size[]=DrawUtils.getSize("res/img/steel.gif");
width=size[0];
hight=size[1];
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} @Override
public void draw() {
// TODO Auto-generated method stub
try {
DrawUtils.draw("res/img/steel.gif", x, y);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} /*
* 挨打后的反映(non-Javadoc)
* @see Event.Hitable#showAttack()
*/
@Override
public Blast showAttack() {
// TODO Auto-generated method stub
blood--;
return new Blast(this,true);
} /*
* 销毁时响应的动作(non-Javadoc)
* @see Event.Destoryable#showDestory()
*/
@Override
public Blast showDestory() {
// TODO Auto-generated method stub
return new Blast(this);
} /*
* 销毁铁墙(non-Javadoc)
* @see Event.Destoryable#isDestoryable()
*/
@Override
public boolean isDestoryable() {
// TODO Auto-generated method stub
return blood<=0;
}
}
package domain; import java.io.IOException; import org.itheima.game.utils.DrawUtils; import Event.Blockable;
import Event.Destoryable;
import Event.Hitable; public class Wall extends Element implements Hitable, Blockable, Destoryable{ //血量
private int blood=3; /*
* 含参数的构造函数
*/
public Wall(int x, int y) {
// TODO Auto-generated constructor stub
super(x, y); //获取宽度，长度
try {
int size[]=DrawUtils.getSize("res/img/wall.gif");
width=size[0];
hight=size[1];
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} }
/*
*绘制
* @see domain.Element#draw()
*/
@Override
public void draw() {
try {
DrawUtils.draw("res/img/wall.gif", x, y);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} /*
* 挨打
* Blast爆炸类
*/
public Blast showAttack() {
blood--; //挨打一次血量减少
return new Blast(this, true);
} /*
* 销毁判断,血量小于等于0时，就销毁
*/
public boolean isDestoryable() {return blood<=0;} /*
* 销毁响应动作
*/
public Blast showDestory() {return new Blast(this);} }
package domain;
import java.io.IOException;
import org.itheima.game.utils.DrawUtils;
import Event.Blockable;
public class Water extends Element implements Blockable{
public Water(int x, int y) {
super(x, y);
try {
int size[]=DrawUtils.getSize("res/img/water.gif");
width=size[0]; hight=size[1];
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
@Override
public void draw() {
try {
DrawUtils.draw("res/img/water.gif", x, y);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
package Grame;
public class APP {
/*
* 游戏的主入口，所有代码的主入口
*/
public static void main(String[] args) {
//绘制窗口
MyWindows gr=new MyWindows(config.TITLE, config.WIDTH, config.HIGHT, config.PFS);
//开始游戏
gr.start();
}
}
package Grame;
public interface config {
String TITLE="坦克大战";
int WIDTH=64*15;
int HIGHT=64*10;
int PFS=50;
}
package Grame; import java.awt.HeadlessException;
import java.awt.Window;
import java.io.IOException;
import java.nio.file.Watchable;
import java.util.Comparator;
import java.util.concurrent.CopyOnWriteArrayList; import org.itheima.game.utils.DrawUtils;
import org.itheima.game.utils.SoundUtils;
import org.lwjgl.input.Keyboard;
import org.omg.PortableServer.ID_ASSIGNMENT_POLICY_ID; import Event.Attackable;
import Event.Blockable;
import Event.Destoryable;
import Event.Hitable;
import Event.Moveable;
import domain.Blast;
import domain.Bullet;
import domain.Direction;
import domain.Element;
import domain.EnemyTank;
import domain.Grass;
import domain.Mytank;
import domain.Steel;
import domain.Tank;
import domain.Wall;
import domain.Water; /*
* 游戏窗口类
*
*/
public class MyWindows extends org.itheima.game.Window{ //定义：集合，存储元素
//CopyOnWeiteArrayList 可以解决并发修改异常的集合
CopyOnWriteArrayList<Element>list=new CopyOnWriteArrayList<>();
//创建坦克对象
Mytank mt;
//创建敌方坦克
EnemyTank et1;
EnemyTank et2; public MyWindows(String title, int width, int height, int fps) {super(title, width, height, fps);} /*
* 绘制窗口时运行
*/
@Override
protected void onCreate() {
//播放开始音乐
try {
SoundUtils.play("res/snd/start.wav");
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} //创建砖墙
for(int i=0;i<config.WIDTH/64-1;++i) {
Wall wall=new Wall(i*64, 64);
addElement(wall);
}
//创建水墙
for(int i=1;i<config.WIDTH/64;++i) {
Water water=new Water(i*64, 64*3);
addElement(water);
}
//绘制铁墙
for(int i=0;i<config.WIDTH/64-1;++i) {
Steel steel=new Steel(i*64, 64*5);
addElement(steel);
}
//创造草坪
for(int i=1;i<config.WIDTH/64;++i) {
Grass grass=new Grass(i*64, 64*7);
addElement(grass);
} //创造己方坦克
mt=new Mytank(config.WIDTH/2-32, config.HIGHT-64);
addElement(mt);
//创建敌方坦克
et1=new EnemyTank(0, 0);
et2=new EnemyTank(config.WIDTH-64, 0);
addElement(et1);
addElement(et2);
} //鼠标事件
@Override
protected void onMouseEvent(int key, int x, int y) {
// TODO Auto-generated method stub } //键盘事件
@Override
protected void onKeyEvent(int key) {
// TODO Auto-generated method stub
switch (key) {
case Keyboard.KEY_UP:
mt.move(Direction.UP);
break;
case Keyboard.KEY_DOWN:
mt.move(Direction.DOWN);
break;
case Keyboard.KEY_LEFT:
mt.move(Direction.LEFT);
break;
case Keyboard.KEY_RIGHT:
mt.move(Direction.RIGHT);
break;
case Keyboard.KEY_SPACE: //回车键
Bullet shot=mt.shot(); //发射子弹
//对子弹进行非空校验
if(shot!=null) {
addElement(shot);
}
break;
default:
break;
}
} //事实刷新
@Override
protected void onDisplayUpdate() {
// TODO Auto-generated method stub
//如果己方坦克已经销毁，或者敌方坦克都销毁，则游戏结束
if(mt.isDestory()||(et1.isDestory()&&et2.isDestory())) {
list.clear();
//绘制结束图片
try {
DrawUtils.draw("res/img/gameover.gif", (config.WIDTH-96)/2, (config.HIGHT-96)/2);
} catch (IOException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
//停止所有音乐
SoundUtils.stop("res/snd/fire.wav"); return;
} //绘制元素
for(Element e:list) {
e.draw();
} //调用敌方坦克的随机移动的功能
for(Element e:list) {
if(e instanceof EnemyTank) {
//如果是敌方坦克，就随机移动
((EnemyTank)e).move(); //如果是敌方坦克，就调用其发射子弹的能力
Bullet shot=((EnemyTank)e).shot();
if(shot!=null) {
addElement(shot);
}
}
} //销毁出界子弹
for(Element e:list) {
//如果是子弹
if(e instanceof Bullet) {
//判断子弹是否出界
boolean flag=((Bullet)e).isDestoryable();
if(flag) {
list.remove(e);
}
}
} //销毁所有需要销毁的实物
for(Element e:list) {
//判断事物是否需要销毁
if( e instanceof Destoryable) {
boolean blast=((Destoryable)e).isDestoryable();
if(blast) {
//说明事物需要销毁
//1.绘制销毁时的爆炸物
Blast blast2=((Destoryable)e).showDestory();
if(blast2!=null) {
addElement(blast2);
} //消除该事物
list.remove(e);
}
}
} /*
* 校验：运动物体 与 障碍物 的碰撞
*/
for(Element e1:list) {
for(Element e2:list) {
if(e1!=e2&&e1 instanceof Moveable&&e2 instanceof Blockable) {
//说明 e1运动物 与 e2 障碍物
boolean flag=((Moveable)e1).checkHit((Blockable)e2);
if(flag) { //说明碰撞了
break;
}
}
}
} /*
* 攻击者 与 被攻击者 是否碰撞
*/
for(Element e1: list) {
for(Element e2: list) {
if(e1 instanceof Attackable&&e2 instanceof Hitable) {
//说明 e1 攻击者 e2 被攻击者
boolean flag=((Attackable)e1).checkAttack((Hitable)e2);
if(flag) {
//校验：是己方坦克发过来的子弹，是则不能攻击，否则能产生攻击
if(((Bullet)e1).getTank().getClass()==e2.getClass()) {
continue;
} //校验：能不能攻击敌军
//子弹销毁
list.remove(e1);
//被攻击者受到攻击，绘制出爆炸物
Blast blast=((Hitable)e2).showAttack();
addElement(blast);
}
}
}
} } /*
* 添加元素
*/
public void addElement(Element e) {
list.add(e); //对集合按照渲染级别进行排序
list.sort(new Comparator<Element>() { @Override
public int compare(Element o1, Element o2) {
// TODO Auto-generated method stub
return o1.getOrder()-o2.getOrder();
}
});
} }