游戏运行图片
源码分两大块:
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类的,而且图片命名也要和我这一样才可)



