Java初学笔记28

• 坦克游戏部分代码0.2
• • 1.Tank
  • 2.MyTank
  • 3.EnemyTank
  • 4.Bullet
  • 5.MyBullet
  • 6.EnemyBullet
  • 7.Bomb
  • 8.Recorder
  • 9.Node
  • 10.AePlayWave
  • 11.TankPanel
  • 12.TankGame05

坦克游戏部分代码0.2

1.Tank

package project.tankgame05;

/**
 * @ClassName: Tank
 * @Description: 坦克父类
 */
public class Tank {
    private int x; //坦克的横坐标
    private int y; //坦克的纵坐标
    private int direction; //坦克方向 0123 上下左右
    private int speed = 3; //坦克速度

    /**
     * 坦克存活状态
     */
    private boolean t_sur = true;

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

    /**
     * 坦克上移动方法
     */
    public void moveUp(){
        y -= speed;
    }

    /**
     * 坦克右移动方法
     */
    public void moveRight(){
        x += speed;
    }

    /**
     * 坦克下移动方法
     */
    public void moveDown(){
        y += speed;
    }

    /**
     * 坦克左移动方法
     */
    public void moveLeft(){
        x -= speed;
    }

    /**
     * 坦克开火的方法
     */
    public void fire(){

    }

    public int getDirection() {
        return direction;
    }

    public void setDirection(int direction) {
        this.direction = direction;
    }

    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 getSpeed() {
        return speed;
    }

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

    public boolean isT_sur() {
        return t_sur;
    }

    public void setT_sur(boolean t_sur) {
        this.t_sur = t_sur;
    }
}

2.MyTank

package project.tankgame05;


import java.util.Vector;

/**
 * @ClassName: MyTank
 * @Description: 自己的坦克
 */
public class MyTank extends Tank {  //继承父类坦克

    /**
     * 属性：自己的子弹线程
     */
    MyBullet myBullet = null;

    /**
     * Vector集合：存储自己的子弹集合
     */
    Vector<MyBullet> myBullets = new Vector<>();

    /**
     * 自己的坦克-构造器
     */
    public MyTank(int x, int y) {
        super(x, y);
    }

    /**
     * 方法：自己坦克开火。
     * 实例化并启动自己的子弹线程
     */
    @Override
    public void fire() {
        //游戏面板控制自己的子弹最多为8个
        if(myBullets.size() == 8){
            return;
        }
        switch (getDirection()){
            case 0:
                myBullet = new MyBullet(getX()+20,getY(),getDirection());
                break;
            case 1:
                myBullet = new MyBullet(getX()+60,getY()+20,getDirection());
                break;
            case 2:
                myBullet = new MyBullet(getX()+20,getY()+60,getDirection());
                break;
            case 3:
                myBullet = new MyBullet(getX(),getY()+20,getDirection());
                break;
        }
        //将自己的子弹线程加入集合
        myBullets.add(myBullet);
        //启动子弹线程
        new Thread(myBullet).start();
    }

}

3.EnemyTank

package project.tankgame05;

import java.util.Vector;

/**
 * @ClassName: EnemyTank
 * @Description: 敌人的坦克线程
 */
public class EnemyTank extends Tank implements Runnable{
    /**
     * Vector集合：每个敌人坦克用集合存放自己的多个子弹线程
     */
    Vector<EnemyBullet> e_Bullets_Ve = new Vector<>();


    /**
     * Vector集合：每个敌人坦克用集合存放其他的敌人坦克线程（该集合内也有自己的）
     */
    Vector<EnemyTank> enemyTanks = new Vector<>();

    /**
     * 可以在TankPanel类中调用该方法，在每个敌人内部初始化多个敌人坦克线程
     * @param enemyTanks
     */
    public void setEnemyTanks(Vector<EnemyTank> enemyTanks) {
        this.enemyTanks = enemyTanks;
    }

    /**
     * 判断当前坦克是否与其他坦克重叠
     * @return
     */
    public boolean isTouchEnemyTank(){
        //遍历取出每一个敌人坦克
        for (int i = 0; i < enemyTanks.size(); i++) {
            EnemyTank enemyTank = enemyTanks.get(i);
            //因为该集合中有自己的的坦克线程，自己坦克不能和自己坦克比较
            if(this != enemyTank){
                //把每个坦克看成60*60的矩形，判断两个坦克中心是否小于60
                double len = Math.sqrt((this.getX() - enemyTank.getX())*(this.getX() - enemyTank.getX())+
                        (this.getY() - enemyTank.getY())*(this.getY() - enemyTank.getY()));
                if(len <= 70){
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * 敌人坦克的构造器
     * @param x
     * @param y
     */
    public EnemyTank(int x, int y) {
        super(x, y);
    }

    @Override
    public void run() {
        while (true){

            //判断此时敌人坦克是否存活，以及坦克里面的子弹线程是否还有
            //使敌人坦克可以发射5颗子弹
            if(isT_sur() && e_Bullets_Ve.size() < 5){

                EnemyBullet bul = null;
                //根据此时坦克的位置创建敌人子弹线程
                switch (getDirection()){
                    case 0:
                        bul = new EnemyBullet(getX()+20,getY(),0);
                        break;
                    case 1:
                        bul = new EnemyBullet(getX()+60,getY()+20,1);
                        break;
                    case 2:
                        bul = new EnemyBullet(getX()+20,getY()+60,2);
                        break;
                    case 3:
                        bul = new EnemyBullet(getX(),getY()+20,3);
                        break;
                }
                //将敌人子弹线程加入集合
                e_Bullets_Ve.add(bul);
                //启动敌人子弹线程
                new Thread(bul).start();
            }
            //敌人坦克随机移动
            switch (getDirection()){
                case 0:
                    for (int i = 0; i < 10; i++) {
                        try {
                            Thread.sleep(50);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        if(getY() > 0 && !isTouchEnemyTank()){
                            moveUp();
                        }
                    }
                    break;
                case 1:
                    for (int i = 0; i < 10; i++) {
                        try {
                            Thread.sleep(50);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        if(getX() + 60 < 1000  && !isTouchEnemyTank()){
                            moveRight();
                        }
                    }
                    break;
                case 2:
                    for (int i = 0; i < 10; i++) {
                        try {
                            Thread.sleep(50);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        if(getY() + 60 < 750  && !isTouchEnemyTank()){
                            moveDown();
                        }
                    }
                    break;
                case 3:
                    for (int i = 0; i < 10; i++) {
                        try {
                            Thread.sleep(50);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        if(getX() > 0 && !isTouchEnemyTank()){
                            moveLeft();
                        }
                    }
                    break;
            }

            //为敌人坦克设置随机方向
            setDirection((int)(Math.random()*4));
            //敌人坦克死亡，结束线程
            if(!isT_sur()){
                System.out.println("敌人坦克线程： "+ Thread.currentThread().getName()
                        +" 已经结束");
                break;
            }
        }
    }
}

4.Bullet

package project.tankgame05;

/**
 * @Package: project.tankgame03
 * @ClassName: Bullet
 * @Author: 爱吃凉拌辣芒果
 * @CreateTime: 2021/10/28 9:50
 * @Description:  子弹父类
 */
public class Bullet {
    /**
     * 子弹的b_x位置
     */
    private int b_x;
    /**
     * 子弹的b_y位置
     */
    private int b_y;
    /**
     * 子弹的方向 0123 上右下左
     */
    private int b_direction;
    /**
     * 子弹的速度  默认3
     */
    private int b_speed = 3;
    /**
     * 子弹存活状态
     */
    private boolean b_sur = true;

    /**
     * 构造函数：初始化子弹的原始位置以及方向
     * @param b_x
     * @param b_y
     * @param b_direction
     */
    public Bullet(int b_x, int b_y, int b_direction) {
        this.b_x = b_x;
        this.b_y = b_y;
        this.b_direction = b_direction;
    }

    /**
     * 获取子弹x坐标
     * @return
     */
    public int getB_x() {
        return b_x;
    }

    /**
     * 设置子弹x坐标
     * @return
     */
    public void setB_x(int b_x) {
        this.b_x = b_x;
    }

    /**
     * 获取子弹y坐标
     * @return
     */
    public int getB_y() {
        return b_y;
    }

    /**
     * 设置子弹y坐标
     * @return
     */
    public void setB_y(int b_y) {
        this.b_y = b_y;
    }

    /**
     * 获取子弹方向
     * @return
     */
    public int getB_direction() {
        return b_direction;
    }

    /**
     * 设置获取子弹方向
     * @return
     */
    public void setB_direction(int b_direction) {
        this.b_direction = b_direction;
    }


    /**
     * 获取子弹速度
     * @return
     */
    public int getB_speed() {
        return b_speed;
    }


    /**
     * 设置子弹速度
     * @return
     */
    public void setB_speed(int b_speed) {
        this.b_speed = b_speed;
    }

    /**
     * 获取子弹存活状态
     * @return
     */
    public boolean isB_sur() {
        return b_sur;
    }

    /**
     * 设置子弹存活状态
     * @return
     */
    public void setB_sur(boolean b_sur) {
        this.b_sur = b_sur;
    }
}

5.MyBullet

package project.tankgame05;

/**
 * @Package: project.tankgame03
 * @ClassName: MyBullet
 * @Author: 爱吃凉拌辣芒果
 * @CreateTime: 2021/10/28 9:57
 * @Description:  我的子弹线程
 */
public class MyBullet extends Bullet implements Runnable{

    /**
     * 构造函数：初始化我的子弹原始位置以及方向
     *
     * @param b_x
     * @param b_y
     * @param b_direction
     */
    public MyBullet(int b_x, int b_y, int b_direction) {
        super(b_x, b_y, b_direction);
    }

    @Override
    public void run() {
        while (true){
            //休眠50毫秒
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //判断自己的子弹方向，沿着这一方向移动
            switch (getB_direction()){
                case 0:
                    setB_y(getB_y()-getB_speed());
                    break;
                case 1:
                    setB_x(getB_x()+getB_speed());
                    break;
                case 2:
                    setB_y(getB_y()+getB_speed());
                    break;
                case 3:
                    setB_x(getB_x()-getB_speed());
                    break;
            }
            //System.out.println("我的子弹坐标"+getB_x()+" "+getB_y());

            //如果自己的子弹超出世界边界，或者生命状态在其他地方被设置成false，则
            //设置子弹线程的生命状态为false，并且结束线程
            if(!(getB_x()>=0 && getB_x()<=1000 && getB_y()>=0 &&getB_y()<=750)
                    || isB_sur() == false){
                setB_sur(false);
                System.out.println("我的子弹线程 "+ Thread.currentThread().getName() +" 已经结束");
                break;
            }
        }
    }
}

6.EnemyBullet

package project.tankgame05;

/**
 * @Package: project.tankgame03
 * @ClassName: EnemyBullet
 * @Author: 爱吃凉拌辣芒果
 * @CreateTime: 2021/10/28 14:10
 * @Description:
 */
public class EnemyBullet extends Bullet implements Runnable{
    /**
     * 构造函数：初始化敌人子弹的原始位置以及方向
     *
     * @param b_x
     * @param b_y
     * @param b_direction
     */
    public EnemyBullet(int b_x, int b_y, int b_direction) {
        super(b_x, b_y, b_direction);
    }

    @Override
    public void run() {
        while (true){
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //设置敌人子弹朝着某一方向移动
            switch (getB_direction()){
                case 0:
                    setB_y(getB_y()-getB_speed());
                    break;
                case 1:
                    setB_x(getB_x()+getB_speed());
                    break;
                case 2:
                    setB_y(getB_y()+getB_speed());
                    break;
                case 3:
                    setB_x(getB_x()-getB_speed());
                    break;
            }
            //System.out.println("敌人子弹坐标"+getB_x()+" "+getB_y());
            if(!(getB_x()>=0 && getB_x()<=1000 && getB_y()>=0 &&getB_y()<=750)
                    || !isB_sur()){
                setB_sur(false);
                System.out.println("敌人子弹线程 "+ Thread.currentThread().getName() +" 已经结束");
                break;
            }
        }
    }
}

7.Bomb

package project.tankgame05;

/**
 * @Package: project.tankgame03
 * @ClassName: Bomb
 * @Author: 爱吃凉拌辣芒果
 * @CreateTime: 2021/10/29 9:41
 * @Description: 炸弹特效类
 */
public class Bomb {
    /**
     * 炸弹的X坐标
     */
    int x;

    /**
     * 炸弹的Y坐标
     */
    int y;

    /**
     * 炸弹的生命周期
     */
    int life = 9;

    /**
     * 炸弹的存活状态
     */
    boolean isLive = true;

    /**
     * 炸弹构造器，初始化X,Y坐标
     * @param x
     * @param y
     */
    public Bomb(int x, int y) {
        this.x = x;
        this.y = y;
    }

    /**
     * 使炸弹图片生命值逐渐减少
     */
    public void cutLife(){
        if(isLive && life>=0){
            life--;
        }else{
            isLive = false;
        }
    }
}

8.Recorder

package project.tankgame05;

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

/**
 * @Package: project.tankgame05
 * @ClassName: Recorder
 * @Author: 爱吃凉拌辣芒果
 * @CreateTime: 2021/11/5 11:12
 * @Description: 与文件进行交互
 */
public class Recorder {
    /**
     * 击毁敌人坦克数量
     */
    private static int killEneTankNum = 0;

    /**
     * 定义输出文件对象
     */
    private static BufferedWriter bw = null;

    /**
     * 定义输入文件对象
     */
    private static BufferedReader br = null;

    /**
     * 定义存放敌人数量的文件路径
     */
    private static String filePath = "src\\record.txt";
    /**
     * 定义存放存活敌人的文件路径
     */
    private static String filePath1 = "src\\record2.txt";

    /**
     * 使击毁的敌人坦克数量就加1
     */
    public static void addkillEneTankNum(){
        Recorder.killEneTankNum++;
    }

    /**
     * 集合：记录敌人坦克信息
     */
    private static Vector<EnemyTank> enemyTanks = null;

    /**
     * 定义我的坦克
     */
    private static MyTank mytank = null;

    /**
     * 集合：记录恢复的坦克信息
     */
    private static Vector<Node> nodes = new Vector<>();

    /**
     * 初始化敌人坦克线程
     * @param enemyTanks
     */
    public static void setEnemyTanks(Vector<EnemyTank> enemyTanks) {
        Recorder.enemyTanks = enemyTanks;
    }

    /**
     * 初始化自己坦克
     * @param mytank
     */
    public static void setMytank(MyTank mytank) {
        Recorder.mytank = mytank;
    }

    /**
     * 关闭游戏时将击毁敌人坦克的数量写入文件
     */
    public static void storekillEneTankNum(){
        try {
            bw = new BufferedWriter(new FileWriter(filePath));
//            bw.write(killEneTankNum+"\r\n");
            bw.write(killEneTankNum+"");
            bw.newLine();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if(bw != null){
                    bw.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 关闭游戏时将存活的敌人与自己的坦克写入文件
     */
    public static void storeAliveEneTank(){
        try {
            bw = new BufferedWriter(new FileWriter(filePath1));
            //存入敌人坦克
            for (int i = 0; i < enemyTanks.size(); i++) {
                //取出每一个坦克
                EnemyTank enemyTank = enemyTanks.get(i);
                if(enemyTank.isT_sur()){
                    String str = enemyTank.getX() + " " + enemyTank.getY()
                            + " " + enemyTank.getDirection();
                    //bw.write(str+"\r\n");
                    bw.write(str);
                    bw.newLine();
                }
            }
            //存入自己的坦克
            if(mytank!= null && mytank.isT_sur()){
                String str = mytank.getX() + " " + mytank.getY()
                        + " " + mytank.getDirection();
                bw.write(str);
                bw.newLine();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if(bw!=null){
                    bw.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 恢复读取已经击杀的敌人坦克数量
     * @return
     */
    public static void readKillTankNum(){
        try {
            br = new BufferedReader(new FileReader(filePath));
            Recorder.killEneTankNum = Integer.parseInt(br.readLine());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                br.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 恢复坦克位置方向信息
     * @return
     */
    public static Vector<Node> readTank(){
        try {
            br = new BufferedReader(new FileReader(filePath1));
            String tanks = null;
            while ((tanks = br.readLine()) != null){
                String[] s = tanks.split(" ");
                Node node = new Node(Integer.parseInt(s[0])
                        , Integer.parseInt(s[1])
                        , Integer.parseInt(s[2]));
                nodes.add(node);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                br.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return nodes;
        }
    }

    public static int getKillEneTankNum() {
        return killEneTankNum;
    }

    public static void setKillEneTankNum(int killEneTankNum) {
        Recorder.killEneTankNum = killEneTankNum;
    }
}

9.Node

package project.tankgame05;

/**
 * @Package: project.tankgame05
 * @ClassName: Node
 * @Author: 爱吃凉拌辣芒果
 * @CreateTime: 2021/11/7 9:52
 * @Description: Node节点恢复保存的坦克
 */
public class Node {
    /**
     * 用于保存恢复的坦克的x,y,方法
     */
    private int x;
    private int y;
    private int direct;

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

    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 getDirect() {
        return direct;
    }

    public void setDirect(int direct) {
        this.direct = direct;
    }
}

10.AePlayWave

package project.tankgame05;

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

/**
 *  wav音频播放线程
 */
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();
        }

    }
}

11.TankPanel

package project.tankgame05;

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

/**
 * @ClassName: TankPanel
 * @Description: 坦克游戏区域————“画板”
 */
public class TankPanel extends JPanel implements KeyListener,Runnable{

    /**
     * 定义我的坦克
     */
    MyTank mytank = null;

    /**
     * Vector集合：集合中存放敌人坦克
     */
    Vector<EnemyTank> enemyTanks = new Vector<>();

    /**
     * Vector集合：集合中存放恢复的坦克
     */
    Vector<Node> nodes = new Vector<>();

    /**
     * 敌人坦克数量
     */
    int enemyTankNum = 5;

    /**
     * Vector集合：存放炸弹特效
     * 当自己的子弹击中敌人坦克时，加入一个炸弹
     */
    Vector<Bomb> bombs = new Vector<>();

    /**
     * 声明3个存放炸弹特效的变量image1，image2，image3
     */
    Image image1 = null;
    Image image2 = null;
    Image image3 = null;

    /**
     * “画板”构造器
     */
    public TankPanel(String key){
        File file1 = new File("src\\record.txt");
        File file2 = new File("src\\record2.txt");
        if(!file1.exists() && !file2.exists()){
            key = "1";
            System.out.println("读取旧游戏失败，开启新游戏");
        }
        switch (key){
            case "1": //1: 开始新游戏
                //初始化我的坦克
                mytank = new MyTank(100,600);
                //初始化敌人坦克，默认朝下
                for (int i = 0; i < enemyTankNum; i++) {
                    EnemyTank enemyTank = new EnemyTank(150 * (i + 1), 0);
                    //初始化敌人的子弹
                    EnemyBullet enemyBullet = new EnemyBullet(enemyTank.getX() + 20,
                            enemyTank.getY() + 60, 2);
                    //把敌人子弹加入到集合中
                    enemyTank.e_Bullets_Ve.add(enemyBullet);
                    //启动敌人子弹线程
                    new Thread(enemyBullet).start();
                    enemyTank.setDirection(2);
                    //把敌人坦克加入到集合中
                    enemyTanks.add(enemyTank);
                    //将 enemyTanks集合 赋值给每个敌人坦克
                    enemyTank.setEnemyTanks(enemyTanks);
                    //启动敌人坦克
                    new Thread(enemyTank).start();
                }
                //将敌人坦克线程初始化到Recorder
                Recorder.setEnemyTanks(enemyTanks);
                //将自己的坦克初始化到Recorder
                Recorder.setMytank(mytank);
                break;
            case "2": //2: 继续上局游戏
                //恢复击杀敌人信息
                Recorder.readKillTankNum();
                //恢复坦克信息
                nodes = Recorder.readTank();
                if(nodes == null){
                    break;
                }
                //核对坦克数量信息
                int hedui = (Recorder.getKillEneTankNum() + nodes.size());
                if(hedui != enemyTankNum){
                    //初始化我的坦克
                    Node node = nodes.get(this.nodes.size() - 1);
                    mytank = new MyTank(node.getX(),node.getY());
                    mytank.setDirection(node.getDirect());
                    //初始化敌人坦克
                    for (int i = 0; i < nodes.size()-1; i++) {
                        //取出敌人坦克节点信息
                        Node node1 = nodes.get(i);
                        EnemyTank enemyTank = new EnemyTank(node1.getX(),node1.getY());
                        //初始化敌人的子弹
                        EnemyBullet enemyBullet = new EnemyBullet(enemyTank.getX() + 20,
                                enemyTank.getY() + 60, node1.getDirect());
                        //把敌人子弹加入到集合中
                        enemyTank.e_Bullets_Ve.add(enemyBullet);
                        //启动敌人子弹线程
                        new Thread(enemyBullet).start();
                        //设置敌人坦克方向
                        enemyTank.setDirection(node1.getDirect());
                        //把敌人坦克加入到集合中
                        enemyTanks.add(enemyTank);
                        //将 enemyTanks集合 赋值给每个敌人坦克
                        enemyTank.setEnemyTanks(enemyTanks);
                        //启动敌人坦克
                        new Thread(enemyTank).start();
                    }
                    //将敌人坦克线程初始化到Recorder
                    Recorder.setEnemyTanks(enemyTanks);
                    //将自己的坦克初始化到Recorder
                    Recorder.setMytank(mytank);
                }else{
                    //初始化敌人坦克
                    for (int i = 0; i < nodes.size(); i++) {
                        //取出敌人坦克节点信息
                        Node node1 = nodes.get(i);
                        EnemyTank enemyTank = new EnemyTank(node1.getX(),node1.getY());
                        //初始化敌人的子弹
                        EnemyBullet enemyBullet = new EnemyBullet(enemyTank.getX() + 20,
                                enemyTank.getY() + 60, node1.getDirect());
                        //把敌人子弹加入到集合中
                        enemyTank.e_Bullets_Ve.add(enemyBullet);
                        //启动敌人子弹线程
                        new Thread(enemyBullet).start();
                        //设置敌人坦克方向
                        enemyTank.setDirection(node1.getDirect());
                        //把敌人坦克加入到集合中
                        enemyTanks.add(enemyTank);
                        //将 enemyTanks集合 赋值给每个敌人坦克
                        enemyTank.setEnemyTanks(enemyTanks);
                        //启动敌人坦克
                        new Thread(enemyTank).start();
                    }
                    //将敌人坦克线程初始化到Recorder
                    Recorder.setEnemyTanks(enemyTanks);
                    //将自己的坦克初始化到Recorder
                    Recorder.setMytank(mytank);
                }
                break;
            default:
                System.out.println("输入有误~~");
        }
        //初始化炸弹特效图片
        image1 = Toolkit.getDefaultToolkit()
                .getImage(TankPanel.class.getResource("/bomb_1.gif"));
        image2 = Toolkit.getDefaultToolkit()
                .getImage(TankPanel.class.getResource("/bomb_2.gif"));
        image3 = Toolkit.getDefaultToolkit()
                .getImage(TankPanel.class.getResource("/bomb_3.gif"));

        //播放音乐
        new AePlayWave("src\\111.wav").start();
    }

    /**
     * 显示玩家成绩
     */
    public void showInfor(Graphics g){
        g.setColor(Color.black);
        Font font = new Font("楷体", Font.BOLD, 25);
        g.setFont(font);
        g.drawString("已击毁敌人坦克",1020,30);

        drawTank(1020,60,g,0,1);
        g.setColor(Color.black);
        g.drawString(Recorder.getKillEneTankNum()+"",1080,100);
    }

    /**
     * paint绘画方法
     * @param g
     */
    @Override
    public void paint(Graphics g) {
        super.paint(g);
        //默认黑色矩形背景
        g.setColor(Color.BLACK);
        //默认黑色矩形1000 × 750
        g.fillRect(0,0,1000,750);

        //绘制成绩
        showInfor(g);
        //绘制-自己的坦克
        if(mytank != null && mytank.isT_sur()){
            drawTank(mytank.getX(),mytank.getY(),g,mytank.getDirection(),0);
        }

        //绘制敌人的坦克
        //判断敌人坦克集合不为空
        if(enemyTanks != null){
            //遍历敌人坦克集合
            for (int i = 0; i < enemyTanks.size(); i++) {
                //取出每个敌人坦克
                EnemyTank enemyTank = enemyTanks.get(i);
                //判断每个坦克的生命状态
                if(enemyTank.isT_sur()) {
                    drawTank(enemyTank.getX(), enemyTank.getY(), g,
                            enemyTank.getDirection(), 1);
                }else{
                    //坦克的生命状态为false，除了不绘画之外，还需要在
                    //集合中移除
                    enemyTanks.remove(enemyTank);
                }
            }
        }

        //绘制自己的子弹
        //遍历自己的子弹集合
        if(mytank != null && mytank.myBullets != null){
            for (int i = 0; i < mytank.myBullets.size(); i++) {
                //取出每个子弹
                MyBullet myBullet = mytank.myBullets.get(i);
                //判断子弹的生命状态
                if(myBullet != null && myBullet.isB_sur()){
                    g.setColor(Color.RED);
                    g.fillOval(myBullet.getB_x(),myBullet.getB_y(),5,5);
                }else{
                    mytank.myBullets.remove(myBullet);
                }
            }
        }

        //绘制敌人的子弹
        //判断敌人坦克集合不为空
        if(enemyTanks != null ){
            //遍历敌人坦克集合
            for (int i = 0; i < enemyTanks.size(); i++) {
                //取出每个敌人坦克
                EnemyTank enemyTank = enemyTanks.get(i);
                //判断敌人坦克的子弹集合不为空
                if(enemyTank.e_Bullets_Ve != null){
                    //遍历敌人坦克的子弹集合
                    for (int j = 0; j < enemyTank.e_Bullets_Ve.size(); j++) {
                        //取出每个敌人坦克的子弹
                        EnemyBullet enemyBullet = enemyTank.e_Bullets_Ve.get(j);
                        //判断每个敌人子弹的状态
                        if(enemyBullet.isB_sur()){
                            g.setColor(Color.yellow);
                            g.fillOval(enemyBullet.getB_x(), enemyBullet.getB_y(),
                                    5, 5);
                        }else{
                            //敌人子弹的生命状态为false，除了不绘画之外
                            // 还需要在集合中移除
                            enemyTank.e_Bullets_Ve.remove(enemyBullet);
                        }
                    }
                }
            }
        }

        //绘制炸弹特效
        //遍历炸弹集合
        for (int i = 0; i < bombs.size(); i++) {
            //取出每一个炸弹
            Bomb bomb = bombs.get(i);
            if(bomb.isLive){
                //分阶段绘制炸弹
                if(bomb.life > 6){
                    g.drawImage(image1,bomb.x,bomb.y,50,50,this);
                    bomb.cutLife();
                }else if(bomb.life > 3){
                    g.drawImage(image2,bomb.x,bomb.y,50,50,this);
                    bomb.cutLife();
                }else{
                    g.drawImage(image3,bomb.x,bomb.y,50,50,this);
                    bomb.cutLife();
                }
            }else{
                bombs.remove(bomb);
            }
        }
    }

    /**
     * 画坦克的方法
     * @param x 坦克左上角的x坐标
     * @param y 坦克右上角的x坐标
     * @param g 画笔
     * @param direct  坦克的方向（上下左右）
     * @param type 坦克类型
     */
    public void drawTank(int x, int y, Graphics g,int direct,int type){
        //根据不同类型的坦克，设置不同的颜色
        switch (type){
            case 0://我们的坦克
                g.setColor(Color.pink);
                break;
            case 1: //敌人坦克
                g.setColor(Color.yellow);
                break;
        }

        //根据坦克方向，绘制不同的坦克
        switch (direct){
            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,y+20,x+30,y+20);  //坦克炮筒
                break;
        }
    }

    /**
     * 字符输出事件方法
     * @param e
     */
    @Override
    public void keyTyped(KeyEvent e) {

    }

    /**
     * 键盘按下事件方法
     * WDSA 坦克的方向：上右下左
     * @param e
     */
    @Override
    public void keyPressed(KeyEvent e) {
        if(e.getKeyCode() == KeyEvent.VK_W){
            mytank.setDirection(0);  //更改坦克的方向
            if(mytank.getY()>0){
                mytank.moveUp(); //使坦克向上走
            }
        }else if(e.getKeyCode() == KeyEvent.VK_D){
            mytank.setDirection(1);
            if(mytank.getX()+60<1000){
                mytank.moveRight(); //使坦克向右走
            }
        }else if(e.getKeyCode() == KeyEvent.VK_S){
            mytank.setDirection(2);
            if(mytank.getY()+60<750){
                mytank.moveDown(); //使坦克向下走
            }
        }else if(e.getKeyCode() == KeyEvent.VK_A){
            mytank.setDirection(3);
            if(mytank.getX()>0){
                mytank.moveLeft(); //使坦克向左走
            }
        }
        //按下J键 子弹射击
        if(mytank != null && mytank.isT_sur()){
            if(e.getKeyCode() == KeyEvent.VK_J){
                mytank.fire();
            }
        }
        this.repaint();
    }

    /**
     * 键盘弹起事件方法
     * @param e
     */
    @Override
    public void keyReleased(KeyEvent e) {

    }

    /**
     * “画板”刷新
     */
    @Override
    public void run() {
        while (true){
            //画板隔0.1秒刷新一次
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            killEnenmy();
            killMyTank();
            this.repaint();
        }
    }

    /**
     * 方法：自己的子弹打敌人坦克
     * 设置自己的子弹和敌人坦克的生命状态
     * @param myBullet  自己的子弹
     * @param enemyTank  敌人坦克
     */
    public void bitEnenmy(MyBullet myBullet, EnemyTank enemyTank){
        switch (enemyTank.getDirection()){
            case 0:
            case 2:
                if(myBullet.getB_x() >= enemyTank.getX() && myBullet.getB_x() <= enemyTank.getX()+40
                        && myBullet.getB_y() >= enemyTank.getY() && myBullet.getB_y() <= enemyTank.getY()+60 ){
                    //子弹状态：FALSE
                    myBullet.setB_sur(false);
                    //坦克状态：FALSE
                    enemyTank.setT_sur(false);
                    for (int i = 0; i < enemyTank.e_Bullets_Ve.size(); i++) {
                        EnemyBullet enemyBullet = enemyTank.e_Bullets_Ve.get(i);
                        enemyBullet.setB_sur(false);
                    }
                    //敌人坦克被击毁的数量加1
                    Recorder.addkillEneTankNum();
                    //把炸弹特效放在敌人位置处，并加入集合
                    bombs.add(new Bomb(enemyTank.getX(),enemyTank.getY()));
                }
                break;
            case 1:
            case 3:
                if(myBullet.getB_x() >= enemyTank.getX() && myBullet.getB_x() <= enemyTank.getX()+60
                        && myBullet.getB_y() >= enemyTank.getY() && myBullet.getB_y() <= enemyTank.getY()+40 ){
                    //子弹状态：FALSE
                    myBullet.setB_sur(false);
                    //坦克状态：FALSE
                    enemyTank.setT_sur(false);
                    for (int i = 0; i < enemyTank.e_Bullets_Ve.size(); i++) {
                        EnemyBullet enemyBullet = enemyTank.e_Bullets_Ve.get(i);
                        enemyBullet.setB_sur(false);
                    }
                    //敌人坦克被击毁的数量加1
                    Recorder.addkillEneTankNum();
                    //把炸弹特效放在敌人位置处，并加入集合
                    bombs.add(new Bomb(enemyTank.getX(),enemyTank.getY()));
                }
                break;
        }
    }

    /**
     * 取出自己的子弹集合与敌人坦克进行遍历看是否击中
     */
    public void killEnenmy(){
        //遍历自己的坦克子弹,取出每个子弹
        for (int i = 0; i < mytank.myBullets.size(); i++) {
            MyBullet myBullet = mytank.myBullets.get(i);
            //判断自己的子弹打中敌人
            for (int j = 0; j < enemyTanks.size(); j++) {
                if (enemyTanks != null && myBullet!= null){
                    EnemyTank enemyTank = enemyTanks.get(j);
                    bitEnenmy(myBullet,enemyTank);
                }
            }
        }
    }

    /**
     * 方法：敌人的子弹打自己坦克
     * 设置敌人的子弹和自己人坦克的生命状态
     * @param enemyBullet  敌人的子弹
     * @param mytank  自己的坦克
     */
    public void bitMyTank(EnemyBullet enemyBullet, MyTank mytank){
        if(mytank != null && mytank.isT_sur()) {
            switch (mytank.getDirection()) {
                case 0:
                case 2:
                    if (enemyBullet.getB_x() >= mytank.getX() && enemyBullet.getB_x() <= mytank.getX() + 40
                            && enemyBullet.getB_y() >= mytank.getY() && enemyBullet.getB_y() <= mytank.getY() + 60) {
                        //子弹状态：FALSE
                        enemyBullet.setB_sur(false);
                        //坦克状态：FALSE
                        mytank.setT_sur(false);
                        for (int i = 0; i < mytank.myBullets.size(); i++) {
                            MyBullet myBullet = mytank.myBullets.get(i);
                            myBullet.setB_sur(false);
                        }
                        //把炸弹特效放在自己位置处，并加入集合
                        bombs.add(new Bomb(mytank.getX(), mytank.getY()));
                    }
                    break;
                case 1:
                case 3:
                    if (enemyBullet.getB_x() >= mytank.getX() && enemyBullet.getB_x() <= mytank.getX() + 60
                            && enemyBullet.getB_y() >= mytank.getY() && enemyBullet.getB_y() <= mytank.getY() + 40) {
                        //子弹状态：FALSE
                        enemyBullet.setB_sur(false);
                        //坦克状态：FALSE
                        mytank.setT_sur(false);
                        for (int i = 0; i < mytank.myBullets.size(); i++) {
                            MyBullet myBullet = mytank.myBullets.get(i);
                            myBullet.setB_sur(false);
                        }
                        //把炸弹特效放在自己位置处，并加入集合
                        bombs.add(new Bomb(mytank.getX(), mytank.getY()));
                    }
                    break;
            }
        }
    }

    /**
     * 取出敌人的子弹与自己坦克遍历，看是否击中自己的坦克
     */
    public void killMyTank(){
        //先遍历敌人的坦克
        for (int i = 0; i < enemyTanks.size(); i++) {
            //取出每个敌人坦克
            EnemyTank enemyTank = enemyTanks.get(i);
            //遍历每个敌人坦克里面的每个子弹线程
            for (int j = 0; j < enemyTank.e_Bullets_Ve.size(); j++) {
                EnemyBullet bullet = enemyTank.e_Bullets_Ve.get(j);
                bitMyTank(bullet,mytank);
            }
        }
    }
}

12.TankGame05

package project.tankgame05;

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

/**
 * @ClassName: TankGame05
 * @Description: 坦克游戏5.0框架
 */
public class TankGame05 extends JFrame {

    TankPanel tankPanel01 = null; //先定义一个空的1.0“画板”

    public static void main(String[] args) {
        TankGame05 tankGame01 = new TankGame05();
    }

    /**
     * 构造器
     */
    public TankGame05(){
        System.out.println("1: 开始新游戏\r\n2: 继续上局游戏");
        Scanner scanner = new Scanner(System.in);
        String next = scanner.next();
        tankPanel01 = new TankPanel(next); //初始化1.0“画板”
        this.add(tankPanel01);  //添加1.0“画板”
        this.setSize(1300,850); //设置“画板”大小
        this.setVisible(true); //设置“画板”可见
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //点×关闭
        this.addKeyListener(tankPanel01);
        new Thread(tankPanel01).start();

        //Windows窗口关闭监听事件
        this.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                System.out.println("游戏关闭，数据正在存档中......");
                Recorder.storekillEneTankNum();
                Recorder.storeAliveEneTank();
                System.exit(0);
            }
        });
    }


}