Java游戏开发 —— 坦克大战
引言：
坦克大战也是小时一个比较经典的游戏了，我在网上也是参考了韩顺平老师写的坦克大战，并做了一下完善，编写出来作为儿时的回忆吧！
思路：
创建主窗口，加载菜单及游戏面板。
在游戏面板中初始化各种参数，并建立各种功能组件。
利用线程固定刷新游戏界面。
处理各种碰撞问题
游戏结束。
代码：
本游戏用的是JDK1.8，编码UTF-8；
我这里用的IDE是Intellij Idea，新建了一个game的空项目，tankwar作为其中的一个模块（当然这个不重要，个人喜好罢了）。类比较多，TankWar.java是游戏入口类。GameFrame.java是主窗口类。GamePanel.java是游戏面板类。GameLogic.java是游戏逻辑类。先一口气把所有的代码贴上来再说。
TankWar.java 游戏入口类
package lag.game.tankwar;
/**
* 功能：坦克大战
* 作者：我是小木鱼（Lag）
*/
public class TankWar
{
public static void main(String[] args)
{
new GameFrame();
}
}
GameFrame.java游戏窗口
package lag.game.tankwar;
import java.awt.*;
import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
/**
* 游戏窗口
*/
public class GameFrame extends JFrame implements ActionListener
{
/** 游戏面板 */
private GamePanel gamePanel;
/**
* 构造函数
*/
public GameFrame()
{
try
{
// 定制菜单
JMenuBar mb_main = new JMenuBar(); // 菜单栏
JMenu m_game = new JMenu("游戏"); // 游戏菜单
m_game.setFont(new Font("微软雅黑",Font.PLAIN,12)); // 游戏菜单字体
JMenuItem mi_new = new JMenuItem("新游戏"); // 游戏菜单中的新游戏子菜单
mi_new.setFont(new Font("微软雅黑",Font.PLAIN,12)); // 子菜单字体
mi_new.addActionListener(this); // 为窗口增加新游戏菜单的事件监听
mi_new.setActionCommand("new"); // 设置新游戏菜单的监听标识
m_game.add(mi_new); // 将新游戏子菜单附加到游戏菜单上
JMenuItem mi_grade = new JMenuItem("选关卡");
mi_grade.setFont(new Font("微软雅黑",Font.PLAIN,12));
mi_grade.addActionListener(this);
mi_grade.setActionCommand("grade");
m_game.add(mi_grade);
m_game.addSeparator(); // 菜单分隔符
JMenuItem mi_exit = new JMenuItem("退出");
mi_exit.setFont(new Font("微软雅黑",Font.PLAIN,12));
mi_exit.addActionListener(this);
mi_exit.setActionCommand("exit");
m_game.add(mi_exit);
mb_main.add(m_game);
JMenu m_help = new JMenu("帮助");
m_help.setFont(new Font("微软雅黑",Font.PLAIN,12));
JMenuItem mi_about = new JMenuItem("关于");
mi_about.setFont(new Font("微软雅黑",Font.PLAIN,12));
mi_about.addActionListener(this);
mi_about.setActionCommand("about");
m_help.add(mi_about);
mb_main.add(m_help);
this.setJMenuBar(mb_main);
// 定制面板
this.gamePanel = new GamePanel();
this.add(this.gamePanel);
// 定制窗口
this.setTitle("坦克大战"); // 标题
this.setLayout(null); // 清空布局管理器
this.setSize(this.gamePanel.getWidth() + 10,this.gamePanel.getHeight() + 60); // 根据游戏面板大小设置游戏窗口大小
this.setResizable(false); // 程序运行时禁止改变窗口大小尺寸
this.setLocationRelativeTo(null); // 窗口居中
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // 点击窗口X按钮时默认关闭程序
this.setVisible(true); // 显示窗口
//音乐（用线程播放）
// new Thread(()->{
// GameMusic gameMusic = new GameMusic(this.getClass().getClassLoader().getResourceAsStream("audio/start.wav"));
// gameMusic.play(false);
// }).start();
}
catch (Exception e)
{
e.printStackTrace();
JOptionPane.showMessageDialog(this,"程序出现异常错误，即将退出！\r\n\r\n"+e.toString(),"提示",JOptionPane.ERROR_MESSAGE);
System.exit(0);
}
}
/**
* 事件监听
*/
@Override
public void actionPerformed(ActionEvent e)
{
// 监听事件的标识
String command = e.getActionCommand();
switch (command)
{
case "new": // 开始新游戏
this.gamePanel.newGame();
break;
case "grade":
int gradeCount = GameMap.getGradeCount();
String[] options = new String[gradeCount];
for (int i = 0; i < gradeCount; i++)
{
options[i] = i + 1 + "";
}
String grade = (String)JOptionPane.showInputDialog(this, "请选择你要进行的关卡：","选关", JOptionPane.INFORMATION_MESSAGE, null, options, options[0]);
gamePanel.setGrade(Integer.parseInt(grade));
gamePanel.newGame();
break;
case "exit":
System.exit(0);
break;
case "about":
JOptionPane.showMessageDialog(this,"我是小木鱼（Lag）","提示",JOptionPane.INFORMATION_MESSAGE);
break;
}
}
}
GamePanel.java游戏面板
package lag.game.tankwar;
import java.awt.*;
import javax.swing.*;
import java.util.List;
import java.util.ArrayList;
import java.util.Vector;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.image.BufferedImage;
/**
* 游戏面板
*/
public class GamePanel extends JPanel implements KeyListener
{
/** 游戏状态常量 */
private final static int GAME_STATE_READY = 0; // 游戏未开始
private final static int GAME_STATE_RUNNING = 1; // 游戏运行中
private final static int GAME_STATE_OVER = 9; // 游戏已结束
/** 游戏运行场景范围常量 */
public final static int GAME_ACTION_WIDTH = Block.BLOCK_WIDTH * 26; // 游戏运行场景宽度
public final static int GAME_ACTION_HEIGHT = Block.BLOCK_HEIGHT * 26; // 游戏运行场景宽度
/** 游戏面板范围常量 */
public final static int GAME_PANEL_WIDTH = GAME_ACTION_WIDTH + 150; // 游戏面板宽度
public final static int GAME_PANEL_HEIGHT = GAME_ACTION_HEIGHT; // 游戏面板高度
/** 利用双缓冲机制防止画面闪烁（创建一张与面板画面一样大小的图片，所有的元素先绘制到该图片上，再将该图片一次性绘制到面板画面上） */
private BufferedImage bufferedImage = new BufferedImage(GAME_ACTION_WIDTH,GAME_ACTION_HEIGHT,BufferedImage.TYPE_4BYTE_ABGR);
/** 游戏刷新频率 */
private int repaintInterval = 50; // 游戏每秒刷新（1000/repaintInterval）次
/** 游戏状态 */
private int gameState = GAME_STATE_READY;
/** 我方的坦克 */
private Hero hero;
/** 我方坦克模型（显示在计分榜上） */
private Hero heroModel = new Hero(GAME_ACTION_WIDTH + 30,200,Tank.TANK_DIRECTION_RIGHT);
/** 敌方坦克池（考虑线程安全用Vector，没用ArrayList） */
private Vector enemyPool = new Vector<>();
/** 敌方坦克池最大数量 */
private int enemyPoolMaxNum = 0;
/** 敌方坦克死亡数量 */
private int enemyDeadNum = 0;
/** 敌方坦克模型（显示在计分榜上） */
private Enemy enemyModel = new Enemy(GAME_ACTION_WIDTH + 30,20,Tank.TANK_DIRECTION_RIGHT);
/** 创建敌方坦克线程是否运行标识 */
private boolean createEnemyTankThreadRunning = false;
/** 上次投放时间（用来设置投放坦克最小时间间隔） */
private long lastCreateEnemyTankTime = System.currentTimeMillis();
/** 块列表 */
private List blockList = new ArrayList<>();
/** 爆炸列表 */
private List bombList = new ArrayList<>();
/** 游戏关卡 */
private int grade = 1;
/** 游戏某关地图 */
private byte[][] gameGradeMap;
/** 大本营 */
private Camp camp = new Camp(12 * Block.BLOCK_WIDTH,24 * Block.BLOCK_HEIGHT);
/**
* 构造函数
*/
public GamePanel()
{
// 设置面板大小
this.setSize(GAME_PANEL_WIDTH,GAME_PANEL_HEIGHT);
// 监听键盘事件
this.setFocusable(true); // 先让面板得到焦点
this.addKeyListener(this); // 将监听键盘事件附加到面板上
// 创建游戏逻辑实例
GameLogic.setInstance(new GameLogic(this));
}
/**
* 开始新游戏
*/
public void newGame()
{
// 游戏清空重置
gameReset();
// 设置游戏状态为运行中
this.gameState = GAME_STATE_RUNNING;
// 加载游戏地图
loadGameMap();
// 设置大本营
camp.setState(Camp.CAMP_STATE_RUNNING);
// 创建我方坦克
int heroX = 8 * Block.BLOCK_WIDTH;
int heroY = (this.gameGradeMap.length - 2) * Block.BLOCK_HEIGHT;
hero = new Hero(heroX,heroY,Tank.TANK_DIRECTION_UP);
hero.work();
// 创建敌方坦克
createEnemyTank();
// 启动线程来定时刷新画面
refresh();
}
/**
* 加载游戏地图
*/
private void loadGameMap()
{
// 得到本关地图
this.gameGradeMap = GameMap.getGameMap(this.grade);
// 得到地图位置（几行几列）
int row = this.gameGradeMap.length;
int column = this.gameGradeMap[0].length;
// 开始循环
for (int i = 0; i < row; i++)
{
for (int j = 0; j < column; j++)
{
int mapValue = this.gameGradeMap[i][j];
switch (mapValue)
{
case Block.BLOCK_KIND_BRICK:
Brick brick = new Brick(Block.BLOCK_WIDTH * j,Block.BLOCK_HEIGHT * i);
this.blockList.add(brick);
break;
case Block.BLOCK_KIND_IRON:
Iron iron = new Iron(Block.BLOCK_WIDTH * j,Block.BLOCK_HEIGHT * i);
this.blockList.add(iron);
break;
}
}
}
this.enemyPoolMaxNum = GameMap.getEnemyTankNum(this.grade); // 本关敌方坦克数量
}
/**
* 游戏重置
*/
private void gameReset()
{
// 停止上局正在运行的线程
if(this.gameState == GAME_STATE_RUNNING){this.gameState = GAME_STATE_READY;}
while (true)
{
if(this.createEnemyTankThreadRunning)
{
try
{
Thread.sleep(10);
}
catch (InterruptedException e)
{
throw new RuntimeException(e);
}
}
else
{
break;
}
}
// 清空敌方坦克池中的所有坦克及其子弹
for (int i = 0; i < enemyPool.size(); i++)
{
Enemy enemy = enemyPool.get(i);
enemy.reset();
for (int j = 0; j < enemy.getBulletPool().size(); j++)
{
Bullet bullet = enemy.getBulletPool().get(j);
bullet.reset();
}
enemy.getBulletPool().clear();
}
enemyPool.clear();
enemyDeadNum = 0;
// 清空我方坦克及其子弹
if(hero != null)
{
hero.reset();
for (int i = 0; i < hero.getBulletPool().size(); i++)
{
Bullet bullet = hero.getBulletPool().get(i);
bullet.reset();
}
hero.getBulletPool().clear();
}
// 清空块池中的所有块
blockList.clear();
}
/**
* 创建敌方坦克
*/
private void createEnemyTank()
{
this.createEnemyTankThreadRunning = true; // 线程运行中
new Thread(()->{
//System.out.println("创建敌方坦克线程开始启动...");
// 记录已投放的坦克数量
int createEnemyTankNum = 0;
try
{
while (this.gameState == GAME_STATE_RUNNING)
{
// 休眠一会
try
{
Thread.sleep(repaintInterval); // 休眠时间短主要是考虑可以迅速退出本线程
}
catch (InterruptedException e)
{
e.printStackTrace();
}
// 控制连续投放间隔
long curCreateEnemyTankTime = System.currentTimeMillis();
if((curCreateEnemyTankTime - this.lastCreateEnemyTankTime) >= 3000) // 3秒投放
{
this.lastCreateEnemyTankTime = curCreateEnemyTankTime;
}
else
{
continue;
}
// 投放敌方坦克到达最大值后退出本线程
if(createEnemyTankNum >= enemyPoolMaxNum){break;}
// 在敌方坦克池中寻找空闲的坦克随机显示在左上角或右上角
Enemy enemy = null;
for (int i = 0; i < enemyPool.size(); i++)
{
Enemy tmpEnemy = enemyPool.get(i);
if(tmpEnemy.getState() == Tank.TANK_STATE_FREE)
{
enemy = tmpEnemy;
//System.out.println("找到空闲的敌方坦克了..................");
break;
}
}
// 没有就增加一个
if(enemy == null)
{
enemy = new Enemy(-100,-100,Tank.TANK_DIRECTION_DOWN);
enemyPool.add(enemy);
//System.out.println("新建敌方坦克了.................");
}
// 开始投放（随机投放到左上角与右上角，坦克不能重叠）
int enemyX; // 坦克X坐标
int enemyDirection = Tank.TANK_DIRECTION_DOWN; // 坦克方向默认向下
int randomPos = GameLogic.getRandomInt(0,1); // 随机生成位置（0-左上角，1-右上角）
if(randomPos == 0) // 左上角（方向下/右）
{
enemyX = 0;
if(GameLogic.getRandomInt(0,1) == 1){enemyDirection = Tank.TANK_DIRECTION_RIGHT;}
}
else // 右上角（方向下/左）
{
enemyX = GAME_ACTION_WIDTH - Tank.TANK_WIDTH;
if(GameLogic.getRandomInt(0,1) == 1){enemyDirection = Tank.TANK_DIRECTION_LEFT;}
}
enemy.setX(enemyX);
enemy.setY(0);
enemy.setDirection(enemyDirection);
// 判断该范围内是否可以投放运行
boolean workFlag = true;
for (int i = 0; i < enemyPool.size(); i++)
{
Enemy tmpEnemy = enemyPool.get(i);
if(tmpEnemy.getState() == Tank.TANK_STATE_RUNNING && enemy != tmpEnemy)
{
if(GameLogic.getInstance().tankCollideTank(enemy,tmpEnemy)) // 敌方坦克占位，不能投放
{
workFlag = false;
continue;
}
}
}
if(GameLogic.getInstance().tankCollideTank(enemy,hero)) // 我方坦克占位，不能投放
{
workFlag = false;
}
// 不能投放准备下一次
if(!workFlag){continue;}
// 可以投放了
enemy.work(); // 启动线程开始工作了
createEnemyTankNum++;
}
}
catch (Exception e)
{
e.printStackTrace();
}
finally
{
this.createEnemyTankThreadRunning = false; // 线程结束
}
//System.out.println("创建敌方坦克线程退出历史舞台了......");
}).start();
}
/**
* 游戏结束
*/
private void gameOver()
{
// 设置游戏状态
this.gameState = GAME_STATE_OVER;
// 游戏清空重置
gameReset();
}
/**
* 游戏胜利
*/
private void gameWin()
{
if(enemyPoolMaxNum - enemyDeadNum <= 0)
{
this.grade++;
newGame();
}
}
/**
* 碰撞处理
*/
private void collide()
{
// 判断我方子弹是否与敌方坦克或块或大本营碰撞
for (int i = 0; i < hero.getBulletPool().size(); i++)
{
Bullet bullet = hero.getBulletPool().get(i);
if(bullet.getState() == Bullet.BULLET_STATE_RUNNING) // 我方子弹飞行中
{
// 判断是否与敌方坦克碰撞
for (int j = 0; j < enemyPool.size(); j++)
{
Enemy enemy = enemyPool.get(j);
if(enemy.getState() == Tank.TANK_STATE_RUNNING) // 敌方坦克爬行中
{
// 开始判断
if(GameLogic.getInstance().bulletCollideTank(bullet,enemy)) // 这还真碰上了
{
// 记录坦克坐标，因为坦克销毁时会改变其坐标
int bombX = enemy.getX();
int bombY = enemy.getY();
// 子弹销毁
bullet.reset();
// 坦克受到伤害
enemy.hurt(bullet);
// 判断坦克是否死亡
if(enemy.isDead())
{
// 坦克销毁
enemy.reset();
enemyDeadNum++;
// 坦克爆炸
addBomb(bombX,bombY,Tank.TANK_WIDTH,Tank.TANK_HEIGHT);
// 判断是否胜利
gameWin();
}
}
}
}
// 判断是否与块碰撞
for (int m = blockList.size() - 1; m >= 0; m--)
{
Block block = blockList.get(m);
// 开始判断
if(GameLogic.getInstance().bulletCollideBlock(bullet,block)) // 这还真碰上了
{
// 记录块坐标
int bombX = block.getX();
int bombY = block.getY();
// 子弹销毁
bullet.reset();
if(block.getBlockKind() == Block.BLOCK_KIND_BRICK)
{
// 砖块销毁
blockList.remove(m);
// 砖块爆炸
addBomb(bombX,bombY,Block.BLOCK_WIDTH,Block.BLOCK_HEIGHT);
}
else
{
addBomb(bombX,bombY,Block.BLOCK_WIDTH,Block.BLOCK_HEIGHT);
}
}
}
// 判断是否与大本营碰撞
if(camp.getState() == Camp.CAMP_STATE_RUNNING)
{
if(GameLogic.getInstance().bulletCollideCamp(bullet,camp)) // 完蛋了啊
{
// 子弹销毁
bullet.reset();
// 大本营销毁
camp.setState(Camp.CAMP_STATE_FREE);
// 大本营爆炸
addBomb(camp.getX(),camp.getY(),camp.getWidth(),camp.getHeight());
// 游戏结束
gameOver();
}
}
}
}
// 判断敌方子弹是否与我方坦克或块或大本营碰撞（不需要判断敌方坦克状态，因为即使坦克销毁子弹可能仍然在飞）
for (int i = 0; i < enemyPool.size(); i++)
{
// 判断是否与我方坦克碰撞
Enemy enemy = enemyPool.get(i);
for (int j = 0; j < enemy.getBulletPool().size(); j++)
{
Bullet bullet = enemy.getBulletPool().get(j);
if(bullet.getState() == Bullet.BULLET_STATE_RUNNING)
{
// 判断子弹是否与坦克碰撞
if(GameLogic.getInstance().bulletCollideTank(bullet,hero)) // 完蛋了啊
{
// 记录坦克坐标，因为坦克销毁时会改变其坐标
int bombX = hero.getX();
int bombY = hero.getY();
// 子弹销毁
bullet.reset();
// 坦克受到伤害
hero.hurt(bullet);
// 判断坦克是否死亡
if(hero.isDead())
{
// 坦克销毁
hero.reset();
// 坦克爆炸
addBomb(bombX,bombY,Tank.TANK_WIDTH,Tank.TANK_HEIGHT);
// 游戏结束
gameOver();
}
}
// 判断子弹是否与块碰撞
for (int m = blockList.size() - 1; m >= 0; m--)
{
Block block = blockList.get(m);
// 开始判断
if(GameLogic.getInstance().bulletCollideBlock(bullet,block)) // 这还真碰上了
{
// 记录块坐标
int bombX = block.getX();
int bombY = block.getY();
// 子弹销毁
bullet.reset();
if(block.getBlockKind() == Block.BLOCK_KIND_BRICK)
{
// 砖块销毁
blockList.remove(m);
// 砖块爆炸
addBomb(bombX,bombY,Block.BLOCK_WIDTH,Block.BLOCK_HEIGHT);
}
else
{
addBomb(bombX,bombY,Block.BLOCK_WIDTH,Block.BLOCK_HEIGHT);
}
}
}
// 判断子弹是否与大本营碰撞
if(camp.getState() == Camp.CAMP_STATE_RUNNING)
{
if(GameLogic.getInstance().bulletCollideCamp(bullet,camp)) // 完蛋了啊
{
// 子弹销毁
bullet.reset();
// 大本营销毁
camp.setState(Camp.CAMP_STATE_FREE);
// 大本营爆炸
addBomb(camp.getX(),camp.getY(),camp.getWidth(),camp.getHeight());
// 游戏结束
gameOver();
}
}
}
}
}
}
/**
* 添加爆炸
*/
private void addBomb(int x,int y,int w,int h)
{
// 查找空闲的爆炸
Bomb bomb = null;
for (int i = 0; i < bombList.size(); i++)
{
Bomb tmpBomb = bombList.get(i);
if(tmpBomb.getState() == Bomb.BOMB_STATE_FREE)
{
bomb = tmpBomb;
//System.out.println("找到空闲的爆炸了..................");
break;
}
}
// 没有就增加一个
if(bomb == null)
{
bomb = new Bomb(-100,-100);
bombList.add(bomb);
//System.out.println("新建爆炸了.................");
}
bomb.setX(x);
bomb.setY(y);
bomb.setWidth(w);
bomb.setHeight(h);
bomb.work();
}
/**
* 字符被输入
*/
@Override
public void keyTyped(KeyEvent e){}
/**
* 某键被按下
*/
@Override
public void keyPressed(KeyEvent e)
{
// 游戏未开始或结束禁止按键
if(this.gameState != GAME_STATE_RUNNING){return;}
int keyCode = e.getKeyCode();
switch (keyCode)
{
case KeyEvent.VK_W:
case KeyEvent.VK_UP:
hero.move(Tank.TANK_DIRECTION_UP);
break;
case KeyEvent.VK_D:
case KeyEvent.VK_RIGHT:
hero.move(Tank.TANK_DIRECTION_RIGHT);
break;
case KeyEvent.VK_S:
case KeyEvent.VK_DOWN:
hero.move(Tank.TANK_DIRECTION_DOWN);
break;
case KeyEvent.VK_A:
case KeyEvent.VK_LEFT:
hero.move(Tank.TANK_DIRECTION_LEFT);
break;
case KeyEvent.VK_SPACE:
hero.shoot();
break;
}
}
/**
* 某键被释放
*/
@Override
public void keyReleased(KeyEvent e){}
/**
* 利用线程来定时刷新重绘游戏画面，适用于飞机类刷新频率较高的游戏。
* 动画原理就是在极短时间内连续显示多个图片，给人眼一种画面动起来的错觉（人眼的识别静态图时间为0.1秒）。
* 屏幕刷新频率（FPS->帧/每秒），单位赫兹（Hz）。
* 20Hz ->每秒刷新画面20次，即每隔（1000/20）毫秒刷新一次画面。
*/
private void refresh()
{
// 利用Lambda表达式替代内部类更方便
new Thread(() ->
{
//System.out.println("游戏自动刷新线程开始启动...");
while (this.gameState == GAME_STATE_RUNNING)
{
// 碰撞处理
collide();
// 开始刷新
repaint();
// 延时睡眠
try
{
Thread.sleep(repaintInterval);
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
//System.out.println("游戏自动刷新线程退出历史舞台了......");
}).start();
}
/**
* 绘制游戏画面（利用双缓冲机制防止画面闪烁）
*/
@Override
public void paint(Graphics g)
{
// 完成初始化工作，该语句千万不要动
super.paint(g);
// 准备开始游戏
if(this.gameState == GAME_STATE_READY)
{
// 清一下背景
g.setColor(Color.BLACK);
g.fillRect(0,0,this.getWidth(),this.getHeight());
// 显示Logo
g.setColor(Color.ORANGE);
g.setFont(new Font("微软雅黑",Font.BOLD,60));
g.drawString("坦 克 大 战", 160,170);
g.setColor(Color.CYAN);
g.setFont(new Font("微软雅黑",Font.BOLD,40));
g.drawString("2023", 280,280);
g.setColor(Color.WHITE);
g.setFont(new Font("宋体",Font.PLAIN,20));
g.drawString("我是小木鱼（Lag）制作", 240,420);
return;
}
// 游戏结束
if(this.gameState == GAME_STATE_OVER)
{
g.setColor(Color.BLACK);
g.fillRect(0,0,this.getWidth(),this.getHeight());
g.setColor(Color.RED);
g.setFont(new Font("宋体",Font.BOLD,60));
g.drawString("游戏结束", 200,170);
g.drawString("大虾请重新来过吧！", 70,280);
}
// 游戏进行中
if(this.gameState == GAME_STATE_RUNNING)
{
// 设置游戏面板区域
g.setColor(Color.LIGHT_GRAY);
g.fillRect(0,0,this.getWidth(),this.getWidth());
g.setColor(Color.WHITE);
g.fill3DRect(GAME_ACTION_WIDTH,0,2,GAME_ACTION_HEIGHT,true);
// 绘制分数
// 敌方坦克信息
enemyModel.draw(g);
g.setColor(Tank.TANK_COLOR_ENEMY);
g.setFont(new Font("微软雅黑",Font.BOLD,20));
g.drawString("总数：" + enemyPoolMaxNum,enemyModel.getX() ,enemyModel.getY() + 70);
g.drawString("死亡：" + enemyDeadNum,enemyModel.getX() ,enemyModel.getY() + 100);
g.drawString("剩余：" + (enemyPoolMaxNum - enemyDeadNum),enemyModel.getX() ,enemyModel.getY() + 130);
// 我方坦克信息
heroModel.draw(g);
g.setColor(Tank.TANK_COLOR_HERO);
g.setFont(new Font("微软雅黑",Font.BOLD,20));
g.drawString("总数：1" ,heroModel.getX() ,heroModel.getY() + 70);
g.drawString("生命：" + hero.getHp() ,heroModel.getX() ,heroModel.getY() + 100);
// 关口信息
g.setColor(Color.BLACK);
int gradeModelX = heroModel.getX();
int gradeModelY = heroModel.getY() + 150;
g.fillRect(gradeModelX,gradeModelY,3,40);
Polygon triangle = new Polygon();
triangle.addPoint(gradeModelX + 3, gradeModelY);
triangle.addPoint(gradeModelX + 3, gradeModelY + 20);
triangle.addPoint(gradeModelX + 40, gradeModelY + 20);
g.setColor(Color.RED);
g.fillPolygon(triangle);
g.setColor(Color.WHITE);
g.setFont(new Font("微软雅黑",Font.BOLD,20));
g.drawString("关数：" + this.grade ,gradeModelX ,gradeModelY + 70);
// 利用双缓冲机制来重绘画面，防止画面闪烁（先把所有的元素绘制到缓冲图片上，再将该图片一次性绘制到画面上）
Graphics ig = bufferedImage.getGraphics(); // 得到缓冲图片的画笔
// 设置游戏面板区域
ig.setColor(Color.BLACK);
ig.fillRect(0,0,GAME_ACTION_WIDTH,GAME_ACTION_HEIGHT);
// 绘制地图
for (Block block : this.blockList){block.draw(ig);}
// 绘制大本营
if(camp.getState() == Camp.CAMP_STATE_RUNNING){camp.draw(ig);}
// 绘制我方坦克
hero.draw(ig);
// 绘制我方子弹
for (Bullet bullet : hero.getBulletPool()){if(bullet.getState() == Bullet.BULLET_STATE_RUNNING){bullet.draw(ig);}}
// 绘制敌方坦克、子弹
for (int i = 0; i < enemyPool.size(); i++)
{
Enemy enemy = enemyPool.get(i);
// 绘制坦克
if(enemy.getState() == Tank.TANK_STATE_RUNNING){enemy.draw(ig);}
// 绘制子弹
for (Bullet bullet : enemy.getBulletPool()){if(bullet.getState() == Bullet.BULLET_STATE_RUNNING){bullet.draw(ig);}}
}
// 绘制爆炸
for (Bomb bomb : bombList){if(bomb.getState() == Bomb.BOMB_STATE_RUNNING){bomb.draw(ig);}}
// 将缓冲图片一次性显示到画面上
g.drawImage(bufferedImage,0,0,null);
}
}
public Hero getHero(){return hero;}
public Vector getEnemyPool(){return enemyPool;}
public List getBlockList(){return blockList;}
public Camp getCamp(){return camp;}
public void setGrade(int grade){this.grade = grade;}
}
GameLogic.java游戏逻辑
package lag.game.tankwar;
/**
* 游戏逻辑（牛逼类）
*/
public class GameLogic
{
/** 唯一实例 */
private static GameLogic instance;
/** 游戏面板 */
private GamePanel gamePanel;
/**
* 构造函数
* @param gamePanel 游戏面板
*/
public GameLogic(GamePanel gamePanel)
{
this.gamePanel = gamePanel;
}
/**
* 得到唯一实例
*/
public static GameLogic getInstance()
{
return instance;
}
/**
* 设置唯一实例
* @param gameLogic 游戏逻辑
*/
public static void setInstance(GameLogic gameLogic)
{
instance = gameLogic;
}
/**
* 判断矩形1是否碰撞到矩形2
* @param x1 矩形1左上角X坐标
* @param y1 矩形1左上角Y坐标
* @param w1 矩形1宽度
* @param h1 矩形1高度
* @param x2 矩形2左上角X坐标
* @param y2 矩形2左上角Y坐标
* @param w2 矩形2宽度
* @param h2 矩形2高度
*/
public boolean rectCollideRect(int x1,int y1,int w1,int h1,int x2,int y2,int w2,int h2)
{
// 判断原理（1、矩形1的四个顶点是否落在矩形2里；2、矩形2的四个顶点是否落在矩形1里。若高度或宽阔相等时特殊判断）
// 这个碰撞判断比较严，必须进入才算碰撞，挨着不算
// 判断矩形1的四个顶点是否落在矩形2里
if((x1 > x2 && x1 < x2 + w2 && y1 > y2 && y1 < y2 + h2)
|| (x1 + w1 > x2 && x1 + w1 < x2 + w2 && y1 > y2 && y1 < y2 + h2)
|| (x1 > x2 && x1 < x2 + w2 && y1 + h1 > y2 && y1 + h1 < y2 + h2)
|| (x1 + w1 > x2 && x1 + w1 < x2 + w2 && y1 + h1 > y2 && y1 + h1 < y2 + h2))
{return true;}
// 判断矩形2的四个顶点是否落在矩形1里
if((x2 > x1 && x2 < x1 + w1 && y2 > y1 && y2 < y1 + h1)
|| (x2 + w2 > x1 && x2 + w2 < x1 + w1 && y2 > y1 && y2 < y1 + h1)
|| (x2 > x1 && x2 < x1 + w1 && y2 + h2 > y1 && y2 + h2 < y1 + h1)
|| (x2 + w2 > x1 && x2 + w2 < x1 + w1 && y2 + h2 > y1 && y2 + h2 < y1 + h1))
{return true;}
// 特殊情况处理
// 若2个矩形的宽度相等时
if(w1 == w2){if(x1 == x2 && x1 + w1 == x2 + w2 && ((y1 > y2 && y1 < y2 + h2) || (y1 + h1 > y2 && y1 + h1 < y2 + h2))){return true;}}
// 若2个矩形的高度相等时
if(h1 == h2){if(y1 == y2 && y1 + h1 == y2 + h2 && ((x1 > x2 && x1 < x2 + w2) || (x1 + w1 > x2 && x1 + w1 < x2 + w2))){return true;}}
// 2个矩形完全重合
if(x1 == x2 && y1 == y2 && w1 == w2 && h1 == h2){return true;}
return false;
}
/**
* 判断坦克移动时的下一个位置是否碰撞到任何对象
*/
public boolean tankMoveCollide(Tank tank)
{
int newX = tank.getX();
int newY = tank.getY();
// 得到移动后的新坐标
switch (tank.getDirection())
{
case Tank.TANK_DIRECTION_UP:
newY = tank.getY() - tank.getSpeed();
break;
case Tank.TANK_DIRECTION_RIGHT:
newX = tank.getX() + tank.getSpeed();
break;
case Tank.TANK_DIRECTION_DOWN:
newY = tank.getY() + tank.getSpeed();
break;
case Tank.TANK_DIRECTION_LEFT:
newX = tank.getX() - tank.getSpeed();
break;
}
// 判断是否碰撞到边界
switch (tank.getDirection())
{
case Tank.TANK_DIRECTION_UP:
if(newY < 0){return true;}
break;
case Tank.TANK_DIRECTION_RIGHT:
if(newX + Tank.TANK_WIDTH > GamePanel.GAME_ACTION_WIDTH){return true;}
break;
case Tank.TANK_DIRECTION_DOWN:
if(newY + Tank.TANK_HEIGHT > GamePanel.GAME_ACTION_HEIGHT){return true;}
break;
case Tank.TANK_DIRECTION_LEFT:
if(newX < 0){return true;}
break;
}
// 判断是否碰撞到敌方坦克
for (int i = 0; i < gamePanel.getEnemyPool().size(); i++)
{
Enemy enemy = gamePanel.getEnemyPool().get(i);
if(enemy.getState() == Tank.TANK_STATE_RUNNING && tank != enemy)
{
if(rectCollideRect(newX,newY,Tank.TANK_WIDTH,Tank.TANK_HEIGHT,enemy.getX(),enemy.getY(),Tank.TANK_WIDTH,Tank.TANK_HEIGHT)){return true;}
}
}
// 判断是否碰撞到我方坦克
if(tank.getTankKind() == Tank.TANK_KIND_ENEMY)
{
if(rectCollideRect(newX,newY,Tank.TANK_WIDTH,Tank.TANK_HEIGHT,gamePanel.getHero().getX(),gamePanel.getHero().getY(),Tank.TANK_WIDTH,Tank.TANK_HEIGHT)){return true;}
}
// 判断是否碰撞到块
for (Block block : gamePanel.getBlockList())
{
if(rectCollideRect(newX,newY,Tank.TANK_WIDTH,Tank.TANK_HEIGHT,block.getX(),block.getY(),Block.BLOCK_WIDTH,Block.BLOCK_HEIGHT)){return true;}
}
// 判断是否碰撞大本营
if(gamePanel.getCamp().getState() == Camp.CAMP_STATE_RUNNING)
{
if(rectCollideRect(newX,newY,Tank.TANK_WIDTH,Tank.TANK_HEIGHT,gamePanel.getCamp().getX(),gamePanel.getCamp().getY(),gamePanel.getCamp().getWidth(),gamePanel.getCamp().getHeight())){return true;}
}
return false;
}
/**
* 判断坦克是否碰撞到坦克
* @param tank1 坦克1
* @param tank2 坦克2
*/
public boolean tankCollideTank(Tank tank1,Tank tank2)
{
return rectCollideRect(tank1.getX(),tank1.getY(),Tank.TANK_WIDTH,Tank.TANK_HEIGHT,tank2.getX(),tank2.getY(),Tank.TANK_WIDTH,Tank.TANK_HEIGHT);
}
/**
* 判断子弹是否碰撞到坦克
*/
public boolean bulletCollideTank(Bullet bullet,Tank tank)
{
return rectCollideRect(bullet.getX(),bullet.getY(),bullet.getWidth(),bullet.getHeight(),tank.getX(),tank.getY(),Tank.TANK_WIDTH,Tank.TANK_HEIGHT);
}
/**
* 判断子弹是否碰撞到块
*/
public boolean bulletCollideBlock(Bullet bullet,Block block)
{
return rectCollideRect(bullet.getX(),bullet.getY(),bullet.getWidth(),bullet.getHeight(),block.getX(),block.getY(),Block.BLOCK_WIDTH,Block.BLOCK_HEIGHT);
}
/**
* 判断子弹是否碰撞到大本营
*/
public boolean bulletCollideCamp(Bullet bullet,Camp camp)
{
return rectCollideRect(bullet.getX(),bullet.getY(),bullet.getWidth(),bullet.getHeight(),camp.getX(),camp.getY(),camp.getWidth(),camp.getHeight());
}
/**
* 得到某范围内的随机整数
* @param min 最小值
* @param max 最大值
*/
public static int getRandomInt(int min,int max)
{
return (int)(min + Math.random() * (max - min + 1));
}
}
GameMap.java游戏地图
package lag.game.tankwar;
/**
* 游戏地图
*/
public class GameMap
{
/** 各关地图[26行26列]（0-空地，1-砖块，2-铁块） */
private static byte[][][] gradeMap =
{
// 第1关地图
{
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,1,1,0,0,1,1,0,0,1,1,0,0,1,1,0,0,1,1,0,0,1,1,0,0},
{0,0,1,1,0,0,1,1,0,0,1,1,0,0,1,1,0,0,1,1,0,0,1,1,0,0},
{0,0,1,1,0,0,1,1,0,0,1,1,0,0,1,1,0,0,1,1,0,0,1,1,0,0},
{0,0,1,1,0,0,1,1,0,0,1,1,0,0,1,1,0,0,1,1,0,0,1,1,0,0},
{0,0,1,1,0,0,1,1,0,0,1,1,2,2,1,1,0,0,1,1,0,0,1,1,0,0},
{0,0,1,1,0,0,1,1,0,0,1,1,2,2,1,1,0,0,1,1,0,0,1,1,0,0},
{0,0,1,1,0,0,1,1,0,0,1,1,0,0,1,1,0,0,1,1,0,0,1,1,0,0},
{0,0,1,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,1,1,0,0},
{0,0,1,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,1,1,0,0},
{0,0,0,0,0,0,0,0,0,0,1,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,1,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0},
{1,1,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,1,1},
{2,2,0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,2,2},
{0,0,0,0,0,0,0,0,0,0,1,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0},
{0,0,1,1,0,0,1,1,0,0,1,1,1,1,1,1,0,0,1,1,0,0,1,1,0,0},
{0,0,1,1,0,0,1,1,0,0,1,1,0,0,1,1,0,0,1,1,0,0,1,1,0,0},
{0,0,1,1,0,0,1,1,0,0,1,1,0,0,1,1,0,0,1,1,0,0,1,1,0,0},
{0,0,1,1,0,0,1,1,0,0,1,1,0,0,1,1,0,0,1,1,0,0,1,1,0,0},
{0,0,1,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,1,1,0,0},
{0,0,1,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,1,1,0,0},
{0,0,1,1,0,0,1,1,0,0,0,1,1,1,1,0,0,0,1,1,0,0,1,1,0,0},
{0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0}
},
// 第2关地图
{
{0,0,0,0,0,0,2,2,0,0,0,0,0,0,2,2,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,2,2,0,0,0,0,0,0,2,2,0,0,0,0,0,0,0,0,0,0},
{0,0,1,1,0,0,2,2,0,0,0,0,0,0,1,1,0,0,1,1,0,0,1,1,0,0},
{0,0,1,1,0,0,2,2,0,0,0,0,0,0,1,1,0,0,1,1,0,0,1,1,0,0},
{0,0,1,1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,1,1,2,2,1,1,0,0},
{0,0,1,1,0,0,0,0,0,0,0,0,1,1,1,1,0,0,1,1,2,2,1,1,0,0},
{0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,2,2,0,0,0,0,0,0},
{0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,2,2,0,0,0,0,0,0},
{0,0,0,0,0,0,1,1,0,0,0,0,2,2,0,0,0,0,1,1,0,0,1,1,2,2},
{0,0,0,0,0,0,1,1,0,0,0,0,2,2,0,0,0,0,1,1,0,0,1,1,2,2},
{0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,2,2,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,2,2,0,0,0,0,0,0,0,0},
{0,0,1,1,1,1,1,1,0,0,0,0,0,0,2,2,0,0,0,0,0,0,1,1,0,0},
{0,0,1,1,1,1,1,1,0,0,0,0,0,0,2,2,0,0,0,0,0,0,1,1,0,0},
{0,0,0,0,0,0,2,2,0,0,1,1,0,0,1,1,0,0,1,1,0,0,1,1,0,0},
{0,0,0,0,0,0,2,2,0,0,1,1,0,0,1,1,0,0,1,1,0,0,1,1,0,0},
{2,2,1,1,0,0,2,2,0,0,1,1,0,0,1,1,0,0,0,0,0,0,1,1,0,0},
{2,2,1,1,0,0,2,2,0,0,1,1,0,0,1,1,0,0,0,0,0,0,1,1,0,0},
{0,0,1,1,0,0,1,1,0,0,1,1,1,1,1,1,0,0,1,1,2,2,1,1,0,0},
{0,0,1,1,0,0,1,1,0,0,1,1,1,1,1,1,0,0,1,1,2,2,1,1,0,0},
{0,0,1,1,0,0,1,1,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0},
{0,0,1,1,0,0,1,1,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0},
{0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,1,1,0,0},
{0,0,1,1,0,0,0,0,0,0,0,1,1,1,1,0,0,0,1,1,0,0,1,1,0,0},
{0,0,1,1,0,0,1,1,0,0,0,1,0,0,1,0,0,0,1,1,1,1,1,1,0,0},
{0,0,1,1,0,0,1,1,0,0,0,1,0,0,1,0,0,0,1,1,1,1,1,1,0,0}
}
// 其他关地图...
};
/** 总关卡数 */
private static int gradeCount = gradeMap.length;
/** 各关敌方坦克数量 */
private static int[] enemyTankNum = {10,20};
/**
* 返回某关地图
* @param grade 关数
*/
public static byte[][] getGameMap(int grade)
{
// 由于数组是个对象，而原始地图是不允许被修改的，所以不能直接赋值（引用地址），得复制一个新的地图让游戏随便修改。
byte[][] tempMap = null;
if(grade > 0 && grade <= gradeCount)
{
tempMap = gradeMap[grade - 1];
}
else
{
tempMap = gradeMap[0];
}
//开始复制
int row = tempMap.length;
int column = tempMap[0].length;
byte[][] returnMap = new byte[row][column];
for (int i = 0; i < row; i++)
{
for (int j = 0; j < column; j++)
{
returnMap[i][j] = tempMap[i][j];
}
}
return returnMap;
}
/**
* 功能：返回总关卡数
*/
public static int getGradeCount(){return gradeCount;}
/**
* 返回某关敌方坦克数量
* @param grade 关数
*/
public static int getEnemyTankNum(int grade)
{
if(grade < 1 || grade > gradeCount){grade = gradeCount;}
return enemyTankNum[grade - 1];
}
}
GameMusic.java
package lag.game.tankwar;
import java.io.File;
import java.io.InputStream;
import javax.sound.sampled.Clip;
import javax.sound.sampled.DataLine;
import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.AudioInputStream;
/**
* 游戏音乐
* 支持音乐格式（AITF、AU、WAV），就是加载有点慢啊。
*/
public class GameMusic
{
/** 音频输入流 */
private AudioInputStream stream;
/** 音频格式 */
private AudioFormat format;
/** 音频剪辑 */
private Clip clip;
/**
* 功能：构造函数
*/
public GameMusic(String fileName)
{
try
{
File file = new File(fileName);
//将音乐文件转为音频输入流
this.stream = AudioSystem.getAudioInputStream(file);
//得到音频格式
this.format = stream.getFormat();
}
catch(Exception e)
{
e.printStackTrace();
}
}
/**
* 构造函数
* @param fileName URL文件名
*/
public GameMusic(InputStream fileName)
{
try
{
//将音乐文件转为音频输入流
this.stream = AudioSystem.getAudioInputStream(fileName);
//得到音频格式
this.format = stream.getFormat();
}
catch(Exception e)
{
e.printStackTrace();
}
}
/**
* 功能：播放音乐
* 参数：boolean _loop -> 是否循环（True-无限循环，False-不循环）
*/
public void play(boolean _loop)
{
try
{
//设置音频行信息
DataLine.Info info = new DataLine.Info(Clip.class,this.format);
//建立音频行信息
this.clip = (Clip)AudioSystem.getLine(info);
this.clip.open(this.stream);
if(_loop) //无限循环
{
this.clip.loop(Clip.LOOP_CONTINUOUSLY);
}
else
{
this.clip.loop(0);
}
this.clip.start();
}
catch(Exception e)
{
e.printStackTrace();
}
}
/**
* 功能：停止音乐
*/
public void stop()
{
try
{
if(this.clip.isRunning())
{
this.clip.stop();
this.clip.close();
}
}
catch(Exception e)
{
e.printStackTrace();
}
}
}
Tank.java坦克父类
package lag.game.tankwar;
import java.awt.*;
import java.util.Vector;
/**
* 坦克父类
*/
public class Tank
{
/** 坦克类别常量 */
public final static int TANK_KIND_HERO = 0; // 我方坦克
public final static int TANK_KIND_ENEMY = 1; // 敌方坦克
/** 坦克颜色常量 */
public final static Color TANK_COLOR_HERO = Color.YELLOW; // 我方坦克颜色
public final static Color TANK_COLOR_ENEMY = Color.CYAN; // 敌方坦克颜色
/** 坦克方向常量 */
public final static int TANK_DIRECTION_UP = 0; // 向上
public final static int TANK_DIRECTION_RIGHT = 1; // 向右
public final static int TANK_DIRECTION_DOWN = 2; // 向下
public final static int TANK_DIRECTION_LEFT = 3; // 向左
/** 坦克状态常量 */
public final static int TANK_STATE_FREE = 0; // 空闲中
public final static int TANK_STATE_RUNNING = 1; // 运行中
/** 坦克最大血量值 */
public final static int TANK_MAX_BLOOD = 100;
/** 坦克尺寸常量 */
public final static int TANK_WIDTH = 40;
public final static int TANK_HEIGHT = 40;
/** 坦克左上角X坐标 */
private int x;
/** 坦克左上角Y坐标 */
private int y;
/** 坦克速度 */
private int speed = 8;
/** 坦克血量 */
private int hp = TANK_MAX_BLOOD;
/** 坦克方向 */
private int direction = TANK_DIRECTION_UP;
/** 坦克类别 */
private int tankKind = TANK_KIND_HERO;
/** 坦克状态 */
private int state = TANK_STATE_FREE;
/** 子弹池（考虑线程安全用Vector，没用ArrayList） */
private Vector bulletPool = new Vector<>();
/** 上次射击时间（用来设置2次射击最小时间间隔，禁止连续射击） */
private long lastShootTime = System.currentTimeMillis();
/**
* 构造函数
* @param tankKind 坦克类别
* @param x 坦克左上角X坐标
* @param y 坦克左上角Y坐标
* @param direction 坦克方向
*/
public Tank(int tankKind, int x, int y, int direction)
{
this.tankKind = tankKind;
this.x = x;
this.y = y;
this.direction = direction;
}
/**
* 画坦克
*/
public void draw(Graphics g)
{
// 绘制血条
g.setColor(Color.YELLOW);
g.fill3DRect(this.x,this.y,TANK_WIDTH,3,false); // 底色
g.setColor(Color.RED);
g.fill3DRect(this.x,this.y,(hp * TANK_WIDTH)/TANK_MAX_BLOOD,3,false); // 血量（计算宽度时由于都是int类型，因此除法是放到最后计算的，防止出现结果为0的问题【int取整了】）
g.setColor(Color.WHITE);
g.draw3DRect(this.x,this.y,TANK_WIDTH,3,false); // 边框
int tankToBloodHeight = 5; // 坦克到血条的高度
// 设置坦克颜色
if(this.tankKind == TANK_KIND_HERO) // 我方坦克颜色
{
g.setColor(TANK_COLOR_HERO);
}
else // 敌方坦克颜色
{
g.setColor(TANK_COLOR_ENEMY);
}
// 绘制四周虚线
for (int i = 0; i <= 10; i++)
{
g.drawOval(x - 1,y + 4 * i - 1, 1,1);
g.drawOval(x + TANK_WIDTH - 1,y + 4 * i - 1, 1,1);
if(i < 10){g.drawOval(x + 4 * i - 1,y + TANK_HEIGHT - 1, 1,1);}
}
// 根据方向开始绘制坦克
switch (direction)
{
case TANK_DIRECTION_UP:
g.fill3DRect(this.x + tankToBloodHeight,this.y + tankToBloodHeight,7,30,false); // 左边轮子
g.fill3DRect(this.x + 23 + tankToBloodHeight,this.y + tankToBloodHeight,7,30,false); // 右边轮子
g.fill3DRect(this.x + 7 + tankToBloodHeight,this.y + 5 + tankToBloodHeight,16,20,false); // 驾驶室
g.fillOval(this.x + 9 + tankToBloodHeight,this.y + 9 + tankToBloodHeight,12,12); // 炮台
g.fill3DRect(x + 14 + tankToBloodHeight,y + tankToBloodHeight,3,15,false); // 炮管
break;
case TANK_DIRECTION_RIGHT:
g.fill3DRect(this.x + tankToBloodHeight,this.y + tankToBloodHeight,30,7,false); // 上边轮子
g.fill3DRect(this.x + tankToBloodHeight,this.y + 23 + tankToBloodHeight,30,7,false); // 下边轮子
g.fill3DRect(this.x + 5 + tankToBloodHeight,this.y + 7 + tankToBloodHeight,20,16,false); // 驾驶室
g.fillOval(this.x + 9 + tankToBloodHeight,this.y + 9 + tankToBloodHeight,12,12); // 炮台
g.fill3DRect(x + 15 + tankToBloodHeight,y + 14 + tankToBloodHeight,15,3,false); // 炮管
break;
case TANK_DIRECTION_DOWN:
g.fill3DRect(this.x + tankToBloodHeight,this.y + tankToBloodHeight,7,30,false); // 左边轮子
g.fill3DRect(this.x + 23 + tankToBloodHeight,this.y + tankToBloodHeight,7,30,false); // 右边轮子
g.fill3DRect(this.x + 7 + tankToBloodHeight,this.y + 5 + tankToBloodHeight,16,20,false); // 驾驶室
g.fillOval(this.x + 9 + tankToBloodHeight,this.y + 9 + tankToBloodHeight,12,12); // 炮台
g.fill3DRect(x + 14 + tankToBloodHeight,y + 15 + tankToBloodHeight,3,15,false); // 炮管
break;
case TANK_DIRECTION_LEFT:
g.fill3DRect(this.x + tankToBloodHeight,this.y + tankToBloodHeight,30,7,false); // 上边轮子
g.fill3DRect(this.x + tankToBloodHeight,this.y + 23 + tankToBloodHeight,30,7,false); // 下边轮子
g.fill3DRect(this.x + 5 + tankToBloodHeight,this.y + 7 + tankToBloodHeight,20,16,false); // 驾驶室
g.fillOval(this.x + 9 + tankToBloodHeight,this.y + 9 + tankToBloodHeight,12,12); // 炮台
g.fill3DRect(x + tankToBloodHeight,y + 14 + tankToBloodHeight,15,3,false); // 炮管
break;
}
}
/**
* 坦克移动
* @param direction 移动方向
*/
public void move(int direction)
{
if(this.direction == direction) // 方向相同，加速前进（要判断边界及是否碰撞到别的对象）
{
if(!GameLogic.getInstance().tankMoveCollide(this)) // 没有碰撞，可以移动
{
switch (direction)
{
case TANK_DIRECTION_UP:
this.y -= this.speed;
break;
case TANK_DIRECTION_RIGHT:
this.x += this.speed;
break;
case TANK_DIRECTION_DOWN:
this.y += this.speed;
break;
case TANK_DIRECTION_LEFT:
this.x -= this.speed;
break;
}
}
}
else // 方向不同，仅调整方向不前进
{
this.direction = direction;
}
}
/**
* 坦克射击
*/
public void shoot()
{
// 禁止连续射击
long curShootTime = System.currentTimeMillis();
if((curShootTime - this.lastShootTime) >= 500) // 2发/秒
{
this.lastShootTime = curShootTime;
}
else
{
return;
}
// 在子弹池中寻找空闲的子弹
Bullet bullet = null;
for (int i = 0; i < bulletPool.size(); i++)
{
Bullet tmpBullet = bulletPool.get(i);
if(tmpBullet.getState() == Bullet.BULLET_STATE_FREE)
{
bullet = tmpBullet;
//System.out.println("找到空闲的子弹了..................");
break;
}
}
// 没有就增加一个
if(bullet == null)
{
bullet = new Bullet(this);
//System.out.println("新建子弹了.................");
bulletPool.add(bullet);
}
// 设置子弹位置
switch (this.direction)
{
case TANK_DIRECTION_UP:
bullet.setPosition(this.x + TANK_WIDTH/2 - bullet.getWidth()/2,this.y - bullet.getHeight(),this.direction);
break;
case TANK_DIRECTION_RIGHT:
bullet.setPosition(this.x + TANK_WIDTH,this.y + TANK_HEIGHT/2 - bullet.getHeight()/2,this.direction);
break;
case TANK_DIRECTION_DOWN:
bullet.setPosition(this.x + TANK_WIDTH/2 - bullet.getWidth()/2,this.y + TANK_HEIGHT,this.direction);
break;
case TANK_DIRECTION_LEFT:
bullet.setPosition(this.x - bullet.getWidth(),this.y + TANK_HEIGHT/2 - bullet.getHeight()/2,this.direction);
break;
}
// 让子弹飞一会
bullet.fly();
}
/** 坦克受到伤害 */
public void hurt(Bullet bullet)
{
this.hp -= bullet.getAtk();
if(this.hp < 0){this.hp = 0;}
}
/**
* 坦克是否死亡
*/
public boolean isDead()
{
return this.hp <= 0;
}
/**
* 坦克开始工作了
*/
public void work()
{
this.state = TANK_STATE_RUNNING;
}
/** 坦克重置 */
public void reset()
{
this.setX(-100);
this.setY(-100);
this.setHp(Tank.TANK_MAX_BLOOD);
this.setState(TANK_STATE_FREE);
}
public int getX(){return x;}
public void setX(int x){this.x = x;}
public int getY(){return y;}
public void setY(int y){this.y = y;}
public int getSpeed(){return speed;}
public void setSpeed(int speed){this.speed = speed;}
public int getHp(){return hp;}
public void setHp(int hp){this.hp = hp;}
public int getDirection(){return direction;}
public void setDirection(int direction){this.direction = direction;}
public int getState(){return state;}
public void setState(int state){this.state = state;}
public int getTankKind(){return tankKind;}
public Vector getBulletPool(){return bulletPool;}
}
Hero.java我方的坦克
package lag.game.tankwar;
/**
* 我方的坦克
*/
public class Hero extends Tank
{
/**
* 构造函数
* @param x 坦克左上角X坐标
* @param y 坦克左上角Y坐标
* @param direction 坦克方向
*/
public Hero(int x, int y, int direction)
{
super(TANK_KIND_HERO, x, y, direction);
}
}
Enemy.java敌方的坦克
package lag.game.tankwar;
/**
* 敌方的坦克
*/
public class Enemy extends Tank
{
/**
* 构造函数
* @param x 坦克左上角X坐标
* @param y 坦克左上角Y坐标
* @param direction 坦克方向
*/
public Enemy(int x, int y, int direction)
{
super(TANK_KIND_ENEMY, x, y, direction);
}
/**
* 起来干活了
*/
@Override
public void work()
{
super.work();
// 启动线程让坦克跑（看看敌方坦克的AI）
new Thread(()->{
//System.out.println("坦克线程启动...");
while (this.getState() == TANK_STATE_RUNNING)
{
try
{
Thread.sleep(200);
}
catch (InterruptedException e)
{
e.printStackTrace();
}
// 随机确认是原地不动还是移动（0-不动，其它-移动）
if(GameLogic.getRandomInt(0,8) != 0) // 移动（概率设大点）
{
// 随机确认是改变方向还是向前移动（0-改变方向，其它-向前移动）
if(GameLogic.getRandomInt(0,12) == 0) // 改变方向（概率设小点）
{
int newDirection = GameLogic.getRandomInt(TANK_DIRECTION_UP, TANK_DIRECTION_LEFT + 3);
if(newDirection > TANK_DIRECTION_LEFT){newDirection = TANK_DIRECTION_DOWN;} // 向下概率设大点
this.setDirection(newDirection);
}
else // 向前移动
{
// 如果到边界了就别顶牛了，赶紧换方向
boolean toBorder = false; // 默认未到边界
switch (this.getDirection())
{
case TANK_DIRECTION_UP:
if((this.getY() - this.getSpeed() < 0))
{
toBorder = true;
}
break;
case TANK_DIRECTION_RIGHT:
if((this.getX() + TANK_WIDTH + this.getSpeed() > GamePanel.GAME_ACTION_WIDTH))
{
toBorder = true;
}
break;
case TANK_DIRECTION_DOWN:
if((this.getY() + TANK_HEIGHT + this.getSpeed() > GamePanel.GAME_ACTION_HEIGHT))
{
toBorder = true;
}
break;
case TANK_DIRECTION_LEFT:
if((this.getX() - this.getSpeed() < 0))
{
toBorder = true;
}
break;
}
if(toBorder) // 到边界了赶紧换方向
{
int newDirection = GameLogic.getRandomInt(TANK_DIRECTION_UP, TANK_DIRECTION_LEFT);
this.setDirection(newDirection);
}
else // 继续前进
{
this.move(this.getDirection());
}
}
}
// 随机确认是发射子弹还是省子弹（1-发射，其它-不发射）
if(GameLogic.getRandomInt(0,8) == 1)
{
this.shoot();
}
}
//System.out.println("坦克线程退出历史舞台了...");
}).start();
}
}
Bullet.java子弹类
package lag.game.tankwar;
import java.awt.*;
/**
* 子弹类
*/
public class Bullet
{
/** 子弹状态常量 */
public final static int BULLET_STATE_FREE = 0; // 空闲中
public final static int BULLET_STATE_RUNNING = 1; // 运行中
/** 子弹攻击力常量 */
public final static int BULLET_MAX_ATTACK = 100; // 最大攻击力
public final static int BULLET_MIN_ATTACK = 20; // 最小攻击力
/** 子弹左上角X坐标 */
private int x;
/** 子弹左上角Y坐标 */
private int y;
/** 子弹宽度 */
private int width = 10;
/** 子弹高度 */
private int height = 10;
/** 子弹方向 */
private int direction;
/** 子弹速度 */
private int speed = 16;
/** 子弹状态 */
private int state = BULLET_STATE_FREE;
/** 所属坦克 */
private Tank tank;
/** 子弹攻击力 */
private int atk;
/**
* 构造函数
* @param tank 所属坦克
*/
public Bullet(Tank tank)
{
this.tank = tank;
this.atk = GameLogic.getRandomInt(BULLET_MIN_ATTACK,BULLET_MAX_ATTACK);
}
/**
* 设置子弹位置
*/
public void setPosition(int x,int y,int direction)
{
this.x = x;
this.y = y;
this.direction = direction;
}
/**
* 功能：子弹重置
*/
public void reset()
{
this.x = -100;
this.y = -100;
this.atk = GameLogic.getRandomInt(BULLET_MIN_ATTACK,BULLET_MAX_ATTACK); // 重新随机生成攻击力
this.state = BULLET_STATE_FREE;
}
/**
* 让子弹飞一会
*/
public void fly()
{
// 设置子弹状态为运行中
this.state = BULLET_STATE_RUNNING;
// 启动线程让子弹飞
new Thread(()->{
//System.out.println(tank.getTankKind() + "子弹线程启动...");
while (this.state == BULLET_STATE_RUNNING) //tank.getState() == Tank.TANK_STATE_RUNNING &&
{
try
{
Thread.sleep(50);
}
catch (InterruptedException e)
{
e.printStackTrace();
}
switch (direction)
{
case Tank.TANK_DIRECTION_UP:
if(this.y - this.speed >= 0)
{
this.y -= this.speed;
}
else
{
this.reset();
}
break;
case Tank.TANK_DIRECTION_RIGHT:
if(this.x + this.width + this.speed <= GamePanel.GAME_ACTION_WIDTH)
{
this.x += this.speed;
}
else
{
this.reset();
}
break;
case Tank.TANK_DIRECTION_DOWN:
if(this.y + this.height + this.speed <= GamePanel.GAME_ACTION_HEIGHT)
{
this.y += this.speed;
}
else
{
this.reset();
}
break;
case Tank.TANK_DIRECTION_LEFT:
if(this.x >= this.speed)
{
this.x -= this.speed;
}
else
{
this.reset();
}
break;
}
}
//System.out.println("子弹线程退出历史舞台了......");
}).start();
}
/**
* 画子弹
*/
public void draw(Graphics g)
{
// 开始画子弹
if(tank.getTankKind() == Tank.TANK_KIND_HERO) // 我方子弹
{
g.setColor(Tank.TANK_COLOR_HERO);
}
else // 敌方子弹
{
g.setColor(Tank.TANK_COLOR_ENEMY);
}
g.fillOval(this.x,this.y,this.width,this.height);
// 根据攻击力画加强子弹
g.setColor(Color.RED);
if(this.atk == 100)
{
g.fillOval(this.x,this.y,this.width,this.height);
}
else if(this.atk >= 90)
{
g.fillOval(this.x + 1,this.y + 1,this.width - 2,this.height - 2);
}
else if(this.atk >= 70)
{
g.fillOval(this.x + 2,this.y + 2,this.width - 4,this.height - 4);
}
else if(this.atk >= 50)
{
g.fillOval(this.x + 3,this.y + 3,this.width - 6,this.height - 6);
}
}
public int getX(){return x;}
public int getY(){return y;}
public int getWidth(){return width;}
public int getHeight(){return height;}
public int getDirection(){return direction;}
public int getSpeed(){return speed;}
public int getState(){return state;}
public int getAtk(){return atk;}
}
Bomb.java爆炸效果
package lag.game.tankwar;
import java.awt.*;
/**
* 爆炸效果
*/
public class Bomb
{
/** 爆炸状态常量 */
public final static int BOMB_STATE_FREE = 0; // 空闲中
public final static int BOMB_STATE_RUNNING = 1; // 运行中
/** 爆炸左上角X坐标 */
private int x;
/** 爆炸左上角Y坐标 */
private int y;
/** 爆炸宽度 */
private int width = 20;
/** 爆炸高度 */
private int height = 20;
/** 状态 */
private int state = BOMB_STATE_FREE;
/** 爆炸进度，根据它来决定显示哪种爆炸形状（-1-不显示任何爆炸形状，0-准备显示，1-显示第一种爆炸形状，2-显示第二种爆炸形状，3-显示第三种爆炸形状） */
public int bombProgress = -1;
/**
* 构造函数
* @param x 爆炸左上角X坐标
* @param y 爆炸左上角Y坐标
*/
public Bomb(int x, int y)
{
this.x = x;
this.y = y;
}
/**
* 起来干活，准备爆炸。
*/
public void work()
{
// 设置爆炸状态为运行中
this.state = BOMB_STATE_RUNNING;
// 爆炸进度，准备显示
bombProgress = 0;
}
/**
* 爆炸重置
*/
public void reset()
{
this.setX(-100);
this.setY(-100);
this.state = BOMB_STATE_FREE;
this.bombProgress = -1;
}
/**
* 画爆炸
* 每帧显示一种形状，共三种，即3帧结束爆炸
*/
public void draw(Graphics g)
{
// 进度走起
this.bombProgress++;
// 根据进度显示某种爆炸形状
switch (this.bombProgress)
{
case 1: // 第一种形状
g.setColor(Color.WHITE);
g.fillRoundRect(this.x + 5,this.y + 5,20,20,10,10);
g.fillOval(this.x + 10,this.y,10,30);
g.setColor(Color.YELLOW);
g.drawOval(this.x + 10,this.y,10,30);
g.setColor(Color.WHITE);
g.fillOval(this.x,this.y + 10,30,10);
g.setColor(Color.YELLOW);
g.drawOval(this.x,this.y + 10,30,10);
break;
case 2: // 第二种形状
g.setColor(Color.WHITE);
g.fillOval(this.x + 12,this.y + 5,6,20);
g.setColor(Color.YELLOW);
g.drawOval(this.x + 12,this.y + 5,6,20);
g.setColor(Color.WHITE);
g.fillOval(this.x + 5,this.y + 12,20,6);
g.setColor(Color.YELLOW);
g.drawOval(this.x + 5,this.y + 12,20,6);
break;
case 3: // 第三种形状
g.setColor(Color.WHITE);
g.fillOval(this.x + 10,this.y + 10,10,10);
g.setColor(Color.YELLOW);
g.drawOval(this.x + 10,this.y + 10,10,10);
break;
default:
this.reset();
break;
}
}
public int getX(){return x;}
public void setX(int x){this.x = x;}
public int getY(){return y;}
public void setY(int y){this.y = y;}
public int getWidth(){return width;}
public void setWidth(int width){this.width = width;}
public int getHeight(){return height;}
public void setHeight(int height){this.height = height;}
public int getState(){return state;}
}
Block.java砖块与铁块的父类
package lag.game.tankwar;
import java.awt.*;
/**
* 砖块与铁块的父类
*/
public class Block
{
/** 块类别常量 */
public final static int BLOCK_KIND_BRICK = 1; // 砖块
public final static int BLOCK_KIND_IRON = 2; // 铁块
/** 块尺寸常量（默认4个块=1坦克大小） */
public final static int BLOCK_WIDTH = Tank.TANK_WIDTH / 2;
public final static int BLOCK_HEIGHT = Tank.TANK_HEIGHT / 2;
/** 块左上角X坐标 */
private int x;
/** 块左上角Y坐标 */
private int y;
/** 块类别 */
private int blockKind = BLOCK_KIND_BRICK;
/**
* 构造函数
* @param blockKind 块类别
* @param x 块左上角X坐标
* @param y 块左上角Y坐标
*/
public Block(int blockKind,int x, int y)
{
this.blockKind = blockKind;
this.x = x;
this.y = y;
}
/**
* 画块
*/
public void draw(Graphics g)
{
if(this.blockKind == BLOCK_KIND_BRICK) // 画砖块
{
g.setColor(new Color(210, 105, 30));
g.fillRect(this.x,this.y,BLOCK_WIDTH,BLOCK_HEIGHT);
g.setColor(new Color(244, 164, 96));
g.drawLine(this.x,this.y,this.x + BLOCK_WIDTH - 1,this.y);
g.drawLine(this.x,this.y + BLOCK_HEIGHT / 2,this.x + BLOCK_WIDTH - 1,this.y + BLOCK_HEIGHT / 2);
g.drawLine(this.x,this.y,this.x,this.y + BLOCK_HEIGHT / 2);
g.drawLine(this.x + BLOCK_WIDTH / 2,this.y + BLOCK_HEIGHT / 2, this.x + BLOCK_WIDTH / 2, this.y + BLOCK_HEIGHT - 1);
}
else if(this.blockKind == BLOCK_KIND_IRON) // 画铁块
{
g.setColor(new Color(190, 190, 190));
g.fillRect(this.x,this.y,BLOCK_WIDTH,BLOCK_HEIGHT);
g.setColor(Color.WHITE);
g.fillRect(this.x + 3,this.y + 3,BLOCK_WIDTH - 6,BLOCK_HEIGHT - 6);
g.draw3DRect(this.x + 3,this.y + 3,BLOCK_WIDTH - 6,BLOCK_HEIGHT - 6,true);
g.drawLine(this.x + 1,this.y + 1,this.x + 3,this.y + 3);
g.drawLine(this.x + BLOCK_WIDTH - 1,this.y + 1,this.x + BLOCK_WIDTH - 3,this.y + 3);
g.drawLine(this.x + 1,this.y + BLOCK_HEIGHT - 1,this.x + 3,this.y + BLOCK_HEIGHT - 3);
g.drawLine(this.x + BLOCK_WIDTH - 1,this.y + BLOCK_HEIGHT - 1,this.x + BLOCK_WIDTH - 3,this.y + BLOCK_HEIGHT - 3);
}
}
public int getX(){return x;}
public void setX(int x){this.x = x;}
public int getY(){return y;}
public void setY(int y){this.y = y;}
public int getBlockKind(){return blockKind;}
}
Brick.java砖块
package lag.game.tankwar;
/**
* 砖块
*/
public class Brick extends Block
{
/**
* 构造函数
* @param x 砖块左上角X坐标
* @param y 砖块左上角Y坐标
*/
public Brick(int x, int y)
{
super(BLOCK_KIND_BRICK, x, y);
}
}
Iron.java铁块
package lag.game.tankwar;
/**
* 铁块
*/
public class Iron extends Block
{
/**
* 构造函数
* @param x 铁块左上角X坐标
* @param y 铁块左上角Y坐标
*/
public Iron(int x, int y)
{
super(BLOCK_KIND_IRON, x, y);
}
}
Camp.java营地
package lag.game.tankwar;
import java.awt.*;
/**
* 营地
*/
public class Camp
{
/** 营地状态常量 */
public final static int CAMP_STATE_FREE = 0; // 空闲中
public final static int CAMP_STATE_RUNNING = 1; // 运行中
/** 营地左上角X坐标 */
private int x;
/** 营地左上角Y坐标 */
private int y;
/** 营地宽度 */
private int width = Tank.TANK_WIDTH;
/** 营地高度 */
private int height = Tank.TANK_HEIGHT;
/** 营地状态 */
private int state = CAMP_STATE_FREE;
/** 元素宽度 */
private int elementWidth = 2;
/** 元素高度 */
private int elementHeight = 2;
/** 营地地图（20 * 20） */
private static byte[][] campMap =
{
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,1,0,0,0,1,1,1,1,0,0,0,0,0,0,0,1,0,0},
{1,1,1,1,0,0,0,1,1,1,1,0,0,0,0,0,1,1,1,1},
{0,2,1,1,1,0,0,0,1,0,0,1,1,0,0,1,1,1,2,0},
{1,1,2,0,1,0,0,0,1,1,1,1,0,0,0,1,0,2,1,1},
{0,0,1,2,1,1,0,0,1,1,1,1,0,0,1,1,2,1,0,0},
{0,1,1,1,2,1,0,0,1,1,1,1,0,0,1,2,1,1,1,0},
{0,0,1,1,1,2,1,1,1,1,1,1,1,1,2,1,1,1,0,0},
{0,0,0,1,1,1,2,1,1,1,1,1,1,2,1,1,1,0,0,0},
{0,0,1,1,1,1,1,1,2,1,1,1,2,1,1,1,1,1,0,0},
{0,0,0,1,1,1,1,1,1,2,1,2,1,1,1,1,1,0,0,0},
{0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0},
{0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0},
{0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0},
{0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0},
{0,0,0,0,0,0,1,0,1,1,1,0,1,0,0,0,0,0,0,0},
{0,0,0,0,0,0,1,1,1,0,1,1,1,0,0,0,0,0,0,0},
{0,0,0,0,0,1,1,1,1,0,1,1,1,1,0,0,0,0,0,0},
{0,0,0,0,0,1,1,0,1,0,1,0,1,1,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}
};
/**
* 构造函数
*/
public Camp(int x, int y)
{
this.x = x;
this.y = y;
}
/**
* 画营地
*/
public void draw(Graphics g)
{
int row = campMap.length;
int column = campMap[0].length;
for (int i = 0; i < row; i++)
{
for (int j = 0; j < column; j++)
{
int mapValue = campMap[i][j];
if(mapValue == 1)
{
g.setColor(Color.WHITE);
drawElement(g,this.x + elementWidth * j,this.y + elementHeight * i);
}
else if(mapValue == 2)
{
g.setColor(Color.LIGHT_GRAY);
drawElement(g,this.x + elementWidth * j,this.y + elementHeight * i);
}
}
}
}
/**
* 画元素
* @param x 元素左上角X坐标
* @param y 元素左上角Y坐标
*/
private void drawElement(Graphics g,int x,int y)
{
g.fillRect(x,y,elementWidth,elementHeight);
g.setColor(Color.WHITE);
g.draw3DRect(x,y,elementWidth,elementHeight,true);
}
public int getX(){return x;}
public void setX(int x){this.x = x;}
public int getY(){return y;}
public void setY(int y){this.y = y;}
public int getWidth(){return width;}
public int getHeight(){return height;}
public int getState(){return state;}
public void setState(int state){this.state = state;}
}
下载：
链接：https://pan.baidu.com/s/1aqNjqATCjteiAdv90YDByw?pwd=mylx
提取码：mylx
感言：
本游戏并没有使用图片，都是用Java画的，有兴趣的朋友可以自己改用图片，图片素材我已经打包了。使用图片的朋友要注意一个问题，就是图片加载是需要时间的，第一次可能还未加载成功就直接刷新下一次界面了，这也是韩顺平老师那个第一次射击坦克不出现爆炸效果的原因。Toolkit.getDefaultToolkit().createImage这个方法有BUG，改用new ImageIcon(图片路径)).getImage()就可以了。