“盗版”坦克大战

最新推荐文章于 2024-06-13 08:37:22 发布

明々天

最新推荐文章于 2024-06-13 08:37:22 发布

阅读量86

点赞数 1

文章标签： java Powered by 金山文档

本文链接：https://blog.csdn.net/qq_63494746/article/details/128916116

版权

坦克大战

1、java绘图坐标体系

1）坐标原点在左上角，水平向右为x轴正方向，垂直向下为y轴正方向。单位是像素。

2）像素是个密度单位，而厘米是长度单位。

2、绘图原理

Component类提供了两个和绘图相关最重要的方法：

paint(Graphics g)：绘制组件的外观；

repaint()：刷新组件的外观。

当组件第一次在屏幕显示的时候，程序自动的调用paint()方法来绘制组件。

在以下情况paint()将会被调用：

窗口最小化，再最大化；

窗口的大小发生变化；

repaint函数被调用。

public class DrawCircle extends JFrame{//JFrame 对应窗口,相当于画框，然后往里面塞画板

    //定义一个面板
    private MyPanel mp = null;
    public static void main(String[] args) {
        new DrawCircle();
    }

    public DrawCircle(){
        //初始化面板
        mp = new MyPanel();
        //把面板放入到窗口
        this.add(mp);
        //设置窗口大小
        this.setSize(400,300);
        //当点击窗口的×时，真正的程序退出
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setVisible(true);//可以显示
    }
}

//1.先定义一个MyPanel，继承JPanel类，画图形
class MyPanel extends JPanel{

    //1.MyPanel对象就是一个画板
    //2.Graphics g 把 g 理解成一支画笔
    //3.Graphics 提供了很多绘图的方法
    @Override
    public void paint(Graphics g) {//绘图方法
        super.paint(g);//调用父类方法，执行初始化
        g.drawOval(10,10,100,100);
    }
}

3、Graphics类

Graphics类可以理解就是画笔，为我们提供各种绘制图像的方法：

1.画直线 drawLine(int x1,int y1,int x2,int y2);
2.画矩形边框 drawRect(int x,int y,int width,int height);
3.画椭圆边框 drawOval(int x,int y,int width,int height);
4.填充矩形 fillRect(int x,int y,int width,int height);
5.填充椭圆 fillOval(int x,int y,int width,int height);
6.画图片 drawImage(Image img,int x,int y,...);
7.画字符串 drawString(String str,int x,int y);
8.设置画笔的字体 setFont(Font font);
9.设置画笔的颜色 setColor(Color c);

//画图片 drawImage(Image img,int x,int y,...);
//1.获取图片资源
Image image = Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/1.png"));

g.drawImage(image,10,10,175,221,this);

//设置画笔的颜色 setColor(Color c);
//设置画笔的字体 setFont(Font font);
g.setColor(Color.red);
g.setFont(new Font("隶书", Font.BOLD, 50));

4、绘出坦克

public class Tank {
    private int x;//坦克的横坐标
    private int y;//坦克的纵坐标
    private int direct;//坦克方向
    private int speed = 1;//坦克速度

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

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

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

    public int getX() {
        return x;
    }

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

    public int getY() {
        return y;
    }

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

public class MyTank extends Tank{

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

}

public class MyPanel extends JPanel {
    //定义我的坦克
    MyTank hero = null;
    public MyPanel(){
        hero = new MyTank(100,100) ;//初始化自己坦克
    }

    @Override
    public void paint(Graphics g) {
        super.paint(g);
        g.fillRect(0,0,1000,750);//背景区域

        //绘制坦克
        drawTank(hero.getX(),hero.getY(),g,0,0);
    }

    //画出坦克

    /**
     *
     * @param x 坦克的左上角横坐标
     * @param y 坦克的左上角纵坐标
     * @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.cyan);
                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, x + 20, y + 30);//炮管
                break;
            default:
                System.out.println("暂时未处理");
        }
    }
}

public class ZWJTankGame01 extends JFrame {

    //定义MyPanel
    MyPanel mp = null;
    public static void main(String[] args) {
        new ZWJTankGame01();
    }

    public ZWJTankGame01(){
        mp = new MyPanel();
        this.add(mp);
        this.setSize(1000,750);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setVisible(true);
    }
}

5、java事件处理机制

java事件处理是采取“委派事件模型”。当事件发生时，产生事件的对象，会把此“信息”传递给“事件的监听者”处理，这里所说的“信息”实际上就是 java.awt.event 事件类库里某个类所创建的对象。

public class BallMove extends JFrame{
    MyPanel mp = null;
    public static void main(String[] args) {
        BallMove ballMove = new BallMove();

    }

    public BallMove(){
        mp = new MyPanel();
        this.add(mp);
        this.setSize(400,300);
        //窗口可以监听键盘事件
        this.addKeyListener(mp);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setVisible(true);
    }
}
//画小球
//KeyListener 是监听器，可以监听键盘事件
class MyPanel extends JPanel implements KeyListener {
    int x = 10;
    int y = 10;

    @Override
    public void paint(Graphics g) {
        super.paint(g);
        g.fillOval(x,y,20,20);
    }

    //有字符输出时，该方法被触发
    @Override
    public void keyTyped(KeyEvent e) {

    }

    //当某个键按下
    @Override
    public void keyPressed(KeyEvent e) {
        if(e.getKeyCode() == KeyEvent.VK_DOWN){//向下
            y++;
        }else if(e.getKeyCode() == KeyEvent.VK_UP){
            y--;
        }else if(e.getKeyCode() == KeyEvent.VK_LEFT){
            x--;
        }else if(e.getKeyCode() == KeyEvent.VK_RIGHT){
            x++;
        }

        //重绘
        this.repaint();
    }

    //当某个键松开
    @Override
    public void keyReleased(KeyEvent e) {

    }
}

6、坦克移动

绘制四种方向的坦克：

//根据坦克方向，来绘制坦克
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, x + 20, y + 30);//炮管
        break;
    case 1://表示向右
        g.fill3DRect(x, y, 60, 10, false);//上轮
        g.fill3DRect(x, y + 30, 60, 10, false);//下轮
        g.fill3DRect(x + 10, y + 10, 40, 20, false);//身体
        g.fillOval(x + 20, y + 10, 20, 20);//炮台
        g.drawLine(x + 30, y + 20, x + 60, y + 20);//炮管
        break;
    case 2://表示向下
        g.fill3DRect(x, y, 10, 60, false);//左轮
        g.fill3DRect(x + 30, y, 10, 60, false);//右轮
        g.fill3DRect(x + 10, y + 10, 20, 40, false);//身体
        g.fillOval(x + 10, y + 20, 20, 20);//炮台
        g.drawLine(x + 20, y + 30, x + 20, y + 60);//炮管
        break;
    case 3://表示向右
        g.fill3DRect(x, y, 60, 10, false);//上轮
        g.fill3DRect(x, y + 30, 60, 10, false);//下轮
        g.fill3DRect(x + 10, y + 10, 40, 20, false);//身体
        g.fillOval(x + 20, y + 10, 20, 20);//炮台
        g.drawLine(x + 30, y + 20, x, y + 20);//炮管
        break;
    default:
        System.out.println("暂时未处理");
}

键盘监听：坦克类多个属性direct

//处理wasd键
@Override
public void keyPressed(KeyEvent e) {
    if(e.getKeyCode() == KeyEvent.VK_W){
        hero.setDirect(0);
        hero.moveUp();
    }else if(e.getKeyCode() == KeyEvent.VK_D){
        hero.setDirect(1);
        hero.moveRight();
    }else if(e.getKeyCode() == KeyEvent.VK_S){
        hero.setDirect(2);
        hero.moveDown();
    }else if(e.getKeyCode() == KeyEvent.VK_A){
        hero.setDirect(3);
        hero.moveLeft();
    }

    this.repaint();
}

7、敌人坦克

分析：

敌人的坦克应该会有自己特殊的属性和方法，可以单开一个EnemyTank类；

敌人坦克数量多，可以放入到集合Vector，因为考虑多线程问题。

//定义敌人坦克
Vector<EnemyTank> enemyTanks = new Vector<>();
int enemyTankSize = 3;

public MyPanel() {
    hero = new MyTank(100, 100);//初始化自己坦克
    hero.setSpeed(5);
    //初始化敌人坦克
    for (int i = 0; i < enemyTanks.size(); i++) {
        EnemyTank enemyTank = new EnemyTank((100 * (i + 1)),0);
        enemyTank.setDirect(2);
        enemyTanks.add(enemyTank);
    }
}

//绘制敌人坦克
for (int i = 0; i < enemyTankSize; i++) {
    //取出坦克
    EnemyTank enemyTank = enemyTanks.get(i);
    drawTank(enemyTank.getX(), enemyTank.getY(), g, enemyTank.getDirect(), 1);
}

8、坦克发射子弹

分析：

当发射一颗子弹后，就相当于启动一个线程；

Hero 有子弹对象，当按下J时，我们就启动一个发射行为(线程)，让子弹不停的移动；

我们面板MyPanel需要不停重绘子弹，才能形成射击效果；

当子弹碰到边界，就应该销毁。

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

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

    @Override
    public void run() {//射击

        while (isLive) {
            //休眠
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //根据方向来改变x,y
            switch (direct) {
                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 = false;
                break;
            }
        }
    }
}

public class MyTank extends Tank {
    //定义一个Shot对象
    Shot shot = null;

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

    //射击
    public void shotEnemyTank() {
        //创建Shot对象
        switch (getDirect()) {
            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线程
        Thread thread = new Thread(shot);
        thread.start();
    }


}

//MyPanel update!!!
@Override
public void paint(Graphics g) {
    ....

    //画出hero射击的子弹
    if (hero.shot != null && hero.shot.isLive == true) {
        g.draw3DRect(hero.shot.x, hero.shot.y, 1, 1, false);
    }

    ....
    }
}

@Override
public void keyPressed(KeyEvent e) {
    .....

    //如果用户按下的是J,就发射
    if (e.getKeyCode() == KeyEvent.VK_J) {
        hero.shotEnemyTank();
    }

    this.repaint();
}

//new add!!!!!!
@Override
public void run() { //每隔一定时间，重绘

    while(true) {	
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.repaint();
    }
}

//tankgame类 update!!!!!
//将mp 放入到Thread中，并启动
Thread thread = new Thread(mp);
thread.start();

遗留问题：自己还无法发射多枚子弹

9、大更新（WoW）

增加功能：

让敌人的坦克也能够发射子弹(可以有多颗子弹)；

子弹击中后产生爆炸效果；

敌人坦克可以自由移动；

控制我方坦克和敌人坦克在规定的范围移动。

1、敌射！多弹？

分析：

在敌人坦克类，使用Vector保存多个Shot；

当每创建一个敌人坦克对象，给该敌人坦克对象初始化一个Shot对象，同时启动Shot；

在绘制敌人坦克时，需要通过Vector，绘制所有的子弹；【同时也要删除死亡子弹】

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

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

}

//MyPanel update!!!!!!!
public MyPanel() {
    ...
    //初始化敌人坦克
    for (int i = 0; i < enemyTankSize; i++) {
        ....
        //给该坦克加入一颗子弹
        Shot shot = new Shot(enemyTank.getX()+20,enemyTank.getY()+60,
                             enemyTank.getDirect());
        //加入到enemyTank的Vector成员中
        enemyTank.shots.add(shot);
        //启动Shot线程
        Thread thread = new Thread(shot);
        thread.start();
        ....
    }
}

@Override
public void paint(Graphics g) {
    ....

    //绘制敌人坦克
    for (int i = 0; i < enemyTankSize; i++) {
        ....
        //画出 敌人坦克的子弹
        for (int j = 0; j < enemyTank.shots.size(); j++) {
            //取出子弹
            Shot shot = enemyTank.shots.get(j);
            //绘制
            if(shot.isLive){
                g.draw3DRect(shot.x, shot.y, 1, 1, false);
            }else{
                //从Vector中移除死亡子弹
                enemyTank.shots.remove(shot);
            }
        }
    }
}

遗留问题：我赌你的枪里只有一颗子弹。

2、爆炸艺术

//命中消失

//MyPanel update!!!!!!
//编写方法，判断我方的子弹是否击中敌人坦克
public static void hitTank(Shot s, EnemyTank enemyTank) {
    //判断s 击中坦克
    switch (enemyTank.getDirect()) {
        case 0://坦克向上
        case 2://坦克向下
            if (s.x > enemyTank.getX() && s.x < enemyTank.getX() + 40
                && s.y > enemyTank.getY() && s.y < enemyTank.getY() + 60) {
                s.isLive = false;
                enemyTank.isLive = false;
            }
            break;
        case 1://坦克向右
        case 3://坦克向左
            if (s.x > enemyTank.getX() && s.x < enemyTank.getX() + 60
                && s.y > enemyTank.getY() && s.y < enemyTank.getY() + 40) {
                s.isLive = false;
                enemyTank.isLive = false;
            }
            break;
    }
}

@Override
public void run() { //每隔一定时间，重绘

    while (true) {
        ....
        //判断是否击中敌人坦克
        if (hero.shot != null && hero.shot.isLive) {//当我子弹存活
            //遍历敌人所有的坦克
            for (int i = 0; i < enemyTanks.size(); i++) {
                EnemyTank enemyTank = enemyTanks.get(i);
                hitTank(hero.shot, enemyTank);
            }
        }

        this.repaint();
    }
}

//Shot update!!!!!!
@Override
public void run() {//射击

    while (isLive) {
        ....
        //子弹到达边界，应该销毁
        //当子弹碰到敌人的时候也应该结束线程
        if (!(x >= 0 && x <= 1000 && y >= 0 && y <= 750 && isLive)) {
            isLive = false;
            break;
        }
    }
}

//爆炸效果

//Bomb add!!!!!!!
public class Bomb {
    int x, y;//炸弹坐标
    int life = 9;//炸弹的生命周期
    boolean isLive = true;//是否还存活

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

    //减少生命值
    public void lifeDown() {
        if (life > 0) {
            life--;
        } else {
            isLive = false;
        }
    }
}

//MyPanel update!!!!!!!!!!!
//定义一个Vector，用于存放炸弹
//当子弹击中坦克时，加入一个Bomb对象
Vector<Bomb> bombs = new Vector<>();

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

public MyPanel() {
    ....
    //初始化爆炸图片
    image1 = Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/image1.jpg"));
    image2 = Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/image2.jpg"));
    image3 = Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/image3.jpg"));
}


public void hitTank(Shot s, EnemyTank enemyTank) {
    //判断s 击中坦克
    switch (enemyTank.getDirect()) {
        case 0://坦克向上
        case 2://坦克向下
            if (s.x > enemyTank.getX() && s.x < enemyTank.getX() + 40
                && s.y > enemyTank.getY() && s.y < enemyTank.getY() + 60) {
                s.isLive = false;
                enemyTank.isLive = false;
                //当我方子弹成功打中敌人坦克
                enemyTanks.remove(enemyTank);
                //创建Bomb对象，加入到bombs集合
                Bomb bomb = new Bomb(enemyTank.getX(), enemyTank.getY());
                bombs.add(bomb);
            }
            break;
        ....
    }
}

@Override
public void paint(Graphics g) {
    ....

    //画出爆炸效果
    for (int i = 0; i < bombs.size(); i++) {
        //取出炸弹
        Bomb bomb = bombs.get(i);
        //根据当前这个bomb对象的life值去画出对应的图片
        if (bomb.life > 6) {
            g.drawImage(image1, bomb.x, bomb.y, 60, 60, this);
        } else if (bomb.life > 3) {
            g.drawImage(image2, bomb.x, bomb.y, 60, 60, this);
        } else {
            g.drawImage(image3, bomb.x, bomb.y, 60, 60, this);
        }
        //让这个炸弹生命值减少
        bomb.lifeDown();
        //如果bomb life 为0，在集合中删掉
        if (bomb.life == 0) {
            bombs.remove(bomb);
        }
    }

    ....
}

3、自由的飞翔

分析：

因为要求敌人的坦克，可以自由移动，因此需要将敌人坦克当做线程使用；

我们需要EnemyTank implements Runnable；

在run中写上相应的业务代码；

在创建敌人坦克的时候，启动线程

//EnemyTank update!!!!!!!
@Override
public void run() {
    while (true) {
        //根据坦克方向来继续移动
        switch (getDirect()) {
            case 0:
                //营造出惯性的感觉
                for (int i = 0; i < 30; i++) {
                    moveUp();
                    //休眠
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                break;
            case 1:
                for (int i = 0; i < 30; i++) {
                    moveRight();
                    //休眠
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                break;
            case 2:
                for (int i = 0; i < 30; i++) {
                    moveDown();
                    //休眠
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                break;
            case 3:
                for (int i = 0; i < 30; i++) {
                    moveLeft();
                    //休眠
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                break;
        }

        //然后随机改变坦克方向
        setDirect((int) (Math.random() * 4));
        //写并发程序一定要考虑，该线程什么时候结束
        if (!isLive) {
            break;//退出线程
        }
    }
}

4、我就是规矩

//让坦克不能出边界
if (getY() > 0) {
    moveUp();
}
if (getX() + 60 < 1000) {
    moveRight();
}
if (getY() + 60 < 750) {
    moveDown();
}
if (getX() > 0) {
    moveLeft();
}

10、喵喵

我方坦克可以发射多枚子弹；

让敌人坦克发射的子弹消亡后，可以再发射子弹；

当敌人的坦克击中我方坦克，我方坦克消失，并出现爆炸效果。

1、火力不足恐惧症

//MyPanel update!!!!!!
@Override
public void paint(Graphics g) {
    ....
        
    //画出hero射击的子弹
    //        if (hero.shot != null && hero.shot.isLive == true) {
    //            g.draw3DRect(hero.shot.x, hero.shot.y, 1, 1, false);
    //        }
    //将hero的子弹集合shots，遍历绘制
    for (int i = 0; i < hero.shots.size(); i++) {
        Shot shot = hero.shots.get(i);
        if (shot != null && shot.isLive) {
            g.draw3DRect(shot.x, shot.y, 1, 1, false);
        }else{
            //如果该shot对象已经无效，要在集合中移除
            hero.shots.remove(shot);
        }
    }

    ....
}

//如果我们的坦克可以发射多个子弹
//要判断有没有打中
//就需要拿所有的子弹和所有的敌人进行比较
public void hitEnemyTank(){
    //遍历我们的子弹
    for (int j = 0; j < hero.shots.size(); j++) {
        Shot shot = hero.shots.get(j);
        //判断是否击中敌人坦克
        if (hero.shot != null && hero.shot.isLive) {//当我子弹存活
            //遍历敌人所有的坦克
            for (int i = 0; i < enemyTanks.size(); i++) {
                EnemyTank enemyTank = enemyTanks.get(i);
                hitTank(hero.shot, enemyTank);
            }
        }
    }
}

2、还想射(-_-)!

//EnemyTank update!!!!!!
@Override
public void run() {
    while (true) {

        //这里我们判断子弹集合大小==0，创建一颗子弹，放入到
        // shots集合中，并启动
        if (isLive && shots.size() < 10) {

            Shot s = null;
            //判断坦克方向，创建对应的子弹
            switch (getDirect()) {
                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();
        }

        ....
    }
}

3、你也想要爆炸吗？

//编写方法，判断敌人坦克是否击中我的坦克
public void hitHero() {
    //遍历所有敌人坦克
    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 (hero.isLive && shot.isLive) {
                hitTank(shot, hero);
            }
        }
    }
}

11、更新更新

防止敌人坦克重叠运动；

记录玩家的成绩，存盘退出；

记录当时敌人坦克坐标，存盘退出；

玩游戏时，可以选择重新开始或者继续上局游戏。

1、不要贴贴

//EnemyTank update!!!!!!
public class EnemyTank extends Tank implements Runnable {
    ....
        
    //增加成员，EnemyTank 可以得到敌认坦克的Vector
    Vector<EnemyTank> enemyTanks = new Vector<>();
    
    ....
        
    //可以将Mypanel对象中的敌人坦克集合放入
    public void setEnemyTanks(Vector<EnemyTank> enemyTanks) {
        this.enemyTanks = enemyTanks;
    }

    //编写方法，判断当前这个敌人坦克，是否和enemyTanks中的其他成员发生重叠或者碰撞
    public boolean isTouchEnemyTank() {

        switch (this.getDirect()) {
            case 0:
                //循环比较
                for (int i = 0; i < enemyTanks.size(); i++) {
                    //取出坦克
                    EnemyTank enemyTank = enemyTanks.get(i);
                    //不和自己比较
                    if (enemyTank != this) {
                        //如果敌人坦克是上下
                        if (enemyTank.getDirect() == 0 || enemyTank.getDirect() == 2) {
                            //左上角
                            if (this.getX() >= enemyTank.getX()
                                    && this.getX() <= enemyTank.getX() + 40
                                    && this.getY() >= enemyTank.getY()
                                    && this.getY() <= enemyTank.getY() + 60) {
                                return true;
                            }
                            //右上角
                            if (this.getX() + 40 >= enemyTank.getX()
                                    && this.getX() + 40 <= enemyTank.getX() + 40
                                    && this.getY() >= enemyTank.getY()
                                    && this.getY() <= enemyTank.getY() + 60) {
                                return true;
                            }
                        }
                        //如果敌人坦克是左右
                        if (enemyTank.getDirect() == 1 || enemyTank.getDirect() == 3) {
                            //左上角
                            if (this.getX() >= enemyTank.getX()
                                    && this.getX() <= enemyTank.getX() + 60
                                    && this.getY() >= enemyTank.getY()
                                    && this.getY() <= enemyTank.getY() + 40) {
                                return true;
                            }
                            //右上角
                            if (this.getX() + 40 >= enemyTank.getX()
                                    && this.getX() + 40 <= enemyTank.getX() + 60
                                    && this.getY() >= enemyTank.getY()
                                    && this.getY() <= enemyTank.getY() + 40) {
                                return true;
                            }
                        }
                    }
                }
                break;
            ....
        }
        return false;
    }


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

            ....
                
            //根据坦克方向来继续移动
            switch (getDirect()) {
                case 0:
                    //营造出惯性的感觉
                    for (int i = 0; i < 30; i++) {//多一个碰撞判断
                        if (getY() > 0 && !isTouchEnemyTank()) {
                            moveUp();
                        }
                        ....
                    }
                    break;
                ....
        }
    }
}

//MyPanel update!!!!!!!!
public MyPanel() {
    ....
    //初始化敌人坦克
    for (int i = 0; i < enemyTankSize; i++) {
        //创建敌人坦克
        EnemyTank enemyTank = new EnemyTank((100 * (i + 1)), 0);
        //将enemyTanks 设置给 enemyTank！！！！
        enemyTank.setEnemyTanks(enemyTanks);
        ....
    }
    ....
}

2、你曾经活过

创建新的类Recorder:

该类记录我方击败敌方坦克数；

当游戏结束时，将数据写入到文件(IO)。

//Recorder add!!!!!
public class Recorder {

    //记录我方击毁敌人坦克数
    private static int allEnemyTankNum = 0;
    //定义IO对象，准备写数据到文件中
    private static BufferedWriter bw = null;
    private static String recordFile = "d:\\myRecord.txt";

    //当游戏退出时，我们将allEnemyTankNum保存到文件中
    public static void keepRecord(){
        try {
            bw = new BufferedWriter(new FileWriter(recordFile));
            bw.write(allEnemyTankNum+"\r\n");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if(bw!=null) {
                    bw.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public static int getAllEnemyTankNum() {
        return allEnemyTankNum;
    }

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

    //当我方坦克击毁一个敌人坦克，就应该增加数量
    public static void addAllEnemyTankNum(){
        allEnemyTankNum++;
    }
}

//MyPanel update!!!!!!
//编写方法，显示我方击败敌方坦克的信息
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,1);
    g.setColor(Color.BLACK);
    g.drawString(Recorder.getAllEnemyTankNum()+"",1080,100);

}

//编写方法，判断我方的子弹是否击中敌人坦克
public void hitTank(Shot s, Tank enemyTank) {
    //判断s 击中坦克
    switch (enemyTank.getDirect()) {
        case 0://坦克向上
        case 2://坦克向下
            if (s.x > enemyTank.getX() && s.x < enemyTank.getX() + 40
                && s.y > enemyTank.getY() && s.y < enemyTank.getY() + 60) {
                ...
                //当我方击毁一个敌人坦克后，就对数据allEnemyTankNum++
                if(enemyTank instanceof EnemyTank){
                    Recorder.addAllEnemyTankNum();
                }
                ....
            }
            break;
        ....
    }
}

//在JFrame中
//增加响应关闭窗口的监听器
this.addWindowListener(new WindowAdapter() {
    @Override
    public void windowClosing(WindowEvent e) {
        Recorder.keepRecord();
        System.exit(0);
    }
});

3、存档点

在Recorder中，当退出游戏的时候，记录敌人坦克的坐标和方向。

//Recorder update!!!!!!!
//记得要在MyPanel中指向一下
public class Recorder {

    ....
    //定义Vector，指向敌人坦克Vecotr
    private static Vector<EnemyTank> enemyTanks = null;

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

    //当游戏退出时，我们将allEnemyTankNum保存到文件中
    //增加，保存敌人坦克的坐标和方向
    public static void keepRecord(){
        try {
            bw = new BufferedWriter(new FileWriter(recordFile));
            bw.write(allEnemyTankNum+"\r\n");
            //遍历Vector
            //定义一个方法，然后通过setXxx得到敌人坦克的Vecotr
            for (int i = 0; i < enemyTanks.size(); i++) {
                //取出敌人坦克
                EnemyTank enemyTank = enemyTanks.get(i);
                if(enemyTank.isLive){
                    //保存该坦克信息
                    String record = enemyTank.getX()+" "+enemyTank.getY()+" "+enemyTank.getDirect();
                    //写入到文件
                    bw.write(record+"\r\n");
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if(bw!=null) {
                    bw.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    ....
}

4、读档

将每个敌人信息，恢复成Node对象 => Vector。通过Node的Vector去恢复敌人坦克的位置和方向。

//Node add!!!!!!!!!!
public class Node {
    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;
    }
}

//Recorder update!!!!!!
public class Recorder {

    .....
    //定义一个Node的Vector,用于保存敌人的信息
    private static Vector<Node> nodes = new Vector<>();
	....

    //用于读取recordFile,恢复相关信息
    //该方法在继续上局游戏的时候调用
    public static Vector<Node> getNodesAndEnemyTankRec(){

        try {
            br = new BufferedReader(new FileReader(recordFile));
            allEnemyTankNum = Integer.parseInt(br.readLine());
            //循环读取文件，拿到敌人坦克信息,生成Nodes
            String line = "";
            while((line = br.readLine())!=null){
                String[] xyd = line.split(" ");
                Node node = new Node(Integer.parseInt(xyd[0]), Integer.parseInt(xyd[1]),
                        Integer.parseInt(xyd[2]));
                nodes.add(node);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if(br!=null){
                    br.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return nodes;
    }

    .....
}

//MyPanel update!!!!!!!!
//定义Node,Vector,用于恢复敌人坦克对象
Vector<Node> nodes = null;

public MyPanel(String key) {
    nodes = Recorder.getNodesAndEnemyTankRec();
    //将敌人坦克Vector赋给Recorder
    Recorder.setEnemyTanks(enemyTanks);
    hero = new MyTank(250, 250);//初始化自己坦克
    hero.setSpeed(5);

    switch (key) {
        case "1":
            ....
            break;
        case "2"://继续上局游戏
            //初始化敌人坦克
            for (int i = 0; i < nodes.size(); i++) {
                //取出一个敌人坦克
                Node node = nodes.get(i);
                //创建敌人坦克
                EnemyTank enemyTank = new EnemyTank(node.getX(), node.getY());
                //将enemyTanks 设置给 enemyTank！！！！
                enemyTank.setEnemyTanks(enemyTanks);
                //设置方向
                enemyTank.setDirect(node.getDirect());
                //启动线程
                new Thread(enemyTank).start();
                //给该坦克加入一颗子弹
                Shot shot = new Shot(enemyTank.getX() + 20, enemyTank.getY() + 60, enemyTank.getDirect());
                //加入到enemyTank的Vector成员中
                enemyTank.shots.add(shot);
                //启动Shot线程
                Thread thread = new Thread(shot);
                thread.start();
                //加入
                enemyTanks.add(enemyTank);
            }
            break;
        default:
            System.out.println("你的输入有问题。。。。");
    }

    ....
}

//JFrame update!!!!!!!
Scanner scanner = new Scanner(System.in);

System.out.println("请输入选择1：新游戏 2：继续上局");
String key = scanner.next();
mp = new MyPanel(key);

12、0.6版本更新

游戏开始时，播放经典的坦克大战音乐；

修正下文件存储位置；

处理文件相关异常。

1、打开音响

使用一个播放音乐的类，即可。

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;
        }
        //允许数据行执行数据 I/O
        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();
        }
    }
}

//MyPanel的MyPanel()中添一句
//播放指定的音乐
new AePlayWave("src\\111.wav").start();
//文件放在src目录下

2、修正

//把记录文件保存到 src 下
//private static String recordFile = "d:\\myRecord.txt";
private static String recordFile = "src\\myRecord.txt";

3、还是**的修正

防止记录文件找不到，无法开启游戏的尴尬。

//MyPanel() update!!!!!!
//先判断记录的文件是否存在
//如果存在，就正常执行，如果文件不存在，提示，只能开启新游戏，key=="1"
File file = new File(Recorder.getRecordFile());
if (key.equals("2") && !file.exists()) {
    System.out.println("文件不存在，只能开启新游戏");
    key = "1";
}