Dominator945

坦克大战进阶第三版：防止重叠、击杀记录、存盘退出、背景音乐等

1. 坦克大战0.5版

1.1 功能进阶：

增加功能[HspTankGame05java]

防止敌人坦克重叠运动[思路->走代码]
记录玩家的总成绩(累积击毁敌方坦克数)，存盘退出[io流]
记录退出游戏时敌人坦克坐标/方向,存盘退出[io流]
玩游戏时，可以选择是开新游戏还是继续上局游戏

1.2 进阶思路一：

1.2.1 第一步：防止敌人坦克重叠运动

这里我们先以一辆敌人坦克跟其他敌人坦克进行对比：
1. 当敌人坦克一方向向上的时候：其他敌人坦克有两种情况
  1. 其他敌人坦克方向为上/下的时候：
    1. 敌人的 x 范围 [enemyTank.getX(),enemyTank.getX() + 40]
    2. 敌人的 y 范围 [enemyTank.getY(),enemyTank.getY() + 60]
  2. 其他敌人坦克方向为左/右的时候：
    1. 敌人的 x 范围 [enemyTank.getX(),enemyTank.getX() + 60]
    2. 敌人的 y 范围 [enemyTank.getY(),enemyTank.getY() + 40]
  3. 这时候我们只要判断敌人坦克一的左上角和右上角不在其他坦克的范围内就为真；
当敌人坦克一方向向右的时候：其他敌人坦克有两种情况
1. 其他敌人坦克方向为上/下的时候：
  1. 敌人的 x 范围 [enemyTank.getX(),enemyTank.getX() + 40]
  2. 敌人的 y 范围 [enemyTank.getY(),enemyTank.getY() + 60]
2. 其他敌人坦克方向为左/右的时候：
  1. 敌人的 x 范围 [enemyTank.getX(),enemyTank.getX() + 60]
  2. 敌人的 y 范围 [enemyTank.getY(),enemyTank.getY() + 40]
3. 这时候我们只要判断敌人坦克一的右上角和右下角不在其他坦克的范围内就为真；
当敌人坦克一方向向下的时候：其他敌人坦克有两种情况
1. 其他敌人坦克方向为上/下的时候：
  1. 敌人的 x 范围 [enemyTank.getX(),enemyTank.getX() + 40]
  2. 敌人的 y 范围 [enemyTank.getY(),enemyTank.getY() + 60]
2. 其他敌人坦克方向为左/右的时候：
  1. 敌人的 x 范围 [enemyTank.getX(),enemyTank.getX() + 60]
  2. 敌人的 y 范围 [enemyTank.getY(),enemyTank.getY() + 40]
3. 这时候我们只要判断敌人坦克一的左下角和右下角不在其他坦克的范围内就为真；
当敌人坦克一方向向左的时候：其他敌人坦克有两种情况
1. 其他敌人坦克方向为上/下的时候：
  1. 敌人的 x 范围 [enemyTank.getX(),enemyTank.getX() + 40]
  2. 敌人的 y 范围 [enemyTank.getY(),enemyTank.getY() + 60]
2. 其他敌人坦克方向为左/右的时候：
  1. 敌人的 x 范围 [enemyTank.getX(),enemyTank.getX() + 60]
  2. 敌人的 y 范围 [enemyTank.getY(),enemyTank.getY() + 40]
3. 这时候我们只要判断敌人坦克一的左上角和左下角不在其他坦克的范围内就为真；
至关重要的一步：在MyPanel中将enemyTanks 设置给 enemyTank，要不然不能实现防止敌人坦克重叠的优化
```
enemyTank.setEnemyTanks(enemyTanks);
```

1.3 进阶思路二

1.3.1 第二步：记录玩家的总成绩(累积击毁敌方坦克数)，存盘退出[io流]

一、新建一个Recorder类，用于记录相关的信息:

在类里面定义变量，记录我方击毁敌人坦克数量
```
private static int allEnemyTankNum = 0;
```

定义IO对象

private static FileWriter fw = null;
private static BufferedWriter bw = null;
private static String recordFile = "E:\\myRecord.txt";

添加allEnemyTankNum的构造器和set方法

public static int getAllEnemyTankNum() {
        return allEnemyTankNum;
    }

    public static void setAllEnemyTankNum(int allEnemyTankNum) {
        Recoder.allEnemyTankNum = allEnemyTankNum;
    }

当我方坦克击毁一个敌人，就应当 allEnemyTankNum++；

public static void addAllEnemyTankNum() {
        Recoder.allEnemyTankNum++;
}

增加一个方法，当游戏退出时，我们将 allEnemyTankNum 保存到 recordFile

public static void keepRecord() {
        try {
            bw = new BufferedWriter(new FileWriter(recordFile));
            bw.write(allEnemyTankNum + "\r\n");//"\r\n" 换行
            //或者用 bw.newLine();换行
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            try {
                if (bw!=null){
                    bw.close();
                }
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }

二、在坦克显示的右边界面画出机会敌方坦克的情况,并且在IO文件中记录相应数据

在MyPanel中编写方法，显示我方击毁敌方坦克的信息

public void showInfo(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, 0);//画出一个敌方坦克
        g.setColor(Color.BLACK);//这里需要重置设置成黑色
        //记录击毁敌方坦克的数量
        g.drawString(Recoder.getAllEnemyTankNum() + "", 1080, 100);
    }

在击中敌人坦克的hitTank()方法中，当敌人击毁的时候，增加Recorder的addAllEnemyTankNum方法，记录击毁的数量

//当我方击毁敌人坦克时，就对数据allEnemyTankNum++
//因为 tank 可以是 MyTank，也可以是 EnemyTank
//所以我们这里要进行一个判断
if (tank instanceof EnemyTank) {
   Recoder.addAllEnemyTankNum();
  }

最后在 Jframe 中增加响应关闭窗口的处理，当我们关闭窗口的时候，记录Recorder的keepRecord()方法

//在 Jframe 中增加响应关闭窗口的处理
this.addWindowListener(new WindowAdapter() {
    @Override
    public void windowClosing(WindowEvent e) {
        Recoder.keepRecord();
        System.exit(0);
   }
 });

1.4 进阶思路三

1.4.1 第三步：记录退出游戏时敌人坦克坐标/方向,存盘退出[io流]

对 KeepRecord() 进行升级，保存敌人坦克的坐标和方向

//遍历敌人坦克的 Vector ，然后根据情况保存
//OOP ，定义一个属性，然后通过setXx 得到敌人的坦克 Vector
for (int i = 0; i < enemyTanks.size(); i++) {
   //取出敌人坦克
   EnemyTank enemyTank = enemyTanks.get(i);
   if (enemyTank.isLive){//为了保险，建议判断
       //保存坦克信息
       String record = enemyTank.getX()+" "+enemyTank.getY()+" "+enemyTank.getDirection();
       //写入到文件
       bw.write(record+"\r\n");
       //或者加一个
       //bw.newLine();
   }
}

接下来将 MyPanel 对象的 enemyTanks 设置给 Recorder 的 enemyTanks

//将 MyPanel 对象的 enemyTanks 设置给 Recorder 的 enemyTanks
Recoder.setEnemyTanks(enemyTanks);

1.5 进阶思路四

1.5.1 第四步：玩游戏时，可以选择是开新游戏还是继续上局游戏

一、将Recorder文件中每个敌人信息恢复成一个Node对象，再将其放入Vector

先在Recorder中定义一个Node的Vector，用于保存敌人坦克的信息
```
private static Vector<Node> nodes = new Vector<>();
```
在Recorder中定义一个输入流，用于读取recordFile文件
```
private static BufferedReader br = null;
```

然后增加一个方法，用于读取recordFile，恢复相关信息；该方法在继续上局游戏的时候调用

public static Vector<Node> getNodesAndEnemyTankRec() {
    try {
        br = new BufferedReader(new FileReader(recordFile));
        //先恢复allEnemyTankNum的值
        //1. 先读取第一行allEnemyTankNum
        //  即读取击毁敌人坦克的数量
        //因为 br.readLine 是一个字符串，所以我们用Integer.parseInt()进行一个转换
        allEnemyTankNum = Integer.parseInt(br.readLine());
        //2. 接下来循环读取文件，生成nodes集合
        String Line = "";
        //后面读取到的数据为 100 170 2类型
        while ((Line = br.readLine()) != null) {
            //所以这里用split分割String生成一个数组
            String[] xyd = Line.split(" ");
            //将读取到的数据生成Node对象
            //因为这里的数据为String，所以用Integer.parseInt()进行一个转换
            Node node = new Node(Integer.parseInt(xyd[0]), Integer.parseInt(xyd[1]),
                    Integer.parseInt(xyd[2]));
            //将生成的Node对象node放入到Vector对象的nodes中
            nodes.add(node);
        }
    } catch (IOException e) {
        throw new RuntimeException(e);
    } finally {
        try {
            if (br != null) {
                br.close();
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
    return nodes;
}

二、通过Node的Vector去恢复敌人坦克的位置和方向

找到我们游戏启动的地方MyPanel，在游戏一启动就进行数据恢复；然后把相应的数据给下面定义的Node对象nodes接收
```
nodes = Recoder.getNodesAndEnemyTankRec();
```
然后在MyPanel中定义一个存放Node对象的Vector，用于恢复敌人坦克的坐标和方向；
```
Vector<Node> nodes = new Vector<>();
```
然后在MyPanel中增加一个参数，用于选择开始新游戏或者继续上局
```
public MyPanel(String key) 
```

在主界面MyTankGame05中增加一个用户输入界面Scanner

static Scanner scanner = new Scanner(System.in);//添加static，可直接调用

在主界面MyTankGame05的构造器中添加供用户选择的代码：开始新游戏还是继续上局，再将key放入初始化中

//供用户选择:开始新游戏还是继续上局
System.out.println("请输入选择：1：新游戏 2：继续上局");
String key = scanner.next();
//初始化
mp = new MyPanel(key);

最后再在MyPanel中进行一个switch判断，进行新游戏和继续上局

switch (key) {
    case "1":
        //初始化敌人的坦克
        for (int i = 0; i < enemyTanksize; i++) {
            //创建一个敌人坦克
            EnemyTank enemyTank = new EnemyTank((100 * (i + 1)), 0);

            //将enemyTanks 设置给 enemyTank ！！！
            //要不然不能完成重叠优化
            enemyTank.setEnemyTanks(enemyTanks);

            //设置方向
            enemyTank.setDirection(2);

            //启动敌人坦克，让他动起来
            new Thread(enemyTank).start();

            //给该enemyTank对象加入一颗子弹
            Shot shot = new Shot(enemyTank.getX() + 20,
                    enemyTank.getY() + 60, enemyTank.getDirection());
            //加入到enemyTank的Vector成员
            enemyTank.shots.add(shot);
            //立即启动
            new Thread(shot).start();

            enemyTanks.add(enemyTank);
        }
        break;
    case "2":
        for (int i = 0; i < nodes.size(); i++) {
            //取出存放上局敌人数据的Node对象
            Node node = nodes.get(i);
            //恢复上局每个敌人坦克的坐标
            EnemyTank enemyTank = new EnemyTank(node.getX(), node.getY());

            //将enemyTanks 设置给 enemyTank ！！！
            //要不然不能完成重叠优化
            enemyTank.setEnemyTanks(enemyTanks);

            //恢复上局每个敌人坦克的方向
            enemyTank.setDirection(node.getDirection());

            //启动敌人坦克，让他动起来
            new Thread(enemyTank).start();

            //给该enemyTank对象加入一颗子弹
            Shot shot = new Shot(enemyTank.getX() + 20,
                    enemyTank.getY() + 60, enemyTank.getDirection());
            //加入到enemyTank的Vector成员
            enemyTank.shots.add(shot);
            //立即启动
            new Thread(shot).start();

            enemyTanks.add(enemyTank);
        }
        break;
    default:
        System.out.println("选择有误");
}

2. 坦克大战0.6版

2.1 功能进阶

增加功能[HspTankGame05java]

游戏开始时，播放经典的坦克大战音乐，[思路,使用一个播放音乐的类，即可]
修正下文件存储位置
处理文件相关异常

2.2 进阶思路一：

2.2.1 第一步：游戏开始时，播放经典的坦克大战音乐，

使用一个播放音乐的类AePlayWave

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();
        }

    }
}

找到一个自己想要的音乐，例如111.wav

在MyPanel的里面播放指定的音乐即可

//这里播放指定的音乐
new AePlayWave("src\\111.wav").start();

2.3 进阶思路二：

2.3.1 第二步：修正下文件存储位置

思路：

我们储存文件的位置一般跟着我们的项目走
但是我们之前储存IO流的文件位置定义在E盘，到时候不一定能够跟着项目一起走

会导致文件缺失，我们可以把记录文件保存到src下

//把记录文件的位置改为src下
//private static String recordFile = "E:\\myRecord.txt";
private static String recordFile = "src\\myRecord.txt";

2.4 进阶思路三：

2.4.1 第三步：处理文件相关异常

一、我们前面在MyPanel中设置了在游戏一启动就进行数据恢复；

二、但是当我们还没有数据储存的时候运行继续上局时，会抛出异常

三、因此我们需要进行优化 => 提升代码的健壮性

先在Recorder类中添加一个getRecordFile()方法，用于返回记录文件的目录

//返回记录文件的目录
public static String getRecordFile() {
    return recordFile;
}

在MyPanel中判断目录是否存在，如果存在，还是按照原来的执行，如果不存在只能开启新的游戏

//1. 我们先判断记录文件是否存在
//2. 如果存在，游戏正常执行，
//    如果文件不存在，提示只能开启新游戏, key = "1"
File file = new File(Recoder.getRecordFile());
if (file.exists()){
    //当我们游戏启动的时候进行数据恢复
    //然后用nodes接收相应数据
    nodes = Recoder.getNodesAndEnemyTankRec();
}else {
    System.out.println("文件不存在，只能开启新的游戏");
    key = "1";
}

3. 坦克大战进阶0.6完整版

3.1 汇总

我们目前为止坦克大战0.6版的最终代码如下：

父类坦克Tank

public class Tank {
    private int x;//坦克的横坐标
    private int y;//坦克的纵坐标

    boolean isLive = true;

    //坦克的方向 0向上 1向右 2向下 3向左
    private int direction;
    //坦克的速度
    private int speed = 2;

    public int getSpeed() {
        return speed;
    }

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

    //添加上下左右移动方法
    //向上
    public void moveUp() {
        y -= speed;
    }

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

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

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

    public int getDirection() {
        return direction;
    }

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

    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;
    }

}

敌人坦克 EnemyTank

public class EnemyTank extends Tank implements Runnable {
    //在敌人坦克类，使用Vector保存多个shot
    Vector<Shot> shots = new Vector<>();

    //1. Vector 在 MyPanel
    Vector<EnemyTank> enemyTanks = new Vector<>();

    //这里提供一个方法，可以将 MyPanel 的成员 Vector enemyTanks = new Vector<>();
    //设置到 EnemyTank 的成员 enemyTanks
    public void setEnemyTanks(Vector<EnemyTank> enemyTanks) {
        this.enemyTanks = enemyTanks;
    }

    //编写方法，判断当前的这个敌人坦克，是否和enemyTanks 中的其他坦克发生重叠或者碰撞
    public boolean isTouchEnemyTank() {
        //判断当前敌人坦克方向（this）
        switch (this.getDirection()) {
            case 0://向上
                for (int i = 0; i < enemyTanks.size(); i++) {
                    EnemyTank enemyTank = enemyTanks.get(i);
                    if (enemyTank != this) {
                        //当敌人坦克是上/下
                        //1.如果敌人的坦克是上/下
                        //  敌人的 x 范围 [enemyTank.getX(),enemyTank.getX() + 40]
                        //  敌人的 y 范围 [enemyTank.getY(),enemyTank.getY() + 60]
                        if (enemyTank.getDirection() == 0 || enemyTank.getDirection() == 2) {
                            //2. 当前的坦克左上角坐标[this.getX(),this.getY()]
                            if (this.getX() >= enemyTank.getX() && this.getX() <= enemyTank.getX() + 40
                                    && this.getY() >= enemyTank.getY() && this.getY() <= enemyTank.getY() + 60) {
                                return true;
                            }
                            //3. 当前的坦克右上角坐标[this.getX()+40,this.getY()]
                            if (this.getX() + 40 >= enemyTank.getX() && this.getX() + 40 <= enemyTank.getX() + 40
                                    && this.getY() >= enemyTank.getY() && this.getY() <= enemyTank.getY() + 60) {
                                return true;
                            }
                        }
                        //当敌人坦克是左/右
                        // 1.如果敌人的坦克是左/右
                        //  敌人的 x 范围 [enemyTank.getX(),enemyTank.getX() + 60]
                        //  敌人的 y 范围 [enemyTank.getY(),enemyTank.getY() + 40]
                        if (enemyTank.getDirection() == 1 || enemyTank.getDirection() == 3) {
                            //2. 当前的坦克左上角坐标[this.getX(),this.getY()]
                            if (this.getX() >= enemyTank.getX() && this.getX() <= enemyTank.getX() + 60
                                    && this.getY() >= enemyTank.getY() && this.getY() <= enemyTank.getY() + 40) {
                                return true;
                            }
                            //3. 当前的坦克右上角坐标[this.getX()+40,this.getY()]
                            if (this.getX() + 40 >= enemyTank.getX() && this.getX() + 40 <= enemyTank.getX() + 60
                                    && this.getY() >= enemyTank.getY() && this.getY() <= enemyTank.getY() + 40) {
                                return true;
                            }
                        }
                    }
                }
                break;
            case 1://向右
                for (int i = 0; i < enemyTanks.size(); i++) {
                    EnemyTank enemyTank = enemyTanks.get(i);
                    if (enemyTank != this) {
                        //当敌人坦克是上/下
                        //1.如果敌人的坦克是上/下
                        //  敌人的 x 范围 [enemyTank.getX(),enemyTank.getX() + 40]
                        //  敌人的 y 范围 [enemyTank.getY(),enemyTank.getY() + 60]
                        if (enemyTank.getDirection() == 0 || enemyTank.getDirection() == 2) {
                            //2. 当前的坦克右上角坐标[this.getX()+60,this.getY()]
                            if (this.getX() + 60 >= enemyTank.getX() && this.getX() + 60 <= enemyTank.getX() + 40
                                    && this.getY() >= enemyTank.getY() && this.getY() <= enemyTank.getY() + 60) {
                                return true;
                            }
                            //3. 当前的坦克右下角坐标[this.getX()+60,this.getY()+40]
                            if (this.getX() + 60 >= enemyTank.getX() && this.getX() + 60 <= enemyTank.getX() + 40
                                    && this.getY() + 40 >= enemyTank.getY() && this.getY() + 40 <= enemyTank.getY() + 60) {
                                return true;
                            }
                        }
                        //当敌人坦克是左/右
                        // 1.如果敌人的坦克是左/右
                        //  敌人的 x 范围 [enemyTank.getX(),enemyTank.getX() + 60]
                        //  敌人的 y 范围 [enemyTank.getY(),enemyTank.getY() + 40]
                        if (enemyTank.getDirection() == 1 || enemyTank.getDirection() == 3) {
                            //2. 当前的坦克右上角坐标[this.getX()+60,this.getY()]
                            if (this.getX() + 60 >= enemyTank.getX() && this.getX() + 60 <= enemyTank.getX() + 60
                                    && this.getY() >= enemyTank.getY() && this.getY() <= enemyTank.getY() + 40) {
                                return true;
                            }
                            //3. 当前的坦克右下角坐标[this.getX()+60,this.getY()+40]
                            if (this.getX() + 60 >= enemyTank.getX() && this.getX() + 60 <= enemyTank.getX() + 60
                                    && this.getY() + 40 >= enemyTank.getY() && this.getY() + 40 <= enemyTank.getY() + 40) {
                                return true;
                            }
                        }
                    }
                }
                break;
            case 2://向下
                for (int i = 0; i < enemyTanks.size(); i++) {
                    EnemyTank enemyTank = enemyTanks.get(i);
                    if (enemyTank != this) {
                        //当敌人坦克是上/下
                        //1.如果敌人的坦克是上/下
                        //  敌人的 x 范围 [enemyTank.getX(),enemyTank.getX() + 40]
                        //  敌人的 y 范围 [enemyTank.getY(),enemyTank.getY() + 60]
                        if (enemyTank.getDirection() == 0 || enemyTank.getDirection() == 2) {
                            //2. 当前的坦克左下角坐标[this.getX(),this.getY()+60]
                            if (this.getX() >= enemyTank.getX() && this.getX() <= enemyTank.getX() + 40
                                    && this.getY() + 60 >= enemyTank.getY() && this.getY() + 60 <= enemyTank.getY() + 60) {
                                return true;
                            }
                            //3. 当前的坦克右下角坐标[this.getX()+40,this.getY()+60]
                            if (this.getX() + 40 >= enemyTank.getX() && this.getX() + 40 <= enemyTank.getX() + 40
                                    && this.getY() + 60 >= enemyTank.getY() && this.getY() + 60 <= enemyTank.getY() + 60) {
                                return true;
                            }
                        }
                        //当敌人坦克是左/右
                        // 1.如果敌人的坦克是左/右
                        //  敌人的 x 范围 [enemyTank.getX(),enemyTank.getX() + 60]
                        //  敌人的 y 范围 [enemyTank.getY(),enemyTank.getY() + 40]
                        if (enemyTank.getDirection() == 1 || enemyTank.getDirection() == 3) {
                            //2. 当前的坦克左下角坐标[this.getX(),this.getY()+60]
                            if (this.getX() >= enemyTank.getX() && this.getX() <= enemyTank.getX() + 60
                                    && this.getY() + 60 >= enemyTank.getY() && this.getY() + 60 <= enemyTank.getY() + 40) {
                                return true;
                            }
                            //3. 当前的坦克右下角坐标[this.getX()+40,this.getY()+60]
                            if (this.getX() + 40 >= enemyTank.getX() && this.getX() + 40 <= enemyTank.getX() + 60
                                    && this.getY() + 60 >= enemyTank.getY() && this.getY() + 60 <= enemyTank.getY() + 40) {
                                return true;
                            }
                        }
                    }
                }
                break;
            case 3://向左
                for (int i = 0; i < enemyTanks.size(); i++) {
                    EnemyTank enemyTank = enemyTanks.get(i);
                    if (enemyTank != this) {
                        //当敌人坦克是上/下
                        //1.如果敌人的坦克是上/下
                        //  敌人的 x 范围 [enemyTank.getX(),enemyTank.getX() + 40]
                        //  敌人的 y 范围 [enemyTank.getY(),enemyTank.getY() + 60]
                        if (enemyTank.getDirection() == 0 || enemyTank.getDirection() == 2) {
                            //2. 当前的坦克左上角坐标[this.getX(),this.getY()]
                            if (this.getX() >= enemyTank.getX() && this.getX() <= enemyTank.getX() + 40
                                    && this.getY() >= enemyTank.getY() && this.getY() <= enemyTank.getY() + 60) {
                                return true;
                            }
                            //3. 当前的坦克左下角坐标[this.getX(),this.getY()+40]
                            if (this.getX() >= enemyTank.getX() && this.getX() <= enemyTank.getX() + 40
                                    && this.getY() + 40 >= enemyTank.getY() && this.getY() + 40 <= enemyTank.getY() + 60) {
                                return true;
                            }
                        }
                        //当敌人坦克是左/右
                        // 1.如果敌人的坦克是左/右
                        //  敌人的 x 范围 [enemyTank.getX(),enemyTank.getX() + 60]
                        //  敌人的 y 范围 [enemyTank.getY(),enemyTank.getY() + 40]
                        if (enemyTank.getDirection() == 1 || enemyTank.getDirection() == 3) {
                            //2. 当前的坦克左上角坐标[this.getX(),this.getY()]
                            if (this.getX() >= enemyTank.getX() && this.getX() <= enemyTank.getX() + 60
                                    && this.getY() >= enemyTank.getY() && this.getY() <= enemyTank.getY() + 40) {
                                return true;
                            }
                            //3. 当前的坦克左下角坐标[this.getX(),this.getY()+40]
                            if (this.getX() >= enemyTank.getX() && this.getX() <= enemyTank.getX() + 60
                                    && this.getY() + 40 >= enemyTank.getY() && this.getY() + 40 <= enemyTank.getY() + 40) {
                                return true;
                            }
                        }
                    }
                }
                break;
        }
        return false;
    }

    public EnemyTank(int x, int y) {
        super(x, y);
    }

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

            //从这里我们判断如果shots.size()==0,
            // 说明子弹已经销毁，再创建一颗子弹放入shots
            //并启动
            if (isLive && shots.size() < 3) {
                //创建一个临时变量
                Shot s = null;
                //判断坦克的方向
                //创建对应的子弹
                switch (getDirection()) {
                    case 0://向上
                        s = new Shot(getX() + 20, getY(), 0);
                        break;
                    case 1://向右
                        s = new Shot(getX() + 60, getY() + 20, 1);
                        break;
                    case 2://向下
                        s = new Shot(getX() + 20, getY() + 60, 2);
                        break;
                    case 3://向左
                        s = new Shot(getX(), getY() + 20, 3);
                        break;
                }
                //添加一颗子弹
                shots.add(s);
                //启动
                new Thread(s).start();
            }

            //设置坦克移动
            switch (getDirection()) {
                case 0:
                    //让坦克保持一个方向走100步
                    for (int i = 0; i < 50; i++) {
                        if (getY() > 0 && !isTouchEnemyTank()) {
                            moveUp();
                        }
                        //休眠100毫秒
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }
                    break;
                case 1:
                    //让坦克保持一个方向走100步
                    for (int i = 0; i < 50; i++) {
                        if (getX() + 60 < 1000 && !isTouchEnemyTank()) {
                            moveRight();
                        }
                        //休眠100毫秒
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }
                    break;
                case 2:
                    //让坦克保持一个方向走100步
                    for (int i = 0; i < 50; i++) {
                        if (getY() + 60 < 750 && !isTouchEnemyTank()) {
                            moveDown();
                        }
                        //休眠100毫秒
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }
                    break;
                case 3:
                    //让坦克保持一个方向走100步
                    for (int i = 0; i < 50; i++) {
                        if (getX() > 0 && !isTouchEnemyTank()) {
                            moveLeft();
                        }
                        //休眠100毫秒
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }
                    break;
            }

            //随机改变方向
            setDirection((int) (Math.random() * 4));

            //考虑线程什么时候退出
            if (!isLive) {
                break;
            }
        }
    }
}

我们的坦克 MyTank

public class MyTank extends Tank {
    //定义一个shot对象,表示一个射击行为（线程）
    Shot shot = null;
    //创建多个子弹
    Vector<Shot> shots = new Vector<>();

    //创建一个属性判断我们是否存活


    public MyTank(int x, int y) {
        super(x, y);
    }

    public void shotEnemyTank() {
        if (shots.size() == 5) {
            return;
        }
        //创建shot对象
        switch (getDirection()) {
            case 0://向上
                shot = new Shot(getX() + 20, getY(), 0);
                break;
            case 1://向右
                shot = new Shot(getX() + 60, getY() + 20, 1);
                break;
            case 2://向下
                shot = new Shot(getX() + 20, getY() + 60, 2);
                break;
            case 3://向左
                shot = new Shot(getX(), getY() + 20, 3);
                break;
        }
        //把新创建的shot放入到shots集合中
        shots.add(shot);
        //启动我们的shot线程
        new Thread(shot).start();
    }
}

子弹 Shot

public class Shot implements Runnable {//射击子弹
    int x;//子弹x坐标
    int y;//子弹y坐标
    int direction;//子弹方向
    int speed = 2;//子弹速度
    boolean isLive = true;//子弹是否还存活

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

    }

    @Override
    public void run() {//射击行为
        while (true) {
            try {//让子弹休眠一下
                Thread.sleep(50);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            //根据方向来改变x,y坐标
            switch (direction) {
                case 0://向上
                    y -= speed;
                    break;
                case 1://向右
                    x += speed;
                    break;
                case 2://向下
                    y += speed;
                    break;
                case 3://向左
                    x -= speed;
                    break;
            }
            //这里用于调试，输入子弹坐标
            //System.out.println("子弹x =" + x + " y =" + y);
            //当子弹超出边界就销毁子弹
            //当子弹碰到敌人坦克时，也应该结束线程
            if (!(x > 0 && x < 1000 && y > 0 && y < 750 && isLive)) {
                System.out.println("子弹消失");
                isLive = false;
                break;
            }
        }
    }
}

爆炸效果 Boom

public class Boom {
    int x, y;//炸弹的坐标
    int life = 9;//炸弹的生命周期
    boolean isLive = true;

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

    //减少生命值
    public void lifeDown() {//配合图片爆炸效果
        if (life > 0) {
            life--;
        } else {
            isLive = false;
        }
    }
}

面板显示 MyPanel

//为了监听键盘事件，实现 KeyListener
//为了让panel不停的重绘，实现 Runnable，当做一个线程使用
public class MyPanel extends JPanel implements KeyListener, Runnable {
    //定义我的坦克
    MyTank myTank = null;
    //定义敌人坦克，放入到 Vector 
    Vector<EnemyTank> enemyTanks = new Vector<>();

    //定义一个存放Node对象的Vector，用于恢复敌人坦克的坐标和方向
    Vector<Node> nodes = new Vector<>();

    //定义一个Vector，用于存放炸弹
    //当子弹击中坦克时，就加入一个Boom对象booms
    Vector<Boom> booms = new Vector<>();

    int enemyTanksize = 3;

    //定义三张图片，用于显示爆炸效果
    Image image1 = null;
    Image image2 = null;
    Image image3 = null;

    public MyPanel(String key) {
        //1. 我们先判断记录文件是否存在
        //2. 如果存在，游戏正常执行，
        //    如果文件不存在，提示只能开启新游戏, key = "1"
        File file = new File(Recoder.getRecordFile());
        if (file.exists()) {
            //当我们游戏启动的时候进行数据恢复
            //然后用nodes接收相应数据
            nodes = Recoder.getNodesAndEnemyTankRec();
        } else {
            System.out.println("文件不存在，只能开启新的游戏");
            key = "1";
        }

        //将 MyPanel 对象的 enemyTanks 设置给 Recorder 的 enemyTanks
        Recoder.setEnemyTanks(enemyTanks);

        //初始化自己的坦克
        myTank = new MyTank(300, 600);

        switch (key) {
            case "1":
                //初始化敌人的坦克
                for (int i = 0; i < enemyTanksize; i++) {
                    //创建一个敌人坦克
                    EnemyTank enemyTank = new EnemyTank((100 * (i + 1)), 0);

                    //将enemyTanks 设置给 enemyTank ！！！
                    //要不然不能完成重叠优化
                    enemyTank.setEnemyTanks(enemyTanks);

                    //设置方向
                    enemyTank.setDirection(2);

                    //启动敌人坦克，让他动起来
                    new Thread(enemyTank).start();

                    //给该enemyTank对象加入一颗子弹
                    Shot shot = new Shot(enemyTank.getX() + 20,
                            enemyTank.getY() + 60, enemyTank.getDirection());
                    //加入到enemyTank的Vector成员
                    enemyTank.shots.add(shot);
                    //立即启动
                    new Thread(shot).start();

                    enemyTanks.add(enemyTank);
                }
                break;
            case "2":
                for (int i = 0; i < nodes.size(); i++) {
                    //取出存放上局敌人数据的Node对象
                    Node node = nodes.get(i);
                    //恢复上局每个敌人坦克的坐标
                    EnemyTank enemyTank = new EnemyTank(node.getX(), node.getY());

                    //将enemyTanks 设置给 enemyTank ！！！
                    //要不然不能完成重叠优化
                    enemyTank.setEnemyTanks(enemyTanks);

                    //恢复上局每个敌人坦克的方向
                    enemyTank.setDirection(node.getDirection());

                    //启动敌人坦克，让他动起来
                    new Thread(enemyTank).start();

                    //给该enemyTank对象加入一颗子弹
                    Shot shot = new Shot(enemyTank.getX() + 20,
                            enemyTank.getY() + 60, enemyTank.getDirection());
                    //加入到enemyTank的Vector成员
                    enemyTank.shots.add(shot);
                    //立即启动
                    new Thread(shot).start();

                    enemyTanks.add(enemyTank);
                }
                break;
            default:
                System.out.println("选择有误");
        }

        //初始化图片
        image1 = Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/bomb_1.gif"));
        image2 = Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/bomb_2.gif"));
        image3 = Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/bomb_3.gif"));

        //这里播放指定的音乐
        new AePlayWave("src\\111.wav").start();
    }

    //编写方法，显示我方击毁敌方坦克的信息
    public void showInfo(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, 0);//画出一个敌方坦克
        g.setColor(Color.BLACK);//这里需要重置设置成黑色
        //记录击毁敌方坦克的数量
        g.drawString(Recoder.getAllEnemyTankNum() + "", 1080, 100);
    }


    @Override
    public void paint(Graphics g) {
        super.paint(g);
        //设置填充矩形，默认黑色
        g.fillRect(0, 0, 1000, 750);

        //调用showInfo()方法
        showInfo(g);

        myTank.setSpeed(5);
        //画出坦克-封装方法
        //自己的坦克
        //增加一个if判断，当自己不为空并且还存活的情况下才画坦克
        if (myTank != null && myTank.isLive) {
            drawTank(myTank.getX(), myTank.getY(), g, myTank.getDirection(), 1);
        }
        //画出自己的子弹(一颗)
//        if (myTank.shot != null && myTank.shot.isLive == true) {
//            g.draw3DRect(myTank.shot.x, myTank.shot.y, 5, 5, true);
//        }
        //现在我们要画多颗子弹
        //将myTank的子弹shots遍历取出
        for (int i = 0; i < myTank.shots.size(); i++) {
            //取出子弹
            Shot shot = myTank.shots.get(i);
            if (shot != null && shot.isLive) {
                g.draw3DRect(shot.x, shot.y, 5, 5, true);
            } else {//否则该shot对象无效，就从shots集合中拿掉
                myTank.shots.remove(shot);
                break;
            }
        }

        //如果booms集合中有对象，就画出
        for (int i = 0; i < booms.size(); i++) {
            //取出炸弹
            Boom boom = booms.get(i);
            //根据当前这个boom对象的life值画出对应的图片
            if (boom.life > 6) {
                g.drawImage(image1, boom.x, boom.y, 80, 80, this);
            } else if (boom.life > 30) {
                g.drawImage(image2, boom.x, boom.y, 80, 80, this);
            } else {
                g.drawImage(image3, boom.x, boom.y, 80, 80, this);
            }
            //让炸弹的生命值减少
            boom.lifeDown();
            //如果boom.life为0，就从booms的集合中删除
            if (boom.life == 0) {
                booms.remove(boom);
            }
        }

        //画出敌人的坦克，遍历Vector
        for (int i = 0; i < enemyTanks.size(); i++) {
            //从Vector取出坦克
            EnemyTank enemyTank = enemyTanks.get(i);
            //判断当前坦克是否还存活
            if (enemyTank.isLive) {//如果敌人的坦克是存活的，才画出该坦克
                drawTank(enemyTank.getX(), enemyTank.getY(), g, enemyTank.getDirection(), 0);

                //画出 enemyTank所有子弹
                for (int j = 0; j < enemyTank.shots.size(); j++) {
                    //取出子弹
                    Shot shot = enemyTank.shots.get(j);
                    //绘制子弹
                    if (shot.isLive) {
                        g.draw3DRect(shot.x, shot.y, 5, 5, true);
                    } else {
                        //从 Vector 移除
                        enemyTank.shots.remove(shot);
                    }
                }
            }
        }
    }
    //编写方法，画出坦克

    /**
     * @param x         坦克的左上角x坐标
     * @param y         坦克的左上角y坐标
     * @param g         画笔
     * @param direction 坦克的方向
     * @param type      坦克的类型
     */
    public void drawTank(int x, int y, Graphics g, int direction, int type) {
        switch (type) {
            case 0://敌人的坦克
                g.setColor(Color.cyan);
                break;
            case 1://我们的坦克
                g.setColor(Color.yellow);
                break;
        }
        //根据坦克的方向，来绘制坦克
        switch (direction) {//0向上 1向右 2向下 3向左
            case 0://默认方向向上
                // 先画第一个矩形 大小 10*60
                //坦克左边轮子
                // 定点(x,y)
                g.fill3DRect(x, y, 10, 60, false);
                // 第二个矩形 大小 20*40
                //坦克身体
                // 定点(x+10,y+10)
                g.fill3DRect(x + 10, y + 10, 20, 40, false);
                // 第三个矩形 大小 10*60
                //坦克右边轮子
                // 定点(x+30,y)
                g.fill3DRect(x + 30, y, 10, 60, false);
                // 上面的圆盖子 大小 (20,20)
                // 定点(x+10,y+20)
                g.fillOval(x + 10, y + 20, 20, 20);
                // 最后的炮管
                // 定点1 (x+20,y)
                // 定点2 (x+20,y+30)
                g.drawLine(x + 20, y, x + 20, y + 30);
                // 画出子弹
                g.drawLine(x + 20, y, x + 20, y + 5);
                break;
            case 1://默认方向向右
                // 先画第一个矩形 大小 60*10
                //坦克上边轮子
                g.fill3DRect(x, y, 60, 10, false);
                // 第二个矩形 大小 40*20
                //坦克身体
                g.fill3DRect(x + 10, y + 10, 40, 20, false);
                // 第三个矩形 大小 10*60
                //坦克下边轮子
                g.fill3DRect(x, y + 30, 60, 10, false);
                // 上面的圆盖子 大小 (20,20)
                g.fillOval(x + 20, y + 10, 20, 20);
                // 最后的炮管
                g.drawLine(x + 60, y + 20, x + 30, y + 20);
                // 画出子弹
                g.drawLine(x + 60, y + 20, x + 55, y + 20);
                break;
            case 2://默认方向向下
                // 先画第一个矩形 大小 10*60
                //坦克左边轮子
                g.fill3DRect(x, y, 10, 60, false);
                // 第二个矩形 大小 20*40
                //坦克身体
                g.fill3DRect(x + 10, y + 10, 20, 40, false);
                // 第三个矩形 大小 10*60
                //坦克右边轮子
                g.fill3DRect(x + 30, y, 10, 60, false);
                // 上面的圆盖子 大小 (20,20)
                g.fillOval(x + 10, y + 20, 20, 20);
                // 最后的炮管
                g.drawLine(x + 20, y + 60, x + 20, y + 30);
                // 画出子弹
                g.drawLine(x + 20, y + 60, x + 20, y + 55);
                break;
            case 3://默认方向向左
                // 先画第一个矩形 大小 60*10
                //坦克上边轮子
                g.fill3DRect(x, y, 60, 10, false);
                // 第二个矩形 大小 40*20
                //坦克身体
                g.fill3DRect(x + 10, y + 10, 40, 20, false);
                // 第三个矩形 大小 10*60
                //坦克下边轮子
                g.fill3DRect(x, y + 30, 60, 10, false);
                // 上面的圆盖子 大小 (20,20)
                g.fillOval(x + 20, y + 10, 20, 20);
                // 最后的炮管
                g.drawLine(x, y + 20, x + 30, y + 20);
                // 画出子弹
                g.drawLine(x, y + 20, x + 5, y + 20);
                break;
            default:
                System.out.println("暂时不作处理");
        }
    }

    // 创建一个方法 hitMyTank
    // 判断敌人的子弹是否打中我们
    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);
                //判断shot是否击中我们的坦克
                if (myTank.isLive && shot.isLive) {
                    hitTank(shot, myTank);
                }
            }
        }
    }

    // 现我们的坦克可以发射多个子弹
    // 在判断我方子弹是否击中敌人坦克时，
    // 就需要把我们的子弹集合中所有的子弹都取出，
    // 和敌人的所有坦克进行判断
    public void hitEnemyTank() {
        //遍历我们的子弹
        for (int j = 0; j < myTank.shots.size(); j++) {
            Shot shot = myTank.shots.get(j);
            if (shot != null && shot.isLive) {//当前我的子弹还存活
                for (int i = 0; i < enemyTanks.size(); i++) {
                    EnemyTank enemyTank = enemyTanks.get(i);
                    hitTank(shot, enemyTank);
                }
            }
        }
    }

    // 编写方法，判断我方子弹是否击中敌人的坦克
    // 什么时候判断我方子弹是否击中敌人?
    // 在run方法里判断比较适合

    // 因为现在这方法用于判断我们的坦克跟敌人的坦克了
    // 所以这里把 EnemyTank enemyTank 改为 Tank tank
    //改用两者的父类 Tank 对象
    public void hitTank(Shot s, Tank tank) {
        //判断击中坦克
        switch (tank.getDirection()) {
            case 0://向上
            case 2://向下
                //子弹的x坐标大于坦克的最左边x坐标
                // 或者小于了坦克最右边x坐标（坦克宽40）
                //子弹的y坐标大于坦克的最上边y坐标
                // 或者小于了坦克最下边y坐标（坦克高60）
                if (s.x > tank.getX() && s.x < tank.getX() + 40
                        && s.y > tank.getY() && s.y < tank.getY() + 60) {
                    //子弹消失
                    s.isLive = false;
                    //敌人的坦克消失
                    tank.isLive = false;
                    //当我们的子弹击中敌人坦克时，将enemyTank从Vector拿掉
                    enemyTanks.remove(tank);

                    //当我方击毁敌人坦克时，就对数据allEnemyTankNum++
                    //因为 tank 可以是 MyTank，也可以是 EnemyTank
                    //所以我们这里要进行一个判断
                    if (tank instanceof EnemyTank) {
                        Recoder.addAllEnemyTankNum();
                    }

                    //创建Boom对象，加入到booms集合
                    Boom boom = new Boom(tank.getX(), tank.getY());
                    booms.add(boom);
                    break;
                }

            case 1://向右
            case 3://向左
                //子弹的x坐标大于坦克的最左边x坐标
                // 或者小于了坦克最右边x坐标（坦克宽60）
                //子弹的y坐标大于坦克的最上边y坐标
                // 或者小于了坦克最下边y坐标（坦克高40）
                if (s.x > tank.getX() && s.x < tank.getX() + 60
                        && s.y > tank.getY() && s.y < tank.getY() + 40) {
                    //子弹消失
                    s.isLive = false;
                    //敌人的坦克消失
                    tank.isLive = false;
                    //当我们的子弹击中敌人坦克时，将enemyTank从Vector拿掉
                    enemyTanks.remove(tank);

                    //当我方击毁敌人坦克时，就对数据allEnemyTankNum++
                    //因为 tank 可以是 MyTank，也可以是 EnemyTank
                    //所以我们这里要进行一个判断
                    if (tank instanceof EnemyTank) {
                        Recoder.addAllEnemyTankNum();
                    }

                    //创建Boom对象，加入到booms集合
                    Boom boom = new Boom(tank.getX(), tank.getY());
                    booms.add(boom);
                    break;
                }
        }
    }


    @Override
    public void keyTyped(KeyEvent e) {

    }

    //处理 wsad 按下的情况
    @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_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();
            }
        } else if (e.getKeyCode() == KeyEvent.VK_D) {
            myTank.setDirection(1);
            if (myTank.getX() + 60 < 1000) {
                myTank.moveRight();
            }
        }

        //如果用户按下J键，就是发射子弹
        if (e.getKeyCode() == KeyEvent.VK_J) {
            //判断当前myTank子弹是否已经销毁 发射一颗子弹
//            if (myTank.shot == null || !myTank.shot.isLive) {
//                myTank.shotEnemyTank();//发射子弹
//            }
            //判断当前myTank子弹是否已经销毁 发射duo颗子弹
            myTank.shotEnemyTank();
        }
        this.repaint();
    }

    @Override
    public void keyReleased(KeyEvent e) {

    }

    //让子弹不停的重绘
    @Override
    public void run() {
        while (true) {
            try {//每隔200毫秒，重绘
                Thread.sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            //把下面注释的这段代码封装到上面的方法里面
            //判断是否击中了敌人的坦克
//            if (myTank.shot != null && myTank.shot.isLive) {//当前我的子弹还存活
//                for (int i = 0; i < enemyTanks.size(); i++) {
//                    EnemyTank enemyTank = enemyTanks.get(i);
//                    hitTank(myTank.shot, enemyTank);
//                }
//            }
            //判断敌人坦克是否击中我们
            hitMyTank();
            hitEnemyTank();
            this.repaint();
        }
    }
}

用于记录相关的信息Recorder

//为了监听键盘事件，实现 KeyListener
//为了让panel不停的重绘，实现 Runnable，当做一个线程使用
public class MyPanel extends JPanel implements KeyListener, Runnable {
    //定义我的坦克
    MyTank myTank = null;
    //定义敌人坦克，放入到 Vector 
    Vector<EnemyTank> enemyTanks = new Vector<>();

    //定义一个存放Node对象的Vector，用于恢复敌人坦克的坐标和方向
    Vector<Node> nodes = new Vector<>();

    //定义一个Vector，用于存放炸弹
    //当子弹击中坦克时，就加入一个Boom对象booms
    Vector<Boom> booms = new Vector<>();

    int enemyTanksize = 3;

    //定义三张图片，用于显示爆炸效果
    Image image1 = null;
    Image image2 = null;
    Image image3 = null;

    public MyPanel(String key) {
        //1. 我们先判断记录文件是否存在
        //2. 如果存在，游戏正常执行，
        //    如果文件不存在，提示只能开启新游戏, key = "1"
        File file = new File(Recoder.getRecordFile());
        if (file.exists()) {
            //当我们游戏启动的时候进行数据恢复
            //然后用nodes接收相应数据
            nodes = Recoder.getNodesAndEnemyTankRec();
        } else {
            System.out.println("文件不存在，只能开启新的游戏");
            key = "1";
        }

        //将 MyPanel 对象的 enemyTanks 设置给 Recorder 的 enemyTanks
        Recoder.setEnemyTanks(enemyTanks);

        //初始化自己的坦克
        myTank = new MyTank(300, 600);

        switch (key) {
            case "1":
                //初始化敌人的坦克
                for (int i = 0; i < enemyTanksize; i++) {
                    //创建一个敌人坦克
                    EnemyTank enemyTank = new EnemyTank((100 * (i + 1)), 0);

                    //将enemyTanks 设置给 enemyTank ！！！
                    //要不然不能完成重叠优化
                    enemyTank.setEnemyTanks(enemyTanks);

                    //设置方向
                    enemyTank.setDirection(2);

                    //启动敌人坦克，让他动起来
                    new Thread(enemyTank).start();

                    //给该enemyTank对象加入一颗子弹
                    Shot shot = new Shot(enemyTank.getX() + 20,
                            enemyTank.getY() + 60, enemyTank.getDirection());
                    //加入到enemyTank的Vector成员
                    enemyTank.shots.add(shot);
                    //立即启动
                    new Thread(shot).start();

                    enemyTanks.add(enemyTank);
                }
                break;
            case "2":
                for (int i = 0; i < nodes.size(); i++) {
                    //取出存放上局敌人数据的Node对象
                    Node node = nodes.get(i);
                    //恢复上局每个敌人坦克的坐标
                    EnemyTank enemyTank = new EnemyTank(node.getX(), node.getY());

                    //将enemyTanks 设置给 enemyTank ！！！
                    //要不然不能完成重叠优化
                    enemyTank.setEnemyTanks(enemyTanks);

                    //恢复上局每个敌人坦克的方向
                    enemyTank.setDirection(node.getDirection());

                    //启动敌人坦克，让他动起来
                    new Thread(enemyTank).start();

                    //给该enemyTank对象加入一颗子弹
                    Shot shot = new Shot(enemyTank.getX() + 20,
                            enemyTank.getY() + 60, enemyTank.getDirection());
                    //加入到enemyTank的Vector成员
                    enemyTank.shots.add(shot);
                    //立即启动
                    new Thread(shot).start();

                    enemyTanks.add(enemyTank);
                }
                break;
            default:
                System.out.println("选择有误");
        }

        //初始化图片
        image1 = Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/bomb_1.gif"));
        image2 = Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/bomb_2.gif"));
        image3 = Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/bomb_3.gif"));

        //这里播放指定的音乐
        new AePlayWave("src\\111.wav").start();
    }

    //编写方法，显示我方击毁敌方坦克的信息
    public void showInfo(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, 0);//画出一个敌方坦克
        g.setColor(Color.BLACK);//这里需要重置设置成黑色
        //记录击毁敌方坦克的数量
        g.drawString(Recoder.getAllEnemyTankNum() + "", 1080, 100);
    }


    @Override
    public void paint(Graphics g) {
        super.paint(g);
        //设置填充矩形，默认黑色
        g.fillRect(0, 0, 1000, 750);

        //调用showInfo()方法
        showInfo(g);

        myTank.setSpeed(5);
        //画出坦克-封装方法
        //自己的坦克
        //增加一个if判断，当自己不为空并且还存活的情况下才画坦克
        if (myTank != null && myTank.isLive) {
            drawTank(myTank.getX(), myTank.getY(), g, myTank.getDirection(), 1);
        }
        //画出自己的子弹(一颗)
//        if (myTank.shot != null && myTank.shot.isLive == true) {
//            g.draw3DRect(myTank.shot.x, myTank.shot.y, 5, 5, true);
//        }
        //现在我们要画多颗子弹
        //将myTank的子弹shots遍历取出
        for (int i = 0; i < myTank.shots.size(); i++) {
            //取出子弹
            Shot shot = myTank.shots.get(i);
            if (shot != null && shot.isLive) {
                g.draw3DRect(shot.x, shot.y, 5, 5, true);
            } else {//否则该shot对象无效，就从shots集合中拿掉
                myTank.shots.remove(shot);
                break;
            }
        }

        //如果booms集合中有对象，就画出
        for (int i = 0; i < booms.size(); i++) {
            //取出炸弹
            Boom boom = booms.get(i);
            //根据当前这个boom对象的life值画出对应的图片
            if (boom.life > 6) {
                g.drawImage(image1, boom.x, boom.y, 80, 80, this);
            } else if (boom.life > 30) {
                g.drawImage(image2, boom.x, boom.y, 80, 80, this);
            } else {
                g.drawImage(image3, boom.x, boom.y, 80, 80, this);
            }
            //让炸弹的生命值减少
            boom.lifeDown();
            //如果boom.life为0，就从booms的集合中删除
            if (boom.life == 0) {
                booms.remove(boom);
            }
        }

        //画出敌人的坦克，遍历Vector
        for (int i = 0; i < enemyTanks.size(); i++) {
            //从Vector取出坦克
            EnemyTank enemyTank = enemyTanks.get(i);
            //判断当前坦克是否还存活
            if (enemyTank.isLive) {//如果敌人的坦克是存活的，才画出该坦克
                drawTank(enemyTank.getX(), enemyTank.getY(), g, enemyTank.getDirection(), 0);

                //画出 enemyTank所有子弹
                for (int j = 0; j < enemyTank.shots.size(); j++) {
                    //取出子弹
                    Shot shot = enemyTank.shots.get(j);
                    //绘制子弹
                    if (shot.isLive) {
                        g.draw3DRect(shot.x, shot.y, 5, 5, true);
                    } else {
                        //从 Vector 移除
                        enemyTank.shots.remove(shot);
                    }
                }
            }
        }
    }
    //编写方法，画出坦克

    /**
     * @param x         坦克的左上角x坐标
     * @param y         坦克的左上角y坐标
     * @param g         画笔
     * @param direction 坦克的方向
     * @param type      坦克的类型
     */
    public void drawTank(int x, int y, Graphics g, int direction, int type) {
        switch (type) {
            case 0://敌人的坦克
                g.setColor(Color.cyan);
                break;
            case 1://我们的坦克
                g.setColor(Color.yellow);
                break;
        }
        //根据坦克的方向，来绘制坦克
        switch (direction) {//0向上 1向右 2向下 3向左
            case 0://默认方向向上
                // 先画第一个矩形 大小 10*60
                //坦克左边轮子
                // 定点(x,y)
                g.fill3DRect(x, y, 10, 60, false);
                // 第二个矩形 大小 20*40
                //坦克身体
                // 定点(x+10,y+10)
                g.fill3DRect(x + 10, y + 10, 20, 40, false);
                // 第三个矩形 大小 10*60
                //坦克右边轮子
                // 定点(x+30,y)
                g.fill3DRect(x + 30, y, 10, 60, false);
                // 上面的圆盖子 大小 (20,20)
                // 定点(x+10,y+20)
                g.fillOval(x + 10, y + 20, 20, 20);
                // 最后的炮管
                // 定点1 (x+20,y)
                // 定点2 (x+20,y+30)
                g.drawLine(x + 20, y, x + 20, y + 30);
                // 画出子弹
                g.drawLine(x + 20, y, x + 20, y + 5);
                break;
            case 1://默认方向向右
                // 先画第一个矩形 大小 60*10
                //坦克上边轮子
                g.fill3DRect(x, y, 60, 10, false);
                // 第二个矩形 大小 40*20
                //坦克身体
                g.fill3DRect(x + 10, y + 10, 40, 20, false);
                // 第三个矩形 大小 10*60
                //坦克下边轮子
                g.fill3DRect(x, y + 30, 60, 10, false);
                // 上面的圆盖子 大小 (20,20)
                g.fillOval(x + 20, y + 10, 20, 20);
                // 最后的炮管
                g.drawLine(x + 60, y + 20, x + 30, y + 20);
                // 画出子弹
                g.drawLine(x + 60, y + 20, x + 55, y + 20);
                break;
            case 2://默认方向向下
                // 先画第一个矩形 大小 10*60
                //坦克左边轮子
                g.fill3DRect(x, y, 10, 60, false);
                // 第二个矩形 大小 20*40
                //坦克身体
                g.fill3DRect(x + 10, y + 10, 20, 40, false);
                // 第三个矩形 大小 10*60
                //坦克右边轮子
                g.fill3DRect(x + 30, y, 10, 60, false);
                // 上面的圆盖子 大小 (20,20)
                g.fillOval(x + 10, y + 20, 20, 20);
                // 最后的炮管
                g.drawLine(x + 20, y + 60, x + 20, y + 30);
                // 画出子弹
                g.drawLine(x + 20, y + 60, x + 20, y + 55);
                break;
            case 3://默认方向向左
                // 先画第一个矩形 大小 60*10
                //坦克上边轮子
                g.fill3DRect(x, y, 60, 10, false);
                // 第二个矩形 大小 40*20
                //坦克身体
                g.fill3DRect(x + 10, y + 10, 40, 20, false);
                // 第三个矩形 大小 10*60
                //坦克下边轮子
                g.fill3DRect(x, y + 30, 60, 10, false);
                // 上面的圆盖子 大小 (20,20)
                g.fillOval(x + 20, y + 10, 20, 20);
                // 最后的炮管
                g.drawLine(x, y + 20, x + 30, y + 20);
                // 画出子弹
                g.drawLine(x, y + 20, x + 5, y + 20);
                break;
            default:
                System.out.println("暂时不作处理");
        }
    }

    // 创建一个方法 hitMyTank
    // 判断敌人的子弹是否打中我们
    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);
                //判断shot是否击中我们的坦克
                if (myTank.isLive && shot.isLive) {
                    hitTank(shot, myTank);
                }
            }
        }
    }

    // 现我们的坦克可以发射多个子弹
    // 在判断我方子弹是否击中敌人坦克时，
    // 就需要把我们的子弹集合中所有的子弹都取出，
    // 和敌人的所有坦克进行判断
    public void hitEnemyTank() {
        //遍历我们的子弹
        for (int j = 0; j < myTank.shots.size(); j++) {
            Shot shot = myTank.shots.get(j);
            if (shot != null && shot.isLive) {//当前我的子弹还存活
                for (int i = 0; i < enemyTanks.size(); i++) {
                    EnemyTank enemyTank = enemyTanks.get(i);
                    hitTank(shot, enemyTank);
                }
            }
        }
    }

    // 编写方法，判断我方子弹是否击中敌人的坦克
    // 什么时候判断我方子弹是否击中敌人?
    // 在run方法里判断比较适合

    // 因为现在这方法用于判断我们的坦克跟敌人的坦克了
    // 所以这里把 EnemyTank enemyTank 改为 Tank tank
    //改用两者的父类 Tank 对象
    public void hitTank(Shot s, Tank tank) {
        //判断击中坦克
        switch (tank.getDirection()) {
            case 0://向上
            case 2://向下
                //子弹的x坐标大于坦克的最左边x坐标
                // 或者小于了坦克最右边x坐标（坦克宽40）
                //子弹的y坐标大于坦克的最上边y坐标
                // 或者小于了坦克最下边y坐标（坦克高60）
                if (s.x > tank.getX() && s.x < tank.getX() + 40
                        && s.y > tank.getY() && s.y < tank.getY() + 60) {
                    //子弹消失
                    s.isLive = false;
                    //敌人的坦克消失
                    tank.isLive = false;
                    //当我们的子弹击中敌人坦克时，将enemyTank从Vector拿掉
                    enemyTanks.remove(tank);

                    //当我方击毁敌人坦克时，就对数据allEnemyTankNum++
                    //因为 tank 可以是 MyTank，也可以是 EnemyTank
                    //所以我们这里要进行一个判断
                    if (tank instanceof EnemyTank) {
                        Recoder.addAllEnemyTankNum();
                    }

                    //创建Boom对象，加入到booms集合
                    Boom boom = new Boom(tank.getX(), tank.getY());
                    booms.add(boom);
                    break;
                }

            case 1://向右
            case 3://向左
                //子弹的x坐标大于坦克的最左边x坐标
                // 或者小于了坦克最右边x坐标（坦克宽60）
                //子弹的y坐标大于坦克的最上边y坐标
                // 或者小于了坦克最下边y坐标（坦克高40）
                if (s.x > tank.getX() && s.x < tank.getX() + 60
                        && s.y > tank.getY() && s.y < tank.getY() + 40) {
                    //子弹消失
                    s.isLive = false;
                    //敌人的坦克消失
                    tank.isLive = false;
                    //当我们的子弹击中敌人坦克时，将enemyTank从Vector拿掉
                    enemyTanks.remove(tank);

                    //当我方击毁敌人坦克时，就对数据allEnemyTankNum++
                    //因为 tank 可以是 MyTank，也可以是 EnemyTank
                    //所以我们这里要进行一个判断
                    if (tank instanceof EnemyTank) {
                        Recoder.addAllEnemyTankNum();
                    }

                    //创建Boom对象，加入到booms集合
                    Boom boom = new Boom(tank.getX(), tank.getY());
                    booms.add(boom);
                    break;
                }
        }
    }


    @Override
    public void keyTyped(KeyEvent e) {

    }

    //处理 wsad 按下的情况
    @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_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();
            }
        } else if (e.getKeyCode() == KeyEvent.VK_D) {
            myTank.setDirection(1);
            if (myTank.getX() + 60 < 1000) {
                myTank.moveRight();
            }
        }

        //如果用户按下J键，就是发射子弹
        if (e.getKeyCode() == KeyEvent.VK_J) {
            //判断当前myTank子弹是否已经销毁 发射一颗子弹
//            if (myTank.shot == null || !myTank.shot.isLive) {
//                myTank.shotEnemyTank();//发射子弹
//            }
            //判断当前myTank子弹是否已经销毁 发射duo颗子弹
            myTank.shotEnemyTank();
        }
        this.repaint();
    }

    @Override
    public void keyReleased(KeyEvent e) {

    }

    //让子弹不停的重绘
    @Override
    public void run() {
        while (true) {
            try {//每隔200毫秒，重绘
                Thread.sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            //把下面注释的这段代码封装到上面的方法里面
            //判断是否击中了敌人的坦克
//            if (myTank.shot != null && myTank.shot.isLive) {//当前我的子弹还存活
//                for (int i = 0; i < enemyTanks.size(); i++) {
//                    EnemyTank enemyTank = enemyTanks.get(i);
//                    hitTank(myTank.shot, enemyTank);
//                }
//            }
            //判断敌人坦克是否击中我们
            hitMyTank();
            hitEnemyTank();
            this.repaint();
        }
    }
}

保存敌人存活坦克的信息Node

//一个Node对象，表示一个敌人坦克的信息
public class Node {
    private int x;
    private int y;
    private int direction;

    public Node(int x, int y, int direction) {
        this.x = x;
        this.y = y;
        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 getDirection() {
        return direction;
    }

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

播放音乐的类AePlayWave

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();
        }

    }
}

主界面MyTankGame06

public class MyTankGame06 extends JFrame {
    //定义 MyPanel
    MyPanel mp = null;
    //用户输入界面
    static Scanner scanner = new Scanner(System.in);

    public static void main(String[] args) {

        MyTankGame06 myTankGame01 = new MyTankGame06();
    }

    public MyTankGame06() {
        //供用户选择:开始新游戏还是继续上局
        System.out.println("请输入选择：1：新游戏 2：继续上局");
        String key = scanner.next();
        //初始化
        mp = new MyPanel(key);
        //将mp放入到Thread并启动
        Thread thread = new Thread(mp);
        thread.start();
        //面板（游戏的绘图区域）
        this.add(mp);
        //面板大小
        this.setSize(1300, 750);
        //添加键盘监听
        this.addKeyListener(mp);
        //当点击窗口的 × ， 程序完全退出
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        //设置显示
        this.setVisible(true);

        //在 Jframe 中增加响应关闭窗口的处理
        this.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                Recoder.keepRecord();
                System.exit(0);
            }
        });
    }
}

这样一个简单版本的坦克大战就生成了。

你可能感兴趣的:(坦克大战进阶第三版：防止重叠,击杀记录,存盘退出,背景音乐等,Java学习,ui,java,前端)

OC语言多界面传值五大方式 Magnetic_h ios ui 学习 objective-c 开发语言
前言在完成暑假仿写项目时，遇到了许多需要用到多界面传值的地方，这篇博客来总结一下比较常用的五种多界面传值的方式。属性传值属性传值一般用前一个界面向后一个界面传值，简单地说就是通过访问后一个视图控制器的属性来为它赋值，通过这个属性来做到从前一个界面向后一个界面传值。首先在后一个界面中定义属性@interfaceBViewController:UIViewController@propertyNSSt
UI学习——cell的复用和自定义cell Magnetic_h ui 学习
目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
element实现动态路由+面包屑软件技术NINI vue案例 vue.js 前端
el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
微服务下功能权限与数据权限的设计与实现 nbsaas-boot 微服务 java 架构
在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
学点心理知识，呵护孩子健康静候花开_7090
昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
Long类型前后端数据不一致 igotyback 前端
响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
LocalDateTime 转 String igotyback java 开发语言
importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
swagger访问路径 igotyback swagger
Swagger2.x版本访问地址：http://{ip}:{port}/{context-path}/swagger-ui.html{ip}是你的服务器IP地址。{port}是你的应用服务端口，通常为8080。{context-path}是你的应用上下文路径，如果应用部署在根路径下，则为空。Swagger3.x版本对于Swagger3.x版本（也称为OpenAPI3）访问地址：http://{ip
扫地机类清洁产品之直流无刷电机控制悟空胆好小清洁服务机器人单片机人工智能
扫地机类清洁产品之直流无刷电机控制1.1前言扫地机产品有很多的电机控制，滚刷电机1个，边刷电机1-2个，清水泵电机，风机一个，部分中高端产品支持抹布功能，也就是存在抹布盘电机，还有追觅科沃斯石头等边刷抬升电机，滚刷抬升电机等的，这些电机有直流有刷电机，直接无刷电机，步进电机，电磁阀，挪动泵等不同类型。电机的原理，驱动控制方式也不行。接下来一段时间的几个文章会作个专题分析分享。直流有刷电机会自动持续
Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类 qt 开发语言 sdl2 linux
需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
向内而求陈陈_19b4
10月27日，阴。阅读书目:《次第花开》。作者:希阿荣博堪布，是当今藏传佛家宁玛派最伟大的上师法王，如意宝晋美彭措仁波切颇具影响力的弟子之一。多年以来，赴海内外各地弘扬佛法，以正式授课、现场开示、发表文章等多种方法指导佛学弟子修行佛法。代表作《寂静之道》、《生命这出戏》、《透过佛法看世界》自出版以来一直是佛教类书籍中的畅销书。图片发自App金句:1.佛陀说，一切痛苦的根源在于我们长期以来对自身及外
消息中间件有哪些常见类型 xmh-sxh-1314 java
消息中间件根据其设计理念和用途，可以大致分为以下几种常见类型：点对点消息队列（Point-to-PointMessagingQueues）：在这种模型中，消息被发送到特定的队列中，消费者从队列中取出并处理消息。队列中的消息只能被一个消费者消费，消费后即被删除。常见的实现包括IBM的MQSeries、RabbitMQ的部分使用场景等。适用于任务分发、负载均衡等场景。发布/订阅消息模型（Pub/Sub
《大清方方案》| 第二话谁佐清欢
和珅究竟说了些什么？竟能令堂堂九五之尊龙颜失色！此处暂且按下不表；单说这位乾隆皇帝，果真不愧是康熙从小带过的，一旦决定了要做的事，便杀伐决断毫不含糊。他当即亲自拟旨，着令和珅为钦差大臣，全权负责处理方方事件，并钦赐尚方宝剑，遇急则三品以下官员可先斩后奏。和珅身负皇上重托，岂敢有半点怠慢，当夜即率领相关人等，马不停蹄杀奔江汉。这一路上，和珅的几位幕僚一直在商讨方方事件的处置方案。有位年轻幕僚建议快刀
回溯 Leetcode 332 重新安排行程 mmaerd Leetcode刷题学习记录 leetcode 算法职场和发展
重新安排行程Leetcode332学习记录自代码随想录给你一份航线列表tickets，其中tickets[i]=[fromi,toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。例如，行程[“JFK”,“LGA”]与[“JFK”,“LGB
Python数据分析与可视化实战指南 William数据分析 python python 数据
在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
怎么起诉借钱不还的人？怎样起诉欠款不还的人？影子爱学习
怎么起诉借钱不还的人？怎样起诉欠款不还的人？如果遇到难以解决的法律问题，我们可以匹配专业律师。例如：婚姻家庭（离婚纠纷）、刑事辩护、合同纠纷、债权债务、房产（继承）纠纷、交通事故、劳动争议、人身损害、公司相关法律事务（法律顾问）等咨询推荐手机/微信:15633770876【全国案件皆可】借钱不还起诉对方需要哪些资料起诉欠钱不还的，一般需要的材料包括以下这些：借据、收据、欠条、付款凭证等证据，以及向
第四天旅游线路预览——从换乘中心到喀纳斯湖陟彼高冈yu 基于Google earth studio 的旅游规划和预览旅游
第四天：从贾登峪到喀纳斯风景区入口，晚上住宿贾登峪；换乘中心有4路车，喀纳斯①号车，去喀纳斯湖，路程时长约5分钟；将上面的的行程安排进行动态展示，具体步骤见”Googleearthstudio进行动态轨迹显示制作过程“、“Googleearthstudio入门教程”和“Googleearthstudio进阶教程“相关内容，得到行程如下所示：Day4-2-480p
Goolge earth studio 进阶4——路径修改与平滑陟彼高冈yu Google earth studio 进阶教程旅游
如果我们希望在大约中途时获得更多的城市鸟瞰视角。可以将相机拖动到这里并创建一个新的关键帧。camera_target_clip_7EarthStudio会自动平滑我们的路径，所以当我们通过这个关键帧时，不是一个生硬的角度，而是一个平滑的曲线。camera_target_clip_8路径上有贝塞尔控制手柄，允许我们调整路径的形状。右键单击，我们可以选择“平滑路径”，这是默认的自动平滑算法，或者我们可
相信相信的力量孙丽_cdb3
孙丽中级十期坚持分享第345天有一个特别有哲理的故事：有一只老鹰下了蛋，这个蛋，不知怎的就滚到了鸡窝里去了，鸡也下了一窝蛋，然后鸡妈妈把这些蛋全都浮出来了，孵出来之后等小鸡长大一点了，就觉得鹰蛋孵出来的那只小鹰怪模怪样，这些小鸡都嘲笑它，真难看，真笨，丑死了，那只小鹰觉得自己真是谁也不像，真是不好看，后来鸡妈妈也不喜欢他，我怎么生出你这样的孩子来了？真烦人，后来这群小鸡和小鹰一起生活，有一天，老鹰
DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计网页设计期末网页作业 html静态网页 html5期末大作业网页设计 web大作业
️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java 算法华为 javascript
华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
【加密社】Solidity 中的事件机制及其应用加密社闲侃区块链智能合约区块链
加密社引言在Solidity合约开发过程中，事件（Events）是一种非常重要的机制。它们不仅能够让开发者记录智能合约的重要状态变更，还能够让外部系统（如前端应用）监听这些状态的变化。本文将详细介绍Solidity中的事件机制以及如何利用不同的手段来触发、监听和获取这些事件。事件存储的地方当我们在Solidity合约中使用emit关键字触发事件时，该事件会被记录在区块链的交易收据中。具体而言，事件
春季养肝正当时 dxn悟
重温快乐2023年2月4日立春。春天来了，春暖花开，小鸟欢唱，那在这样的季节我们如何养肝呢？自然界的春季对应中医五行的木，人体五脏肝属木，“木曰曲直”，是以树干曲曲直直地向上、向外伸长舒展的生发姿态，来形容具有生长、升发、条达、舒畅等特征的食物及现象。根据中医天人相应的理念，肝五行属木，喜条达，主疏泄，与春天相应，所以春天最适合养肝。养肝首先要少生气，因为肝喜条达恶抑郁。人体五志肝为怒，生气发怒最
关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业 javascript html css 旅游风景
⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
HTML网页设计制作大作业（div+css）云南我的家乡旅游景点带文字滚动二挡起步 web前端期末大作业 web设计网页规划与设计 html css javascript dreamweaver 前端
Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
人工智能时代，程序员如何保持核心竞争力？ jmoych 人工智能
随着AIGC（如chatgpt、midjourney、claude等）大语言模型接二连三的涌现，AI辅助编程工具日益普及，程序员的工作方式正在发生深刻变革。有人担心AI可能取代部分编程工作，也有人认为AI是提高效率的得力助手。面对这一趋势,程序员应该如何应对?是专注于某个领域深耕细作，还是广泛学习以适应快速变化的技术环境?又或者，我们是否应该将重点转向AI无法轻易替代的软技能？让我们一起探讨程序员
每日算法&面试题，大厂特训二十八天——第二十天（树）肥学 ⚡算法题⚡面试题每日精进 java 算法数据结构
目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法进行二十八天的一个小总结。还在等什么快来一起肥学进行二十八天挑战吧！！特别介绍小白练手专栏，适合刚入手的新人欢迎订阅编程小白进阶python有趣练手项目里面包括了像《机器人尬聊》《恶搞程序》这样的有趣文章
2022现在哪个打车软件比较好用又便宜实惠的打车软件合集高省APP珊珊
这是一个信息高速传播的社会。信息可以通过手机，微信，自媒体，抖音等方式进行传播。但同时这也是一个交通四通发达的社会。高省APP，是2022年推出的平台，0投资，0风险、高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几百万篇报道，也期待你的加入。珊珊导师，高省邀请码777777，注册送2皇冠会员，送万元推广大礼包，教你如何1年做到百万团队。高
MongoDB Oplog 窗口喝醉酒的小白 MongoDB 运维
在MongoDB中，oplog（操作日志）是一个特殊的日志系统，用于记录对数据库的所有写操作。oplog允许副本集成员（通常是从节点）应用主节点上已经执行的操作，从而保持数据的一致性。它是MongoDB副本集实现数据复制的基础。MongoDBOplog窗口oplog窗口是指在MongoDB副本集中，从节点可以用来同步数据的时间范围。这个窗口通常由以下因素决定：Oplog大小：oplog的大小是有限
webpack图片等资源的处理 dmengmeng
需要的loaderfile-loader（让我们可以引入这些资源文件）url-loader（其实是file-loader的二次封装）img-loader（处理图片所需要的）在没有使用任何处理图片的loader之前，比如说css中用到了背景图片，那么最后打包会报错的，因为他没办法处理图片。其实你只想能够使用图片的话。只加一个file-loader就可以，打开网页能准确看到图片。{test:/\.(p
HQL之投影查询归来朝歌 HQL Hibernate 查询语句投影查询
在HQL查询中，常常面临这样一个场景，对于多表查询，是要将一个表的对象查出来还是要只需要每个表中的几个字段，最后放在一起显示？针对上面的场景，如果需要将一个对象查出来： HQL语句写“from 对象”即可 Session session = HibernateUtil.openSession();
Spring整合redis bylijinnan redis
pom.xml <dependencies>  <dependency> <groupId>org.springframework.data</groupId> <artifactId>spring-data-redi
org.hibernate.NonUniqueResultException: query did not return a unique result: 2 0624chenhong Hibernate
参考：http://blog.csdn.net/qingfeilee/article/details/7052736 org.hibernate.NonUniqueResultException: query did not return a unique result: 2 在项目中出现了org.hiber
android动画效果不懂事的小屁孩 android动画
前几天弄alertdialog和popupwindow的时候，用到了android的动画效果，今天专门研究了一下关于android的动画效果，列出来，方便以后使用。 Android 平台提供了两类动画。一类是Tween动画，就是对场景里的对象不断的进行图像变化来产生动画效果（旋转、平移、放缩和渐变）。第二类就是 Frame动画，即顺序的播放事先做好的图像，与gif图片原理类似。
js delete 删除机理以及它的内存泄露问题的解决方案换个号韩国红果果 JavaScript
delete删除属性时只是解除了属性与对象的绑定，故当属性值为一个对象时，删除时会造成内存泄露（其实还未删除）举例： var person={name:{firstname:'bob'}} var p=person.name delete person.name p.firstname -->'bob' // 依然可以访问p.firstname，存在内存泄露
Oracle将零干预分析加入网络即服务计划蓝儿唯美 oracle
由Oracle通信技术部门主导的演示项目并没有在本月较早前法国南斯举行的行业集团TM论坛大会中获得嘉奖。但是，Oracle通信官员解雇致力于打造一个支持零干预分配和编制功能的网络即服务（NaaS）平台，帮助企业以更灵活和更适合云的方式实现通信服务提供商（CSP）的连接产品。这个Oracle主导的项目属于TM Forum Live!活动上展示的Catalyst计划的19个项目之一。Catalyst计
spring学习——springmvc（二） a-john springMVC
Spring MVC提供了非常方便的文件上传功能。 1，配置Spring支持文件上传： DispatcherServlet本身并不知道如何处理multipart的表单数据，需要一个multipart解析器把POST请求的multipart数据中抽取出来，这样DispatcherServlet就能将其传递给我们的控制器了。为了在Spring中注册multipart解析器，需要声明一个实现了Mul
POJ-2828-Buy Tickets aijuans ACM_POJ
POJ-2828-Buy Tickets http://poj.org/problem?id=2828 线段树，逆序插入 #include<iostream>#include<cstdio>#include<cstring>#include<cstdlib>using namespace std;#define N 200010struct
Java Ant build.xml详解 asia007 build.xml
1,什么是antant是构建工具2,什么是构建概念到处可查到，形象来说，你要把代码从某个地方拿来，编译，再拷贝到某个地方去等等操作，当然不仅与此，但是主要用来干这个3,ant的好处跨平台 --因为ant是使用java实现的，所以它跨平台使用简单--与ant的兄弟make比起来语法清晰--同样是和make相比功能强大--ant能做的事情很多，可能你用了很久，你仍然不知道它能有
android按钮监听器的四种技术百合不是茶 android xml配置监听器实现接口
android开发中经常会用到各种各样的监听器,android监听器的写法与java又有不同的地方; 1,activity中使用内部类实现接口 ,创建内部类实例使用add方法与java类似创建监听器的实例 myLis lis = new myLis(); 使用add方法给按钮添加监听器
软件架构师不等同于资深程序员 bijian1013 程序员架构师架构设计
本文的作者Armel Nene是ETAPIX Global公司的首席架构师，他居住在伦敦，他参与过的开源项目包括 Apache Lucene,，Apache Nutch， Liferay 和 Pentaho等。如今很多的公司
TeamForge Wiki Syntax & CollabNet User Information Center sunjing TeamForge How do Attachement Anchor Wiki Syntax
the CollabNet user information center http://help.collab.net/ How do I create a new Wiki page? A CollabNet TeamForge project can have any number of Wiki pages. All Wiki pages are linked, and
【Redis四】Redis数据类型 bit1129 redis
概述 Redis是一个高性能的数据结构服务器，称之为数据结构服务器的原因是，它提供了丰富的数据类型以满足不同的应用场景，本文对Redis的数据类型以及对这些类型可能的操作进行总结。 Redis常用的数据类型包括string、set、list、hash以及sorted set.Redis本身是K/V系统，这里的数据类型指的是value的类型，而不是key的类型，key的类型只有一种即string
SSH2整合-附源码白糖_ eclipse spring tomcat Hibernate Google
今天用eclipse终于整合出了struts2+hibernate+spring框架。我创建的是tomcat项目，需要有tomcat插件。导入项目以后，鼠标右键选择属性，然后再找到“tomcat”项，勾选一下“Is a tomcat project”即可。具体方法见源码里的jsp图片，sql也在源码里。补充1：项目中部分jar包不是最新版的，可能导
[转]开源项目代码的学习方法 braveCS 学习方法
转自： http://blog.sina.com.cn/s/blog_693458530100lk5m.html http://www.cnblogs.com/west-link/archive/2011/06/07/2074466.html 1）阅读features。以此来搞清楚该项目有哪些特性2）思考。想想如果自己来做有这些features的项目该如何构架3）下载并安装d
编程之美-子数组的最大和（二维） bylijinnan 编程之美
package beautyOfCoding; import java.util.Arrays; import java.util.Random; public class MaxSubArraySum2 { /** * 编程之美子数组之和的最大值（二维） */ private static final int ROW = 5; private stat
读书笔记-3 chengxuyuancsdn jquery笔记 resultMap配置 ibatis一对多配置
1、resultMap配置 2、ibatis一对多配置 3、jquery笔记 1、resultMap配置当<select resultMap="topic_data"> <resultMap id="topic_data">必须一一对应。 (1)<resultMap class="tblTopic&q
[物理与天文]物理学新进展 comsci
如果我们必须获得某种地球上没有的矿石,才能够进行某些能量输出装置的设计和建造,而要获得这种矿石,又必须首先进行深空探测,而要进行深空探测,又必须获得这种能量输出装置,这个矛盾的循环,会导致地球联盟在与宇宙文明建立关系的时候,陷入困境怎么办呢?
Oracle 11g新特性:Automatic Diagnostic Repository daizj oracle ADR
Oracle Database 11g的FDI（Fault Diagnosability Infrastructure）是自动化诊断方面的又一增强。 FDI的一个关键组件是自动诊断库（Automatic Diagnostic Repository-ADR）。在oracle 11g中，alert文件的信息是以xml的文件格式存在的，另外提供了普通文本格式的alert文件。这两份log文
简单排序:选择排序 dieslrae 选择排序
public void selectSort(int[] array){ int select; for(int i=0;i<array.length;i++){ select = i; for(int k=i+1;k<array.leng
C语言学习六指针的经典程序，互换两个数字 dcj3sjt126com c
示例程序，swap_1和swap_2都是错误的，推理从1开始推到2，2没完成，推到3就完成了 # include <stdio.h> void swap_1(int, int); void swap_2(int *, int *); void swap_3(int *, int *); int main(void) { int a = 3; int b =
php 5.4中php-fpm 的重启、终止操作命令 dcj3sjt126com PHP
php 5.4中php-fpm 的重启、终止操作命令: 查看php运行目录命令：which php/usr/bin/php 查看php-fpm进程数：ps aux | grep -c php-fpm 查看运行内存/usr/bin/php -i|grep mem 重启php-fpm/etc/init.d/php-fpm restart 在phpinfo()输出内容可以看到php
线程同步工具类 shuizhaosi888 同步工具类
同步工具类包括信号量（Semaphore）、栅栏（barrier）、闭锁（CountDownLatch）闭锁（CountDownLatch） public class RunMain { public long timeTasks(int nThreads, final Runnable task) throws InterruptedException { fin
bleeding edge是什么意思 haojinghua DI
不止一次，看到很多讲技术的文章里面出现过这个词语。今天终于弄懂了——通过朋友给的浏览软件，上了wiki。我再一次感到，没有辞典能像WiKi一样，给出这样体贴人心、一清二楚的解释了。为了表达我对WiKi的喜爱，只好在此一一中英对照，给大家上次课。 In computer science, bleeding edge is a term that
c中实现utf8和gbk的互转 jimmee c iconv utf8&gbk编码
#include <iconv.h> #include <stdlib.h> #include <stdio.h> #include <unistd.h> #include <fcntl.h> #include <string.h> #include <sys/stat.h> int code_c
大型分布式网站架构设计与实践 lilin530 应用服务器搜索引擎
1.大型网站软件系统的特点？ a.高并发，大流量。 b.高可用。 c.海量数据。 d.用户分布广泛，网络情况复杂。 e.安全环境恶劣。 f.需求快速变更，发布频繁。 g.渐进式发展。 2.大型网站架构演化发展历程？ a.初始阶段的网站架构。应用程序，数据库，文件等所有的资源都在一台服务器上。 b.应用服务器和数据服务器分离。 c.使用缓存改善网站性能。 d.使用应用
在代码中获取Android theme中的attr属性值 OliveExcel android theme
Android的Theme是由各种attr组合而成, 每个attr对应了这个属性的一个引用, 这个引用又可以是各种东西. 在某些情况下, 我们需要获取非自定义的主题下某个属性的内容 (比如拿到系统默认的配色colorAccent), 操作方式举例一则: int defaultColor = 0xFF000000; int[] attrsArray = { andorid.r.
基于Zookeeper的分布式共享锁 roadrunners zookeeper 分布式共享锁
首先，说说我们的场景，订单服务是做成集群的，当两个以上结点同时收到一个相同订单的创建指令，这时并发就产生了，系统就会重复创建订单。等等......场景。这时，分布式共享锁就闪亮登场了。共享锁在同一个进程中是很容易实现的，但在跨进程或者在不同Server之间就不好实现了。Zookeeper就很容易实现。具体的实现原理官网和其它网站也有翻译，这里就不在赘述了。官
两个容易被忽略的MySQL知识 tomcat_oracle mysql
1、varchar(5)可以存储多少个汉字，多少个字母数字？　　相信有好多人应该跟我一样，对这个已经很熟悉了，根据经验我们能很快的做出决定，比如说用varchar(200)去存储url等等，但是，即使你用了很多次也很熟悉了，也有可能对上面的问题做出错误的回答。　　这个问题我查了好多资料，有的人说是可以存储5个字符，2.5个汉字（每个汉字占用两个字节的话），有的人说这个要区分版本，5.0
zoj 3827 Information Entropy(水题) 阿尔萨斯 format
题目链接：zoj 3827 Information Entropy 题目大意：三种底，计算和。解题思路：调用库函数就可以直接算了，不过要注意Pi = 0的时候，不过它题目里居然也讲了。。。limp→0+plogb(p)=0，因为p是logp的高阶。 #include <cstdio> #include <cstring> #include <cmath&

坦克大战进阶第三版：防止重叠、击杀记录、存盘退出、背景音乐等

坦克大战进阶第三版：防止重叠、击杀记录、存盘退出、背景音乐等

1. 坦克大战0.5版

1.1 功能进阶：

1.2 进阶思路一：

1.2.1 第一步：防止敌人坦克重叠运动

1.3 进阶思路二

1.3.1 第二步：记录玩家的总成绩(累积击毁敌方坦克数)，存盘退出[io流]

1.4 进阶思路三

1.4.1 第三步：记录退出游戏时敌人坦克坐标/方向,存盘退出[io流]

1.5 进阶思路四

1.5.1 第四步：玩游戏时，可以选择是开新游戏还是继续上局游戏

2. 坦克大战0.6版

2.1 功能进阶

2.2 进阶思路一：

2.2.1 第一步：游戏开始时，播放经典的坦克大战音乐 ，

2.3 进阶思路二：

2.3.1 第二步：修正下文件存储位置

2.4 进阶思路三：

2.4.1 第三步：处理文件相关异常

3. 坦克大战进阶0.6完整版

3.1 汇总

你可能感兴趣的:(坦克大战进阶第三版：防止重叠,击杀记录,存盘退出,背景音乐等,Java学习,ui,java,前端)

2.2.1 第一步：游戏开始时，播放经典的坦克大战音乐，