day03-2-应用线程02

JavaGUI-坦克大战03-2

7.线程的应用02

7.3.坦克大战4.0版

坦克大战4.0版
增加功能：
功能1.让敌人的坦克也能够发射子弹（可以有多个子弹）
功能2.当我方坦克集中敌人坦克时，敌人的坦克就消失，如果能做出爆炸的效果更好
功能3.让敌人的坦克也可以自由随机地上下左右移动
功能4.控制我方坦克和敌人坦克在规定的范围内移动
7.3.1功能1:敌方发射子弹

功能1思路：

• 在敌人坦克类使用Vector保存多个Shot
  
• 当每创建一个敌人坦克时，就给该敌人坦克初始化一个Shot对象，同时启动Shot线程
  
• 在绘制敌人坦克时，需要遍历敌人坦克对象Vector，绘制所有的子弹，当子弹isLive==false时，就从Vector移除
  

EnemyTank:

1. package li.TankGame.version04;
4. import java.util.Vector;
6. public class EnemyTank extends Tank {
8.     //在敌人坦克类使用Vector保存多个Shot
9.     Vector<Shot> shots = new Vector<>();
11.     public EnemyTank(int x, int y) {
12.         super(x, y);
13.     }
15. }

复制代码

MyPanel：在创建敌人坦克的时候，每初始化一个敌人坦克，就创建并初始化一个shot对象，将该shot对象加入到shots集合中，然后启动这个shot对象线程

1. package li.TankGame.version04;
3. import javax.swing.*;
4. import java.awt.*;
5. import java.awt.event.KeyEvent;
6. import java.awt.event.KeyListener;
7. import java.util.Vector;
9. /**
10. * @author 李
11. * @version 4.0
12. * 坦克大战的绘图区域
13. */
14. //为了监听键盘事件，要实现 KeyListener
16. //为了让Panel不停地重绘子弹，需要将MyPanel实现Runnable，
17. // 当做一个线程使用（因为需要不停地重绘子弹的图案）
18. public class MyPanel extends JPanel implements KeyListener, Runnable {
19.     //定义我的坦克
20.     Hero hero = null;
22.     //定义敌方坦克，放入到Vector集合中
23.     Vector<EnemyTank> enemyTanks = new Vector<>();
24.     int enemyTankNum = 3;//初始化坦克数量
26.     public MyPanel() {
27.         hero = new Hero(100, 100);//初始化自己的坦克
28.         //hero.setSpeed(5); //改变坦克的速度
30.         //初始化敌人的坦克
31.         for (int i = 0; i < enemyTankNum; i++) {
32.             //创建一个敌人的坦克
33.             EnemyTank enemyTank = new EnemyTank(100 * (i + 1), 0);
34.             //初始化敌人坦克方向向下
35.             enemyTank.setDirect(2);
36.             //给该enemyTank加入一颗子弹
37.             Shot shot = new Shot(enemyTank.getX() + 20, enemyTank.getY() + 60, enemyTank.getDirect());
38.             //将该子弹加入到enemyTank的Vector集合中
39.             enemyTank.shots.add(shot);
40.             //启动 shot对象
41.             new Thread(shot).start();
42.             //将设置好的的敌人坦克放入到集合中
43.             enemyTanks.add(enemyTank);
44.         }
45.     }
47.     @Override
48.     public void paint(Graphics g) {
49.         super.paint(g);
50.         g.fillRect(0, 0, 700, 550);//填充矩形，默认为黑色
52.         //画出自己的坦克-封装方法
53.         drawTank(hero.getX(), hero.getY(), g, hero.getDirect(), 1);
55.         //画出hero发射的子弹
56.         //如果子弹对象不为空，并且处于存活状态（即没有超出边界）
57.         if (hero.shot != null && hero.shot.isLive) {
58.             System.out.println("hero的子弹被绘制");
59.             g.draw3DRect(hero.shot.x, hero.shot.y, 2, 2, false);
60.         }
62.         //画出敌人的坦克,遍历Vector
63.         for (int i = 0; i < enemyTanks.size(); i++) {
64.             //取出敌人的坦克
65.             EnemyTank enemyTank = enemyTanks.get(i);
66.             drawTank(enemyTank.getX(), enemyTank.getY(), g, enemyTank.getDirect(), 0);
67.             //画出enemyTank所有子弹
68.             for (int j = 0; j < enemyTank.shots.size(); j++) {
69.                 //enemyTank.shots.size()是当前的enemy对象的shots集合的大小
70.                 //取出子弹
71.                 Shot shot = enemyTank.shots.get(j);
72.                 //绘制子弹
73.                 if (shot.isLive) {//shot.isLive==true
74.                     g.draw3DRect(shot.x, shot.y, 2, 2, false);
75.                 }else{
76.                     //从Vector移除子弹shot对象
77.                     enemyTank.shots.remove(shot);
78.                 }
79.             }
80.         }
81.     }
83.     /**
84.      * 编写方法，画出坦克
85.      *
86.      * @param x      坦克的左上角横坐标
87.      * @param y      坦克的左上角纵坐标
88.      * @param g      画笔
89.      * @param direct 坦克方向（上下左右）
90.      * @param type   坦克的类型（我方，敌方）
91.      */
92.     public void drawTank(int x, int y, Graphics g, int direct, int type) {
94.         //根据不同类型的坦克设置不同的颜色
95.         switch (type) {
96.             case 0://敌方坦克
97.                 g.setColor(Color.cyan);//设置我方坦克颜色
98.                 break;
99.             case 1://我方坦克
100.                 g.setColor(Color.yellow);//设敌方坦克颜色
101.                 break;
102.         }
103.         //根据坦克坐标方向，来绘制对应方向的坦克
104.         //direct表示方向（0：向上  1：向右  2：向下  3：向左）
105.         switch (direct) {
106.             case 0://表示向上
107.                 g.fill3DRect(x, y, 10, 60, false);//画出坦克左边的轮子
108.                 g.fill3DRect(x + 30, y, 10, 60, false);//画出坦克右边的轮子
109.                 g.fill3DRect(x + 10, y + 10, 20, 40, false);//画出坦克主体
110.                 g.fillOval(x + 10, y + 20, 20, 20);//画出坦克舱体
111.                 g.drawLine(x + 20, y + 30, x + 20, y);//画出炮管
112.                 break;
113.             case 1://表示向右
114.                 //注意：以坦克左上角的(x,y)坐标为参考画图案
115.                 g.fill3DRect(x, y, 60, 10, false);//画出坦克上边的轮子
116.                 g.fill3DRect(x, y + 30, 60, 10, false);//画出坦克下边的轮子
117.                 g.fill3DRect(x + 10, y + 10, 40, 20, false);//画出坦克方形主体
118.                 g.fillOval(x + 20, y + 10, 20, 20);//画出坦克舱体
119.                 g.drawLine(x + 30, y + 20, x + 60, y + 20);//画出炮管
120.                 break;
121.             case 2://表示向下
122.                 //向下只需要将向上的炮筒的位置改变即可
123.                 g.fill3DRect(x, y, 10, 60, false);//画出坦克左边的轮子
124.                 g.fill3DRect(x + 30, y, 10, 60, false);//画出坦克右边的轮子
125.                 g.fill3DRect(x + 10, y + 10, 20, 40, false);//画出坦克主体
126.                 g.fillOval(x + 10, y + 20, 20, 20);//画出坦克舱体
127.                 g.drawLine(x + 20, y + 30, x + 20, y + 60);//画出炮管
128.                 break;
129.             case 3://表示向左
130.                 //向左只需要将向右的炮筒的位置改变即可
131.                 g.fill3DRect(x, y, 60, 10, false);//画出坦克上边的轮子
132.                 g.fill3DRect(x, y + 30, 60, 10, false);//画出坦克下边的轮子
133.                 g.fill3DRect(x + 10, y + 10, 40, 20, false);//画出坦克方形主体
134.                 g.fillOval(x + 20, y + 10, 20, 20);//画出坦克舱体
135.                 g.drawLine(x + 30, y + 20, x, y + 20);//画出炮管
136.                 break;
137.             default:
138.                 System.out.println("暂时没有处理");
139.         }
141.     }
143.     @Override
144.     public void keyTyped(KeyEvent e) {
146.     }
148.     //控制方向--处理 WSAD 键按下的情况
149.     @Override
150.     public void keyPressed(KeyEvent e) {
151.         if (e.getKeyCode() == KeyEvent.VK_W) {//按下W键-向上
152.             //改变坦克的方向
153.             hero.setDirect(0);
154.             //修改坦克的坐标
155.             hero.moveUp();
156.         } else if (e.getKeyCode() == KeyEvent.VK_D) {//按下D键-向右
157.             hero.setDirect(1);
158.             hero.moveRight();
159.         } else if (e.getKeyCode() == KeyEvent.VK_S) {//按下S键-向下
160.             hero.setDirect(2);
161.             hero.moveDown();
162.         } else if (e.getKeyCode() == KeyEvent.VK_A) {//按下A键-向左
163.             hero.setDirect(3);
164.             hero.moveLeft();
165.         }
167.         //如果用户按下j键，hero就发射子弹
168.         if (e.getKeyCode() == KeyEvent.VK_J) {
169.             hero.shotEnemyTank();
170.         }
172.         //让面板重绘
173.         this.repaint();
174.     }
176.     @Override
177.     public void keyReleased(KeyEvent e) {
179.     }
181.     @Override
182.     public void run() {//每个100毫秒，重绘区域,刷新绘图区域，子弹就移动
183.         while (true) {
184.             try {
185.                 Thread.sleep(100);
186.             } catch (InterruptedException e) {
187.                 e.printStackTrace();
188.             }
189.             this.repaint();
190.         }
191.     }
192. }

复制代码

7.3.2功能2:敌方坦克消失

功能2:当我方坦克集中敌人坦克时，敌人的坦克就消失，如果能做出爆炸的效果更好
功能2思路：

• 关键点在于判断子弹怎么样算击中敌人：即坦克的击中范围的坐标
  
• 在run()方法中不断地去判断是否击中敌人
  
• 然后在调用drawTank方法前也进行相应的判断，如果敌人未被击中，即enemy.isLive = true，就调用drawTank方法
  
• 关于子弹线程的退出问题：之前只是判断了子弹超出面板时会结束线程。现增加新的线程停止条件：当子弹击中敌方坦克时，该子弹的线程也应结束
  

更改的类：Shot、EnemyTank、MyPanel：
Shot：更改了子弹线程结束的条件

1. package li.TankGame.version04;
3. /**
4. * @author 李
5. * @version 4.0
6. * 射击子弹
7. */
8. public class Shot implements Runnable {
9.     int x; // 记录子弹 x 坐标
10.     int y; // 记录子弹 y 坐标
11.     int direct = 0; // 子弹方向
12.     int speed = 2; // 子弹速度
13.     boolean isLive = true;//记录子弹（线程）存活状态
15.     //构造器
16.     public Shot(int x, int y, int direct) {
17.         this.x = x;
18.         this.y = y;
19.         this.direct = direct;
20.     }
22.     @Override
23.     public void run() {//射击
24.         while (true) {
25.             //休眠50 毫秒
26.             try {
27.                 Thread.sleep(50);
28.             } catch (InterruptedException e) {
29.                 e.printStackTrace();
30.             }
31.             //根据方向来改变(x,y)坐标
32.             switch (direct) {
33.                 case 0://上
34.                     y -= speed;
35.                     break;
36.                 case 1://右
37.                     x += speed;
38.                     break;
39.                 case 2://下
40.                     y += speed;
41.                     break;
42.                 case 3://左
43.                     x -= speed;
44.                     break;
45.             }
46.             //测试。输出坐标
47.             System.out.println("x=" + x + "y=" + y);
48.             //如果子弹移动到面板边界时，就应该销毁（把启动的子弹的线程销毁）
49.             //当子弹碰到敌人坦克时，也应该结束线程
50.             if (!(x >= 0 && x <= 700 && y <= 550 && y >= 0 && isLive)) {//如果不符合条件
51.                 System.out.println("子弹线程退出...");
52.                 isLive = false;
53.                 break;//线程退出
54.             }
55.         }
56.     }
57. }

复制代码

7.3.3功能2plus:坦克爆炸

功能2完善：当子弹击中坦克时，做出爆炸效果
思路：

• 新建一个炸弹Bomb类
  
• 在MyPanel里定义一个Vector集合，用于存放Bomb对象
  
• 在hitTank方法中判断，当子弹击中坦克时就加入一个Bomb对象到bombs集合里（这里将hitTank方法改为非静态方法）
  
• 想要显示出炸弹的效果图，就要在paint方法里面画出，如果bombs集合中有炸弹对象，就画出来
  
• 将爆炸的素材图片放到out目录的根目录下面
  

Bomb：

1. package li.TankGame.version04;
4. import java.util.Vector;
6. public class EnemyTank extends Tank {
8.     //在敌人坦克类使用Vector保存多个Shot
9.     Vector<Shot> shots = new Vector<>();
10.     boolean isLive = true;
12.     public EnemyTank(int x, int y) {
13.         super(x, y);
14.     }
16. }

复制代码

MyPanel：

1. package li.TankGame.version04;
3. import javax.swing.*;
4. import java.awt.*;
5. import java.awt.event.KeyEvent;
6. import java.awt.event.KeyListener;
7. import java.util.Vector;
9. /**
10. * @author 李
11. * @version 4.0
12. * 坦克大战的绘图区域
13. */
14. //为了监听键盘事件，要实现 KeyListener
16. //为了让Panel不停地重绘子弹，需要将MyPanel实现Runnable，
17. // 当做一个线程使用（因为需要不停地重绘子弹的图案）
18. public class MyPanel extends JPanel implements KeyListener, Runnable {
19.     //定义我的坦克
20.     Hero hero = null;
22.     //定义敌方坦克，放入到Vector集合中
23.     Vector<EnemyTank> enemyTanks = new Vector<>();
24.     int enemyTankNum = 3;//初始化坦克数量
26.     public MyPanel() {
27.         hero = new Hero(100, 100);//初始化自己的坦克
28.         //hero.setSpeed(5); //改变坦克的速度
30.         //初始化敌人的坦克
31.         for (int i = 0; i < enemyTankNum; i++) {
32.             //创建一个敌人的坦克
33.             EnemyTank enemyTank = new EnemyTank(100 * (i + 1), 0);
34.             //初始化敌人坦克方向向下
35.             enemyTank.setDirect(2);
36.             //给该enemyTank加入一颗子弹
37.             Shot shot = new Shot(enemyTank.getX() + 20, enemyTank.getY() + 60, enemyTank.getDirect());
38.             //将该子弹加入到enemyTank的Vector集合中
39.             enemyTank.shots.add(shot);
40.             //启动 shot对象
41.             new Thread(shot).start();
42.             //将设置好的的敌人坦克放入到集合中
43.             enemyTanks.add(enemyTank);
44.         }
45.     }
47.     @Override
48.     public void paint(Graphics g) {
49.         super.paint(g);
50.         g.fillRect(0, 0, 700, 550);//填充矩形，默认为黑色
52.         //画出自己的坦克-封装方法
53.         drawTank(hero.getX(), hero.getY(), g, hero.getDirect(), 1);
55.         //画出hero发射的子弹
56.         //如果子弹对象不为空，并且处于存活状态（即没有超出边界）
57.         if (hero.shot != null && hero.shot.isLive) {
58.             System.out.println("hero的子弹被绘制");
59.             g.draw3DRect(hero.shot.x, hero.shot.y, 2, 2, false);
60.         }
62.         //画出敌人的坦克,遍历Vector
63.         for (int i = 0; i < enemyTanks.size(); i++) {
64.             //取出坦克
65.             EnemyTank enemyTank = enemyTanks.get(i);
66.             if (enemyTank.isLive) {//当敌人坦克是活的，才将其画出
67.                 drawTank(enemyTank.getX(), enemyTank.getY(), g, enemyTank.getDirect(), 0);
68.                 //画出enemyTank所有子弹
69.                 for (int j = 0; j < enemyTank.shots.size(); j++) {
70.                     //enemyTank.shots.size()是当前的enemy对象的shots集合的大小
71.                     //取出子弹
72.                     Shot shot = enemyTank.shots.get(j);
73.                     //绘制子弹
74.                     if (shot.isLive) {//shot.isLive==true
75.                         g.draw3DRect(shot.x, shot.y, 2, 2, false);
76.                     } else {
77.                         //从Vector移除子弹shot对象
78.                         enemyTank.shots.remove(shot);
79.                     }
80.                 }
81.             }
82.         }
83.     }
85.     /**
86.      * 编写方法，画出坦克
87.      *
88.      * @param x      坦克的左上角横坐标
89.      * @param y      坦克的左上角纵坐标
90.      * @param g      画笔
91.      * @param direct 坦克方向（上下左右）
92.      * @param type   坦克的类型（我方，敌方）
93.      */
94.     public void drawTank(int x, int y, Graphics g, int direct, int type) {
96.         //根据不同类型的坦克设置不同的颜色
97.         switch (type) {
98.             case 0://敌方坦克
99.                 g.setColor(Color.cyan);//设置我方坦克颜色
100.                 break;
101.             case 1://我方坦克
102.                 g.setColor(Color.yellow);//设敌方坦克颜色
103.                 break;
104.         }
105.         //根据坦克坐标方向，来绘制对应方向的坦克
106.         //direct表示方向（0：向上  1：向右  2：向下  3：向左）
107.         switch (direct) {
108.             case 0://表示向上
109.                 g.fill3DRect(x, y, 10, 60, false);//画出坦克左边的轮子
110.                 g.fill3DRect(x + 30, y, 10, 60, false);//画出坦克右边的轮子
111.                 g.fill3DRect(x + 10, y + 10, 20, 40, false);//画出坦克主体
112.                 g.fillOval(x + 10, y + 20, 20, 20);//画出坦克舱体
113.                 g.drawLine(x + 20, y + 30, x + 20, y);//画出炮管
114.                 break;
115.             case 1://表示向右
116.                 //注意：以坦克左上角的(x,y)坐标为参考画图案
117.                 g.fill3DRect(x, y, 60, 10, false);//画出坦克上边的轮子
118.                 g.fill3DRect(x, y + 30, 60, 10, false);//画出坦克下边的轮子
119.                 g.fill3DRect(x + 10, y + 10, 40, 20, false);//画出坦克方形主体
120.                 g.fillOval(x + 20, y + 10, 20, 20);//画出坦克舱体
121.                 g.drawLine(x + 30, y + 20, x + 60, y + 20);//画出炮管
122.                 break;
123.             case 2://表示向下
124.                 //向下只需要将向上的炮筒的位置改变即可
125.                 g.fill3DRect(x, y, 10, 60, false);//画出坦克左边的轮子
126.                 g.fill3DRect(x + 30, y, 10, 60, false);//画出坦克右边的轮子
127.                 g.fill3DRect(x + 10, y + 10, 20, 40, false);//画出坦克主体
128.                 g.fillOval(x + 10, y + 20, 20, 20);//画出坦克舱体
129.                 g.drawLine(x + 20, y + 30, x + 20, y + 60);//画出炮管
130.                 break;
131.             case 3://表示向左
132.                 //向左只需要将向右的炮筒的位置改变即可
133.                 g.fill3DRect(x, y, 60, 10, false);//画出坦克上边的轮子
134.                 g.fill3DRect(x, y + 30, 60, 10, false);//画出坦克下边的轮子
135.                 g.fill3DRect(x + 10, y + 10, 40, 20, false);//画出坦克方形主体
136.                 g.fillOval(x + 20, y + 10, 20, 20);//画出坦克舱体
137.                 g.drawLine(x + 30, y + 20, x, y + 20);//画出炮管
138.                 break;
139.             default:
140.                 System.out.println("暂时没有处理");
141.         }
143.     }
145.     /*编写方法，判断我方的子弹是否击中敌人*/
147.     public static void hitTank(Shot s, EnemyTank enemyTank) {
148.         //判断s击中坦克
149.         switch (enemyTank.getDirect()) {
150.             case 0://敌人坦克向上（向上和向下的击中范围一样）
151.             case 2://敌人坦克向下
152.                 if (s.x > enemyTank.getX() && s.y < enemyTank.getX() + 40
153.                         && s.y > enemyTank.getY() && s.y < enemyTank.getY() + 60) {
154.                     s.isLive = false;
155.                     enemyTank.isLive = false;
156.                     //当子弹击中敌人后，将enemyTank从Vector中删除
157.                     enemyTanks.remove(enemyTank);
158.                     
159.                 }
160.             case 1://右
161.             case 3://左
162.                 if (s.x > enemyTank.getX() && s.y < enemyTank.getX() + 60
163.                         && s.y > enemyTank.getY() && s.y < enemyTank.getY() + 40) {
164.                     s.isLive = false;
165.                     enemyTank.isLive = false;
166.                     //当子弹击中敌人后，将enemyTank从Vector中删除
167.                     enemyTanks.remove(enemyTank);
168.                     
169.                 }
170.                 break;
171.         }
172.       
173.     }
176.     @Override
177.     public void keyTyped(KeyEvent e) {
179.     }
181.     //控制方向--处理 WSAD 键按下的情况
182.     @Override
183.     public void keyPressed(KeyEvent e) {
184.         if (e.getKeyCode() == KeyEvent.VK_W) {//按下W键-向上
185.             //改变坦克的方向
186.             hero.setDirect(0);
187.             //修改坦克的坐标
188.             hero.moveUp();
189.         } else if (e.getKeyCode() == KeyEvent.VK_D) {//按下D键-向右
190.             hero.setDirect(1);
191.             hero.moveRight();
192.         } else if (e.getKeyCode() == KeyEvent.VK_S) {//按下S键-向下
193.             hero.setDirect(2);
194.             hero.moveDown();
195.         } else if (e.getKeyCode() == KeyEvent.VK_A) {//按下A键-向左
196.             hero.setDirect(3);
197.             hero.moveLeft();
198.         }
200.         //如果用户按下j键，hero就发射子弹
201.         if (e.getKeyCode() == KeyEvent.VK_J) {
202.             hero.shotEnemyTank();
203.         }
205.         //让面板重绘
206.         this.repaint();
207.     }
209.     @Override
210.     public void keyReleased(KeyEvent e) {
212.     }
214.     @Override
215.     public void run() {//每个100毫秒，重绘区域,刷新绘图区域，子弹就移动
216.         while (true) {
217.             try {
218.                 Thread.sleep(100);
219.             } catch (InterruptedException e) {
220.                 e.printStackTrace();
221.             }
223.             //判断是否击中敌人坦克
224.             if (hero.shot != null && hero.shot.isLive) {//如果当前我方子弹不为空且子弹还存活
225.                 //就遍历敌人所有的坦克
226.                 for (int i = 0; i < enemyTanks.size(); i++) {
227.                     EnemyTank enemyTank = enemyTanks.get(i);
228.                     hitTank(hero.shot, enemyTank);            
229.                 }
230.             }
231.             this.repaint();
232.         }
233.     }
234. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！