java简单坦克大战制作代码
利用Java语言中的集合、Swing、线程等知识点编写一个坦克大战游戏。
（1）画出敌我坦克的原理：
在坦克类里面有一个布尔类型变量good。用于判断坦克的阵营，在创建坦克对象时在Tank类的构造方法中传入good的值。在画坦克的时候判断good的值，区分敌我坦克的颜色；
（2）坦克运动的原理：
在坦克类里写入了监听键盘摁键的响应事件，对监听到的上下左右键进行记录，并合成坦克移动的八个方向的变量。之后对应每个方向的不同对坦克坐标x，y的值做响应的更改实现我方坦克的移动。而敌方坦克则自动移动，通过随机数对敌方坦克移动方向的随机，并且随机出每次移动的次数。两个随机值相结合即实现了敌方坦克的移动。
（3）坦克发射子弹的原理：
通过键盘监听，检测到发射子弹命令后将主类的子弹类集合中添加一个子弹类。将炮筒的方向以及坦克的位置以及坦克的阵营传入给子弹类，在主类paint画方法中一直循环子弹类集合，如果集合内有子弹，就画出来。这样就实现了发射子弹。
（4）坦克、子弹、墙的碰撞原理：
在坦克类子弹类墙类中分别getRect方法获取自身的范围，然后在每次画坦克、子弹时都会进行相应的碰撞检测（在坦克类里有与墙和出自己外的坦克相撞的处理方法、在子弹类里有与墙和坦克相碰撞的处理方法。），如果自身与不该碰撞的物体的范围相重合，则代表两物体相撞。
（5）坦克加血的原理：
在血块类中有血块与我方坦克相碰撞的处理方法，如果血块范围与坦克范围重合则血块类死亡，并且坦克类的血量回复置满。
（6）坦克复活的原理：
通过键盘监听，检测到我方坦克复活命令后，如果我方坦克处于死亡状态，则将我方坦克存货状态改为活着并且将我方坦克血量回置满血。
编程思想：
坦克大战的编程思想在主类开启一个线程，没50毫秒循环一次画方法（绘制整个界面内的所有东西）。画的东西有敌我坦克（颜色区分）、子弹、墙、血块、爆炸。所以总共写出了几个类：Tank坦克类、Missile子弹类、Wall墙类、Blood血块类、TankClient主类。在每一个类中均写有画方法实现本类属性的绘制功能。在主类中有键盘监听事件调用这Tank类的键盘监听事件。通过键盘监听判断出对Tank做出相应的移动，而敌方Tank则是随机运动。并且每次刷新都有调用各类的碰撞方法，判断一些不该碰撞的对象的情况时做出处理。而每个对象的创建例如子弹这些是在触发产生之后将新建子弹类加入一个子弹类集合之中，在绘制的时候判断集合中的数量进行绘制，出界或者打死坦克则在集合中删除。其他类也均相似，不在细说。
代码中每步都注释有相应的解释。
TankClient.java
importjava.awt.Color;
importjava.awt.Font;
importjava.awt.Graphics;
importjava.awt.Image;
importjava.awt.event.KeyAdapter;
importjava.awt.event.KeyEvent;
importjava.awt.event.WindowAdapter;
importjava.awt.event.WindowEvent;
importjava.util.ArrayList;
importjava.util.List;
importjavax.swing.JFrame;
publicclassTankClientextendsJFrame{
/**
*@paramargs
*/
ImageOffScrennImage=null;//双缓冲内存图片存储
/*游戏大小*/
publicstaticfinalintGAME_WIDTH=800;//界面宽
publicstaticfinalintGAME_HEIGTH=600;//界面高
TankmyTank=newTank(500,400,true,Color.red,Tank.Direction.STOP,this);//我方坦克类
List<Missile>missiles=newArrayList<Missile>();//子弹的集合
List<Explode>explode=newArrayList<Explode>();//爆炸集合
List<Tank>tanks=newArrayList<Tank>();//坦克集合
Wallwall1=newWall(150,200,20,300,this);//墙1
Wallwall2=newWall(250,500,300,20,this);//墙2
Wallwall3=newWall(650,200,20,300,this);//墙2
Wallwall4=newWall(250,300,300,20,this);//墙2
Wallwb=newWall(750,550,40,40,this);//墙2
Bloodb=newBlood();//血类
publicstaticvoidmain(String[]args){
//TODOAuto-generatedmethodstub
TankClienttc=newTankClient();
tc.lauchFrame();
}
privatevoidlauchFrame(){
//TODOAuto-generatedmethodstub
for(inti=0;i<10;i++){
tanks.add(newTank(50+40*(i+1),50,false,Color.blue,Tank.Direction.D,this));
}
this.setLocation(100,100);//窗口初始坐标点
this.setSize(GAME_WIDTH,GAME_HEIGTH);//窗口初始大小
this.setTitle("TankWar");//窗口名称
/*窗口监听*/
this.addWindowListener(newWindowAdapter(){
@Override
/*点退出叉之后运行*/
publicvoidwindowClosing(WindowEvente){
//TODOAuto-generatedmethodstub
System.exit(0);//退出
}
});
this.addKeyListener(newKeyMoniton());//设置键盘监听
this.setVisible(true);//设置窗口显现
this.setResizable(false);//设置窗口不可改变大小
this.getContentPane().setBackground(Color.green);//设置窗口前景色为绿色
newThread(newPaintThread()).start();//开始运行PaintThread类run
}
@Override
publicvoidpaint(Graphicsg){
//TODOAuto-generatedmethodstub
//Graphics为画笔类
super.paint(g);
myTank.draw(g);
wall1.draw(g);
wall2.draw(g);
wall3.draw(g);
wall4.draw(g);
wb.draw(g);
b.draw(g);
myTank.eatBlood(b);
myTank.hitWall(wall1);
myTank.hitWall(wall2);
myTank.hitWall(wall3);
myTank.hitWall(wall4);
/*循环子弹集合*/
for(inti=0;i<missiles.size();i++){
Missilem=missiles.get(i);//获取当前子弹
m.hitTanks(tanks);//自己子弹打死敌方坦克
m.hitWall(wall1);//子弹与墙
m.hitWall(wall2);
m.hitWall(wall3);
m.hitWall(wall4);
m.hitTank(myTank);//敌人子弹打击自己的坦克
m.draw(g);//画子弹
}
for(inti=0;i<explode.size();i++){
explode.get(i).draw(g);//画爆炸
}
for(inti=0;i<tanks.size();i++){
Tankt=tanks.get(i);
t.draw(g);//画敌方坦克
t.hitTanks(tanks);
t.hitWall(wall1);//坦克与墙
t.hitWall(wall2);
t.hitWall(wall3);
t.hitWall(wall4);
}
//g.setFont(newFont("宋体",Font.BOLD,20));
g.drawString("missilescount:"+missiles.size(),10,50);//显示
g.drawString("explodecount:"+explode.size(),10,80);//显示
g.drawString("tankscount:"+tanks.size(),10,110);
g.drawString("myTankLife:"+myTank.getLife(),10,130);
g.drawString("回血:",750,540);
g.drawString("方向键移动方向；E:释放移动血快",10,590);
g.drawString("z：发射东风-31；a：发射东风-41;",10,570);
g.drawString("F2：复活；F3：敌方复活（对多20）",10,550);
g.drawString("R：位置还原;Q:血量加满",10,530);
}
@Override
/*repaint-〉update->paint*/
publicvoidupdate(Graphicsg){
//TODOAuto-generatedmethodstub
super.update(g);
if(OffScrennImage==null)
OffScrennImage=this.createImage(GAME_WIDTH,GAME_HEIGTH);
Graphicsgoffscrenn=OffScrennImage.getGraphics();//设置一个内存画笔颜色为前景图片颜色
Colorc=goffscrenn.getColor();//还是先保存前景颜色
goffscrenn.setColor(Color.green);//设置内存画笔颜色为绿色
goffscrenn.fillRect(0,0,GAME_WIDTH,GAME_HEIGTH);//画成图片，大小为游戏大小
goffscrenn.setColor(c);//还原颜色
g.drawImage(OffScrennImage,0,0,null);//在界面画出保存的图片
paint(goffscrenn);//把内存画笔调用给paint
}
privateclassPaintThreadimplementsRunnable{
@Override
publicvoidrun(){
//TODOAuto-generatedmethodstub
while(true){
repaint();//运行顺序repaint->update->paint
try{
Thread.sleep(50);//每隔50毫秒刷新画面一次
}catch(Exceptione){
e.printStackTrace();
}
}
}
}
/*键盘响应*/
privateclassKeyMonitonextendsKeyAdapter{
/*摁下键盘响应*/
@Override
publicvoidkeyPressed(KeyEvente){
//TODOAuto-generatedmethodstub
super.keyPressed(e);
myTank.KeyPressed(e);
}
/*抬起键盘响应*/
@Override
publicvoidkeyReleased(KeyEvente){
//TODOAuto-generatedmethodstub
super.keyReleased(e);
myTank.keyReleased(e);
}
}
}
Tank.java
importjava.awt.Color;
importjava.awt.Graphics;
importjava.awt.Image;
importjava.awt.Rectangle;
importjava.awt.event.KeyEvent;
importjava.util.List;
importjava.util.Random;
importjavax.swing.ImageIcon;
publicclassTank{
/*坦克本身数据*/
intx,y;//坦克坐标
privateintoldX,oldY;//坦克上一步坐标
publicstaticfinalintWhith=30;//坦克宽
publicstaticfinalintHigth=30;//坦克高
publicstaticfinalintXSPEED=5;//横向移动速度
publicstaticfinalintYSPEED=5;//纵向移动速度
privateColorcolor;//坦克颜色
privatebooleanbL=false,bU=false,bR=false,bD=false;//四个方向控制值
enumDirection{L,LU,U,RU,R,RD,D,LD,STOP};//由四个方向值合成八个方向的移动
privateDirectiondir=Direction.STOP;//出场方向
privateDirectionptDir=Direction.D;//炮筒初始方向
privatebooleangood;//判断坦克的阵营
privatebooleanlive=true;//判断坦克是否存活
privatestaticRandomr=newRandom();//设置一个随机值变量
privatestaticintstep=r.nextInt(12)+3;//敌方坦克随机移动步骤3-14步
privateintLife=100;//血量
privateBloodBarbb=newBloodBar();//血块类
//ImageIconicon=newImageIcon("res\\myTank.jpg");
//ImageIconicon2=newImageIcon("res\\enemyTank.jpg");
//Imageimage=icon.getImage();
//Imageimage2=icon2.getImage();
privateTankClienttc;//主类权限
publicTank(intx,inty,booleangood,Colorcolor){
super();
this.x=x;
this.y=y;
this.color=color;
this.good=good;
}
publicTank(intx,inty,booleangood,Colorcolor,Directiondir,TankClienttc){
this(x,y,good,color);
this.dir=dir;
this.tc=tc;
}
/*获取坦克生命值*/
publicintgetLife(){
returnLife;
}
/*设置坦克生命值*/
publicvoidsetLife(intLife){
this.Life=Life;
}
/*获取坦克阵营*/
publicbooleanisGood(){
returngood;
}
/*设置坦克阵营*/
publicvoidsetGood(booleangood){
this.good=good;
}
/*获取坦克存活状态*/
publicbooleanisLive(){
returnlive;
}
/*设置坦克存活状态*/
publicvoidsetLive(booleanlive){
this.live=live;
}
/*画坦克*/
publicvoiddraw(Graphicsg){
if(!live){
if(!good){
tc.tanks.remove(this);//敌方坦克死亡时在集合中删除
//tc.tanks.add(newTank(r.nextInt(700),r.nextInt(500),false,Color.blue,Direction.D,this.tc));
}
return;
}
/*先保存之前的画笔颜色，画完之后再还原画笔颜色*/
Colorc=g.getColor();//获取当前画笔颜色
g.setColor(color);//设置画笔颜色为红色
/*画坦克*/
g.fillOval(x,y,Whith,Higth);
/*两种方法绘制敌我坦克，运用之前加入的图片或者颜色区分*/
//if(good)
//g.drawImage(image,x,y,Whith,Higth,null);
//else
//g.drawImage(image2,x,y,Whith,Higth,null);
if(good)
bb.draw(g);//我方坦克画血条
g.setColor(Color.black);
/*通过炮筒方向画出炮筒*/
switch(ptDir){
caseL:
g.drawLine(x+Tank.Whith/2,y+Tank.Higth/2,x,y+Tank.Higth/2);
break;
caseLU:
g.drawLine(x+Tank.Whith/2,y+Tank.Higth/2,x,y);
break;
caseU:
g.drawLine(x+Tank.Whith/2,y+Tank.Higth/2,x+Tank.Whith/2,y);
break;
caseRU:
g.drawLine(x+Tank.Whith/2,y+Tank.Higth/2,x+Tank.Whith,y);
break;
caseR:
g.drawLine(x+Tank.Whith/2,y+Tank.Higth/2,x+Tank.Whith,y+Tank.Higth/2);
break;
caseRD:
g.drawLine(x+Tank.Whith/2,y+Tank.Higth/2,x+Tank.Whith,y+Tank.Higth);
break;
caseD:
g.drawLine(x+Tank.Whith/2,y+Tank.Higth/2,x+Tank.Whith/2,y+Tank.Higth);
break;
caseLD:
g.drawLine(x+Tank.Whith/2,y+Tank.Higth/2,x,y+Tank.Higth);
break;
}
g.setColor(c);//还原画笔颜色
move();//移动
}
/*键盘监听；摁键*/
publicvoidKeyPressed(KeyEvente){
intkey=e.getKeyCode();//将键盘监听到的摁键以整数保存
/*键盘移动坦克*/
switch(key){
/*移动摁键*/
caseKeyEvent.VK_UP:
bU=true;
break;
caseKeyEvent.VK_DOWN:
bD=true;
break;
caseKeyEvent.VK_RIGHT:
bR=true;
break;
caseKeyEvent.VK_LEFT:
bL=true;
break;
}
locateDirection();
}
/*键盘监听；抬起键*/
publicvoidkeyReleased(KeyEvente){
intkey=e.getKeyCode();//将键盘监听到的摁键以整数保存
/*键盘移动坦克*/
switch(key){
caseKeyEvent.VK_UP:
bU=false;
break;
caseKeyEvent.VK_DOWN:
bD=false;
break;
caseKeyEvent.VK_RIGHT:
bR=false;
break;
caseKeyEvent.VK_LEFT:
bL=false;
break;
caseKeyEvent.VK_Z://单发子弹
if(live)
fire();
break;
caseKeyEvent.VK_F2://我方复活
if(!this.live){
this.live=true;
this.setLife(100);
}
break;
caseKeyEvent.VK_F3://敌方复活
fuhuo();
break;
caseKeyEvent.VK_A://无敌导弹
superFire();
break;
caseKeyEvent.VK_Q://回血
if(this.live)
this.Life=100;
break;
caseKeyEvent.VK_E://释放血块
tc.b.fh();
break;
/*还原位置键*/
caseKeyEvent.VK_R:
x=50;
y=50;
break;
}
locateDirection();//合成方向
}
/*合成移动方向*/
voidlocateDirection(){
if(bL&&!bU&&!bR&&!bD)dir=Direction.L;
elseif(bL&&bU&&!bR&&!bD)dir=Direction.LU;
elseif(!bL&&bU&&!bR&&!bD)dir=Direction.U;
elseif(!bL&&bU&&bR&&!bD)dir=Direction.RU;
elseif(!bL&&!bU&&bR&&!bD)dir=Direction.R;
elseif(!bL&&!bU&&bR&&bD)dir=Direction.RD;
elseif(!bL&&!bU&&!bR&&bD)dir=Direction.D;
elseif(bL&&!bU&&!bR&&bD)dir=Direction.LD;
elseif(!bL&&!bU&&!bR&&!bD)dir=Direction.STOP;
}
voidmove(){//移动
/*记录上一步的位置*/
oldX=x;
oldY=y;
switch(dir){
caseL:
x-=XSPEED;
break;
caseLU:
x-=XSPEED;
y-=YSPEED;
break;
caseU:
y-=YSPEED;
break;
caseRU:
x+=XSPEED;
y-=YSPEED;
break;
caseR:
x+=XSPEED;
break;
caseRD:
x+=XSPEED;
y+=YSPEED;
break;
caseD:
y+=YSPEED;
break;
caseLD:
x-=XSPEED;
y+=YSPEED;
break;
caseSTOP:
break;
}
/*判断坦克移动越界情况（游戏边界）*/
if(x<5)x=5;
if(y<25)y=25;
if(x+Whith>tc.GAME_WIDTH-5)x=tc.GAME_WIDTH-Whith-5;
if(y+Higth>tc.GAME_HEIGTH-5)y=tc.GAME_HEIGTH-Higth-5;
if(dir!=Direction.STOP)//如果坦克不静止就改变炮筒方向
ptDir=dir;
/*敌方坦克自动移动*/
if(!good){
Direction[]dirs=Direction.values();//将方向变量设为数组
if(step==0){
step=r.nextInt(12)+3;//随机移动步骤
intrandomNumber=r.nextInt(dirs.length);//随机移动方向
dir=dirs[randomNumber];
}
step--;
if(r.nextInt(40)>30)this.fire();//随机是否发射炮弹
}
}
/*敌方坦克复活*/
publicvoidfuhuo(){
if(tc.tanks.size()<20)
while(true){
intx=r.nextInt(700);
inty=r.nextInt(500);
Tankt=newTank(x,y,false,Color.blue,Direction.D,tc);
/*如果坦克与墙重合则重新随机位置直到不重合为止才将新坦克加入集合*/
if(t.getRect().intersects(tc.wall1.getRect())||t.getRect().intersects(tc.wall2.getRect())
||t.getRect().intersects(tc.wall3.getRect())
||t.getRect().intersects(tc.wall4.getRect())){
continue;
}
else{
tc.tanks.add(t);
break;
}
}
}
/*子弹发射*/
publicvoidfire(){
intx=this.x+Whith/2-Missile.Whith/2;//控制子弹方向为坦克中间
inty=this.y+Higth/2-Missile.Higth/2;
tc.missiles.add(newMissile(ptDir,color,x,y,good,tc));//创建新的子弹类加入到子弹集合中
}
/*碰撞；获取坦克的范围*/
publicRectanglegetRect(){
returnnewRectangle(x,y,Whith,Higth);
}
/*回执上一步位置*/
privatevoidstay(){
x=oldX;
y=oldY;
}
/*如果撞墙，调用stay方法，返回上一步位置*/
publicbooleanhitWall(Wallw){
if(this.live&&this.getRect().intersects(w.getRect())){
this.stay();
returntrue;
}
returnfalse;
}
/*坦克互相撞击事件*/
publicbooleanhitTanks(List<Tank>tanks){
for(inti=0;i<tanks.size();i++){
Tankt=tanks.get(i);
if(this!=t){//自己与自己不可相撞
/*如果相撞返回上一步位置*/
if(this.live&&t.isLive()&&this.getRect().intersects(t.getRect())){
this.stay();
t.stay();
returntrue;
}
}
}
returnfalse;
}
/*带开火方向的发射函数*/
publicMissilefire(Directiondir){
if(!live)returnnull;
intx=this.x+Whith/2-Missile.Whith/2;
inty=this.y+Higth/2-Missile.Higth/2;
Missilem=newMissile(dir,color,x,y,good,this.tc);
tc.missiles.add(m);
returnm;
}
/*超级射击导弹*/
privatevoidsuperFire(){
Direction[]dirs=Direction.values();
for(inti=0;i<8;i++){
fire(dirs[i]);//循环调用八个方向
}
}
/*新增血块类*/
privateclassBloodBar{
/*画血条*/
publicvoiddraw(Graphicsg){
Colorc=g.getColor();
g.setColor(Color.red);
g.drawRect(x,y-10,Whith,10);
intw=Whith*Life/100;
g.fillRect(x,y-10,w,10);
g.setColor(c);
}
}
/*吃血方法*/
publicbooleaneatBlood(Bloodb){
if(this.live&&b.isLive()&&this.isGood()&&this.getRect().intersects(b.getRect())){
this.setLife(100);
b.setLive(false);
returntrue;
}
if(this.getRect().intersects(tc.wb.getRect()))
this.Life=100;
returnfalse;
}
}
Missile.java
importjava.awt.Color;
importjava.awt.Graphics;
importjava.awt.Rectangle;
importjava.util.List;
publicclassMissile{
/*子弹本身数据*/
Tank.Directiondir;//子弹方向
Colorc;//子弹颜色
intx,y;//子弹位置
publicstaticfinalintXSPEED=15;//横向移动速度
publicstaticfinalintYSPEED=15;//纵向移动速度
publicstaticfinalintWhith=10;//子弹宽
publicstaticfinalintHigth=10;//子弹高
privatebooleanlive=true;//判断子弹的存活
privatebooleangood;//判断子弹和阵营
privateTankClienttc;//主类权限
publicMissile(Tank.Directiondir,Colorc,intx,inty){
super();
this.dir=dir;
this.x=x;
this.y=y;
this.c=c;
}
publicMissile(Tank.Directiondir,Colorc,intx,inty,booleangood,TankClienttc){
this(dir,c,x,y);
this.good=good;
this.tc=tc;
}
/*获取子弹的存活*/
publicbooleanisLive(){
returnlive;
}
/*设置子弹的存活*/
publicvoidsetLive(booleanlive){
this.live=live;
}
publicvoiddraw(Graphicsg){
/*如果子弹死亡状态将这个子弹在子弹集合中删除*/
if(!live){
tc.missiles.remove(this);//集合中删除
return;
}
/*先保存之前的画笔颜色，画完之后再还原画笔颜色*/
Colord=g.getColor();//获取当前画笔颜色
g.setColor(c);//设置画笔颜色为红色
/*画子弹*/
g.fillOval(x,y,Whith,Higth);
g.setColor(d);//还原画笔颜色
move();//移动
}
publicvoidmove(){
/*判断移动方向移动坦克位置*/
switch(dir){
caseL:
x-=XSPEED;
break;
caseLU:
x-=XSPEED;
y-=YSPEED;
break;
caseU:
y-=YSPEED;
break;
caseRU:
x+=XSPEED;
y-=YSPEED;
break;
caseR:
x+=XSPEED;
break;
caseRD:
x+=XSPEED;
y+=YSPEED;
break;
caseD:
y+=YSPEED;
break;
caseLD:
x-=XSPEED;
y+=YSPEED;
break;
caseSTOP:
break;
}
/*判断子弹的越界情况；出界则子弹死亡，在子弹集合中删去*/
if(x<0||y<0||x>TankClient.GAME_WIDTH||y>TankClient.GAME_HEIGTH)
live=false;
}
/*碰撞；获取子弹的范围*/
publicRectanglegetRect(){
returnnewRectangle(x,y,Whith,Higth);
}
/*子弹与坦克碰撞过程*/
publicbooleanhitTank(Tankt){
/*如果子弹与坦克在同一范围则子弹和坦克同时死亡；且子弹只能杀死对方坦克*/
if(this.live&&this.getRect().intersects(t.getRect())&&t.isLive()&&this.good!=t.isGood()){
if(t.isGood()){//好坦克
/*我方坦克子弹射中会减少生命值，生命值0的时候会死亡*/
t.setLife(t.getLife()-20);
if(t.getLife()<=0)
t.setLive(false);
}else{//坏坦克
t.setLive(false);//死亡
}
this.live=false;//子弹死亡
tc.explode.add(newExplode(x,y,tc));//新建爆炸加入集合
returntrue;
}
returnfalse;
}
/*循环坦克集合分别进行判断子弹碰撞*/
publicbooleanhitTanks(List<Tank>tanks){
for(inti=0;i<tanks.size();i++){
if(hitTank(tanks.get(i)))
returntrue;
}
returnfalse;
}
/*子弹与墙的碰撞过程*/
publicbooleanhitWall(Wallw){
/*如果子弹与墙的范围重合子弹死亡*/
if(this.live&&this.getRect().intersects(w.getRect())){
this.live=false;//子弹死亡
returntrue;
}
returnfalse;
}
}
Wall.java
importjava.awt.Graphics;
importjava.awt.Rectangle;
publicclassWall{
/*墙数据*/
intx,y,w,h;//位置和宽高
privateTankClienttc;//主类权限
publicWall(intx,inty,intw,inth,TankClienttc){
super();
this.x=x;
this.y=y;
this.w=w;
this.h=h;
this.tc=tc;
}
/*获取墙的范围*/
publicRectanglegetRect(){
returnnewRectangle(x,y,w,h);
}
/*画墙*/
publicvoiddraw(Graphicsg){
g.fillRect(x,y,w,h);
}
}
Explode.java
importjava.awt.Color;
importjava.awt.Graphics;
publicclassExplode{
/*坦克爆炸属性*/
intx,y;//爆炸位置
privatebooleanlive=true;//爆炸是否存在
intstep=0;//爆炸时间控制
int[]diameter=newint[]{4,7,12,18,26,32,49,56,65,77,80,50,40,30,14,6};//爆炸范围
privateTankClienttc;//主类权限
publicExplode(intx,inty,TankClienttc){
super();
this.x=x;
this.y=y;
this.tc=tc;
}
/*画爆炸*/
publicvoiddraw(Graphicsg){
if(!live)return;//如果爆炸死亡状态不画结束
/*如果爆炸时间结束爆炸不存在并在集合中删除*/
if(step==diameter.length){
live=false;//爆炸死亡
step=0;//步骤时间归0
tc.explode.remove(this);//集合中删除
return;
}
/*画爆炸*/
Colorc=g.getColor();
g.setColor(Color.orange);
g.fillOval(x,y,diameter[step],diameter[step]);
g.setColor(c);
step++;
}
}
Blood.java
importjava.awt.Color;
importjava.awt.Graphics;
importjava.awt.Rectangle;
importjava.util.Random;
publicclassBlood{
/*血块数据*/
intx,y,w,h;//血块位置和大小
privateTankClienttc;//主类权限
privatebooleanlive=true;//血块的存活
privatestaticRandomr=newRandom();//设置一个随机值变量
/*获取血块的存活状态*/
publicbooleanisLive(){
returnlive;
}
/*设置血块的存活状态*/
publicvoidsetLive(booleanlive){
this.live=live;
}
/*血块位置初值随机一个数值*/
publicBlood(){
x=r.nextInt(600)+100;
y=r.nextInt(400)+100;
w=h=15;
}
/*画血块*/
publicvoiddraw(Graphicsg){
if(!live)return;
Colorc=g.getColor();
g.setColor(Color.magenta);
g.fillRect(x,y,w,h);
g.setColor(c);
}
/*释放血块*/
publicvoidfh(){
if(!live){
x=r.nextInt(600)+100;
y=r.nextInt(400)+100;
live=true;
}
}
/*获取血块范围*/
publicRectanglegetRect(){
returnnewRectangle(x,y,w,h);
}
}
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持毛票票。