java零基础Ⅱ-- 11.坦克大战[3]

最新推荐文章于 2024-08-19 16:01:20 发布
最新推荐文章于 2024-08-19 16:01:20 发布
阅读量359 收藏
点赞数
分类专栏： java基础 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42469070/article/details/121659248
版权

java零基础Ⅱ-- 11.坦克大战[3]

连接视频



IO流 - 应用到坦克大战

坦克大战0.5版

增加功能【ZzpTankGame05.java】

1、防止敌人坦克重叠运动
2、记录玩家的成绩，存盘退出 【io流】
3、记录当时的敌人坦克坐标/方向，存盘退出【io流】
4、玩游戏时，可以选择是开新游戏还是继续上局游戏

package com.zzpedu.tankgame5;

/**
 * 炸弹
 */
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--;
        }
        if(life == 0){
            isLive = false;
        }
    }
}

package com.zzpedu.tankgame4;

import java.util.Vector;

/**
 * 敌人的坦克
 * @author zzp
 */
@SuppressWarnings({"all"})
public class EnemyTank extends Tank implements Runnable{
    //敌人的坦克类，使用Vector 保存多个Shot
    Vector<Shot> shots = new Vector<>();
    boolean isLive = true;//坦克是否还存活
    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 (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();
            }

            //根据坦克的方向来继续移动
            switch (getDirect()){
                case 0://向上
                    //让坦克保持一个方向，走30步
                    for (int i = 0; i < 30; i++) {
                        //判断范围
                        if(getY() > 0){
                            moveUp();
                        }
                        //休眠50毫秒
                        try {
                            Thread.sleep(50);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    break;
                case 1://向右
                    for (int i = 0; i < 30; i++) {
                        if((getX() + 60) < 1000){
                            moveRight();
                        }
                        //休眠50毫秒
                        try {
                            Thread.sleep(50);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    break;
                case 2://向下
                    for (int i = 0; i < 30; i++) {
                        if((getY() + 60) < 750){
                            moveDown();
                        }
                        //休眠50毫秒
                        try {
                            Thread.sleep(50);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    break;
                case 3://向左
                    for (int i = 0; i < 30; i++) {
                        if(getX() > 0){
                            moveLeft();
                        }
                        //休眠50毫秒
                        try {
                            Thread.sleep(50);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    break;
            }

            //然后随机的改变坦克方向 0-3
            //setDirect(3);//测试指定方向
            setDirect((int)(Math.random() * 4));

            //写并发程序，一定要考虑清楚，该线程什么时候结束
            if(!isLive){
                break;//退出线程
            }
        }
    }
}


package com.zzpedu.tankgame5;


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

/**
 * 坦克大战的绘图区域
 * @author zzp
 */
//为了监听键盘事件，要实现KeyListener
//为了让Panel 不停的重绘子弹，需要加 MyPanel 实现Runnable，当做一个线程使用
@SuppressWarnings({"all"})
public class MyPanel extends JPanel implements KeyListener,Runnable {
    //定义我的坦克
    MyTank myTank = null;

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

    //定义一个Vector，用于存放炸弹
    //说明，当子弹击中坦克时，加入一个Bomb对象到bombs
    Vector<Bomb> bombs = new Vector<>();
    //定义三张炸弹图片，用于显示爆炸效果
    Image image1 = null;
    Image image2 = null;
    Image image3 = null;

    public MyPanel(){
        myTank = new MyTank(500,100);//初始化自己的坦克
        myTank.setSpeed(1);
        //初始化敌人的坦克
        for(int i = 0; i < enemyTankSize; i++){
            //创建一个敌人的坦克
            EnemyTank enemyTank = new EnemyTank((100 * (i + 1)), 0);
            //设置方向
            enemyTank.setDirect(2);
            //启动敌人坦克线程，让其动起来
            new Thread(enemyTank).start();
            //给该enemyTank 加入一颗子弹
            Shot shot = new Shot(enemyTank.getX() + 20, enemyTank.getY() + 60, enemyTank.getDirect());
            //加入enemyTank的Vector 成员
            enemyTank.shots.add(shot);
            //启动shot 对象
            new Thread(shot).start();
            //加入
            enemyTanks.add(enemyTank);
        }
        //初始化图片对象
        image1 = Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/bomb1.png"));
        image2 = Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/bomb2.png"));
        image3 = Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/bomb3.png"));
    }

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

        if(myTank != null && myTank.isLive){
            //画出自己坦克-封装方法
            drawTank(myTank.getX(),myTank.getY(),g,myTank.getDirect(),1);
        }



        //画出myTank射击的子弹
//        if(myTank.shot != null && myTank.shot.isLive == true){
//            g.draw3DRect(myTank.shot.x,myTank.shot.y,2,2,false);
//        }
        //将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,2,2,false);
            }else {//如果该对象shot对象已经无效，就从shots集合中删除
                myTank.shots.remove(shot);
            }
        }

        //画出敌人的坦克,遍历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.getDirect(),0);
                //画出 enemyTank 所有子弹
                for(int j = 0; j < enemyTank.shots.size(); j++){
                    //取出子弹
                    Shot shot = enemyTank.shots.get(j);
                    //绘制
                    if(shot.isLive){// shot.isLive == true
                        g.draw3DRect(shot.x,shot.y,2,2,false);
                    }else {
                        //从Vector移除
                        enemyTank.shots.remove(shot);
                    }
                }
            }
        }
        long start = System.currentTimeMillis();
        //如果bombs 集合中有对象，就画出
        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);
                if (System.currentTimeMillis() - start < 90){
                    try {
                        Thread.sleep(20);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                start = System.currentTimeMillis();
            }else if(bomb.life > 3){
                g.drawImage(image2,bomb.x,bomb.y,60,60,this);
                if (System.currentTimeMillis() - start < 90){
                    try {
                        Thread.sleep(20);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                start = System.currentTimeMillis();
            }else {
                g.drawImage(image3,bomb.x,bomb.y,60,60,this);
                if (System.currentTimeMillis() - start < 90){
                    try {
                        Thread.sleep(20);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                start = System.currentTimeMillis();
            }

            //让炸弹的生命值减少
            bomb.lifeDown();
            //如果bomb life 为0，就从bombs 的集合中删除
            if(bomb.life == 0){
                bombs.remove(bomb);
            }
        }
    }

    /**
     *  编写方法，画出坦克
     * @param x 坦克的左上角x坐标
     * @param y 坦克的左上角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;
        }

        //根据坦克的方向，来绘制对应形状的坦克
        //direct 表示方向(0:向上 1:向右 2:向下 3:向左)
        switch (direct){
            case 0://表示向上方向
                g.fill3DRect(x,y,10,60,false);//画出坦克左边的轮子
                g.fill3DRect(x + 30,y,10,60,false);//画出坦克右边的轮子
                g.fill3DRect(x + 10,y + 10,20,40,false);//画出坦克盖子
                g.fillOval(x + 10,y + 20,20,20);//画出坦克圆盖子
                g.drawLine(x + 20,y + 30, x + 20,y);//画出炮筒
                break;
            case 1://表示向右
                g.fill3DRect(x,y,60,10,false);//画出坦克上边的轮子
                g.fill3DRect(x ,y + 30,60,10,false);//画出坦克下边的轮子
                g.fill3DRect(x + 10,y + 10,40,20,false);//画出坦克盖子
                g.fillOval(x + 20,y + 10,20,20);//画出坦克圆盖子
                g.drawLine(x + 30,y + 20, x + 60,y + 20);//画出炮筒
                break;
            case 2://表示向下
                g.fill3DRect(x,y,10,60,false);//画出坦克左边的轮子
                g.fill3DRect(x + 30,y,10,60,false);//画出坦克右边的轮子
                g.fill3DRect(x + 10,y + 10,20,40,false);//画出坦克盖子
                g.fillOval(x + 10,y + 20,20,20);//画出坦克圆盖子
                g.drawLine(x + 20,y + 30, x + 20,y + 60);//画出炮筒
                break;
            case 3://表示向左
                g.fill3DRect(x,y,60,10,false);//画出坦克上边的轮子
                g.fill3DRect(x ,y + 30,60,10,false);//画出坦克下边的轮子
                g.fill3DRect(x + 10,y + 10,40,20,false);//画出坦克盖子
                g.fillOval(x + 20,y + 10,20,20);//画出坦克圆盖子
                g.drawLine(x + 30,y + 20, x,y + 20);//画出炮筒
                break;
            default:
                System.out.println("暂时没有处理");
        }
    }

    //如果我们的坦克可以发射多个子弹
    //在判断我方子弹是否击中敌人坦克时，需要把我们的子弹集合中
    //使用子弹，都取出和敌人使用坦克,进行判断
    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);
                }
            }
        }
    }

    //编写方法，判断敌人的坦克是否击中我方坦克
    public void hitMyTank(){
        //遍历使用的敌人坦克
        for (int i = 0; i < enemyTanks.size(); i++) {
            //取出敌人坦克
            EnemyTank enemyTank = enemyTanks.get(i);
            //遍历enemyTank对象的所以子弹
            for (int j = 0; j < enemyTank.shots.size(); j++) {
                //取出子弹
                Shot shot = enemyTank.shots.get(j);
                //判断 shot 是否击中我方坦克
                if(myTank.isLive && shot.isLive){
                    hitTank(shot,myTank);
                }
            }
        }
    }

    //编写方法，判断我方的子弹是否击中敌人坦克
    //什么时候判断 我方子弹是否击中敌人坦克？ 在run方法 判断
    //后面我们将 enemyTank 改成 tank名称
    public void hitTank(Shot shot,Tank enemyTank){
        //判断shot  击中坦克
        switch (enemyTank.getDirect()){
            case 0://坦克向上
            case 2://坦克向下
                if(shot.x > enemyTank.getX() && shot.x < enemyTank.getX() + 40
                   && shot.y > enemyTank.getY() && shot.y < enemyTank.getY() + 60 ){
                    //击中
                    shot.isLive = false;
                    enemyTank.isLive = false;
                    //当我的子弹击中敌人坦克后，将enemyTank 从Vector 拿掉
                    enemyTanks.remove(enemyTank);
                    //创建Bomb对象，加入bombs集合
                    Bomb bomb = new Bomb(enemyTank.getX(), enemyTank.getY());
                    bombs.add(bomb);
                }
                break;
            case 1://坦克向右
            case 3://坦克向左
                if(shot.x > enemyTank.getX() && shot.x < enemyTank.getX() + 60
                    && shot.y > enemyTank.getY() && shot.y < enemyTank.getY() + 40 ){
                    //击中
                    shot.isLive = false;
                    enemyTank.isLive = false;
                    //当我的子弹击中敌人坦克后，将enemyTank 从Vector 拿掉
                    enemyTanks.remove(enemyTank);
                    //创建Bomb对象，加入bombs集合
                    Bomb bomb = new Bomb(enemyTank.getX(), enemyTank.getY());
                    bombs.add(bomb);
                }
                break;
        }
    }

    @Override
    public void keyTyped(KeyEvent e) {
    }

    //处理按键事件 wdsa
    @Override
    public void keyPressed(KeyEvent e) {
        if(e.getKeyCode() == KeyEvent.VK_W){//按下W键
            //改变坦克方向 上
            myTank.setDirect(0);
            //修改坦克的坐标 y -= 1
            if(myTank.getY() > 0){
                myTank.moveUp();
            }
        }else if(e.getKeyCode() == KeyEvent.VK_D){//按下D键
            //改变坦克方向 右
            myTank.setDirect(1);
            if((myTank.getX() + 60) < 1000){
                myTank.moveRight();
            }
        }else if(e.getKeyCode() == KeyEvent.VK_S){//按下S键
            //改变坦克方向 下
            myTank.setDirect(2);
            if((myTank.getY() + 60) < 750){
                myTank.moveDown();
            }
        }else if(e.getKeyCode() == KeyEvent.VK_A){//按下A键
            //改变坦克方向 左
            myTank.setDirect(3);
            if(myTank.getX() > 0){
                myTank.moveLeft();
            }
        }
        //如果用户按下的是J键，就发射子弹
        if(e.getKeyCode() == KeyEvent.VK_J){
            System.out.println("用户按下了J，开始射击~");
            //判断myTank的子弹是否销毁，发射一颗子弹的情况
//            if(myTank.shot == null || !myTank.shot.isLive){
//                myTank.shotEnemyTank();
//            }
            //发射多颗子弹的情况
            myTank.shotEnemyTank();
        }
        //让面板重绘
        this.repaint();
    }

    @Override
    public void keyReleased(KeyEvent e) {
    }

    @Override
    public void run() {//每个 100毫秒 重绘区域，刷新绘图区域，子弹移动起来
        while (true){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

//            //判断是否击中 敌人的坦克
//            if(myTank.shot != null && myTank.shot.isLive){//当我方子弹还存活
//                //遍历敌人所以坦克
//                for (int i = 0; i < enemyTanks.size(); i++) {
//                    EnemyTank enemyTank = enemyTanks.get(i);
//                    hitTank(myTank.shot,enemyTank);
//                }
//            }
            hitEnemyTank();
            //判断敌人坦克是否击中我方坦克
            hitMyTank();
            this.repaint();
        }
    }
}

package com.zzpedu.tankgame5;

import java.util.Vector;

/**
 * 自己的坦克
 * @author zzp
 */
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(){
        //控制发射子弹，最多有 5 颗
        if(shots.size() == 5){
            return;
        }

        //创建 Shot 对象，根据当前对象MyTank对象的位置和方向来创建Shot
        switch (getDirect()){//得到MyTank对象方向
            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();
    }

}

package com.zzpedu.tankgame5;

/**
 * 射击子弹
 */
public class Shot implements Runnable{
    int x;//子弹x坐标
    int y;//子弹y坐标
    int direct = 0;//子弹方向
    int speed = 2;//子弹速度
    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 (true){
            //让线程休眠50毫秒
            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;
            }
            //测试，这里我们输出x,y的坐标
            //System.out.println("子弹 x=" + x + " y=" + y);
            //当子弹移动到面板的边界时，就应销毁(把启动的子弹的线程销毁)
            //当子弹碰到敌人坦克时，也应该结束线程
            if(!(x >= 0 && x<= 1000 && y >=0 && y <= 750 && isLive)){
                System.out.println("子弹移动到边界了 退出~  x=" + x + " y=" + y );
                isLive = false;
                break;
            }
        }

    }
}

package com.zzpedu.tankgame5;

/**
 * @author zzp
 */
public class Tank {
    private int x;//坦克的横坐标
    private int y;//坦克的纵坐标
    private int direct;//坦克的方向 0上 1右 2下 3左
    private int speed = 1;//坦克的速度
    boolean isLive = true;
    public Tank(int x, int y) {
        this.x = x;
        this.y = y;
    }
    //上右下左移动方法
    public void moveUp(){
        y -= speed;
    }
    public void moveRight(){
        x += speed;
    }
    public void moveDown(){
        y += speed;
    }
    public void moveLeft(){
        x -= speed;
    }

    public 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; }
    public int getSpeed() { return speed; }
    public void setSpeed(int speed) { this.speed = speed; }
}

package com.zzpedu.tankgame5;

import javax.swing.*;

/**
 * @author zzp
 */
public class ZzpTankGame05 extends JFrame {
    //定义MyPanel
    MyPanel mp = null;

    public static void main(String[] args) {
        ZzpTankGame05 zzpTankGame04 = new ZzpTankGame05();
    }

    public ZzpTankGame05() {//构造器
        mp = new MyPanel();
        //将mp 放入Thread，并启动
        new Thread(mp).start();
        this.add(mp);//把面板(就是游戏的绘图区域)
        this.setSize(1000,750);
        //让JFrame 监听mp键盘事件
        this.addKeyListener(mp);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setVisible(true);
    }
}

在这里插入图片描述


防止敌人坦克重叠运动

思路：判断坦克之间 方向 位置 坐标相同的几种情况

在这里插入图片描述

防止敌人坦克重叠运动1

在EnemyTank类，添加isTouchEnemyTank方法，在run方法添加代码

/**
 * 敌人的坦克
 * @author zzp
 */
@SuppressWarnings({"all"})
public class EnemyTank extends Tank implements Runnable{
    //敌人的坦克类，使用Vector 保存多个Shot
    Vector<Shot> shots = new Vector<>();
    //增加成员，EnemyTank 可以得到敌人坦克的Vector
    //分析
    //1. Vector<EnemyTank> 在
    Vector<EnemyTank> enemyTanks = new Vector<>();
    boolean isLive = true;//坦克是否还存活
    public EnemyTank(int x, int y) {
        super(x, y);
    }

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

    //编写方法，判断当前的敌人坦克，是否和 enemyTanks 中的其他坦克发生重叠或者碰撞
    public boolean isTouchEnemyTank(){
        //判断当前敌人坦克(this)方向
        switch (this.getDirect()){
            case 0://向上
                //让当前敌人坦克和其它所有坦克比较
                for (int i = 0; i < enemyTanks.size(); i++) {
                    //从Vector 中取出一个敌人的坦克
                    EnemyTank enemyTank = enemyTanks.get(i);
                    //不和自己比较
                    if(enemyTank != this){
                        //如果敌人坦克是 上/下方向
                        //分析
                        //1. 如果敌人坦克是 上/下方向 x范围 [enemyTank.getX(), enemyTank.getX() + 40]
                        //                       y范围 [enemyTank.getY(), enemyTank.gety() + 60]
                        if(enemyTank.getDirect() == 0 || enemyTank.getDirect() == 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.getDirect() == 1 || enemyTank.getDirect() == 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++) {
                    //从Vector 中取出一个敌人的坦克
                    EnemyTank enemyTank = enemyTanks.get(i);
                    //不和自己比较
                    if(enemyTank != this){
                        //如果敌人坦克是 上/下方向
                        //分析
                        //1. 如果敌人坦克是 上/下方向 x范围 [enemyTank.getX(), enemyTank.getX() + 40]
                        //                       y范围 [enemyTank.getY(), enemyTank.gety() + 60]
                        if(enemyTank.getDirect() == 0 || enemyTank.getDirect() == 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.getDirect() == 1 || enemyTank.getDirect() == 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++) {
                    //从Vector 中取出一个敌人的坦克
                    EnemyTank enemyTank = enemyTanks.get(i);
                    //不和自己比较
                    if(enemyTank != this){
                        //如果敌人坦克是 上/下方向
                        //分析
                        //1. 如果敌人坦克是 上/下方向 x范围 [enemyTank.getX(), enemyTank.getX() + 40]
                        //                       y范围 [enemyTank.getY(), enemyTank.gety() + 60]
                        if(enemyTank.getDirect() == 0 || enemyTank.getDirect() == 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.getDirect() == 1 || enemyTank.getDirect() == 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++) {
                    //从Vector 中取出一个敌人的坦克
                    EnemyTank enemyTank = enemyTanks.get(i);
                    //不和自己比较
                    if(enemyTank != this){
                        //如果敌人坦克是 上/下方向
                        //分析
                        //1. 如果敌人坦克是 上/下方向 x范围 [enemyTank.getX(), enemyTank.getX() + 40]
                        //                       y范围 [enemyTank.getY(), enemyTank.gety() + 60]
                        if(enemyTank.getDirect() == 0 || enemyTank.getDirect() == 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.getDirect() == 1 || enemyTank.getDirect() == 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;
    }

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

            //根据坦克的方向来继续移动
            switch (getDirect()){
                case 0://向上
                    //让坦克保持一个方向，走30步
                    for (int i = 0; i < 30; i++) {
                        //判断范围 并且 判断是否碰撞
                        if(getY() > 0 && !isTouchEnemyTank()){
                            moveUp();
                        }
                        //休眠50毫秒
                        try {
                            Thread.sleep(50);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    break;
                case 1://向右
                    for (int i = 0; i < 30; i++) {
                        //判断范围 并且 判断是否碰撞
                        if((getX() + 60) < 1000 && !isTouchEnemyTank()){
                            moveRight();
                        }
                        //休眠50毫秒
                        try {
                            Thread.sleep(50);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    break;
                case 2://向下
                    for (int i = 0; i < 30; i++) {
                        //判断范围 并且 判断是否碰撞
                        if((getY() + 60) < 750 && !isTouchEnemyTank()){
                            moveDown();
                        }
                        //休眠50毫秒
                        try {
                            Thread.sleep(50);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    break;
                case 3://向左
                    for (int i = 0; i < 30; i++) {
                        //判断范围 并且 判断是否碰撞
                        if(getX() > 0 && !isTouchEnemyTank()){
                            moveLeft();
                        }
                        //休眠50毫秒
                        try {
                            Thread.sleep(50);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    break;
            }

        ....
    }
}

在MyPanel类，MyPanel方法设置敌人坦克集合，修改敌人数量演示效果

public class MyPanel extends JPanel implements KeyListener,Runnable {
    //定义我的坦克
    MyTank myTank = null;

    //定义敌人坦克，放入Vector中
    Vector<EnemyTank> enemyTanks = new Vector<>();
    int enemyTankSize = 6;

	...

    public MyPanel(){
        myTank = new MyTank(500,100);//初始化自己的坦克
        myTank.setSpeed(1);
        //初始化敌人的坦克
        for(int i = 0; i < enemyTankSize; i++){
            //创建一个敌人的坦克
            EnemyTank enemyTank = new EnemyTank((100 * (i + 1)), 0);
            //将 enemyTanks 设置给 enemyTank 一定给
            enemyTank.setEnemyTanks(enemyTanks);
            ...
        }
 		...
    }
	....
}

运行效果：

在这里插入图片描述



记录玩家成绩

累计击毁敌人坦克数量

在这里插入图片描述

思路：
记录我方击毁敌人坦克的总数

1、新增一个类 Recorder类（该类我方击毁敌方坦克的数量）
2、当游戏结束，将数据写入文件（IO）【myRecord.txt 文件夹】

显示我方击毁敌人坦克界面

在MyPanel类，添加方法

public class MyPanel extends JPanel implements KeyListener,Runnable {
    ...
    //编写方法，显示我方击毁敌方坦克的信息
    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("0",1080,100);

    }

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

修改ZzpTankGame05类的面板

public class ZzpTankGame05 extends JFrame {
    //定义MyPanel
    MyPanel mp = null;

    public static void main(String[] args) {
        ZzpTankGame05 zzpTankGame04 = new ZzpTankGame05();
    }

    public ZzpTankGame05() {//构造器
       ....
        this.setSize(1300,850);
      	....
    }
}

运行效果：

在这里插入图片描述


我方击毁敌人并记录

新增Recorder类，记录信息

/**
 * 该类记录相关的信息，和文件交互
 */
public class Recorder {

    //定义变量，记录我方击毁敌人坦克数
    private static int allEnemyTankNum = 0;
    //定义IO对象,用于写数据到文件中

    private static OutputStreamWriter osw = null;
    //文件路径
    private static String recordFile = "src\\myRecord.txt";

    //当我方坦克击毁一个敌人坦克，就应当 allEnemyTankNum++
    public static void addAllEnemyTankNum(){
        Recorder.allEnemyTankNum++;
    }

    //增加一个方法，当游戏退出时，我们将allEnemyTankNum 保存到 recordFile
    public static void keepRecord(){
        try {
            osw = new OutputStreamWriter(new FileOutputStream(recordFile),"gbk");
            osw.write(allEnemyTankNum + "\r\n");
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(osw != null){
                try {
                    osw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

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

在MyPanel类，添加方法

public class MyPanel extends JPanel implements KeyListener,Runnable {
	...
    //编写方法，显示我方击毁敌方坦克的信息
    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(Recorder.getAllEnemyTankNum() + "",1080,100);

    }
	//编写方法，判断我方的子弹是否击中敌人坦克
    //什么时候判断 我方子弹是否击中敌人坦克？ 在run方法 判断
    //后面我们将 enemyTank 改成 tank名称
    public void hitTank(Shot shot,Tank enemyTank){
        //判断shot  击中坦克
        switch (enemyTank.getDirect()){
            case 0://坦克向上
            case 2://坦克向下
                if(shot.x > enemyTank.getX() && shot.x < enemyTank.getX() + 40
                   && shot.y > enemyTank.getY() && shot.y < enemyTank.getY() + 60 ){
                    //击中
                    shot.isLive = false;
                    enemyTank.isLive = false;
                    //当我的子弹击中敌人坦克后，将enemyTank 从Vector 拿掉
                    enemyTanks.remove(enemyTank);

                    //当我方击毁一个敌人坦克时，就对数据 allEnemyTankNum++
                    //解读：因为 enemyTank 可以是 MyTank 也可以是 EnemyTank
                    if(enemyTank instanceof EnemyTank){
                        Recorder.addAllEnemyTankNum();
                    }

                    //创建Bomb对象，加入bombs集合
                    Bomb bomb = new Bomb(enemyTank.getX(), enemyTank.getY());
                    bombs.add(bomb);
                }
                break;
            case 1://坦克向右
            case 3://坦克向左
                if(shot.x > enemyTank.getX() && shot.x < enemyTank.getX() + 60
                    && shot.y > enemyTank.getY() && shot.y < enemyTank.getY() + 40 ){
                    //击中
                    shot.isLive = false;
                    enemyTank.isLive = false;
                    //当我的子弹击中敌人坦克后，将enemyTank 从Vector 拿掉
                    enemyTanks.remove(enemyTank);

                    //当我方击毁一个敌人坦克时，就对数据 allEnemyTankNum++
                    //解读：因为 enemyTank 可以是 MyTank 也可以是 EnemyTank
                    if(enemyTank instanceof EnemyTank){
                        Recorder.addAllEnemyTankNum();
                    }

                    //创建Bomb对象，加入bombs集合
                    Bomb bomb = new Bomb(enemyTank.getX(), enemyTank.getY());
                    bombs.add(bomb);
                }
                break;
        }
    }
}

在ZzpTankGame05类，添加监听事件

public class ZzpTankGame05 extends JFrame {
    //定义MyPanel
    MyPanel mp = null;

    public static void main(String[] args) {
        ZzpTankGame05 zzpTankGame04 = new ZzpTankGame05();
    }

    public ZzpTankGame05() {//构造器
        mp = new MyPanel();
        //将mp 放入Thread，并启动
        new Thread(mp).start();
        this.add(mp);//把面板(就是游戏的绘图区域)
        this.setSize(1300,850);
        //让JFrame 监听mp键盘事件
        this.addKeyListener(mp);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setVisible(true);

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

运行效果：
在这里插入图片描述
在这里插入图片描述


记录当时的敌人坦克坐标/方向

在Recorder类，添加敌人坦克集合

/**
 * 该类记录相关的信息，和文件交互
 */
public class Recorder {

    //定义变量，记录我方击毁敌人坦克数
    private static int allEnemyTankNum = 0;
    //定义IO对象,用于写数据到文件中

    private static OutputStreamWriter osw = null;
    //文件路径
    private static String recordFile = "src\\myRecord.txt";
    //定义Vector，指向 MyPanel 对象的 敌人坦克Vector
    private static Vector<EnemyTank> enemyTanks = null;

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

    //当我方坦克击毁一个敌人坦克，就应当 allEnemyTankNum++
    public static void addAllEnemyTankNum(){
        Recorder.allEnemyTankNum++;
    }

    //增加一个方法，当游戏退出时，我们将allEnemyTankNum 保存到 recordFile
    //对keepRecord 进行升级，保存敌人坦克的坐标方向
    public static void keepRecord(){
        try {
            osw = new OutputStreamWriter(new FileOutputStream(recordFile),"gbk");
            osw.write(allEnemyTankNum + "\r\n");
            //遍历敌人坦克的Vector, 然后根据情况保存即可，
            //OOP，定义一个属性，然后通过setXxx得到 敌人坦克的Vector
            for (int i = 0; i < enemyTanks.size(); i++) {
                //取出敌人坦克
                EnemyTank enemyTank = enemyTanks.get(i);
                if(enemyTank.isLive){//建议判断一下 存活状态
                    //保存该enemyTank信息
                    String record = enemyTank.getX() + " " + enemyTank.getY() + " " + enemyTank.getDirect();
                    //写入到文件
                    osw.write(record + "\r\n");
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(osw != null){
                try {
                    osw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

	...

在MyPanel类，设置Recorder类的敌人坦克

public class MyPanel extends JPanel implements KeyListener,Runnable {
	 public MyPanel(){
        //将MyPanel对象的 enemyTanks 设计给 Recorder 的 enemyTanks
        Recorder.setEnemyTanks(enemyTanks);
     	...  
    }   

}

运行效果：
在这里插入图片描述
在这里插入图片描述


玩游戏时，可以选择是开新游戏还是继续上局游戏

**思路：**将每个敌人信息，恢复成一个Node对象，放入Vector里，通过Node的Vector去恢复敌人坦克的位置和方向

新增Node类，保存敌人坐标信息

/**
 * 一个Node对象，表示一个敌人坦克的信息
 */
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类，添加读取敌人信息

/**
 * 该类记录相关的信息，和文件交互
 */
public class Recorder {

    //定义变量，记录我方击毁敌人坦克数
    private static int allEnemyTankNum = 0;
    //定义IO对象,用于写数据到文件中

    private static OutputStreamWriter osw = null;
    private static BufferedReader br = null;
   ...

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


    //增加一个方法，用于读取文件recordFile，恢复相关信息
    //该方法，在继续上局的时候调用即可
    public static Vector<Node> getNodesAndEnemyTankRec(){
        try {
            br = new BufferedReader(new InputStreamReader(
                    new FileInputStream(recordFile), "gbk"));
            allEnemyTankNum = Integer.parseInt(br.readLine()) ;
            //循环读取文件，生成node集合
            String line = "";//155 40 0
            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);//放入nodes Vector
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if(br != null){
                    br.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return nodes;
    }

}

在ZzpTankGame05类，添加 输入值 判断 新局 还是 继续上一局

/**
 * @author zzp
 */
public class ZzpTankGame05 extends JFrame {


    static Scanner scanner = new Scanner(System.in);

	...

    public ZzpTankGame05() {//构造器
        System.out.println("请输入选择 1: 新游戏 2: 继续上局");
        String key = scanner.next();

       ...
}

在MyPanel类，构造器中 添加判断

public class MyPanel extends JPanel implements KeyListener,Runnable {
   
    //定义一个存放Node 对象的Vector，用于恢复敌人坦克的坐标方向
    Vector<Node> nodes = new Vector<>();
  	...

    public MyPanel(String key){
        nodes = Recorder.getNodesAndEnemyTankRec();

        //将MyPanel对象的 enemyTanks 设计给 Recorder 的 enemyTanks
        Recorder.setEnemyTanks(enemyTanks);
        myTank = new MyTank(500,100);//初始化自己的坦克
        myTank.setSpeed(1);

        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.setDirect(2);
                    //启动敌人坦克线程，让其动起来
                    new Thread(enemyTank).start();
                    //给该enemyTank 加入一颗子弹
                    Shot shot = new Shot(enemyTank.getX() + 20, enemyTank.getY() + 60, enemyTank.getDirect());
                    //加入enemyTank的Vector 成员
                    enemyTank.shots.add(shot);
                    //启动shot 对象
                    new Thread(shot).start();
                    //加入
                    enemyTanks.add(enemyTank);
                }
                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();
                    //给该enemyTank 加入一颗子弹
                    Shot shot = new Shot(enemyTank.getX() + 20, enemyTank.getY() + 60, enemyTank.getDirect());
                    //加入enemyTank的Vector 成员
                    enemyTank.shots.add(shot);
                    //启动shot 对象
                    new Thread(shot).start();
                    //加入
                    enemyTanks.add(enemyTank);
                }
                break;
            default:
                System.out.println("你的输入有误...");
        }
        ...
	}
}

运行效果：

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述



坦克大战0.6版

增加功能【ZzpTankGame06.java】

1、游戏开始时，播放经典的坦克大战音乐
2、处理文件相关异常


播放音乐

使用一个播放音乐工具类,【注意：音乐文件后缀是…wav 格式的，自己不能随便改后缀】

/**
 * 音乐播放工具
 */
public class AePlayWave extends Thread{
    private String fieName;

    public AePlayWave(String fieName) {//构造器,指定文件
        this.fieName = fieName;
    }

    @Override
    public void run() {
        File sourceFile = new File(fieName);

        AudioInputStream audioInputStream = null;

        try {
            audioInputStream = AudioSystem.getAudioInputStream(sourceFile);
        } catch (Exception e) {
            e.printStackTrace();
            return;
        }

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

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

        dataLine.start();
        int nBytesRead = 0;
        //缓存
        byte[] abData = new byte[512];

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

    }
}

在MyPanel类，启动播放音乐

public class MyPanel extends JPanel implements KeyListener,Runnable {
   

    public MyPanel(String key){
		...
		//这里，播放指定的音乐
        new AePlayWave("src\\tank.wav").start();
	}
}

处理文件相关异常

如果第一次开启游戏时，选择继续上一局，如果文件myRecord.txt不存在时，后台会出现异常

Recorder 类添加获取文件路径方法

public class Recorder {
	...
	//返回记录文件的路径
    public static String getRecordFile() {
        return recordFile;
    }
}

MyPanel类添加判断

public class MyPanel extends JPanel implements KeyListener,Runnable {
  
	...
	 public MyPanel(String key){
        //先判断记录文件是否存在
        //如果存在，就正常执行，如果文件不存在，提示：只能开启新游戏， key = "1"
        File file = new File(Recorder.getRecordFile());
        if(file.exists()){
            nodes = Recorder.getNodesAndEnemyTankRec();
        }else {
            System.out.println("文件不存在，只能开启新的游戏");
            key = "1";
        }
        ....
	}
}
weixin_42469070
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
坦克大战系列三：从零编写【坦克大战】
你好, 我在学java的博客
12-15 716
坦克移动问题
坦克大战哦哦哦哦哦
m0_56398287的博客
05-26 224
文章目录防止坦克重叠坦克大战全部源码 防止坦克重叠 坦克的红点，碰到到别的坦克的范围就不动了 //获取全部的敌人坦克，故此来获得他们的坐标来比较是否碰撞 Vector<Enemy_Tank> enemy_tanks = new Vector<>(); //利用set方法来个坦克集合来赋值 public void setEnemy_tanks(Vector<Enemy_Tank> enemy_tanks) { this.enemy
今日份学习报告
qq_61411852的博客
03-24 2542
三月二十四号
java 坦克重叠_【Java_项目篇】--JAVA实现坦克大战游戏--修改BUG防止坦克重叠（六）...
weixin_33544518的博客
02-16 456
();// 定义8张图片,8张图片组成一颗炸弹Image image1 = null;Image image2 = null;Image image3 = null;Image image4 = null;Image image5 = null;Image image6 = null;Image image7 = null;Image image8 = null;public MyPanel() ...
【Java入门小游戏-坦克大战】.rar
12-20
【Java入门小游戏-坦克大战】是一款使用Java标准版（JAVASE）开发的初级编程练习项目，旨在帮助初学者理解并掌握Java编程基础，同时体验游戏开发的乐趣。在这个简易版的坦克大战中，玩家可以控制坦克移动、射击，与...
Java超级坦克大战-支持网络对战.rar
07-10
Java超级坦克大战-支持网络对战，分客户端和网络端，双打时需要在电脑上建立主机。还记得以前在电视游戏机上玩的伊拉克坦克大战吗？ 如果你很怀旧的话就试试我仿做的java版。 　几点说明： 　1、支持双人连线 ...
JAVA基础项目-坦克大战.zip
10-23
matlab算法，毕设、课设程序，全部源码均已进行严格测试，可以直接运行！ matlab算法，毕设、课设程序，全部源码均已进行严格测试，可以直接运行！ matlab算法，毕设、课设程序，全部源码均已进行严格测试，可以直接...
Java桌面-坦克大战小游戏.zip
10-10
Java桌面_坦克大战小游戏.zipJava桌面_坦克大战小游戏.zip Java桌面_坦克大战小游戏.zipJava桌面_坦克大战小游戏.zip Java桌面_坦克大战小游戏.zipJava桌面_坦克大战小游戏.zip Java桌面_坦克大战小游戏.zipJava桌面...
坦克大战--Java课程设计.doc
06-11
在本次Java课程设计中，学生们被要求开发一款名为"坦克大战"的游戏，这个游戏旨在利用面向对象编程的概念来实现。游戏的核心是通过Java GUI中的AWT包来构建一个交互式的坦克战斗环境，包含了各种元素如坦克、障碍物...
方向控制移动java程序_坦克游戏教程二：实现坦克移动以及方向控制
weixin_34439836的博客
02-27 468
今天实现了可以通过键盘的游戏键控制坦克的移动，以及可以控制其方向位置改变。同时可以绘制多辆敌方坦克。代码如下：/** Function: TankGame 1.0* Draw Tank*/package com.test1;import javax.swing.*;import java.util.*;import java.awt.*;import java.awt.event.*;import...
Java基础 - 坦克大战（第六章，敌人重叠运动，IO流记录玩家成绩，增加音乐，继续游戏功能）
qq_39123467的博客
02-05 2967
明天新课程，网络编程
java绘图_java绘图,画坦克
weixin_32494473的博客
02-21 231
/*** 功能:画出坦克*/package com.tank;import java.awt.Color;import java.awt.Font;import java.awt.Graphics;import javax.swing.*;public class myTankGame1 extends JFrame{public static void main(String[] args){m...
【Java_项目篇<1>】--JAVA实现坦克大战游戏--修改BUG防止坦克重叠（六）
ACMer_Shadow的博客
08-24 6559
前期相关文章【Java_项目篇<1>】–JAVA实现坦克大战游戏–画出坦克（一） 【Java_项目篇<1>】–JAVA实现坦克大战游戏–坦克移动+添加敌方坦克（二） 【Java_项目篇<1>】–JAVA实现坦克大战游戏–坦克发射子弹（三） 【Java_项目篇<1>】–JAVA实现坦克大战游戏–子弹连发+爆炸效果（四） 【Java_项目篇<1>】–JAVA实现坦克大战游戏–赋予敌人行动和攻
【链表在Java中DeBug】
最新发布
在这个充满危险的乱世之中，只有学会烤鸡才能顽强的活下去。
08-19 233
时，你实际上是在告诉当前节点 cur：“你的下一个节点应该是这个新创建的节点。，你将 cur 的引用更新为新创建的节点，这样 cur 现在就指向了你刚刚添加到链表末尾的节点。实际上，head 是一个固定的引用，它始终指向链表的第一个节点（即头节点）。当你看到链表似乎“增长”了，这实际上是因为你通过操作 cur（当前节点的引用）在链表的末尾添加了新的节点。所以，当你看到链表“增长”时，你实际上是在通过更新节点之间的链接（即 next 指针）来扩展链表结构。它只是保持了对链表起始节点的引用。
Spring Boot实现简单的Oracle数据库操作
beautiful77moon的博客
08-18 415
使用到的技术：1. Spring Boot：用于简化Spring应用的开发。2. Dynamic DataSource：实现动态多数据源的访问和切换3. Oracle JDBC Driver：与Oracle数据库进行连接和交互。4. Mybatis-Plus：简化SQL映射和数据库访问。其中BaseMapper接口提供了对数据表进行基本操作的功能。5. Lombok：用于简化Java类的开发，自动生成常用的代码，比如getter、setter、构造函数等。
Linux配置Maven环境
Java全栈开发者
08-18 407
官网地址：https://maven.apache.org/download.cgi。获取其对应的下载链接（也可以使用下载到本地后，手动上传到服务器的方式）切到自己想要存放的路径后，使用wget下载。使用pwd查看文件路径，ll查看文件名称。这里以当前最新版本3.9.8为例。
手撕快排——三种实现方法（附动图及源码）
jsjs1346的博客
08-16 962
🤖💻👨‍💻👩‍💻🌟🚀🤖🌟👨‍💻👩‍💻👨‍💻👩‍💻🚀是一种高效的排序算法，广泛应用于各种场景。它采用策略，将一个数组分成两个子数组，然后递归地对这两个子数组进行排序。本文将介绍三种快速排序的实现方法，并附上相应的源码。⚙️一、快速排序的基本原理一个基准元素（pivot）分成两个子数组递归合并O(n log n)O(n log n)O(n^2)后文我们将给出优化方案O(log n)📚三、实现霍尔方法是快速排序原始版本中使用的分区方法。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值