java坦克大战爆炸效果_Java坦克大战 (五) 之产生敌方坦克和爆炸效果

在此小易将坦克大战这个项目分为几个版本，以此对J2SE的知识进行回顾和总结，希望这样也能给刚学完J2SE的小伙伴们一点启示！

(此版本基本上就可以和电脑对打了，不信把源码放到你的电脑上就可以马上开启坦克大战之旅哦)

坦克大战V0.5实现功能：

1、产生一个敌方坦克

2、将敌人坦克击毙，相应的子弹和坦克都消失

3、添加爆炸效果

4、添加多辆坦克，并能够打掉敌方坦克

5、让敌方坦克可以随机运动，可以打出子弹打掉我方坦克

6、加两堵墙出来，可以吞没子弹，挡住敌方坦克

7、敌方坦克相撞不能穿透过去

注意事项：

1、画一辆敌人的坦克，步骤：加入区别敌我的量good，根据敌我的不同设置不同的颜色更新Tank的构造函数，加入good，TankClient中new 出敌人的坦克并画出(注意如果新增加了成员变量，就要马上考虑是否要更改或新增构造方法)

2、将敌人坦克击毙，分析：一颗子弹击中敌人坦克，步骤：Missle中加入hitTank(Tank)方法，返回布尔类型；利用碰撞检测的辅助类Rectangle；为Tank和Missle都加入getRect方法；当击中敌人坦克时，坦克被打死，子弹也死去；增加控制Tank生死的量live，如果死去就不画了

3、加入爆炸，步骤：添加爆炸类；用不同直径的圆模拟爆炸；加入live；加入位置属性；加入draw方法。爆炸应该存在于集合类中；TankClient加入集合；将集合中的爆炸逐一画出(如果死去就去除)。击毙一辆坦克后应产生爆炸；hitTank时应产生爆炸

4、添加多辆坦克，步骤：用容器来装敌人的Tank；向容器中装入多辆敌人Tank；画出来；运行，不能打掉；添加hitTanks方法，打一系列Tank；TankClient里面每发子弹都打tanks

5、让敌军坦克更加智能，步骤：

==>让敌军坦克动起来：构造函数中可以指定方向；new敌军坦克的时候指定敌军坦克的方向。

==>让敌军坦克向随机方向移动：(Tank)静态的，添加随机数产生器 java.util.Random；move完成后，如果是敌军坦克的，随机产生一个数，来设定坦克下一个方向；Direction.values()。

==>让敌军坦克向随机方向移动随机的步骤：添加变量，记录随机步骤；当==0时，改变方向，否则，只是随机步骤递减；

==>让敌军坦克发射炮弹：本军炮弹不打本军；炮弹添加好坏bGood，根据好坏画不同颜色；修改炮弹的构造方法；修改Tank的fire方法；修改hitTank方法，好不能打好，坏不能打坏

6、添加两堵墙，步骤：建Wall类、建立Wall对象、画出来。

==>让每一颗子弹打击每一堵墙：hitWall()方法；注意子弹速度不能太快，否则很容易穿过墙；

==>让坦克不能穿过墙：记录上一次的位置oldX, oldY；修改构造函数；每次move之前纪录上一次位置；添加stay方法；记录移动前的位置；当撞到时回到移动前的位置；当碰到墙的时候stay

坦克大战V0.5源代码：

TankClient类：

import java.awt.*;

import java.awt.event.*;

import java.util.List; //java.awt包中也有个List，所以此处要导包明确

import java.util.ArrayList;

public class TankClient extends Frame {

public static final int GAME_WIDTH = 800;

public static final int GAME_HEIGHT = 600;

Tank myTank = new Tank(350, 450, true, Tank.Direction.STOP, this); //我方坦克

Wall w1 = new Wall(100, 300, 20, 100, this), w2 = new Wall(300, 250, 150, 20, this);

List missiles = new ArrayList(); //定义一个集合来装子弹

List explodes = new ArrayList();

List tanks = new ArrayList();

Image offScreenImage = null; //定义一个屏幕后的虚拟图片

@Override

public void paint(Graphics g) {

g.drawString("missiles Count: " + missiles.size(), 10, 50); //用来记录missiles中子弹的个数

g.drawString("explodes Count: " + explodes.size(), 10, 70);

g.drawString("tanks Count: " + tanks.size(), 10, 90);

for (int i = 0; i < missiles.size(); i++) { //遍历集合，把其中的子弹画出来

Missile m = missiles.get(i);

m.hitTanks(tanks);

m.hitTank(myTank);

m.hitWall(w1); //检测子弹是否撞墙

m.hitWall(w2);

m.drawMissile(g);

}

for (int i = 0; i < explodes.size(); i++) {

Explode e = explodes.get(i);

e.draw(g);

}

for (int i = 0; i < tanks.size(); i++) {

Tank t = tanks.get(i);

t.collidesWithWall(w1); //检测敌方坦克是否撞墙

t.collidesWithWall(w2);

t.collidesWithTanks(tanks);

t.drawTank(g);

}

myTank.drawTank(g);

w1.draw(g);

w2.draw(g);

}

//利用双缓冲消除圆圈移动时屏幕的闪动

@Override

public void update(Graphics g) {

if (offScreenImage == null) {

offScreenImage = this.createImage(GAME_WIDTH, GAME_HEIGHT); //判断是为了避免每次重画时都给offScreenImage赋值

}

Graphics gOffScreen = offScreenImage.getGraphics(); //定义虚拟图片上的画笔gOffScreen

Color c = gOffScreen.getColor();

gOffScreen.setColor(Color.GREEN);

gOffScreen.fillRect(0, 0, GAME_WIDTH, GAME_HEIGHT); //重画背景，如果没有这句则在屏幕上会保留圆圈的移动路径

gOffScreen.setColor(c);

paint(gOffScreen); //把圆圈画到虚拟图片上

g.drawImage(offScreenImage, 0, 0, null); //再一次性把虚拟图片画到真实屏幕上，在真实屏幕上画则要用真实屏幕的画笔g

}

public void luanchFrame() {

for(int i = 0; i < 10; i++) {

tanks.add(new Tank(50 + 40*(i+1), 50, false,Tank.Direction.D, this));

}

this.setLocation(300, 50);

this.setSize(GAME_WIDTH, GAME_HEIGHT);

this.setTitle("坦克大战 - By:小易 - QQ：381740148");

this.setResizable(false); //不允许改变窗口大小

this.addWindowListener(new WindowAdapter() {

@Override

public void windowClosing(WindowEvent e) {

System.exit(0);

}

}); //添加关闭功能，此处使用匿名类比较合适

this.setBackground(Color.GREEN);

this.addKeyListener(new KeyMonitor());

setVisible(true);

new Thread(new PaintThread()).start(); //启动线程，实例化线程对象时不要忘了new Thread(Runnable对象);

}

public static void main(String[] args) {

TankClient tc = new TankClient();

tc.luanchFrame();

}

//PaintThread只为TankClient服务，所以写成内部类好些

public class PaintThread implements Runnable {

public void run() {

while (true) {

repaint(); //repaint()是TankClient或者他的父类的方法，内部类可以访问外部包装类的成员，这也是内部类的好处

try {

Thread.sleep(50); //每隔50毫秒重画一次

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

}

public class KeyMonitor extends KeyAdapter {

@Override

public void keyReleased(KeyEvent e) {

myTank.keyReleased(e);

}

@Override

public void keyPressed(KeyEvent e) {

myTank.keyPressed(e);

}

}

}

Tank类：

import java.awt.*;

import java.awt.event.*;

import java.util.Random;

public class Tank {

public static final int XSPEED = 5; //定义常量X轴速度

public static final int YSPEED = 5;

public static final int WIDTH = 30;

public static final int HEIGHT = 30;

//定义一个随机数产生器，此时的Random类是java.util.Random，不同于Math中的

private static Random r = new Random(); //随机数产生器只需要一个，所以定义成静态，防止每次new一个坦克是都会产生一个随机数产生器

private boolean good; //定义变量说明是我方还是敌方坦克，为true表示我方坦克

private boolean live = true; //定义变量说明是坦克是否存活

TankClient tc;

private int x , y; //定义变量画圆圈(坦克)时四边形左上点的x、y左边

private int oldX , oldY; //定义坦克上个位置的坐标

private boolean bL = false, bU = false, bR = false, bD = false; //定义变量左上右下的按键是否被按下

enum Direction {L,LU,U,RU,R,RD,D,LD,STOP}; //定义枚举类型，值为左、左上、上、右上、右、右下、下、左下、停止

private Direction dir = Direction.STOP; //定义变量坦克的方向

private Direction ptDir = Direction.D; //定义变量坦克炮筒的方向，起初向下

private int step = r.nextInt(12) + 3; //定义坦克朝着一个方向移动几步

public Tank(int x, int y, boolean good) {

this.x = x;

this.y = y;

this.good = good;

this.oldX = x;

this.oldY =y;

}

public Tank(int x, int y, boolean good, Direction dir, TankClient tc) {

this(x, y, good); //相当于调用上面的构造方法

this.dir = dir;

this.tc = tc;

}

public void drawTank(Graphics g) {

if(!live) {

if(!good) {

tc.tanks.remove(this);

}

return; //如果坦克没有存活就直接返回，不用画坦克了

}

Color c = g.getColor(); //取得g(以后称为画笔)的颜色

if(good) g.setColor(Color.RED);

else g.setColor(Color.BLUE);

g.fillOval(x, y, WIDTH, HEIGHT); //"画圆",利用填充一个四边形(四边形的内切圆)，参数分别代表：四边形左上点的坐标X，Y，宽度，高度

g.setColor(c); //用完画笔后把画笔默认的颜色(黑色)设置回去

//根据炮筒的方向，画直线代表炮筒

switch (ptDir) {

case L:

g.drawLine(x+Tank.WIDTH/2, y+Tank.HEIGHT/2, x, y+Tank.HEIGHT/2);

break;

case LU:

g.drawLine(x+Tank.WIDTH/2, y+Tank.HEIGHT/2, x, y);

break;

case U:

g.drawLine(x+Tank.WIDTH/2, y+Tank.HEIGHT/2, x+Tank.WIDTH/2, y);

break;

case RU:

g.drawLine(x+Tank.WIDTH/2, y+Tank.HEIGHT/2, x+Tank.WIDTH, y);

break;

case R:

g.drawLine(x+Tank.WIDTH/2, y+Tank.HEIGHT/2, x+Tank.WIDTH, y+Tank.HEIGHT/2);

break;

case RD:

g.drawLine(x+Tank.WIDTH/2, y+Tank.HEIGHT/2, x+Tank.WIDTH, y+Tank.HEIGHT);

break;

case D:

g.drawLine(x+Tank.WIDTH/2, y+Tank.HEIGHT/2, x+Tank.WIDTH/2, y+Tank.HEIGHT);

break;

case LD:

g.drawLine(x+Tank.WIDTH/2, y+Tank.HEIGHT/2, x, y+Tank.HEIGHT);

break;

}

move(); //每次按键都会重画，就会调用drawTank，在这里重画坦克的此时位置

}

public void keyPressed(KeyEvent e) {

int key = e.getKeyCode(); //得到按键的虚拟码，再和下面的KeyEvent.VK_LEFT等虚拟码比较看是否是某按键

switch (key) {

case KeyEvent.VK_LEFT:

bL = true;

break;

case KeyEvent.VK_UP:

bU = true;

break;

case KeyEvent.VK_RIGHT:

bR = true;

break;

case KeyEvent.VK_DOWN:

bD = true;

break;

}

locateDraction();

if (dir != Direction.STOP) {

ptDir = dir;

}

}

public void keyReleased(KeyEvent e) {

int key = e.getKeyCode();

switch (key) {

case KeyEvent.VK_R: //按R就发射子弹调用fire方法

fire(); //只有松开R才能发出子弹

break;

case KeyEvent.VK_LEFT:

bL = false;

break;

case KeyEvent.VK_UP:

bU = false;

break;

case KeyEvent.VK_RIGHT:

bR = false;

break;

case KeyEvent.VK_DOWN:

bD = false;

break;

}

locateDraction();

}

//通过上右下的按键是否被按下判断坦克要运动的方向

void locateDraction() {

if(bL && !bU && !bR && !bD) dir =Direction.L;

else if(bL && bU && !bR && !bD) dir =Direction.LU;

else if(!bL && bU && !bR && !bD) dir =Direction.U;

else if(!bL && bU && bR && !bD) dir =Direction.RU;

else if(!bL && !bU && bR && !bD) dir =Direction.R;

else if(!bL && !bU && bR && bD) dir =Direction.RD;

else if(!bL && !bU && !bR && bD) dir =Direction.D;

else if(bL && !bU && !bR && bD) dir =Direction.LD;

else if(!bL && !bU && !bR && !bD) dir =Direction.STOP;

}

public void move() {

oldX = x;

oldY = y;

switch (dir) {

case L:

x -= XSPEED;

break;

case LU:

x -= XSPEED;

y -= YSPEED;

break;

case U:

y -= YSPEED;

break;

case RU:

x += XSPEED;

y -= YSPEED;

break;

case R:

x += XSPEED;

break;

case RD:

x += XSPEED;

y += YSPEED;

break;

case D:

y += YSPEED;

break;

case LD:

x -= XSPEED;

y += YSPEED;

break;

case STOP:

break;

}

if(this.dir != Direction.STOP) {

this.ptDir = this.dir;

}

//防止坦克出界

if (x < 0) x = 0;

if (y < 25) y = 25; //考虑了标题栏的高度

if (x + Tank.WIDTH > TankClient.GAME_WIDTH) x = TankClient.GAME_WIDTH - Tank.WIDTH;

if (y + Tank.HEIGHT > TankClient.GAME_HEIGHT) y = TankClient.GAME_HEIGHT - Tank.HEIGHT;

if (!good) {

Direction[] dirs = Direction.values(); //把枚举转换成数组

if (step == 0) {

int rn = r.nextInt(dirs.length);

dir = dirs[rn]; //如果移动步数为0就改变方向

step = r.nextInt(12) + 3;

}

step --;

if(r.nextInt(40) > 37) this.fire();

}

}

public void stay() {

x = oldX;

y = oldY;

}

//坦克开火，就new一个子弹出来

private Missile fire() {

if(!live) return null;

int x = this.x + Tank.WIDTH/2 - Missile.WIDTH/2; //让子弹从坦克中心打出

int y = this.y + Tank.HEIGHT/2 - Missile.HEIGHT/2;

Missile m = new Missile(x, y,good, ptDir , this.tc);

tc.missiles.add(m); //每new一个Missile对象就把他装到集合中

return m; //返回的m，其他地方可调用可不调用

}

public Rectangle getRect() {

return new Rectangle(x, y, WIDTH, HEIGHT); //得到坦克的探测方块，Rectangle是java.awt包中专门用于游戏碰撞的类

}

public boolean isLive() {

return live;

}

//Tank类的成员方法可生成对应的get和set方法，那么在其他类中就可以访问了

public void setLive(boolean live) {

this.live = live;

}

public boolean isGood() {

return good;

}

//检测坦克是否撞墙

public boolean collidesWithWall(Wall w) {

if(this.live && this.getRect().intersects(w.getRect())) {

stay(); //如果坦克撞到墙就让他回到上一个位置

return true;

}

return false;

}

//检测坦克是否相撞,java.util.List接口或者类的另一种写法，java.awt中也有List，所以要写明确

public boolean collidesWithTanks(java.util.List tanks) {

for (int i = 0; i < tanks.size(); i++) {

Tank t = tanks.get(i);

if (this != t) {

if(this.live && t.isLive() && this.getRect().intersects(t.getRect())) {

this.stay();

t.stay();

return true;

}

}

}

return false;

}

}

Missile类：

import java.awt.*;

import java.util.List;

public class Missile {

public static final int XSPEED = 10;

public static final int YSPEED = 10;

public static final int WIDTH = 10;

public static final int HEIGHT = 10;

int x, y;

Tank.Direction dir;

private boolean good; //定义变量表示是否是我方子弹

private boolean live = true; //定义一个判断子弹是否出界的变量

private TankClient tc;

public Missile(int x, int y, Tank.Direction dir) {

this.x = x;

this.y = y;

this.dir = dir;

}

public Missile(int x, int y,boolean good, Tank.Direction dir, TankClient tc) {

this(x, y, dir);

this.good = good;

this.tc = tc;

}

public void drawMissile(Graphics g) {

if(!live) {

tc.missiles.remove(this);

return;

}

Color c = g.getColor();

g.setColor(Color.BLACK);

g.fillOval(x, y, WIDTH, HEIGHT);

g.setColor(c);

move();

}

private void move() {

switch (dir) {

case L:

x -= XSPEED;

break;

case LU:

x -= XSPEED;

y -= YSPEED;

break;

case U:

y -= YSPEED;

break;

case RU:

x += XSPEED;

y -= YSPEED;

break;

case R:

x += XSPEED;

break;

case RD:

x += XSPEED;

y += YSPEED;

break;

case D:

y += YSPEED;

break;

case LD:

x -= XSPEED;

y += YSPEED;

break;

}

if (x < 0 || y < 0 || x > tc.GAME_WIDTH || y > tc.GAME_HEIGHT) {

live = false;

}

}

public boolean isLive() {

return live;

}

public Rectangle getRect() {

return new Rectangle(x, y, WIDTH, HEIGHT); //得到子弹的探测方块，Rectangle是java.awt包中专门用于游戏碰撞的类

}

//判断子弹是否打到了坦克

public boolean hitTank(Tank t) {

//intersects是Rectangle的一个方法；t.isLive()是为了判断坦克是否存活，如果没有则打掉这个坦克后，之后的子弹到达原来这个坦克的位置就会消失

if (this.live && this.getRect().intersects(t.getRect()) && t.isLive() && this.good != t.isGood()) {

t.setLive(false);

this.live = false;

Explode e = new Explode(x, y, tc);

tc.explodes.add(e);

return true;

}

return false;

}

public boolean hitTanks(List tanks) {

for (int i = 0; i < tanks.size(); i++) {

if (hitTank(tanks.get(i))) {

return true;

}

}

return false;

}

public boolean hitWall(Wall w) {

if(this.live && this.getRect().intersects(w.getRect())) {

this.live = false;

return true;

}

return false;

}

}

Explode类：

import java.awt.*;

//爆炸类(爆炸的英文：explode)

public class Explode {

int x, y;

private TankClient tc;

private boolean live = true;

int[] diameter = {4, 10, 20, 36, 56, 24, 12, 6}; //定义画不同直径的圆表示爆炸(直径的英文:diameter)

int step = 0; //定义变量代表画爆炸的圆画到第几个了

public Explode(int x, int y, TankClient tc) {

this.x = x;

this.y = y;

this.tc = tc;

}

public void draw(Graphics g) {

if(!live) {

tc.explodes.remove(this);

return;

}

if (step == diameter.length) {

live = false;

step = 0;

return;

}

Color c = g.getColor();

g.setColor(Color.ORANGE);

g.fillOval(x, y, diameter[step], diameter[step]);

g.setColor(c);

step ++ ;

}

}

Wall类：

import java.awt.*;

public class Wall {

private int x, y, w, h;

private TankClient tc;

public Wall(int x, int y, int w, int h, TankClient tc) {

this.x = x;

this.y = y;

this.w = w;

this.h = h;

this.tc = tc;

}

public void draw(Graphics g) {

g.fillRect(x, y, w, h);

}

public Rectangle getRect() {

return new Rectangle(x, y, w, h);

}

}

知识点回顾：

1、碰撞检测的辅助类Rectangle，属于java.awt.Rectangle中,用法：

==>首先获取两个要检测物体的边界，相当于一个Rectangle对象，可以给他们定义相应的getRect()方法，返回值为一个Rectangle对象，在函数内return

new Rectangle(x, y, w, h);

==>定义一个方法判断是否碰撞到了，返回值为boolean，物体1.getRect().intersects(物体2.getRect())的返回值也是一个boolean类型，返回真则表示碰撞到了，再执行相应的功能，反之亦然。

2、将枚举转换成数组：枚举名.values()，返回的是相应的数组。如：Direction[] dirs = Direction.values();返回的是Direction类型的数组

3、随机数的使用：

==>java.util.Random比较方便，可以直接产生随机整数，使用时先定义一个随机数产生器，如：定义随机数产生器：Random

r = new Random(); 产生随机数整数：r.nextInt(12)表示产生一个0-11的随机整数

==>math.random()产生的是一个0-1的数，使用时一般要通过计算转换，比较麻烦