栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

坦克大战JAVA版(全码)

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

坦克大战JAVA版(全码)

 游戏运行图片

源码分两大块:

java类和resources

其中java中又分了constant、tank、util、window、StartGame(主类);constant里只有Constant类;tank有Bomb、Bullet、EnemyTank、HeroTank、Tank类;util中含MyThreadFactroy、MyUtil、PlayAudio、Recorder类;window中只有MainWindow和MyPanel类。

而resources中只有res,res中含audio和data及image,image中为gif类的三张图片(坦克爆炸图片)

 一、constant中的Constant类

package constant;

// 系统常量




public class Constant {
    // 游戏界面宽度
    public static final int WINDOW_WIDTH = 1450;
    // 游戏界面高度
    public static final int WINDOW_HEIGHT = 950;
    // 界面顶部标题栏高度
    public static final int WINDOW_TITLE_HEIGHT = 25;
    // 信息栏高度
    public static  final int INFO_BAR_HEIGHT = 100;

    // 界面重绘时间
    public static final int REPAINT_TIME = 80;

    // 游戏状态
    public static final int GAME_WIN = 1;
    public static final int GAME_RUNNING = 0;
    public static final int GAME_FAIL = -1;
    public static final int GAME_INIT = -2;

    //我方坦克初始数量
    public static final int MY_TANK_INIT_NUM = 3;
    //敌方坦克初始数量
    public static final int ENEMY_TANK_INIT_NUM = 30;

    // 坦克轮子宽度
    public static final int TANK_WHEEL_WIDTH = 10;
    // 坦克轮子高度
    public static final int TANK_WHEEL_HEIGHT = 60;
    // 坦克主体宽度
    public static final int TANK_BODY_WIDTH = 20;
    // 坦克主体高度
    public static final int TANK_BODY_HEIGHT = 40;
    // 坦克速度
    public static final int TANK_SPEED = 10;

    // 子弹半径
    public static final int BULLET_RADIUS = 3;
    // 子弹速度
    public static final int BULLET_SPEED = 50;
    // 子弹每次运行的时间间隔
    public static final int BULLET_RUN_INTERVAL_TIME = 200;
    // 我方坦克发射子弹最少时间间隔(毫秒),低于这个时间的发射无效
    public static final int MY_TANK_SHOT_MIN_INTERVAL_TIME = 10;
    // 敌方坦克发射子弹最少时间间隔(毫秒)
    public static final int ENEMY_TANK_SHOT_MIN_INTERVAL_TIME = 200;

    // 方向
    public static final int UP = 0;
    public static final int RIGHT = 1;
    public static final int DOWN = 2;
    public static final int LEFT = 3;
}

二、 tank中的Bomb类

package tank;


// 坦克坐标

public class Bomb {
    // 坐标
    private int x,y;
    // 生命值
    private int life;
    // 是否存活
    private boolean live;

    
    private void init(){
        life = 9;
        live = true;
    }

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

    
    public void lifeDown(){
        if(life > 0){
            life --;
            return;
        }
        live = false;
    }

    public int getX() {
        return x;
    }

    public int getY() {
        return y;
    }

    public int getLife() {
        return life;
    }

    public boolean isLive() {
        return live;
    }

    public void setLive(boolean live) {
        this.live = live;
    }
}

二、 tank中的Bullet类

package tank;

import constant.Constant;

import java.util.Objects;
import java.util.concurrent.TimeUnit;

// 子弹

public class Bullet{
    // 子弹 X 坐标
    private int x;
    // 子弹 Y 坐标
    private int y;
    // 子弹方向
    private int direction;
    // 子弹存活状态
    private boolean live = true;

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

    
    public void shot() {
        // 子弹循环移动
        while (live) {
            // 休眠
            try {
                TimeUnit.MILLISECONDS.sleep(Constant.BULLET_RUN_INTERVAL_TIME);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 根据方向移动
            switch (direction) {
                case Constant.UP:
                    y -= Constant.BULLET_SPEED;
                    break;
                case Constant.RIGHT:
                    x += Constant.BULLET_SPEED;
                    break;
                case Constant.DOWN:
                    y += Constant.BULLET_SPEED;
                    break;
                case Constant.LEFT:
                    x -= Constant.BULLET_SPEED;
                    break;
                default:
            }

            // 判断子弹是否到边界
            if (x <= 0 || x >= Constant.WINDOW_WIDTH || y <= Constant.INFO_BAR_HEIGHT || y >= Constant.WINDOW_HEIGHT) {
                live = false;
            }
        }
    }

    public int getX() {
        return x;
    }

    public int getY() {
        return y;
    }


    public boolean isLive() {
        return live;
    }

    public void setLive(boolean live) {
        this.live = live;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Bullet bullet = (Bullet) o;
        return x == bullet.x && y == bullet.y && direction == bullet.direction && live == bullet.live;
    }

    @Override
    public int hashCode() {
        return Objects.hash(x, y, direction, live);
    }
}

二、 tank中的EnemyTank类

package tank;

import constant.Constant;

import java.util.List;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.TimeUnit;

// 敌方坦克

public class EnemyTank extends Tank {
    // 我方坦克集合:可以让敌方坦克自动追击
    private List myTanks = null;

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

    
    @Override
    public void shot() {
        // 如果存活就一直发射
        while (isLive()) {
            try {
                TimeUnit.MILLISECONDS.sleep(Constant.ENEMY_TANK_SHOT_MIN_INTERVAL_TIME);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 根据方向移动
            switch (getDirection()) {
                case Constant.UP:
                    moveUp();
                    break;
                case Constant.RIGHT:
                    moveRight();
                    break;
                case Constant.DOWN:
                    moveDown();
                    break;
                default:
                    moveLeft();
            }
            // 可以发射
            if (isAllowShot()) {
                // 开启线程,发射子弹
                getBulletThreadPool().execute(() -> {
                    // 根据方向创建子弹,并射击
                    int d = getDirection();
                    Bullet bullet = null;
                    switch (d) {
                        case Constant.UP:
                            // 创建子弹
                            bullet = new Bullet(getX() + Constant.TANK_WHEEL_WIDTH + Constant.TANK_BODY_WIDTH / 2 - Constant.BULLET_RADIUS, getY(), d);
                            break;
                        case Constant.RIGHT:
                            // 创建子弹
                            bullet = new Bullet(getX() + Constant.TANK_WHEEL_HEIGHT, getY() + Constant.TANK_WHEEL_WIDTH + Constant.TANK_BODY_WIDTH / 2 - Constant.BULLET_RADIUS, d);
                            break;
                        case Constant.DOWN:
                            // 创建子弹
                            bullet = new Bullet(getX() + Constant.TANK_WHEEL_WIDTH + Constant.TANK_BODY_WIDTH / 2 - Constant.BULLET_RADIUS, getY() + Constant.TANK_WHEEL_HEIGHT, d);
                            break;
                        case Constant.LEFT:
                            // 创建子弹
                            bullet = new Bullet(getX(), getY() + Constant.TANK_WHEEL_WIDTH + Constant.TANK_BODY_WIDTH / 2 - Constant.BULLET_RADIUS, d);
                            break;
                        default:
                    }
                    if (bullet != null) {
                        // 加入坦克的子弹集合,并射击
                        getBullets().add(bullet);
                        bullet.shot();
                    }
                });

                // 发射后把发射状态设为不可发射
                setAllowShot(false);

                // 开启新线程,设置发射状态。如果在当前线程休眠等待时,会出现阻塞,子弹有停顿现象
                getShotIntervalThreadPool().execute(() -> {
                    try {
                        // 随机休眠
                        ThreadLocalRandom random = ThreadLocalRandom.current();
                        int t = 300 * random.nextInt(10);
                        TimeUnit.MILLISECONDS.sleep(t);
                        // 设为可以发射
                        setAllowShot(true);
                    } catch (InterruptedException interruptedException) {
                        interruptedException.printStackTrace();
                    }
                });
                // 改变方向,追击目标坦克
                if (myTanks.size() > 0 && myTanks.get(0) != null && myTanks.get(0).isLive()) {
                    Tank myTank = myTanks.get(0);
                    // 开启新线程,改变方向
                    getShotIntervalThreadPool().execute(() -> {
                        try {
                            // 随机休眠
                            ThreadLocalRandom random = ThreadLocalRandom.current();
                            int t = 1000 + 1000 * random.nextInt(10);
                            TimeUnit.MILLISECONDS.sleep(t);
                            // 判断我方坦克位置,从而改变方向
                            // x 轴距离
                            int xDistance = myTank.getX() - getX() + Constant.TANK_WHEEL_HEIGHT;
                            // y 轴距离
                            int yDistance = myTank.getY() - getY() + Constant.TANK_WHEEL_HEIGHT;
                            // 改变方向
                            if (Math.abs(xDistance) < Math.abs(yDistance)) {
                                // 纵向改变方向
                                if (yDistance >= 0) {
                                    // 向下
                                    setDirection(Constant.DOWN);
                                } else {
                                    // 向上
                                    setDirection(Constant.UP);
                                }
                            } else {
                                // 横向改变方向
                                if (xDistance >= 0) {
                                    // 向右
                                    setDirection(Constant.RIGHT);
                                } else {
                                    // 向左
                                    setDirection(Constant.LEFT);
                                }
                            }
                        } catch (InterruptedException interruptedException) {
                            interruptedException.printStackTrace();
                        }
                    });
                }
            }
        }
    }

    public void setMyTanks(List myTanks) {
        this.myTanks = myTanks;
    }
}

 二、tank中的HeroTank类

package tank;

import constant.Constant;

import java.util.concurrent.*;

//我放坦克

public class HeroTank extends Tank {
    
    public HeroTank(int x, int y) {
        super(x, y, Constant.UP);
    }

    
    @Override
    public void shot() {
        // 可以发射
        if (isAllowShot()) {
            // 开启线程,发射子弹
            getBulletThreadPool().execute(() -> {
                // 根据方向创建子弹,并射击
                int d = getDirection();
                Bullet bullet = null;
                switch (d) {
                    case Constant.UP:
                        // 创建子弹
                        bullet = new Bullet(getX() + Constant.TANK_WHEEL_WIDTH + Constant.TANK_BODY_WIDTH / 2 - Constant.BULLET_RADIUS, getY(), d);
                        break;
                    case Constant.RIGHT:
                        // 创建子弹
                        bullet = new Bullet(getX() + Constant.TANK_WHEEL_HEIGHT, getY() + Constant.TANK_WHEEL_WIDTH + Constant.TANK_BODY_WIDTH / 2 - Constant.BULLET_RADIUS, d);
                        break;
                    case Constant.DOWN:
                        // 创建子弹
                        bullet = new Bullet(getX() + Constant.TANK_WHEEL_WIDTH + Constant.TANK_BODY_WIDTH / 2 - Constant.BULLET_RADIUS, getY() + Constant.TANK_WHEEL_HEIGHT, d);
                        break;
                    case Constant.LEFT:
                        // 创建子弹
                        bullet = new Bullet(getX(), getY() + Constant.TANK_WHEEL_WIDTH + Constant.TANK_BODY_WIDTH / 2 - Constant.BULLET_RADIUS, d);
                        break;
                    default:
                }
                // 加入坦克的子弹集合,并射击
                if (bullet != null) {
                    getBullets().add(bullet);
                    bullet.shot();
                }
            });

            // 发射后把发射状态设为不可发射
            setAllowShot(false);

            // 开启新线程,设置发射状态。如果在当前线程休眠等待时,会出现阻塞,子弹有停顿现象
            getShotIntervalThreadPool().execute(() -> {
                try {
                    // 休眠最小间隔时间
                    TimeUnit.MILLISECONDS.sleep(Constant.MY_TANK_SHOT_MIN_INTERVAL_TIME);
                    // 设为可以发射
                    setAllowShot(true);
                } catch (InterruptedException interruptedException) {
                    interruptedException.printStackTrace();
                }
            });
        }
    }

    
    public void waitShot() {
        // 如果坦克是存活状态,就一直循环,等待点击发射键
        while (isLive()) {
            try {
                TimeUnit.MILLISECONDS.sleep(Constant.MY_TANK_SHOT_MIN_INTERVAL_TIME);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

 二、tank中的Tank类

package tank;

import constant.Constant;
import util.MyThreadFactory;

import java.util.List;
import java.util.concurrent.*;

//坦克

public abstract class Tank {
    // 坦克的横坐标
    private int x;
    // 坦克的纵坐标
    private int y;
    // 坦克方向
    private int direction;
    // 是否可以发射;结合发射间隔时间,控制发射频率
    private boolean allowShot;
    // 坦克是否存活
    private boolean live;
    // 子弹集合
    private List bullets;
    // 子弹线程池;当坦克被摧毁时,线程池销毁
    private ThreadPoolExecutor bulletThreadPool;
    // 计算子弹发射间隔时间线程池
    private ThreadPoolExecutor shotIntervalThreadPool;
    // 所有坦克:用于判断是否发生碰撞
    private List allTanks;

    
    private void init() {
        // 是否可以发射;结合发射间隔时间,控制发射频率
        allowShot = true;
        // 坦克是否存活
        live = true;
        // 子弹集合
        bullets = new CopyOnWriteArrayList<>();
        // 子弹线程池;当坦克被摧毁时,线程池销毁
        bulletThreadPool = new ThreadPoolExecutor(
                15, // 核心线程数
                40, // 最大线程数
                200, // 空闲时间
                TimeUnit.MILLISECONDS, // 时间单位
                new ArrayBlockingQueue<>(5), // 阻塞队列
                new MyThreadFactory("子弹"), // 线程工厂
                new ThreadPoolExecutor.DiscardOldestPolicy()); // 拒绝策略
        // 计算子弹发射间隔时间线程池
        shotIntervalThreadPool = new ThreadPoolExecutor(
                3, // 核心线程数
                5, // 最大线程数
                100, // 空闲时间
                TimeUnit.MILLISECONDS, // 时间单位
                new ArrayBlockingQueue<>(2), // 阻塞队列
                new MyThreadFactory("子弹发射频率"), // 线程工厂
                new ThreadPoolExecutor.DiscardOldestPolicy()); // 拒绝策略

        // 所有坦克
        allTanks = new CopyOnWriteArrayList<>();
    }

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

    
    private boolean isTouch() {
        // 坦克数量大于1时再判断。至少两个坦克才可能发生碰撞
        if (allTanks.size() > 1) {
            // 当前坦克的前方一点
            int x1, y1;
            Point p1;
            // 当前坦克的前方另一点
            int x2, y2;
            Point p2;

            // 根据当前坦克的方向分类判断
            switch (getDirection()) {
                
                case Constant.UP:
                    // 当前坦克上方左侧
                    x1 = this.getX();
                    y1 = this.getY();
                    p1 = new Point(x1, y1);
                    // 当前坦克上方右侧
                    x2 = x1 + 2 * Constant.TANK_WHEEL_WIDTH + Constant.TANK_BODY_WIDTH;
                    y2 = y1;
                    p2 = new Point(x2, y2);

                    // 判断当前坦克与其它坦克是否相撞
                    if (isTouchCurrentTankAndOtherTank(this, p1, p2)) {
                        return true;
                    }

                    break;

                
                case Constant.RIGHT:
                    // 当前坦克右侧上方
                    x1 = this.getX() + 2 * Constant.TANK_WHEEL_WIDTH + Constant.TANK_BODY_WIDTH;
                    y1 = this.getY();
                    p1 = new Point(x1, y1);
                    // 当前坦克右侧下方
                    x2 = x1;
                    y2 = y1 + 2 * Constant.TANK_WHEEL_WIDTH + Constant.TANK_BODY_WIDTH;
                    p2 = new Point(x2, y2);

                    // 判断当前坦克与其它坦克是否相撞
                    if (isTouchCurrentTankAndOtherTank(this, p1, p2)) {
                        return true;
                    }

                    break;

                
                case Constant.DOWN:
                    // 当前坦克下方左侧
                    x1 = this.getX();
                    y1 = this.getY() + Constant.TANK_WHEEL_HEIGHT;
                    p1 = new Point(x1, y1);
                    // 当前坦克下方右侧
                    x2 = x1 + 2 * Constant.TANK_WHEEL_WIDTH + Constant.TANK_BODY_WIDTH;
                    y2 = y1;
                    p2 = new Point(x2, y2);

                    // 判断当前坦克与其它坦克是否相撞
                    if (isTouchCurrentTankAndOtherTank(this, p1, p2)) {
                        return true;
                    }

                    break;

                
                default:
                    // 当前坦克左侧上方
                    x1 = this.getX();
                    y1 = this.getY();
                    p1 = new Point(x1, y1);
                    // 当前坦克左侧下方
                    x2 = x1;
                    y2 = y1 + 2 * Constant.TANK_WHEEL_WIDTH + Constant.TANK_BODY_WIDTH;
                    p2 = new Point(x2, y2);

                    // 判断当前坦克与其它坦克是否相撞
                    if (isTouchCurrentTankAndOtherTank(this, p1, p2)) {
                        return true;
                    }
            }
        }
        return false;
    }

    
    private boolean isPointInBounds(Point p, Bounds b) {
        

        
        if (p.x < b.p1.x || p.y < b.p1.y) {
            return false;
        }

        
        if (p.x > b.p2x) {
            return false;
        }

        
        if (p.y > b.p3y) {
            return false;
        }

        return true;
    }
    
    private boolean isTouchCurrentTankAndOtherTank(Tank currentTank, Point p1, Point p2) {
        // 目标坦克区域面
        Bounds b;
        // 遍历坦克集合。比较与其它坦克是否发生碰撞
        for (Tank tank : allTanks) {
            // 避免与自已比较
            if (!currentTank.equals(tank)) {
                // 得到 tank 的区域面
                b = getBoundsByTank(tank);
                // 判断当前坦克的 上左点p1 或 上右点p2 是否与 目标坦克区域面b 重叠
                if (isPointInBounds(p1, b) || isPointInBounds(p2, b)) {
                    return true;
                }
            }
        }
        return false;
    }
    
    private Bounds getBoundsByTank(Tank tank) {
        // 目标坦克的上左
        int op1_x = tank.getX();
        int op1_y = tank.getY();
        Point op1 = new Point(op1_x, op1_y);

        // 目标坦克的上右x
        int op2_x;
        // 目标坦克的下右y
        int op3_y;

        // 目标坦克方向
        int d = tank.getDirection();
        if (d == Constant.UP || d == Constant.DOWN) { // 上下移动:计算方法一致
            // 目标坦克的上右x
            op2_x = op1_x + 2 * Constant.TANK_WHEEL_WIDTH + Constant.TANK_BODY_WIDTH;
            // 目标坦克的下右y
            op3_y = op1_y + Constant.TANK_WHEEL_HEIGHT;
        } else { // 左右移动:计算方法一致
            // 目标坦克的上右x
            op2_x = op1_x + Constant.TANK_WHEEL_HEIGHT;
            // 目标坦克的下右y
            op3_y = op1_y + 2 * Constant.TANK_WHEEL_WIDTH + Constant.TANK_BODY_WIDTH;
        }
        // 目标坦克的区域面
        return new Bounds(op1, op2_x, op3_y);
    }
    
    class Point {
        int x;
        int y;

        public Point(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }
    
    class Bounds {
        // 左上
        Point p1;
        // 右上x
        int p2x;
        // 右下y
        int p3y;

        public Bounds(Point p1, int p2x, int p3y) {
            this.p1 = p1;
            this.p2x = p2x;
            this.p3y = p3y;
        }
    }
    
    public void moveUp() {
        if (isTouch()) {
            direction = y % 2 == 0 ? Constant.DOWN : Constant.RIGHT;
        } else {
            y -= Constant.TANK_SPEED;
            if (y < Constant.INFO_BAR_HEIGHT) {
                y = Constant.INFO_BAR_HEIGHT;
                direction = Constant.RIGHT;
            }
        }
    }

    
    public void moveDown() {
        if (isTouch()) {
            direction = y % 2 == 0 ? Constant.UP : Constant.LEFT;
        } else {
            y += Constant.TANK_SPEED;
            if (y > Constant.WINDOW_HEIGHT - Constant.TANK_WHEEL_HEIGHT - Constant.WINDOW_TITLE_HEIGHT) {
                y = Constant.WINDOW_HEIGHT - Constant.TANK_WHEEL_HEIGHT - Constant.WINDOW_TITLE_HEIGHT;
                direction = Constant.LEFT;
            }
        }
    }

    
    public void moveLeft() {
        if (isTouch()) {
            direction = y % 2 == 0 ? Constant.RIGHT : Constant.DOWN;
        } else {
            x -= Constant.TANK_SPEED;
            if (x < 1) {
                x = 0;
                direction = Constant.UP;
            }
        }
    }

    
    public void moveRight() {
        if (isTouch()) {
            direction = y % 2 == 0 ? Constant.LEFT : Constant.UP;
        } else {
            x += Constant.TANK_SPEED;
            if (x > Constant.WINDOW_WIDTH - Constant.TANK_WHEEL_HEIGHT) {
                x = Constant.WINDOW_WIDTH - Constant.TANK_WHEEL_HEIGHT;
                direction = Constant.DOWN;
            }
        }
    }

    
    public abstract void shot();

    
    public void death() {
        if (bulletThreadPool != null) {
            bulletThreadPool.shutdown();
            // 把该坦克的子弹存活状态设为 false
            for (Bullet bullet : bullets) {
                bullet.setLive(false);
            }
        }
        if (shotIntervalThreadPool != null) {
            shotIntervalThreadPool.shutdown();
        }
    }

    public int getX() {
        return x;
    }

    public int getY() {
        return y;
    }

    public int getDirection() {
        return direction;
    }

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

    public boolean isAllowShot() {
        return allowShot;
    }

    public void setAllowShot(boolean allowShot) {
        this.allowShot = allowShot;
    }

    public boolean isLive() {
        return live;
    }

    public void setLive(boolean live) {
        this.live = live;
    }

    public List getBullets() {
        return bullets;
    }

    public ThreadPoolExecutor getBulletThreadPool() {
        return bulletThreadPool;
    }

    public ThreadPoolExecutor getShotIntervalThreadPool() {
        return shotIntervalThreadPool;
    }

    public List getAllTanks() {
        return allTanks;
    }

    public void setAllTanks(List allTanks) {
        this.allTanks = allTanks;
    }
}

三、util中的MyThreadFactory类 

package util;

import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;

//自定义线性工程

public class MyThreadFactory implements ThreadFactory {
    private static final AtomicInteger poolNumber = new AtomicInteger(1);
    private final ThreadGroup group;
    private final AtomicInteger threadNumber = new AtomicInteger(1);
    private final String namePrefix;

    public MyThreadFactory(String poolName) {
        SecurityManager s = System.getSecurityManager();
        group = (s != null) ? s.getThreadGroup() :
                Thread.currentThread().getThreadGroup();
        namePrefix = poolName + "-" +
                poolNumber.getAndIncrement() +
                "-线程-";
    }

    public Thread newThread(Runnable r) {
        Thread t = new Thread(group, r,
                namePrefix + threadNumber.getAndIncrement(),
                0);
        if (t.isDaemon())
            t.setDaemon(false);
        if (t.getPriority() != Thread.NORM_PRIORITY)
            t.setPriority(Thread.NORM_PRIORITY);
        return t;
    }
}

三、util中的MyUtils类 

package util;

import java.util.HashSet;
import java.util.Random;
import java.util.Set;

//工具类

public class MyUitls {
    
    public static Set getRandoms(int start, int end, int count) {
        // 参数有效性检查
        if (start > end || count < 1) {
            count = 0;
        }
        // 结束值 与 开始值 的差小于 总数量
        if ((end - start) < count) {
            count = (end - start) > 0 ? (end - start) : 0;
        }

        // 定义存放集合
        Set set = new HashSet<>(count);
        if (count > 0) {
            Random r = new Random();
            // 一直生成足够数量后再停止
            while (set.size() < count) {
                set.add(start + r.nextInt(end - start));
            }
        }
        return set;
    }
}

 三、util中的PlayAudio类

package util;

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

// 播放音乐

public class PlayAudio implements Runnable {

    private String filename;

    public PlayAudio(String wavfile) {
        filename = wavfile;
    }

    @Override
    public void run() {

        InputStream is = this.getClass().getResourceAsStream("/res/audio/" + filename);
        AudioInputStream audioInputStream = null;
        try {
            audioInputStream = AudioSystem.getAudioInputStream(new BufferedInputStream(is));
        } 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();
        }
    }
}

 三、util中的Recorder类

package util;

import java.io.*;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

//坦克数量

public class Recorder {
    // 摧毁敌方坦克数量
    public volatile static AtomicInteger destroyEnemyTankNum = new AtomicInteger(0);
    // 我方战毁数量
    public volatile static AtomicInteger destroyMyNum = new AtomicInteger(0);
    // 我方发射子弹数量
    public volatile static AtomicInteger myBulletNum = new AtomicInteger(0);

    // 定义IO对象,存取游戏数据
    private static BufferedWriter bw = null;
    private static BufferedReader br = null;
    private static String recordFile = "gameinfo.txt";

    // 摧毁敌方坦克数量加1
    public static void destroyEnemyTankNumAdd() {
        destroyEnemyTankNum.getAndIncrement();
    }

    // 我方战毁数量
    public static void destroyMyNumAdd() {
        destroyMyNum.getAndIncrement();
    }

    // 我方发射子弹数量加1
    public static void myBulletNumAdd() {
        myBulletNum.getAndIncrement();
    }

    // 保存游戏数据
    public static void saveInfo() {
        try {
            bw = new BufferedWriter(new FileWriter(recordFile));
            StringBuffer sb = new StringBuffer();
            sb.append(destroyEnemyTankNum + "rn")
                    .append(destroyMyNum + "rn")
                    .append(myBulletNum + "rn");
            bw.write(sb.toString());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (bw != null) {
                try {
                    bw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    // 读取游戏数据
    public static void readInfo() {
        try {
            br = new BufferedReader(new FileReader(recordFile));
            String s;
            List ls = new ArrayList<>();
            //循环读取
            while ((s = br.readLine()) != null) {
                ls.add(Integer.parseInt(s));
            }
            // 把读取到的数据赋值给记录属性
            if (ls.size() == 3) {
                destroyEnemyTankNum.set(ls.get(0));
                destroyMyNum.set(ls.get(1));
                myBulletNum.set(ls.get(2));
            }
        } catch (IOException e){
            // e.printStackTrace(); 如果读取不到文件,不抛错误信息。写入时会创建
        } finally{
            if (br != null) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

 四、window中的MainWinodw(这里鄙人有些小瑕疵就是MainWindow写成了MainWinodw,问题不是很大,主意自己的写引用时注意点即可)

package window;

import constant.Constant;
import util.MyThreadFactory;
import util.Recorder;

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



public class MainWinodw extends JFrame {
    // 活动面板
    private MyPanel myPanel;
    // 线程池
    private ThreadPoolExecutor threadPool;

    
    private void init(){
        // 线程池
        threadPool = new ThreadPoolExecutor(
                1, // 核心线程数
                1, // 最大线程数
                0L, // 空闲时间
                TimeUnit.MILLISECONDS, // 时间单位
                new LinkedBlockingQueue(),// 阻塞队列
                new MyThreadFactory("游戏界面"), // 线程工厂
                new ThreadPoolExecutor.DiscardOldestPolicy()); // 拒绝策略

        myPanel = new MyPanel();
        try{
            threadPool.execute(myPanel);
        }finally {
            threadPool.shutdown();
        }

        //new Thread(myPanel,"游戏界面").start();

        // 添加面板
        this.add(myPanel);
        // 窗口位置及大小
        this.setBounds(50,80, Constant.WINDOW_WIDTH,Constant.WINDOW_HEIGHT);
        // 关闭
        this.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                // 保存游戏数据
                Recorder.saveInfo();
                System.exit(0);
            }
        });

        // 添加键盘监听
        this.addKeyListener(myPanel);
        // 不可改变窗口大小
        this.setResizable(false);
        // 设置窗口可见
        this.setVisible(true);
    }

    
    public MainWinodw(){
        // 游戏名称
        super("坦克大战");
        // 读取游戏数据
        Recorder.readInfo();
        // 初始化
        init();
    }
}

 四、window中的MyPanel类

package window;

import tank.*;
import constant.Constant;
import util.MyThreadFactory;
import util.MyUitls;
import util.PlayAudio;
import util.Recorder;

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


//
public class MyPanel extends JPanel implements KeyListener, Runnable {
    // 游戏状态
    private int status;
    // 我方坦克集合
    private volatile List myTanks;
    // 敌方坦克集合
    private volatile List enemyTanks;
    // 所有坦克:用于判断是否碰撞
    private volatile List allTanks;
    // 我方坦克数量
    private int myTankNum;
    // 敌方坦克数量
    private int enemyTankNum;
    // 我方坦克生成线程池
    private ThreadPoolExecutor myTankThreadPool;
    // 敌方坦克生成线程池
    private ThreadPoolExecutor enemyTankThreadPool;
    // 爆炸效果图片
    private List bombs;
    private Image image1;
    private Image image2;
    private Image image3;

    
    private void init(int status) {
        this.status = status;
        // 只有运行状态时再初始化其它
        if (this.status == Constant.GAME_RUNNING) {
            // 我方
            myTanks = new CopyOnWriteArrayList<>();
            myTankNum = Constant.MY_TANK_INIT_NUM;
            // 敌方
            enemyTanks = new CopyOnWriteArrayList<>();
            enemyTankNum = Constant.ENEMY_TANK_INIT_NUM;

            // 所有坦克
            allTanks = new CopyOnWriteArrayList<>();

            myTankThreadPool = new ThreadPoolExecutor(
                    1, // 核心线程数
                    1, // 最大线程数
                    200, // 空闲时间
                    TimeUnit.MILLISECONDS, // 时间单位
                    new ArrayBlockingQueue<>(5), // 阻塞队列
                    new MyThreadFactory("我方坦克"), // 线程工厂
                    new ThreadPoolExecutor.DiscardOldestPolicy()); // 拒绝策略

            enemyTankThreadPool = new ThreadPoolExecutor(
                    5, // 核心线程数
                    20, // 最大线程数
                    200, // 空闲时间
                    TimeUnit.MILLISECONDS, // 时间单位
                    new ArrayBlockingQueue<>(30), // 阻塞队列
                    new MyThreadFactory("敌方坦克"), // 线程工厂
                    new ThreadPoolExecutor.DiscardOldestPolicy()); // 拒绝策略

            // 坦克竖向宽度
            int tankWidth = 2 * Constant.TANK_WHEEL_WIDTH + Constant.TANK_BODY_WIDTH;
            // 竖向一排可以放置的数量
            int num = (int) Math.floor(Constant.WINDOW_WIDTH / tankWidth);

            
            // 生成不重复随机数:用于坦克横向分布
            Object[] xs1 = MyUitls.getRandoms(0, num, myTankNum).toArray();
            int y1 = Constant.WINDOW_HEIGHT - Constant.TANK_WHEEL_HEIGHT - 2 * Constant.WINDOW_TITLE_HEIGHT;
            for (int i = 0; i < myTankNum; i++) {
                final int a = i;
                myTankThreadPool.execute(() -> {
                    HeroTank myTank = new HeroTank(tankWidth * (int) xs1[a], y1);
                    myTanks.add(myTank);

                    // 每二次创建(超过最大核心线程数)
                    if (a >= myTankThreadPool.getCorePoolSize()) {
                        // 给当前所有坦克设置 allTanks 属性
                        setAllTanks();
                    }

                    myTank.waitShot();

                });
            }

            
            // 生成不重复随机数:用于坦克横向分布
            Object[] xs2 = MyUitls.getRandoms(0, num, enemyTankNum).toArray();
            Object[] ys2 = MyUitls.getRandoms(Constant.WINDOW_TITLE_HEIGHT + Constant.INFO_BAR_HEIGHT, Constant.WINDOW_TITLE_HEIGHT + Constant.INFO_BAR_HEIGHT + 100, enemyTankNum).toArray();

            Random random = new Random();
            for (int j = 0; j < enemyTankNum; j++) {
                // 如果生成的随机数小于坦克数量,那么多出的坦克坐标值就在现在的随机数中获取
                int c = j;
                if (j >= num) {
                    c = random.nextInt(num);
                }
                final int b = c;

                enemyTankThreadPool.execute(() -> {
                    EnemyTank enemyTank = new EnemyTank(tankWidth * (int) xs2[b], (int) ys2[b]);
                    enemyTanks.add(enemyTank);
                    enemyTank.setMyTanks(myTanks);
                    enemyTank.shot();
                });
            }

            int myCorePoolSize = myTankThreadPool.getCorePoolSize();
            int enemyCorePoolSize = enemyTankThreadPool.getCorePoolSize();
            // 当所有初始坦克全部创建完后执行
            while (myTanks.size() < myCorePoolSize || enemyTanks.size() < enemyCorePoolSize) {
                try {
                    TimeUnit.MILLISECONDS.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            setAllTanks();

            
            bombs = new CopyOnWriteArrayList<>();
            image1 = new ImageIcon(getClass().getResource("/res/image/bomb_1.gif")).getImage();
            image2 = new ImageIcon(getClass().getResource("/res/image/bomb_2.gif")).getImage();
            image3 = new ImageIcon(getClass().getResource("/res/image/bomb_3.gif")).getImage();

            
            new Thread(new PlayAudio("bg.wav"),"播放音乐").start();
        }
    }

    
    public MyPanel() {
        init(Constant.GAME_INIT);
    }

    
    @Override
    public void paint(Graphics g) {
        // 清屏
        super.paint(g);
        // 活动区域,填充矩形,默认黑色
        g.fillRect(0, 0, Constant.WINDOW_WIDTH, Constant.WINDOW_HEIGHT);

        // 绘制战绩信息栏
        drawInfo(g);

        switch (status) {
            // 初始化
            case Constant.GAME_INIT:
                g.setColor(Color.green);
                g.setFont(new Font("微软雅黑", Font.BOLD, 40));
                g.drawString("坦克大战", Constant.WINDOW_WIDTH / 2 - 70, Constant.WINDOW_HEIGHT / 2 - 50);
                g.setColor(Color.orange);
                g.setFont(new Font("微软雅黑", Font.PLAIN, 30));
                g.drawString("按回车键Enter 开始游戏", Constant.WINDOW_WIDTH / 2 - 150, Constant.WINDOW_HEIGHT / 2 + 10);
                g.setColor(Color.GRAY);
                g.setFont(new Font("微软雅黑", Font.PLAIN, 20));
                g.drawString("W:向上移动 / A:向左移动 / S:向下移动 / D:向右移动 / ↑:发射", 30, Constant.WINDOW_HEIGHT - 60);
                break;
            // 进行中
            case Constant.GAME_RUNNING:
                // 绘制我方坦克
                Iterator iterator1 = myTanks.iterator();
                HeroTank myTank;
                List myBullets;
                while (iterator1.hasNext()) {
                    myTank = iterator1.next();
                    if (myTank.isLive()) {
                        drawTank(
                                myTank.getX(),
                                myTank.getY(),
                                g,
                                myTank.getDirection(),
                                0);
                        // 绘制子弹
                        myBullets = myTank.getBullets();
                        for (Bullet bullet1 : myBullets) {
                            // 如果子弹存在,并且是存活的,就绘制
                            if (bullet1 != null && bullet1.isLive()) {
                                g.setColor(Color.MAGENTA);
                                g.fillOval(bullet1.getX(), bullet1.getY(), 2 * Constant.BULLET_RADIUS, 2 * Constant.BULLET_RADIUS);
                            }
                            // 如果子弹存在,并且不再存活,就清除
                            if (bullet1 != null && !bullet1.isLive()) {
                                myBullets.remove(bullet1);
                            }
                        }
                    }
                }

                // 绘制敌人坦克
                Iterator iterator2 = enemyTanks.iterator();
                EnemyTank enemyTank;
                List enemyBullets;
                while (iterator2.hasNext()) {
                    enemyTank = iterator2.next();
                    if (enemyTank.isLive()) {
                        drawTank(
                                enemyTank.getX(),
                                enemyTank.getY(),
                                g,
                                enemyTank.getDirection(),
                                1);
                        // 绘制子弹
                        enemyBullets = enemyTank.getBullets();
                        for (Bullet bullet2 : enemyBullets) {
                            // 如果子弹存在,并且是存活的,就绘制
                            if (bullet2 != null && bullet2.isLive()) {
                                g.setColor(Color.PINK);
                                g.fillOval(bullet2.getX(), bullet2.getY(), 2 * Constant.BULLET_RADIUS, 2 * Constant.BULLET_RADIUS);
                            }
                            // 如果子弹存在,并且不再存活,就清除
                            if (bullet2 != null && !bullet2.isLive()) {
                                enemyBullets.remove(bullet2);
                            }
                        }
                    }
                }

                // 绘制爆炸效果
                drawBomb(bombs, g);
                break;
            // 胜利
            case Constant.GAME_WIN:
                // 绘制最后的爆炸效果
                drawBomb(bombs, g);

                g.setColor(Color.green);
                g.setFont(new Font("微软雅黑", Font.BOLD, 40));
                g.drawString("恭喜!胜利了!", Constant.WINDOW_WIDTH / 2 - 120, Constant.WINDOW_HEIGHT / 2 - 50);
                g.setColor(Color.orange);
                g.setFont(new Font("微软雅黑", Font.PLAIN, 30));
                g.drawString("按回车键Enter 重新开始", Constant.WINDOW_WIDTH / 2 - 150, Constant.WINDOW_HEIGHT / 2 + 10);
                g.setColor(Color.GRAY);
                g.setFont(new Font("微软雅黑", Font.PLAIN, 20));
                g.drawString("W:向上移动 / A:向左移动 / S:向下移动 / D:向右移动 / ↑:发射", 30, Constant.WINDOW_HEIGHT - 60);
                break;
            // 失败
            default:
                // 绘制最后的爆炸效果
                drawBomb(bombs, g);

                g.setColor(Color.red);
                g.setFont(new Font("微软雅黑", Font.BOLD, 40));
                g.drawString("游戏结束!", Constant.WINDOW_WIDTH / 2 - 85, Constant.WINDOW_HEIGHT / 2 - 50);
                g.setColor(Color.orange);
                g.setFont(new Font("微软雅黑", Font.PLAIN, 30));
                g.drawString("按回车键Enter 重新开始", Constant.WINDOW_WIDTH / 2 - 150, Constant.WINDOW_HEIGHT / 2 + 10);
                g.setColor(Color.GRAY);
                g.setFont(new Font("微软雅黑", Font.PLAIN, 20));
                g.drawString("W:向上移动 / A:向左移动 / S:向下移动 / D:向右移动 / ↑:发射", 30, Constant.WINDOW_HEIGHT - 60);
        }
    }

    
    private void drawInfo(Graphics g) {
        // 摧毁敌方坦克数
        String destroyEnemyTankNum = String.valueOf(Recorder.destroyEnemyTankNum);
        // 我方战损数
        String destroyMyTankNum = String.valueOf(Recorder.destroyMyNum);
        // 我方发射子弹数
        String myBulletNum = String.valueOf(Recorder.myBulletNum);

        // 绘制顶部信息栏
        g.setColor(Color.BLACK);
        g.fillRect(0, 0, Constant.WINDOW_WIDTH, Constant.INFO_BAR_HEIGHT);
        // 敌方信息
        g.setColor(Color.GRAY);
        g.setFont(new Font("微软雅黑", Font.PLAIN, 25));
        g.drawString("摧毁", 100, 45);
        g.setFont(new Font("微软雅黑", Font.PLAIN, 25));
        g.drawString("敌方", 100, 75);
        drawTank(160, 20, g, Constant.UP, 1);
        g.setColor(Color.WHITE);
        g.setFont(new Font("微软雅黑", Font.PLAIN, 50));
        g.drawString(destroyEnemyTankNum, 220, 70);

        // 我方信息
        g.setColor(Color.GRAY);
        g.setFont(new Font("微软雅黑", Font.PLAIN, 25));
        g.drawString("我方", Constant.WINDOW_WIDTH / 2 - 100, 45);
        g.setFont(new Font("微软雅黑", Font.PLAIN, 25));
        g.drawString("战损", Constant.WINDOW_WIDTH / 2 - 100, 75);
        drawTank(Constant.WINDOW_WIDTH / 2 - 40, 20, g, Constant.UP, 0);
        g.setColor(Color.WHITE);
        g.setFont(new Font("微软雅黑", Font.PLAIN, 50));
        g.drawString(destroyMyTankNum, Constant.WINDOW_WIDTH / 2 + 20, 70);

        g.setColor(Color.GRAY);
        g.setFont(new Font("微软雅黑", Font.PLAIN, 25));
        g.drawString("发射子弹:", Constant.WINDOW_WIDTH / 2 + 230, 60);
        g.setColor(Color.WHITE);
        g.setFont(new Font("微软雅黑", Font.PLAIN, 30));
        g.drawString(myBulletNum, Constant.WINDOW_WIDTH / 2 + 350, 62);
    }

    
    private void drawTank(int x, int y, Graphics g, int direction, int type) {
        // 根据类型设置坦克颜色
        switch (type) {
            // 我的坦克
            case 0:
                g.setColor(Color.ORANGE);
                break;
            // 敌人坦克
            case 1:
                g.setColor(Color.CYAN);
                break;
            default:
        }

        // 根据方向绘制坦克
        switch (direction) {
            case Constant.UP:
                // 左边轮子
                g.fill3DRect(
                        x,
                        y,
                        Constant.TANK_WHEEL_WIDTH,
                        Constant.TANK_WHEEL_HEIGHT,
                        false);
                // 右边轮子
                g.fill3DRect(
                        x + Constant.TANK_WHEEL_WIDTH + Constant.TANK_BODY_WIDTH,
                        y,
                        Constant.TANK_WHEEL_WIDTH,
                        Constant.TANK_WHEEL_HEIGHT,
                        false);
                // 坦克体
                g.fill3DRect(
                        x + Constant.TANK_WHEEL_WIDTH,
                        y + (Constant.TANK_WHEEL_HEIGHT - Constant.TANK_BODY_HEIGHT) / 2,
                        Constant.TANK_BODY_WIDTH,
                        Constant.TANK_BODY_HEIGHT,
                        false);
                // 坦克转盘
                g.fillOval(
                        x + Constant.TANK_WHEEL_WIDTH,
                        y + (Constant.TANK_WHEEL_HEIGHT - Constant.TANK_BODY_WIDTH) / 2,
                        Constant.TANK_BODY_WIDTH,
                        Constant.TANK_BODY_WIDTH);
                // 炮塔
                g.drawLine(
                        x + Constant.TANK_WHEEL_WIDTH + Constant.TANK_BODY_WIDTH / 2,
                        y + Constant.TANK_WHEEL_HEIGHT / 2,
                        x + Constant.TANK_WHEEL_WIDTH + Constant.TANK_BODY_WIDTH / 2,
                        y);
                break;
            case Constant.DOWN:
                // 左边轮子
                g.fill3DRect(
                        x,
                        y,
                        Constant.TANK_WHEEL_WIDTH,
                        Constant.TANK_WHEEL_HEIGHT,
                        false);
                // 右边轮子
                g.fill3DRect(
                        x + Constant.TANK_WHEEL_WIDTH + Constant.TANK_BODY_WIDTH,
                        y,
                        Constant.TANK_WHEEL_WIDTH,
                        Constant.TANK_WHEEL_HEIGHT,
                        false);
                // 坦克体
                g.fill3DRect(
                        x + Constant.TANK_WHEEL_WIDTH,
                        y + (Constant.TANK_WHEEL_HEIGHT - Constant.TANK_BODY_HEIGHT) / 2,
                        Constant.TANK_BODY_WIDTH,
                        Constant.TANK_BODY_HEIGHT,
                        false);
                // 坦克转盘
                g.fillOval(
                        x + Constant.TANK_WHEEL_WIDTH,
                        y + (Constant.TANK_WHEEL_HEIGHT - Constant.TANK_BODY_WIDTH) / 2,
                        Constant.TANK_BODY_WIDTH,
                        Constant.TANK_BODY_WIDTH);
                // 炮塔
                g.drawLine(
                        x + Constant.TANK_WHEEL_WIDTH + Constant.TANK_BODY_WIDTH / 2,
                        y + Constant.TANK_WHEEL_HEIGHT / 2,
                        x + Constant.TANK_WHEEL_WIDTH + Constant.TANK_BODY_WIDTH / 2,
                        y + Constant.TANK_WHEEL_HEIGHT);
                break;
            case Constant.LEFT:
                // 上边轮子
                g.fill3DRect(
                        x,
                        y,
                        Constant.TANK_WHEEL_HEIGHT,
                        Constant.TANK_WHEEL_WIDTH,
                        false);
                // 下边轮子
                g.fill3DRect(
                        x,
                        y + Constant.TANK_WHEEL_WIDTH + Constant.TANK_BODY_WIDTH,
                        Constant.TANK_WHEEL_HEIGHT,
                        Constant.TANK_WHEEL_WIDTH,
                        false);
                // 坦克体
                g.fill3DRect(
                        x + (Constant.TANK_WHEEL_HEIGHT - Constant.TANK_BODY_HEIGHT) / 2,
                        y + Constant.TANK_WHEEL_WIDTH,
                        Constant.TANK_BODY_HEIGHT,
                        Constant.TANK_BODY_WIDTH,
                        false);
                // 坦克转盘
                g.fillOval(
                        x + (Constant.TANK_WHEEL_HEIGHT - Constant.TANK_BODY_WIDTH) / 2,
                        y + Constant.TANK_WHEEL_WIDTH,
                        Constant.TANK_BODY_WIDTH,
                        Constant.TANK_BODY_WIDTH);
                // 炮塔
                g.drawLine(
                        x + Constant.TANK_WHEEL_HEIGHT / 2,
                        y + Constant.TANK_WHEEL_WIDTH + Constant.TANK_BODY_WIDTH / 2,
                        x,
                        y + Constant.TANK_WHEEL_WIDTH + Constant.TANK_BODY_WIDTH / 2);
                break;
            case Constant.RIGHT:
                // 上边轮子
                g.fill3DRect(
                        x,
                        y,
                        Constant.TANK_WHEEL_HEIGHT,
                        Constant.TANK_WHEEL_WIDTH,
                        false);
                // 下边轮子
                g.fill3DRect(
                        x,
                        y + Constant.TANK_WHEEL_WIDTH + Constant.TANK_BODY_WIDTH,
                        Constant.TANK_WHEEL_HEIGHT,
                        Constant.TANK_WHEEL_WIDTH,
                        false);
                // 坦克体
                g.fill3DRect(
                        x + (Constant.TANK_WHEEL_HEIGHT - Constant.TANK_BODY_HEIGHT) / 2,
                        y + Constant.TANK_WHEEL_WIDTH,
                        Constant.TANK_BODY_HEIGHT,
                        Constant.TANK_BODY_WIDTH,
                        false);
                // 坦克转盘
                g.fillOval(
                        x + (Constant.TANK_WHEEL_HEIGHT - Constant.TANK_BODY_WIDTH) / 2,
                        y + Constant.TANK_WHEEL_WIDTH,
                        Constant.TANK_BODY_WIDTH,
                        Constant.TANK_BODY_WIDTH);
                // 炮塔
                g.drawLine(
                        x + Constant.TANK_WHEEL_HEIGHT / 2,
                        y + Constant.TANK_WHEEL_WIDTH + Constant.TANK_BODY_WIDTH / 2,
                        x + Constant.TANK_WHEEL_HEIGHT,
                        y + Constant.TANK_WHEEL_WIDTH + Constant.TANK_BODY_WIDTH / 2);
                break;
            default:
        }
    }

    
    private void drawBomb(List bombs, Graphics g) {
        // 绘制爆炸效果
        for (Bomb bomb : bombs) {
            if (bomb.getLife() > 6) {
                g.drawImage(image1, bomb.getX(), bomb.getY(), Constant.TANK_WHEEL_HEIGHT, Constant.TANK_WHEEL_HEIGHT, this);
            } else if (bomb.getLife() > 3) {
                g.drawImage(image2, bomb.getX(), bomb.getY(), Constant.TANK_WHEEL_HEIGHT, Constant.TANK_WHEEL_HEIGHT, this);
            } else {
                g.drawImage(image3, bomb.getX(), bomb.getY(), Constant.TANK_WHEEL_HEIGHT, Constant.TANK_WHEEL_HEIGHT, this);
            }
            bomb.lifeDown();
            if (bomb.getLife() == 0) {
                bombs.remove(bomb);
            }
        }
    }

    
    private void setAllTanks() {
        allTanks.clear();

        allTanks.addAll(myTanks);
        allTanks.addAll(enemyTanks);

        // 遍历所有坦克设置 allTanks 属性
        for (Tank tank : allTanks) {
            tank.setAllTanks(allTanks);
        }
    }

    
    @Override
    public void keyTyped(KeyEvent e) {
    }

    
    @Override
    public void keyPressed(KeyEvent e) {
        int keyCode = e.getKeyCode();

        // 判断按键
        switch (keyCode) {
            // w:向上
            case KeyEvent.VK_W:
                if (myTanks != null && myTanks.size() > 0) {
                    myTanks.get(0).setDirection(Constant.UP);
                    myTanks.get(0).moveUp();
                }
                break;
            // s:向下
            case KeyEvent.VK_S:
                if (myTanks != null && myTanks.size() > 0) {
                    myTanks.get(0).setDirection(Constant.DOWN);
                    myTanks.get(0).moveDown();
                }
                break;
            // a:向左
            case KeyEvent.VK_A:
                if (myTanks != null && myTanks.size() > 0) {
                    myTanks.get(0).setDirection(Constant.LEFT);
                    myTanks.get(0).moveLeft();
                }
                break;
            // d:向右
            case KeyEvent.VK_D:
                if (myTanks != null && myTanks.size() > 0) {
                    myTanks.get(0).setDirection(Constant.RIGHT);
                    myTanks.get(0).moveRight();
                }
                break;
            // 向上箭头:发射子弹
            case KeyEvent.VK_UP:
                // 发射
                if (myTanks != null && myTanks.size() > 0) {
                    myTanks.get(0).shot();
                    Recorder.myBulletNumAdd();
                }
                break;
            // 回车键:重新开始
            case KeyEvent.VK_ENTER:
                // 重新开始
                init(Constant.GAME_RUNNING);
                break;
            default:
        }

        // 重绘
        repaint();
    }

    
    @Override
    public void keyReleased(KeyEvent e) {
    }

    
    @Override
    public void run() {
        while (true) {
            try {
                TimeUnit.MILLISECONDS.sleep(Constant.REPAINT_TIME);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 运行状态时再做判断
            if (status == Constant.GAME_RUNNING) {
                // 判断我方子弹是否击中敌方坦克
                List myBs;
                for (HeroTank myTank : myTanks) {
                    myBs = myTank.getBullets();
                    for (Bullet mb : myBs) {
                        if (mb.isLive()) {
                            for (EnemyTank enemyTank : enemyTanks) {
                                hitTank(mb, enemyTank);
                            }
                        }
                    }
                }
                // 判断敌人子弹是否击中我方坦克
                List enemyBs;
                for (EnemyTank enemyTank : enemyTanks) {
                    enemyBs = enemyTank.getBullets();
                    for (Bullet eb : enemyBs) {
                        if (eb.isLive()) {
                            for (HeroTank myTank : myTanks) {
                                hitTank(eb, myTank);
                            }
                        }
                    }
                }
            }
            // 判断游戏状态
            status = gameStatus();
            // 重绘
            repaint();
        }
    }

    
    private void hitTank(Bullet bullet, Tank tank) {
        // 根据坦克方向判断子弹是否进入坦克区域
        boolean xArea;
        boolean yArea;
        switch (tank.getDirection()) {
            case Constant.UP:
            case Constant.DOWN:
                // x 区域:
                xArea = bullet.getX() > tank.getX() && bullet.getX() < (tank.getX() + 2 * Constant.TANK_WHEEL_WIDTH + Constant.TANK_BODY_WIDTH);
                // y 区域:
                yArea = bullet.getY() > tank.getY() && bullet.getY() < (tank.getY() + Constant.TANK_WHEEL_HEIGHT);
                if (xArea && yArea) {
                    // 定义爆炸效果
                    Bomb bomb = new Bomb(tank.getX(), tank.getY());
                    // 加入爆炸集合
                    bombs.add(bomb);
                    // 爆炸后把子弹live设为 false
                    bullet.setLive(false);
                    // 爆炸后把坦克live设为 false
                    tank.setLive(false);
                    // 是否为敌人坦克
                    if (tank instanceof EnemyTank) {
                        // 爆炸后把坦克从敌方坦克集合中清除
                        enemyTanks.remove(tank);
                        Recorder.destroyEnemyTankNumAdd();
                    } else {
                        // 爆炸后把我方坦克从我方坦克集合中清除
                        myTanks.remove(tank);
                        Recorder.destroyMyNumAdd();
                    }
                    // 调用坦克的死亡方法:停止发射子弹线程池、子弹发射间隔时间线程池
                    tank.death();

                    // 给当前所有坦克设置 allTanks 属性
                    setAllTanks();
                }
                break;
            case Constant.LEFT:
            case Constant.RIGHT:
                // x 区域:
                xArea = bullet.getX() > tank.getX() && bullet.getX() < (tank.getX() + Constant.TANK_WHEEL_HEIGHT);
                // y 区域:
                yArea = bullet.getY() > tank.getY() && bullet.getY() < (tank.getY() + 2 * Constant.TANK_WHEEL_WIDTH + Constant.TANK_BODY_WIDTH);
                if (xArea && yArea) {
                    Bomb bomb = new Bomb(tank.getX(), tank.getY());
                    bombs.add(bomb);
                    bullet.setLive(false);
                    tank.setLive(false);
                    // 是否为敌人坦克
                    if (tank instanceof EnemyTank) {
                        // 爆炸后把坦克从敌方坦克集合中清除
                        enemyTanks.remove(tank);
                        Recorder.destroyEnemyTankNumAdd();
                    } else {
                        // 爆炸后把我方坦克从我方坦克集合中清除
                        myTanks.remove(tank);
                        Recorder.destroyMyNumAdd();
                    }
                    tank.death();

                    // 给当前所有坦克设置 allTanks 属性
                    setAllTanks();
                }
                break;
            default:
        }
    }

    
    private int gameStatus() {
        // 运行状态时再做判断
        if (status == Constant.GAME_RUNNING) {
            // 我方坦克全部催毁(数量为 0)
            if (myTanks.size() < 1 && myTankThreadPool.getCompletedTaskCount() == myTankNum) {
                // 把敌方坦克全部清除,结束线程
                for (EnemyTank enemyTank : enemyTanks) {
                    enemyTank.setLive(false);
                    enemyTank.death();
                }
                // 结束线程池
                if (myTankThreadPool != null) {
                    myTankThreadPool.shutdown();
                }
                if (enemyTankThreadPool != null) {
                    enemyTankThreadPool.shutdown();
                }
                //保存游戏数据
                Recorder.saveInfo();
                return Constant.GAME_FAIL;
            }
            // 敌方坦克全部催毁(数量为 0)
            if (enemyTanks.size() < 1 && enemyTankThreadPool.getCompletedTaskCount() == enemyTankNum) {
                // 把我方坦克清除,结束线程
                for (HeroTank myTank : myTanks) {
                    myTank.setLive(false);
                    myTank.death();
                }
                // 结束线程池
                if (myTankThreadPool != null) {
                    myTankThreadPool.shutdown();
                }
                if (enemyTankThreadPool != null) {
                    enemyTankThreadPool.shutdown();
                }
                //保存游戏数据
                Recorder.saveInfo();
                return Constant.GAME_WIN;
            }
        } else {
            // 非运行状态时保持状态不变
            if (myTanks != null) {
                for (Tank tank : myTanks) {
                    tank.setLive(false);
                    tank.death();
                }
            }
            if (enemyTanks != null) {
                for (Tank tank : enemyTanks) {
                    tank.setLive(false);
                    tank.death();
                }
            }
        }
        return status;
    }
}

五、StartGame(主类)

import window.MainWinodw;


public class StartGame {
    
    public static void main(String[] args) {
        new MainWinodw();
    }
}

六、resource中的三张爆炸图(这里注意图片一定要转化为gif类的,而且图片命名也要和我这一样才可)

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/980723.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号