坦克大战
1、java绘图坐标体系
1)坐标原点在左上角,水平向右为x轴正方向,垂直向下为y轴正方向。单位是像素。
2)像素是个密度单位,而厘米是长度单位。
2、绘图原理
Component类提供了两个和绘图相关最重要的方法:
paint(Graphics g):绘制组件的外观;
repaint():刷新组件的外观。
当组件第一次在屏幕显示的时候,程序自动的调用paint()方法来绘制组件。
在以下情况paint()将会被调用:
窗口最小化,再最大化;
窗口的大小发生变化;
repaint函数被调用。
public class DrawCircle extends JFrame{//JFrame 对应窗口,相当于画框,然后往里面塞画板
//定义一个面板
private MyPanel mp = null;
public static void main(String[] args) {
new DrawCircle();
}
public DrawCircle(){
//初始化面板
mp = new MyPanel();
//把面板放入到窗口
this.add(mp);
//设置窗口大小
this.setSize(400,300);
//当点击窗口的×时,真正的程序退出
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setVisible(true);//可以显示
}
}
//1.先定义一个MyPanel,继承JPanel类,画图形
class MyPanel extends JPanel{
//1.MyPanel对象就是一个画板
//2.Graphics g 把 g 理解成一支画笔
//3.Graphics 提供了很多绘图的方法
@Override
public void paint(Graphics g) {//绘图方法
super.paint(g);//调用父类方法,执行初始化
g.drawOval(10,10,100,100);
}
}
3、Graphics类
Graphics类可以理解就是画笔,为我们提供各种绘制图像的方法:
1.画直线 drawLine(int x1,int y1,int x2,int y2);
2.画矩形边框 drawRect(int x,int y,int width,int height);
3.画椭圆边框 drawOval(int x,int y,int width,int height);
4.填充矩形 fillRect(int x,int y,int width,int height);
5.填充椭圆 fillOval(int x,int y,int width,int height);
6.画图片 drawImage(Image img,int x,int y,...);
7.画字符串 drawString(String str,int x,int y);
8.设置画笔的字体 setFont(Font font);
9.设置画笔的颜色 setColor(Color c);
//画图片 drawImage(Image img,int x,int y,...);
//1.获取图片资源
Image image = Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/1.png"));
g.drawImage(image,10,10,175,221,this);
//设置画笔的颜色 setColor(Color c);
//设置画笔的字体 setFont(Font font);
g.setColor(Color.red);
g.setFont(new Font("隶书", Font.BOLD, 50));
4、绘出坦克
public class Tank {
private int x;//坦克的横坐标
private int y;//坦克的纵坐标
private int direct;//坦克方向
private int speed = 1;//坦克速度
public int getSpeed() {
return speed;
}
public void setSpeed(int speed) {
this.speed = speed;
}
//修改坐标
public void moveUp() {
y -= speed;
}
public void moveDown() {
y += speed;
}
public void moveLeft() {
x -= speed;
}
public void moveRight() {
x += speed;
}
public int getDirect() {
return direct;
}
public void setDirect(int direct) {
this.direct = direct;
}
public Tank(int x, int y) {
this.x = x;
this.y = y;
}
public int getX() {
return x;
}
public void setX(int x) {
this.x = x;
}
public int getY() {
return y;
}
public void setY(int y) {
this.y = y;
}
}
public class MyTank extends Tank{
public MyTank(int x, int y) {
super(x, y);
}
}
public class MyPanel extends JPanel {
//定义我的坦克
MyTank hero = null;
public MyPanel(){
hero = new MyTank(100,100) ;//初始化自己坦克
}
@Override
public void paint(Graphics g) {
super.paint(g);
g.fillRect(0,0,1000,750);//背景区域
//绘制坦克
drawTank(hero.getX(),hero.getY(),g,0,0);
}
//画出坦克
/**
*
* @param x 坦克的左上角横坐标
* @param y 坦克的左上角纵坐标
* @param g 画笔
* @param direct 坦克方向
* @param type 坦克类型
*/
public void drawTank(int x,int y,Graphics g,int direct ,int type){
//根据种类,设置不同的颜色
switch(type){
case 0://我们的坦克
g.setColor(Color.cyan);
break;
case 1://敌人的坦克
g.setColor(Color.yellow);
break;
}
//根据坦克方向,来绘制坦克
switch(direct) {
case 0://表示向上
g.fill3DRect(x, y, 10, 60, false);//左轮
g.fill3DRect(x + 30, y, 10, 60, false);//右轮
g.fill3DRect(x + 10, y + 10, 20, 40, false);//身体
g.fillOval(x + 10, y + 20, 20, 20);//炮台
g.drawLine(x + 20, y, x + 20, y + 30);//炮管
break;
default:
System.out.println("暂时未处理");
}
}
}
public class ZWJTankGame01 extends JFrame {
//定义MyPanel
MyPanel mp = null;
public static void main(String[] args) {
new ZWJTankGame01();
}
public ZWJTankGame01(){
mp = new MyPanel();
this.add(mp);
this.setSize(1000,750);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setVisible(true);
}
}
5、java事件处理机制
java事件处理是采取“委派事件模型”。当事件发生时,产生事件的对象,会把此“信息”传递给“事件的监听者”处理,这里所说的“信息”实际上就是 java.awt.event 事件类库里某个类所创建的对象。
public class BallMove extends JFrame{
MyPanel mp = null;
public static void main(String[] args) {
BallMove ballMove = new BallMove();
}
public BallMove(){
mp = new MyPanel();
this.add(mp);
this.setSize(400,300);
//窗口可以监听键盘事件
this.addKeyListener(mp);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setVisible(true);
}
}
//画小球
//KeyListener 是监听器,可以监听键盘事件
class MyPanel extends JPanel implements KeyListener {
int x = 10;
int y = 10;
@Override
public void paint(Graphics g) {
super.paint(g);
g.fillOval(x,y,20,20);
}
//有字符输出时,该方法被触发
@Override
public void keyTyped(KeyEvent e) {
}
//当某个键按下
@Override
public void keyPressed(KeyEvent e) {
if(e.getKeyCode() == KeyEvent.VK_DOWN){//向下
y++;
}else if(e.getKeyCode() == KeyEvent.VK_UP){
y--;
}else if(e.getKeyCode() == KeyEvent.VK_LEFT){
x--;
}else if(e.getKeyCode() == KeyEvent.VK_RIGHT){
x++;
}
//重绘
this.repaint();
}
//当某个键松开
@Override
public void keyReleased(KeyEvent e) {
}
}
6、坦克移动
绘制四种方向的坦克:
//根据坦克方向,来绘制坦克
switch (direct) {
case 0://表示向上
g.fill3DRect(x, y, 10, 60, false);//左轮
g.fill3DRect(x + 30, y, 10, 60, false);//右轮
g.fill3DRect(x + 10, y + 10, 20, 40, false);//身体
g.fillOval(x + 10, y + 20, 20, 20);//炮台
g.drawLine(x + 20, y, x + 20, y + 30);//炮管
break;
case 1://表示向右
g.fill3DRect(x, y, 60, 10, false);//上轮
g.fill3DRect(x, y + 30, 60, 10, false);//下轮
g.fill3DRect(x + 10, y + 10, 40, 20, false);//身体
g.fillOval(x + 20, y + 10, 20, 20);//炮台
g.drawLine(x + 30, y + 20, x + 60, y + 20);//炮管
break;
case 2://表示向下
g.fill3DRect(x, y, 10, 60, false);//左轮
g.fill3DRect(x + 30, y, 10, 60, false);//右轮
g.fill3DRect(x + 10, y + 10, 20, 40, false);//身体
g.fillOval(x + 10, y + 20, 20, 20);//炮台
g.drawLine(x + 20, y + 30, x + 20, y + 60);//炮管
break;
case 3://表示向右
g.fill3DRect(x, y, 60, 10, false);//上轮
g.fill3DRect(x, y + 30, 60, 10, false);//下轮
g.fill3DRect(x + 10, y + 10, 40, 20, false);//身体
g.fillOval(x + 20, y + 10, 20, 20);//炮台
g.drawLine(x + 30, y + 20, x, y + 20);//炮管
break;
default:
System.out.println("暂时未处理");
}
键盘监听:坦克类多个属性direct
//处理wasd键
@Override
public void keyPressed(KeyEvent e) {
if(e.getKeyCode() == KeyEvent.VK_W){
hero.setDirect(0);
hero.moveUp();
}else if(e.getKeyCode() == KeyEvent.VK_D){
hero.setDirect(1);
hero.moveRight();
}else if(e.getKeyCode() == KeyEvent.VK_S){
hero.setDirect(2);
hero.moveDown();
}else if(e.getKeyCode() == KeyEvent.VK_A){
hero.setDirect(3);
hero.moveLeft();
}
this.repaint();
}
7、敌人坦克
分析:
敌人的坦克应该会有自己特殊的属性和方法,可以单开一个EnemyTank类;
敌人坦克数量多,可以放入到集合Vector,因为考虑多线程问题。
//定义敌人坦克
Vector<EnemyTank> enemyTanks = new Vector<>();
int enemyTankSize = 3;
public MyPanel() {
hero = new MyTank(100, 100);//初始化自己坦克
hero.setSpeed(5);
//初始化敌人坦克
for (int i = 0; i < enemyTanks.size(); i++) {
EnemyTank enemyTank = new EnemyTank((100 * (i + 1)),0);
enemyTank.setDirect(2);
enemyTanks.add(enemyTank);
}
}
//绘制敌人坦克
for (int i = 0; i < enemyTankSize; i++) {
//取出坦克
EnemyTank enemyTank = enemyTanks.get(i);
drawTank(enemyTank.getX(), enemyTank.getY(), g, enemyTank.getDirect(), 1);
}
8、坦克发射子弹
分析:
当发射一颗子弹后,就相当于启动一个线程;
Hero 有子弹对象,当按下J时,我们就启动一个发射行为(线程),让子弹不停的移动;
我们面板MyPanel需要不停重绘子弹,才能形成射击效果;
当子弹碰到边界,就应该销毁。
//射击子弹
public class Shot implements Runnable {
int x;//子弹x坐标
int y;//子弹y坐标
int direct = 0;//子弹方向
int speed = 3;//子弹速度
boolean isLive = true;//子弹是否存活
public Shot(int x, int y, int direct) {
this.x = x;
this.y = y;
this.direct = direct;
}
@Override
public void run() {//射击
while (isLive) {
//休眠
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
//根据方向来改变x,y
switch (direct) {
case 0://上
y -= speed;
break;
case 1://右
x += speed;
break;
case 2:
y += speed;
break;
case 3:
x -= speed;
break;
}
System.out.println("x=" + x + " y=" + y);
//子弹到达边界,应该销毁
if (!(x >= 0 && x <= 1000 && y >= 0 && y <= 750)) {
isLive = false;
break;
}
}
}
}
public class MyTank extends Tank {
//定义一个Shot对象
Shot shot = null;
public MyTank(int x, int y) {
super(x, y);
}
//射击
public void shotEnemyTank() {
//创建Shot对象
switch (getDirect()) {
case 0:
shot = new Shot(getX() + 20, getY(), 0);
break;
case 1:
shot = new Shot(getX() + 60, getY() + 20, 1);
break;
case 2:
shot = new Shot(getX() + 20, getY() + 60, 2);
break;
case 3:
shot = new Shot(getX(), getY() + 20, 3);
break;
}
//启动Shot线程
Thread thread = new Thread(shot);
thread.start();
}
}
//MyPanel update!!!
@Override
public void paint(Graphics g) {
....
//画出hero射击的子弹
if (hero.shot != null && hero.shot.isLive == true) {
g.draw3DRect(hero.shot.x, hero.shot.y, 1, 1, false);
}
....
}
}
@Override
public void keyPressed(KeyEvent e) {
.....
//如果用户按下的是J,就发射
if (e.getKeyCode() == KeyEvent.VK_J) {
hero.shotEnemyTank();
}
this.repaint();
}
//new add!!!!!!
@Override
public void run() { //每隔一定时间,重绘
while(true) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.repaint();
}
}
//tankgame类 update!!!!!
//将mp 放入到Thread中,并启动
Thread thread = new Thread(mp);
thread.start();
遗留问题:自己还无法发射多枚子弹
9、大更新(WoW)
增加功能:
让敌人的坦克也能够发射子弹(可以有多颗子弹);
子弹击中后产生爆炸效果;
敌人坦克可以自由移动;
控制我方坦克和敌人坦克在规定的范围移动。
1、敌射!多弹?
分析:
在敌人坦克类,使用Vector保存多个Shot;
当每创建一个敌人坦克对象,给该敌人坦克对象初始化 一个Shot对象,同时启动Shot;
在绘制敌人坦克时,需要通过Vector,绘制所有的子弹;【同时也要删除死亡子弹】
//EnemyTank update!!!!!
public class EnemyTank extends Tank {
//在敌人坦克类,使用Vector 保存多个Shot
Vector<Shot> shots = new Vector<>();
public EnemyTank(int x, int y) {
super(x, y);
}
}
//MyPanel update!!!!!!!
public MyPanel() {
...
//初始化敌人坦克
for (int i = 0; i < enemyTankSize; i++) {
....
//给该坦克加入一颗子弹
Shot shot = new Shot(enemyTank.getX()+20,enemyTank.getY()+60,
enemyTank.getDirect());
//加入到enemyTank的Vector成员中
enemyTank.shots.add(shot);
//启动Shot线程
Thread thread = new Thread(shot);
thread.start();
....
}
}
@Override
public void paint(Graphics g) {
....
//绘制敌人坦克
for (int i = 0; i < enemyTankSize; i++) {
....
//画出 敌人坦克的子弹
for (int j = 0; j < enemyTank.shots.size(); j++) {
//取出子弹
Shot shot = enemyTank.shots.get(j);
//绘制
if(shot.isLive){
g.draw3DRect(shot.x, shot.y, 1, 1, false);
}else{
//从Vector中移除死亡子弹
enemyTank.shots.remove(shot);
}
}
}
}
遗留问题:我赌你的枪里只有一颗子弹。
2、爆炸艺术
//命中消失
//MyPanel update!!!!!!
//编写方法,判断我方的子弹是否击中敌人坦克
public static void hitTank(Shot s, EnemyTank enemyTank) {
//判断s 击中坦克
switch (enemyTank.getDirect()) {
case 0://坦克向上
case 2://坦克向下
if (s.x > enemyTank.getX() && s.x < enemyTank.getX() + 40
&& s.y > enemyTank.getY() && s.y < enemyTank.getY() + 60) {
s.isLive = false;
enemyTank.isLive = false;
}
break;
case 1://坦克向右
case 3://坦克向左
if (s.x > enemyTank.getX() && s.x < enemyTank.getX() + 60
&& s.y > enemyTank.getY() && s.y < enemyTank.getY() + 40) {
s.isLive = false;
enemyTank.isLive = false;
}
break;
}
}
@Override
public void run() { //每隔一定时间,重绘
while (true) {
....
//判断是否击中敌人坦克
if (hero.shot != null && hero.shot.isLive) {//当我子弹存活
//遍历敌人所有的坦克
for (int i = 0; i < enemyTanks.size(); i++) {
EnemyTank enemyTank = enemyTanks.get(i);
hitTank(hero.shot, enemyTank);
}
}
this.repaint();
}
}
//Shot update!!!!!!
@Override
public void run() {//射击
while (isLive) {
....
//子弹到达边界,应该销毁
//当子弹碰到敌人的时候也应该结束线程
if (!(x >= 0 && x <= 1000 && y >= 0 && y <= 750 && isLive)) {
isLive = false;
break;
}
}
}
//爆炸效果
//Bomb add!!!!!!!
public class Bomb {
int x, y;//炸弹坐标
int life = 9;//炸弹的生命周期
boolean isLive = true;//是否还存活
public Bomb(int x, int y) {
this.x = x;
this.y = y;
}
//减少生命值
public void lifeDown() {
if (life > 0) {
life--;
} else {
isLive = false;
}
}
}
//MyPanel update!!!!!!!!!!!
//定义一个Vector,用于存放炸弹
//当子弹击中坦克时,加入一个Bomb对象
Vector<Bomb> bombs = new Vector<>();
//定义三张炸弹图片,用于显示爆炸效果
Image image1 = null;
Image image2 = null;
Image image3 = null;
public MyPanel() {
....
//初始化爆炸图片
image1 = Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/image1.jpg"));
image2 = Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/image2.jpg"));
image3 = Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/image3.jpg"));
}
public void hitTank(Shot s, EnemyTank enemyTank) {
//判断s 击中坦克
switch (enemyTank.getDirect()) {
case 0://坦克向上
case 2://坦克向下
if (s.x > enemyTank.getX() && s.x < enemyTank.getX() + 40
&& s.y > enemyTank.getY() && s.y < enemyTank.getY() + 60) {
s.isLive = false;
enemyTank.isLive = false;
//当我方子弹成功打中敌人坦克
enemyTanks.remove(enemyTank);
//创建Bomb对象,加入到bombs集合
Bomb bomb = new Bomb(enemyTank.getX(), enemyTank.getY());
bombs.add(bomb);
}
break;
....
}
}
@Override
public void paint(Graphics g) {
....
//画出爆炸效果
for (int i = 0; i < bombs.size(); i++) {
//取出炸弹
Bomb bomb = bombs.get(i);
//根据当前这个bomb对象的life值去画出对应的图片
if (bomb.life > 6) {
g.drawImage(image1, bomb.x, bomb.y, 60, 60, this);
} else if (bomb.life > 3) {
g.drawImage(image2, bomb.x, bomb.y, 60, 60, this);
} else {
g.drawImage(image3, bomb.x, bomb.y, 60, 60, this);
}
//让这个炸弹生命值减少
bomb.lifeDown();
//如果bomb life 为0,在集合中删掉
if (bomb.life == 0) {
bombs.remove(bomb);
}
}
....
}
3、自由的飞翔
分析:
因为要求敌人的坦克,可以自由移动,因此需要将敌人坦克当做线程使用;
我们需要EnemyTank implements Runnable;
在run中写上相应的业务代码;
在创建敌人坦克的时候,启动线程
//EnemyTank update!!!!!!!
@Override
public void run() {
while (true) {
//根据坦克方向来继续移动
switch (getDirect()) {
case 0:
//营造出惯性的感觉
for (int i = 0; i < 30; i++) {
moveUp();
//休眠
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
break;
case 1:
for (int i = 0; i < 30; i++) {
moveRight();
//休眠
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
break;
case 2:
for (int i = 0; i < 30; i++) {
moveDown();
//休眠
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
break;
case 3:
for (int i = 0; i < 30; i++) {
moveLeft();
//休眠
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
break;
}
//然后随机改变坦克方向
setDirect((int) (Math.random() * 4));
//写并发程序一定要考虑,该线程什么时候结束
if (!isLive) {
break;//退出线程
}
}
}
4、我就是规矩
//让坦克不能出边界
if (getY() > 0) {
moveUp();
}
if (getX() + 60 < 1000) {
moveRight();
}
if (getY() + 60 < 750) {
moveDown();
}
if (getX() > 0) {
moveLeft();
}
10、喵喵
我方坦克可以发射多枚子弹;
让敌人坦克发射的子弹消亡后,可以再发射子弹;
当敌人的坦克击中我方坦克,我方坦克消失,并出现爆炸效果。
1、火力不足恐惧症
//MyPanel update!!!!!!
@Override
public void paint(Graphics g) {
....
//画出hero射击的子弹
// if (hero.shot != null && hero.shot.isLive == true) {
// g.draw3DRect(hero.shot.x, hero.shot.y, 1, 1, false);
// }
//将hero的子弹集合shots,遍历绘制
for (int i = 0; i < hero.shots.size(); i++) {
Shot shot = hero.shots.get(i);
if (shot != null && shot.isLive) {
g.draw3DRect(shot.x, shot.y, 1, 1, false);
}else{
//如果该shot对象已经无效,要在集合中移除
hero.shots.remove(shot);
}
}
....
}
//如果我们的坦克可以发射多个子弹
//要判断有没有打中
//就需要拿所有的子弹和所有的敌人进行比较
public void hitEnemyTank(){
//遍历我们的子弹
for (int j = 0; j < hero.shots.size(); j++) {
Shot shot = hero.shots.get(j);
//判断是否击中敌人坦克
if (hero.shot != null && hero.shot.isLive) {//当我子弹存活
//遍历敌人所有的坦克
for (int i = 0; i < enemyTanks.size(); i++) {
EnemyTank enemyTank = enemyTanks.get(i);
hitTank(hero.shot, enemyTank);
}
}
}
}
2、还想射(-_-)!
//EnemyTank update!!!!!!
@Override
public void run() {
while (true) {
//这里我们判断子弹集合大小==0,创建一颗子弹,放入到
// shots集合中,并启动
if (isLive && shots.size() < 10) {
Shot s = null;
//判断坦克方向,创建对应的子弹
switch (getDirect()) {
case 0:
s = new Shot(getX() + 20, getY(), 0);
break;
case 1:
s = new Shot(getX() + 60, getY() + 20, 1);
break;
case 2:
s = new Shot(getX() + 20, getY() + 60, 2);
break;
case 3:
s = new Shot(getX(), getY() + 20, 3);
break;
}
shots.add(s);
//启动
new Thread(s).start();
}
....
}
}
3、你也想要爆炸吗?
//编写方法,判断敌人坦克是否击中我的坦克
public void hitHero() {
//遍历所有敌人坦克
for (int i = 0; i < enemyTanks.size(); i++) {
//取出敌人坦克
EnemyTank enemyTank = enemyTanks.get(i);
//遍历所有子弹
for (int j = 0; j < enemyTank.shots.size(); j++) {
//取出子弹
Shot shot = enemyTank.shots.get(j);
//判断 shot 是否击中我的坦克
if (hero.isLive && shot.isLive) {
hitTank(shot, hero);
}
}
}
}
11、更新更新
防止敌人坦克重叠运动;
记录玩家的成绩,存盘退出;
记录当时敌人坦克坐标,存盘退出;
玩游戏时,可以选择重新开始或者继续上局游戏。
1、不要贴贴
//EnemyTank update!!!!!!
public class EnemyTank extends Tank implements Runnable {
....
//增加成员,EnemyTank 可以得到敌认坦克的Vector
Vector<EnemyTank> enemyTanks = new Vector<>();
....
//可以将Mypanel对象中的敌人坦克集合放入
public void setEnemyTanks(Vector<EnemyTank> enemyTanks) {
this.enemyTanks = enemyTanks;
}
//编写方法,判断当前这个敌人坦克,是否和enemyTanks中的其他成员发生重叠或者碰撞
public boolean isTouchEnemyTank() {
switch (this.getDirect()) {
case 0:
//循环比较
for (int i = 0; i < enemyTanks.size(); i++) {
//取出坦克
EnemyTank enemyTank = enemyTanks.get(i);
//不和自己比较
if (enemyTank != this) {
//如果敌人坦克是上下
if (enemyTank.getDirect() == 0 || enemyTank.getDirect() == 2) {
//左上角
if (this.getX() >= enemyTank.getX()
&& this.getX() <= enemyTank.getX() + 40
&& this.getY() >= enemyTank.getY()
&& this.getY() <= enemyTank.getY() + 60) {
return true;
}
//右上角
if (this.getX() + 40 >= enemyTank.getX()
&& this.getX() + 40 <= enemyTank.getX() + 40
&& this.getY() >= enemyTank.getY()
&& this.getY() <= enemyTank.getY() + 60) {
return true;
}
}
//如果敌人坦克是左右
if (enemyTank.getDirect() == 1 || enemyTank.getDirect() == 3) {
//左上角
if (this.getX() >= enemyTank.getX()
&& this.getX() <= enemyTank.getX() + 60
&& this.getY() >= enemyTank.getY()
&& this.getY() <= enemyTank.getY() + 40) {
return true;
}
//右上角
if (this.getX() + 40 >= enemyTank.getX()
&& this.getX() + 40 <= enemyTank.getX() + 60
&& this.getY() >= enemyTank.getY()
&& this.getY() <= enemyTank.getY() + 40) {
return true;
}
}
}
}
break;
....
}
return false;
}
@Override
public void run() {
while (true) {
....
//根据坦克方向来继续移动
switch (getDirect()) {
case 0:
//营造出惯性的感觉
for (int i = 0; i < 30; i++) {//多一个碰撞判断
if (getY() > 0 && !isTouchEnemyTank()) {
moveUp();
}
....
}
break;
....
}
}
}
//MyPanel update!!!!!!!!
public MyPanel() {
....
//初始化敌人坦克
for (int i = 0; i < enemyTankSize; i++) {
//创建敌人坦克
EnemyTank enemyTank = new EnemyTank((100 * (i + 1)), 0);
//将enemyTanks 设置给 enemyTank!!!!
enemyTank.setEnemyTanks(enemyTanks);
....
}
....
}
2、你曾经活过
创建新的类Recorder:
该类记录我方击败敌方坦克数;
当游戏结束时,将数据写入到文件(IO)。
//Recorder add!!!!!
public class Recorder {
//记录我方击毁敌人坦克数
private static int allEnemyTankNum = 0;
//定义IO对象,准备写数据到文件中
private static BufferedWriter bw = null;
private static String recordFile = "d:\\myRecord.txt";
//当游戏退出时,我们将allEnemyTankNum保存到文件中
public static void keepRecord(){
try {
bw = new BufferedWriter(new FileWriter(recordFile));
bw.write(allEnemyTankNum+"\r\n");
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if(bw!=null) {
bw.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
public static int getAllEnemyTankNum() {
return allEnemyTankNum;
}
public static void setAllEnemyTankNum(int allEnemyTankNum) {
Recorder.allEnemyTankNum = allEnemyTankNum;
}
//当我方坦克击毁一个敌人坦克,就应该增加数量
public static void addAllEnemyTankNum(){
allEnemyTankNum++;
}
}
//MyPanel update!!!!!!
//编写方法,显示我方击败敌方坦克的信息
public void showInfo(Graphics g){
//画出玩家的总成绩
g.setColor(Color.BLACK);
Font font = new Font("宋体",Font.BOLD,25);
g.setFont(font);
g.drawString("您累计击毁敌方坦克",1020,30);
drawTank(1020,60,g,0,1);
g.setColor(Color.BLACK);
g.drawString(Recorder.getAllEnemyTankNum()+"",1080,100);
}
//编写方法,判断我方的子弹是否击中敌人坦克
public void hitTank(Shot s, Tank enemyTank) {
//判断s 击中坦克
switch (enemyTank.getDirect()) {
case 0://坦克向上
case 2://坦克向下
if (s.x > enemyTank.getX() && s.x < enemyTank.getX() + 40
&& s.y > enemyTank.getY() && s.y < enemyTank.getY() + 60) {
...
//当我方击毁一个敌人坦克后,就对数据allEnemyTankNum++
if(enemyTank instanceof EnemyTank){
Recorder.addAllEnemyTankNum();
}
....
}
break;
....
}
}
//在JFrame中
//增加响应关闭窗口的监听器
this.addWindowListener(new WindowAdapter() {
@Override
public void windowClosing(WindowEvent e) {
Recorder.keepRecord();
System.exit(0);
}
});
3、存档点
在Recorder中,当退出游戏的时候,记录敌人坦克的坐标和方向。
//Recorder update!!!!!!!
//记得要在MyPanel中指向一下
public class Recorder {
....
//定义Vector,指向敌人坦克Vecotr
private static Vector<EnemyTank> enemyTanks = null;
public static void setEnemyTanks(Vector<EnemyTank> enemyTanks) {
Recorder.enemyTanks = enemyTanks;
}
//当游戏退出时,我们将allEnemyTankNum保存到文件中
//增加,保存敌人坦克的坐标和方向
public static void keepRecord(){
try {
bw = new BufferedWriter(new FileWriter(recordFile));
bw.write(allEnemyTankNum+"\r\n");
//遍历Vector
//定义一个方法,然后通过setXxx得到敌人坦克的Vecotr
for (int i = 0; i < enemyTanks.size(); i++) {
//取出敌人坦克
EnemyTank enemyTank = enemyTanks.get(i);
if(enemyTank.isLive){
//保存该坦克信息
String record = enemyTank.getX()+" "+enemyTank.getY()+" "+enemyTank.getDirect();
//写入到文件
bw.write(record+"\r\n");
}
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if(bw!=null) {
bw.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
....
}
4、读档
将每个敌人信息,恢复成Node对象 => Vector。通过Node的Vector去恢复敌人坦克的位置和方向。
//Node add!!!!!!!!!!
public class Node {
private int x;
private int y;
private int direct;
public Node(int x, int y, int direct) {
this.x = x;
this.y = y;
this.direct = direct;
}
public int getX() {
return x;
}
public void setX(int x) {
this.x = x;
}
public int getY() {
return y;
}
public void setY(int y) {
this.y = y;
}
public int getDirect() {
return direct;
}
public void setDirect(int direct) {
this.direct = direct;
}
}
//Recorder update!!!!!!
public class Recorder {
.....
//定义一个Node的Vector,用于保存敌人的信息
private static Vector<Node> nodes = new Vector<>();
....
//用于读取recordFile,恢复相关信息
//该方法在继续上局游戏的时候调用
public static Vector<Node> getNodesAndEnemyTankRec(){
try {
br = new BufferedReader(new FileReader(recordFile));
allEnemyTankNum = Integer.parseInt(br.readLine());
//循环读取文件,拿到敌人坦克信息,生成Nodes
String line = "";
while((line = br.readLine())!=null){
String[] xyd = line.split(" ");
Node node = new Node(Integer.parseInt(xyd[0]), Integer.parseInt(xyd[1]),
Integer.parseInt(xyd[2]));
nodes.add(node);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if(br!=null){
br.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
return nodes;
}
.....
}
//MyPanel update!!!!!!!!
//定义Node,Vector,用于恢复敌人坦克对象
Vector<Node> nodes = null;
public MyPanel(String key) {
nodes = Recorder.getNodesAndEnemyTankRec();
//将敌人坦克Vector赋给Recorder
Recorder.setEnemyTanks(enemyTanks);
hero = new MyTank(250, 250);//初始化自己坦克
hero.setSpeed(5);
switch (key) {
case "1":
....
break;
case "2"://继续上局游戏
//初始化敌人坦克
for (int i = 0; i < nodes.size(); i++) {
//取出一个敌人坦克
Node node = nodes.get(i);
//创建敌人坦克
EnemyTank enemyTank = new EnemyTank(node.getX(), node.getY());
//将enemyTanks 设置给 enemyTank!!!!
enemyTank.setEnemyTanks(enemyTanks);
//设置方向
enemyTank.setDirect(node.getDirect());
//启动线程
new Thread(enemyTank).start();
//给该坦克加入一颗子弹
Shot shot = new Shot(enemyTank.getX() + 20, enemyTank.getY() + 60, enemyTank.getDirect());
//加入到enemyTank的Vector成员中
enemyTank.shots.add(shot);
//启动Shot线程
Thread thread = new Thread(shot);
thread.start();
//加入
enemyTanks.add(enemyTank);
}
break;
default:
System.out.println("你的输入有问题。。。。");
}
....
}
//JFrame update!!!!!!!
Scanner scanner = new Scanner(System.in);
System.out.println("请输入选择1:新游戏 2:继续上局");
String key = scanner.next();
mp = new MyPanel(key);
12、0.6版本更新
游戏开始时,播放经典的坦克大战音乐;
修正下文件存储位置;
处理文件相关异常。
1、打开音响
使用一个播放音乐的类,即可。
public class AePlayWave extends Thread{
private String filename;
public AePlayWave(String wavfile) {
filename = wavfile;
}
public void run() {
File soundFile = new File(filename);
AudioInputStream audioInputStream = null;
try {
//获得音频输入流
audioInputStream = AudioSystem.getAudioInputStream(soundFile);
} catch (Exception e1) {
e1.printStackTrace();
return;
}
//指定声音流中特定数据安排
AudioFormat format = audioInputStream.getFormat();
SourceDataLine auline = null;
DataLine.Info info = new DataLine.Info(SourceDataLine.class, format);
try {
//从混频器获得源数据行
auline = (SourceDataLine) AudioSystem.getLine(info);
//打开具有指定格式的行,这样可使行获得所有所需的系统资源并变得可操作。
auline.open(format);
} catch (Exception e) {
e.printStackTrace();
return;
}
//允许数据行执行数据 I/O
auline.start();
int nBytesRead = 0;
// 这是缓冲
byte[] abData = new byte[512];
try {
while (nBytesRead != -1) {
//从音频流读取指定的最大数量的数据字节,并将其放入给定的字节数组中
nBytesRead = audioInputStream.read(abData, 0, abData.length);
if (nBytesRead >= 0)
//通过此源数据行将音频数据写入混频器
auline.write(abData, 0, nBytesRead);
}
} catch (IOException e) {
e.printStackTrace();
return;
} finally {
auline.drain();
auline.close();
}
}
}
//MyPanel的MyPanel()中添一句
//播放指定的音乐
new AePlayWave("src\\111.wav").start();
//文件放在src目录下
2、修正
//把记录文件保存到 src 下
//private static String recordFile = "d:\\myRecord.txt";
private static String recordFile = "src\\myRecord.txt";
3、还是**的修正
防止记录文件找不到,无法开启游戏的尴尬。
//MyPanel() update!!!!!!
//先判断记录的文件是否存在
//如果存在,就正常执行,如果文件不存在,提示,只能开启新游戏,key=="1"
File file = new File(Recorder.getRecordFile());
if (key.equals("2") && !file.exists()) {
System.out.println("文件不存在,只能开启新游戏");
key = "1";
}