码迷，mamicode.com
首页 > 其他好文 > 详细

坦克大战(版本1.7-版本2.4)

时间：2016-05-25 15:13:35      阅读：331      评论：0      收藏：0      [点我收藏+]

标签：

版本1.7

功能：加入爆炸
步骤：
        1)添加爆炸类:Explode
           用不同直径的圆模拟爆炸: int[] diameter = {4, 7, 12, 18, 26, 32, 49, 30, 14, 6};
           加入live: private boolean live = true;
           加入位置属性: int x, y;
           加入draw方法
        2)爆炸应该存在于集合类中:
           TankClient加入集合explodes: List<Explode> explodes=new ArrayList<Explode>();
           将集合中的爆炸逐一画出(如果死去就去除):在Missile类的draw方法中,当爆炸live==false的时候,tc.missiles.remove(this);
        3)击毙一辆坦克后应产生爆炸:
           在Missile类的hitTank中，产生爆炸,Explode e=new Explode(x, y, tc); tc.explodes.add(e);

具体代码实现：

Tank:

技术分享 
  1 import java.awt.*;
  2 import java.awt.event.*;
  3 import java.util.Random;
  4 
  5 public class Tank {
  6     // 方便后期更改
  7     public static final int XSPEED = 5;
  8     public static final int YSPEED = 5;
  9     // 将坦克的高度和宽度设置为常量
 10     public static final int WIDTH = 30;
 11     public static final int HEIGHT = 30;
 12     TankClient tc;
 13     // 区别是我方坦克还是地方坦克，方便据此进行不同的设置
 14     private boolean good;
 15     
 16     //判断坦克生死的变量
 17     private boolean live=true;
 18 
 19     
 20     public boolean isLive() {
 21         return live;
 22     }
 23 
 24     public void setLive(boolean live) {
 25         this.live = live;
 26     }
 27 
 28     private int x;
 29     private int y;
 30     // 添加记录按键状态的布尔量
 31     private boolean bL = false;
 32     private boolean bR = false;
 33     private boolean bU = false;
 34     private boolean bD = false;
 35 
 36     // 添加代表方向的量（使用枚举）
 37     enum Direction {
 38         L, R, U, D, LU, LD, RU, RD, STOP
 39     };
 40 
 41     private Direction dir = Direction.STOP;
 42 
 43     // 定义炮筒的方向，我们想办法将炮筒的方法调整成和坦克移动方向一致;
 44     // 我们这里会用一条直线来表示炮筒:模拟炮筒
 45     // 我们要根据炮筒的方向画直线表示炮筒
 46     Direction ptDir = Direction.D;
 47 
 48     //更改构造函数
 49     public Tank(int x, int y,boolean good) {
 50         this.x = x;
 51         this.y = y;
 52         this.good=good;
 53     }
 54 
 55     //这个位置的构造函数也相应进行了更改
 56     public Tank(int x, int y,boolean good,TankClient tc) {
 57         // 调用那个有两个参数的构造方法
 58         this(x, y,good);
 59         // 在这个位置初始化tc
 60         this.tc = tc;
 61     }
 62 
 63     // Tank对象的draw方法
 64     public void draw(Graphics g) {
 65         if(!live){
 66             return;
 67         }
 68         Color c = g.getColor();
 69         if(good){    
 70         g.setColor(Color.RED);
 71         }
 72         else {
 73             g.setColor(Color.PINK);
 74         }
 75         g.fillOval(x, y, WIDTH, HEIGHT);
 76         g.setColor(c);
 77         // 根据炮筒的方向画直线来表示我们坦克的炮筒
 78         switch (ptDir) {
 79         case L:
 80             // 画直线:四个参数分别代表：坦克中心点的坐标 直线的另一头的的坐标
 81             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x, y
 82                     + Tank.HEIGHT / 2);
 83             break;
 84         case R:
 85             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x + Tank.WIDTH,
 86                     y + Tank.HEIGHT / 2);
 87 
 88             break;
 89         case U:
 90             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x + Tank.WIDTH
 91                     / 2, y);
 92 
 93             break;
 94         case D:
 95             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x + Tank.WIDTH
 96                     / 2, y + Tank.HEIGHT);
 97 
 98             break;
 99         case LU:
100             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x, y);
101             break;
102         case LD:
103             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x, y
104                     + Tank.HEIGHT);
105 
106             break;
107         case RU:
108             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x + Tank.WIDTH,
109                     y);
110 
111             break;
112         case RD:
113             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x + Tank.WIDTH,
114                     y + Tank.HEIGHT);
115 
116             break;
117         /*
118          * case STOP: break;
119          */
120         }
121         move();
122     }
123 
124     public void move() {
125         switch (dir) {
126         case L:
127             x -= XSPEED;
128             break;
129         case R:
130             x += XSPEED;
131             break;
132         case U:
133             y -= YSPEED;
134             break;
135         case D:
136             y += YSPEED;
137             break;
138         case LU:
139             x -= XSPEED;
140             y -= YSPEED;
141             break;
142         case LD:
143             x -= XSPEED;
144             y += YSPEED;
145             break;
146         case RU:
147             x += XSPEED;
148             y -= YSPEED;
149             break;
150         case RD:
151             x += XSPEED;
152             y += YSPEED;
153             break;
154 
155         case STOP:
156             break;
157         }
158         // 如果坦克不是停着的，则将炮筒调整至和坦克移动的方向相同
159         if (this.dir != Direction.STOP) {
160             this.ptDir = this.dir;
161         }
162         if (x < 0) {
163             x = 0;
164         }
165         // 因为我们的游戏界面有那个missileCount标签，所以在y轴方向不能用y是否<0进行判断
166         // 否则的话我们的坦克可以从上面出去
167         if (y < 50) {
168             y = 50;
169         }
170         if (x + Tank.WIDTH > TankClient.GAME_WIDTH) {
171             x = TankClient.GAME_WIDTH - Tank.WIDTH;
172         }
173         if (y + Tank.HEIGHT > TankClient.GAME_HEIGHT) {
174             y = TankClient.GAME_HEIGHT - Tank.HEIGHT;
175         }
176     }
177 
178     public void locateDirection() {
179         if (bL && !bU && !bR && !bD)
180             dir = Direction.L;
181         else if (bL && bU && !bR && !bD)
182             dir = Direction.LU;
183         else if (!bL && bU && !bR && !bD)
184             dir = Direction.U;
185         else if (!bL && bU && bR && !bD)
186             dir = Direction.RU;
187         else if (!bL && !bU && bR && !bD)
188             dir = Direction.R;
189         else if (!bL && !bU && bR && bD)
190             dir = Direction.RD;
191         else if (!bL && !bU && !bR && bD)
192             dir = Direction.D;
193         else if (bL && !bU && !bR && bD)
194             dir = Direction.LD;
195         else if (!bL && !bU && !bR && !bD)
196             dir = Direction.STOP;
197 
198     }
199 
200     // 坦克自己向哪个方向移动，它自己最清楚;
201     public void KeyPressed(KeyEvent e) {
202         // 获得所按下的键所对应的虚拟码:
203         // Returns the integer keyCode associated with the key in this event
204         int key = e.getKeyCode();
205         // 判断不同的按键，指挥坦克的运动方向
206         switch (key) {
207         case KeyEvent.VK_LEFT:
208             bL = true;
209             break;
210         case KeyEvent.VK_UP:
211             bU = true;
212             break;
213         case KeyEvent.VK_RIGHT:
214             bR = true;
215             break;
216         case KeyEvent.VK_DOWN:
217             bD = true;
218             break;
219         }
220         locateDirection();
221     }
222 
223     public void keyReleased(KeyEvent e) {
224         int key = e.getKeyCode();
225         // 判断不同的按键，指挥坦克的运动方向
226         // 哪个键按下了，就把对应方向的布尔类型置为false
227         switch (key) {
228         // 为了防止一直按着Ctrl键的时候，炮弹太过于密集
229         // 因此我们定义在Ctrl键抬起的时候才发炮弹
230         // 这样炮弹不至于太过密集
231         case KeyEvent.VK_CONTROL:
232             fire();
233             break;
234         case KeyEvent.VK_LEFT:
235             bL = false;
236             break;
237         case KeyEvent.VK_UP:
238             bU = false;
239             break;
240         case KeyEvent.VK_RIGHT:
241             bR = false;
242             break;
243         case KeyEvent.VK_DOWN:
244             bD = false;
245             break;
246         }
247         // 重新定位一下
248         locateDirection();
249     }
250 
251     public Missile fire() {
252         // 计算子弹的位置，使得子弹从坦克的中间发出来
253         int x = this.x + Tank.WIDTH / 2 - Missile.WIDTH / 2;
254         int y = this.y + Tank.HEIGHT / 2 - Missile.HEIGHT / 2;
255         // 这个时候我们就根据炮筒的方向来发炮弹了，之前是根据坦克的方向来发炮弹
256         Missile m = new Missile(x, y, ptDir, tc);
257         // 将新产生的炮弹放置到List容器中
258         tc.missiles.add(m);
259         return m;
260     }
261 
262     //拿到包围坦克的那个方块
263     public Rectangle getRect() {
264         
265         return new Rectangle(x,y,WIDTH,HEIGHT);
266     }
267 }
View Code

Missile:

技术分享 
  1 import java.awt.Color;
  2 import java.awt.Graphics;
  3 import java.awt.Rectangle;
  4 
  5 public class Missile {
  6     // 炮弹的移动速度，不要比坦克的移动速度慢，不然你看到的是满屏的坦克追着炮弹跑
  7     public static final int XSPEED = 10;
  8     public static final int YSPEED = 10;
  9     // 将子弹的高度和宽度设置为常量
 10     public static final int WIDTH = 10;
 11     public static final int HEIGHT = 10;
 12     // 炮弹自己的三个属性
 13     int x;
 14     int y;
 15     Tank.Direction dir;
 16 
 17     // 定义一个布尔类型的变量来判断炮弹是否已经消亡
 18     private boolean live = true;
 19     //我们在Missile类中也持有一个TankClient的引用
 20     //在炮弹出界的时候就可以从装炮弹的missiles集合中去除该炮弹，不再对其重画
 21     private TankClient tc;
 22 
 23     public boolean isLive() {
 24         return live;
 25     }
 26 
 27     public Missile(int x, int y, Tank.Direction dir) {
 28         this.x = x;
 29         this.y = y;
 30         this.dir = dir;
 31     }
 32     public Missile(int x,int y,Tank.Direction dir,TankClient tc){
 33         this(x, y, dir);
 34         this.tc=tc;
 35     }
 36 
 37     // 炮弹自己的draw方法
 38     public void draw(Graphics g) {
 39         //炮弹消亡就不需要再画出来了
 40         if(!live){
 41             tc.missiles.remove(this);
 42             return;
 43         }
 44         Color c = g.getColor();
 45         g.setColor(Color.BLACK);
 46         // 炮弹形状不要比坦克大,这里设置成10,10;
 47         g.fillOval(x, y, WIDTH, HEIGHT);
 48         g.setColor(c);
 49         move();
 50     }
 51 
 52     public void move() {
 53         switch (dir) {
 54         case L:
 55             x -= XSPEED;
 56             break;
 57         case R:
 58             x += XSPEED;
 59             break;
 60         case U:
 61             y -= YSPEED;
 62             break;
 63         case D:
 64             y += YSPEED;
 65             break;
 66         case LU:
 67             x -= XSPEED;
 68             y -= YSPEED;
 69             break;
 70         case LD:
 71             x -= XSPEED;
 72             y += YSPEED;
 73             break;
 74         case RU:
 75             x += XSPEED;
 76             y -= YSPEED;
 77             break;
 78         case RD:
 79             x += XSPEED;
 80             y += YSPEED;
 81             break;
 82         // 炮弹就没有STOP这个枚举类型的值了
 83         /*
 84          * case STOP: break;
 85          */
 86         }
 87         // 判断炮弹出边界则消亡
 88         // 注意x,y只有正数值，x向右递增，y向下递增
 89         if (x < 0 || y < 0 || x > TankClient.GAME_WIDTH
 90                 || y > TankClient.GAME_HEIGHT) {
 91             live = false;
 92         }
 93     }
 94     public boolean hitTank(Tank t){
 95         //炮弹的方框和坦克的方框碰在一起了并且坦克是存活着的
 96         if(this.getRect().intersects(t.getRect())&&t.isLive()){
 97             t.setLive(false);
 98             this.live=false;
 99             
100             //炮弹击中坦克，发生爆炸
101             Explode e=new Explode(x, y, tc);
102             tc.explodes.add(e);
103             return true;
104         }
105         return false;
106     }
107     //碰撞检测类Rectangle
108     //拿到包围在炮弹周围的小方块
109     public Rectangle getRect(){
110         return new Rectangle(x,y,WIDTH,HEIGHT);
111     }
112 }
View Code

Explode:

技术分享 
 1 import java.awt.*;
 2 
 3 public class Explode {
 4     //爆炸的位置
 5     int x, y;
 6     //爆炸是否存在
 7     private boolean live = true;
 8     
 9     //持有一个Tankclient的引用
10     private TankClient tc ;
11     
12     //定义不同直径大小的爆炸
13     int[] diameter = {4, 7, 12, 18, 26, 32, 49, 30, 14, 6};
14     //爆炸发生到哪一个阶段了，对应相应大小的直径
15     int step = 0;
16     
17     public Explode(int x, int y, TankClient tc) {
18         this.x = x;
19         this.y = y;
20         this.tc = tc;
21     }
22     
23     public void draw(Graphics g) {
24         if(!live) {
25             //爆炸发生，将相应直径的爆炸圆从集合explodes中去除
26             tc.explodes.remove(this);
27             return;
28         }
29         
30         if(step == diameter.length) {
31             live = false;
32             step = 0;
33             return;
34         }
35         
36         Color c = g.getColor();
37         g.setColor(Color.ORANGE);
38         
39         //把不同的圆画出来
40         g.fillOval(x, y, diameter[step], diameter[step]);
41         g.setColor(c);
42         
43         step ++;
44     }
45 }
View Code

TankClient:

技术分享 
  1 import java.awt.*;
  2 import java.awt.event.*;
  3 import java.util.ArrayList;
  4 import java.util.List;
  5 
  6 public class TankClient extends Frame {
  7     // 设置成常量，方便以后的改动
  8     public static final int GAME_WIDTH = 800;
  9     public static final int GAME_HEIGHT = 600;
 10 
 11     // 将当前的TankClient对象传递给myTank;
 12     // 目的是方便我们在Tank这个类中访问m(炮弹对象)这个成员变量
 13     // 其实就是在Tank类中持有TankClient类对象的一个引用
 14     
 15     //我们这里new我们自己的坦克，用下面的方式
 16     Tank myTank = new Tank(50, 50, true,this);
 17     
 18     //新建敌方坦克
 19     Tank enemyTank=new Tank(100,100,false,this);
 20     //定义爆炸
 21     Explode e=new Explode(70, 70, this);
 22     //定义一个集合，多个爆炸点
 23     List<Explode> explodes=new ArrayList<Explode>();
 24     
 25     //使用容器装炮弹
 26     List<Missile> missiles=new ArrayList<Missile>();
 27 
 28     // 定义虚拟图片，方便后期的一次性显示
 29     Image offScreenImage = null;
 30 
 31     
 32     public void paint(Graphics g) {
 33         //记录屏幕上的子弹数目
 34         g.drawString("missiles count:" + missiles.size(), 10, 50);
 35         //添加上方标记栏，记录爆炸次数
 36         g.drawString("explodes count:" + explodes.size(), 10, 70);
 37 
 38         
 39         //遍历结合，发出多发炮弹
 40         for(int i=0;i<missiles.size();i++){
 41             Missile m=missiles.get(i);
 42             //子弹打敌方坦克
 43             m.hitTank(enemyTank);
 44             
 45             m.draw(g);
 46         }
 47         
 48         for(int i=0;i<explodes.size();i++){
 49             Explode e=explodes.get(i);
 50             e.draw(g);
 51         }
 52         // 不改变前景色
 53         myTank.draw(g);
 54         //敌方坦克调用draw方法
 55         enemyTank.draw(g);
 56     }
 57 
 58     // 刷新操作
 59     public void update(Graphics g) {
 60         if (offScreenImage == null) {
 61             offScreenImage = this.createImage(GAME_WIDTH, GAME_HEIGHT);
 62         }
 63         Graphics gOffScreen = offScreenImage.getGraphics();
 64         Color c = gOffScreen.getColor();
 65         gOffScreen.setColor(Color.GREEN);
 66         gOffScreen.fillRect(0, 0, GAME_WIDTH, GAME_HEIGHT);
 67         gOffScreen.setColor(c);
 68         paint(gOffScreen);
 69         g.drawImage(offScreenImage, 0, 0, null);
 70     }
 71 
 72     public void lauchFrame() {
 73 //        this.setLocation(400, 300);
 74         this.setSize(GAME_WIDTH, GAME_HEIGHT);
 75         this.setTitle("TankWar");
 76         this.addWindowListener(new WindowAdapter() {
 77             public void windowClosing(WindowEvent e) {
 78                 System.exit(0);
 79             }
 80         });
 81         this.setResizable(false);
 82         this.setBackground(Color.GREEN);
 83 
 84         this.addKeyListener(new KeyMonitor());
 85 
 86         setVisible(true);
 87 
 88         new Thread(new PaintThread()).start();
 89     }
 90 
 91     public static void main(String[] args) {
 92         TankClient tc = new TankClient();
 93         tc.lauchFrame();
 94     }
 95 
 96     private class PaintThread implements Runnable {
 97 
 98         public void run() {
 99             while (true) {
100                 repaint();
101                 try {
102                     //为了爆炸效果，改成1000
103                     Thread.sleep(50);
104                 } catch (InterruptedException e) {
105                     e.printStackTrace();
106                 }
107             }
108         }
109     }
110 
111     // 创建键盘时间监听
112     private class KeyMonitor extends KeyAdapter {
113 
114         // 直接调用myTank自己的方法根据相应的按键信息进行移动
115         public void keyPressed(KeyEvent e) {
116             myTank.KeyPressed(e);
117             // 添加了处理键抬起的事件，可以控制坦克起步以后的状态
118             // 而不是一直按照一个方向走下去
119         }
120 
121         public void keyReleased(KeyEvent e) {
122             myTank.keyReleased(e);
123         }
124 
125     }
126 }
View Code

版本1.8
功能：添加多辆坦克
步骤：
        1)用容器来装敌人的Tank:在Tankclient类中List<Tank> tanks=new ArrayList<Tank>();
        2)向容器中装入多辆敌人Tank
        3)画出来
        4)运行，不能打掉
           添加hitTanks方法，打一系列Tank：

1 public boolean hitTanks(List<Tank> tanks){
2         for(int i=0;i<tanks.size();i++){
3             if(hitTank(tanks.get(i))){
4                 return true;
5             }
6         }
7         return false;
8         
9     }

          TankClient里面每发子弹都可以打tanks：

具体代码实现：

Tank:

技术分享 
  1 import java.awt.*;
  2 import java.awt.event.*;
  3 import java.util.Random;
  4 
  5 public class Tank {
  6     // 方便后期更改
  7     public static final int XSPEED = 5;
  8     public static final int YSPEED = 5;
  9     // 将坦克的高度和宽度设置为常量
 10     public static final int WIDTH = 30;
 11     public static final int HEIGHT = 30;
 12     TankClient tc;
 13     // 区别是我方坦克还是地方坦克，方便据此进行不同的设置
 14     private boolean good;
 15     
 16     //判断坦克生死的变量
 17     private boolean live=true;
 18 
 19     
 20     public boolean isLive() {
 21         return live;
 22     }
 23 
 24     public void setLive(boolean live) {
 25         this.live = live;
 26     }
 27 
 28     private int x;
 29     private int y;
 30     // 添加记录按键状态的布尔量
 31     private boolean bL = false;
 32     private boolean bR = false;
 33     private boolean bU = false;
 34     private boolean bD = false;
 35 
 36     // 添加代表方向的量（使用枚举）
 37     enum Direction {
 38         L, R, U, D, LU, LD, RU, RD, STOP
 39     };
 40 
 41     private Direction dir = Direction.STOP;
 42 
 43     // 定义炮筒的方向，我们想办法将炮筒的方法调整成和坦克移动方向一致;
 44     // 我们这里会用一条直线来表示炮筒:模拟炮筒
 45     // 我们要根据炮筒的方向画直线表示炮筒
 46     Direction ptDir = Direction.D;
 47 
 48     //更改构造函数
 49     public Tank(int x, int y,boolean good) {
 50         this.x = x;
 51         this.y = y;
 52         this.good=good;
 53     }
 54 
 55     //这个位置的构造函数也相应进行了更改
 56     public Tank(int x, int y,boolean good,TankClient tc) {
 57         // 调用那个有两个参数的构造方法
 58         this(x, y,good);
 59         // 在这个位置初始化tc
 60         this.tc = tc;
 61     }
 62 
 63     // Tank对象的draw方法
 64     public void draw(Graphics g) {
 65         if(!live){
 66             //如果死亡的是敌方坦克，在tanks集合中去除该坦克
 67             if(!good){
 68                 tc.tanks.remove(this);
 69             }
 70             //如果是我方坦克，直接返回
 71             return;
 72         }
 73         Color c = g.getColor();
 74         if(good){    
 75         g.setColor(Color.RED);
 76         }
 77         else {
 78             g.setColor(Color.PINK);
 79         }
 80         g.fillOval(x, y, WIDTH, HEIGHT);
 81         g.setColor(c);
 82         // 根据炮筒的方向画直线来表示我们坦克的炮筒
 83         switch (ptDir) {
 84         case L:
 85             // 画直线:四个参数分别代表：坦克中心点的坐标 直线的另一头的的坐标
 86             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x, y
 87                     + Tank.HEIGHT / 2);
 88             break;
 89         case R:
 90             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x + Tank.WIDTH,
 91                     y + Tank.HEIGHT / 2);
 92 
 93             break;
 94         case U:
 95             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x + Tank.WIDTH
 96                     / 2, y);
 97 
 98             break;
 99         case D:
100             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x + Tank.WIDTH
101                     / 2, y + Tank.HEIGHT);
102 
103             break;
104         case LU:
105             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x, y);
106             break;
107         case LD:
108             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x, y
109                     + Tank.HEIGHT);
110 
111             break;
112         case RU:
113             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x + Tank.WIDTH,
114                     y);
115 
116             break;
117         case RD:
118             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x + Tank.WIDTH,
119                     y + Tank.HEIGHT);
120 
121             break;
122         /*
123          * case STOP: break;
124          */
125         }
126         move();
127     }
128 
129     public void move() {
130         switch (dir) {
131         case L:
132             x -= XSPEED;
133             break;
134         case R:
135             x += XSPEED;
136             break;
137         case U:
138             y -= YSPEED;
139             break;
140         case D:
141             y += YSPEED;
142             break;
143         case LU:
144             x -= XSPEED;
145             y -= YSPEED;
146             break;
147         case LD:
148             x -= XSPEED;
149             y += YSPEED;
150             break;
151         case RU:
152             x += XSPEED;
153             y -= YSPEED;
154             break;
155         case RD:
156             x += XSPEED;
157             y += YSPEED;
158             break;
159 
160         case STOP:
161             break;
162         }
163         // 如果坦克不是停着的，则将炮筒调整至和坦克移动的方向相同
164         if (this.dir != Direction.STOP) {
165             this.ptDir = this.dir;
166         }
167         if (x < 0) {
168             x = 0;
169         }
170         // 因为我们的游戏界面有那个missileCount标签，所以在y轴方向不能用y是否<0进行判断
171         // 否则的话我们的坦克可以从上面出去
172         if (y < 50) {
173             y = 50;
174         }
175         if (x + Tank.WIDTH > TankClient.GAME_WIDTH) {
176             x = TankClient.GAME_WIDTH - Tank.WIDTH;
177         }
178         if (y + Tank.HEIGHT > TankClient.GAME_HEIGHT) {
179             y = TankClient.GAME_HEIGHT - Tank.HEIGHT;
180         }
181     }
182 
183     public void locateDirection() {
184         if (bL && !bU && !bR && !bD)
185             dir = Direction.L;
186         else if (bL && bU && !bR && !bD)
187             dir = Direction.LU;
188         else if (!bL && bU && !bR && !bD)
189             dir = Direction.U;
190         else if (!bL && bU && bR && !bD)
191             dir = Direction.RU;
192         else if (!bL && !bU && bR && !bD)
193             dir = Direction.R;
194         else if (!bL && !bU && bR && bD)
195             dir = Direction.RD;
196         else if (!bL && !bU && !bR && bD)
197             dir = Direction.D;
198         else if (bL && !bU && !bR && bD)
199             dir = Direction.LD;
200         else if (!bL && !bU && !bR && !bD)
201             dir = Direction.STOP;
202 
203     }
204 
205     // 坦克自己向哪个方向移动，它自己最清楚;
206     public void KeyPressed(KeyEvent e) {
207         // 获得所按下的键所对应的虚拟码:
208         // Returns the integer keyCode associated with the key in this event
209         int key = e.getKeyCode();
210         // 判断不同的按键，指挥坦克的运动方向
211         switch (key) {
212         case KeyEvent.VK_LEFT:
213             bL = true;
214             break;
215         case KeyEvent.VK_UP:
216             bU = true;
217             break;
218         case KeyEvent.VK_RIGHT:
219             bR = true;
220             break;
221         case KeyEvent.VK_DOWN:
222             bD = true;
223             break;
224         }
225         locateDirection();
226     }
227 
228     public void keyReleased(KeyEvent e) {
229         int key = e.getKeyCode();
230         // 判断不同的按键，指挥坦克的运动方向
231         // 哪个键按下了，就把对应方向的布尔类型置为false
232         switch (key) {
233         // 为了防止一直按着Ctrl键的时候，炮弹太过于密集
234         // 因此我们定义在Ctrl键抬起的时候才发炮弹
235         // 这样炮弹不至于太过密集
236         case KeyEvent.VK_CONTROL:
237             fire();
238             break;
239         case KeyEvent.VK_LEFT:
240             bL = false;
241             break;
242         case KeyEvent.VK_UP:
243             bU = false;
244             break;
245         case KeyEvent.VK_RIGHT:
246             bR = false;
247             break;
248         case KeyEvent.VK_DOWN:
249             bD = false;
250             break;
251         }
252         // 重新定位一下
253         locateDirection();
254     }
255 
256     public Missile fire() {
257         // 计算子弹的位置，使得子弹从坦克的中间发出来
258         int x = this.x + Tank.WIDTH / 2 - Missile.WIDTH / 2;
259         int y = this.y + Tank.HEIGHT / 2 - Missile.HEIGHT / 2;
260         // 这个时候我们就根据炮筒的方向来发炮弹了，之前是根据坦克的方向来发炮弹
261         Missile m = new Missile(x, y, ptDir, tc);
262         // 将新产生的炮弹放置到List容器中
263         tc.missiles.add(m);
264         return m;
265     }
266 
267     //拿到包围坦克的那个方块
268     public Rectangle getRect() {
269         
270         return new Rectangle(x,y,WIDTH,HEIGHT);
271     }
272 }
View Code

Missile:

技术分享 
  1 import java.awt.Color;
  2 import java.awt.Graphics;
  3 import java.awt.Rectangle;
  4 import java.util.List;
  5 
  6 public class Missile {
  7     // 炮弹的移动速度，不要比坦克的移动速度慢，不然你看到的是满屏的坦克追着炮弹跑
  8     public static final int XSPEED = 10;
  9     public static final int YSPEED = 10;
 10     // 将子弹的高度和宽度设置为常量
 11     public static final int WIDTH = 10;
 12     public static final int HEIGHT = 10;
 13     // 炮弹自己的三个属性
 14     int x;
 15     int y;
 16     Tank.Direction dir;
 17 
 18     // 定义一个布尔类型的变量来判断炮弹是否已经消亡
 19     private boolean live = true;
 20     //我们在Missile类中也持有一个TankClient的引用
 21     //在炮弹出界的时候就可以从装炮弹的missiles集合中去除该炮弹，不再对其重画
 22     private TankClient tc;
 23 
 24     public boolean isLive() {
 25         return live;
 26     }
 27 
 28     public Missile(int x, int y, Tank.Direction dir) {
 29         this.x = x;
 30         this.y = y;
 31         this.dir = dir;
 32     }
 33     public Missile(int x,int y,Tank.Direction dir,TankClient tc){
 34         this(x, y, dir);
 35         this.tc=tc;
 36     }
 37 
 38     // 炮弹自己的draw方法
 39     public void draw(Graphics g) {
 40         //炮弹消亡就不需要再画出来了
 41         if(!live){
 42             tc.missiles.remove(this);
 43             return;
 44         }
 45         Color c = g.getColor();
 46         g.setColor(Color.BLACK);
 47         // 炮弹形状不要比坦克大,这里设置成10,10;
 48         g.fillOval(x, y, WIDTH, HEIGHT);
 49         g.setColor(c);
 50         move();
 51     }
 52 
 53     public void move() {
 54         switch (dir) {
 55         case L:
 56             x -= XSPEED;
 57             break;
 58         case R:
 59             x += XSPEED;
 60             break;
 61         case U:
 62             y -= YSPEED;
 63             break;
 64         case D:
 65             y += YSPEED;
 66             break;
 67         case LU:
 68             x -= XSPEED;
 69             y -= YSPEED;
 70             break;
 71         case LD:
 72             x -= XSPEED;
 73             y += YSPEED;
 74             break;
 75         case RU:
 76             x += XSPEED;
 77             y -= YSPEED;
 78             break;
 79         case RD:
 80             x += XSPEED;
 81             y += YSPEED;
 82             break;
 83         // 炮弹就没有STOP这个枚举类型的值了
 84         /*
 85          * case STOP: break;
 86          */
 87         }
 88         // 判断炮弹出边界则消亡
 89         // 注意x,y只有正数值，x向右递增，y向下递增
 90         if (x < 0 || y < 0 || x > TankClient.GAME_WIDTH
 91                 || y > TankClient.GAME_HEIGHT) {
 92             live = false;
 93         }
 94     }
 95     public boolean hitTank(Tank t){
 96         //炮弹的方框和坦克的方框碰在一起了并且坦克是存活着的
 97         if(this.getRect().intersects(t.getRect())&&t.isLive()){
 98             t.setLive(false);
 99             this.live=false;
100             
101             //炮弹击中坦克，发生爆炸
102             Explode e=new Explode(x, y, tc);
103             tc.explodes.add(e);
104             return true;
105         }
106         return false;
107     }
108     //碰撞检测类Rectangle
109     //拿到包围在炮弹周围的小方块
110     public Rectangle getRect(){
111         return new Rectangle(x,y,WIDTH,HEIGHT);
112     }
113     
114     //添加hitTanks方法
115     public boolean hitTanks(List<Tank> tanks){
116         for(int i=0;i<tanks.size();i++){
117             if(hitTank(tanks.get(i))){
118                 return true;
119             }
120         }
121         return false;
122         
123     }
124 }
View Code

Explode:

技术分享 
 1 import java.awt.*;
 2 
 3 public class Explode {
 4     //爆炸的位置
 5     int x, y;
 6     //爆炸是否存在
 7     private boolean live = true;
 8     
 9     //持有一个Tankclient的引用
10     private TankClient tc ;
11     
12     //定义不同直径大小的爆炸
13     int[] diameter = {4, 7, 12, 18, 26, 32, 49, 30, 14, 6};
14     //爆炸发生到哪一个阶段了，对应相应大小的直径
15     int step = 0;
16     
17     public Explode(int x, int y, TankClient tc) {
18         this.x = x;
19         this.y = y;
20         this.tc = tc;
21     }
22     
23     public void draw(Graphics g) {
24         if(!live) {
25             //爆炸发生，将相应直径的爆炸圆从集合explodes中去除
26             tc.explodes.remove(this);
27             return;
28         }
29         
30         if(step == diameter.length) {
31             live = false;
32             step = 0;
33             return;
34         }
35         
36         Color c = g.getColor();
37         g.setColor(Color.ORANGE);
38         
39         //把不同的圆画出来
40         g.fillOval(x, y, diameter[step], diameter[step]);
41         g.setColor(c);
42         
43         step ++;
44     }
45 }
View Code

TankClient:

技术分享 
  1 import java.awt.*;
  2 import java.awt.event.*;
  3 import java.util.ArrayList;
  4 import java.util.List;
  5 
  6 public class TankClient extends Frame {
  7     // 设置成常量，方便以后的改动
  8     public static final int GAME_WIDTH = 800;
  9     public static final int GAME_HEIGHT = 600;
 10 
 11     // 将当前的TankClient对象传递给myTank;
 12     // 目的是方便我们在Tank这个类中访问m(炮弹对象)这个成员变量
 13     // 其实就是在Tank类中持有TankClient类对象的一个引用
 14     
 15     //我们这里new我们自己的坦克，用下面的方式
 16     Tank myTank = new Tank(50, 50, true,this);
 17     
 18     /*//新建敌方坦克,(不再需要这个了)
 19     Tank enemyTank=new Tank(100,100,false,this);*/
 20     //定义爆炸
 21     Explode e=new Explode(70, 70, this);
 22     //定义一个集合，多个爆炸点
 23     List<Explode> explodes=new ArrayList<Explode>();
 24     
 25     //使用容器装炮弹
 26     List<Missile> missiles=new ArrayList<Missile>();
 27 
 28     //用容器来装敌人的Tank
 29     List<Tank> tanks=new ArrayList<Tank>();
 30     // 定义虚拟图片，方便后期的一次性显示
 31     Image offScreenImage = null;
 32 
 33     
 34     public void paint(Graphics g) {
 35         //记录屏幕上的子弹数目
 36         g.drawString("missiles count:" + missiles.size(), 10, 50);
 37         //添加上方标记栏，记录爆炸次数
 38         g.drawString("explodes count:" + explodes.size(), 10, 70);
 39         //记录现在屏幕上一共有多少敌方坦克
 40         g.drawString("tanks count:" + tanks.size(), 10, 90);
 41 
 42         
 43         //遍历结合，发出多发炮弹
 44         for(int i=0;i<missiles.size();i++){
 45             Missile m=missiles.get(i);
 46             //对于每一发炮弹，都可以将tanks集合中的敌方炮弹干掉
 47             m.hitTanks(tanks);
 48             m.draw(g);
 49         }
 50         
 51         for(int i=0;i<explodes.size();i++){
 52             Explode e=explodes.get(i);
 53             e.draw(g);
 54         }
 55         
 56         for(int i=0;i<tanks.size();i++){
 57             Tank t=tanks.get(i);
 58             t.draw(g);
 59         }
 60         // 不改变前景色
 61         myTank.draw(g);
 62     }
 63 
 64     // 刷新操作
 65     public void update(Graphics g) {
 66         if (offScreenImage == null) {
 67             offScreenImage = this.createImage(GAME_WIDTH, GAME_HEIGHT);
 68         }
 69         Graphics gOffScreen = offScreenImage.getGraphics();
 70         Color c = gOffScreen.getColor();
 71         gOffScreen.setColor(Color.GREEN);
 72         gOffScreen.fillRect(0, 0, GAME_WIDTH, GAME_HEIGHT);
 73         gOffScreen.setColor(c);
 74         paint(gOffScreen);
 75         g.drawImage(offScreenImage, 0, 0, null);
 76     }
 77 
 78     public void lauchFrame() {
 79         
 80         //添加多辆坦克
 81         for(int i=0;i<10;i++){
 82             tanks.add(new Tank(50+40*(i+1),50,false));
 83         }
 84 //        this.setLocation(400, 300);
 85         this.setSize(GAME_WIDTH, GAME_HEIGHT);
 86         this.setTitle("TankWar");
 87         this.addWindowListener(new WindowAdapter() {
 88             public void windowClosing(WindowEvent e) {
 89                 System.exit(0);
 90             }
 91         });
 92         this.setResizable(false);
 93         this.setBackground(Color.GREEN);
 94 
 95         this.addKeyListener(new KeyMonitor());
 96 
 97         setVisible(true);
 98 
 99         new Thread(new PaintThread()).start();
100     }
101 
102     public static void main(String[] args) {
103         TankClient tc = new TankClient();
104         tc.lauchFrame();
105     }
106 
107     private class PaintThread implements Runnable {
108 
109         public void run() {
110             while (true) {
111                 repaint();
112                 try {
113                     //为了爆炸效果，改成1000
114                     Thread.sleep(50);
115                 } catch (InterruptedException e) {
116                     e.printStackTrace();
117                 }
118             }
119         }
120     }
121 
122     // 创建键盘时间监听
123     private class KeyMonitor extends KeyAdapter {
124 
125         // 直接调用myTank自己的方法根据相应的按键信息进行移动
126         public void keyPressed(KeyEvent e) {
127             myTank.KeyPressed(e);
128             // 添加了处理键抬起的事件，可以控制坦克起步以后的状态
129             // 而不是一直按照一个方向走下去
130         }
131 
132         public void keyReleased(KeyEvent e) {
133             myTank.keyReleased(e);
134         }
135 
136     }
137 }
View Code

版本1.9

功能：让敌军坦克更加智能
步骤：
        1)让敌军坦克动起来
           构造函数中可以指定方向
           new敌军坦克的时候指定敌军坦克的方向
        2)让敌军坦克向随机方向移动
          (Tank)静态的，添加随机数产生器 java.util.Random
          move完成后，如果是敌军坦克的，随机产生一个数，来设定坦克下一个方向
          Direction.values();
        3)让敌军坦克向随机方向移动随机的步骤
           添加变量，记录随机步骤
           当==0时，改变方向，否则，只是随机步骤递减
        4)让敌军坦克发射炮弹
           本军炮弹不打本军
           炮弹添加好坏bGood，根据好坏画不同颜色
           修改炮弹的构造方法
           修改Tank的fire方法
           修改hitTank方法，好不能打好，坏不能打坏
        5)敌军炮火不能太猛烈

Tank:

技术分享 
  1 import java.awt.*;
  2 import java.awt.event.*;
  3 import java.util.Random;
  4 
  5 public class Tank {
  6     // 方便后期更改
  7     public static final int XSPEED = 5;
  8     public static final int YSPEED = 5;
  9     // 将坦克的高度和宽度设置为常量
 10     public static final int WIDTH = 30;
 11     public static final int HEIGHT = 30;
 12     TankClient tc;
 13     // 区别是我方坦克还是地方坦克，方便据此进行不同的设置
 14     private boolean good;
 15 
 16     public boolean isGood() {
 17         return good;
 18     }
 19 
 20     public void setGood(boolean good) {
 21         this.good = good;
 22     }
 23 
 24     // 判断坦克生死的变量
 25     private boolean live = true;
 26 
 27     public boolean isLive() {
 28         return live;
 29     }
 30 
 31     public void setLive(boolean live) {
 32         this.live = live;
 33     }
 34 
 35     private int x;
 36     private int y;
 37 
 38     // 随机数产生器，方便敌方坦克可以任意移动
 39     private static Random r = new Random();
 40     // 添加记录按键状态的布尔量
 41     private boolean bL = false;
 42     private boolean bR = false;
 43     private boolean bU = false;
 44     private boolean bD = false;
 45 
 46     // 添加代表方向的量（使用枚举）
 47     enum Direction {
 48         L, R, U, D, LU, LD, RU, RD, STOP
 49     };
 50 
 51     private Direction dir = Direction.STOP;
 52 
 53     // 定义炮筒的方向，我们想办法将炮筒的方法调整成和坦克移动方向一致;
 54     // 我们这里会用一条直线来表示炮筒:模拟炮筒
 55     // 我们要根据炮筒的方向画直线表示炮筒
 56     Direction ptDir = Direction.D;
 57 
 58     // 为了让敌方坦克在一定方向运动移动时间再自动变换方向
 59     private int step = r.nextInt(12) + 3;
 60 
 61     // 更改构造函数
 62     public Tank(int x, int y, boolean good) {
 63         this.x = x;
 64         this.y = y;
 65         this.good = good;
 66     }
 67 
 68     // 这个位置的构造函数也相应进行了更改
 69     public Tank(int x, int y, boolean good, Direction dir, TankClient tc) {
 70         // 调用那个有两个参数的构造方法
 71         this(x, y, good);
 72         this.dir = dir;
 73         // 在这个位置初始化tc
 74         this.tc = tc;
 75     }
 76 
 77     // Tank对象的draw方法
 78     public void draw(Graphics g) {
 79         if (!live) {
 80             // 如果死亡的是敌方坦克，在tanks集合中去除该坦克
 81             if (!good) {
 82                 tc.tanks.remove(this);
 83             }
 84             // 如果是我方坦克，直接返回
 85             return;
 86         }
 87         Color c = g.getColor();
 88         if (good) {
 89             g.setColor(Color.RED);
 90         } else {
 91             g.setColor(Color.PINK);
 92         }
 93         g.fillOval(x, y, WIDTH, HEIGHT);
 94         g.setColor(c);
 95         // 根据炮筒的方向画直线来表示我们坦克的炮筒
 96         switch (ptDir) {
 97         case L:
 98             // 画直线:四个参数分别代表：坦克中心点的坐标 直线的另一头的的坐标
 99             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x, y
100                     + Tank.HEIGHT / 2);
101             break;
102         case R:
103             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x + Tank.WIDTH,
104                     y + Tank.HEIGHT / 2);
105 
106             break;
107         case U:
108             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x + Tank.WIDTH
109                     / 2, y);
110 
111             break;
112         case D:
113             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x + Tank.WIDTH
114                     / 2, y + Tank.HEIGHT);
115 
116             break;
117         case LU:
118             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x, y);
119             break;
120         case LD:
121             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x, y
122                     + Tank.HEIGHT);
123 
124             break;
125         case RU:
126             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x + Tank.WIDTH,
127                     y);
128 
129             break;
130         case RD:
131             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x + Tank.WIDTH,
132                     y + Tank.HEIGHT);
133 
134             break;
135         /*
136          * case STOP: break;
137          */
138         }
139         move();
140     }
141 
142     public void move() {
143         switch (dir) {
144         case L:
145             x -= XSPEED;
146             break;
147         case R:
148             x += XSPEED;
149             break;
150         case U:
151             y -= YSPEED;
152             break;
153         case D:
154             y += YSPEED;
155             break;
156         case LU:
157             x -= XSPEED;
158             y -= YSPEED;
159             break;
160         case LD:
161             x -= XSPEED;
162             y += YSPEED;
163             break;
164         case RU:
165             x += XSPEED;
166             y -= YSPEED;
167             break;
168         case RD:
169             x += XSPEED;
170             y += YSPEED;
171             break;
172 
173         case STOP:
174             break;
175         }
176         // 如果坦克不是停着的，则将炮筒调整至和坦克移动的方向相同
177         if (this.dir != Direction.STOP) {
178             this.ptDir = this.dir;
179         }
180         if (x < 0) {
181             x = 0;
182         }
183         // 因为我们的游戏界面有那个missileCount标签，所以在y轴方向不能用y是否<0进行判断
184         // 否则的话我们的坦克可以从上面出去
185         if (y < 50) {
186             y = 50;
187         }
188         if (x + Tank.WIDTH > TankClient.GAME_WIDTH) {
189             x = TankClient.GAME_WIDTH - Tank.WIDTH;
190         }
191         if (y + Tank.HEIGHT > TankClient.GAME_HEIGHT) {
192             y = TankClient.GAME_HEIGHT - Tank.HEIGHT;
193         }
194         // 在move方法中判断如果是敌方坦克
195         if (!good) {
196             Direction[] dirs = Direction.values();
197             // 定义敌方坦克的移动
198             if (step == 0) {
199                 step = r.nextInt(12) + 3;
200                 int rn = r.nextInt(dirs.length);
201                 dir = dirs[rn];
202             }
203             // 使得敌方坦克每隔一定时间就变化方向，values:方向枚举转化为数组
204 
205             step--;
206             //用随机数，使得敌方坦克可以发炮弹，但是不要太猛烈
207             if(r.nextInt(40)>38){    
208                 this.fire();
209             }
210         }
211     }
212 
213     public void locateDirection() {
214         if (bL && !bU && !bR && !bD)
215             dir = Direction.L;
216         else if (bL && bU && !bR && !bD)
217             dir = Direction.LU;
218         else if (!bL && bU && !bR && !bD)
219             dir = Direction.U;
220         else if (!bL && bU && bR && !bD)
221             dir = Direction.RU;
222         else if (!bL && !bU && bR && !bD)
223             dir = Direction.R;
224         else if (!bL && !bU && bR && bD)
225             dir = Direction.RD;
226         else if (!bL && !bU && !bR && bD)
227             dir = Direction.D;
228         else if (bL && !bU && !bR && bD)
229             dir = Direction.LD;
230         else if (!bL && !bU && !bR && !bD)
231             dir = Direction.STOP;
232 
233     }
234 
235     // 坦克自己向哪个方向移动，它自己最清楚;
236     public void KeyPressed(KeyEvent e) {
237         // 获得所按下的键所对应的虚拟码:
238         // Returns the integer keyCode associated with the key in this event
239         int key = e.getKeyCode();
240         // 判断不同的按键，指挥坦克的运动方向
241         switch (key) {
242         case KeyEvent.VK_LEFT:
243             bL = true;
244             break;
245         case KeyEvent.VK_UP:
246             bU = true;
247             break;
248         case KeyEvent.VK_RIGHT:
249             bR = true;
250             break;
251         case KeyEvent.VK_DOWN:
252             bD = true;
253             break;
254         }
255         locateDirection();
256     }
257 
258     public void keyReleased(KeyEvent e) {
259         int key = e.getKeyCode();
260         // 判断不同的按键，指挥坦克的运动方向
261         // 哪个键按下了，就把对应方向的布尔类型置为false
262         switch (key) {
263         // 为了防止一直按着Ctrl键的时候，炮弹太过于密集
264         // 因此我们定义在Ctrl键抬起的时候才发炮弹
265         // 这样炮弹不至于太过密集
266         case KeyEvent.VK_CONTROL:
267             fire();
268             break;
269         case KeyEvent.VK_LEFT:
270             bL = false;
271             break;
272         case KeyEvent.VK_UP:
273             bU = false;
274             break;
275         case KeyEvent.VK_RIGHT:
276             bR = false;
277             break;
278         case KeyEvent.VK_DOWN:
279             bD = false;
280             break;
281         }
282         // 重新定位一下
283         locateDirection();
284     }
285 
286     public Missile fire() {
287         if(!live){
288             return null;
289         }
290         // 计算子弹的位置，使得子弹从坦克的中间发出来
291         int x = this.x + Tank.WIDTH / 2 - Missile.WIDTH / 2;
292         int y = this.y + Tank.HEIGHT / 2 - Missile.HEIGHT / 2;
293         // 这个时候我们就根据炮筒的方向来发炮弹了，之前是根据坦克的方向来发炮弹
294         Missile m = new Missile(x, y, good,ptDir, tc);
295         // 将新产生的炮弹放置到List容器中
296         tc.missiles.add(m);
297         return m;
298     }
299 
300     // 拿到包围坦克的那个方块
301     public Rectangle getRect() {
302 
303         return new Rectangle(x, y, WIDTH, HEIGHT);
304     }
305 }
View Code

Missile:

技术分享 
  1 import java.awt.Color;
  2 import java.awt.Graphics;
  3 import java.awt.Rectangle;
  4 import java.util.List;
  5 
  6 public class Missile {
  7     // 炮弹的移动速度，不要比坦克的移动速度慢，不然你看到的是满屏的坦克追着炮弹跑
  8     public static final int XSPEED = 10;
  9     public static final int YSPEED = 10;
 10     // 将子弹的高度和宽度设置为常量
 11     public static final int WIDTH = 10;
 12     public static final int HEIGHT = 10;
 13     // 炮弹自己的三个属性
 14     int x;
 15     int y;
 16     Tank.Direction dir;
 17 
 18     //同一阵营的的坦克发出的子弹不能伤害自己人
 19     private boolean good;
 20     // 定义一个布尔类型的变量来判断炮弹是否已经消亡
 21     private boolean live = true;
 22     //我们在Missile类中也持有一个TankClient的引用
 23     //在炮弹出界的时候就可以从装炮弹的missiles集合中去除该炮弹，不再对其重画
 24     private TankClient tc;
 25 
 26     public boolean isLive() {
 27         return live;
 28     }
 29 
 30     public Missile(int x, int y, Tank.Direction dir) {
 31         this.x = x;
 32         this.y = y;
 33         this.dir = dir;
 34     }
 35     public Missile(int x,int y,boolean good,Tank.Direction dir,TankClient tc){
 36         this(x, y, dir);
 37         this.good=good;
 38         this.tc=tc;
 39     }
 40 
 41     // 炮弹自己的draw方法
 42     public void draw(Graphics g) {
 43         //炮弹消亡就不需要再画出来了
 44         if(!live){
 45             tc.missiles.remove(this);
 46             return;
 47         }
 48         Color c = g.getColor();
 49         g.setColor(Color.BLACK);
 50         // 炮弹形状不要比坦克大,这里设置成10,10;
 51         g.fillOval(x, y, WIDTH, HEIGHT);
 52         g.setColor(c);
 53         move();
 54     }
 55 
 56     public void move() {
 57         switch (dir) {
 58         case L:
 59             x -= XSPEED;
 60             break;
 61         case R:
 62             x += XSPEED;
 63             break;
 64         case U:
 65             y -= YSPEED;
 66             break;
 67         case D:
 68             y += YSPEED;
 69             break;
 70         case LU:
 71             x -= XSPEED;
 72             y -= YSPEED;
 73             break;
 74         case LD:
 75             x -= XSPEED;
 76             y += YSPEED;
 77             break;
 78         case RU:
 79             x += XSPEED;
 80             y -= YSPEED;
 81             break;
 82         case RD:
 83             x += XSPEED;
 84             y += YSPEED;
 85             break;
 86         // 炮弹就没有STOP这个枚举类型的值了
 87         /*
 88          * case STOP: break;
 89          */
 90         }
 91         // 判断炮弹出边界则消亡
 92         // 注意x,y只有正数值，x向右递增，y向下递增
 93         if (x < 0 || y < 0 || x > TankClient.GAME_WIDTH
 94                 || y > TankClient.GAME_HEIGHT) {
 95             live = false;
 96         }
 97     }
 98     public boolean hitTank(Tank t){
 99         //炮弹的方框和坦克的方框碰在一起了并且坦克是存活着的,后面的判断我们是一伙的我就不打你了
100         if(this.live&&this.getRect().intersects(t.getRect())&&t.isLive()&&this.good!=t.isGood()){
101             t.setLive(false);
102             this.live=false;
103             
104             //炮弹击中坦克，发生爆炸
105             Explode e=new Explode(x, y, tc);
106             tc.explodes.add(e);
107             return true;
108         }
109         return false;
110     }
111     //碰撞检测类Rectangle
112     //拿到包围在炮弹周围的小方块
113     public Rectangle getRect(){
114         return new Rectangle(x,y,WIDTH,HEIGHT);
115     }
116     
117     //添加hitTanks方法
118     public boolean hitTanks(List<Tank> tanks){
119         for(int i=0;i<tanks.size();i++){
120             if(hitTank(tanks.get(i))){
121                 return true;
122             }
123         }
124         return false;
125         
126     }
127 }
View Code

Explode(这个类没有变化):

技术分享 
 1 import java.awt.*;
 2 
 3 public class Explode {
 4     //爆炸的位置
 5     int x, y;
 6     //爆炸是否存在
 7     private boolean live = true;
 8     
 9     //持有一个Tankclient的引用
10     private TankClient tc ;
11     
12     //定义不同直径大小的爆炸
13     int[] diameter = {4, 7, 12, 18, 26, 32, 49, 30, 14, 6};
14     //爆炸发生到哪一个阶段了，对应相应大小的直径
15     int step = 0;
16     
17     public Explode(int x, int y, TankClient tc) {
18         this.x = x;
19         this.y = y;
20         this.tc = tc;
21     }
22     
23     public void draw(Graphics g) {
24         if(!live) {
25             //爆炸发生，将相应直径的爆炸圆从集合explodes中去除
26             tc.explodes.remove(this);
27             return;
28         }
29         
30         if(step == diameter.length) {
31             live = false;
32             step = 0;
33             return;
34         }
35         
36         Color c = g.getColor();
37         g.setColor(Color.ORANGE);
38         
39         //把不同的圆画出来
40         g.fillOval(x, y, diameter[step], diameter[step]);
41         g.setColor(c);
42         
43         step ++;
44     }
45 }
View Code

Tankclient:

技术分享 
  1 import java.awt.*;
  2 import java.awt.event.*;
  3 import java.util.ArrayList;
  4 import java.util.List;
  5 
  6 public class TankClient extends Frame {
  7     // 设置成常量，方便以后的改动
  8     public static final int GAME_WIDTH = 800;
  9     public static final int GAME_HEIGHT = 600;
 10 
 11     // 将当前的TankClient对象传递给myTank;
 12     // 目的是方便我们在Tank这个类中访问m(炮弹对象)这个成员变量
 13     // 其实就是在Tank类中持有TankClient类对象的一个引用
 14 
 15     // 我们这里new我们自己的坦克
 16     Tank myTank = new Tank(50, 50, true, Tank.Direction.STOP, this);
 17 
 18     /*
 19      * //新建敌方坦克,(不再需要这个了) Tank enemyTank=new Tank(100,100,false,this);
 20      */
 21     // 定义爆炸
 22     Explode e = new Explode(70, 70, this);
 23     // 定义一个集合，多个爆炸点
 24     List<Explode> explodes = new ArrayList<Explode>();
 25 
 26     // 使用容器装炮弹
 27     List<Missile> missiles = new ArrayList<Missile>();
 28 
 29     // 用容器来装敌人的Tank
 30     List<Tank> tanks = new ArrayList<Tank>();
 31     // 定义虚拟图片，方便后期的一次性显示
 32     Image offScreenImage = null;
 33 
 34     public void paint(Graphics g) {
 35         // 记录屏幕上的子弹数目
 36         g.drawString("missiles count:" + missiles.size(), 10, 50);
 37         // 添加上方标记栏，记录爆炸次数
 38         g.drawString("explodes count:" + explodes.size(), 10, 70);
 39         // 记录现在屏幕上一共有多少敌方坦克
 40         g.drawString("tanks count:" + tanks.size(), 10, 90);
 41 
 42         // 遍历结合，发出多发炮弹
 43         for (int i = 0; i < missiles.size(); i++) {
 44             Missile m = missiles.get(i);
 45             // 对于每一发炮弹，都可以将tanks集合中的敌方炮弹干掉
 46             m.hitTanks(tanks);
 47             m.hitTank(myTank);
 48             m.draw(g);
 49         }
 50 
 51         for (int i = 0; i < explodes.size(); i++) {
 52             Explode e = explodes.get(i);
 53             e.draw(g);
 54         }
 55 
 56         for (int i = 0; i < tanks.size(); i++) {
 57             Tank t = tanks.get(i);
 58             t.draw(g);
 59         }
 60         // 不改变前景色
 61         myTank.draw(g);
 62     }
 63 
 64     // 刷新操作
 65     public void update(Graphics g) {
 66         if (offScreenImage == null) {
 67             offScreenImage = this.createImage(GAME_WIDTH, GAME_HEIGHT);
 68         }
 69         Graphics gOffScreen = offScreenImage.getGraphics();
 70         Color c = gOffScreen.getColor();
 71         gOffScreen.setColor(Color.GREEN);
 72         gOffScreen.fillRect(0, 0, GAME_WIDTH, GAME_HEIGHT);
 73         gOffScreen.setColor(c);
 74         paint(gOffScreen);
 75         g.drawImage(offScreenImage, 0, 0, null);
 76     }
 77 
 78     public void lauchFrame() {
 79 
 80         // 添加多辆坦克
 81         for (int i = 0; i < 10; i++) {
 82             tanks.add(new Tank(50 + 40 * (i + 1), 50, false, Tank.Direction.D,
 83                     this));
 84         }
 85         // this.setLocation(400, 300);
 86         this.setSize(GAME_WIDTH, GAME_HEIGHT);
 87         this.setTitle("TankWar");
 88         this.addWindowListener(new WindowAdapter() {
 89             public void windowClosing(WindowEvent e) {
 90                 System.exit(0);
 91             }
 92         });
 93         this.setResizable(false);
 94         this.setBackground(Color.GREEN);
 95 
 96         this.addKeyListener(new KeyMonitor());
 97 
 98         setVisible(true);
 99 
100         new Thread(new PaintThread()).start();
101     }
102 
103     public static void main(String[] args) {
104         TankClient tc = new TankClient();
105         tc.lauchFrame();
106     }
107 
108     private class PaintThread implements Runnable {
109 
110         public void run() {
111             while (true) {
112                 repaint();
113                 try {
114                     // 为了爆炸效果，改成1000
115                     Thread.sleep(50);
116                 } catch (InterruptedException e) {
117                     e.printStackTrace();
118                 }
119             }
120         }
121     }
122 
123     // 创建键盘时间监听
124     private class KeyMonitor extends KeyAdapter {
125 
126         // 直接调用myTank自己的方法根据相应的按键信息进行移动
127         public void keyPressed(KeyEvent e) {
128             myTank.KeyPressed(e);
129             // 添加了处理键抬起的事件，可以控制坦克起步以后的状态
130             // 而不是一直按照一个方向走下去
131         }
132 
133         public void keyReleased(KeyEvent e) {
134             myTank.keyReleased(e);
135         }
136 
137     }
138 }
View Code

版本2.0

功能：添加两堵墙
步骤：1)建Wall类、建立Wall对象、画出来
        2)让每一颗子弹打击每一堵墙
             hitWall()方法
             注意：子弹速度不能太快，否则很容易穿过墙
        3)让坦克不能穿过墙
           记录上一次的位置oldX, oldY
           修改构造函数
           每次move之前纪录上一次位置
           添加stay方法
           记录移动前的位置
           当撞到时回到移动前的位置
           当碰到墙的时候stay

具体代码实现：

Tank:

技术分享 
  1 import java.awt.*;
  2 import java.awt.event.*;
  3 import java.util.Random;
  4 
  5 public class Tank {
  6     // 方便后期更改
  7     public static final int XSPEED = 5;
  8     public static final int YSPEED = 5;
  9     // 将坦克的高度和宽度设置为常量
 10     public static final int WIDTH = 30;
 11     public static final int HEIGHT = 30;
 12     TankClient tc;
 13     // 区别是我方坦克还是地方坦克，方便据此进行不同的设置
 14     private boolean good;
 15 
 16     public boolean isGood() {
 17         return good;
 18     }
 19 
 20     public void setGood(boolean good) {
 21         this.good = good;
 22     }
 23 
 24     // 判断坦克生死的变量
 25     private boolean live = true;
 26 
 27     public boolean isLive() {
 28         return live;
 29     }
 30 
 31     public void setLive(boolean live) {
 32         this.live = live;
 33     }
 34 
 35     private int x;
 36     private int y;
 37     
 38     //记录坦克上一步的位置，防止坦克一碰到wall,就会依附在上面
 39     private int oldx;
 40     private int oldy;
 41 
 42     // 随机数产生器，方便敌方坦克可以任意移动
 43     private static Random r = new Random();
 44     // 添加记录按键状态的布尔量
 45     private boolean bL = false;
 46     private boolean bR = false;
 47     private boolean bU = false;
 48     private boolean bD = false;
 49 
 50     // 添加代表方向的量（使用枚举）
 51     enum Direction {
 52         L, R, U, D, LU, LD, RU, RD, STOP
 53     };
 54 
 55     private Direction dir = Direction.STOP;
 56 
 57     // 定义炮筒的方向，我们想办法将炮筒的方法调整成和坦克移动方向一致;
 58     // 我们这里会用一条直线来表示炮筒:模拟炮筒
 59     // 我们要根据炮筒的方向画直线表示炮筒
 60     Direction ptDir = Direction.D;
 61 
 62     // 为了让敌方坦克在一定方向运动移动时间再自动变换方向
 63     private int step = r.nextInt(12) + 3;
 64 
 65     // 更改构造函数
 66     public Tank(int x, int y, boolean good) {
 67         this.x = x;
 68         this.y = y;
 69         this.oldx=x;
 70         this.oldy=y;
 71         this.good = good;
 72     }
 73 
 74     // 这个位置的构造函数也相应进行了更改
 75     public Tank(int x, int y, boolean good, Direction dir, TankClient tc) {
 76         // 调用那个有两个参数的构造方法
 77         this(x, y, good);
 78         this.dir = dir;
 79         // 在这个位置初始化tc
 80         this.tc = tc;
 81     }
 82 
 83     // Tank对象的draw方法
 84     public void draw(Graphics g) {
 85         if (!live) {
 86             // 如果死亡的是敌方坦克，在tanks集合中去除该坦克
 87             if (!good) {
 88                 tc.tanks.remove(this);
 89             }
 90             // 如果是我方坦克，直接返回
 91             return;
 92         }
 93         Color c = g.getColor();
 94         if (good) {
 95             g.setColor(Color.RED);
 96         } else {
 97             g.setColor(Color.PINK);
 98         }
 99         g.fillOval(x, y, WIDTH, HEIGHT);
100         g.setColor(c);
101         // 根据炮筒的方向画直线来表示我们坦克的炮筒
102         switch (ptDir) {
103         case L:
104             // 画直线:四个参数分别代表：坦克中心点的坐标 直线的另一头的的坐标
105             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x, y
106                     + Tank.HEIGHT / 2);
107             break;
108         case R:
109             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x + Tank.WIDTH,
110                     y + Tank.HEIGHT / 2);
111 
112             break;
113         case U:
114             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x + Tank.WIDTH
115                     / 2, y);
116 
117             break;
118         case D:
119             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x + Tank.WIDTH
120                     / 2, y + Tank.HEIGHT);
121 
122             break;
123         case LU:
124             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x, y);
125             break;
126         case LD:
127             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x, y
128                     + Tank.HEIGHT);
129 
130             break;
131         case RU:
132             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x + Tank.WIDTH,
133                     y);
134 
135             break;
136         case RD:
137             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x + Tank.WIDTH,
138                     y + Tank.HEIGHT);
139 
140             break;
141         /*
142          * case STOP: break;
143          */
144         }
145         move();
146     }
147 
148     public void move() {
149         //记录坦克上一步的位置
150         this.oldx=x;
151         this.oldy=y;
152         switch (dir) {
153         case L:
154             x -= XSPEED;
155             break;
156         case R:
157             x += XSPEED;
158             break;
159         case U:
160             y -= YSPEED;
161             break;
162         case D:
163             y += YSPEED;
164             break;
165         case LU:
166             x -= XSPEED;
167             y -= YSPEED;
168             break;
169         case LD:
170             x -= XSPEED;
171             y += YSPEED;
172             break;
173         case RU:
174             x += XSPEED;
175             y -= YSPEED;
176             break;
177         case RD:
178             x += XSPEED;
179             y += YSPEED;
180             break;
181 
182         case STOP:
183             break;
184         }
185         // 如果坦克不是停着的，则将炮筒调整至和坦克移动的方向相同
186         if (this.dir != Direction.STOP) {
187             this.ptDir = this.dir;
188         }
189         if (x < 0) {
190             x = 0;
191         }
192         // 因为我们的游戏界面有那个missileCount标签，所以在y轴方向不能用y是否<0进行判断
193         // 否则的话我们的坦克可以从上面出去
194         if (y < 50) {
195             y = 50;
196         }
197         if (x + Tank.WIDTH > TankClient.GAME_WIDTH) {
198             x = TankClient.GAME_WIDTH - Tank.WIDTH;
199         }
200         if (y + Tank.HEIGHT > TankClient.GAME_HEIGHT) {
201             y = TankClient.GAME_HEIGHT - Tank.HEIGHT;
202         }
203         // 在move方法中判断如果是敌方坦克
204         if (!good) {
205             Direction[] dirs = Direction.values();
206             // 定义敌方坦克的移动
207             if (step == 0) {
208                 step = r.nextInt(12) + 3;
209                 int rn = r.nextInt(dirs.length);
210                 dir = dirs[rn];
211             }
212             // 使得敌方坦克每隔一定时间就变化方向，values:方向枚举转化为数组
213 
214             step--;
215             //用随机数，使得敌方坦克可以发炮弹，但是不要太猛烈
216             if(r.nextInt(40)>38){    
217                 this.fire();
218             }
219         }
220     }
221 
222     public void locateDirection() {
223         if (bL && !bU && !bR && !bD)
224             dir = Direction.L;
225         else if (bL && bU && !bR && !bD)
226             dir = Direction.LU;
227         else if (!bL && bU && !bR && !bD)
228             dir = Direction.U;
229         else if (!bL && bU && bR && !bD)
230             dir = Direction.RU;
231         else if (!bL && !bU && bR && !bD)
232             dir = Direction.R;
233         else if (!bL && !bU && bR && bD)
234             dir = Direction.RD;
235         else if (!bL && !bU && !bR && bD)
236             dir = Direction.D;
237         else if (bL && !bU && !bR && bD)
238             dir = Direction.LD;
239         else if (!bL && !bU && !bR && !bD)
240             dir = Direction.STOP;
241 
242     }
243 
244     private void stay(){
245         x=oldx;
246         y=oldy;
247     }
248     // 坦克自己向哪个方向移动，它自己最清楚;
249     public void KeyPressed(KeyEvent e) {
250         // 获得所按下的键所对应的虚拟码:
251         // Returns the integer keyCode associated with the key in this event
252         int key = e.getKeyCode();
253         // 判断不同的按键，指挥坦克的运动方向
254         switch (key) {
255         case KeyEvent.VK_LEFT:
256             bL = true;
257             break;
258         case KeyEvent.VK_UP:
259             bU = true;
260             break;
261         case KeyEvent.VK_RIGHT:
262             bR = true;
263             break;
264         case KeyEvent.VK_DOWN:
265             bD = true;
266             break;
267         }
268         locateDirection();
269     }
270 
271     public void keyReleased(KeyEvent e) {
272         int key = e.getKeyCode();
273         // 判断不同的按键，指挥坦克的运动方向
274         // 哪个键按下了，就把对应方向的布尔类型置为false
275         switch (key) {
276         // 为了防止一直按着Ctrl键的时候，炮弹太过于密集
277         // 因此我们定义在Ctrl键抬起的时候才发炮弹
278         // 这样炮弹不至于太过密集
279         case KeyEvent.VK_CONTROL:
280             fire();
281             break;
282         case KeyEvent.VK_LEFT:
283             bL = false;
284             break;
285         case KeyEvent.VK_UP:
286             bU = false;
287             break;
288         case KeyEvent.VK_RIGHT:
289             bR = false;
290             break;
291         case KeyEvent.VK_DOWN:
292             bD = false;
293             break;
294         }
295         // 重新定位一下
296         locateDirection();
297     }
298 
299     public Missile fire() {
300         if(!live){
301             return null;
302         }
303         // 计算子弹的位置，使得子弹从坦克的中间发出来
304         int x = this.x + Tank.WIDTH / 2 - Missile.WIDTH / 2;
305         int y = this.y + Tank.HEIGHT / 2 - Missile.HEIGHT / 2;
306         // 这个时候我们就根据炮筒的方向来发炮弹了，之前是根据坦克的方向来发炮弹
307         Missile m = new Missile(x, y, good,ptDir, tc);
308         // 将新产生的炮弹放置到List容器中
309         tc.missiles.add(m);
310         return m;
311     }
312 
313     // 拿到包围坦克的那个方块
314     public Rectangle getRect() {
315 
316         return new Rectangle(x, y, WIDTH, HEIGHT);
317     }
318     
319     public boolean collidesWithWall(Wall w){
320         
321         if(this.live&&this.getRect().intersects(w.getRect())){
322             this.dir=Direction.STOP;
323             //当坦克撞到墙上的时候，停一下，再回到上一步的位置
324             this.stay();
325             return true;
326         }
327         return false;
328         
329     }
330 }
View Code

Missile:

技术分享 
  1 import java.awt.Color;
  2 import java.awt.Graphics;
  3 import java.awt.Rectangle;
  4 import java.util.List;
  5 
  6 public class Missile {
  7     // 炮弹的移动速度，不要比坦克的移动速度慢，不然你看到的是满屏的坦克追着炮弹跑
  8     public static final int XSPEED = 10;
  9     public static final int YSPEED = 10;
 10     // 将子弹的高度和宽度设置为常量
 11     public static final int WIDTH = 10;
 12     public static final int HEIGHT = 10;
 13     // 炮弹自己的三个属性
 14     int x;
 15     int y;
 16     Tank.Direction dir;
 17 
 18     //同一阵营的的坦克发出的子弹不能伤害自己人
 19     private boolean good;
 20     // 定义一个布尔类型的变量来判断炮弹是否已经消亡
 21     private boolean live = true;
 22     //我们在Missile类中也持有一个TankClient的引用
 23     //在炮弹出界的时候就可以从装炮弹的missiles集合中去除该炮弹，不再对其重画
 24     private TankClient tc;
 25 
 26     public boolean isLive() {
 27         return live;
 28     }
 29 
 30     public Missile(int x, int y, Tank.Direction dir) {
 31         this.x = x;
 32         this.y = y;
 33         this.dir = dir;
 34     }
 35     public Missile(int x,int y,boolean good,Tank.Direction dir,TankClient tc){
 36         this(x, y, dir);
 37         this.good=good;
 38         this.tc=tc;
 39     }
 40 
 41     // 炮弹自己的draw方法
 42     public void draw(Graphics g) {
 43         //炮弹消亡就不需要再画出来了
 44         if(!live){
 45             tc.missiles.remove(this);
 46             return;
 47         }
 48         Color c = g.getColor();
 49         g.setColor(Color.BLACK);
 50         // 炮弹形状不要比坦克大,这里设置成10,10;
 51         g.fillOval(x, y, WIDTH, HEIGHT);
 52         g.setColor(c);
 53         move();
 54     }
 55 
 56     public void move() {
 57         switch (dir) {
 58         case L:
 59             x -= XSPEED;
 60             break;
 61         case R:
 62             x += XSPEED;
 63             break;
 64         case U:
 65             y -= YSPEED;
 66             break;
 67         case D:
 68             y += YSPEED;
 69             break;
 70         case LU:
 71             x -= XSPEED;
 72             y -= YSPEED;
 73             break;
 74         case LD:
 75             x -= XSPEED;
 76             y += YSPEED;
 77             break;
 78         case RU:
 79             x += XSPEED;
 80             y -= YSPEED;
 81             break;
 82         case RD:
 83             x += XSPEED;
 84             y += YSPEED;
 85             break;
 86         // 炮弹就没有STOP这个枚举类型的值了
 87         /*
 88          * case STOP: break;
 89          */
 90         }
 91         // 判断炮弹出边界则消亡
 92         // 注意x,y只有正数值，x向右递增，y向下递增
 93         if (x < 0 || y < 0 || x > TankClient.GAME_WIDTH
 94                 || y > TankClient.GAME_HEIGHT) {
 95             live = false;
 96         }
 97     }
 98     public boolean hitTank(Tank t){
 99         //炮弹的方框和坦克的方框碰在一起了并且坦克是存活着的,后面的判断我们是一伙的我就不打你了
100         if(this.live&&this.getRect().intersects(t.getRect())&&t.isLive()&&this.good!=t.isGood()){
101             t.setLive(false);
102             this.live=false;
103             
104             //炮弹击中坦克，发生爆炸
105             Explode e=new Explode(x, y, tc);
106             tc.explodes.add(e);
107             return true;
108         }
109         return false;
110     }
111     //碰撞检测类Rectangle
112     //拿到包围在炮弹周围的小方块
113     public Rectangle getRect(){
114         return new Rectangle(x,y,WIDTH,HEIGHT);
115     }
116     
117     //添加hitTanks方法
118     public boolean hitTanks(List<Tank> tanks){
119         for(int i=0;i<tanks.size();i++){
120             if(hitTank(tanks.get(i))){
121                 return true;
122             }
123         }
124         return false;
125         
126     }
127     public boolean hitWall(Wall w){
128         if(this.live&&this.getRect().intersects(w.getRect())){
129             this.live=false;
130             return true;
131         }
132         return false;
133     }
134 }
View Code

Explode:

技术分享 
 1 import java.awt.*;
 2 
 3 public class Explode {
 4     //爆炸的位置
 5     int x, y;
 6     //爆炸是否存在
 7     private boolean live = true;
 8     
 9     //持有一个Tankclient的引用
10     private TankClient tc ;
11     
12     //定义不同直径大小的爆炸
13     int[] diameter = {4, 7, 12, 18, 26, 32, 49, 30, 14, 6};
14     //爆炸发生到哪一个阶段了，对应相应大小的直径
15     int step = 0;
16     
17     public Explode(int x, int y, TankClient tc) {
18         this.x = x;
19         this.y = y;
20         this.tc = tc;
21     }
22     
23     public void draw(Graphics g) {
24         if(!live) {
25             //爆炸发生，将相应直径的爆炸圆从集合explodes中去除
26             tc.explodes.remove(this);
27             return;
28         }
29         
30         if(step == diameter.length) {
31             live = false;
32             step = 0;
33             return;
34         }
35         
36         Color c = g.getColor();
37         g.setColor(Color.ORANGE);
38         
39         //把不同的圆画出来
40         g.fillOval(x, y, diameter[step], diameter[step]);
41         g.setColor(c);
42         
43         step ++;
44     }
45 }
View Code

Wall:

 1 import java.awt.Graphics;
 2 import java.awt.Rectangle;
 3 
 4 //墙
 5 public class Wall {
 6     int x,y,w,h;
 7     TankClient tc;
 8     public Wall(int x, int y, int w, int h, TankClient tc) {
 9         super();
10         this.x = x;
11         this.y = y;
12         this.w = w;
13         this.h = h;
14         this.tc = tc;
15     }
16     public void draw(Graphics g){
17         g.fillRect(x, y, w, h);
18     }
19     //碰撞检测
20     public Rectangle getRect(){
21         return new Rectangle(x,y,w,h);
22     }
23 }

TankClient:

技术分享 
  1 import java.awt.*;
  2 import java.awt.event.*;
  3 import java.util.ArrayList;
  4 import java.util.List;
  5 
  6 public class TankClient extends Frame {
  7     // 设置成常量，方便以后的改动
  8     public static final int GAME_WIDTH = 800;
  9     public static final int GAME_HEIGHT = 600;
 10 
 11     // 将当前的TankClient对象传递给myTank;
 12     // 目的是方便我们在Tank这个类中访问m(炮弹对象)这个成员变量
 13     // 其实就是在Tank类中持有TankClient类对象的一个引用
 14 
 15     // 我们这里new我们自己的坦克
 16     Tank myTank = new Tank(50, 50, true, Tank.Direction.STOP, this);
 17 
 18     Wall w1=new Wall(100, 200,20, 150,this);
 19     Wall w2=new Wall(300, 100,300,20,this);
 20     /*
 21      * //新建敌方坦克,(不再需要这个了) Tank enemyTank=new Tank(100,100,false,this);
 22      */
 23     // 定义爆炸
 24     Explode e = new Explode(70, 70, this);
 25     // 定义一个集合，多个爆炸点
 26     List<Explode> explodes = new ArrayList<Explode>();
 27 
 28     // 使用容器装炮弹
 29     List<Missile> missiles = new ArrayList<Missile>();
 30 
 31     // 用容器来装敌人的Tank
 32     List<Tank> tanks = new ArrayList<Tank>();
 33     // 定义虚拟图片，方便后期的一次性显示
 34     Image offScreenImage = null;
 35 
 36     public void paint(Graphics g) {
 37         // 记录屏幕上的子弹数目
 38         g.drawString("missiles count:" + missiles.size(), 10, 50);
 39         // 添加上方标记栏，记录爆炸次数
 40         g.drawString("explodes count:" + explodes.size(), 10, 70);
 41         // 记录现在屏幕上一共有多少敌方坦克
 42         g.drawString("tanks count:" + tanks.size(), 10, 90);
 43 
 44         // 遍历结合，发出多发炮弹
 45         for (int i = 0; i < missiles.size(); i++) {
 46             Missile m = missiles.get(i);
 47             // 对于每一发炮弹，都可以将tanks集合中的敌方炮弹干掉
 48             m.hitTanks(tanks);
 49             m.hitTank(myTank);
 50             m.hitWall(w1);
 51             m.hitWall(w2);
 52             m.draw(g);
 53         }
 54 
 55         for (int i = 0; i < explodes.size(); i++) {
 56             Explode e = explodes.get(i);
 57             e.draw(g);
 58         }
 59 
 60         for (int i = 0; i < tanks.size(); i++) {
 61             Tank t = tanks.get(i);
 62             t.collidesWithWall(w1);
 63             t.collidesWithWall(w2);
 64             t.draw(g);
 65         }
 66         // 不改变前景色
 67         myTank.draw(g);
 68         w1.draw(g);
 69         w2.draw(g);
 70     }
 71 
 72     // 刷新操作
 73     public void update(Graphics g) {
 74         if (offScreenImage == null) {
 75             offScreenImage = this.createImage(GAME_WIDTH, GAME_HEIGHT);
 76         }
 77         Graphics gOffScreen = offScreenImage.getGraphics();
 78         Color c = gOffScreen.getColor();
 79         gOffScreen.setColor(Color.GREEN);
 80         gOffScreen.fillRect(0, 0, GAME_WIDTH, GAME_HEIGHT);
 81         gOffScreen.setColor(c);
 82         paint(gOffScreen);
 83         g.drawImage(offScreenImage, 0, 0, null);
 84     }
 85 
 86     public void lauchFrame() {
 87 
 88         // 添加多辆坦克
 89         for (int i = 0; i < 10; i++) {
 90             tanks.add(new Tank(50 + 40 * (i + 1), 50, false, Tank.Direction.D,
 91                     this));
 92         }
 93         // this.setLocation(400, 300);
 94         this.setSize(GAME_WIDTH, GAME_HEIGHT);
 95         this.setTitle("TankWar");
 96         this.addWindowListener(new WindowAdapter() {
 97             public void windowClosing(WindowEvent e) {
 98                 System.exit(0);
 99             }
100         });
101         this.setResizable(false);
102         this.setBackground(Color.GREEN);
103 
104         this.addKeyListener(new KeyMonitor());
105 
106         setVisible(true);
107 
108         new Thread(new PaintThread()).start();
109     }
110 
111     public static void main(String[] args) {
112         TankClient tc = new TankClient();
113         tc.lauchFrame();
114     }
115 
116     private class PaintThread implements Runnable {
117 
118         public void run() {
119             while (true) {
120                 repaint();
121                 try {
122                     // 为了爆炸效果，改成1000
123                     Thread.sleep(50);
124                 } catch (InterruptedException e) {
125                     e.printStackTrace();
126                 }
127             }
128         }
129     }
130 
131     // 创建键盘时间监听
132     private class KeyMonitor extends KeyAdapter {
133 
134         // 直接调用myTank自己的方法根据相应的按键信息进行移动
135         public void keyPressed(KeyEvent e) {
136             myTank.KeyPressed(e);
137             // 添加了处理键抬起的事件，可以控制坦克起步以后的状态
138             // 而不是一直按照一个方向走下去
139         }
140 
141         public void keyReleased(KeyEvent e) {
142             myTank.keyReleased(e);
143         }
144 
145     }
146 }
View Code

版本2.1
功能：坦克不能互相穿越
步骤：
        当坦克撞到Tank时stay：添加碰撞检测，就添加了一个方法

 1 public boolean collidesWithTanks(java.util.List<Tank> tanks) {
 2         for (int i = 0; i < tanks.size(); i++) {
 3             Tank t = tanks.get(i);
 4             if (this != t) {
 5                 if (this.live && t.isLive()
 6                         && this.getRect().intersects(t.getRect())) {
 7                     this.stay();
 8                     t.stay();
 9                 }
10             }
11         }
12         return bD;
13 
14     }

TankClient类中的paint方法中：

1 for (int i = 0; i < tanks.size(); i++) {
2             Tank t = tanks.get(i);
3             t.collidesWithWall(w1);
4             t.collidesWithWall(w2);
5             t.collidesWithTanks(tanks);
6             t.draw(g);
7         }

具体代码实现：

Tank：

技术分享 
  1 import java.awt.*;
  2 import java.awt.event.*;
  3 import java.util.Random;
  4 
  5 public class Tank {
  6     // 方便后期更改
  7     public static final int XSPEED = 5;
  8     public static final int YSPEED = 5;
  9     // 将坦克的高度和宽度设置为常量
 10     public static final int WIDTH = 30;
 11     public static final int HEIGHT = 30;
 12     TankClient tc;
 13     // 区别是我方坦克还是地方坦克，方便据此进行不同的设置
 14     private boolean good;
 15 
 16     public boolean isGood() {
 17         return good;
 18     }
 19 
 20     public void setGood(boolean good) {
 21         this.good = good;
 22     }
 23 
 24     // 判断坦克生死的变量
 25     private boolean live = true;
 26 
 27     public boolean isLive() {
 28         return live;
 29     }
 30 
 31     public void setLive(boolean live) {
 32         this.live = live;
 33     }
 34 
 35     private int x;
 36     private int y;
 37 
 38     // 记录坦克上一步的位置，防止坦克一碰到wall,就会依附在上面
 39     private int oldx;
 40     private int oldy;
 41 
 42     // 随机数产生器，方便敌方坦克可以任意移动
 43     private static Random r = new Random();
 44     // 添加记录按键状态的布尔量
 45     private boolean bL = false;
 46     private boolean bR = false;
 47     private boolean bU = false;
 48     private boolean bD = false;
 49 
 50     // 添加代表方向的量（使用枚举）
 51     enum Direction {
 52         L, R, U, D, LU, LD, RU, RD, STOP
 53     };
 54 
 55     private Direction dir = Direction.STOP;
 56 
 57     // 定义炮筒的方向，我们想办法将炮筒的方法调整成和坦克移动方向一致;
 58     // 我们这里会用一条直线来表示炮筒:模拟炮筒
 59     // 我们要根据炮筒的方向画直线表示炮筒
 60     Direction ptDir = Direction.D;
 61 
 62     // 为了让敌方坦克在一定方向运动移动时间再自动变换方向
 63     private int step = r.nextInt(12) + 3;
 64 
 65     // 更改构造函数
 66     public Tank(int x, int y, boolean good) {
 67         this.x = x;
 68         this.y = y;
 69         this.oldx = x;
 70         this.oldy = y;
 71         this.good = good;
 72     }
 73 
 74     // 这个位置的构造函数也相应进行了更改
 75     public Tank(int x, int y, boolean good, Direction dir, TankClient tc) {
 76         // 调用那个有两个参数的构造方法
 77         this(x, y, good);
 78         this.dir = dir;
 79         // 在这个位置初始化tc
 80         this.tc = tc;
 81     }
 82 
 83     // Tank对象的draw方法
 84     public void draw(Graphics g) {
 85         if (!live) {
 86             // 如果死亡的是敌方坦克，在tanks集合中去除该坦克
 87             if (!good) {
 88                 tc.tanks.remove(this);
 89             }
 90             // 如果是我方坦克，直接返回
 91             return;
 92         }
 93         Color c = g.getColor();
 94         if (good) {
 95             g.setColor(Color.RED);
 96         } else {
 97             g.setColor(Color.PINK);
 98         }
 99         g.fillOval(x, y, WIDTH, HEIGHT);
100         g.setColor(c);
101         // 根据炮筒的方向画直线来表示我们坦克的炮筒
102         switch (ptDir) {
103         case L:
104             // 画直线:四个参数分别代表：坦克中心点的坐标 直线的另一头的的坐标
105             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x, y
106                     + Tank.HEIGHT / 2);
107             break;
108         case R:
109             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x + Tank.WIDTH,
110                     y + Tank.HEIGHT / 2);
111 
112             break;
113         case U:
114             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x + Tank.WIDTH
115                     / 2, y);
116 
117             break;
118         case D:
119             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x + Tank.WIDTH
120                     / 2, y + Tank.HEIGHT);
121 
122             break;
123         case LU:
124             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x, y);
125             break;
126         case LD:
127             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x, y
128                     + Tank.HEIGHT);
129 
130             break;
131         case RU:
132             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x + Tank.WIDTH,
133                     y);
134 
135             break;
136         case RD:
137             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x + Tank.WIDTH,
138                     y + Tank.HEIGHT);
139 
140             break;
141         /*
142          * case STOP: break;
143          */
144         }
145         move();
146     }
147 
148     public void move() {
149         // 记录坦克上一步的位置
150         this.oldx = x;
151         this.oldy = y;
152         switch (dir) {
153         case L:
154             x -= XSPEED;
155             break;
156         case R:
157             x += XSPEED;
158             break;
159         case U:
160             y -= YSPEED;
161             break;
162         case D:
163             y += YSPEED;
164             break;
165         case LU:
166             x -= XSPEED;
167             y -= YSPEED;
168             break;
169         case LD:
170             x -= XSPEED;
171             y += YSPEED;
172             break;
173         case RU:
174             x += XSPEED;
175             y -= YSPEED;
176             break;
177         case RD:
178             x += XSPEED;
179             y += YSPEED;
180             break;
181 
182         case STOP:
183             break;
184         }
185         // 如果坦克不是停着的，则将炮筒调整至和坦克移动的方向相同
186         if (this.dir != Direction.STOP) {
187             this.ptDir = this.dir;
188         }
189         if (x < 0) {
190             x = 0;
191         }
192         // 因为我们的游戏界面有那个missileCount标签，所以在y轴方向不能用y是否<0进行判断
193         // 否则的话我们的坦克可以从上面出去
194         if (y < 50) {
195             y = 50;
196         }
197         if (x + Tank.WIDTH > TankClient.GAME_WIDTH) {
198             x = TankClient.GAME_WIDTH - Tank.WIDTH;
199         }
200         if (y + Tank.HEIGHT > TankClient.GAME_HEIGHT) {
201             y = TankClient.GAME_HEIGHT - Tank.HEIGHT;
202         }
203         // 在move方法中判断如果是敌方坦克
204         if (!good) {
205             Direction[] dirs = Direction.values();
206             // 定义敌方坦克的移动
207             if (step == 0) {
208                 step = r.nextInt(12) + 3;
209                 int rn = r.nextInt(dirs.length);
210                 dir = dirs[rn];
211             }
212             // 使得敌方坦克每隔一定时间就变化方向，values:方向枚举转化为数组
213 
214             step--;
215             // 用随机数，使得敌方坦克可以发炮弹，但是不要太猛烈
216             if (r.nextInt(40) > 38) {
217                 this.fire();
218             }
219         }
220     }
221 
222     public void locateDirection() {
223         if (bL && !bU && !bR && !bD)
224             dir = Direction.L;
225         else if (bL && bU && !bR && !bD)
226             dir = Direction.LU;
227         else if (!bL && bU && !bR && !bD)
228             dir = Direction.U;
229         else if (!bL && bU && bR && !bD)
230             dir = Direction.RU;
231         else if (!bL && !bU && bR && !bD)
232             dir = Direction.R;
233         else if (!bL && !bU && bR && bD)
234             dir = Direction.RD;
235         else if (!bL && !bU && !bR && bD)
236             dir = Direction.D;
237         else if (bL && !bU && !bR && bD)
238             dir = Direction.LD;
239         else if (!bL && !bU && !bR && !bD)
240             dir = Direction.STOP;
241 
242     }
243 
244     private void stay() {
245         x = oldx;
246         y = oldy;
247     }
248 
249     // 坦克自己向哪个方向移动，它自己最清楚;
250     public void KeyPressed(KeyEvent e) {
251         // 获得所按下的键所对应的虚拟码:
252         // Returns the integer keyCode associated with the key in this event
253         int key = e.getKeyCode();
254         // 判断不同的按键，指挥坦克的运动方向
255         switch (key) {
256         case KeyEvent.VK_LEFT:
257             bL = true;
258             break;
259         case KeyEvent.VK_UP:
260             bU = true;
261             break;
262         case KeyEvent.VK_RIGHT:
263             bR = true;
264             break;
265         case KeyEvent.VK_DOWN:
266             bD = true;
267             break;
268         }
269         locateDirection();
270     }
271 
272     public void keyReleased(KeyEvent e) {
273         int key = e.getKeyCode();
274         // 判断不同的按键，指挥坦克的运动方向
275         // 哪个键按下了，就把对应方向的布尔类型置为false
276         switch (key) {
277         // 为了防止一直按着Ctrl键的时候，炮弹太过于密集
278         // 因此我们定义在Ctrl键抬起的时候才发炮弹
279         // 这样炮弹不至于太过密集
280         case KeyEvent.VK_CONTROL:
281             fire();
282             break;
283         case KeyEvent.VK_LEFT:
284             bL = false;
285             break;
286         case KeyEvent.VK_UP:
287             bU = false;
288             break;
289         case KeyEvent.VK_RIGHT:
290             bR = false;
291             break;
292         case KeyEvent.VK_DOWN:
293             bD = false;
294             break;
295         }
296         // 重新定位一下
297         locateDirection();
298     }
299 
300     public Missile fire() {
301         if (!live) {
302             return null;
303         }
304         // 计算子弹的位置，使得子弹从坦克的中间发出来
305         int x = this.x + Tank.WIDTH / 2 - Missile.WIDTH / 2;
306         int y = this.y + Tank.HEIGHT / 2 - Missile.HEIGHT / 2;
307         // 这个时候我们就根据炮筒的方向来发炮弹了，之前是根据坦克的方向来发炮弹
308         Missile m = new Missile(x, y, good, ptDir, tc);
309         // 将新产生的炮弹放置到List容器中
310         tc.missiles.add(m);
311         return m;
312     }
313 
314     // 拿到包围坦克的那个方块
315     public Rectangle getRect() {
316 
317         return new Rectangle(x, y, WIDTH, HEIGHT);
318     }
319 
320     public boolean collidesWithWall(Wall w) {
321 
322         if (this.live && this.getRect().intersects(w.getRect())) {
323             this.dir = Direction.STOP;
324             // 当坦克撞到墙上的时候，停一下，再回到上一步的位置
325             this.stay();
326             return true;
327         }
328         return false;
329 
330     }
331 
332     // 坦克和坦克之间的碰撞检测
333     public boolean collidesWithTanks(java.util.List<Tank> tanks) {
334         for (int i = 0; i < tanks.size(); i++) {
335             Tank t = tanks.get(i);
336             if (this != t) {
337                 if (this.live && t.isLive()
338                         && this.getRect().intersects(t.getRect())) {
339                     this.stay();
340                     t.stay();
341                 }
342             }
343         }
344         return bD;
345 
346     }
347 }
View Code

Missile：

技术分享 
  1 import java.awt.Color;
  2 import java.awt.Graphics;
  3 import java.awt.Rectangle;
  4 import java.util.List;
  5 
  6 public class Missile {
  7     // 炮弹的移动速度，不要比坦克的移动速度慢，不然你看到的是满屏的坦克追着炮弹跑
  8     public static final int XSPEED = 10;
  9     public static final int YSPEED = 10;
 10     // 将子弹的高度和宽度设置为常量
 11     public static final int WIDTH = 10;
 12     public static final int HEIGHT = 10;
 13     // 炮弹自己的三个属性
 14     int x;
 15     int y;
 16     Tank.Direction dir;
 17 
 18     //同一阵营的的坦克发出的子弹不能伤害自己人
 19     private boolean good;
 20     // 定义一个布尔类型的变量来判断炮弹是否已经消亡
 21     private boolean live = true;
 22     //我们在Missile类中也持有一个TankClient的引用
 23     //在炮弹出界的时候就可以从装炮弹的missiles集合中去除该炮弹，不再对其重画
 24     private TankClient tc;
 25 
 26     public boolean isLive() {
 27         return live;
 28     }
 29 
 30     public Missile(int x, int y, Tank.Direction dir) {
 31         this.x = x;
 32         this.y = y;
 33         this.dir = dir;
 34     }
 35     public Missile(int x,int y,boolean good,Tank.Direction dir,TankClient tc){
 36         this(x, y, dir);
 37         this.good=good;
 38         this.tc=tc;
 39     }
 40 
 41     // 炮弹自己的draw方法
 42     public void draw(Graphics g) {
 43         //炮弹消亡就不需要再画出来了
 44         if(!live){
 45             tc.missiles.remove(this);
 46             return;
 47         }
 48         Color c = g.getColor();
 49         g.setColor(Color.BLACK);
 50         // 炮弹形状不要比坦克大,这里设置成10,10;
 51         g.fillOval(x, y, WIDTH, HEIGHT);
 52         g.setColor(c);
 53         move();
 54     }
 55 
 56     public void move() {
 57         switch (dir) {
 58         case L:
 59             x -= XSPEED;
 60             break;
 61         case R:
 62             x += XSPEED;
 63             break;
 64         case U:
 65             y -= YSPEED;
 66             break;
 67         case D:
 68             y += YSPEED;
 69             break;
 70         case LU:
 71             x -= XSPEED;
 72             y -= YSPEED;
 73             break;
 74         case LD:
 75             x -= XSPEED;
 76             y += YSPEED;
 77             break;
 78         case RU:
 79             x += XSPEED;
 80             y -= YSPEED;
 81             break;
 82         case RD:
 83             x += XSPEED;
 84             y += YSPEED;
 85             break;
 86         // 炮弹就没有STOP这个枚举类型的值了
 87         /*
 88          * case STOP: break;
 89          */
 90         }
 91         // 判断炮弹出边界则消亡
 92         // 注意x,y只有正数值，x向右递增，y向下递增
 93         if (x < 0 || y < 0 || x > TankClient.GAME_WIDTH
 94                 || y > TankClient.GAME_HEIGHT) {
 95             live = false;
 96         }
 97     }
 98     public boolean hitTank(Tank t){
 99         //炮弹的方框和坦克的方框碰在一起了并且坦克是存活着的,后面的判断我们是一伙的我就不打你了
100         if(this.live&&this.getRect().intersects(t.getRect())&&t.isLive()&&this.good!=t.isGood()){
101             t.setLive(false);
102             this.live=false;
103             
104             //炮弹击中坦克，发生爆炸
105             Explode e=new Explode(x, y, tc);
106             tc.explodes.add(e);
107             return true;
108         }
109         return false;
110     }
111     //碰撞检测类Rectangle
112     //拿到包围在炮弹周围的小方块
113     public Rectangle getRect(){
114         return new Rectangle(x,y,WIDTH,HEIGHT);
115     }
116     
117     //添加hitTanks方法
118     public boolean hitTanks(List<Tank> tanks){
119         for(int i=0;i<tanks.size();i++){
120             if(hitTank(tanks.get(i))){
121                 return true;
122             }
123         }
124         return false;
125         
126     }
127     public boolean hitWall(Wall w){
128         if(this.live&&this.getRect().intersects(w.getRect())){
129             this.live=false;
130             return true;
131         }
132         return false;
133     }
134 }
View Code

Explode：

技术分享 
 1 import java.awt.*;
 2 
 3 public class Explode {
 4     //爆炸的位置
 5     int x, y;
 6     //爆炸是否存在
 7     private boolean live = true;
 8     
 9     //持有一个Tankclient的引用
10     private TankClient tc ;
11     
12     //定义不同直径大小的爆炸
13     int[] diameter = {4, 7, 12, 18, 26, 32, 49, 30, 14, 6};
14     //爆炸发生到哪一个阶段了，对应相应大小的直径
15     int step = 0;
16     
17     public Explode(int x, int y, TankClient tc) {
18         this.x = x;
19         this.y = y;
20         this.tc = tc;
21     }
22     
23     public void draw(Graphics g) {
24         if(!live) {
25             //爆炸发生，将相应直径的爆炸圆从集合explodes中去除
26             tc.explodes.remove(this);
27             return;
28         }
29         
30         if(step == diameter.length) {
31             live = false;
32             step = 0;
33             return;
34         }
35         
36         Color c = g.getColor();
37         g.setColor(Color.ORANGE);
38         
39         //把不同的圆画出来
40         g.fillOval(x, y, diameter[step], diameter[step]);
41         g.setColor(c);
42         
43         step ++;
44     }
45 }
View Code

Wall：

技术分享 
 1 import java.awt.Graphics;
 2 import java.awt.Rectangle;
 3 
 4 //墙
 5 public class Wall {
 6     int x,y,w,h;
 7     TankClient tc;
 8     public Wall(int x, int y, int w, int h, TankClient tc) {
 9         super();
10         this.x = x;
11         this.y = y;
12         this.w = w;
13         this.h = h;
14         this.tc = tc;
15     }
16     public void draw(Graphics g){
17         g.fillRect(x, y, w, h);
18     }
19     //碰撞检测
20     public Rectangle getRect(){
21         return new Rectangle(x,y,w,h);
22     }
23 }
View Code

TankClient：

技术分享 
  1 import java.awt.*;
  2 import java.awt.event.*;
  3 import java.util.ArrayList;
  4 import java.util.List;
  5 
  6 public class TankClient extends Frame {
  7     // 设置成常量，方便以后的改动
  8     public static final int GAME_WIDTH = 800;
  9     public static final int GAME_HEIGHT = 600;
 10 
 11     // 将当前的TankClient对象传递给myTank;
 12     // 目的是方便我们在Tank这个类中访问m(炮弹对象)这个成员变量
 13     // 其实就是在Tank类中持有TankClient类对象的一个引用
 14 
 15     // 我们这里new我们自己的坦克
 16     Tank myTank = new Tank(50, 50, true, Tank.Direction.STOP, this);
 17 
 18     Wall w1=new Wall(100, 200,20, 150,this);
 19     Wall w2=new Wall(300, 100,300,20,this);
 20     /*
 21      * //新建敌方坦克,(不再需要这个了) Tank enemyTank=new Tank(100,100,false,this);
 22      */
 23     // 定义爆炸
 24     Explode e = new Explode(70, 70, this);
 25     // 定义一个集合，多个爆炸点
 26     List<Explode> explodes = new ArrayList<Explode>();
 27 
 28     // 使用容器装炮弹
 29     List<Missile> missiles = new ArrayList<Missile>();
 30 
 31     // 用容器来装敌人的Tank
 32     List<Tank> tanks = new ArrayList<Tank>();
 33     // 定义虚拟图片，方便后期的一次性显示
 34     Image offScreenImage = null;
 35 
 36     public void paint(Graphics g) {
 37         // 记录屏幕上的子弹数目
 38         g.drawString("missiles count:" + missiles.size(), 10, 50);
 39         // 添加上方标记栏，记录爆炸次数
 40         g.drawString("explodes count:" + explodes.size(), 10, 70);
 41         // 记录现在屏幕上一共有多少敌方坦克
 42         g.drawString("tanks count:" + tanks.size(), 10, 90);
 43 
 44         // 遍历结合，发出多发炮弹
 45         for (int i = 0; i < missiles.size(); i++) {
 46             Missile m = missiles.get(i);
 47             // 对于每一发炮弹，都可以将tanks集合中的敌方炮弹干掉
 48             m.hitTanks(tanks);
 49             m.hitTank(myTank);
 50             m.hitWall(w1);
 51             m.hitWall(w2);
 52             m.draw(g);
 53         }
 54 
 55         for (int i = 0; i < explodes.size(); i++) {
 56             Explode e = explodes.get(i);
 57             e.draw(g);
 58         }
 59 
 60         for (int i = 0; i < tanks.size(); i++) {
 61             Tank t = tanks.get(i);
 62             t.collidesWithWall(w1);
 63             t.collidesWithWall(w2);
 64             t.collidesWithTanks(tanks);
 65             t.draw(g);
 66         }
 67         // 不改变前景色
 68         myTank.draw(g);
 69         w1.draw(g);
 70         w2.draw(g);
 71     }
 72 
 73     // 刷新操作
 74     public void update(Graphics g) {
 75         if (offScreenImage == null) {
 76             offScreenImage = this.createImage(GAME_WIDTH, GAME_HEIGHT);
 77         }
 78         Graphics gOffScreen = offScreenImage.getGraphics();
 79         Color c = gOffScreen.getColor();
 80         gOffScreen.setColor(Color.GREEN);
 81         gOffScreen.fillRect(0, 0, GAME_WIDTH, GAME_HEIGHT);
 82         gOffScreen.setColor(c);
 83         paint(gOffScreen);
 84         g.drawImage(offScreenImage, 0, 0, null);
 85     }
 86 
 87     public void lauchFrame() {
 88 
 89         // 添加多辆坦克
 90         for (int i = 0; i < 10; i++) {
 91             tanks.add(new Tank(50 + 40 * (i + 1), 50, false, Tank.Direction.D,
 92                     this));
 93         }
 94         // this.setLocation(400, 300);
 95         this.setSize(GAME_WIDTH, GAME_HEIGHT);
 96         this.setTitle("TankWar");
 97         this.addWindowListener(new WindowAdapter() {
 98             public void windowClosing(WindowEvent e) {
 99                 System.exit(0);
100             }
101         });
102         this.setResizable(false);
103         this.setBackground(Color.GREEN);
104 
105         this.addKeyListener(new KeyMonitor());
106 
107         setVisible(true);
108 
109         new Thread(new PaintThread()).start();
110     }
111 
112     public static void main(String[] args) {
113         TankClient tc = new TankClient();
114         tc.lauchFrame();
115     }
116 
117     private class PaintThread implements Runnable {
118 
119         public void run() {
120             while (true) {
121                 repaint();
122                 try {
123                     // 为了爆炸效果，改成1000
124                     Thread.sleep(50);
125                 } catch (InterruptedException e) {
126                     e.printStackTrace();
127                 }
128             }
129         }
130     }
131 
132     // 创建键盘时间监听
133     private class KeyMonitor extends KeyAdapter {
134 
135         // 直接调用myTank自己的方法根据相应的按键信息进行移动
136         public void keyPressed(KeyEvent e) {
137             myTank.KeyPressed(e);
138             // 添加了处理键抬起的事件，可以控制坦克起步以后的状态
139             // 而不是一直按照一个方向走下去
140         }
141 
142         public void keyReleased(KeyEvent e) {
143             myTank.keyReleased(e);
144         }
145 
146     }
147 }
View Code

版本2.2

功能：超级炮弹
步骤：
        处理按键A

具体代码实现：只有Tank类发生了变化

Tank类 ：

技术分享 
  1 import java.awt.*;
  2 import java.awt.event.*;
  3 import java.util.Random;
  4 
  5 public class Tank {
  6     // 方便后期更改
  7     public static final int XSPEED = 5;
  8     public static final int YSPEED = 5;
  9     // 将坦克的高度和宽度设置为常量
 10     public static final int WIDTH = 30;
 11     public static final int HEIGHT = 30;
 12     TankClient tc;
 13     // 区别是我方坦克还是地方坦克，方便据此进行不同的设置
 14     private boolean good;
 15 
 16     public boolean isGood() {
 17         return good;
 18     }
 19 
 20     public void setGood(boolean good) {
 21         this.good = good;
 22     }
 23 
 24     // 判断坦克生死的变量
 25     private boolean live = true;
 26 
 27     public boolean isLive() {
 28         return live;
 29     }
 30 
 31     public void setLive(boolean live) {
 32         this.live = live;
 33     }
 34 
 35     private int x;
 36     private int y;
 37 
 38     // 记录坦克上一步的位置，防止坦克一碰到wall,就会依附在上面
 39     private int oldx;
 40     private int oldy;
 41 
 42     // 随机数产生器，方便敌方坦克可以任意移动
 43     private static Random r = new Random();
 44     // 添加记录按键状态的布尔量
 45     private boolean bL = false;
 46     private boolean bR = false;
 47     private boolean bU = false;
 48     private boolean bD = false;
 49 
 50     // 添加代表方向的量（使用枚举）
 51     enum Direction {
 52         L, R, U, D, LU, LD, RU, RD, STOP
 53     };
 54 
 55     private Direction dir = Direction.STOP;
 56 
 57     // 定义炮筒的方向，我们想办法将炮筒的方法调整成和坦克移动方向一致;
 58     // 我们这里会用一条直线来表示炮筒:模拟炮筒
 59     // 我们要根据炮筒的方向画直线表示炮筒
 60     Direction ptDir = Direction.D;
 61 
 62     // 为了让敌方坦克在一定方向运动移动时间再自动变换方向
 63     private int step = r.nextInt(12) + 3;
 64 
 65     // 更改构造函数
 66     public Tank(int x, int y, boolean good) {
 67         this.x = x;
 68         this.y = y;
 69         this.oldx = x;
 70         this.oldy = y;
 71         this.good = good;
 72     }
 73 
 74     // 这个位置的构造函数也相应进行了更改
 75     public Tank(int x, int y, boolean good, Direction dir, TankClient tc) {
 76         // 调用那个有两个参数的构造方法
 77         this(x, y, good);
 78         this.dir = dir;
 79         // 在这个位置初始化tc
 80         this.tc = tc;
 81     }
 82 
 83     // Tank对象的draw方法
 84     public void draw(Graphics g) {
 85         if (!live) {
 86             // 如果死亡的是敌方坦克，在tanks集合中去除该坦克
 87             if (!good) {
 88                 tc.tanks.remove(this);
 89             }
 90             // 如果是我方坦克，直接返回
 91             return;
 92         }
 93         Color c = g.getColor();
 94         if (good) {
 95             g.setColor(Color.RED);
 96         } else {
 97             g.setColor(Color.PINK);
 98         }
 99         g.fillOval(x, y, WIDTH, HEIGHT);
100         g.setColor(c);
101         // 根据炮筒的方向画直线来表示我们坦克的炮筒
102         switch (ptDir) {
103         case L:
104             // 画直线:四个参数分别代表：坦克中心点的坐标 直线的另一头的的坐标
105             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x, y
106                     + Tank.HEIGHT / 2);
107             break;
108         case R:
109             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x + Tank.WIDTH,
110                     y + Tank.HEIGHT / 2);
111 
112             break;
113         case U:
114             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x + Tank.WIDTH
115                     / 2, y);
116 
117             break;
118         case D:
119             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x + Tank.WIDTH
120                     / 2, y + Tank.HEIGHT);
121 
122             break;
123         case LU:
124             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x, y);
125             break;
126         case LD:
127             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x, y
128                     + Tank.HEIGHT);
129 
130             break;
131         case RU:
132             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x + Tank.WIDTH,
133                     y);
134 
135             break;
136         case RD:
137             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x + Tank.WIDTH,
138                     y + Tank.HEIGHT);
139 
140             break;
141         /*
142          * case STOP: break;
143          */
144         }
145         move();
146     }
147 
148     public void move() {
149         // 记录坦克上一步的位置
150         this.oldx = x;
151         this.oldy = y;
152         switch (dir) {
153         case L:
154             x -= XSPEED;
155             break;
156         case R:
157             x += XSPEED;
158             break;
159         case U:
160             y -= YSPEED;
161             break;
162         case D:
163             y += YSPEED;
164             break;
165         case LU:
166             x -= XSPEED;
167             y -= YSPEED;
168             break;
169         case LD:
170             x -= XSPEED;
171             y += YSPEED;
172             break;
173         case RU:
174             x += XSPEED;
175             y -= YSPEED;
176             break;
177         case RD:
178             x += XSPEED;
179             y += YSPEED;
180             break;
181 
182         case STOP:
183             break;
184         }
185         // 如果坦克不是停着的，则将炮筒调整至和坦克移动的方向相同
186         if (this.dir != Direction.STOP) {
187             this.ptDir = this.dir;
188         }
189         if (x < 0) {
190             x = 0;
191         }
192         // 因为我们的游戏界面有那个missileCount标签，所以在y轴方向不能用y是否<0进行判断
193         // 否则的话我们的坦克可以从上面出去
194         if (y < 50) {
195             y = 50;
196         }
197         if (x + Tank.WIDTH > TankClient.GAME_WIDTH) {
198             x = TankClient.GAME_WIDTH - Tank.WIDTH;
199         }
200         if (y + Tank.HEIGHT > TankClient.GAME_HEIGHT) {
201             y = TankClient.GAME_HEIGHT - Tank.HEIGHT;
202         }
203         // 在move方法中判断如果是敌方坦克
204         if (!good) {
205             Direction[] dirs = Direction.values();
206             // 定义敌方坦克的移动
207             if (step == 0) {
208                 step = r.nextInt(12) + 3;
209                 int rn = r.nextInt(dirs.length);
210                 dir = dirs[rn];
211             }
212             // 使得敌方坦克每隔一定时间就变化方向，values:方向枚举转化为数组
213 
214             step--;
215             // 用随机数，使得敌方坦克可以发炮弹，但是不要太猛烈
216             if (r.nextInt(40) > 38) {
217                 this.fire();
218             }
219         }
220     }
221 
222     public void locateDirection() {
223         if (bL && !bU && !bR && !bD)
224             dir = Direction.L;
225         else if (bL && bU && !bR && !bD)
226             dir = Direction.LU;
227         else if (!bL && bU && !bR && !bD)
228             dir = Direction.U;
229         else if (!bL && bU && bR && !bD)
230             dir = Direction.RU;
231         else if (!bL && !bU && bR && !bD)
232             dir = Direction.R;
233         else if (!bL && !bU && bR && bD)
234             dir = Direction.RD;
235         else if (!bL && !bU && !bR && bD)
236             dir = Direction.D;
237         else if (bL && !bU && !bR && bD)
238             dir = Direction.LD;
239         else if (!bL && !bU && !bR && !bD)
240             dir = Direction.STOP;
241 
242     }
243 
244     private void stay() {
245         x = oldx;
246         y = oldy;
247     }
248 
249     // 坦克自己向哪个方向移动，它自己最清楚;
250     public void KeyPressed(KeyEvent e) {
251         // 获得所按下的键所对应的虚拟码:
252         // Returns the integer keyCode associated with the key in this event
253         int key = e.getKeyCode();
254         // 判断不同的按键，指挥坦克的运动方向
255         switch (key) {
256         case KeyEvent.VK_LEFT:
257             bL = true;
258             break;
259         case KeyEvent.VK_UP:
260             bU = true;
261             break;
262         case KeyEvent.VK_RIGHT:
263             bR = true;
264             break;
265         case KeyEvent.VK_DOWN:
266             bD = true;
267             break;
268         }
269         locateDirection();
270     }
271 
272     public void keyReleased(KeyEvent e) {
273         int key = e.getKeyCode();
274         // 判断不同的按键，指挥坦克的运动方向
275         // 哪个键按下了，就把对应方向的布尔类型置为false
276         switch (key) {
277         // 为了防止一直按着Ctrl键的时候，炮弹太过于密集
278         // 因此我们定义在Ctrl键抬起的时候才发炮弹
279         // 这样炮弹不至于太过密集
280         case KeyEvent.VK_CONTROL:
281             fire();
282             break;
283         case KeyEvent.VK_LEFT:
284             bL = false;
285             break;
286         case KeyEvent.VK_UP:
287             bU = false;
288             break;
289         case KeyEvent.VK_RIGHT:
290             bR = false;
291             break;
292         case KeyEvent.VK_DOWN:
293             bD = false;
294             break;
295             
296         //当按键A被按下时，会发出超级炮弹superFire()
297         case KeyEvent.VK_A:
298             superFire();
299             break;
300         }
301         // 重新定位一下
302         locateDirection();
303     }
304 
305     public Missile fire() {
306         if (!live) {
307             return null;
308         }
309         // 计算子弹的位置，使得子弹从坦克的中间发出来
310         int x = this.x + Tank.WIDTH / 2 - Missile.WIDTH / 2;
311         int y = this.y + Tank.HEIGHT / 2 - Missile.HEIGHT / 2;
312         // 这个时候我们就根据炮筒的方向来发炮弹了，之前是根据坦克的方向来发炮弹
313         Missile m = new Missile(x, y, good, ptDir, tc);
314         // 将新产生的炮弹放置到List容器中
315         tc.missiles.add(m);
316         return m;
317     }
318     
319     public Missile fire(Direction dir){
320         if (!live) {
321             return null;
322         }
323         // 计算子弹的位置，使得子弹从坦克的中间发出来
324         int x = this.x + Tank.WIDTH / 2 - Missile.WIDTH / 2;
325         int y = this.y + Tank.HEIGHT / 2 - Missile.HEIGHT / 2;
326         // 这个时候我们就根据炮筒的方向来发炮弹了，之前是根据坦克的方向来发炮弹
327         Missile m = new Missile(x, y, good, ptDir, tc);
328         // 将新产生的炮弹放置到List容器中
329         tc.missiles.add(m);
330         return m;
331     }
332 
333     // 拿到包围坦克的那个方块
334     public Rectangle getRect() {
335 
336         return new Rectangle(x, y, WIDTH, HEIGHT);
337     }
338 
339     public boolean collidesWithWall(Wall w) {
340 
341         if (this.live && this.getRect().intersects(w.getRect())) {
342             this.dir = Direction.STOP;
343             // 当坦克撞到墙上的时候，停一下，再回到上一步的位置
344             this.stay();
345             return true;
346         }
347         return false;
348 
349     }
350 
351     // 坦克和坦克之间的碰撞检测
352     public boolean collidesWithTanks(java.util.List<Tank> tanks) {
353         for (int i = 0; i < tanks.size(); i++) {
354             Tank t = tanks.get(i);
355             if (this != t) {
356                 if (this.live && t.isLive()
357                         && this.getRect().intersects(t.getRect())) {
358                     this.stay();
359                     t.stay();
360                 }
361             }
362         }
363         return bD;
364     }
365     
366     //超级炮弹
367     private void superFire(){
368         Direction[] dirs=Direction.values();
369         for(int i=0;i<8;i++){
370             //朝八个方向各打一发
371             fire(dirs[i]);
372         }
373     }
374 }
View Code

版本2.3

功能：主战坦克的生命值(我们的坦克不能一炮就被打死吧，敌方坦克我们可以一炮打死)，代码的变化相较于上一个版本Wall类和Explode类没有变化
步骤：  

        1)加入life变量：在Tank类中private int life=100;并添加get和set方法
        2)在窗口显示生命值：TankClient的paint方法中：g.drawString("tanks life:" + myTank.getLife(), 10, 110);

Tank：

技术分享 
  1 import java.awt.*;
  2 import java.awt.event.*;
  3 import java.util.Random;
  4 
  5 public class Tank {
  6     // 方便后期更改
  7     public static final int XSPEED = 5;
  8     public static final int YSPEED = 5;
  9     // 将坦克的高度和宽度设置为常量
 10     public static final int WIDTH = 30;
 11     public static final int HEIGHT = 30;
 12     TankClient tc;
 13     // 区别是我方坦克还是地方坦克，方便据此进行不同的设置
 14     private boolean good;
 15     
 16     //坦克的生命值
 17     private int life=100;
 18 
 19     public int getLife() {
 20         return life;
 21     }
 22 
 23     public void setLife(int life) {
 24         this.life = life;
 25     }
 26 
 27     public boolean isGood() {
 28         return good;
 29     }
 30 
 31     public void setGood(boolean good) {
 32         this.good = good;
 33     }
 34 
 35     // 判断坦克生死的变量
 36     private boolean live = true;
 37 
 38     public boolean isLive() {
 39         return live;
 40     }
 41 
 42     public void setLive(boolean live) {
 43         this.live = live;
 44     }
 45 
 46     private int x;
 47     private int y;
 48 
 49     // 记录坦克上一步的位置，防止坦克一碰到wall,就会依附在上面
 50     private int oldx;
 51     private int oldy;
 52 
 53     // 随机数产生器，方便敌方坦克可以任意移动
 54     private static Random r = new Random();
 55     // 添加记录按键状态的布尔量
 56     private boolean bL = false;
 57     private boolean bR = false;
 58     private boolean bU = false;
 59     private boolean bD = false;
 60 
 61     // 添加代表方向的量（使用枚举）
 62     enum Direction {
 63         L, R, U, D, LU, LD, RU, RD, STOP
 64     };
 65 
 66     private Direction dir = Direction.STOP;
 67 
 68     // 定义炮筒的方向，我们想办法将炮筒的方法调整成和坦克移动方向一致;
 69     // 我们这里会用一条直线来表示炮筒:模拟炮筒
 70     // 我们要根据炮筒的方向画直线表示炮筒
 71     Direction ptDir = Direction.D;
 72 
 73     // 为了让敌方坦克在一定方向运动移动时间再自动变换方向
 74     private int step = r.nextInt(12) + 3;
 75 
 76     // 更改构造函数
 77     public Tank(int x, int y, boolean good) {
 78         this.x = x;
 79         this.y = y;
 80         this.oldx = x;
 81         this.oldy = y;
 82         this.good = good;
 83     }
 84 
 85     // 这个位置的构造函数也相应进行了更改
 86     public Tank(int x, int y, boolean good, Direction dir, TankClient tc) {
 87         // 调用那个有两个参数的构造方法
 88         this(x, y, good);
 89         this.dir = dir;
 90         // 在这个位置初始化tc
 91         this.tc = tc;
 92     }
 93 
 94     // Tank对象的draw方法
 95     public void draw(Graphics g) {
 96         if (!live) {
 97             // 如果死亡的是敌方坦克，在tanks集合中去除该坦克
 98             if (!good) {
 99                 tc.tanks.remove(this);
100             }
101             // 如果是我方坦克，直接返回
102             return;
103         }
104         Color c = g.getColor();
105         if (good) {
106             g.setColor(Color.RED);
107         } else {
108             g.setColor(Color.PINK);
109         }
110         g.fillOval(x, y, WIDTH, HEIGHT);
111         g.setColor(c);
112         // 根据炮筒的方向画直线来表示我们坦克的炮筒
113         switch (ptDir) {
114         case L:
115             // 画直线:四个参数分别代表：坦克中心点的坐标 直线的另一头的的坐标
116             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x, y
117                     + Tank.HEIGHT / 2);
118             break;
119         case R:
120             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x + Tank.WIDTH,
121                     y + Tank.HEIGHT / 2);
122 
123             break;
124         case U:
125             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x + Tank.WIDTH
126                     / 2, y);
127 
128             break;
129         case D:
130             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x + Tank.WIDTH
131                     / 2, y + Tank.HEIGHT);
132 
133             break;
134         case LU:
135             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x, y);
136             break;
137         case LD:
138             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x, y
139                     + Tank.HEIGHT);
140 
141             break;
142         case RU:
143             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x + Tank.WIDTH,
144                     y);
145 
146             break;
147         case RD:
148             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x + Tank.WIDTH,
149                     y + Tank.HEIGHT);
150 
151             break;
152         /*
153          * case STOP: break;
154          */
155         }
156         move();
157     }
158 
159     public void move() {
160         // 记录坦克上一步的位置
161         this.oldx = x;
162         this.oldy = y;
163         switch (dir) {
164         case L:
165             x -= XSPEED;
166             break;
167         case R:
168             x += XSPEED;
169             break;
170         case U:
171             y -= YSPEED;
172             break;
173         case D:
174             y += YSPEED;
175             break;
176         case LU:
177             x -= XSPEED;
178             y -= YSPEED;
179             break;
180         case LD:
181             x -= XSPEED;
182             y += YSPEED;
183             break;
184         case RU:
185             x += XSPEED;
186             y -= YSPEED;
187             break;
188         case RD:
189             x += XSPEED;
190             y += YSPEED;
191             break;
192 
193         case STOP:
194             break;
195         }
196         // 如果坦克不是停着的，则将炮筒调整至和坦克移动的方向相同
197         if (this.dir != Direction.STOP) {
198             this.ptDir = this.dir;
199         }
200         if (x < 0) {
201             x = 0;
202         }
203         // 因为我们的游戏界面有那个missileCount标签，所以在y轴方向不能用y是否<0进行判断
204         // 否则的话我们的坦克可以从上面出去
205         if (y < 50) {
206             y = 50;
207         }
208         if (x + Tank.WIDTH > TankClient.GAME_WIDTH) {
209             x = TankClient.GAME_WIDTH - Tank.WIDTH;
210         }
211         if (y + Tank.HEIGHT > TankClient.GAME_HEIGHT) {
212             y = TankClient.GAME_HEIGHT - Tank.HEIGHT;
213         }
214         // 在move方法中判断如果是敌方坦克
215         if (!good) {
216             Direction[] dirs = Direction.values();
217             // 定义敌方坦克的移动
218             if (step == 0) {
219                 step = r.nextInt(12) + 3;
220                 int rn = r.nextInt(dirs.length);
221                 dir = dirs[rn];
222             }
223             // 使得敌方坦克每隔一定时间就变化方向，values:方向枚举转化为数组
224 
225             step--;
226             // 用随机数，使得敌方坦克可以发炮弹，但是不要太猛烈
227             if (r.nextInt(40) > 38) {
228                 this.fire();
229             }
230         }
231     }
232 
233     public void locateDirection() {
234         if (bL && !bU && !bR && !bD)
235             dir = Direction.L;
236         else if (bL && bU && !bR && !bD)
237             dir = Direction.LU;
238         else if (!bL && bU && !bR && !bD)
239             dir = Direction.U;
240         else if (!bL && bU && bR && !bD)
241             dir = Direction.RU;
242         else if (!bL && !bU && bR && !bD)
243             dir = Direction.R;
244         else if (!bL && !bU && bR && bD)
245             dir = Direction.RD;
246         else if (!bL && !bU && !bR && bD)
247             dir = Direction.D;
248         else if (bL && !bU && !bR && bD)
249             dir = Direction.LD;
250         else if (!bL && !bU && !bR && !bD)
251             dir = Direction.STOP;
252 
253     }
254 
255     private void stay() {
256         x = oldx;
257         y = oldy;
258     }
259 
260     // 坦克自己向哪个方向移动，它自己最清楚;
261     public void KeyPressed(KeyEvent e) {
262         // 获得所按下的键所对应的虚拟码:
263         // Returns the integer keyCode associated with the key in this event
264         int key = e.getKeyCode();
265         // 判断不同的按键，指挥坦克的运动方向
266         switch (key) {
267         case KeyEvent.VK_LEFT:
268             bL = true;
269             break;
270         case KeyEvent.VK_UP:
271             bU = true;
272             break;
273         case KeyEvent.VK_RIGHT:
274             bR = true;
275             break;
276         case KeyEvent.VK_DOWN:
277             bD = true;
278             break;
279         }
280         locateDirection();
281     }
282 
283     public void keyReleased(KeyEvent e) {
284         int key = e.getKeyCode();
285         // 判断不同的按键，指挥坦克的运动方向
286         // 哪个键按下了，就把对应方向的布尔类型置为false
287         switch (key) {
288         // 为了防止一直按着Ctrl键的时候，炮弹太过于密集
289         // 因此我们定义在Ctrl键抬起的时候才发炮弹
290         // 这样炮弹不至于太过密集
291         case KeyEvent.VK_CONTROL:
292             fire();
293             break;
294         case KeyEvent.VK_LEFT:
295             bL = false;
296             break;
297         case KeyEvent.VK_UP:
298             bU = false;
299             break;
300         case KeyEvent.VK_RIGHT:
301             bR = false;
302             break;
303         case KeyEvent.VK_DOWN:
304             bD = false;
305             break;
306             
307         //当按键A被按下时，会发出超级炮弹superFire()
308         case KeyEvent.VK_A:
309             superFire();
310             break;
311         }
312         // 重新定位一下
313         locateDirection();
314     }
315 
316     public Missile fire() {
317         if (!live) {
318             return null;
319         }
320         // 计算子弹的位置，使得子弹从坦克的中间发出来
321         int x = this.x + Tank.WIDTH / 2 - Missile.WIDTH / 2;
322         int y = this.y + Tank.HEIGHT / 2 - Missile.HEIGHT / 2;
323         // 这个时候我们就根据炮筒的方向来发炮弹了，之前是根据坦克的方向来发炮弹
324         Missile m = new Missile(x, y, good, ptDir, tc);
325         // 将新产生的炮弹放置到List容器中
326         tc.missiles.add(m);
327         return m;
328     }
329     
330     public Missile fire(Direction dir){
331         if (!live) {
332             return null;
333         }
334         // 计算子弹的位置，使得子弹从坦克的中间发出来
335         int x = this.x + Tank.WIDTH / 2 - Missile.WIDTH / 2;
336         int y = this.y + Tank.HEIGHT / 2 - Missile.HEIGHT / 2;
337         // 这个时候我们就根据炮筒的方向来发炮弹了，之前是根据坦克的方向来发炮弹
338         Missile m = new Missile(x, y, good, ptDir, tc);
339         // 将新产生的炮弹放置到List容器中
340         tc.missiles.add(m);
341         return m;
342     }
343 
344     // 拿到包围坦克的那个方块
345     public Rectangle getRect() {
346 
347         return new Rectangle(x, y, WIDTH, HEIGHT);
348     }
349 
350     public boolean collidesWithWall(Wall w) {
351 
352         if (this.live && this.getRect().intersects(w.getRect())) {
353             this.dir = Direction.STOP;
354             // 当坦克撞到墙上的时候，停一下，再回到上一步的位置
355             this.stay();
356             return true;
357         }
358         return false;
359 
360     }
361 
362     // 坦克和坦克之间的碰撞检测
363     public boolean collidesWithTanks(java.util.List<Tank> tanks) {
364         for (int i = 0; i < tanks.size(); i++) {
365             Tank t = tanks.get(i);
366             if (this != t) {
367                 if (this.live && t.isLive()
368                         && this.getRect().intersects(t.getRect())) {
369                     this.stay();
370                     t.stay();
371                 }
372             }
373         }
374         return bD;
375     }
376     
377     //超级炮弹
378     private void superFire(){
379         Direction[] dirs=Direction.values();
380         for(int i=0;i<8;i++){
381             //朝八个方向各打一发
382             fire(dirs[i]);
383         }
384     }
385 }
View Code

Missile：

技术分享 
  1 import java.awt.Color;
  2 import java.awt.Graphics;
  3 import java.awt.Rectangle;
  4 import java.util.List;
  5 
  6 public class Missile {
  7     // 炮弹的移动速度，不要比坦克的移动速度慢，不然你看到的是满屏的坦克追着炮弹跑
  8     public static final int XSPEED = 10;
  9     public static final int YSPEED = 10;
 10     // 将子弹的高度和宽度设置为常量
 11     public static final int WIDTH = 10;
 12     public static final int HEIGHT = 10;
 13     // 炮弹自己的三个属性
 14     int x;
 15     int y;
 16     Tank.Direction dir;
 17 
 18     //同一阵营的的坦克发出的子弹不能伤害自己人
 19     private boolean good;
 20     // 定义一个布尔类型的变量来判断炮弹是否已经消亡
 21     private boolean live = true;
 22     //我们在Missile类中也持有一个TankClient的引用
 23     //在炮弹出界的时候就可以从装炮弹的missiles集合中去除该炮弹，不再对其重画
 24     private TankClient tc;
 25 
 26     public boolean isLive() {
 27         return live;
 28     }
 29 
 30     public Missile(int x, int y, Tank.Direction dir) {
 31         this.x = x;
 32         this.y = y;
 33         this.dir = dir;
 34     }
 35     public Missile(int x,int y,boolean good,Tank.Direction dir,TankClient tc){
 36         this(x, y, dir);
 37         this.good=good;
 38         this.tc=tc;
 39     }
 40 
 41     // 炮弹自己的draw方法
 42     public void draw(Graphics g) {
 43         //炮弹消亡就不需要再画出来了
 44         if(!live){
 45             tc.missiles.remove(this);
 46             return;
 47         }
 48         Color c = g.getColor();
 49         g.setColor(Color.BLACK);
 50         // 炮弹形状不要比坦克大,这里设置成10,10;
 51         g.fillOval(x, y, WIDTH, HEIGHT);
 52         g.setColor(c);
 53         move();
 54     }
 55 
 56     public void move() {
 57         switch (dir) {
 58         case L:
 59             x -= XSPEED;
 60             break;
 61         case R:
 62             x += XSPEED;
 63             break;
 64         case U:
 65             y -= YSPEED;
 66             break;
 67         case D:
 68             y += YSPEED;
 69             break;
 70         case LU:
 71             x -= XSPEED;
 72             y -= YSPEED;
 73             break;
 74         case LD:
 75             x -= XSPEED;
 76             y += YSPEED;
 77             break;
 78         case RU:
 79             x += XSPEED;
 80             y -= YSPEED;
 81             break;
 82         case RD:
 83             x += XSPEED;
 84             y += YSPEED;
 85             break;
 86         // 炮弹就没有STOP这个枚举类型的值了
 87         /*
 88          * case STOP: break;
 89          */
 90         }
 91         // 判断炮弹出边界则消亡
 92         // 注意x,y只有正数值，x向右递增，y向下递增
 93         if (x < 0 || y < 0 || x > TankClient.GAME_WIDTH
 94                 || y > TankClient.GAME_HEIGHT) {
 95             live = false;
 96         }
 97     }
 98     public boolean hitTank(Tank t){
 99         //炮弹的方框和坦克的方框碰在一起了并且坦克是存活着的,后面的判断我们是一伙的我就不打你了
100         if(this.live&&this.getRect().intersects(t.getRect())&&t.isLive()&&this.good!=t.isGood()){
101             if(t.isGood()){
102                 t.setLife(t.getLife()-20);
103                 if(t.getLife()<=0){
104                     t.setLive(false);
105                 }
106             }else {
107                 t.setLive(false);
108             }
109             this.live=false;
110             
111             //炮弹击中坦克，发生爆炸
112             Explode e=new Explode(x, y, tc);
113             tc.explodes.add(e);
114             return true;
115         }
116         return false;
117     }
118     //碰撞检测类Rectangle
119     //拿到包围在炮弹周围的小方块
120     public Rectangle getRect(){
121         return new Rectangle(x,y,WIDTH,HEIGHT);
122     }
123     
124     //添加hitTanks方法
125     public boolean hitTanks(List<Tank> tanks){
126         for(int i=0;i<tanks.size();i++){
127             if(hitTank(tanks.get(i))){
128                 return true;
129             }
130         }
131         return false;
132         
133     }
134     public boolean hitWall(Wall w){
135         if(this.live&&this.getRect().intersects(w.getRect())){
136             this.live=false;
137             return true;
138         }
139         return false;
140     }
141 }
View Code

TankClient：

技术分享 
  1 import java.awt.*;
  2 import java.awt.event.*;
  3 import java.util.ArrayList;
  4 import java.util.List;
  5 
  6 public class TankClient extends Frame {
  7     // 设置成常量，方便以后的改动
  8     public static final int GAME_WIDTH = 800;
  9     public static final int GAME_HEIGHT = 600;
 10 
 11     // 将当前的TankClient对象传递给myTank;
 12     // 目的是方便我们在Tank这个类中访问m(炮弹对象)这个成员变量
 13     // 其实就是在Tank类中持有TankClient类对象的一个引用
 14 
 15     // 我们这里new我们自己的坦克
 16     Tank myTank = new Tank(50, 50, true, Tank.Direction.STOP, this);
 17 
 18     Wall w1=new Wall(100, 200,20, 150,this);
 19     Wall w2=new Wall(300, 100,300,20,this);
 20     /*
 21      * //新建敌方坦克,(不再需要这个了) Tank enemyTank=new Tank(100,100,false,this);
 22      */
 23     // 定义爆炸
 24     Explode e = new Explode(70, 70, this);
 25     // 定义一个集合，多个爆炸点
 26     List<Explode> explodes = new ArrayList<Explode>();
 27 
 28     // 使用容器装炮弹
 29     List<Missile> missiles = new ArrayList<Missile>();
 30 
 31     // 用容器来装敌人的Tank
 32     List<Tank> tanks = new ArrayList<Tank>();
 33     // 定义虚拟图片，方便后期的一次性显示
 34     Image offScreenImage = null;
 35 
 36     public void paint(Graphics g) {
 37         // 记录屏幕上的子弹数目
 38         g.drawString("missiles count:" + missiles.size(), 10, 50);
 39         // 添加上方标记栏，记录爆炸次数
 40         g.drawString("explodes count:" + explodes.size(), 10, 70);
 41         // 记录现在屏幕上一共有多少敌方坦克
 42         g.drawString("tanks count:" + tanks.size(), 10, 90);
 43         //我们坦克的生命值
 44         g.drawString("tanks life:" + myTank.getLife(), 10, 110);
 45 
 46         // 遍历结合，发出多发炮弹
 47         for (int i = 0; i < missiles.size(); i++) {
 48             Missile m = missiles.get(i);
 49             // 对于每一发炮弹，都可以将tanks集合中的敌方炮弹干掉
 50             m.hitTanks(tanks);
 51             m.hitTank(myTank);
 52             m.hitWall(w1);
 53             m.hitWall(w2);
 54             m.draw(g);
 55         }
 56 
 57         for (int i = 0; i < explodes.size(); i++) {
 58             Explode e = explodes.get(i);
 59             e.draw(g);
 60         }
 61 
 62         for (int i = 0; i < tanks.size(); i++) {
 63             Tank t = tanks.get(i);
 64             t.collidesWithWall(w1);
 65             t.collidesWithWall(w2);
 66             t.collidesWithTanks(tanks);
 67             t.draw(g);
 68         }
 69         // 不改变前景色
 70         myTank.draw(g);
 71         w1.draw(g);
 72         w2.draw(g);
 73     }
 74 
 75     // 刷新操作
 76     public void update(Graphics g) {
 77         if (offScreenImage == null) {
 78             offScreenImage = this.createImage(GAME_WIDTH, GAME_HEIGHT);
 79         }
 80         Graphics gOffScreen = offScreenImage.getGraphics();
 81         Color c = gOffScreen.getColor();
 82         gOffScreen.setColor(Color.GREEN);
 83         gOffScreen.fillRect(0, 0, GAME_WIDTH, GAME_HEIGHT);
 84         gOffScreen.setColor(c);
 85         paint(gOffScreen);
 86         g.drawImage(offScreenImage, 0, 0, null);
 87     }
 88 
 89     public void lauchFrame() {
 90 
 91         // 添加多辆坦克
 92         for (int i = 0; i < 10; i++) {
 93             tanks.add(new Tank(50 + 40 * (i + 1), 50, false, Tank.Direction.D,
 94                     this));
 95         }
 96         // this.setLocation(400, 300);
 97         this.setSize(GAME_WIDTH, GAME_HEIGHT);
 98         this.setTitle("TankWar");
 99         this.addWindowListener(new WindowAdapter() {
100             public void windowClosing(WindowEvent e) {
101                 System.exit(0);
102             }
103         });
104         this.setResizable(false);
105         this.setBackground(Color.GREEN);
106 
107         this.addKeyListener(new KeyMonitor());
108 
109         setVisible(true);
110 
111         new Thread(new PaintThread()).start();
112     }
113 
114     public static void main(String[] args) {
115         TankClient tc = new TankClient();
116         tc.lauchFrame();
117     }
118 
119     private class PaintThread implements Runnable {
120 
121         public void run() {
122             while (true) {
123                 repaint();
124                 try {
125                     // 为了爆炸效果，改成1000
126                     Thread.sleep(50);
127                 } catch (InterruptedException e) {
128                     e.printStackTrace();
129                 }
130             }
131         }
132     }
133 
134     // 创建键盘时间监听
135     private class KeyMonitor extends KeyAdapter {
136 
137         // 直接调用myTank自己的方法根据相应的按键信息进行移动
138         public void keyPressed(KeyEvent e) {
139             myTank.KeyPressed(e);
140             // 添加了处理键抬起的事件，可以控制坦克起步以后的状态
141             // 而不是一直按照一个方向走下去
142         }
143 
144         public void keyReleased(KeyEvent e) {
145             myTank.keyReleased(e);
146         }
147 
148     }
149 }
View Code

版本2.4

功能：图形化表示主战坦克的生命值
步骤：
        根据不同的life值进行的不同的显示：在Tank类中我们添加一个内部类BloodBar(血条)，编写一个函数

 

 1 private class BloodBar{
 2         public void draw(Graphics g){
 3             Color c=g.getColor();
 4             g.setColor(Color.RED);
 5             //空心方块
 6             g.drawRect(x, y-10, WIDTH, 10);
 7             
 8             //根据我方坦克的生命值来画代表血量的实体快的大小
 9             int w=WIDTH*life/100;
10             
11             g.fillRect(x, y-10, w,10);
12             g.setColor(c);
13         }
14     }

具体代码实现：只有Tank类中的代码发生了变化

技术分享 
  1 import java.awt.*;
  2 import java.awt.event.*;
  3 import java.util.Random;
  4 
  5 public class Tank {
  6     // 方便后期更改
  7     public static final int XSPEED = 5;
  8     public static final int YSPEED = 5;
  9     // 将坦克的高度和宽度设置为常量
 10     public static final int WIDTH = 30;
 11     public static final int HEIGHT = 30;
 12     TankClient tc;
 13     // 区别是我方坦克还是地方坦克，方便据此进行不同的设置
 14     private boolean good;
 15     
 16     private BloodBar bb=new BloodBar();
 17     //坦克的生命值
 18     private int life=100;
 19 
 20     public int getLife() {
 21         return life;
 22     }
 23 
 24     public void setLife(int life) {
 25         this.life = life;
 26     }
 27 
 28     public boolean isGood() {
 29         return good;
 30     }
 31 
 32     public void setGood(boolean good) {
 33         this.good = good;
 34     }
 35 
 36     // 判断坦克生死的变量
 37     private boolean live = true;
 38 
 39     public boolean isLive() {
 40         return live;
 41     }
 42 
 43     public void setLive(boolean live) {
 44         this.live = live;
 45     }
 46 
 47     private int x;
 48     private int y;
 49 
 50     // 记录坦克上一步的位置，防止坦克一碰到wall,就会依附在上面
 51     private int oldx;
 52     private int oldy;
 53 
 54     // 随机数产生器，方便敌方坦克可以任意移动
 55     private static Random r = new Random();
 56     // 添加记录按键状态的布尔量
 57     private boolean bL = false;
 58     private boolean bR = false;
 59     private boolean bU = false;
 60     private boolean bD = false;
 61 
 62     // 添加代表方向的量（使用枚举）
 63     enum Direction {
 64         L, R, U, D, LU, LD, RU, RD, STOP
 65     };
 66 
 67     private Direction dir = Direction.STOP;
 68 
 69     // 定义炮筒的方向，我们想办法将炮筒的方法调整成和坦克移动方向一致;
 70     // 我们这里会用一条直线来表示炮筒:模拟炮筒
 71     // 我们要根据炮筒的方向画直线表示炮筒
 72     Direction ptDir = Direction.D;
 73 
 74     // 为了让敌方坦克在一定方向运动移动时间再自动变换方向
 75     private int step = r.nextInt(12) + 3;
 76 
 77     // 更改构造函数
 78     public Tank(int x, int y, boolean good) {
 79         this.x = x;
 80         this.y = y;
 81         this.oldx = x;
 82         this.oldy = y;
 83         this.good = good;
 84     }
 85 
 86     // 这个位置的构造函数也相应进行了更改
 87     public Tank(int x, int y, boolean good, Direction dir, TankClient tc) {
 88         // 调用那个有两个参数的构造方法
 89         this(x, y, good);
 90         this.dir = dir;
 91         // 在这个位置初始化tc
 92         this.tc = tc;
 93     }
 94 
 95     // Tank对象的draw方法
 96     public void draw(Graphics g) {
 97         if (!live) {
 98             // 如果死亡的是敌方坦克，在tanks集合中去除该坦克
 99             if (!good) {
100                 tc.tanks.remove(this);
101             }
102             // 如果是我方坦克，直接返回
103             return;
104         }
105         Color c = g.getColor();
106         if (good) {
107             g.setColor(Color.YELLOW);
108         } else {
109             g.setColor(Color.PINK);
110         }
111         g.fillOval(x, y, WIDTH, HEIGHT);
112         g.setColor(c);
113         //判断一下，我方坦克才有血条显示
114         if(good){
115             
116             bb.draw(g);
117         }
118         // 根据炮筒的方向画直线来表示我们坦克的炮筒
119         switch (ptDir) {
120         case L:
121             // 画直线:四个参数分别代表：坦克中心点的坐标 直线的另一头的的坐标
122             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x, y
123                     + Tank.HEIGHT / 2);
124             break;
125         case R:
126             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x + Tank.WIDTH,
127                     y + Tank.HEIGHT / 2);
128 
129             break;
130         case U:
131             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x + Tank.WIDTH
132                     / 2, y);
133 
134             break;
135         case D:
136             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x + Tank.WIDTH
137                     / 2, y + Tank.HEIGHT);
138 
139             break;
140         case LU:
141             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x, y);
142             break;
143         case LD:
144             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x, y
145                     + Tank.HEIGHT);
146 
147             break;
148         case RU:
149             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x + Tank.WIDTH,
150                     y);
151 
152             break;
153         case RD:
154             g.drawLine(x + Tank.WIDTH / 2, y + Tank.HEIGHT / 2, x + Tank.WIDTH,
155                     y + Tank.HEIGHT);
156 
157             break;
158         /*
159          * case STOP: break;
160          */
161         }
162         move();
163     }
164 
165     public void move() {
166         // 记录坦克上一步的位置
167         this.oldx = x;
168         this.oldy = y;
169         switch (dir) {
170         case L:
171             x -= XSPEED;
172             break;
173         case R:
174             x += XSPEED;
175             break;
176         case U:
177             y -= YSPEED;
178             break;
179         case D:
180             y += YSPEED;
181             break;
182         case LU:
183             x -= XSPEED;
184             y -= YSPEED;
185             break;
186         case LD:
187             x -= XSPEED;
188             y += YSPEED;
189             break;
190         case RU:
191             x += XSPEED;
192             y -= YSPEED;
193             break;
194         case RD:
195             x += XSPEED;
196             y += YSPEED;
197             break;
198 
199         case STOP:
200             break;
201         }
202         // 如果坦克不是停着的，则将炮筒调整至和坦克移动的方向相同
203         if (this.dir != Direction.STOP) {
204             this.ptDir = this.dir;
205         }
206         if (x < 0) {
207             x = 0;
208         }
209         // 因为我们的游戏界面有那个missileCount标签，所以在y轴方向不能用y是否<0进行判断
210         // 否则的话我们的坦克可以从上面出去
211         if (y < 50) {
212             y = 50;
213         }
214         if (x + Tank.WIDTH > TankClient.GAME_WIDTH) {
215             x = TankClient.GAME_WIDTH - Tank.WIDTH;
216         }
217         if (y + Tank.HEIGHT > TankClient.GAME_HEIGHT) {
218             y = TankClient.GAME_HEIGHT - Tank.HEIGHT;
219         }
220         // 在move方法中判断如果是敌方坦克
221         if (!good) {
222             Direction[] dirs = Direction.values();
223             // 定义敌方坦克的移动
224             if (step == 0) {
225                 step = r.nextInt(12) + 3;
226                 int rn = r.nextInt(dirs.length);
227                 dir = dirs[rn];
228             }
229             // 使得敌方坦克每隔一定时间就变化方向，values:方向枚举转化为数组
230 
231             step--;
232             // 用随机数，使得敌方坦克可以发炮弹，但是不要太猛烈
233             if (r.nextInt(40) > 38) {
234                 this.fire();
235             }
236         }
237     }
238 
239     public void locateDirection() {
240         if (bL && !bU && !bR && !bD)
241             dir = Direction.L;
242         else if (bL && bU && !bR && !bD)
243             dir = Direction.LU;
244         else if (!bL && bU && !bR && !bD)
245             dir = Direction.U;
246         else if (!bL && bU && bR && !bD)
247             dir = Direction.RU;
248         else if (!bL && !bU && bR && !bD)
249             dir = Direction.R;
250         else if (!bL && !bU && bR && bD)
251             dir = Direction.RD;
252         else if (!bL && !bU && !bR && bD)
253             dir = Direction.D;
254         else if (bL && !bU && !bR && bD)
255             dir = Direction.LD;
256         else if (!bL && !bU && !bR && !bD)
257             dir = Direction.STOP;
258 
259     }
260 
261     private void stay() {
262         x = oldx;
263         y = oldy;
264     }
265 
266     // 坦克自己向哪个方向移动，它自己最清楚;
267     public void KeyPressed(KeyEvent e) {
268         // 获得所按下的键所对应的虚拟码:
269         // Returns the integer keyCode associated with the key in this event
270         int key = e.getKeyCode();
271         // 判断不同的按键，指挥坦克的运动方向
272         switch (key) {
273         case KeyEvent.VK_LEFT:
274             bL = true;
275             break;
276         case KeyEvent.VK_UP:
277             bU = true;
278             break;
279         case KeyEvent.VK_RIGHT:
280             bR = true;
281             break;
282         case KeyEvent.VK_DOWN:
283             bD = true;
284             break;
285         }
286         locateDirection();
287     }
288 
289     public void keyReleased(KeyEvent e) {
290         int key = e.getKeyCode();
291         // 判断不同的按键，指挥坦克的运动方向
292         // 哪个键按下了，就把对应方向的布尔类型置为false
293         switch (key) {
294         // 为了防止一直按着Ctrl键的时候，炮弹太过于密集
295         // 因此我们定义在Ctrl键抬起的时候才发炮弹
296         // 这样炮弹不至于太过密集
297         case KeyEvent.VK_CONTROL:
298             fire();
299             break;
300         case KeyEvent.VK_LEFT:
301             bL = false;
302             break;
303         case KeyEvent.VK_UP:
304             bU = false;
305             break;
306         case KeyEvent.VK_RIGHT:
307             bR = false;
308             break;
309         case KeyEvent.VK_DOWN:
310             bD = false;
311             break;
312             
313         //当按键A被按下时，会发出超级炮弹superFire()
314         case KeyEvent.VK_A:
315             superFire();
316             break;
317         }
318         // 重新定位一下
319         locateDirection();
320     }
321 
322     public Missile fire() {
323         if (!live) {
324             return null;
325         }
326         // 计算子弹的位置，使得子弹从坦克的中间发出来
327         int x = this.x + Tank.WIDTH / 2 - Missile.WIDTH / 2;
328         int y = this.y + Tank.HEIGHT / 2 - Missile.HEIGHT / 2;
329         // 这个时候我们就根据炮筒的方向来发炮弹了，之前是根据坦克的方向来发炮弹
330         Missile m = new Missile(x, y, good, ptDir, tc);
331         // 将新产生的炮弹放置到List容器中
332         tc.missiles.add(m);
333         return m;
334     }
335     
336     public Missile fire(Direction dir){
337         if (!live) {
338             return null;
339         }
340         // 计算子弹的位置，使得子弹从坦克的中间发出来
341         int x = this.x + Tank.WIDTH / 2 - Missile.WIDTH / 2;
342         int y = this.y + Tank.HEIGHT / 2 - Missile.HEIGHT / 2;
343         // 这个时候我们就根据炮筒的方向来发炮弹了，之前是根据坦克的方向来发炮弹
344         Missile m = new Missile(x, y, good, ptDir, tc);
345         // 将新产生的炮弹放置到List容器中
346         tc.missiles.add(m);
347         return m;
348     }
349 
350     // 拿到包围坦克的那个方块
351     public Rectangle getRect() {
352 
353         return new Rectangle(x, y, WIDTH, HEIGHT);
354     }
355 
356     public boolean collidesWithWall(Wall w) {
357 
358         if (this.live && this.getRect().intersects(w.getRect())) {
359             this.dir = Direction.STOP;
360             // 当坦克撞到墙上的时候，停一下，再回到上一步的位置
361             this.stay();
362             return true;
363         }
364         return false;
365 
366     }
367 
368     // 坦克和坦克之间的碰撞检测
369     public boolean collidesWithTanks(java.util.List<Tank> tanks) {
370         for (int i = 0; i < tanks.size(); i++) {
371             Tank t = tanks.get(i);
372             if (this != t) {
373                 if (this.live && t.isLive()
374                         && this.getRect().intersects(t.getRect())) {
375                     this.stay();
376                     t.stay();
377                 }
378             }
379         }
380         return bD;
381     }
382     
383     //超级炮弹
384     private void superFire(){
385         Direction[] dirs=Direction.values();
386         for(int i=0;i<8;i++){
387             //朝八个方向各打一发
388             fire(dirs[i]);
389         }
390     }
391     //内部类定义坦克的图形化血量显示
392     private class BloodBar{
393         public void draw(Graphics g){
394             Color c=g.getColor();
395             g.setColor(Color.RED);
396             //空心方块
397             g.drawRect(x, y-10, WIDTH, 10);
398             
399             //根据我方坦克的生命值来画代表血量的实体快的大小
400             int w=WIDTH*life/100;
401             
402             g.fillRect(x, y-10, w,10);
403             g.setColor(c);
404         }
405     }
406 }
View Code

未完待续。。。。。。

 

坦克大战(版本1.7-版本2.4)

标签：

原文地址：http://www.cnblogs.com/ysw-go/p/5526783.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！