坦克大战体会

首先我们得创造这些类

• 坦克类

  • 我的坦克

  • 敌人的坦克

    • Vector
    • Vector
    • 判断敌人坦克重叠的方法

• 子弹类

  • 线程

• 炸弹类

  • 生命值属性，可以让炸弹出现爆炸的效果

• TankGame 类

  • 启动myPanel线程

• my panel extends JPanel,implement Runnable,KeyListener

  • paint

    • 画框

    • 敌人

      • 调用draw方法就可以了

    • 我方

    • 子弹

    • 炸弹

      • 由三张照片组成，放在out chapter跟目录下
      • 读取要注意⚠️是所在类.class.getResource()

  • run

    • this.repaint

  • hitTank

  • 键盘的监听

    • this.repaint

  • hitEnemyTank

  • hitMyTank

  • constructor

    • 我的坦克的初始化
    • 敌人坦克
    • 子弹
    • 炸弹

  • DrawTank()

    • 抽出一个方法来专门画所有的坦克

  • TouchEnemy

    • 调用isTouchEnemy()方法来判断自己的坦克是否跟敌方坦克碰撞

  • isTouchEnemy()

• Record

  • 文件读取

  • 文件的存储BufferedWriter

    • 不能使用br.writer()里面传int 参数；因为要考虑读取的时候readLine()只能接受string，所以存储的时候也必须是相同的形式，很多地方都是这样，要注意‼️，不然会出现异常

  • 最好是把它变成工具类，用static

• node

  • 是将敌人的坦克存储的坐标及方向，以node 的形式存储起来，因为初始化的时候，敌人的坦克是Vector<>的形式存储的，那么这样应该考虑再调用的时候，也应该是一个vector<>的集合

• music

  • 继承线程

package com.tankgamepractice1;

import javax.swing.*;
import java.awt.*;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.util.Scanner;

/**
 * @author jessica~
 * @version 1.0
 */
public class TankGame extends JFrame {
   MyPanel myPanel;
  Scanner scanner = new Scanner(System.in);
    public TankGame()  {
        System.out.println("press 1  to start new game;press 2 to continue.");
         String key = scanner.next();
        myPanel = new MyPanel(key);
       new Thread(myPanel).start();
       this.add(myPanel);
       this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
       this.setVisible(true);
       this.setSize(1300,750);
       //一点要加进去，不然就无法按键成功
       this.addKeyListener(myPanel);
       this.addWindowListener(new WindowAdapter() {
           @Override
           public void windowClosing(WindowEvent e) {
               Reader.Record();
               System.exit(0);
           }
       });
    }

    public static void main(String[] args) {
        new TankGame();
    }
}

package com.tankgamepractice1;

/**
 * @author jessica~
 * @version 1.0
 */
public class Tank {
    int x;
    int y;
    int dir;
    int speed = 1;

    boolean isLive = true;

    public Tank(int x, int y) {
        this.x = x;
        this.y = y;

    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }

    public int getDir() {
        return dir;
    }

    public void setDir(int dir) {
        this.dir = dir;
    }

    public boolean isLive() {
        return isLive;
    }

    public void setLive(boolean live) {
        isLive = live;
    }

    public void moveUp() {
        y -= speed;
    }

    public void moveDown() {
        y += speed;
    }

    public void moveLeft() {
        x -= speed;
    }

    public void moveRight() {
        x += speed;
    }
}

package com.tankgamepractice1;

/**
 * @author jessica~
 * @version 1.0
 */
public class Shot implements Runnable{
    int x;
    int y;
    int dir;
    int speed = 1;
    boolean isLive = true;

    public Shot(int x, int y, int dir) {
        this.x = x;
        this.y = y;
        this.dir = dir;
    }

    public boolean isLive() {
        return isLive;
    }

    public void setLive(boolean live) {
        isLive = live;
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }

    public int getDir() {
        return dir;
    }

    public void setDir(int dir) {
        this.dir = dir;
    }

    public int getSpeed() {
        return speed;
    }

    public void setSpeed(int speed) {
        this.speed = speed;
    }

    @Override
    public void run() {
        while (true){
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            switch (dir){
                case 0:
                    y -=speed;
                    break;
                case 1:
                    x += speed;
                    break;
                case 2:
                    y+=speed;
                    break;
                case 3:
                    x-=speed;
                    break;
            }
            if( !(x>0 &&x<1000&&y>0&&y<750&&isLive)){
                isLive = false;
                break;
            }

        }
    }
}

package com.tankgamepractice1;

import java.io.*;
import java.util.Vector;

/**
 * @author jessica~
 * @version 1.0
 */
public class Reader {
    private static BufferedWriter bw = null;
    private static BufferedReader br = null;
    private static String filePath = "src/practicRecord.txt";
    private static int hitEnemyTank = 0;
    private static Vector<Node> nodes = new Vector<>();
    private static Vector<EnemyTank> enemyTanks = new Vector<>();
    public  static Vector<Node> readRecord(){
        try {
            br = new BufferedReader(new FileReader(filePath));
            String s = br.readLine();
            hitEnemyTank = Integer.parseInt(s);
           String readEnemyTank = null;
            while(( readEnemyTank=br.readLine())!=null){
                String[] s1 = readEnemyTank.split(" ");
                Node node = new Node(Integer.parseInt(s1[0]),
                        Integer.parseInt(s1[1]), Integer.parseInt(s1[2]));
                nodes.add(node);

            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if(br !=null){
                    br.close();
                }

            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return  nodes;
    }
    public static String getFilePath() {
        return filePath;
    }

    public static void setEnemyTanks(Vector<EnemyTank> enemyTanks) {
        Reader.enemyTanks = enemyTanks;
    }

    public static void setFilePath(String filePath) {
        Reader.filePath = filePath;
    }

    public static int getHitEnemyTank() {
        return hitEnemyTank;
    }

    public static void setHitEnemyTank(int hitEnemyTank) {
        Reader.hitEnemyTank = hitEnemyTank;
    }

    public static void addAllTanks() {
        hitEnemyTank++;
    }

    public static void Record() {
        try {

            bw = new BufferedWriter(new FileWriter(filePath));
//            bw.write(hitEnemyTank+"\r\n");
           //因为读取的时候是读取的s ，所以必须以string 的形式存储
            bw.write(hitEnemyTank+"");
            bw.newLine();
            for (int i = 0; i <enemyTanks.size(); i++) {
                EnemyTank enemyTank = enemyTanks.get(i);
                String xyd=enemyTank.x+" "+enemyTank.y+" "+enemyTank.getDir();
                bw.write(xyd+"\r\n");
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                bw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }


}

package com.tankgamepractice1;

/**
 * @author jessica~
 * @version 1.0
 */
public class Node {
    int x;
    int y;
    int dir;

    public Node(int x, int y, int dir) {
        this.x = x;
        this.y = y;
        this.dir = dir;
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }

    public int getDir() {
        return dir;
    }

    public void setDir(int dir) {
        this.dir = dir;
    }
}

package com.tankgamepractice1;

import java.util.Vector;

/**
 * @author jessica~
 * @version 1.0
 */
public class MyTank extends Tank{
    Shot shot;
    Vector<Shot> shots = new Vector<>();
    public MyTank(int x, int y) {
        super(x, y);
    }
    public  void shotEnemy(){
        switch (dir){
            case 0:
                shot = new Shot(x+20,y,0);
                break;
            case 1:
                shot = new Shot(x+60,y+20,1);
                break;
            case 2:
                shot = new Shot(x+20,y+60,2);
                break;
            case 3:
                shot = new Shot(x,y+20,3);
                break;
        }
        shots.add(shot);
        new Thread(shot).start();
    }

}

package com.tankgamepractice1;






import com.hsp.NewReader;

import javax.swing.*;
import java.awt.*;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.io.File;
import java.util.Vector;

/**
 * @author jessica~
 * @version 1.0
 */
public class MyPanel extends JPanel implements KeyListener,Runnable{
    MyTank myTank ;
    Vector<EnemyTank> enemyTanks = new Vector<>();
    int enemySize = 3;
    Vector<Bomb> bombs = new Vector<>();
    Image image1 =null;
    Image image2 =null;
    Image image3 = null;
    Vector<Node> nodes = new Vector<>();

    public MyPanel(String key) {
        myTank = new MyTank(500,100);
        File file = new File(Reader.getFilePath());
        if(file.exists()){
            //这个代码可以写在这，也可以写在下面，逻辑是对的
//            nodes = Reader.readRecord();

        }else {
            System.out.println("no file ,only can start new game.");
            key = "1";
        }
        Reader.setEnemyTanks(enemyTanks);
            switch (key){
                case "1":
                    for (int i = 0; i < enemySize; i++) {
                    EnemyTank enemyTank = new EnemyTank(100*(1+i),0);
                    //这个方法就把它们两个类中的enemyTanks关联起来了
                    //让它们都指向的是同一个类
                    enemyTank.setEnemyTanks(enemyTanks);
                    enemyTank.setDir(2);
                    enemyTanks.add(enemyTank);
                    //这个很重要阿，不然不会开启敌人坦克的线程
                    //它们就不会动，子弹也不会出现
                    new Thread(enemyTank).start();
                }

                    break;
                case "2":
                    nodes = Reader.readRecord();
                    for (int i = 0; i < nodes.size(); i++) {
                        Node node = nodes.get(i);
                        EnemyTank enemyTank = new EnemyTank(node.getX(), node.getY());
                        enemyTank.setEnemyTanks(enemyTanks);
                        enemyTank.setDir(node.getDir());
                        enemyTanks.add(enemyTank);
                        new Thread(enemyTank).start();
                    }

                    break;
            }





        image1 = Toolkit.getDefaultToolkit().getImage(MyPanel.class.getResource("/bomb_1.gif"));
        image2 = Toolkit.getDefaultToolkit().getImage(MyPanel.class.getResource("/bomb_2.gif"));
        image3 = Toolkit.getDefaultToolkit().getImage(MyPanel.class.getResource("/bomb_3.gif"));
        new AePlayWave("src/111.wav").start();
    }
    public  void showInfo_(Graphics g){
        g.setColor(Color.black);
        Font times = new Font("Menlo", Font.BOLD, 25);
        g.setFont(times);
        g.drawString("the destroyed enemy tanks:",1020,30);
        drawTank(1020,60,g,1,0);
        g.setColor(Color.black);
        g.drawString(Reader.getHitEnemyTank()+"",1080,100);
    }
    //这个功能是实现自己坦克跟敌人坦克相碰的时候，两个坦克都爆炸的效果
    //我做了两个部分
    //这个部分是只要实现一辆敌人坦克和我的坦克相碰，就返回false
    public Boolean isTouchETank1(EnemyTank enemyTank, MyTank myTank){
        switch (myTank.getDir()){
            case 0://up

                //不能和自己比较，自己比较的化，就永远碰撞
                //只要比较对象就可以了

                //敌人的其它坦克向上/向下
                //敌人坦克x的范围x,x+40
                //y 的范围是y ,y+60
                if(enemyTank.getDir() == 0 ||enemyTank.getDir() ==2){
                    //当前坦克左上角x,y
                    if(myTank.x >= enemyTank.x &&myTank.x <= enemyTank.x+40
                            &&myTank.y >=enemyTank.y && myTank.y <= enemyTank.y+60){
                        return true;
                    }
                    //右上角x+40,y
                    if(myTank.x+40 >= enemyTank.x &&myTank.x+40 <= enemyTank.x+40
                            &&myTank.y >=enemyTank.y && myTank.y <= enemyTank.y+60){
                        return true;
                    }
                    //敌人坦克左和右
                    //范围x,x+60;y,y+40
                }
                if(enemyTank.getDir() == 3 ||enemyTank.getDir() ==1){
                    //左上角
                    if(myTank.x >= enemyTank.x &&myTank.x <= enemyTank.x+60
                            &&myTank.y >=enemyTank.y && myTank.y <= enemyTank.y+40){
                        return true;
                    }
                    //右上角x+40,y
                    if(myTank.x+40 >= enemyTank.x &&myTank.x+40 <= enemyTank.x+60
                            &&myTank.y >=enemyTank.y && myTank.y <= enemyTank.y+40){
                        return true;
                    }
                }




                break;
            case 1://right

                //不能和自己比较，自己比较的化，就永远碰撞
                //只要比较对象就可以了

                //敌人的其它坦克向上/向下
                //敌人坦克x的范围x,x+40
                //y 的范围是y ,y+60
                if(enemyTank.getDir() == 0 ||enemyTank.getDir() ==2){
                    //当前坦克右上角x+60,y
                    if(myTank.x+60 >= enemyTank.x &&myTank.x+60 <= enemyTank.x+40
                            &&myTank.y >=enemyTank.y && myTank.y <= enemyTank.y+60){
                        return true;
                    }
                    //右下角x+60,y+40
                    if(myTank.x+60 >= enemyTank.x &&myTank.x+60 <= enemyTank.x+40
                            &&myTank.y+40 >=enemyTank.y && myTank.y+40 <= enemyTank.y+60){
                        return true;
                    }
                    //敌人坦克左和右
                    //范围x,x+60;y,y+40
                }
                if(enemyTank.getDir() == 3 ||enemyTank.getDir() ==1){
                    //右上角
                    if(myTank.x+60 >= enemyTank.x &&myTank.x+60 <= enemyTank.x+60
                            &&myTank.y >=enemyTank.y && myTank.y <= enemyTank.y+40){
                        return true;
                    }
                    //右下角x+60,y+40
                    if(myTank.x+60 >= enemyTank.x &&myTank.x+60 <= enemyTank.x+60
                            &&myTank.y+40 >=enemyTank.y && myTank.y+40 <= enemyTank.y+40){
                        return true;
                    }
                }




                break;
            case 2://down

                //不能和自己比较，自己比较的化，就永远碰撞
                //只要比较对象就可以了

                //敌人的其它坦克向上/向下
                //敌人坦克x的范围x,x+40
                //y 的范围是y ,y+60
                if(enemyTank.getDir() == 0 ||enemyTank.getDir() ==2){
                    //当前坦克左下角x,y+60
                    if(myTank.x >= enemyTank.x &&myTank.x <= enemyTank.x+40
                            &&myTank.y+60 >=enemyTank.y && myTank.y+60 <= enemyTank.y+60){
                        return true;
                    }
                    //右下角x+40,y+60
                    if(myTank.x+40 >= enemyTank.x &&myTank.x+40 <= enemyTank.x+40
                            &&myTank.y+60 >=enemyTank.y && myTank.y+60 <= enemyTank.y+60){
                        return true;
                    }
                    //敌人坦克左和右
                    //范围x,x+60;y,y+40
                }
                if(enemyTank.getDir() == 3 ||enemyTank.getDir() ==1){
                    //当前坦克左下角x,y+60
                    if(myTank.x >= enemyTank.x &&myTank.x <= enemyTank.x+60
                            &&myTank.y+60 >=enemyTank.y && myTank.y+60 <= enemyTank.y+40){
                        return true;
                    }
                    //右下角x+40,y+60
                    if(myTank.x+40 >= enemyTank.x &&myTank.x+40 <= enemyTank.x+60
                            &&myTank.y+60 >=enemyTank.y && myTank.y+60 <= enemyTank.y+40){
                        return true;
                    }
                }


                break;


            case 3://left


                //不能和自己比较，自己比较的化，就永远碰撞
                //只要比较对象就可以了

                //敌人的其它坦克向上/向下
                //敌人坦克x的范围x,x+40
                //y 的范围是y ,y+60
                if(enemyTank.getDir() == 0 ||enemyTank.getDir() ==2){
                    //当前坦克左上角x,y
                    if(myTank.x >= enemyTank.x &&myTank.x <= enemyTank.x+40
                            &&myTank.y >=enemyTank.y && myTank.y <= enemyTank.y+60){
                        return true;
                    }
                    //左下角x,y+40
                    if(myTank.x >= enemyTank.x &&myTank.x <= enemyTank.x+40
                            &&myTank.y+40 >=enemyTank.y && myTank.y+40 <= enemyTank.y+60){
                        return true;
                    }
                    //敌人坦克左和右
                    //范围x,x+60;y,y+40
                }
                if(enemyTank.getDir() == 3 ||enemyTank.getDir() ==1){
                    //当前坦克左上角x,y
                    if(myTank.x >= enemyTank.x &&myTank.x <= enemyTank.x+60
                            &&myTank.y >=enemyTank.y && myTank.y<= enemyTank.y+40){
                        return true;
                    }
                    //左下角x,y+40
                    if(myTank.x>= enemyTank.x &&myTank.x <= enemyTank.x+60
                            &&myTank.y+40 >=enemyTank.y && myTank.y+40 <= enemyTank.y+40){
                        return true;
                    }
                }





                break;

        }  return  false;

    }

    //这个是实现真正的相碰，会出现什么情况，
    //比如说需要设置坦克的生命值，炸弹出现的时机
    //需要注意的是，需要在run 方法中去调用它，因为需要它不停的去判断，然后再不停的去画
    public void TouchTank(MyTank myTank){
        for (int i = 0; i <enemyTanks.size() ; i++) {
          EnemyTank enemyTank = enemyTanks.get(i);
            if(isTouchETank1(enemyTank,myTank)){
                myTank.isLive = false;
                Reader.addAllTanks();
                enemyTanks.remove(enemyTank);
              Bomb bomb = new Bomb(myTank.x, myTank.y);
                bombs.add(bomb);
            }
        }

    }

    @Override
    public void paint(Graphics g) {
        super.paint(g);
        g.fillRect(0, 0, 1000, 750);
        showInfo_(g);
        if(myTank.isLive){
            drawTank(myTank.x,myTank.y,g,0,myTank.dir);
        }
        for (int i = 0; i < myTank.shots.size(); i++) {
            Shot shot = myTank.shots.get(i);
            if(shot.isLive){
                g.draw3DRect(shot.x,shot.y,2,2,false);
            }
            else {
                myTank.shots.remove(shot);
            }
        }
        for (int i = 0; i < enemyTanks.size(); i++) {
            EnemyTank enemyTank = enemyTanks.get(i);
            if(enemyTank.isLive){
                drawTank(enemyTank.x,enemyTank.y,g,1,enemyTank.getDir());
                for(int j = 0;j<enemyTank.shots.size();j++){
                    Shot shot = enemyTank.shots.get(j);
                    if(shot.isLive){
                        g.draw3DRect(shot.x, shot.y, 2, 2, false);
                    }else {
                        enemyTank.shots.remove(shot);
                    }
                }
            }
        }
        for (int i = 0; i < bombs.size(); i++) {
            Bomb bomb = bombs.get(i);
            if(bomb.life>6){
                g.drawImage(image1, bomb.x, bomb.y, 60, 60, this
                );
            } else if (bomb.life > 3) {
                g.drawImage(image2, bomb.x, bomb.y, 60, 60, this);

            } else {
                g.drawImage(image3, bomb.x, bomb.y, 60, 60, this);
            }
            bomb.lifeDown();
            if (bomb.life == 0) {
                bombs.remove(bomb);
            }
        }

        }


    public void hitTank(Shot s, Tank tank) {
        switch (tank.dir) {
            case 0:
            case 2:
                if( (s.x > tank.x && s.x < tank.x + 40 && s.y > tank.y && s.y < tank.y + 60) ){
                    s.isLive = false;
                    tank.isLive = false;
                    if(tank instanceof EnemyTank){
                        enemyTanks.remove(tank);
                        Reader.addAllTanks();
                    }

                    Bomb bomb = new Bomb(tank.x, tank.y);
                    bombs.add(bomb);
                }
                break;
            case 1:
            case 3:
                if ((s.x > tank.x && s.x < tank.x + 60 && s.y > tank.y && s.y < tank.y + 40) ) {
                    s.isLive = false;
                    tank.isLive = false;
                    if(tank instanceof EnemyTank){
                        enemyTanks.remove(tank);
                       Reader.addAllTanks();
                    }
                    Bomb bomb = new Bomb(tank.x, tank.y);
                    bombs.add(bomb);
                }
                break;
        }
    }

    @Override
    public void keyTyped(KeyEvent e) {

    }

    @Override
    public void keyPressed(KeyEvent e) {
        if(e.getKeyCode()== KeyEvent.VK_W){
            myTank.setDir(0);
            if(myTank.y>0){
                myTank.moveUp();
            }
        }else if(e.getKeyCode()==KeyEvent.VK_A){
            myTank.setDir(3);
            if(myTank.x>0){
                myTank.moveLeft();
            }
        }else if (e.getKeyCode() == KeyEvent.VK_D) {
            myTank.setDir(1);
            {
                if (myTank.x + 60 < 1000) {
                    myTank.moveRight();
                }
            }
        }else if(e.getKeyCode() == KeyEvent.VK_S){
            myTank.setDir(2);
            if(myTank.y +60 <750){
                myTank.moveDown();
            }
        }
        if(e.getKeyCode() == KeyEvent.VK_J){
            myTank.shotEnemy();
        }
        this.repaint();
    }



  public  void hitMyTank(){
      for (int i = 0; i < enemyTanks.size(); i++) {
          EnemyTank enemyTank = enemyTanks.get(i);
          for(int j = 0;j<enemyTank.shots.size();j++){
              Shot shot = enemyTank.shots.get(j);
              if(shot.isLive &&myTank.isLive){
                  hitTank(shot,myTank);
              }
          }
      }
  }
  public  void hitEnemyTank(){
        for(int i = 0;i<myTank.shots.size();i++){
            Shot shot = myTank.shots.get(i);
            if(shot.isLive){
                for (int j = 0; j < enemyTanks.size(); j++) {
                    EnemyTank enemyTank = enemyTanks.get(j);
                    hitTank(shot,enemyTank);
                }
            }

        }
  }
    @Override
    public void keyReleased(KeyEvent e) {

    }
    public void drawTank(int x, int y, Graphics g, int type, int dir) {
        //用switch 语句来控制
        switch (type) {
            case 0:
                //我方的坦克
                g.setColor(Color.cyan);
                break;
            case 1:
                //敌方的坦克
                g.setColor(Color.yellow);
                break;
        }
        //direction 表示坦克的方向，0表示向上，1表示向右，2表示向下，3表示向左
        switch (dir) {
            case 0://坦克向上
                g.fill3DRect(x, y, 10, 60, false);//画左边的
                g.fill3DRect(x + 30, y, 10, 60, false);//画左边的
                g.fill3DRect(x + 10, y + 10, 20, 40, false);//画中间的
                g.fillOval(x + 10, y + 20, 20, 20);//画圆盖子
                g.drawLine(x + 20, y + 30, x + 20, y);//画一条线
                break;
            case 1://坦克向右
                g.fill3DRect(x, y, 60, 10, false);//画上边的
                g.fill3DRect(x, y + 30, 60, 10, false);//画下边的
                g.fill3DRect(x + 10, y + 10, 40, 20, false);//画中间的
                g.fillOval(x + 20, y + 10, 20, 20);//画圆盖子
                g.drawLine(x + 30, y + 20, x + 60, y + 20);//画一条线
                break;
            case 2://坦克向下
                g.fill3DRect(x, y, 10, 60, false);//画左边的
                g.fill3DRect(x + 30, y, 10, 60, false);//画左边的
                g.fill3DRect(x + 10, y + 10, 20, 40, false);//画中间的
                g.fillOval(x + 10, y + 20, 20, 20);//画圆盖子
                g.drawLine(x + 20, y + 30, x + 20, y + 60);//画一条线
                break;
            case 3://坦克向左
                g.fill3DRect(x, y, 60, 10, false);//画上边的
                g.fill3DRect(x, y + 30, 60, 10, false);//画下边的
                g.fill3DRect(x + 10, y + 10, 40, 20, false);//画中间的
                g.fillOval(x + 20, y + 10, 20, 20);//画圆盖子
                g.drawLine(x + 30, y + 20, x, y + 20);//画一条线
                break;
            default:
                System.out.println("none");
        }
    }


    @Override
    public void run() {
        while (true){
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            hitMyTank();
            hitEnemyTank();
            TouchTank(myTank);
            this.repaint();
        }
    }
}

package com.tankgamepractice1;

import java.util.Vector;

/**
 * @author jessica~
 * @version 1.0
 */
public class EnemyTank extends Tank implements Runnable{

    Vector<Shot> shots = new Vector<>();
    Vector<EnemyTank> enemyTanks = new Vector<>();
    public EnemyTank(int x, int y) {
        super(x, y);
    }

    public void setEnemyTanks(Vector<EnemyTank> enemyTanks) {
        this.enemyTanks = enemyTanks;
    }

    //在哪里使用呢？在敌人坦克移动的时候
    public  Boolean isTouchTank(){
        //判断当前敌人坦克的方向
        switch (this.getDir()){
            case 0://up
                for (int i = 0; i < enemyTanks.size(); i++) {
                    EnemyTank enemyTank = enemyTanks.get(i);
                    //不能和自己比较，自己比较的化，就永远碰撞
                    //只要比较对象就可以了
                    if(enemyTank != this){
                        //敌人的其它坦克向上/向下
                        //敌人坦克x的范围x,x+40
                        //y 的范围是y ,y+60
                        if(enemyTank.getDir() == 0 ||enemyTank.getDir() ==2){
                            //当前坦克左上角x,y
                            if(this.x >= enemyTank.x &&this.x <= enemyTank.x+40
                                    &&this.y >=enemyTank.y && this.y <= enemyTank.y+60){
                                return true;
                            }
                            //右上角x+40,y
                            if(this.x+40 >= enemyTank.x &&this.x+40 <= enemyTank.x+40
                                    &&this.y >=enemyTank.y && this.y <= enemyTank.y+60){
                                return true;
                            }
                            //敌人坦克左和右
                            //范围x,x+60;y,y+40
                        }
                        if(enemyTank.getDir() == 3 ||enemyTank.getDir() ==1){
                            //左上角
                            if(this.x >= enemyTank.x &&this.x <= enemyTank.x+60
                                    &&this.y >=enemyTank.y && this.y <= enemyTank.y+40){
                                return true;
                            }
                            //右上角x+40,y
                            if(this.x+40 >= enemyTank.x &&this.x+40 <= enemyTank.x+60
                                    &&this.y >=enemyTank.y && this.y <= enemyTank.y+40){
                                return true;
                            }
                        }

                    }

                }
                break;
            case 1://right
                for (int i = 0; i < enemyTanks.size(); i++) {
                    EnemyTank enemyTank = enemyTanks.get(i);
                    //不能和自己比较，自己比较的化，就永远碰撞
                    //只要比较对象就可以了
                    if(enemyTank != this){
                        //敌人的其它坦克向上/向下
                        //敌人坦克x的范围x,x+40
                        //y 的范围是y ,y+60
                        if(enemyTank.getDir() == 0 ||enemyTank.getDir() ==2){
                            //当前坦克右上角x+60,y
                            if(this.x+60 >= enemyTank.x &&this.x+60 <= enemyTank.x+40
                                    &&this.y >=enemyTank.y && this.y <= enemyTank.y+60){
                                return true;
                            }
                            //右下角x+60,y+40
                            if(this.x+60 >= enemyTank.x &&this.x+60 <= enemyTank.x+40
                                    &&this.y+40 >=enemyTank.y && this.y+40 <= enemyTank.y+60){
                                return true;
                            }
                            //敌人坦克左和右
                            //范围x,x+60;y,y+40
                        }
                        if(enemyTank.getDir() == 3 ||enemyTank.getDir() ==1){
                            //右上角
                            if(this.x+60 >= enemyTank.x &&this.x+60 <= enemyTank.x+60
                                    &&this.y >=enemyTank.y && this.y <= enemyTank.y+40){
                                return true;
                            }
                            //右下角x+60,y+40
                            if(this.x+60 >= enemyTank.x &&this.x+60 <= enemyTank.x+60
                                    &&this.y+40 >=enemyTank.y && this.y+40 <= enemyTank.y+40){
                                return true;
                            }
                        }

                    }

                }
                break;
            case 2://down
                for (int i = 0; i < enemyTanks.size(); i++) {
                    EnemyTank enemyTank = enemyTanks.get(i);
                    //不能和自己比较，自己比较的化，就永远碰撞
                    //只要比较对象就可以了
                    if(enemyTank != this){
                        //敌人的其它坦克向上/向下
                        //敌人坦克x的范围x,x+40
                        //y 的范围是y ,y+60
                        if(enemyTank.getDir() == 0 ||enemyTank.getDir() ==2){
                            //当前坦克左下角x,y+60
                            if(this.x >= enemyTank.x &&this.x <= enemyTank.x+40
                                    &&this.y+60 >=enemyTank.y && this.y+60 <= enemyTank.y+60){
                                return true;
                            }
                            //右下角x+40,y+60
                            if(this.x+40 >= enemyTank.x &&this.x+40 <= enemyTank.x+40
                                    &&this.y+60 >=enemyTank.y && this.y+60 <= enemyTank.y+60){
                                return true;
                            }
                            //敌人坦克左和右
                            //范围x,x+60;y,y+40
                        }
                        if(enemyTank.getDir() == 3 ||enemyTank.getDir() ==1){
                            //当前坦克左下角x,y+60
                            if(this.x >= enemyTank.x &&this.x <= enemyTank.x+60
                                    &&this.y+60 >=enemyTank.y && this.y+60 <= enemyTank.y+40){
                                return true;
                            }
                            //右下角x+40,y+60
                            if(this.x+40 >= enemyTank.x &&this.x+40 <= enemyTank.x+60
                                    &&this.y+60 >=enemyTank.y && this.y+60 <= enemyTank.y+40){
                                return true;
                            }
                        }

                    }

                }
                break;
            case 3://left
                for (int i = 0; i < enemyTanks.size(); i++) {
                  EnemyTank enemyTank = enemyTanks.get(i);
                    //不能和自己比较，自己比较的化，就永远碰撞
                    //只要比较对象就可以了
                    if(enemyTank != this){
                        //敌人的其它坦克向上/向下
                        //敌人坦克x的范围x,x+40
                        //y 的范围是y ,y+60
                        if(enemyTank.getDir() == 0 ||enemyTank.getDir() ==2){
                            //当前坦克左上角x,y
                            if(this.x >= enemyTank.x &&this.x <= enemyTank.x+40
                                    &&this.y >=enemyTank.y && this.y <= enemyTank.y+60){
                                return true;
                            }
                            //左下角x,y+40
                            if(this.x >= enemyTank.x &&this.x <= enemyTank.x+40
                                    &&this.y+40 >=enemyTank.y && this.y+40 <= enemyTank.y+60){
                                return true;
                            }
                            //敌人坦克左和右
                            //范围x,x+60;y,y+40
                        }
                        if(enemyTank.getDir() == 3 ||enemyTank.getDir() ==1){
                            //当前坦克左上角x,y
                            if(this.x >= enemyTank.x &&this.x <= enemyTank.x+60
                                    &&this.y >=enemyTank.y && this.y<= enemyTank.y+40){
                                return true;
                            }
                            //左下角x,y+40
                            if(this.x>= enemyTank.x &&this.x <= enemyTank.x+60
                                    &&this.y+40 >=enemyTank.y && this.y+40 <= enemyTank.y+40){
                                return true;
                            }
                        }

                    }

                }
                break;
        }
        return  false;
    }
    @Override
    public void run() {
       Shot shot = null;
        while (isLive) {
            if (shots.size() < 4) {

            switch (getDir()) {
                case 0:
                    shot = new Shot(x + 20, y, 0);
                    break;
                case 1:
                    shot = new Shot(x + 60, y + 20, 1);
                    break;
                case 2:
                    shot = new Shot(x + 20, y + 60, 2);
                    break;
                case 3:
                    shot = new Shot(x, y + 20, 3);
                    break;
            }
            shots.add(shot);
            new Thread(shot).start();
        }
            switch (dir){
                case 0:
                    for (int i = 0; i < 30; i++) {
                        if(y>0  && !isTouchTank()){
                            moveUp();

                        }
                        //每一次移动都需要休眠一下，不然看不出效果
                        try {
                            Thread.sleep(50);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                case 1:
                    for (int i = 0; i < 30; i++) {
                        if (x + 60 < 1000&& !isTouchTank()) {
                            moveRight();
                        }

                        //每一步都让它休眠一下
                        try {
                            Thread.sleep(50);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    break;
                case 2:
                    for (int i = 0; i < 30; i++) {

                        if (y + 60 < 750&& !isTouchTank()) {
                            moveDown();
                        }

                        try {
                            Thread.sleep(50);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    break;
                case 3:
                    for (int i = 0; i < 30; i++) {
                        if (x> 0 && !isTouchTank()) {
                            moveLeft();
                        }


                        try {
                            Thread.sleep(50);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    break;



            }
            setDir((int)(Math.random()*4));
        }
    }
}

package com.tankgamepractice1;

/**
 * @author jessica~
 * @version 1.0
 */
public class Bomb {
    int x;
    int y;
    int life = 9;
    //是boolean ，不是Boolean
    boolean isLive ;

    public Bomb(int x, int y) {
        this.x = x;
        this.y = y;
    }
    public  void lifeDown(){
        //这里设置错误，我设置为>6，
        // 结果就导致炸弹持续在最大的状态，不消失
        if(life>0){
            life --;

        }else {
            isLive = false;
        }
    }
}

package com.tankgamepractice1;

import javax.sound.sampled.*;
import java.io.File;
import java.io.IOException;

/**
 * @author jessica~
 * @version 1.0
 */
public class AePlayWave extends Thread{
    private String filename;

    public AePlayWave(String wavfile) { //构造器 , 指定文件
        filename = wavfile;

    }

    public void run() {

        File soundFile = new File(filename);

        AudioInputStream audioInputStream = null;
        try {
            audioInputStream = AudioSystem.getAudioInputStream(soundFile);
        } catch (Exception e1) {
            e1.printStackTrace();
            return;
        }

        AudioFormat format = audioInputStream.getFormat();
        SourceDataLine auline = null;
        DataLine.Info info = new DataLine.Info(SourceDataLine.class, format);

        try {
            auline = (SourceDataLine) AudioSystem.getLine(info);
            auline.open(format);
        } catch (Exception e) {
            e.printStackTrace();
            return;
        }

        auline.start();
        int nBytesRead = 0;
        //这是缓冲
        byte[] abData = new byte[512];

        try {
            while (nBytesRead != -1) {
                nBytesRead = audioInputStream.read(abData, 0, abData.length);
                if (nBytesRead >= 0)
                    auline.write(abData, 0, nBytesRead);
            }
        } catch (IOException e) {
            e.printStackTrace();
            return;
        } finally {
            auline.drain();
            auline.close();
        }

    }
}