坦克大战（TankWar）

花了一个星期的时间把马士兵老师讲的那个单机版坦克大战编好了，在编写过程中经常出错，由于对debug使用还不是很熟练，每次修复bug都要花很长时间，现在终于编好了个demo，给大家分享下

编TankWar，主要功能有 1.能够四处移动、2.-能够打击敌人 3.敌人能够移动 4.能够模拟爆炸 5.能够产生障碍

编程过程中的思想：

* 1.首先先new出一个frame，并设置大小，位置，
 * 2.用户不能改变窗口大小，监听窗口关闭
 * 3.画出一个子弹，设置大小和颜色
 * 4.让坦克动起来，将a位置改变为变量，b启动线程不断重画 ,c每次重画改变Tank位置
 * 5. 使用双缓冲消除闪烁现象，将所有东西画在虚拟图片上,一次性显示出来
 * 6.添加键盘监听器类KeyMonitor,针对不同的键改变坦克的位置，与重画线程结合产生不同方向运动,
 * 7.将坦克单独包装成类，
 * 8.让主战坦克向8个方向行走,
 * 9主战坦克向8个方向行走,并处理键抬起的消息
 * 10.添加子弹类
 * 11.根据主战坦克的方向和位置，打出子弹
 * 12.解决坦克停下也能打出炮弹的问题—画出炮筒,步骤一：Tank类增加新的属性ptDir
        步骤二：每次move后根据Tank新的方向确定炮筒的方向
 步骤三：将炮筒用直线的形式表现出来
 * 13.打出多发炮弹 步骤一：使用容器装炮弹，步骤二：每当抬起Ctrl键就往容器中加入新的炮弹，步骤三：逐一画出每一发炮弹
 * 14.解决炮弹不消亡的问题，解决坦克出界的问题。步骤一：加入控制炮弹生死的量bLive（Missle）
 *   步骤二：当炮弹已经死去就不需要对其重画，步骤三：当炮弹飞出边界就死亡，步骤四：当炮弹死亡就从容器中去除
 *15 画一辆敌人的坦克，步骤一：加入区别敌我的量good，步骤二：根据敌我的不同设置不同的颜色
 *  步骤三：更新Tank的构造函数，加入good，步骤四：TankClient中new 出敌人的坦克并画出
 *16 一颗子弹击中敌人坦克 步骤一：Missle中加入hitTank(Tank)方法，返回布尔类型；步骤二：碰撞检测的辅助类Rectangle
 *步骤三：为Tank和Missle都加入getRect方法 步骤四：当击中敌人坦克时，坦克被打死，子弹也死去
 *步骤五：增加控制Tank生死的量live 步骤六：如果死去就不画了
 *17 加入爆炸:步骤一：添加爆炸类，步骤二：爆炸应存在于集合类中，步骤三：击毙一辆坦克后应产生爆炸
 *18添加多辆坦克，步骤一：用容器来装敌人的Tank，步骤二：向容器中装入多辆敌人Tank，步骤三：画出来
 *19.让敌军坦克更加智能,步骤一：让敌军坦克动起来，步骤二：让敌军坦克向随机方向移动，步骤三：让敌军坦克向随机方向移动随机的步骤
 *   步骤四：让敌军坦克发射炮弹 步骤五：敌军炮火不能太猛烈
 *20添加两堵墙
 *21坦克不能互相穿越
 *22超级炮弹
 *23,主战坦克的生命值
 *24 画出主坦克的血块

这个程序总共五个类：

先发TankClient.java这个类

package cn.shaoyangjiang.com;
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.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(50,200,true,Tank.Driection.STOP,this);
    //设置两堵墙
    Wall w1 = new Wall(100, 200, 20, 150, this), w2 = new Wall(300, 100, 300, 20, this);
    //泛型，new出一个容器放子弹,爆炸，坦克
    List<Missile> missiles = new ArrayList<Missile>();
    List<Explode> explodes = new ArrayList<Explode>();
    List<Tank> tanks = new ArrayList<Tank>();
    
    Image offScreenImage = null;
    
   //绘制容器 ，画坦克和子弹
    public void paint(Graphics g){
        //当坏坦克数量小于3时，再出来5辆坦克
        if(tanks.size()<3){
            for(int i=0; i <5;i++){
                tanks.add(new Tank(50 + 40*(i+1),50,false ,Tank.Driection.D,this));
            }
        }
        //这句是用来测试missiles里可以放多少子弹
        g.drawString("missiles count:" + missiles.size(), 10, 50);
        g.drawString("explodes count:" + explodes.size(), 10, 70);
        g.drawString("tanks count" + tanks.size(), 10, 90);
        g.drawString("tank life" + myTank.getLife(),10,110);
        
        //挨个画ArrayList容器里的子弹，逐一画出每一发炮弹
        for( int i=0; i<missiles.size();i++){
            Missile m = missiles.get(i);
            //TankClient里面的每发子弹都打tanks
            m.hitTanks(tanks);
            m.hitTank(myTank);
            m.hitWall(w1);
            m.hitWall(w2);
            m.draw(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.draw(g);
        }
        //画出自己的坦克
        myTank.draw(g);
        w1.draw(g);
        w2.draw(g);
    }
    
    // 使用双缓冲消除闪烁现象，将所有东西画在虚拟图片上,一次性显示出来
    public void update(Graphics g) {
        if(offScreenImage == null) {
            offScreenImage = this.createImage(GAME_WIDTH, GAME_HEIGHT);
        }
        Graphics gOffScreen = offScreenImage.getGraphics();
        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);
    }
    
    public void lauchFrame(){
        //增加坏坦克
        for(int i=0; i <12;i++){
            tanks.add(new Tank(50 + 40*(i+1),50,false ,Tank.Driection.D,this));
        }
    
        this.setTitle("邵洋江   vs tank");
        this.setSize(GAME_WIDTH, GAME_HEIGHT);
        this.setLocation(100, 100);
        this.setBackground(Color.GREEN);
        //用户不能改变窗口大小
        this.setResizable(false);
        this.setVisible(true);
        this.addWindowListener( new WindowAdapter() {
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
            
        });
        this.addKeyListener(new KeyMonitor());
        //4.启动线程
        new Thread(new PaintThread()).start();
    }
    
    public static void main(String[] args) {
        TankClient tc = new TankClient();
        tc.lauchFrame();
    }
    
    //每100毫秒重画一次
    private class PaintThread implements Runnable{
        public void run() {
            while(true){
                repaint();
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            
        }
    }

    //6让坦克动起来，添加键盘监听器类KeyMonitor,针对不同的键改变坦克的位置，与重画线程结合产生不同方向运动,
    private class KeyMonitor extends KeyAdapter{
        //按键按下
        public void keyPressed(KeyEvent e) {
            myTank.keyPressed(e);
        }
        //按键弹起
        public void keyReleased(KeyEvent e){
            myTank.keyReleased(e);
        }
    }
    

}

第二个类是Tank.java类

package cn.shaoyangjiang.com;
//可以方便的实现new出100辆坦克
/*
 * 建立Tank类
 为Tank类添加成员变量x y
 添加draw方法，使Tank类独立控制自己的画法
 添加Tank类处理按键的方法
 根据Tank类修改TankClient类

 */

import java.awt.*;
import java.awt.event.*;
import java.util.*;

public class Tank {
 //定义坦克移动常量
 private int x,y;
 private int oldx,oldy;
 public static final int XSPEED = 5;
 public static final int YSPEED = 5;
 public static final int WIDTH = 30;
 public static final int HEIGHT = 30;
 //定义四个按键状态
 private boolean bL = false, bU = false, bR = false,bD = false;
 //添加代表方向的枚举
 enum Driection {L,LU,U,RU,R,RD,D,LD,STOP};
 //指定一个初始的状态
 private Driection dir = Driection.STOP;
 //指定炮筒的初始位置
 private Driection ptDir = Driection.D;
 //持有对象的应用
 TankClient tc;
 //区分是自己的坦克还是敌人的坦克
 private boolean good;
 //坦克的生命值
 private int life = 100;
 //new出血块
 private BloodBar bb = new BloodBar();
 //这个方法是为其他类访问private的life
 public int getLife() {
  return life;
 }
 public void setLife(int life) {
  this.life = life;
 }

 public boolean isGood() {
  return good;
 }
 public void setGood(boolean good) {
  this.good = good;
 }

 //增加控制Tank生死的量live
 private boolean live = true;
 
 private static Random r = new Random();
 
 private int step = r.nextInt(12) + 3;
 
 public Tank(int x, int y, boolean good){
  this.x = x;
  this.y = y;
  this.oldx = x;
  this.oldy = y;
  this.good=good;
 }
 //方法的覆盖
 public Tank(int x, int y,boolean good, Driection dir,TankClient tc) {
  this(x,y,good);
  this.dir = dir;
  this.tc = tc;
 }
 //graphics指画笔，这里是画坦克
 public void draw(Graphics g){
  //如果坦克死了就不画了
  if(!live){
   if(!good){
    tc.tanks.remove(this);
   }
   return;
  }
  //如果是好的就画出血块
  if(good){
   bb.draw(g);
  }
  //取出前景色
  Color c = g.getColor();
  if(good) g.setColor(Color.RED);
  else g.setColor(Color.BLUE);
  //小坦克，前两个参数指定坐标，第三个是宽度，第四个是高度。
  g.fillOval(x, y , WIDTH, HEIGHT);
  //设回前景色
  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();
 }
 
 //坦克回到原来一步
 private void stay(){
  x = oldx;
  y = oldy;
 }
 //坦克移动的方法
 void move() {
  //把坦克的当前位置给oldx，oldy
  this.oldx = x;
  this.oldy = y;
  switch(dir) {
  case L :
   x = x - XSPEED;
   break;
  case LU :
   x = x - XSPEED;
   y = y - YSPEED;
   break;
  case U :
   y = y - YSPEED;
   break;
  case RU :
   x = x + XSPEED;
   y = y - YSPEED;
   break;
  case R :
   x = x + XSPEED;
   break;
  case RD :
   x = x + XSPEED;
   y = y + YSPEED;
   break;
  case D :
   y = y + YSPEED;
   break;
  case LD :
   x = x - XSPEED;
   y = y + YSPEED;
   break;
  case STOP :
   break;
  }
  //当坦克的方向改变时，炮筒的方向也改变。
  if(this.dir!= Tank.Driection.STOP) {
   this.ptDir = this.dir;
  }
  //防止坦克出界
  if(x < 0) x = 0;
  if(y < 30) y = 30;
  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){
   //把enum（枚举）里的方向转化为数组
   Driection[] dirs = Driection.values();
   if(step == 0){
   step = r.nextInt(12)+3;
   //随机产生一个数
   int rn = r.nextInt(dirs.length);
   dir = dirs[rn];
   }
   step--;
   if(r.nextInt(40) > 36) this.fire();
  }
 
  
 }
 
 //6让坦克动起来，添加键盘监听器类KeyMonitor,针对不同的键改变坦克的位置，与重画线程结合产生不同方向运动,
 //根据按键状态改变坦克的方向
   public void keyPressed(KeyEvent e) {
    int key = e.getKeyCode();
    switch(key){
    case KeyEvent.VK_LEFT:
     bL = true;
     break;
    case KeyEvent.VK_RIGHT:
     bR = true;
     break;
    case KeyEvent.VK_UP:
     bU = true;
     break;
    case KeyEvent.VK_DOWN:
     bD = true;
     break;
    }
    locationDircation();
   }
   
  //按键释放时,坦克停止 
   public void keyReleased(KeyEvent e) {
    int key = e.getKeyCode();
    switch(key){
    //按下F2重新出来自己的好坦克
    case KeyEvent.VK_F2:
     if(!this.live){
      this.live = true;
      life = 100;
     }
     break;
    //当ctrl弹起来的时候发出子弹
    case KeyEvent.VK_CONTROL:
     fire();
     break;
    case KeyEvent.VK_LEFT:
     bL = false;
     break;
    case KeyEvent.VK_RIGHT:
     bR = false;
     break;
    case KeyEvent.VK_UP:
     bU = false;
     break;
    case KeyEvent.VK_DOWN:
     bD = false;
     break;
    case KeyEvent.VK_A:
     superfire();
     break;
    }
    locationDircation();
   }
   
 //确定坦克的位置  
 void locationDircation(){
  if( bL && !bU && !bR && !bD ) dir = Driection.L;
  else if( bL && bU && !bR && !bD ) dir = Driection.LU;
  else if( !bL && bU && !bR && !bD ) dir = Driection.U;
  else if( !bL && bU && bR && !bD ) dir = Driection.RU;
  else if( !bL && !bU && bR && !bD ) dir = Driection.R;
  else if( !bL && !bU && bR && bD ) dir = Driection.RD;
  else if( !bL && !bU && !bR && bD ) dir = Driection.D;
  else if( bL && !bU && !bR && bD ) dir = Driection.LD;
  else if( !bL && !bU && !bR && !bD ) dir = Driection.STOP;
 }
 
 //打出子弹的方法
 public 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);
  return m;
 }
 //根据dir（有八个方向）的方向发出子弹
 public Missile fire(Driection dir) {
  if(!live) return null;
  int x = this.x + Tank.WIDTH/2 - Missile.WIDTH/2;
  int y = this.y + Tank.HEIGHT/2 - Missile.HEIGHT/2;
  //根据dir的方向
  Missile m = new Missile(x, y, good, dir, this.tc);
  tc.missiles.add(m);
  return m;
 }
 
 //碰撞检测的辅助类Rectangle，并加入getRect方法
 public Rectangle getRect() {
  return new Rectangle(x,y,WIDTH,HEIGHT);
 }
 
 //坦克不能穿越墙
 public boolean collidesWithWall(Wall w) {
  if(this.live && this.getRect().intersects(w.getRect())) {
   //坦克回到上一步停住
   this.stay();
   this.dir = Driection.STOP;
   return true;
  }
  return false;
 }
 
 //坦克不能互相穿越
 public boolean collidesWithTanks(java.util.List<Tank> 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;
 }
 //按八个方向打子弹的方法
 public void superfire(){
  Driection[] dirs = Driection.values();
  for(int i =0;i < 8;i ++){
   fire(dirs[i]);
  }
 }
 //血块
 private class BloodBar {
  public void draw(Graphics g) {
   Color c = g.getColor();
   g.setColor(Color.RED);
   g.drawRect(x, y-10, WIDTH, 10);
   int w = WIDTH * life/100 ;
   g.fillRect(x, y-10, w, 10);
   g.setColor(c);
  }
 }
 
 public boolean isLive() {
  return live;
 }
 
 public void setLive(boolean live) {
  this.live = live;
 }
 
}

第三个类是子弹类，Missile.java类

package cn.shaoyangjiang.com;
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.Driection dir;
    private boolean live = true;
    private TankClient tc;
    private boolean good;
    
    public Missile(int x, int y,Tank.Driection dir) {
        this.x = x;
        this.y = y;
        this.dir = dir;
    }
    
    //方法的重载
    public Missile(int x, int y,boolean good,Tank.Driection dir,TankClient tc){
        this(x,y,dir);
        this.good = good;
        this.tc = tc;
    }
    //绘制容器 ，画出一个子弹，设置大小和颜色
    public void draw(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 = x - XSPEED;
            break;
        case LU :
            x = x - XSPEED;
            y = y - YSPEED;
            break;
        case U :
            y = y - YSPEED;
            break;
        case RU :
            x = x + XSPEED;
            y = y - YSPEED;
            break;
        case R :
            x = x + XSPEED;
            break;
        case RD :
            x = x + XSPEED;
            y = y + YSPEED;
            break;
        case D :
            y = y + YSPEED;
            break;
        case LD :
            x = x - XSPEED;
            y = y + YSPEED;
            break;
        case STOP :
            break;
        }
        //当子弹飞出边界的时候，把子弹从容器里移除
        if(x < 0 || y < 0 || x > TankClient.GAME_WIDTH || y > TankClient.GAME_HEIGHT){
            live = false ;
            
        }
    }
    
    public boolean isLive() {
        return live;
    }
    
    //碰撞检测的辅助类Rectangle,并加入getRect方法
    public Rectangle getRect() {
        return new Rectangle(x,y,WIDTH,HEIGHT);
    }
    
    //Missle中加入hitTank(Tank)方法，返回布尔类型
    public boolean hitTank(Tank t){
        //当击中敌人坦克时，坦克被打死，子弹也死去
        if(this.live && this.getRect().intersects(t.getRect()) && t.isLive() && this.good != t.isGood()) {
            //如果坦克是好的，当击中坦克的时候，生命值减20，当生命值小于0的时候，坦克死去，坏坦克打一下就死
            if(t.isGood()) {
                t.setLife(t.getLife()-20);
                if(t.getLife() <= 0) t.setLive(false);
            } else {
                t.setLive(false);
            }
            this.live = false;
            //当打中坦克时，new出爆炸。
            Explode e = new Explode(x,y,tc);
            //坦克里加入爆炸
            tc.explodes.add(e);
            return true;
        }
        return false;
    }
    
    //打一系列tank的方法
    public boolean hitTanks(List<Tank> 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.java

package cn.shaoyangjiang.com;

import java.awt.*;
//添加爆炸类
public class Explode {
    
    int x,y;
    //设置圆的直径，给爆炸做效果用
    int[] diameter = {4,7,12,18,26,32,49,30,14,6};
    //申明爆炸是否活着
    private boolean live = true;
    int step = 0;
    private TankClient tc;
    
    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.java

package cn.shaoyangjiang.com;
import java.awt.*;
//墙这个类
public class Wall {
    int x, y, w, h;
    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);
    }
    //碰撞检测的辅助类Rectangle,并加入getRect方法
    public Rectangle getRect() {
        return new Rectangle(x, y, w, h);
    }
}

演示效果图：