devbox
AllinToyou
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Java 坦克大战项目学习阶段记录及总结_tankwar 的java项目怎么学

作者：AllinToyou | 2024-03-27 18:57:04

赞

踩

tankwar 的java项目怎么学

/*首先要声明的是，这个并不是坦克大战项目编写细节的过程分享，只是个人的阶段学习记录及总结,坦克大战的项目可以参考B站上韩顺平老师的视频教学*/

阶段一：

小总结：今天刚开始，跟着视频一起学习编写坦克大战的项目，首先，我觉得对于编写一个项目，最重要的就是要构思好一个框架，比如，你写一个项目，要设几个类，每个类分别有什么作用。但是也不要太过于想提前想好要写什么方法（函数），我们只需要先构思好大的类，具体的，等到我们自己去写的时候，是可以慢慢再实现的。最重要的，一定是首先要有一个明确的思路。比如这个坦克大战的编写，目前写了五个类：主程序类，游戏界面绘制类，坦克基类，我的坦克类，敌方坦克类。思路是：先进行游戏界面的绘制，再画出坦克的图形，此时是静态的。然后再到动态的坦克编写，今天最后完成的，就是敌方坦克的绘制，因为敌方坦克会有许多特有的方法，所以要单独成一个类。因此，我对面向对象设计，或者说是对程序设计的感受是，最重要的就是有一个明确的思路，有一个框架，里面的内容是可以慢慢去填充的。  

今天“手痒”测试了一下，给敌方一个坦克添加了键盘监听事件，让我觉得写成之后，甚至可以写一个双人1V1的坦克大战，但是我在移动的时候，我发现，一次只能移动一辆坦克，要想同时移动两辆坦克，目前肯定是不行的。下一个阶段是学习多线程，因此我想到了实现多线程，应该就是为了多个坦克可以同时移动。

以下是今天的代码记录截图：

五个类（根据英文应该能猜到各自对应什么） 

1.主程序类（TankGame01）

  1. package com.wak.TankGame01Version;
  2.  
  3. import javax.swing.*;
  4.  
  5. /*坦克大战游戏主程序*/
  6. public class TankGame01 extends JFrame {
  7.     public static void main(String[] args) {
  8.         //启动！
  9.         new TankGame01();
  10.     }
  11.  
  12.     //定义GamePanel，创建游戏环境
  13.     GamePanel gamePanel = null;
  14.  
  15.     //加载游戏环境
  16.     public TankGame01(){
  17.         //1.0版本
  18.         this.setTitle("坦克大战1.0");
  19.         //加载游戏环境
  20.         gamePanel = new GamePanel();
  21.         //将游戏区域加载到界面里
  22.         this.add(gamePanel);
  23.         //将键盘监听器加载到界面里
  24.         this.addKeyListener(gamePanel);
  25.         //设置界面可视化
  26.         this.setVisible(true);
  27.         //设置界面的大小
  28.         this.setSize(1000,800);
  29.         //设置界面可关闭
  30.         this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  31.     }
  32.  
  33. }

2.游戏界面绘制类（GamePanel）

  1. package com.wak.TankGame01Version;
  2.  
  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;
  8.  
  9. /*坦克大战的绘图区域*/
  10. public class GamePanel extends JPanel implements KeyListener {
  11.     //定义一个自己的坦克
  12.     MyTank myTank = null;
  13.  
  14.     //创建敌方坦克
  15.     Vector<OpTank> opTanks = new Vector<>();
  16.     //设置敌方坦克数量
  17.     int opTanksSize = 3;
  18.  
  19.     public GamePanel(){
  20.         myTank = new MyTank(200,600);   //初始化坦克的位置
  21.         myTank.setSpeed(3); //设置坦克的速度
  22.  
  23.         for(int i=0;i<opTanksSize;i++){
  24.             OpTank opTank = new OpTank((100 * i + 100),0);
  25.             opTank.setDirect(2);
  26.             opTanks.add(opTank);
  27.         }
  28.     }
  29.  
  30.  
  31.     @Override
  32.     public void paint(Graphics g) {
  33.         super.paint(g);
  34.         g.fillRect(0,0,1000,800);    //默认背景是黑色
  35.  
  36.         //画出坦克-封装方法
  37.         DrawTank(myTank.getX(),myTank.getY(),g,myTank.getDirect(),0);
  38.         DrawTank(myTank.getX(),myTank.getY(),g,myTank.getDirect(),0);
  39.         for(int i=0;i<opTanks.size();i++){
  40.             //取出敌方坦克
  41.             OpTank opTank = opTanks.get(i);
  42.             DrawTank(opTank.getX(),opTank.getY(),g,opTank.getDirect(),1);
  43.         }
  44.     }
  45.  
  46.     //编写方法，画出坦克
  47.  
  48.     /**
  49.      *
  50.      * @param x 坦克的x坐标
  51.      * @param y 坦克的y坐标
  52.      * @param g 画笔
  53.      * @param direct    坦克方向（上下左右）
  54.      * @param type  坦克类型
  55.      */
  56.     public void DrawTank(int x,int y,Graphics g,int direct,int type){
  57.         //坦克的类型
  58.         switch (type){
  59.             case 0: //自己的坦克
  60.                 g.setColor(Color.CYAN);
  61.                 break;
  62.             case 1: //敌人的坦克
  63.                 g.setColor(Color.RED);
  64.                 break;
  65.         }
  66.  
  67.         switch (direct){
  68.             case 0: //表示向上
  69.                 g.fill3DRect(x,y,10,60,false);  //坦克的左边轮子
  70.                 g.drawLine(x,y + 10,x + 10,y + 10); //坦克左轮的履带
  71.                 g.drawLine(x,y + 20,x + 10,y + 20);
  72.                 g.drawLine(x,y + 30,x + 10,y + 30);
  73.                 g.drawLine(x,y + 40,x + 10,y + 40);
  74.                 g.drawLine(x,y + 50,x + 10,y + 50);
  75.  
  76.                 g.fill3DRect(x + 40,y,10,60,false); //坦克的右边轮子
  77.                 g.drawLine(x + 40,y + 10,x + 50,y + 10);     //坦克右轮的履带
  78.                 g.drawLine(x + 40,y + 20,x + 50,y + 20);
  79.                 g.drawLine(x + 40,y + 30,x + 50,y + 30);
  80.                 g.drawLine(x + 40,y + 40,x + 50,y + 40);
  81.                 g.drawLine(x + 40,y + 50,x + 50,y + 50);
  82.  
  83.                 g.fill3DRect(x + 10,y + 10,30,40,false);    //坦克的身体
  84.                 g.fillOval(x + 10,y + 15,30,30);    //坦克的炮盖
  85.                 g.drawLine(x + 25,y + 30,x + 25,y); //坦克的炮筒
  86.                 break;
  87.  
  88.             case 1: //表示向右
  89.                 g.fill3DRect(x,y,60,10,false);  //坦克左边的轮子
  90.                 g.drawLine(x + 10,y,x + 10 ,y + 10);    //坦克左轮的履带
  91.                 g.drawLine(x + 20,y,x + 20 ,y + 10);
  92.                 g.drawLine(x + 30,y,x + 30 ,y + 10);
  93.                 g.drawLine(x + 40,y,x + 40 ,y + 10);
  94.                 g.drawLine(x + 50,y,x + 50 ,y + 10);
  95.  
  96.  
  97.                 g.fill3DRect(x,y + 40,60,10,false); //坦克右边的轮子
  98.                 g.drawLine(x + 10,y + 40,x + 10,y + 50);
  99.                 g.drawLine(x + 20,y + 40,x + 20,y + 50);
  100.                 g.drawLine(x + 30,y + 40,x + 30,y + 50);
  101.                 g.drawLine(x + 40,y + 40,x + 40,y + 50);
  102.                 g.drawLine(x + 50,y + 40,x + 50,y + 50);
  103.  
  104.  
  105.                 g.fill3DRect( x + 10,y + 10,40,30,false);   //坦克的身体
  106.                 g.fillOval(x + 15,y + 10,30,30);    //坦克的炮盖
  107.                 g.drawLine(x + 30,y + 25,x +60,y + 25); //坦克的炮筒
  108.                 break;
  109.  
  110.             case 2: //表示向下
  111.                 g.fill3DRect(x,y,10,60,false);  //坦克的左边轮子
  112.                 g.drawLine(x,y + 10,x + 10,y + 10); //坦克左轮的履带
  113.                 g.drawLine(x,y + 20,x + 10,y + 20);
  114.                 g.drawLine(x,y + 30,x + 10,y + 30);
  115.                 g.drawLine(x,y + 40,x + 10,y + 40);
  116.                 g.drawLine(x,y + 50,x + 10,y + 50);
  117.  
  118.                 g.fill3DRect(x + 40,y,10,60,false); //坦克的右边轮子
  119.                 g.drawLine(x + 40,y + 10,x + 50,y + 10);    //坦克右轮的履带
  120.                 g.drawLine(x + 40,y + 20,x + 50,y + 20);
  121.                 g.drawLine(x + 40,y + 30,x + 50,y + 30);
  122.                 g.drawLine(x + 40,y + 40,x + 50,y + 40);
  123.                 g.drawLine(x + 40,y + 50,x + 50,y + 50);
  124.  
  125.                 g.fill3DRect(x + 10,y + 10,30,40,false);    //坦克的身体
  126.                 g.fillOval(x + 10,y + 15,30,30);    //坦克的炮盖
  127.                 g.drawLine(x + 25,y + 30,x + 25,y + 60); //坦克的炮筒
  128.                 break;
  129.  
  130.             case 3: //表示向左
  131.                 g.fill3DRect(x,y,60,10,false);  //坦克左边的轮子
  132.                 g.drawLine(x + 10,y,x + 10 ,y + 10);    //坦克左轮的履带
  133.                 g.drawLine(x + 20,y,x + 20 ,y + 10);
  134.                 g.drawLine(x + 30,y,x + 30 ,y + 10);
  135.                 g.drawLine(x + 40,y,x + 40 ,y + 10);
  136.                 g.drawLine(x + 50,y,x + 50 ,y + 10);
  137.  
  138.  
  139.                 g.fill3DRect(x,y + 40,60,10,false); //坦克右边的轮子
  140.                 g.drawLine(x + 10,y + 40,x + 10,y + 50);
  141.                 g.drawLine(x + 20,y + 40,x + 20,y + 50);
  142.                 g.drawLine(x + 30,y + 40,x + 30,y + 50);
  143.                 g.drawLine(x + 40,y + 40,x + 40,y + 50);
  144.                 g.drawLine(x + 50,y + 40,x + 50,y + 50);
  145.  
  146.  
  147.                 g.fill3DRect( x + 10,y + 10,40,30,false);   //坦克的身体
  148.                 g.fillOval(x + 15,y + 10,30,30);    //坦克的炮盖
  149.                 g.drawLine(x + 30,y + 25,x,y + 25); //坦克的炮筒
  150.                 break;
  151.  
  152.             default:
  153.                 System.out.println("暂时没有处理");
  154.         }
  155.     }
  156.  
  157.     @Override
  158.     public void keyTyped(KeyEvent e) {
  159.  
  160.     }
  161.  
  162.     @Override
  163.     public void keyPressed(KeyEvent e) {
  164.         if(e.getKeyCode() == KeyEvent.VK_W){
  165.             myTank.setDirect(0);
  166.             myTank.MoveUp();
  167.         }else if(e.getKeyCode() == KeyEvent.VK_D){
  168.             myTank.setDirect(1);
  169.             myTank.MoveRight();
  170.         }else if(e.getKeyCode() == KeyEvent.VK_S){
  171.             myTank.setDirect(2);
  172.             myTank.MoveDown();
  173.         }else if(e.getKeyCode() == KeyEvent.VK_A){
  174.             myTank.setDirect(3);
  175.             myTank.MoveLeft();
  176.         }
  177. //        else if(e.getKeyCode() == KeyEvent.VK_UP){
  178. //            opTanks.get(0).setDirect(0);
  179. //            opTanks.get(0).MoveUp();
  180. //        }else if(e.getKeyCode() == KeyEvent.VK_RIGHT){
  181. //            opTanks.get(0).setDirect(1);
  182. //            opTanks.get(0).MoveRight();
  183. //        }else if(e.getKeyCode() == KeyEvent.VK_DOWN){
  184. //            opTanks.get(0).setDirect(2);
  185. //            opTanks.get(0).MoveDown();
  186. //        }else if(e.getKeyCode() == KeyEvent.VK_LEFT) {
  187. //            opTanks.get(0).setDirect(3);
  188. //            opTanks.get(0).MoveLeft();
  189. //        }
  190.         this.repaint();
  191.  
  192.     }
  193.  
  194.     @Override
  195.     public void keyReleased(KeyEvent e) {
  196.  
  197.     }
  198. }

3.坦克基类（Tank）

  1. package com.wak.TankGame01Version;
  2.  
  3. /*坦克的基类*/
  4. public class Tank {
  5.     private int x;  //坦克的横坐标
  6.     private int y;  //坦克的纵坐标
  7.     private int direct = 0; //坦克的方向
  8.     private int speed = 1;  //坦克的速度
  9.  
  10.     public Tank(){
  11.         this.x = 100;   //默认坦克的初始x坐标为100
  12.         this.y = 100;   //默认坦克的初始y坐标为100
  13.     }
  14.  
  15.     public Tank(int x,int y){   //自己设置坦克的初始x,y坐标
  16.         this.x = x;
  17.         this.y = y;
  18.     }
  19.  
  20.  
  21.     //设置坦克的x坐标
  22.     public void setX(int x){
  23.         this.x = x;
  24.     }
  25.  
  26.     //设置坦克的y坐标
  27.     public void setY(int y){
  28.         this.y = y;
  29.     }
  30.  
  31.     //获得坦克的x坐标
  32.     public int getX(){
  33.         return x;
  34.     }
  35.  
  36.     //获得坦克的y坐标
  37.     public int getY(){
  38.         return y;
  39.     }
  40.  
  41.     //设置坦克的方向
  42.     public void setDirect(int direct){
  43.         this.direct = direct;
  44.     }
  45.  
  46.     //获得坦克的方向
  47.     public int getDirect(){
  48.         return direct;
  49.     }
  50.  
  51.     //设置坦克的速度
  52.     public void setSpeed(int speed){
  53.         this.speed = speed;
  54.     }
  55.  
  56.     //获得坦克的速度
  57.     public int getSpeed(){
  58.         return speed;
  59.     }
  60.  
  61.     //坦克的上右下左移动
  62.     public void MoveUp(){
  63.         y -= speed;
  64.     }
  65.     public void MoveRight(){
  66.         x += speed;
  67.     }
  68.     public void MoveDown(){
  69.         y += speed;
  70.     }
  71.     public void MoveLeft(){
  72.         x -= speed;
  73.     }
  74. }
  75.  
  76.

4.我的坦克类(MyTank)

  1. package com.wak.TankGame01Version;
  2.  
  3. /*自己的坦克*/
  4. public class MyTank extends Tank{
  5.     //创建一个坦克
  6.     private MyTank myTank = null;
  7.     //设置坦克的初始化坐标
  8.     public MyTank(int x,int y){
  9.         this.setX(x);
  10.         this.setY(y);
  11.     }
  12.  
  13.  
  14. }

5.敌方坦克类(OpTank)

  1. package com.wak.TankGame01Version;
  2.  
  3. public class OpTank extends Tank{
  4.     private OpTank opTank = null;
  5.  
  6.     public OpTank(int x,int y){
  7.         this.setX(x);
  8.         this.setY(y);
  9.     }
  10.  
  11.  
  12. }

运行效果：（蓝色是我的坦克，红色是敌方坦克，蓝色坦克可以上下左右移动）

阶段二：

小总结：今天接续昨天的内容，完成了我的坦克的发射炮弹，敌方坦克发射子弹，敌方坦克消失，敌方坦克自由移动，以及控制坦克移动的范围。我发现到这里，才真正写到了坦克大战的比较核心的、难的部分，那就是多线程。先简要的说一下今天学习的编写思路吧：因为炮弹是我的和敌方坦克都有的，所以需要单独写一个类，所以今天加了一个Shot类，但是因为你要射击的时候，它也要在界面上移动，所以这时候就需要用到多线程，像敌方坦克发射炮弹，敌方坦克移动，都是要用到多线程，而其中的另一个关键就是，在哪里启动，而这其中有很多思路是很巧妙的，比如，对于控制坦克的移动范围，我以为要另外写一个方法去进行判断的时候，韩老师的思路就是直接在控制坦克上下左右移动的代码上进行一个if判断，这样直接且非常巧妙的解决了问题，再比如，绘制敌方坦克的时候，先判断一下敌方坦克是否存活，再进行绘制，这样又提高了代码的运行效率，等等等。我发现，对于写一个程序，甚至是一段代码，一定要先想一想，构思一下，确立好思路再动手，尽量发散一下思维。

以下是今天的代码记录截图：

六个类（根据英文应该能猜到各自对应什么） 

 1.主程序类（TankGame01）

  1. package com.wak.TankGame01Version;
  2.  
  3. import javax.swing.*;
  4.  
  5. /*坦克大战游戏主程序*/
  6. public class TankGame01 extends JFrame {
  7.     public static void main(String[] args) {
  8.         //启动！
  9.         new TankGame01();
  10.     }
  11.  
  12.     //定义GamePanel，创建游戏环境
  13.     GamePanel gamePanel = null;
  14.  
  15.     //加载游戏环境
  16.     public TankGame01(){
  17.         //1.0版本
  18.         this.setTitle("坦克大战1.0");
  19.         //加载游戏环境
  20.         gamePanel = new GamePanel();
  21.         //将游戏区域加载到界面里
  22.         this.add(gamePanel);
  23.         //将游戏界面的炮弹线程加入到界面里
  24.         Thread thread = new Thread(gamePanel);
  25.         //启动子线程
  26.         thread.start();
  27.         //将键盘监听器加载到界面里
  28.         this.addKeyListener(gamePanel);
  29.         //设置界面可视化
  30.         this.setVisible(true);
  31.         //设置界面的大小
  32.         this.setSize(1000,800);
  33.         //设置界面可关闭
  34.         this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  35.     }
  36.  
  37. }

2.游戏界面绘制类（GamePanel）

  1. package com.wak.TankGame01Version;
  2.  
  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;
  8.  
  9. /*坦克大战的绘图区域*/
  10.  
  11. //为了监听键盘事件，实现KeyListener
  12. //
  13. public class GamePanel extends JPanel implements KeyListener,Runnable{
  14.     //定义一个自己的坦克
  15.     MyTank myTank = null;
  16.  
  17.     //创建敌方坦克
  18.     Vector<OpTank> opTanks = new Vector<>();
  19.     //设置敌方坦克数量
  20.     int opTanksSize = 3;
  21.  
  22.     public GamePanel(){
  23.         myTank = new MyTank(200,600);   //初始化坦克的位置
  24.         myTank.setSpeed(3); //设置坦克的速度
  25.  
  26.         for(int i=0;i<opTanksSize;i++){
  27.             OpTank opTank = new OpTank((100 * i + 100),0);
  28.             //设置方向
  29.             opTank.setDirect(2);
  30.             //启动敌人坦克线程
  31.             new Thread(opTank).start();
  32.             //给该opTank加入一颗炮弹
  33.             Shot shot = new Shot(opTank.getX() + 25,opTank.getY() + 60,2);
  34.             //存放到Vector中
  35.             opTank.shots.add(shot);
  36.             //启动线程对象
  37.             new Thread(shot).start();
  38.             //加入
  39.             opTanks.add(opTank);
  40.         }
  41.     }
  42.  
  43.  
  44.     @Override
  45.     public void paint(Graphics g) {
  46.         super.paint(g);
  47.         g.fillRect(0,0,1000,800);    //默认背景是黑色
  48.  
  49.         //画出坦克-封装方法
  50.         //画出我的坦克
  51.         DrawTank(myTank.getX(),myTank.getY(),g,myTank.getDirect(),0);
  52.         //画出敌人的坦克
  53.         for(int i=0;i<opTanks.size();i++){
  54.             //取出敌方坦克
  55.             OpTank opTank = opTanks.get(i);
  56.             //判断敌方坦克是否存活
  57.             if(opTank.isLive) { //当敌人坦克是存活的时候，才去画
  58.                 DrawTank(opTank.getX(), opTank.getY(), g, opTank.getDirect(), 1);
  59.                 //画出敌人的坦克发出的炮弹
  60.                 for (int j = 0; j < opTank.shots.size(); j++) {
  61.                     //取出子弹
  62.                     Shot shot = opTank.shots.get(j);
  63.                     //绘制
  64.                     if (shot.isLive) {
  65.                         g.setColor(Color.WHITE);
  66.                         g.fill3DRect(shot.x, shot.y, 4, 4, false);
  67.                     } else {
  68.                         opTank.shots.remove(shot);
  69.                     }
  70.                 }
  71.             }
  72.  
  73.         }
  74.  
  75.         //画出我的坦克发出的炮弹
  76.         if(myTank.shot != null && myTank.shot.isLive == true){
  77.             g.setColor(Color.CYAN);
  78.             g.fill3DRect(myTank.shot.x,myTank.shot.y,4,4,false);
  79.         }
  80.  
  81.  
  82.  
  83.     }
  84.  
  85.     //编写方法，画出坦克
  86.  
  87.     /**
  88.      *
  89.      * @param x 坦克的x坐标
  90.      * @param y 坦克的y坐标
  91.      * @param g 画笔
  92.      * @param direct    坦克方向（上下左右）
  93.      * @param type  坦克类型
  94.      */
  95.     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.RED);
  103.                 break;
  104.         }
  105.  
  106.         switch (direct){
  107.             case 0: //表示向上
  108.                 g.fill3DRect(x,y,10,60,false);  //坦克的左边轮子
  109.                 g.drawLine(x,y + 10,x + 10,y + 10); //坦克左轮的履带
  110.                 g.drawLine(x,y + 20,x + 10,y + 20);
  111.                 g.drawLine(x,y + 30,x + 10,y + 30);
  112.                 g.drawLine(x,y + 40,x + 10,y + 40);
  113.                 g.drawLine(x,y + 50,x + 10,y + 50);
  114.  
  115.                 g.fill3DRect(x + 40,y,10,60,false); //坦克的右边轮子
  116.                 g.drawLine(x + 40,y + 10,x + 50,y + 10);     //坦克右轮的履带
  117.                 g.drawLine(x + 40,y + 20,x + 50,y + 20);
  118.                 g.drawLine(x + 40,y + 30,x + 50,y + 30);
  119.                 g.drawLine(x + 40,y + 40,x + 50,y + 40);
  120.                 g.drawLine(x + 40,y + 50,x + 50,y + 50);
  121.  
  122.                 g.fill3DRect(x + 10,y + 10,30,40,false);    //坦克的身体
  123.                 g.fillOval(x + 10,y + 15,30,30);    //坦克的炮盖
  124.                 g.drawLine(x + 25,y + 30,x + 25,y); //坦克的炮筒
  125.                 break;
  126.  
  127.             case 1: //表示向右
  128.                 g.fill3DRect(x,y,60,10,false);  //坦克左边的轮子
  129.                 g.drawLine(x + 10,y,x + 10 ,y + 10);    //坦克左轮的履带
  130.                 g.drawLine(x + 20,y,x + 20 ,y + 10);
  131.                 g.drawLine(x + 30,y,x + 30 ,y + 10);
  132.                 g.drawLine(x + 40,y,x + 40 ,y + 10);
  133.                 g.drawLine(x + 50,y,x + 50 ,y + 10);
  134.  
  135.  
  136.                 g.fill3DRect(x,y + 40,60,10,false); //坦克右边的轮子
  137.                 g.drawLine(x + 10,y + 40,x + 10,y + 50);
  138.                 g.drawLine(x + 20,y + 40,x + 20,y + 50);
  139.                 g.drawLine(x + 30,y + 40,x + 30,y + 50);
  140.                 g.drawLine(x + 40,y + 40,x + 40,y + 50);
  141.                 g.drawLine(x + 50,y + 40,x + 50,y + 50);
  142.  
  143.  
  144.                 g.fill3DRect( x + 10,y + 10,40,30,false);   //坦克的身体
  145.                 g.fillOval(x + 15,y + 10,30,30);    //坦克的炮盖
  146.                 g.drawLine(x + 30,y + 25,x +60,y + 25); //坦克的炮筒
  147.                 break;
  148.  
  149.             case 2: //表示向下
  150.                 g.fill3DRect(x,y,10,60,false);  //坦克的左边轮子
  151.                 g.drawLine(x,y + 10,x + 10,y + 10); //坦克左轮的履带
  152.                 g.drawLine(x,y + 20,x + 10,y + 20);
  153.                 g.drawLine(x,y + 30,x + 10,y + 30);
  154.                 g.drawLine(x,y + 40,x + 10,y + 40);
  155.                 g.drawLine(x,y + 50,x + 10,y + 50);
  156.  
  157.                 g.fill3DRect(x + 40,y,10,60,false); //坦克的右边轮子
  158.                 g.drawLine(x + 40,y + 10,x + 50,y + 10);    //坦克右轮的履带
  159.                 g.drawLine(x + 40,y + 20,x + 50,y + 20);
  160.                 g.drawLine(x + 40,y + 30,x + 50,y + 30);
  161.                 g.drawLine(x + 40,y + 40,x + 50,y + 40);
  162.                 g.drawLine(x + 40,y + 50,x + 50,y + 50);
  163.  
  164.                 g.fill3DRect(x + 10,y + 10,30,40,false);    //坦克的身体
  165.                 g.fillOval(x + 10,y + 15,30,30);    //坦克的炮盖
  166.                 g.drawLine(x + 25,y + 30,x + 25,y + 60); //坦克的炮筒
  167.                 break;
  168.  
  169.             case 3: //表示向左
  170.                 g.fill3DRect(x,y,60,10,false);  //坦克左边的轮子
  171.                 g.drawLine(x + 10,y,x + 10 ,y + 10);    //坦克左轮的履带
  172.                 g.drawLine(x + 20,y,x + 20 ,y + 10);
  173.                 g.drawLine(x + 30,y,x + 30 ,y + 10);
  174.                 g.drawLine(x + 40,y,x + 40 ,y + 10);
  175.                 g.drawLine(x + 50,y,x + 50 ,y + 10);
  176.  
  177.  
  178.                 g.fill3DRect(x,y + 40,60,10,false); //坦克右边的轮子
  179.                 g.drawLine(x + 10,y + 40,x + 10,y + 50);
  180.                 g.drawLine(x + 20,y + 40,x + 20,y + 50);
  181.                 g.drawLine(x + 30,y + 40,x + 30,y + 50);
  182.                 g.drawLine(x + 40,y + 40,x + 40,y + 50);
  183.                 g.drawLine(x + 50,y + 40,x + 50,y + 50);
  184.  
  185.  
  186.                 g.fill3DRect( x + 10,y + 10,40,30,false);   //坦克的身体
  187.                 g.fillOval(x + 15,y + 10,30,30);    //坦克的炮盖
  188.                 g.drawLine(x + 30,y + 25,x,y + 25); //坦克的炮筒
  189.                 break;
  190.  
  191.             default:
  192.                 System.out.println("暂时没有处理");
  193.         }
  194.     }
  195.  
  196.     @Override
  197.     public void keyTyped(KeyEvent e) {
  198.  
  199.     }
  200.  
  201.     @Override
  202.     public void keyPressed(KeyEvent e) {
  203.         if(e.getKeyCode() == KeyEvent.VK_W){
  204.             myTank.setDirect(0);
  205.             if(myTank.getY() > 0) {
  206.                 myTank.MoveUp();
  207.             }
  208.         }else if(e.getKeyCode() == KeyEvent.VK_D){
  209.             myTank.setDirect(1);
  210.             if(myTank.getX() + 60 < 1000) {
  211.                 myTank.MoveRight();
  212.             }
  213.         }else if(e.getKeyCode() == KeyEvent.VK_S){
  214.             myTank.setDirect(2);
  215.             if(myTank.getY() + 60 < 800) {
  216.                 myTank.MoveDown();
  217.             }
  218.         }else if(e.getKeyCode() == KeyEvent.VK_A){
  219.             myTank.setDirect(3);
  220.             if(myTank.getX() + 60 > 0) {
  221.                 myTank.MoveLeft();
  222.             }
  223.         }
  224. //        else if(e.getKeyCode() == KeyEvent.VK_UP){
  225. //            opTanks.get(0).setDirect(0);
  226. //            opTanks.get(0).MoveUp();
  227. //        }else if(e.getKeyCode() == KeyEvent.VK_RIGHT){
  228. //            opTanks.get(0).setDirect(1);
  229. //            opTanks.get(0).MoveRight();
  230. //        }else if(e.getKeyCode() == KeyEvent.VK_DOWN){
  231. //            opTanks.get(0).setDirect(2);
  232. //            opTanks.get(0).MoveDown();
  233. //        }else if(e.getKeyCode() == KeyEvent.VK_LEFT) {
  234. //            opTanks.get(0).setDirect(3);
  235. //            opTanks.get(0).MoveLeft();
  236. //        }
  237.  
  238.  
  239.         //如果玩家按下J键，我的坦克就会发出一个炮弹
  240.         if(e.getKeyCode() == KeyEvent.VK_J){
  241.             System.out.println("玩家按下了J键，开始射击！");
  242.  
  243.             myTank.shotOpTank();
  244.         }
  245.  
  246.         this.repaint();
  247.  
  248.     }
  249.  
  250.     @Override
  251.     public void keyReleased(KeyEvent e) {
  252.  
  253.     }
  254.  
  255.     @Override
  256.     public void run() {
  257.         while(true) {
  258.             try {
  259.                 Thread.sleep(100);
  260.             } catch (InterruptedException e) {
  261.                 e.printStackTrace();
  262.             }
  263.             //判断是否击中了敌人的坦克
  264.             if(myTank.shot != null && myTank.shot.isLive){
  265.                 for(int i=0;i<opTanks.size();i++){  //遍历敌人的所有坦克
  266.                     HitTank(myTank.shot,opTanks.get(i));
  267.                 }
  268.             }
  269.  
  270.  
  271.             this.repaint();
  272.         }
  273.     }
  274.  
  275.     //编写方法判断炮弹是否打中坦克
  276.     public void HitTank(Shot s,OpTank opTank){
  277.         //判断是否击中坦克
  278.         switch (opTank.getDirect()){
  279.             case 0: //敌人坦克向上的方向
  280.             case 2: //敌人坦克向下的方向
  281.                 if(s.x > opTank.getX() && s.x < opTank.getX() + 50 && s.y > opTank.getY() && s.y < opTank.getY() + 60){
  282.                     s.isLive = false;
  283.                     opTank.isLive = false;
  284.                 }
  285.                 break;
  286.             case 1: //敌人坦克向右的方向
  287.             case 3: //敌人坦克向左的方向
  288.                 if(s.x > opTank.getX() && s.x < opTank.getX() + 60 && s.y > opTank.getY() && s.y < opTank.getY() + 50){
  289.                     s.isLive = false;
  290.                     opTank.isLive = false;
  291.                     //当坦克被击中后将坦克从集合中移除
  292.                     opTanks.remove(opTank);
  293.                 }
  294.                 break;
  295.         }
  296.     }
  297.  
  298. }

3.坦克基类（Tank）

  1. package com.wak.TankGame01Version;
  2.  
  3. /*坦克的基类*/
  4. public class Tank {
  5.     private int x;  //坦克的横坐标
  6.     private int y;  //坦克的纵坐标
  7.     private int direct = 0; //坦克的方向
  8.     private int speed = 1;  //坦克的速度
  9.  
  10.     public Tank(){
  11.         this.x = 100;   //默认坦克的初始x坐标为100
  12.         this.y = 100;   //默认坦克的初始y坐标为100
  13.     }
  14.  
  15.     public Tank(int x,int y){   //自己设置坦克的初始x,y坐标
  16.         this.x = x;
  17.         this.y = y;
  18.     }
  19.  
  20.  
  21.     //设置坦克的x坐标
  22.     public void setX(int x){
  23.         this.x = x;
  24.     }
  25.  
  26.     //设置坦克的y坐标
  27.     public void setY(int y){
  28.         this.y = y;
  29.     }
  30.  
  31.     //获得坦克的x坐标
  32.     public int getX(){
  33.         return x;
  34.     }
  35.  
  36.     //获得坦克的y坐标
  37.     public int getY(){
  38.         return y;
  39.     }
  40.  
  41.     //设置坦克的方向
  42.     public void setDirect(int direct){
  43.         this.direct = direct;
  44.     }
  45.  
  46.     //获得坦克的方向
  47.     public int getDirect(){
  48.         return direct;
  49.     }
  50.  
  51.     //设置坦克的速度
  52.     public void setSpeed(int speed){
  53.         this.speed = speed;
  54.     }
  55.  
  56.     //获得坦克的速度
  57.     public int getSpeed(){
  58.         return speed;
  59.     }
  60.  
  61.     //坦克的上右下左移动
  62.     public void MoveUp(){
  63.         y -= speed;
  64.     }
  65.     public void MoveRight(){
  66.         x += speed;
  67.     }
  68.     public void MoveDown(){
  69.         y += speed;
  70.     }
  71.     public void MoveLeft(){
  72.         x -= speed;
  73.     }
  74. }
  75.  
  76.

4.我的坦克类(MyTank)

  1. package com.wak.TankGame01Version;
  2.  
  3. /*自己的坦克*/
  4. public class MyTank extends Tank{
  5.     //创建一个坦克
  6.     private MyTank myTank = null;
  7.  
  8.     Shot shot = null;
  9.     //设置坦克的初始化坐标
  10.     public MyTank(int x,int y){
  11.         this.setX(x);
  12.         this.setY(y);
  13.     }
  14.  
  15.     //射击
  16.     public void shotOpTank(){
  17.         //设置炮弹的初始化坐标及方向
  18.         switch (this.getDirect()){
  19.             case 0:
  20.                 shot = new Shot(this.getX() + 25,this.getY(),0);
  21.                 break;
  22.             case 1:
  23.                 shot = new Shot(this.getX() + 60,this.getY() + 25,1);
  24.                 break;
  25.             case 2:
  26.                 shot = new Shot(this.getX() + 25,this.getY() + 60,2);
  27.                 break;
  28.             case 3:
  29.                 shot = new Shot(this.getX(),this.getY() + 25,3);
  30.         }
  31.  
  32.  
  33.         //启动我们的Shot线程
  34.         new Thread(shot).start();
  35.     }
  36. }

5.敌方坦克类(OpTank)

  1. package com.wak.TankGame01Version;
  2.  
  3. import java.util.Vector;
  4.  
  5. public class OpTank extends Tank implements Runnable{
  6.     private OpTank opTank = null;   //创建一个敌方坦克
  7.     boolean isLive = true;   //敌方坦克的存活状态
  8.     Vector<Shot> shots = new Vector<>();    //存储多个炮弹
  9.  
  10.     public OpTank(int x,int y){
  11.         this.setX(x);
  12.         this.setY(y);
  13.     }
  14.  
  15.     @Override
  16.     public void run() {
  17.         while(true){
  18.             switch (this.getDirect()){
  19.                 case 0:
  20.                     for(int i=0;i<80;i++) {
  21.                         if (getY() > 0){
  22.                             MoveUp();
  23.                         }
  24.                         //休眠
  25.                         try {
  26.                             Thread.sleep(50);
  27.                         } catch (InterruptedException e) {
  28.                             e.printStackTrace();
  29.                         }
  30.                     }
  31.                     break;
  32.                 case 1:
  33.                     for (int i=0;i<80;i++){
  34.                         if(getX() + 60< 1000) {
  35.                             MoveRight();
  36.                         }
  37.                         //休眠
  38.                         try {
  39.                             Thread.sleep(50);
  40.                         } catch (InterruptedException e) {
  41.                             e.printStackTrace();
  42.                         }
  43.                     }
  44.                     break;
  45.                 case 2:
  46.                     for (int i=0;i<80;i++){
  47.                         if(getY() + 60 < 1000) {
  48.                             MoveDown();
  49.                         }
  50.                         //休眠
  51.                         try {
  52.                             Thread.sleep(50);
  53.                         } catch (InterruptedException e) {
  54.                             e.printStackTrace();
  55.                         }
  56.                     }
  57.                     break;
  58.                 case 3:
  59.                     for (int i=0;i<80;i++){
  60.                         if(getY() + 60 < 800) {
  61.                             MoveLeft();
  62.                         }
  63.                         //休眠
  64.                         try {
  65.                             Thread.sleep(50);
  66.                         } catch (InterruptedException e) {
  67.                             e.printStackTrace();
  68.                         }
  69.                     }
  70.                     break;
  71.             }
  72.             setDirect((int)(Math.random() * 4));
  73.             if(!isLive){
  74.                break;
  75.             }
  76.         }
  77.     }
  78. }

6.炮弹类（Shot）

  1. package com.wak.TankGame01Version;
  2.  
  3. public class Shot implements Runnable{
  4.     int x;  //子弹的x坐标
  5.     int y;  //子弹的y坐标
  6.     int direct = 0; //子弹的方向
  7.     int speed = 2;  //子弹的速度
  8.     boolean isLive = true;  //子弹的存活状态
  9.  
  10.     public Shot(int x,int y,int direct){
  11.         this.x = x;
  12.         this.y = y;
  13.         this.direct = direct;
  14.     }
  15.  
  16.     @Override
  17.     public void run() { //射击
  18.         while(isLive){
  19.             //休眠
  20.             try {
  21.                 Thread.sleep(50);
  22.             } catch (InterruptedException e) {
  23.                 e.printStackTrace();
  24.             }
  25.  
  26.             switch (direct){
  27.                 case 0: //向上
  28.                     y -= speed;
  29.                     break;
  30.                 case 1: //向右
  31.                     x += speed;
  32.                     break;
  33.                 case 2: //向下
  34.                     y += speed;
  35.                     break;
  36.                 case 3: //向左
  37.                     x -= speed;
  38.                     break;
  39.             }
  40.  
  41.             System.out.println("炮弹的x坐标：" + x + ",炮弹的y坐标：" + y);
  42.             //如果炮弹弹撞到墙壁，则销毁
  43.             //当炮弹碰到敌人坦克时，也应当结束
  44.             if(!(x >= 0 && x <= 1000 && y >=0 && y <= 800 && isLive)){
  45.                 isLive = false;
  46.                 System.out.println("炮弹已销毁");
  47.             }
  48.         }
  49.     }
  50. }

运行效果截图：

阶段三：

小总结：今天完成了，坦克发射多颗炮弹，敌方坦克移动发射，我方坦克被炮弹击中，防止敌方坦克重叠，记录玩家成绩，记录敌人坦克信息。今天觉得比较有创新的点就是防止坦克重叠，还是以坦克的一个点出发，从坐标出发，这样思路就很明确。今天的一个小插曲是，最后韩老师还教了一个继续上局游戏的操作，但是，这个视频中，我发现，有很多内容之前都没学过，但是我先跟着敲了（这就为后面埋下了一个伏笔），结果当我正式运行的时候，开始新的游戏，是正常的，除了对记录击毁多少个敌人的次数，是上一局继承下来的（我觉得这个问题后面可以用一个if语句进行，清零操作），但是，当我继续上局游戏时，运行出来，敌方的坦克全部消失，然后我就又重新看视频，找问题，改了几个地方，发现越改越错，当时脑子直接懵了，然后我就一直Ctrl-Z，还好，最后改回来了，我本来想把这个内容加上去的，但是我发现以我现在的能力，我可以把这个时间去用来写一些跟游戏更贴切的内容，比如现在运行出来只有我的坦克和对面坦克，还没有掩体等，坦克的速度，初始位置，以及炮弹的速度，都还没有进行调试，相比于那个，这才是重点，这也是明天的内容。今天新增了一个Recorder类和一个Node类（记录坦克的位置信息等，但是由于后面的内容我没有继续再写了，这个类也就相当于白建的）。

以下是今天的代码记录截图：

七个类 （根据英文应该能猜到各自对应什么）

1.主程序类（TankGame01）

  1. package com.wak.TankGame01Version;
  2.  
  3. import javax.swing.*;
  4. import java.awt.event.WindowAdapter;
  5. import java.awt.event.WindowEvent;
  6.  
  7. /*坦克大战游戏主程序*/
  8. public class TankGame01 extends JFrame {
  9.     public static void main(String[] args) {
  10.         //启动！
  11.         new TankGame01();
  12.     }
  13.  
  14.     //定义GamePanel，创建游戏环境
  15.     GamePanel gamePanel = null;
  16.  
  17.     //加载游戏环境
  18.     public TankGame01(){
  19.         //1.0版本
  20.         this.setTitle("坦克大战1.0");
  21.         //加载游戏环境
  22.         gamePanel = new GamePanel();
  23.         //将游戏区域加载到界面里
  24.         this.add(gamePanel);
  25.         //将游戏界面的炮弹线程加入到界面里
  26.         Thread thread = new Thread(gamePanel);
  27.         //启动子线程
  28.         thread.start();
  29.         //将键盘监听器加载到界面里
  30.         this.addKeyListener(gamePanel);
  31.         //设置界面可视化
  32.         this.setVisible(true);
  33.         //设置界面的大小
  34.         this.setSize(1400,950);
  35.         //设置界面可关闭
  36.         this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  37.  
  38.         //在JFrame中增加相应关闭窗口的处理
  39.         this.addWindowListener(new WindowAdapter() {
  40.             @Override
  41.             public void windowClosing(WindowEvent e) {
  42.                 Recorder.KeepRecord();
  43.                 System.exit(0);
  44.             }
  45.         });
  46.     }
  47.  
  48. }

2.游戏界面绘制类（GamePanel）

  1. package com.wak.TankGame01Version;
  2.  
  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;
  8.  
  9. /*坦克大战的绘图区域*/
  10.  
  11. //为了监听键盘事件，实现KeyListener
  12. //
  13. public class GamePanel extends JPanel implements KeyListener,Runnable{
  14.     //定义一个自己的坦克
  15.     MyTank myTank = null;
  16.     //创建敌方坦克
  17.     Vector<OpTank> opTanks = new Vector<>();
  18.     //定义一个存放Node对象的Vector，用于恢复敌方坦克的坐标和方向
  19.     Vector<Node> nodes = new Vector<>();
  20.     //设置敌方坦克数量
  21.     int opTanksSize = 6;
  22.  
  23.     public GamePanel(/*String key*/){
  24. //        Recorder.getNodesAndEnemyTankRec();
  25.         myTank = new MyTank(200,600);   //初始化坦克的位置
  26.         myTank.setSpeed(3); //设置坦克的速度
  27.  
  28.         //将GamePanel对象的 opTanks 设置给 Recorder 的 opTanks
  29.         Recorder.setOpTanks(opTanks);
  30.  
  31.  
  32.  
  33.         for(int i=0;i<opTanksSize;i++){
  34.             OpTank opTank = new OpTank((100 * i + 100),0);
  35.             opTank.setOpTanks(opTanks);
  36.             //设置方向
  37.             opTank.setDirect(2);
  38.             //启动敌人坦克线程
  39.             new Thread(opTank).start();
  40.             //给该opTank加入一颗炮弹
  41.             Shot shot = new Shot(opTank.getX() + 25,opTank.getY() + 60,2);
  42.             //存放到Vector中
  43.             opTank.shots.add(shot);
  44.             //启动线程对象
  45.             new Thread(shot).start();
  46.             //加入
  47.             opTanks.add(opTank);
  48.         }
  49.  
  50.     }
  51.  
  52.     //编写方法，显示我方击毁敌方坦克的信息
  53.     public void showInfo(Graphics g){
  54.         //画出玩家的总成绩
  55.         g.setColor(Color.BLACK);
  56.         Font font = new Font("宋体",Font.BOLD,25);
  57.         g.setFont(font);
  58.  
  59.         g.drawString("您累计击毁敌方坦克的数量",1020,30);
  60.         DrawTank(1020,60,g,0,1);
  61.         g.setColor(Color.BLACK);
  62.         g.drawString(Recorder.getAllOpTanksNum() + "",1080,100);
  63.     }
  64.  
  65.  
  66.  
  67.     @Override
  68.     public void paint(Graphics g) {
  69.         super.paint(g);
  70.         g.fillRect(0,0,1000,800);    //默认背景是黑色
  71.  
  72.         showInfo(g);
  73.         //画出坦克-封装方法
  74.         //画出我的坦克
  75.         if(myTank.isLive) {
  76.             DrawTank(myTank.getX(), myTank.getY(), g, myTank.getDirect(), 0);
  77.         }
  78.         //画出敌人的坦克
  79.         for(int i=0;i<opTanks.size();i++){
  80.             //取出敌方坦克
  81.             OpTank opTank = opTanks.get(i);
  82.             //判断敌方坦克是否存活
  83.             if(opTank.isLive) { //当敌人坦克是存活的时候，才去画
  84.                 DrawTank(opTank.getX(), opTank.getY(), g, opTank.getDirect(), 1);
  85.                 //画出敌人的坦克发出的炮弹
  86.                 for (int j = 0; j < opTank.shots.size(); j++) {
  87.                     //取出子弹
  88.                     Shot shot = opTank.shots.get(j);
  89.                     //绘制
  90.                     if (shot.isLive) {
  91.                         g.setColor(Color.WHITE);
  92.                         g.fill3DRect(shot.x, shot.y, 4, 4, false);
  93.                     } else {
  94.                         opTank.shots.remove(shot);
  95.                     }
  96.                 }
  97.             }
  98.  
  99.         }
  100.  
  101.         //画出我的坦克发出的炮弹
  102.         if(myTank.isLive) {
  103.             for (int i = 0; i < myTank.shots.size(); i++) {
  104.                 if (myTank.shots.get(i) != null && myTank.shots.get(i).isLive == true) {
  105.                     g.setColor(Color.CYAN);
  106.                     g.fill3DRect(myTank.shots.get(i).x, myTank.shots.get(i).y, 4, 4, false);
  107.                 } else {
  108.                     myTank.shots.remove(i);
  109.                 }
  110.             }
  111.         }
  112.  
  113.     }
  114.  
  115.     //编写方法，画出坦克
  116.  
  117.     /**
  118.      *
  119.      * @param x 坦克的x坐标
  120.      * @param y 坦克的y坐标
  121.      * @param g 画笔
  122.      * @param direct    坦克方向（上下左右）
  123.      * @param type  坦克类型
  124.      */
  125.     public void DrawTank(int x,int y,Graphics g,int direct,int type){
  126.         //坦克的类型
  127.         switch (type){
  128.             case 0: //自己的坦克
  129.                 g.setColor(Color.CYAN);
  130.                 break;
  131.             case 1: //敌人的坦克
  132.                 g.setColor(Color.RED);
  133.                 break;
  134.         }
  135.  
  136.         switch (direct){
  137.             case 0: //表示向上
  138.                 g.fill3DRect(x,y,10,60,false);  //坦克的左边轮子
  139.                 g.drawLine(x,y + 10,x + 10,y + 10); //坦克左轮的履带
  140.                 g.drawLine(x,y + 20,x + 10,y + 20);
  141.                 g.drawLine(x,y + 30,x + 10,y + 30);
  142.                 g.drawLine(x,y + 40,x + 10,y + 40);
  143.                 g.drawLine(x,y + 50,x + 10,y + 50);
  144.  
  145.                 g.fill3DRect(x + 40,y,10,60,false); //坦克的右边轮子
  146.                 g.drawLine(x + 40,y + 10,x + 50,y + 10);     //坦克右轮的履带
  147.                 g.drawLine(x + 40,y + 20,x + 50,y + 20);
  148.                 g.drawLine(x + 40,y + 30,x + 50,y + 30);
  149.                 g.drawLine(x + 40,y + 40,x + 50,y + 40);
  150.                 g.drawLine(x + 40,y + 50,x + 50,y + 50);
  151.  
  152.                 g.fill3DRect(x + 10,y + 10,30,40,false);    //坦克的身体
  153.                 g.fillOval(x + 10,y + 15,30,30);    //坦克的炮盖
  154.                 g.drawLine(x + 25,y + 30,x + 25,y); //坦克的炮筒
  155.                 break;
  156.  
  157.             case 1: //表示向右
  158.                 g.fill3DRect(x,y,60,10,false);  //坦克左边的轮子
  159.                 g.drawLine(x + 10,y,x + 10 ,y + 10);    //坦克左轮的履带
  160.                 g.drawLine(x + 20,y,x + 20 ,y + 10);
  161.                 g.drawLine(x + 30,y,x + 30 ,y + 10);
  162.                 g.drawLine(x + 40,y,x + 40 ,y + 10);
  163.                 g.drawLine(x + 50,y,x + 50 ,y + 10);
  164.  
  165.  
  166.                 g.fill3DRect(x,y + 40,60,10,false); //坦克右边的轮子
  167.                 g.drawLine(x + 10,y + 40,x + 10,y + 50);
  168.                 g.drawLine(x + 20,y + 40,x + 20,y + 50);
  169.                 g.drawLine(x + 30,y + 40,x + 30,y + 50);
  170.                 g.drawLine(x + 40,y + 40,x + 40,y + 50);
  171.                 g.drawLine(x + 50,y + 40,x + 50,y + 50);
  172.  
  173.  
  174.                 g.fill3DRect( x + 10,y + 10,40,30,false);   //坦克的身体
  175.                 g.fillOval(x + 15,y + 10,30,30);    //坦克的炮盖
  176.                 g.drawLine(x + 30,y + 25,x +60,y + 25); //坦克的炮筒
  177.                 break;
  178.  
  179.             case 2: //表示向下
  180.                 g.fill3DRect(x,y,10,60,false);  //坦克的左边轮子
  181.                 g.drawLine(x,y + 10,x + 10,y + 10); //坦克左轮的履带
  182.                 g.drawLine(x,y + 20,x + 10,y + 20);
  183.                 g.drawLine(x,y + 30,x + 10,y + 30);
  184.                 g.drawLine(x,y + 40,x + 10,y + 40);
  185.                 g.drawLine(x,y + 50,x + 10,y + 50);
  186.  
  187.                 g.fill3DRect(x + 40,y,10,60,false); //坦克的右边轮子
  188.                 g.drawLine(x + 40,y + 10,x + 50,y + 10);    //坦克右轮的履带
  189.                 g.drawLine(x + 40,y + 20,x + 50,y + 20);
  190.                 g.drawLine(x + 40,y + 30,x + 50,y + 30);
  191.                 g.drawLine(x + 40,y + 40,x + 50,y + 40);
  192.                 g.drawLine(x + 40,y + 50,x + 50,y + 50);
  193.  
  194.                 g.fill3DRect(x + 10,y + 10,30,40,false);    //坦克的身体
  195.                 g.fillOval(x + 10,y + 15,30,30);    //坦克的炮盖
  196.                 g.drawLine(x + 25,y + 30,x + 25,y + 60); //坦克的炮筒
  197.                 break;
  198.  
  199.             case 3: //表示向左
  200.                 g.fill3DRect(x,y,60,10,false);  //坦克左边的轮子
  201.                 g.drawLine(x + 10,y,x + 10 ,y + 10);    //坦克左轮的履带
  202.                 g.drawLine(x + 20,y,x + 20 ,y + 10);
  203.                 g.drawLine(x + 30,y,x + 30 ,y + 10);
  204.                 g.drawLine(x + 40,y,x + 40 ,y + 10);
  205.                 g.drawLine(x + 50,y,x + 50 ,y + 10);
  206.  
  207.  
  208.                 g.fill3DRect(x,y + 40,60,10,false); //坦克右边的轮子
  209.                 g.drawLine(x + 10,y + 40,x + 10,y + 50);
  210.                 g.drawLine(x + 20,y + 40,x + 20,y + 50);
  211.                 g.drawLine(x + 30,y + 40,x + 30,y + 50);
  212.                 g.drawLine(x + 40,y + 40,x + 40,y + 50);
  213.                 g.drawLine(x + 50,y + 40,x + 50,y + 50);
  214.  
  215.  
  216.                 g.fill3DRect( x + 10,y + 10,40,30,false);   //坦克的身体
  217.                 g.fillOval(x + 15,y + 10,30,30);    //坦克的炮盖
  218.                 g.drawLine(x + 30,y + 25,x,y + 25); //坦克的炮筒
  219.                 break;
  220.  
  221.             default:
  222.                 System.out.println("暂时没有处理");
  223.         }
  224.     }
  225.  
  226.     @Override
  227.     public void keyTyped(KeyEvent e) {
  228.  
  229.     }
  230.  
  231.     @Override
  232.     public void keyPressed(KeyEvent e) {    //控制键盘WDSA键，操控我的坦克上右下左移动
  233.         if(e.getKeyCode() == KeyEvent.VK_W){
  234.             myTank.setDirect(0);
  235.             if(myTank.getY() > 0) {
  236.                 myTank.MoveUp();
  237.             }
  238.         }else if(e.getKeyCode() == KeyEvent.VK_D){
  239.             myTank.setDirect(1);
  240.             if(myTank.getX() + 60 < 1000) {
  241.                 myTank.MoveRight();
  242.             }
  243.         }else if(e.getKeyCode() == KeyEvent.VK_S){
  244.             myTank.setDirect(2);
  245.             if(myTank.getY() + 60 < 800) {
  246.                 myTank.MoveDown();
  247.             }
  248.         }else if(e.getKeyCode() == KeyEvent.VK_A){
  249.             myTank.setDirect(3);
  250.             if(myTank.getX() + 60 > 0) {
  251.                 myTank.MoveLeft();
  252.             }
  253.         }
  254. //        else if(e.getKeyCode() == KeyEvent.VK_UP){
  255. //            opTanks.get(0).setDirect(0);
  256. //            opTanks.get(0).MoveUp();
  257. //        }else if(e.getKeyCode() == KeyEvent.VK_RIGHT){
  258. //            opTanks.get(0).setDirect(1);
  259. //            opTanks.get(0).MoveRight();
  260. //        }else if(e.getKeyCode() == KeyEvent.VK_DOWN){
  261. //            opTanks.get(0).setDirect(2);
  262. //            opTanks.get(0).MoveDown();
  263. //        }else if(e.getKeyCode() == KeyEvent.VK_LEFT) {
  264. //            opTanks.get(0).setDirect(3);
  265. //            opTanks.get(0).MoveLeft();
  266. //        }
  267.  
  268.  
  269.         //如果玩家按下J键，我的坦克就会发出一个炮弹
  270.         if(e.getKeyCode() == KeyEvent.VK_J){
  271. //            System.out.println("玩家按下了J键，开始射击！");
  272. //            if(myTank.shot == null || myTank.shot.isLive == false) {    //当坦克只能发射一颗炮弹时，先判断
  273. //                myTank.shotOpTank();
  274. //            }
  275.             myTank.shotOpTank();
  276.         }
  277.  
  278.         this.repaint();
  279.  
  280.     }
  281.  
  282.     @Override
  283.     public void keyReleased(KeyEvent e) {
  284.  
  285.     }
  286.  
  287.     @Override
  288.     public void run() {
  289.         while(true) {
  290.             try {
  291.                 Thread.sleep(100);
  292.             } catch (InterruptedException e) {
  293.                 e.printStackTrace();
  294.             }
  295.             //判断是否击中了敌人的坦克
  296.             for(int j=0;j<myTank.shots.size();j++) {
  297.                 if (myTank.shots.get(j) != null && myTank.shots.get(j).isLive) {
  298.                     for (int i = 0; i < opTanks.size(); i++) {  //遍历敌人的所有坦克
  299.                         HitTank(myTank.shots.get(j), opTanks.get(i));
  300.                     }
  301.                 }
  302.             }
  303.             HitMyTank();
  304.             this.repaint();
  305.         }
  306.     }
  307.  
  308.     //编写方法判断敌方坦克的炮弹是否打中我的坦克
  309.     public void HitMyTank(){
  310.         for(int i=0;i<opTanks.size();i++){
  311.             for(int j=0;j<opTanks.get(i).shots.size();j++){
  312.                 if(myTank.isLive && opTanks.get(i).shots.get(j).isLive){
  313.                     HitTank(opTanks.get(i).shots.get(j),myTank);
  314.                 }
  315.             }
  316.         }
  317.     }
  318.  
  319.  
  320.     //编写方法判断炮弹是否打中坦克
  321.     public void HitTank(Shot s,Tank opTank){
  322.         //判断是否击中坦克
  323.         switch (opTank.getDirect()){
  324.             case 0: //敌人坦克向上的方向
  325.             case 2: //敌人坦克向下的方向
  326.                 if(s.x > opTank.getX() && s.x < opTank.getX() + 50 && s.y > opTank.getY() && s.y < opTank.getY() + 60){
  327.                     s.isLive = false;
  328.                     opTank.isLive = false;
  329.                     //当坦克被击中后将坦克从集合中移除
  330.                     opTanks.remove(opTank);
  331.                     //解读，因为opTank可以是没有Tank，也可以是opTank
  332.                     if(opTank instanceof OpTank){
  333.                         Recorder.addAllOpTanksNum();
  334.                     }
  335.                 }
  336.                 break;
  337.             case 1: //敌人坦克向右的方向
  338.             case 3: //敌人坦克向左的方向
  339.                 if(s.x > opTank.getX() && s.x < opTank.getX() + 60 && s.y > opTank.getY() && s.y < opTank.getY() + 50){
  340.                     s.isLive = false;
  341.                     opTank.isLive = false;
  342.                     //当坦克被击中后将坦克从集合中移除
  343.                     opTanks.remove(opTank);
  344.                     //解读，因为opTank可以是没有Tank，也可以是opTank
  345.                     if(opTank instanceof OpTank){
  346.                         Recorder.addAllOpTanksNum();
  347.                     }
  348.                 }
  349.                 break;
  350.         }
  351.     }
  352.  
  353. }

3.坦克基类（Tank）

  1. package com.wak.TankGame01Version;
  2.  
  3. /*坦克的基类*/
  4. public class Tank {
  5.     private int x;  //坦克的横坐标
  6.     private int y;  //坦克的纵坐标
  7.     private int direct = 0; //坦克的方向
  8.     private int speed = 1;  //坦克的速度
  9.     boolean isLive = true;      //坦克的存活状态
  10.  
  11.     public Tank(){
  12.         this.x = 100;   //默认坦克的初始x坐标为100
  13.         this.y = 100;   //默认坦克的初始y坐标为100
  14.     }
  15.  
  16.     public Tank(int x,int y){   //自己设置坦克的初始x,y坐标
  17.         this.x = x;
  18.         this.y = y;
  19.     }
  20.  
  21.  
  22.     //设置坦克的x坐标
  23.     public void setX(int x){
  24.         this.x = x;
  25.     }
  26.  
  27.     //设置坦克的y坐标
  28.     public void setY(int y){
  29.         this.y = y;
  30.     }
  31.  
  32.     //获得坦克的x坐标
  33.     public int getX(){
  34.         return x;
  35.     }
  36.  
  37.     //获得坦克的y坐标
  38.     public int getY(){
  39.         return y;
  40.     }
  41.  
  42.     //设置坦克的方向
  43.     public void setDirect(int direct){
  44.         this.direct = direct;
  45.     }
  46.  
  47.     //获得坦克的方向
  48.     public int getDirect(){
  49.         return direct;
  50.     }
  51.  
  52.     //设置坦克的速度
  53.     public void setSpeed(int speed){
  54.         this.speed = speed;
  55.     }
  56.  
  57.     //获得坦克的速度
  58.     public int getSpeed(){
  59.         return speed;
  60.     }
  61.  
  62.     //坦克的上右下左移动
  63.     public void MoveUp(){
  64.         y -= speed;
  65.     }
  66.     public void MoveRight(){
  67.         x += speed;
  68.     }
  69.     public void MoveDown(){
  70.         y += speed;
  71.     }
  72.     public void MoveLeft(){
  73.         x -= speed;
  74.     }
  75. }
  76.  
  77.

4.我的坦克类(MyTank)

  1. package com.wak.TankGame01Version;
  2.  
  3. import java.util.Vector;
  4.  
  5. /*自己的坦克*/
  6. public class MyTank extends Tank{
  7.  
  8.     //创建一个坦克
  9.     private MyTank myTank = null;
  10.  
  11.     //定义一个shot对象，表示一个射击（线程）
  12.     Shot shot = null;
  13.     //创建一个存储炮弹的集合
  14.     Vector<Shot> shots = new Vector<>();
  15.     //设置坦克的初始化坐标
  16.     public MyTank(int x,int y){
  17.         this.setX(x);
  18.         this.setY(y);
  19.     }
  20.  
  21.     //射击
  22.     public void shotOpTank(){
  23.         //设置炮弹的初始化坐标及方向
  24.         if(shots.size() < 5) {
  25.             switch (this.getDirect()) {
  26.                 case 0:
  27.                     shot = new Shot(this.getX() + 25, this.getY(), 0);
  28.                     break;
  29.                 case 1:
  30.                     shot = new Shot(this.getX() + 60, this.getY() + 25, 1);
  31.                     break;
  32.                 case 2:
  33.                     shot = new Shot(this.getX() + 25, this.getY() + 60, 2);
  34.                     break;
  35.                 case 3:
  36.                     shot = new Shot(this.getX(), this.getY() + 25, 3);
  37.             }
  38.         //将发射的炮弹弹存入集合中
  39.  
  40.             shots.add(shot);
  41.         }
  42.         //启动我们的Shot线程
  43.         new Thread(shot).start();
  44.  
  45.     }
  46. }

5.敌方坦克类(OpTank)

  1. package com.wak.TankGame01Version;
  2.  
  3. import java.util.Vector;
  4.  
  5. public class OpTank extends Tank implements Runnable{
  6.     private OpTank opTank = null;   //创建一个敌方坦克
  7.     Vector<Shot> shots = new Vector<>();    //存储多个炮弹
  8.     Vector<OpTank> opTanks = new Vector<>();    //增加成员，可以得到敌人坦克的Vector集合
  9.     public OpTank(int x,int y){
  10.         this.setX(x);
  11.         this.setY(y);
  12.     }
  13.  
  14.     public void setOpTanks(Vector<OpTank> opTanks){
  15.         this.opTanks = opTanks;
  16.     }
  17.  
  18.     public boolean isTouchOpTank(){
  19.         //判断当前敌人坦克的方向
  20.         switch (this.getDirect()){
  21.             case 0: //上
  22.                 for(int j=0;j<opTanks.size();j++){
  23.                     //取出一个敌方坦克
  24.                     OpTank o = opTanks.get(j);
  25.                     if(o != this){  //不能跟自己比
  26.                         //如果敌人是向上或者向下
  27.                         if(o.getDirect() == 0 || o.getDirect() == 2){
  28.                             //当前坦克左上角的坐标
  29.                             if(this.getX() >= o.getX()
  30.                                     && this.getX() <= o.getX() + 50
  31.                                     && this.getY() <= o.getY() + 60
  32.                                     && this.getY() >= o.getY()){
  33.                                 return true;
  34.                             }
  35.                             //当前坦克右上角的坐标
  36.                             if(this.getX() + 50 >= o.getX()
  37.                                     && this.getX() + 50<= o.getX() + 50
  38.                                     && this.getY() <= o.getY() + 60
  39.                                     && this.getY() >= o.getY()){
  40.                              return true;
  41.                             }
  42.                         }
  43.                         //如果敌人是向右或者向左
  44.                         if(o.getDirect() == 1 || o.getDirect() == 3){
  45.                             //当前坦克左上角的坐标
  46.                             if(this.getX() >= o.getX()
  47.                                     && this.getX() <= o.getX() + 60
  48.                                     && this.getY() >= o.getY()
  49.                                     && this.getY() <= o.getY() + 50){
  50.                                 return true;
  51.                             }
  52.                             //当前坦克右上角的坐标
  53.                             if(this.getX() + 50>= o.getX()
  54.                                     && this.getX() + 50<= o.getX() + 60
  55.                                     && this.getY() >= o.getY()
  56.                                     && this.getY() <= o.getY() + 50){
  57.                                 return true;
  58.                             }
  59.                         }
  60.                     }
  61.                 }
  62.                 break;
  63.             case 1: //右
  64.                 for(int j=0;j<opTanks.size();j++){
  65.                     //取出一辆坦克
  66.                     OpTank o = opTanks.get(j);
  67.                     if(o != this){  //不能跟自己比
  68.                         //如果敌方坦克是向上或向下
  69.                         if(o.getDirect() == 0 || o.getDirect() == 2){
  70.                             //当前坦克右上角的坐标
  71.                             if(this.getX() + 60 >= o.getX()
  72.                                     && this.getX() + 60 <= o.getX() + 50
  73.                                     && this.getY() >= o.getY()
  74.                                     && this.getY() <= o.getY() + 60){
  75.                                 return true;
  76.                             }
  77.                             //当前坦克右下角的坐标
  78.                             if(this.getX() + 60 >= o.getX()
  79.                                     && this.getX() + 60 <= o.getX() + 50
  80.                                     && this.getY() + 50 >= o.getY()
  81.                                     && this.getY() + 50 <= o.getY() + 60){
  82.                                 return true;
  83.                             }
  84.                         }
  85.                         //如果敌方坦克是向右或向左
  86.                         if(o.getDirect() == 1 || o.getDirect() == 3){
  87.                             //当前坦克右上角的坐标
  88.                             if(this.getX() + 60 >= o.getX()
  89.                                     && this.getX() + 60 <= o.getX() + 60
  90.                                     && this.getY() >= o.getY()
  91.                                     && this.getY() <= o.getY() + 50){
  92.                                 return true;
  93.                             }
  94.                             //当前坦克右下角的坐标
  95.                             if(this.getX() + 60 >= o.getX()
  96.                                     && this.getX() + 60 <= o.getX() + 60
  97.                                     && this.getY() + 50 >= o.getY()
  98.                                     && this.getY() + 50 <= o.getY() + 50){
  99.                                 return true;
  100.                             }
  101.                         }
  102.                     }
  103.                 }
  104.                 break;
  105.             case 2: //下
  106.                 for(int j=0;j<opTanks.size();j++){
  107.                     //取出一辆坦克
  108.                     OpTank o = opTanks.get(j);
  109.                     if(o != this){  //不能跟自己比
  110.                         //如果敌方坦克是向上或向下
  111.                         if(o.getDirect() == 0 || o.getDirect() == 2){
  112.                             //当前坦克左下角的坐标
  113.                             if(this.getX() >= o.getX()
  114.                                     && this.getX() <= o.getX() + 60
  115.                                     && this.getY() + 60 >= o.getY()
  116.                                     && this.getY() + 60 <= o.getY()){
  117.                                 return true;
  118.                             }
  119.                             //当前坦克右下角的坐标
  120.                             if(this.getX() + 50>= o.getX()
  121.                                     && this.getX() + 50 <= o.getX() + 60
  122.                                     && this.getY() + 60 >= o.getY()
  123.                                     && this.getY() + 60 <= o.getY()){
  124.                                 return true;
  125.                             }
  126.                         }
  127.                         //如果敌方坦克是向右或向左
  128.                         if(o.getDirect() == 1 || o.getDirect() == 3){
  129.                             //当前坦克左下角的坐标
  130.                             if(this.getX() >= o.getX()
  131.                                     && this.getX() + 60 <= o.getX() + 60
  132.                                     && this.getY() >= o.getY()
  133.                                     && this.getY() + 50 <= o.getY() + 50){
  134.                                 return true;
  135.                             }
  136.                             //当前坦克右下角的坐标
  137.                             if(this.getX() + 50 >= o.getX()
  138.                                     && this.getX() + 50 <= o.getX() + 60
  139.                                     && this.getY() + 60 >= o.getY()
  140.                                     && this.getY() + 60 <= o.getY() + 50){
  141.                                 return true;
  142.                             }
  143.                         }
  144.                     }
  145.                 }
  146.                 break;
  147.             case 3: //左
  148.                 for(int j=0;j<opTanks.size();j++){
  149.                     //取出一辆坦克
  150.                     OpTank o = opTanks.get(j);
  151.                     if(o != this){  //不能跟自己比
  152.                         //如果敌方坦克是向上或向下
  153.                         if(o.getDirect() == 0 || o.getDirect() == 2){
  154.                             //当前坦克左上角的坐标
  155.                             if(this.getX() >= o.getX()
  156.                                     && this.getX() <= o.getX() + 60
  157.                                     && this.getY() >= o.getY()
  158.                                     && this.getY() <= o.getY()){
  159.                                 return true;
  160.                             }
  161.                             //当前坦克左下角的坐标
  162.                             if(this.getX() >= o.getX()
  163.                                     && this.getX() <= o.getX() + 60
  164.                                     && this.getY() + 50 >= o.getY()
  165.                                     && this.getY() + 50 <= o.getY()){
  166.                                 return true;
  167.                             }
  168.                         }
  169.                         //如果敌方坦克是向右或向左
  170.                         if(o.getDirect() == 1 || o.getDirect() == 3){
  171.                             //当前坦克左上角的坐标
  172.                             if(this.getX() >= o.getX()
  173.                                     && this.getX() <= o.getX() + 60
  174.                                     && this.getY() >= o.getY()
  175.                                     && this.getY() <= o.getY() + 50){
  176.                                 return true;
  177.                             }
  178.                             //当前坦克左下角的坐标
  179.                             if(this.getX() >= o.getX()
  180.                                     && this.getX() <= o.getX() + 60
  181.                                     && this.getY() + 50 >= o.getY()
  182.                                     && this.getY() + 50 <= o.getY() + 50){
  183.                                 return true;
  184.                             }
  185.                         }
  186.                     }
  187.                 }
  188.                 break;
  189.         }
  190.         return false;
  191.     }
  192.  
  193.     @Override
  194.     public void run() {
  195.         while(true){
  196.  
  197.             //这里判断坦克的方向，创建对应的炮弹
  198.             if(isLive && shots.size() < 6){
  199.                 Shot s = null;
  200.                 switch (getDirect()){
  201.                     case 0:
  202.                         s = new Shot(getX() + 25,getY(),0);
  203.                         break;
  204.                     case 1:
  205.                         s = new Shot(getX() + 60,getY() + 25,1);
  206.                         break;
  207.                     case 2:
  208.                         s = new Shot(getX() + 25,getY() + 60,2);
  209.                         break;
  210.                     case 3:
  211.                         s = new Shot(getX(),getY() + 25,3);
  212.                         break;
  213.                 }
  214.  
  215.                 //每隔1秒发射一个炮弹
  216.                 try {
  217.                     Thread.sleep(2000);
  218.                 } catch (InterruptedException e) {
  219.                     e.printStackTrace();
  220.                 }
  221.  
  222.                 shots.add(s);
  223.  
  224.                 new Thread(s).start();
  225.             }
  226.             //坦克移动的方向
  227.             switch (this.getDirect()){
  228.                 case 0:
  229.                     for(int i=0;i<80;i++) {
  230.                         if (getY() > 0 && !isTouchOpTank()){
  231.                             MoveUp();
  232.                         }
  233.                         //休眠
  234.                         try {
  235.                             Thread.sleep(50);
  236.                         } catch (InterruptedException e) {
  237.                             e.printStackTrace();
  238.                         }
  239.                     }
  240.                     break;
  241.                 case 1:
  242.                     for (int i=0;i<80;i++){
  243.                         if(getX() + 60< 1000 && !isTouchOpTank()) {
  244.                             MoveRight();
  245.                         }
  246.                         //休眠
  247.                         try {
  248.                             Thread.sleep(50);
  249.                         } catch (InterruptedException e) {
  250.                             e.printStackTrace();
  251.                         }
  252.                     }
  253.                     break;
  254.                 case 2:
  255.                     for (int i=0;i<80;i++){
  256.                         if(getY() + 60 < 800 && !isTouchOpTank()) {
  257.                             MoveDown();
  258.                         }
  259.                         //休眠
  260.                         try {
  261.                             Thread.sleep(50);
  262.                         } catch (InterruptedException e) {
  263.                             e.printStackTrace();
  264.                         }
  265.                     }
  266.                     break;
  267.                 case 3:
  268.                     for (int i=0;i<80;i++){
  269.                         if(getX() > 0 && !isTouchOpTank()) {
  270.                             MoveLeft();
  271.                         }
  272.                         //休眠
  273.                         try {
  274.                             Thread.sleep(50);
  275.                         } catch (InterruptedException e) {
  276.                             e.printStackTrace();
  277.                         }
  278.                     }
  279.                     break;
  280.             }
  281.             setDirect((int)(Math.random() * 4));
  282.             if(!isLive){
  283.                break;
  284.             }
  285.         }
  286.     }
  287. }

6.炮弹类（Shot）

  1. package com.wak.TankGame01Version;
  2.  
  3. public class Shot implements Runnable{
  4.     int x;  //子弹的x坐标
  5.     int y;  //子弹的y坐标
  6.     int direct = 0; //子弹的方向
  7.     int speed = 2;  //子弹的速度
  8.     boolean isLive = true;  //子弹的存活状态
  9.  
  10.     public Shot(int x,int y,int direct){
  11.         this.x = x;
  12.         this.y = y;
  13.         this.direct = direct;
  14.     }
  15.  
  16.     @Override
  17.     public void run() { //射击
  18.         while(isLive){
  19.             //休眠
  20.             try {
  21.                 Thread.sleep(50);
  22.             } catch (InterruptedException e) {
  23.                 e.printStackTrace();
  24.             }
  25.  
  26.             switch (direct){
  27.                 case 0: //向上
  28.                     y -= speed;
  29.                     break;
  30.                 case 1: //向右
  31.                     x += speed;
  32.                     break;
  33.                 case 2: //向下
  34.                     y += speed;
  35.                     break;
  36.                 case 3: //向左
  37.                     x -= speed;
  38.                     break;
  39.             }
  40.  
  41.             System.out.println("炮弹的x坐标：" + x + ",炮弹的y坐标：" + y);
  42.             //如果炮弹弹撞到墙壁，则销毁
  43.             //当炮弹碰到敌人坦克时，也应当结束
  44.             if(!(x >= 0 && x <= 1000 && y >=0 && y <= 800 && isLive)){
  45.                 isLive = false;
  46.                 System.out.println("炮弹已销毁");
  47.             }
  48.         }
  49.     }
  50. }

7.记录信息类（Recorder）

  1. package com.wak.TankGame01Version;
  2.  
  3. import java.awt.*;
  4. import java.io.*;
  5. import java.util.Vector;
  6.  
  7. public class Recorder {
  8.     private static int allOpTanksNum = 0;
  9.     //定义IO对象，准备写数据到文件中
  10.     private static FileWriter fw = null;
  11.     private static BufferedWriter bw = null;
  12.     private static BufferedReader br = null;
  13.     private static String recordFile = "D:\\myTankGameRecord.txt";
  14.     //定义Vec，指向GamePanel对象的 敌人坦克Vector
  15.     private static Vector<OpTank> opTanks = null;
  16.     //定义一个Node 的Vector，用于保存敌人的信息node
  17.     private static Vector<Node> nodes = new Vector<>();
  18.  
  19.     public static void setOpTanks(Vector<OpTank> opTanks){
  20.         Recorder.opTanks = opTanks;
  21.     }
  22.  
  23.     public static int getAllOpTanksNum(){
  24.         return allOpTanksNum;
  25.     }
  26.  
  27.     public static void setAllOpTanksNum(int allOpTanksNum){
  28.         Recorder.allOpTanksNum = allOpTanksNum;
  29.     }
  30.  
  31.  
  32.     //当我方坦克击毁一个敌人坦克，就应当allOpTanksNum++
  33.     public static void addAllOpTanksNum(){
  34.         Recorder.allOpTanksNum++;
  35.     }
  36.  
  37.     //增加一个方法，当游戏退出时，我们将allOpTanksNum保存到recordFile
  38.     //对KeepRecord方法进行升级，保存敌人坦克的坐标和方向
  39.     public static void KeepRecord(){
  40.         try {
  41.             bw = new BufferedWriter((new FileWriter((recordFile))));
  42.             bw.write(allOpTanksNum + "\r\n");
  43.             //遍历敌人坦克的Vector，然后根据情况保存即可
  44.             for(int i=0;i<opTanks.size();i++){
  45.                 //取出敌人坦克
  46.                 OpTank o = opTanks.get(i);
  47.                 if(o.isLive){
  48.                     //保存该opTank的信息
  49.                     String record = o.getX() + " " + o.getY() + " " + o.getDirect();
  50.                     //写入到文件
  51.                     bw.write(record + "\r\n");
  52.                 }
  53.             }
  54.         } catch (IOException e) {
  55.             e.printStackTrace();
  56.         }finally {
  57.             if (bw != null) {
  58.                 try {
  59.                     bw.close();
  60.                 } catch (IOException e) {
  61.                     e.printStackTrace();
  62.                 }
  63.             }
  64.         }
  65.     }
  66.  
  67. //    //增加一个方法，用于读取recordFile，恢复相关信息
  68. //    public static Vector<Node> getNodesAndEnemyTankRec(){
  69. //        try {
  70. //            br = new BufferedReader(new FileReader(recordFile));
  71. //
  72. //        } catch (FileNotFoundException e) {
  73. //            e.printStackTrace();
  74. //        }finally {
  75. //
  76. //        }
  77. //        return null;
  78. //    }
  79. }

运行效果截图：

阶段四：

小总结：今天完成了界面画面的布置，包括画了一条小河，草地，和障碍物（墙体），以及坦克碰到障碍物会停止前进，炮弹打到墙壁会销毁。今天真的是写这个项目这么久来，让我最印象深刻的一次今天，我在写完障碍物，遇到一个问题（当时没有截图或者录视频保存下来，可惜的是），就是我在离界面顶部Y坐标为100的位置时，坦克只会在这个Y坐标为0到100的范围内移动，于是我就觉得很奇怪，然后我就强制让他们只能朝下移动，结果发现，到了Y坐标等于100这个线的时候，所有的坦克全都不动了，只是发射炮弹，不会再继续往下移动。我又重新看了一遍我的方法，没有问题，于是我只好找学长求助，因为当我让他们自由可以改变方向移动时，他们能突破Y坐标为100的这条我暂且称之为“诡异线”，因为学长们对我的代码也不是特别熟悉，所以他们也没有给出一个正确答案，然后我就去找我之前的大四室友（已经在苏宁易购工作了），在通过测试时，我们发现一个问题，因为我是设置的六个坦克，从左到右依次排开，初始化他们是先向下移动的，当移动完之后，有一个坦克正好碰到了障碍物，而其他的没有，于是我们就猜测是不是这个影响了其他坦克，于是我们就把这个前面是障碍物的坦克删除掉，但是还是不行，我们最后只测试一个，发现这个坦克就可以突破这个“诡异线”，于是我想到了，就算把那个正好碰到坦克的障碍物删除，但是有一个坦克的右下角，与障碍物的一个角挨着了，因为我的判断是够与墙壁碰撞的判断条件，是写的大于等于，或者小于等于，就是这个等号，让代码运行过程有问题，后来总结出，尤其是在写这种游戏时，有的边界条件不能卡的太死，要不然就会出问题，因为这个毕竟是像素块，说不定就有个时候，越过了这个边界，然后就卡住了。但是由于是第一次写，还有很多知识点没有完全掌握好，所以当解决完这个问题后，整个人真的是，或许这就是代码的魅力吧！

以下是今天的代码记录截图：

七个类（根据英文应该能猜到各自对应什么）

 

1.主程序类（TankGame01）

  1. package com.wak.TankGame01Version;
  2.  
  3. import javax.swing.*;
  4. import java.awt.event.WindowAdapter;
  5. import java.awt.event.WindowEvent;
  6.  
  7. /*坦克大战游戏主程序*/
  8. public class TankGame01 extends JFrame {
  9.     public static void main(String[] args) {
  10.         //启动！
  11.         new TankGame01();
  12.     }
  13.  
  14.     //定义GamePanel，创建游戏环境
  15.     GamePanel gamePanel = null;
  16.  
  17.     //加载游戏环境
  18.     public TankGame01(){
  19.         //1.0版本
  20.         this.setTitle("坦克大战1.0");
  21.         //加载游戏环境
  22.         gamePanel = new GamePanel();
  23.         //将游戏区域加载到界面里
  24.         this.add(gamePanel);
  25.         //将游戏界面的炮弹线程加入到界面里
  26.         Thread thread = new Thread(gamePanel);
  27.         //启动子线程
  28.         thread.start();
  29.         //将键盘监听器加载到界面里
  30.         this.addKeyListener(gamePanel);
  31.         //设置界面可视化
  32.         this.setVisible(true);
  33.         //设置界面的大小
  34.         this.setSize(1600,950);
  35.         //设置界面可关闭
  36.         this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  37.  
  38.         //在JFrame中增加相应关闭窗口的处理
  39.         this.addWindowListener(new WindowAdapter() {
  40.             @Override
  41.             public void windowClosing(WindowEvent e) {
  42.                 Recorder.KeepRecord();
  43.                 System.exit(0);
  44.             }
  45.         });
  46.     }
  47.  
  48. }

 

2.游戏界面绘制类（GamePanel）

  1. package com.wak.TankGame01Version;
  2.  
  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;
  8.  
  9. /*坦克大战的绘图区域*/
  10.  
  11. //为了监听键盘事件，实现KeyListener
  12. //
  13. public class GamePanel extends JPanel implements KeyListener,Runnable{
  14.     //定义一个自己的坦克
  15.     MyTank myTank = null;
  16.     //创建敌方坦克
  17.     Vector<OpTank> opTanks = new Vector<>();
  18.     //定义一个存放Node对象的Vector，用于恢复敌方坦克的坐标和方向
  19.     Vector<Node> nodes = new Vector<>();
  20.     //设置敌方坦克数量
  21.     int opTanksSize = 6;
  22.  
  23.     public GamePanel(/*String key*/){
  24. //        Recorder.getNodesAndEnemyTankRec();
  25.         myTank = new MyTank(580,810);   //初始化我的坦克的位置
  26.         myTank.setSpeed(3); //设置我的坦克的速度
  27. //        myTank.shot.setShotSpeed(5);    //设置我的坦克的炮弹的速度
  28.  
  29.         //将GamePanel对象的 opTanks 设置给 Recorder 的 opTanks
  30.         Recorder.setOpTanks(opTanks);
  31.  
  32.  
  33.         //初始化敌方坦克
  34.         for(int i=0;i<opTanksSize;i++){
  35.             OpTank opTank = new OpTank((200 * i + 90),0);
  36.             opTank.setOpTanks(opTanks);
  37.             //设置方向
  38.             opTank.setDirect(2);
  39.             //设置敌人坦克的速度
  40.             opTank.setSpeed(1);
  41.             //启动敌人坦克线程
  42.             new Thread(opTank).start();
  43.             //给该opTank加入一颗炮弹
  44.             Shot shot = new Shot(opTank.getX() + 25,opTank.getY() + 60,2);
  45.             //存放到Vector中
  46.             opTank.shots.add(shot);
  47.             //启动线程对象
  48.             new Thread(shot).start();
  49.             //加入
  50.             opTanks.add(opTank);
  51.         }
  52.  
  53.     }
  54.  
  55.     //编写方法，显示我方击毁敌方坦克的信息
  56.     public void showInfo(Graphics g){
  57.         //画出玩家的总成绩
  58.         g.setColor(Color.BLACK);
  59.         Font font = new Font("宋体",Font.BOLD,25);
  60.         g.setFont(font);
  61.  
  62.         g.drawString("您累计击毁敌方坦克的数量",1220,30);
  63.         DrawTank(1220,60,g,0,1);
  64.         g.setColor(Color.BLACK);
  65.         g.drawString(Recorder.getAllOpTanksNum() + "",1280,100);
  66.     }
  67.  
  68.  
  69.  
  70.     @Override
  71.     public void paint(Graphics g) {
  72.         super.paint(g);
  73.         g.fillRect(0,0,1200,900);    //默认背景是黑色
  74.  
  75.         //设置背景为蓝色，代表河流
  76.         g.setColor(Color.cyan);
  77.         g.fill3DRect(100,400,1000,200,false);
  78.  
  79.         //设置背景为绿色，代表草地
  80.         g.setColor(Color.GREEN);
  81.         for(int i=0;i<7;i++) {
  82.             g.fill3DRect(15 * i,100,5,600,false);
  83.             g.fill3DRect(1100 + 15 * i,100,5,600,false);
  84.         }
  85.         for(int i=0;i<41;i++) {
  86.             g.fill3DRect(0,100 + 15 * i,95,5,false);
  87.             g.fill3DRect(1100,100 + 15 * i,95,5,false);
  88.         }
  89.  
  90.         //设置背景为亮灰色，代表墙体
  91.         g.setColor(Color.LIGHT_GRAY);
  92.  
  93.         g.fill3DRect(500,660,200,50,false);
  94.         for(int i=1;i<5;i++) {
  95.             g.drawLine(500, 660 + i*10, 700, 660 + i*10);
  96.         }
  97.         for(int i=1;i<20;i++){
  98.             g.drawLine(500 + i*10,660,500 + i*10,710);
  99.         }
  100.  
  101.         g.fill3DRect(260,660,60,130,false);
  102.         for(int i=1;i<6;i++){
  103.             g.drawLine(260 + i*10,660,260 + i*10,790);
  104.         }
  105.         for(int i=1;i<13;i++){
  106.             g.drawLine(260,660 + i*10,320,660 + i*10);
  107.         }
  108.  
  109.         g.fill3DRect(880,660,60,130,false);
  110.         for(int i=1;i<6;i++){
  111.             g.drawLine(880 + i*10,660,880 + i*10,790);
  112.         }
  113.         for(int i=1;i<13;i++){
  114.             g.drawLine(880,660 + i*10,940,660 + i*10);
  115.         }
  116.  
  117.         g.fill3DRect(350,100,60,240,false);
  118.         for(int i=1;i<6;i++){
  119.             g.drawLine(350 + i*10,100,350 + i*10,340);
  120.         }
  121.         for(int i=1;i<24;i++){
  122.             g.drawLine(350,100 + i*10,410,100 + i*10);
  123.         }
  124.  
  125.         g.fill3DRect(790,100,60,240,false);
  126.         for(int i=1;i<6;i++){
  127.             g.drawLine(790 + i*10,100,790 + i*10,340);
  128.         }
  129.         for(int i=1;i<24;i++){
  130.             g.drawLine(790,100 + i*10,850,100 + i*10);
  131.         }
  132.  
  133.         g.fill3DRect(550,160,100,100,false);
  134.         for(int i=1;i<10;i++){
  135.             g.drawLine(550 + i*10,160 ,550 + i*10,260);
  136.         }
  137.         for(int i=1;i<10;i++){
  138.             g.drawLine(550,160 + i*10,650,160 + i*10);
  139.         }
  140.  
  141. //        g.fill3DRect(160,100,130,60,false);
  142. //        for(int i=1;i<13;i++){
  143. //            g.drawLine(160 + i*10,100,160 + i*10,160);
  144. //        }
  145. //        for(int i=1;i<6;i++){
  146. //            g.drawLine(160,100 + i*10,290,100 + i*10);
  147. //        }
  148.  
  149. //        g.fill3DRect(910,100,130,60,false);
  150. //        for(int i=1;i<13;i++){
  151. //            g.drawLine(910 + i*10,100,910 + i*10,160);
  152. //        }
  153. //        for(int i=1;i<6;i++){
  154. //            g.drawLine(910,100 + i*10,1040,100 + i*10);
  155. //        }
  156.  
  157.  
  158.         showInfo(g);
  159.         //画出坦克-封装方法
  160.         //画出我的坦克
  161.         if(myTank.isLive) {
  162.             DrawTank(myTank.getX(), myTank.getY(), g, myTank.getDirect(), 0);
  163.         }
  164.         //画出敌人的坦克
  165.         for(int i=0;i<opTanks.size();i++){
  166.             //取出敌方坦克
  167.             OpTank opTank = opTanks.get(i);
  168.             //判断敌方坦克是否存活
  169.             if(opTank.isLive) { //当敌人坦克是存活的时候，才去画
  170.                 DrawTank(opTank.getX(), opTank.getY(), g, opTank.getDirect(), 1);
  171.                 //画出敌人的坦克发出的炮弹
  172.                 for (int j = 0; j < opTank.shots.size(); j++) {
  173.                     //取出子弹
  174.                     Shot shot = opTank.shots.get(j);
  175.                     //绘制
  176.                     if (shot.isLive) {
  177.                         g.setColor(Color.RED);
  178.                         g.fill3DRect(shot.x, shot.y, 4, 4, true);
  179.                     } else {
  180.                         opTank.shots.remove(shot);
  181.                     }
  182.                 }
  183.             }
  184.  
  185.         }
  186.  
  187.         //画出我的坦克发出的炮弹
  188.         if(myTank.isLive) {
  189.             for (int i = 0; i < myTank.shots.size(); i++) {
  190.                 if (myTank.shots.get(i) != null && myTank.shots.get(i).isLive == true) {
  191.                     g.setColor(Color.YELLOW);
  192.                     g.fill3DRect(myTank.shots.get(i).x, myTank.shots.get(i).y, 4, 4, false);
  193.                 } else {
  194.                     myTank.shots.remove(i);
  195.                 }
  196.             }
  197.         }
  198.  
  199.     }
  200.  
  201.     //编写方法，画出坦克
  202.  
  203.     /**
  204.      *
  205.      * @param x 坦克的x坐标
  206.      * @param y 坦克的y坐标
  207.      * @param g 画笔
  208.      * @param direct    坦克方向（上下左右）
  209.      * @param type  坦克类型
  210.      */
  211.     public void DrawTank(int x,int y,Graphics g,int direct,int type){
  212.         //坦克的类型
  213.         switch (type){
  214.             case 0: //自己的坦克
  215.                 g.setColor(Color.PINK);
  216.                 break;
  217.             case 1: //敌人的坦克
  218.                 g.setColor(Color.RED);
  219.                 break;
  220.         }
  221.  
  222.         switch (direct){
  223.             case 0: //表示向上
  224.                 g.fill3DRect(x,y,10,60,false);  //坦克的左边轮子
  225.                 g.drawLine(x,y + 10,x + 10,y + 10); //坦克左轮的履带
  226.                 g.drawLine(x,y + 20,x + 10,y + 20);
  227.                 g.drawLine(x,y + 30,x + 10,y + 30);
  228.                 g.drawLine(x,y + 40,x + 10,y + 40);
  229.                 g.drawLine(x,y + 50,x + 10,y + 50);
  230.  
  231.                 g.fill3DRect(x + 40,y,10,60,false); //坦克的右边轮子
  232.                 g.drawLine(x + 40,y + 10,x + 50,y + 10);     //坦克右轮的履带
  233.                 g.drawLine(x + 40,y + 20,x + 50,y + 20);
  234.                 g.drawLine(x + 40,y + 30,x + 50,y + 30);
  235.                 g.drawLine(x + 40,y + 40,x + 50,y + 40);
  236.                 g.drawLine(x + 40,y + 50,x + 50,y + 50);
  237.  
  238.                 g.fill3DRect(x + 10,y + 10,30,40,false);    //坦克的身体
  239.                 g.fillOval(x + 10,y + 15,30,30);    //坦克的炮盖
  240.                 g.drawLine(x + 25,y + 30,x + 25,y); //坦克的炮筒
  241.                 break;
  242.  
  243.             case 1: //表示向右
  244.                 g.fill3DRect(x,y,60,10,false);  //坦克左边的轮子
  245.                 g.drawLine(x + 10,y,x + 10 ,y + 10);    //坦克左轮的履带
  246.                 g.drawLine(x + 20,y,x + 20 ,y + 10);
  247.                 g.drawLine(x + 30,y,x + 30 ,y + 10);
  248.                 g.drawLine(x + 40,y,x + 40 ,y + 10);
  249.                 g.drawLine(x + 50,y,x + 50 ,y + 10);
  250.  
  251.  
  252.                 g.fill3DRect(x,y + 40,60,10,false); //坦克右边的轮子
  253.                 g.drawLine(x + 10,y + 40,x + 10,y + 50);
  254.                 g.drawLine(x + 20,y + 40,x + 20,y + 50);
  255.                 g.drawLine(x + 30,y + 40,x + 30,y + 50);
  256.                 g.drawLine(x + 40,y + 40,x + 40,y + 50);
  257.                 g.drawLine(x + 50,y + 40,x + 50,y + 50);
  258.  
  259.  
  260.                 g.fill3DRect( x + 10,y + 10,40,30,false);   //坦克的身体
  261.                 g.fillOval(x + 15,y + 10,30,30);    //坦克的炮盖
  262.                 g.drawLine(x + 30,y + 25,x +60,y + 25); //坦克的炮筒
  263.                 break;
  264.  
  265.             case 2: //表示向下
  266.                 g.fill3DRect(x,y,10,60,false);  //坦克的左边轮子
  267.                 g.drawLine(x,y + 10,x + 10,y + 10); //坦克左轮的履带
  268.                 g.drawLine(x,y + 20,x + 10,y + 20);
  269.                 g.drawLine(x,y + 30,x + 10,y + 30);
  270.                 g.drawLine(x,y + 40,x + 10,y + 40);
  271.                 g.drawLine(x,y + 50,x + 10,y + 50);
  272.  
  273.                 g.fill3DRect(x + 40,y,10,60,false); //坦克的右边轮子
  274.                 g.drawLine(x + 40,y + 10,x + 50,y + 10);    //坦克右轮的履带
  275.                 g.drawLine(x + 40,y + 20,x + 50,y + 20);
  276.                 g.drawLine(x + 40,y + 30,x + 50,y + 30);
  277.                 g.drawLine(x + 40,y + 40,x + 50,y + 40);
  278.                 g.drawLine(x + 40,y + 50,x + 50,y + 50);
  279.  
  280.                 g.fill3DRect(x + 10,y + 10,30,40,false);    //坦克的身体
  281.                 g.fillOval(x + 10,y + 15,30,30);    //坦克的炮盖
  282.                 g.drawLine(x + 25,y + 30,x + 25,y + 60); //坦克的炮筒
  283.                 break;
  284.  
  285.             case 3: //表示向左
  286.                 g.fill3DRect(x,y,60,10,false);  //坦克左边的轮子
  287.                 g.drawLine(x + 10,y,x + 10 ,y + 10);    //坦克左轮的履带
  288.                 g.drawLine(x + 20,y,x + 20 ,y + 10);
  289.                 g.drawLine(x + 30,y,x + 30 ,y + 10);
  290.                 g.drawLine(x + 40,y,x + 40 ,y + 10);
  291.                 g.drawLine(x + 50,y,x + 50 ,y + 10);
  292.  
  293.  
  294.                 g.fill3DRect(x,y + 40,60,10,false); //坦克右边的轮子
  295.                 g.drawLine(x + 10,y + 40,x + 10,y + 50);
  296.                 g.drawLine(x + 20,y + 40,x + 20,y + 50);
  297.                 g.drawLine(x + 30,y + 40,x + 30,y + 50);
  298.                 g.drawLine(x + 40,y + 40,x + 40,y + 50);
  299.                 g.drawLine(x + 50,y + 40,x + 50,y + 50);
  300.  
  301.  
  302.                 g.fill3DRect( x + 10,y + 10,40,30,false);   //坦克的身体
  303.                 g.fillOval(x + 15,y + 10,30,30);    //坦克的炮盖
  304.                 g.drawLine(x + 30,y + 25,x,y + 25); //坦克的炮筒
  305.                 break;
  306.  
  307.             default:
  308.                 System.out.println("暂时没有处理");
  309.         }
  310.     }
  311.  
  312.     @Override
  313.     public void keyTyped(KeyEvent e) {
  314.  
  315.     }
  316.  
  317.     @Override
  318.     public void keyPressed(KeyEvent e) {    //控制键盘WDSA键，操控我的坦克上右下左移动
  319.         if(e.getKeyCode() == KeyEvent.VK_W){
  320.             myTank.setDirect(0);
  321.             if(myTank.getY() > 0 && !isMyTankTouchWall()) {
  322.                 myTank.MoveUp();
  323.             }
  324.         }else if(e.getKeyCode() == KeyEvent.VK_D){
  325.             myTank.setDirect(1);
  326.             if(myTank.getX() + 60 < 1200 && !isMyTankTouchWall()) {
  327.                 myTank.MoveRight();
  328.             }
  329.         }else if(e.getKeyCode() == KeyEvent.VK_S){
  330.             myTank.setDirect(2);
  331.             if(myTank.getY() + 60 < 900 && !isMyTankTouchWall()) {
  332.                 myTank.MoveDown();
  333.             }
  334.         }else if(e.getKeyCode() == KeyEvent.VK_A){
  335.             myTank.setDirect(3);
  336.             if(myTank.getX() + 60 > 0 && !isMyTankTouchWall()) {
  337.                 myTank.MoveLeft();
  338.             }
  339.         }
  340. //        else if(e.getKeyCode() == KeyEvent.VK_UP){
  341. //            opTanks.get(0).setDirect(0);
  342. //            opTanks.get(0).MoveUp();
  343. //        }else if(e.getKeyCode() == KeyEvent.VK_RIGHT){
  344. //            opTanks.get(0).setDirect(1);
  345. //            opTanks.get(0).MoveRight();
  346. //        }else if(e.getKeyCode() == KeyEvent.VK_DOWN){
  347. //            opTanks.get(0).setDirect(2);
  348. //            opTanks.get(0).MoveDown();
  349. //        }else if(e.getKeyCode() == KeyEvent.VK_LEFT) {
  350. //            opTanks.get(0).setDirect(3);
  351. //            opTanks.get(0).MoveLeft();
  352. //        }
  353.  
  354.  
  355.  
  356.  
  357.         //如果玩家按下J键，我的坦克就会发出一个炮弹
  358.         if(e.getKeyCode() == KeyEvent.VK_J){
  359. //            System.out.println("玩家按下了J键，开始射击！");
  360. //            if(myTank.shot == null || myTank.shot.isLive == false) {    //当坦克只能发射一颗炮弹时，先判断
  361. //                myTank.shotOpTank();
  362. //            }
  363.             myTank.shotOpTank();
  364.         }
  365.  
  366.         this.repaint();
  367.  
  368.     }
  369.  
  370.     @Override
  371.     public void keyReleased(KeyEvent e) {
  372.  
  373.     }
  374.  
  375.     @Override
  376.     public void run() {
  377.         while(true) {
  378.             try {
  379.                 Thread.sleep(100);
  380.             } catch (InterruptedException e) {
  381.                 e.printStackTrace();
  382.             }
  383.             //判断是否击中了敌人的坦克
  384.             for(int j=0;j<myTank.shots.size();j++) {
  385.                 if (myTank.shots.get(j) != null && myTank.shots.get(j).isLive) {
  386.                     for (int i = 0; i < opTanks.size(); i++) {  //遍历敌人的所有坦克
  387.                         HitTank(myTank.shots.get(j), opTanks.get(i));
  388.                     }
  389.                 }
  390.             }
  391.             HitMyTank();
  392.             this.repaint();
  393.         }
  394.     }
  395.  
  396.     //编写方法判断敌方坦克的炮弹是否打中我的坦克
  397.     public void HitMyTank(){
  398.         for(int i=0;i<opTanks.size();i++){
  399.             for(int j=0;j<opTanks.get(i).shots.size();j++){
  400.                 if(myTank.isLive && opTanks.get(i).shots.get(j).isLive){
  401.                     HitTank(opTanks.get(i).shots.get(j),myTank);
  402.                 }
  403.             }
  404.         }
  405.     }
  406.  
  407.  
  408.     //编写方法判断炮弹是否打中坦克
  409.     public void HitTank(Shot s,Tank opTank){
  410.         //判断是否击中坦克
  411.         switch (opTank.getDirect()){
  412.             case 0: //敌人坦克向上的方向
  413.             case 2: //敌人坦克向下的方向
  414.                 if(s.x > opTank.getX() && s.x < opTank.getX() + 50 && s.y > opTank.getY() && s.y < opTank.getY() + 60){
  415.                     s.isLive = false;
  416.                     opTank.isLive = false;
  417.                     //当坦克被击中后将坦克从集合中移除
  418.                     opTanks.remove(opTank);
  419.                     //解读，因为opTank可以是没有Tank，也可以是opTank
  420.                     if(opTank instanceof OpTank){
  421.                         Recorder.addAllOpTanksNum();
  422.                     }
  423.                 }
  424.                 break;
  425.             case 1: //敌人坦克向右的方向
  426.             case 3: //敌人坦克向左的方向
  427.                 if(s.x > opTank.getX() && s.x < opTank.getX() + 60 && s.y > opTank.getY() && s.y < opTank.getY() + 50){
  428.                     s.isLive = false;
  429.                     opTank.isLive = false;
  430.                     //当坦克被击中后将坦克从集合中移除
  431.                     opTanks.remove(opTank);
  432.                     //解读，因为opTank可以是没有Tank，也可以是opTank
  433.                     if(opTank instanceof OpTank){
  434.                         Recorder.addAllOpTanksNum();
  435.                     }
  436.                 }
  437.                 break;
  438.         }
  439.     }
  440.  
  441.     //判断我方坦克是否触碰到了墙壁
  442.     public boolean isMyTankTouchWall(){
  443.         //判断敌人当前的方向
  444.         switch (myTank.getDirect()){
  445.             case 0: //向上
  446.                 if(myTank.getX() > 500 && myTank.getX() < 700 && myTank.getY() > 660 && myTank.getY() < 710
  447. //                            || o.getX() > 160 && o.getX() <= 290 && o.getY() > 100 && o.getY() <= 160
  448. //                            || o.getX() > 910 && o.getX() <= 1040 && o.getY() > 100 && o.getY() <= 160
  449.                         || myTank.getX() > 550 && myTank.getX() < 650 && myTank.getY() > 160 && myTank.getY() < 260
  450.                         || myTank.getX() > 790 && myTank.getX() < 850 && myTank.getY() > 100 && myTank.getY() < 160
  451.                         || myTank.getX() > 350 && myTank.getX() < 410 && myTank.getY() > 100 && myTank.getY() < 340
  452.                         || myTank.getX() > 880 && myTank.getX() < 940 && myTank.getY() > 660 && myTank.getY() < 790
  453.                         || myTank.getX() > 260 && myTank.getX() < 320 && myTank.getY() > 660 && myTank.getY() < 790){
  454.                     return true;
  455.                 }
  456.                 //当前坦克的右上角坐标
  457.                 if(myTank.getX() + 50 > 500 && myTank.getX() + 50 < 700 && myTank.getY() > 660 && myTank.getY() < 710
  458. //                            || o.getX() + 50 >= 160 && o.getX() + 50 <= 290 && o.getY() >= 100 && o.getY() <= 160
  459. //                            || o.getX() + 50 >= 910 && o.getX() + 50 <= 1040 && o.getY() >= 100 && o.getY() <= 160
  460.                         || myTank.getX() + 50 > 550 && myTank.getX() + 50 < 650 && myTank.getY() > 160 && myTank.getY() < 260
  461.                         || myTank.getX() + 50 > 790 && myTank.getX() + 50 < 850 && myTank.getY() > 100 && myTank.getY() < 160
  462.                         || myTank.getX() + 50 > 350 && myTank.getX() + 50 < 410 && myTank.getY() > 100 && myTank.getY() < 340
  463.                         || myTank.getX() + 50 > 880 && myTank.getX() + 50 < 940 && myTank.getY() > 660 && myTank.getY() < 790
  464.                         || myTank.getX() + 50 > 260 && myTank.getX() + 50 < 320 && myTank.getY() > 660 && myTank.getY() < 790) {
  465.                     return true;
  466.                 }
  467.                 break;
  468.             case 1: //向右
  469.                 //当前坦克的右上角坐标
  470.                 if (myTank.getX() + 60 > 500 && myTank.getX() + 60 < 700 && myTank.getY() > 660 && myTank.getY() < 710
  471. //                            || o.getX() + 60 >= 160 && o.getX() + 60 <= 290 && o.getY() >= 100 && o.getY() <= 160
  472. //                            || o.getX() + 60 >= 910 && o.getX() + 60 <= 1040 && o.getY() >= 100 && o.getY() <= 160
  473.                         || myTank.getX() + 60 > 550 && myTank.getX() + 60 < 650 && myTank.getY() > 160 && myTank.getY() < 260
  474.                         || myTank.getX() + 60 > 790 && myTank.getX() + 60 < 850 && myTank.getY() > 100 && myTank.getY() < 160
  475.                         || myTank.getX() + 60 > 350 && myTank.getX() + 60 < 410 && myTank.getY() > 100 && myTank.getY() < 340
  476.                         || myTank.getX() + 60 > 880 && myTank.getX() + 60 < 940 && myTank.getY() > 660 && myTank.getY() < 790
  477.                         || myTank.getX() + 60 > 260 && myTank.getX() + 60 < 320 && myTank.getY() > 660 && myTank.getY() < 790){
  478.                     return true;
  479.                 }
  480.                 //当前坦克的右下角坐标
  481.                 if(myTank.getX() + 60 > 500 && myTank.getX() + 60 < 700 && myTank.getY() + 50 > 660 && myTank.getY() + 50 < 710
  482. //                            || o.getX() + 60 >= 160 && o.getX() + 60 <= 290 && o.getY() + 50 >= 100 && o.getY() + 50 <= 160
  483. //                            || o.getX() + 60 >= 910 && o.getX() + 60 <= 1040 && o.getY() + 50 >= 100 && o.getY() + 50 <= 160
  484.                         || myTank.getX() + 60 > 550 && myTank.getX() + 60 < 650 && myTank.getY() + 50 > 160 && myTank.getY() + 50 < 260
  485.                         || myTank.getX() + 60 > 790 && myTank.getX() + 60 < 850 && myTank.getY() + 50 > 100 && myTank.getY() + 50 < 160
  486.                         || myTank.getX() + 60 > 350 && myTank.getX() + 60 < 410 && myTank.getY() + 50 > 100 && myTank.getY() + 50 < 340
  487.                         || myTank.getX() + 60 > 880 && myTank.getX() + 60 < 940 && myTank.getY() + 50 > 660 && myTank.getY() + 50 < 790
  488.                         || myTank.getX() + 60 > 260 && myTank.getX() + 60 < 320 && myTank.getY() + 50 > 660 && myTank.getY() + 50 < 790){
  489.                     return true;
  490.                 }
  491.                 break;
  492.             case 2: //向下
  493.                 //当前坦克的左下角坐标
  494.                 if(myTank.getX() > 500 && myTank.getX() < 700 && myTank.getY() + 60 > 660 && myTank.getY() + 60 < 710
  495. //                            || o.getX() >= 160 && o.getX() <= 290 && o.getY() + 60 >= 100 && o.getY() + 60 <= 160
  496. //                            || o.getX() >= 910 && o.getX() <= 1040 && o.getY() + 60 >= 100 && o.getY() + 60 <= 160
  497.                         || myTank.getX() > 550 && myTank.getX() < 650 && myTank.getY() + 60 > 160 && myTank.getY() + 60 < 260
  498.                         || myTank.getX() > 790 && myTank.getX() < 850 && myTank.getY() + 60 > 100 && myTank.getY() + 60 < 160
  499.                         || myTank.getX() > 350 && myTank.getX() < 410 && myTank.getY() + 60 > 100 && myTank.getY() + 60 < 340
  500.                         || myTank.getX() > 880 && myTank.getX() < 940 && myTank.getY() + 60 > 660 && myTank.getY() + 60 < 790
  501.                         || myTank.getX() > 260 && myTank.getX() < 320 && myTank.getY() + 60 > 660 && myTank.getY() + 60 < 790){
  502.                     return true;
  503.                 }
  504.                 //当前坦克的右下角坐标
  505.                 if(myTank.getX() + 50 > 500 && myTank.getX() + 50 < 700 && myTank.getY() + 60 > 660 && myTank.getY() + 60 < 710
  506. //                            || o.getX() + 50 >= 160 && o.getX() + 50 <= 290 && o.getY() + 60 >= 100 && o.getY() + 60 <= 160
  507. //                            || o.getX() + 50 >= 910 && o.getX() + 50 <= 1040 && o.getY() + 60 >= 100 && o.getY() + 60 <= 160
  508.                         || myTank.getX() + 50 > 550 && myTank.getX() + 50 < 650 && myTank.getY() + 60 > 160 && myTank.getY() + 60 < 260
  509.                         || myTank.getX() + 50 > 790 && myTank.getX() + 50 < 850 && myTank.getY() + 60 > 100 && myTank.getY() + 60 < 160
  510.                         || myTank.getX() + 50 > 350 && myTank.getX() + 50 < 410 && myTank.getY() + 60 > 100 && myTank.getY() + 60 < 340
  511.                         || myTank.getX() + 50 > 880 && myTank.getX() + 50 < 940 && myTank.getY() + 60 > 660 && myTank.getY() + 60 < 790
  512.                         || myTank.getX() + 50 > 260 && myTank.getX() + 50 < 320 && myTank.getY() + 60 > 660 && myTank.getY() + 60 < 790){
  513.                     return true;
  514.                 }
  515.                 break;
  516.             case 3: //向左
  517.                 //当前坦克的左上角坐标
  518.                 if(myTank.getX() > 500 && myTank.getX() < 700 && myTank.getY() > 660 && myTank.getY() < 710
  519. //                            || o.getX() >= 160 && o.getX() <= 290 && o.getY() >= 100 && o.getY() <= 160
  520. //                            || o.getX() >= 910 && o.getX() <= 1040 && o.getY() >= 100 && o.getY() <= 160
  521.                         || myTank.getX() > 550 && myTank.getX() < 650 && myTank.getY() > 160 && myTank.getY() < 260
  522.                         || myTank.getX() > 790 && myTank.getX() < 850 && myTank.getY() > 100 && myTank.getY() < 160
  523.                         || myTank.getX() > 350 && myTank.getX() < 410 && myTank.getY() > 100 && myTank.getY() < 340
  524.                         || myTank.getX() > 880 && myTank.getX() < 940 && myTank.getY() > 660 && myTank.getY() < 790
  525.                         || myTank.getX() > 260 && myTank.getX() < 320 && myTank.getY() > 660 && myTank.getY() < 790){
  526.                     return true;
  527.                 }
  528.                 //当前坦克的左下角坐标
  529.                 if(myTank.getX() > 500 && myTank.getX() < 700 && myTank.getY() + 50 > 660 && myTank.getY() + 50 < 710
  530.                         || myTank.getX() > 160 && myTank.getX() < 290 && myTank.getY() + 50 > 100 && myTank.getY() + 50 < 160
  531.                         || myTank.getX() > 910 && myTank.getX() < 1040 && myTank.getY() + 50 > 100 && myTank.getY() + 50 < 160
  532.                         || myTank.getX() > 550 && myTank.getX() < 650 && myTank.getY() + 50 > 160 && myTank.getY() + 50 < 260
  533.                         || myTank.getX() > 790 && myTank.getX() < 850 && myTank.getY() + 50 > 100 && myTank.getY() + 50 < 160
  534.                         || myTank.getX() > 350 && myTank.getX() < 410 && myTank.getY() + 50 > 100 && myTank.getY() + 50 < 340
  535.                         || myTank.getX() > 880 && myTank.getX() < 940 && myTank.getY() + 50 > 660 && myTank.getY() + 50 < 790
  536.                         || myTank.getX() > 260 && myTank.getX() < 320 && myTank.getY() + 50 > 660 && myTank.getY() + 50 < 790){
  537.                     return true;
  538.                 }
  539.                 break;
  540.         }
  541.         return false;
  542.     }
  543.  
  544. }

3.坦克基类（Tank）

  1. package com.wak.TankGame01Version;
  2.  
  3. /*坦克的基类*/
  4. public class Tank {
  5.     private int x;  //坦克的横坐标
  6.     private int y;  //坦克的纵坐标
  7.     private int direct = 0; //坦克的方向
  8.     private int speed = 1;  //坦克的速度
  9.     boolean isLive = true;      //坦克的存活状态
  10.  
  11.     public Tank(){
  12.         this.x = 100;   //默认坦克的初始x坐标为100
  13.         this.y = 100;   //默认坦克的初始y坐标为100
  14.     }
  15.  
  16.     public Tank(int x,int y){   //自己设置坦克的初始x,y坐标
  17.         this.x = x;
  18.         this.y = y;
  19.     }
  20.  
  21.  
  22.     //设置坦克的x坐标
  23.     public void setX(int x){
  24.         this.x = x;
  25.     }
  26.  
  27.     //设置坦克的y坐标
  28.     public void setY(int y){
  29.         this.y = y;
  30.     }
  31.  
  32.     //获得坦克的x坐标
  33.     public int getX(){
  34.         return x;
  35.     }
  36.  
  37.     //获得坦克的y坐标
  38.     public int getY(){
  39.         return y;
  40.     }
  41.  
  42.     //设置坦克的方向
  43.     public void setDirect(int direct){
  44.         this.direct = direct;
  45.     }
  46.  
  47.     //获得坦克的方向
  48.     public int getDirect(){
  49.         return direct;
  50.     }
  51.  
  52.     //设置坦克的速度
  53.     public void setSpeed(int speed){
  54.         this.speed = speed;
  55.     }
  56.  
  57.     //获得坦克的速度
  58.     public int getSpeed(){
  59.         return speed;
  60.     }
  61.  
  62.     //坦克的上右下左移动
  63.     public void MoveUp(){
  64.         y -= speed;
  65.     }
  66.     public void MoveRight(){
  67.         x += speed;
  68.     }
  69.     public void MoveDown(){
  70.         y += speed;
  71.     }
  72.     public void MoveLeft(){
  73.         x -= speed;
  74.     }
  75. }
  76.  
  77.

4.我的坦克类(MyTank)

  1. package com.wak.TankGame01Version;
  2.  
  3. import java.util.Vector;
  4.  
  5. /*自己的坦克*/
  6. public class MyTank extends Tank{
  7.  
  8.     //创建一个坦克
  9.     private MyTank myTank = null;
  10.  
  11.     //定义一个shot对象，表示一个射击（线程）
  12.     Shot shot = null;
  13.     //创建一个存储炮弹的集合
  14.     Vector<Shot> shots = new Vector<>();
  15.     //设置坦克的初始化坐标
  16.     public MyTank(int x,int y){
  17.         this.setX(x);
  18.         this.setY(y);
  19.     }
  20.  
  21.     //射击
  22.     public void shotOpTank(){
  23.         //设置炮弹的初始化坐标及方向
  24.         if(shots.size() < 5) {
  25.             switch (this.getDirect()) {
  26.                 case 0:
  27.                     shot = new Shot(this.getX() + 25, this.getY(), 0);
  28.                     shot.speed = 4;
  29.                     break;
  30.                 case 1:
  31.                     shot = new Shot(this.getX() + 60, this.getY() + 25, 1);
  32.                     shot.speed = 4;
  33.                     break;
  34.                 case 2:
  35.                     shot = new Shot(this.getX() + 25, this.getY() + 60, 2);
  36.                     shot.speed = 4;
  37.                     break;
  38.                 case 3:
  39.                     shot = new Shot(this.getX(), this.getY() + 25, 3);
  40.                     shot.speed = 4;
  41.                     break;
  42.             }
  43.         //将发射的炮弹弹存入集合中
  44.  
  45.             shots.add(shot);
  46.         }
  47.         //启动我们的Shot线程
  48.         new Thread(shot).start();
  49.  
  50.     }
  51. }

5.敌方坦克类(OpTank)

  1. package com.wak.TankGame01Version;
  2.  
  3. import java.util.Vector;
  4.  
  5. public class OpTank extends Tank implements Runnable{
  6.     private OpTank opTank = null;   //创建一个敌方坦克
  7.     Vector<Shot> shots = new Vector<>();    //存储多个炮弹
  8.     Vector<OpTank> opTanks = new Vector<>();    //增加成员，可以得到敌人坦克的Vector集合
  9.     public OpTank(int x,int y){
  10.         this.setX(x);
  11.         this.setY(y);
  12.     }
  13.  
  14.     public void setOpTanks(Vector<OpTank> opTanks){
  15.         this.opTanks = opTanks;
  16.     }
  17.  
  18.     public boolean isTouchOpTank(){ //防止坦克间重叠
  19.         //判断当前敌人坦克的方向
  20.         switch (this.getDirect()){
  21.             case 0: //上
  22.                 for(int j=0;j<opTanks.size();j++){
  23.                     //取出一个敌方坦克
  24.                     OpTank o = opTanks.get(j);
  25.                     if(o != this){  //不能跟自己比
  26.                         //如果敌人是向上或者向下
  27.                         if(o.getDirect() == 0 || o.getDirect() == 2){
  28.                             //当前坦克左上角的坐标
  29.                             if(this.getX() >= o.getX()
  30.                                     && this.getX() <= o.getX() + 50
  31.                                     && this.getY() <= o.getY() + 60
  32.                                     && this.getY() >= o.getY()){
  33.                                 return true;
  34.                             }
  35.                             //当前坦克右上角的坐标
  36.                             if(this.getX() + 50 >= o.getX()
  37.                                     && this.getX() + 50<= o.getX() + 50
  38.                                     && this.getY() <= o.getY() + 60
  39.                                     && this.getY() >= o.getY()){
  40.                              return true;
  41.                             }
  42.                         }
  43.                         //如果敌人是向右或者向左
  44.                         if(o.getDirect() == 1 || o.getDirect() == 3){
  45.                             //当前坦克左上角的坐标
  46.                             if(this.getX() >= o.getX()
  47.                                     && this.getX() <= o.getX() + 60
  48.                                     && this.getY() >= o.getY()
  49.                                     && this.getY() <= o.getY() + 50){
  50.                                 return true;
  51.                             }
  52.                             //当前坦克右上角的坐标
  53.                             if(this.getX() + 50>= o.getX()
  54.                                     && this.getX() + 50<= o.getX() + 60
  55.                                     && this.getY() >= o.getY()
  56.                                     && this.getY() <= o.getY() + 50){
  57.                                 return true;
  58.                             }
  59.                         }
  60.                     }
  61.                 }
  62.                 break;
  63.             case 1: //右
  64.                 for(int j=0;j<opTanks.size();j++){
  65.                     //取出一辆坦克
  66.                     OpTank o = opTanks.get(j);
  67.                     if(o != this){  //不能跟自己比
  68.                         //如果敌方坦克是向上或向下
  69.                         if(o.getDirect() == 0 || o.getDirect() == 2){
  70.                             //当前坦克右上角的坐标
  71.                             if(this.getX() + 60 >= o.getX()
  72.                                     && this.getX() + 60 <= o.getX() + 50
  73.                                     && this.getY() >= o.getY()
  74.                                     && this.getY() <= o.getY() + 60){
  75.                                 return true;
  76.                             }
  77.                             //当前坦克右下角的坐标
  78.                             if(this.getX() + 60 >= o.getX()
  79.                                     && this.getX() + 60 <= o.getX() + 50
  80.                                     && this.getY() + 50 >= o.getY()
  81.                                     && this.getY() + 50 <= o.getY() + 60){
  82.                                 return true;
  83.                             }
  84.                         }
  85.                         //如果敌方坦克是向右或向左
  86.                         if(o.getDirect() == 1 || o.getDirect() == 3){
  87.                             //当前坦克右上角的坐标
  88.                             if(this.getX() + 60 >= o.getX()
  89.                                     && this.getX() + 60 <= o.getX() + 60
  90.                                     && this.getY() >= o.getY()
  91.                                     && this.getY() <= o.getY() + 50){
  92.                                 return true;
  93.                             }
  94.                             //当前坦克右下角的坐标
  95.                             if(this.getX() + 60 >= o.getX()
  96.                                     && this.getX() + 60 <= o.getX() + 60
  97.                                     && this.getY() + 50 >= o.getY()
  98.                                     && this.getY() + 50 <= o.getY() + 50){
  99.                                 return true;
  100.                             }
  101.                         }
  102.                     }
  103.                 }
  104.                 break;
  105.             case 2: //下
  106.                 for(int j=0;j<opTanks.size();j++){
  107.                     //取出一辆坦克
  108.                     OpTank o = opTanks.get(j);
  109.                     if(o != this){  //不能跟自己比
  110.                         //如果敌方坦克是向上或向下
  111.                         if(o.getDirect() == 0 || o.getDirect() == 2){
  112.                             //当前坦克左下角的坐标
  113.                             if(this.getX() >= o.getX()
  114.                                     && this.getX() <= o.getX() + 60
  115.                                     && this.getY() + 60 >= o.getY()
  116.                                     && this.getY() + 60 <= o.getY()){
  117.                                 return true;
  118.                             }
  119.                             //当前坦克右下角的坐标
  120.                             if(this.getX() + 50>= o.getX()
  121.                                     && this.getX() + 50 <= o.getX() + 60
  122.                                     && this.getY() + 60 >= o.getY()
  123.                                     && this.getY() + 60 <= o.getY()){
  124.                                 return true;
  125.                             }
  126.                         }
  127.                         //如果敌方坦克是向右或向左
  128.                         if(o.getDirect() == 1 || o.getDirect() == 3){
  129.                             //当前坦克左下角的坐标
  130.                             if(this.getX() >= o.getX()
  131.                                     && this.getX() + 60 <= o.getX() + 60
  132.                                     && this.getY() >= o.getY()
  133.                                     && this.getY() + 50 <= o.getY() + 50){
  134.                                 return true;
  135.                             }
  136.                             //当前坦克右下角的坐标
  137.                             if(this.getX() + 50 >= o.getX()
  138.                                     && this.getX() + 50 <= o.getX() + 60
  139.                                     && this.getY() + 60 >= o.getY()
  140.                                     && this.getY() + 60 <= o.getY() + 50){
  141.                                 return true;
  142.                             }
  143.                         }
  144.                     }
  145.                 }
  146.                 break;
  147.             case 3: //左
  148.                 for(int j=0;j<opTanks.size();j++){
  149.                     //取出一辆坦克
  150.                     OpTank o = opTanks.get(j);
  151.                     if(o != this){  //不能跟自己比
  152.                         //如果敌方坦克是向上或向下
  153.                         if(o.getDirect() == 0 || o.getDirect() == 2){
  154.                             //当前坦克左上角的坐标
  155.                             if(this.getX() >= o.getX()
  156.                                     && this.getX() <= o.getX() + 60
  157.                                     && this.getY() >= o.getY()
  158.                                     && this.getY() <= o.getY()){
  159.                                 return true;
  160.                             }
  161.                             //当前坦克左下角的坐标
  162.                             if(this.getX() >= o.getX()
  163.                                     && this.getX() <= o.getX() + 60
  164.                                     && this.getY() + 50 >= o.getY()
  165.                                     && this.getY() + 50 <= o.getY()){
  166.                                 return true;
  167.                             }
  168.                         }
  169.                         //如果敌方坦克是向右或向左
  170.                         if(o.getDirect() == 1 || o.getDirect() == 3){
  171.                             //当前坦克左上角的坐标
  172.                             if(this.getX() >= o.getX()
  173.                                     && this.getX() <= o.getX() + 60
  174.                                     && this.getY() >= o.getY()
  175.                                     && this.getY() <= o.getY() + 50){
  176.                                 return true;
  177.                             }
  178.                             //当前坦克左下角的坐标
  179.                             if(this.getX() >= o.getX()
  180.                                     && this.getX() <= o.getX() + 60
  181.                                     && this.getY() + 50 >= o.getY()
  182.                                     && this.getY() + 50 <= o.getY() + 50){
  183.                                 return true;
  184.                             }
  185.                         }
  186.                     }
  187.                 }
  188.                 break;
  189.         }
  190.         return false;
  191.     }
  192.  
  193.  
  194.     //判断敌方坦克是否触碰到了墙壁
  195.     public boolean isTouchWall(){
  196.         //判断敌人当前的方向
  197.         switch (getDirect()){
  198.             case 0: //向上
  199.                 for(int i=0;i<opTanks.size();i++){  //取出一个坦克
  200.                     OpTank o = opTanks.get(i);
  201.                     //当前坦克的左上角坐标
  202.                     if(o.getX() > 500 && o.getX() < 700 && o.getY() > 660 && o.getY() < 710
  203. //                            || o.getX() > 160 && o.getX() <= 290 && o.getY() > 100 && o.getY() <= 160
  204. //                            || o.getX() > 910 && o.getX() <= 1040 && o.getY() > 100 && o.getY() <= 160
  205.                             || o.getX() > 550 && o.getX() < 650 && o.getY() > 160 && o.getY() < 260
  206.                             || o.getX() > 790 && o.getX() < 850 && o.getY() > 100 && o.getY() < 160
  207.                             || o.getX() > 350 && o.getX() < 410 && o.getY() > 100 && o.getY() < 340
  208.                             || o.getX() > 880 && o.getX() < 940 && o.getY() > 660 && o.getY() < 790
  209.                             || o.getX() > 260 && o.getX() < 320 && o.getY() > 660 && o.getY() < 790){
  210.                         return true;
  211.                     }
  212.                     //当前坦克的右上角坐标
  213.                     if(o.getX() + 50 > 500 && o.getX() + 50 < 700 && o.getY() > 660 && o.getY() < 710
  214. //                            || o.getX() + 50 >= 160 && o.getX() + 50 <= 290 && o.getY() >= 100 && o.getY() <= 160
  215. //                            || o.getX() + 50 >= 910 && o.getX() + 50 <= 1040 && o.getY() >= 100 && o.getY() <= 160
  216.                             || o.getX() + 50 > 550 && o.getX() + 50 < 650 && o.getY() > 160 && o.getY() < 260
  217.                             || o.getX() + 50 > 790 && o.getX() + 50 < 850 && o.getY() > 100 && o.getY() < 160
  218.                             || o.getX() + 50 > 350 && o.getX() + 50 < 410 && o.getY() > 100 && o.getY() < 340
  219.                             || o.getX() + 50 > 880 && o.getX() + 50 < 940 && o.getY() > 660 && o.getY() < 790
  220.                             || o.getX() + 50 > 260 && o.getX() + 50 < 320 && o.getY() > 660 && o.getY() < 790){
  221.                         return true;
  222.                     }
  223.                 }
  224.                 break;
  225.             case 1: //向右
  226.                 for(int i=0;i<opTanks.size();i++) {  //取出一个坦克
  227.                     OpTank o = opTanks.get(i);
  228.                     //当前坦克的右上角坐标
  229.                     if (o.getX() + 60 > 500 && o.getX() + 60 < 700 && o.getY() > 660 && o.getY() < 710
  230. //                            || o.getX() + 60 >= 160 && o.getX() + 60 <= 290 && o.getY() >= 100 && o.getY() <= 160
  231. //                            || o.getX() + 60 >= 910 && o.getX() + 60 <= 1040 && o.getY() >= 100 && o.getY() <= 160
  232.                             || o.getX() + 60 > 550 && o.getX() + 60 < 650 && o.getY() > 160 && o.getY() < 260
  233.                             || o.getX() + 60 > 790 && o.getX() + 60 < 850 && o.getY() > 100 && o.getY() < 160
  234.                             || o.getX() + 60 > 350 && o.getX() + 60 < 410 && o.getY() > 100 && o.getY() < 340
  235.                             || o.getX() + 60 > 880 && o.getX() + 60 < 940 && o.getY() > 660 && o.getY() < 790
  236.                             || o.getX() + 60 > 260 && o.getX() + 60 < 320 && o.getY() > 660 && o.getY() < 790){
  237.                         return true;
  238.                     }
  239.                     //当前坦克的右下角坐标
  240.                     if(o.getX() + 60 > 500 && o.getX() + 60 < 700 && o.getY() + 50 > 660 && o.getY() + 50 < 710
  241. //                            || o.getX() + 60 >= 160 && o.getX() + 60 <= 290 && o.getY() + 50 >= 100 && o.getY() + 50 <= 160
  242. //                            || o.getX() + 60 >= 910 && o.getX() + 60 <= 1040 && o.getY() + 50 >= 100 && o.getY() + 50 <= 160
  243.                             || o.getX() + 60 > 550 && o.getX() + 60 < 650 && o.getY() + 50 > 160 && o.getY() + 50 < 260
  244.                             || o.getX() + 60 > 790 && o.getX() + 60 < 850 && o.getY() + 50 > 100 && o.getY() + 50 < 160
  245.                             || o.getX() + 60 > 350 && o.getX() + 60 < 410 && o.getY() + 50 > 100 && o.getY() + 50 < 340
  246.                             || o.getX() + 60 > 880 && o.getX() + 60 < 940 && o.getY() + 50 > 660 && o.getY() + 50 < 790
  247.                             || o.getX() + 60 > 260 && o.getX() + 60 < 320 && o.getY() + 50 > 660 && o.getY() + 50 < 790){
  248.                         return true;
  249.                     }
  250.                 }
  251.                 break;
  252.             case 2: //向下
  253.                 for(int i=0;i<opTanks.size();i++) {  //取出一个坦克
  254.                     OpTank o = opTanks.get(i);
  255.                     //当前坦克的左下角坐标
  256.                     if(o.getX() > 500 && o.getX() < 700 && o.getY() + 60 > 660 && o.getY() + 60 < 710
  257. //                            || o.getX() >= 160 && o.getX() <= 290 && o.getY() + 60 >= 100 && o.getY() + 60 <= 160
  258. //                            || o.getX() >= 910 && o.getX() <= 1040 && o.getY() + 60 >= 100 && o.getY() + 60 <= 160
  259.                             || o.getX() > 550 && o.getX() < 650 && o.getY() + 60 > 160 && o.getY() + 60 < 260
  260.                             || o.getX() > 790 && o.getX() < 850 && o.getY() + 60 > 100 && o.getY() + 60 < 160
  261.                             || o.getX() > 350 && o.getX() < 410 && o.getY() + 60 > 100 && o.getY() + 60 < 340
  262.                             || o.getX() > 880 && o.getX() < 940 && o.getY() + 60 > 660 && o.getY() + 60 < 790
  263.                             || o.getX() > 260 && o.getX() < 320 && o.getY() + 60 > 660 && o.getY() + 60 < 790){
  264.                         return true;
  265.                     }
  266.                     //当前坦克的右下角坐标
  267.                     if(o.getX() + 50 > 500 && o.getX() + 50 < 700 && o.getY() + 60 > 660 && o.getY() + 60 < 710
  268. //                            || o.getX() + 50 >= 160 && o.getX() + 50 <= 290 && o.getY() + 60 >= 100 && o.getY() + 60 <= 160
  269. //                            || o.getX() + 50 >= 910 && o.getX() + 50 <= 1040 && o.getY() + 60 >= 100 && o.getY() + 60 <= 160
  270.                             || o.getX() + 50 > 550 && o.getX() + 50 < 650 && o.getY() + 60 > 160 && o.getY() + 60 < 260
  271.                             || o.getX() + 50 > 790 && o.getX() + 50 < 850 && o.getY() + 60 > 100 && o.getY() + 60 < 160
  272.                             || o.getX() + 50 > 350 && o.getX() + 50 < 410 && o.getY() + 60 > 100 && o.getY() + 60 < 340
  273.                             || o.getX() + 50 > 880 && o.getX() + 50 < 940 && o.getY() + 60 > 660 && o.getY() + 60 < 790
  274.                             || o.getX() + 50 > 260 && o.getX() + 50 < 320 && o.getY() + 60 > 660 && o.getY() + 60 < 790){
  275.                         return true;
  276.                     }
  277.                 }
  278.                 break;
  279.             case 3: //向左
  280.                 for(int i=0;i<opTanks.size();i++) {  //取出一个坦克
  281.                     OpTank o = opTanks.get(i);
  282.                     //当前坦克的左上角坐标
  283.                     if(o.getX() > 500 && o.getX() < 700 && o.getY() > 660 && o.getY() < 710
  284. //                            || o.getX() >= 160 && o.getX() <= 290 && o.getY() >= 100 && o.getY() <= 160
  285. //                            || o.getX() >= 910 && o.getX() <= 1040 && o.getY() >= 100 && o.getY() <= 160
  286.                             || o.getX() > 550 && o.getX() < 650 && o.getY() > 160 && o.getY() < 260
  287.                             || o.getX() > 790 && o.getX() < 850 && o.getY() > 100 && o.getY() < 160
  288.                             || o.getX() > 350 && o.getX() < 410 && o.getY() > 100 && o.getY() < 340
  289.                             || o.getX() > 880 && o.getX() < 940 && o.getY() > 660 && o.getY() < 790
  290.                             || o.getX() > 260 && o.getX() < 320 && o.getY() > 660 && o.getY() < 790){
  291.                         return true;
  292.                     }
  293.                     //当前坦克的左下角坐标
  294.                     if(o.getX() > 500 && o.getX() < 700 && o.getY() + 50 > 660 && o.getY() + 50 < 710
  295.                             || o.getX() > 160 && o.getX() < 290 && o.getY() + 50 > 100 && o.getY() + 50 < 160
  296.                             || o.getX() > 910 && o.getX() < 1040 && o.getY() + 50 > 100 && o.getY() + 50 < 160
  297.                             || o.getX() > 550 && o.getX() < 650 && o.getY() + 50 > 160 && o.getY() + 50 < 260
  298.                             || o.getX() > 790 && o.getX() < 850 && o.getY() + 50 > 100 && o.getY() + 50 < 160
  299.                             || o.getX() > 350 && o.getX() < 410 && o.getY() + 50 > 100 && o.getY() + 50 < 340
  300.                             || o.getX() > 880 && o.getX() < 940 && o.getY() + 50 > 660 && o.getY() + 50 < 790
  301.                             || o.getX() > 260 && o.getX() < 320 && o.getY() + 50 > 660 && o.getY() + 50 < 790){
  302.                         return true;
  303.                     }
  304.                 }
  305.                 break;
  306.         }
  307.         return false;
  308.     }
  309.  
  310.  
  311.     @Override
  312.     public void run() {
  313.         while(true){
  314.  
  315.             //这里判断坦克的方向，创建对应的炮弹
  316.             if(isLive && shots.size() < 6){
  317.                 Shot s = null;
  318.                 switch (getDirect()){
  319.                     case 0:
  320.                         s = new Shot(getX() + 25,getY(),0);
  321.                         break;
  322.                     case 1:
  323.                         s = new Shot(getX() + 60,getY() + 25,1);
  324.                         break;
  325.                     case 2:
  326.                         s = new Shot(getX() + 25,getY() + 60,2);
  327.                         break;
  328.                     case 3:
  329.                         s = new Shot(getX(),getY() + 25,3);
  330.                         break;
  331.                 }
  332.  
  333.                 //每隔2秒发射一个炮弹
  334.                 try {
  335.                     Thread.sleep(2000);
  336.                 } catch (InterruptedException e) {
  337.                     e.printStackTrace();
  338.                 }
  339.  
  340.                 shots.add(s);
  341.  
  342.                 new Thread(s).start();
  343.             }
  344.  
  345.             //坦克移动的方向
  346.             switch (this.getDirect()){
  347.                 case 0:
  348.                     for(int i=0;i<60;i++) {
  349.                         if (getY() > 0 && !isTouchOpTank() && !isTouchWall()){
  350.                             MoveUp();
  351.                         }
  352.                         //休眠
  353.                         try {
  354.                             Thread.sleep(50);
  355.                         } catch (InterruptedException e) {
  356.                             e.printStackTrace();
  357.                         }
  358.                     }
  359.                     break;
  360.                 case 1:
  361.                     for (int i=0;i<60;i++){
  362.                         if(getX() + 60< 1200 && !isTouchOpTank() && !isTouchWall()) {
  363.                             MoveRight();
  364.                         }
  365.                         //休眠
  366.                         try {
  367.                             Thread.sleep(50);
  368.                         } catch (InterruptedException e) {
  369.                             e.printStackTrace();
  370.                         }
  371.                     }
  372.                     break;
  373.                 case 2:
  374.                     for (int i=0;i<60;i++){
  375.                         if(getY() + 60 < 900 && !isTouchOpTank() && !isTouchWall()) {
  376.                             MoveDown();
  377.                         }
  378.                         //休眠
  379.                         try {
  380.                             Thread.sleep(50);
  381.                         } catch (InterruptedException e) {
  382.                             e.printStackTrace();
  383.                         }
  384.                     }
  385.                     break;
  386.                 case 3:
  387.                     for (int i=0;i<60;i++){
  388.                         if(getX() > 0 && !isTouchOpTank() && !isTouchWall()) {
  389.                             MoveLeft();
  390.                         }
  391.                         //休眠
  392.                         try {
  393.                             Thread.sleep(50);
  394.                         } catch (InterruptedException e) {
  395.                             e.printStackTrace();
  396.                         }
  397.                     }
  398.                     break;
  399.             }
  400.             setDirect((int)(Math.random() * 4));
  401. //            System.out.println("坦克的x坐标" + getX() + " y坐标 "+ getY() );
  402.             if(!isLive){
  403.                break;
  404.             }
  405.         }
  406.     }
  407. }

6.炮弹类（Shot）

  1. package com.wak.TankGame01Version;
  2.  
  3. public class Shot implements Runnable{
  4.     int x;  //子弹的x坐标
  5.     int y;  //子弹的y坐标
  6.     int direct = 0; //子弹的方向
  7.     int speed = 4;  //子弹的速度
  8.     boolean isLive = true;  //子弹的存活状态
  9.  
  10.     public Shot(int x,int y,int direct){
  11.         this.x = x;
  12.         this.y = y;
  13.         this.direct = direct;
  14.     }
  15.  
  16.     public void setShotSpeed(int speed){
  17.         this.speed = speed;
  18.     }
  19.  
  20.     @Override
  21.     public void run() { //射击
  22.         while(isLive){
  23.             //休眠
  24.             try {
  25.                 Thread.sleep(50);
  26.             } catch (InterruptedException e) {
  27.                 e.printStackTrace();
  28.             }
  29.  
  30.             switch (direct){
  31.                 case 0: //向上
  32.                     y -= speed;
  33.                     break;
  34.                 case 1: //向右
  35.                     x += speed;
  36.                     break;
  37.                 case 2: //向下
  38.                     y += speed;
  39.                     break;
  40.                 case 3: //向左
  41.                     x -= speed;
  42.                     break;
  43.             }
  44.  
  45. //            System.out.println("炮弹的x坐标：" + x + ",炮弹的y坐标：" + y);
  46.             //如果炮弹弹撞到墙壁，则销毁
  47.             //当炮弹碰到敌人坦克时，也应当结束
  48.             if(!(x > 0 && x < 1200 && y > 0 && y <= 900 && isLive)
  49. //                    || x >= 160 && x <= 290 && y >= 100 && y <= 160
  50. //                    || x >= 910 && x<= 1040 && y >= 100 && y <= 160
  51.                     || x > 550 && x < 650 && y > 160 && y < 260
  52.                     || x > 790 && x < 850 && y > 100 && y < 340
  53.                     || x > 350 && x < 410 && y > 100 && y < 340
  54.                     || x > 880 && x < 940 && y > 660 && y < 790
  55.                     || x > 260 && x < 320 && y > 660 && y < 790
  56.                     || x > 500 && x < 700 && y > 660 && y < 710){
  57.                 isLive = false;
  58. //                System.out.println("炮弹已销毁");
  59.             }
  60.         }
  61.     }
  62. }

7.记录信息类（Recorder）

  1. package com.wak.TankGame01Version;
  2.  
  3. import java.awt.*;
  4. import java.io.*;
  5. import java.util.Vector;
  6.  
  7. public class Recorder {
  8.     private static int allOpTanksNum = 0;
  9.     //定义IO对象，准备写数据到文件中
  10.     private static FileWriter fw = null;
  11.     private static BufferedWriter bw = null;
  12.     private static BufferedReader br = null;
  13.     private static String recordFile = "D:\\myTankGameRecord.txt";
  14.     //定义Vec，指向GamePanel对象的 敌人坦克Vector
  15.     private static Vector<OpTank> opTanks = null;
  16.     //定义一个Node 的Vector，用于保存敌人的信息node
  17.     private static Vector<Node> nodes = new Vector<>();
  18.  
  19.     public static void setOpTanks(Vector<OpTank> opTanks){
  20.         Recorder.opTanks = opTanks;
  21.     }
  22.  
  23.     public static int getAllOpTanksNum(){
  24.         return allOpTanksNum;
  25.     }
  26.  
  27.     public static void setAllOpTanksNum(int allOpTanksNum){
  28.         Recorder.allOpTanksNum = allOpTanksNum;
  29.     }
  30.  
  31.  
  32.     //当我方坦克击毁一个敌人坦克，就应当allOpTanksNum++
  33.     public static void addAllOpTanksNum(){
  34.         Recorder.allOpTanksNum++;
  35.     }
  36.  
  37.     //增加一个方法，当游戏退出时，我们将allOpTanksNum保存到recordFile
  38.     //对KeepRecord方法进行升级，保存敌人坦克的坐标和方向
  39.     public static void KeepRecord(){
  40.         try {
  41.             bw = new BufferedWriter((new FileWriter((recordFile))));
  42.             bw.write(allOpTanksNum + "\r\n");
  43.             //遍历敌人坦克的Vector，然后根据情况保存即可
  44.             for(int i=0;i<opTanks.size();i++){
  45.                 //取出敌人坦克
  46.                 OpTank o = opTanks.get(i);
  47.                 if(o.isLive){
  48.                     //保存该opTank的信息
  49.                     String record = o.getX() + " " + o.getY() + " " + o.getDirect();
  50.                     //写入到文件
  51.                     bw.write(record + "\r\n");
  52.                 }
  53.             }
  54.         } catch (IOException e) {
  55.             e.printStackTrace();
  56.         }finally {
  57.             if (bw != null) {
  58.                 try {
  59.                     bw.close();
  60.                 } catch (IOException e) {
  61.                     e.printStackTrace();
  62.                 }
  63.             }
  64.         }
  65.     }
  66.  
  67. //    //增加一个方法，用于读取recordFile，恢复相关信息
  68. //    public static Vector<Node> getNodesAndEnemyTankRec(){
  69. //        try {
  70. //            br = new BufferedReader(new FileReader(recordFile));
  71. //
  72. //        } catch (FileNotFoundException e) {
  73. //            e.printStackTrace();
  74. //        }finally {
  75. //
  76. //        }
  77. //        return null;
  78. //    }
  79. }

运行效果截图：

 

 

总结：

这次短学期实践，给我带来了很大收获，让我的时间变得充实，让我收获了写电子笔记，写总结的好习惯，让我能像被封印在椅子上一样，就这么写代码写一整个下午，也深刻的意识到写一个项目或者是一段代码，一定要先有自己的思路，思路是最重要的，是基础，才能去实现，也很感谢老师们，和学长学姐们，以及各位与我一起参加短学期实践的小伙伴们，是他们让我认识到了自己的不足，是他们让我学会了很多对于学习中很有用的方法，见证到了代码的魅力，让我们一起继续加油，尽最大的努力，做最好的自己，为了我爱的和爱我的！

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/AllinToyou/article/detail/326339
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号