今天想将自己去年自己编写的坦克大战的代码与大家分享一下，主要面向学习过java但对java运用并不是很熟悉的同学，该编程代码基本上涉及了java基础知识的各个方面，大家可以通过练习该程序对自己的java进行一下实战。
每个程序版本代码中，都附有相关注释，看完注释大家就可以对本程序设计有个很明显的思路。真的很有趣，想对java重新温习的同学完全不必再对厚厚的java基础书籍进行阅读了，在跟着本次代码练习并分析后，大家一定会对java各方面基础知识 尤其是线程的知识有更深一步的了解！！！
本次坦克大战系列的各个版本都是在一步步的升级改进，难度逐渐加大，功能愈加完善；话不多说，先给大家分享一下代码(●ˇ∀ˇ●)
Tank大战 version1.0
实现功能：
1.绘制出我方Tank;
2.可以通过键盘上下左右键 控制移动；
package com.test; import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.*; import javax.swing.*; public class MyTankGame extends JFrame {
Mypanel mp=null;
public static void main(String[] args) {
// TODO 自动生成的方法存根
MyTankGame mtg=new MyTankGame();
}
//构造函数
public MyTankGame()
{
mp=new Mypanel();
this.add(mp);
this.setSize(800,600);
this.setVisible(true);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); } } //坦克类
class Tank
{
//表示坦克横坐标
int x=0;
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;
} //表示坦克纵坐标
int y=0; public Tank(int x,int y)
{
this.x=x;
this.y=y;
}
} //我的Tank
class Hero extends Tank
{ public Hero(int x, int y) {
super(x, y);
// TODO 自动生成的构造函数存根
} } //我的面板
class Mypanel extends JPanel
{
//定义一个我的坦克
Hero hero=null; //构造函数
public Mypanel()
{
hero=new Hero(100,100);
}
public void paint(Graphics g)
{
super.paint(g);
//设置面板背景色，全部填充即可，默认为黑色
g.fillRect(0, 0, 800, 600);
//画出我的tank，放到paint函数中
this.DrawTank(hero.getX(), hero.getY(), g,0,0);//hero.getX(), hero.getY()就将x,y传过去了
} //画出tank
public void DrawTank(int x,int y,Graphics g,int direct,int type)
{
//判断是什么类型坦克
switch(type)
{
case 0://我的tank
g.setColor(Color.cyan);
break;
case 1://敌人的tank
g.setColor(Color.orange);
break;
}
//判断坦克的方向
switch(direct)
{
//向上
case 0:
//画出左边矩形
g.fill3DRect(x, y, 5, 30, false);
//画出右边矩形
g.fill3DRect(x+15, y, 5, 30, false);
//画出中间矩形
g.fill3DRect(x+5, y+5, 10, 20, false);
//画出中间圆形
g.fillOval(x+5, y+10, 10, 10);
//画出中间直线
g.fillRect(x+9, y, 2, 10);
break;
}
}
} /*
画出左边矩形
g.fill3DRect(hero.getX(), hero.getY(), 5, 30, false);
//画出右边矩形
g.fill3DRect(hero.getX()+15, hero.getY(), 5, 30, false);
//画出中间矩形
g.fill3DRect(hero.getX()+5, hero.getY()+5, 10, 20, false);
//画出中间圆形
g.fillOval(hero.getX()+5, hero.getY()+10, 10, 10);
//画出中间直线
g.drawLine(hero.getX()+10, hero.getY()+15, 10, 20);
break; */
Tank大战 version2.0
java练习---->坦克大战2.0------>引入多线程
实现功能：
1.有敌方tank与我方tank;
2.我方tank可以控制移动；
3.我方tank可以发射炮弹；
4.敌方tank未作处理；
package TankGame2; import java.awt.*;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.util.*;
import javax.swing.*;
public class MyTankGame2 extends JFrame
{
MyPanel mp=null;
public static void main(String[] args)
{
MyTankGame2 mytankgame1=new MyTankGame2();
} public MyTankGame2()
{
mp=new MyPanel();
//启动mp线程 Thread t=new Thread(mp);
t.start(); this.add(mp);
this.addKeyListener(mp); this.setSize(400,300);
this.setVisible(true);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
}
} class MyPanel extends JPanel implements KeyListener,Runnable
{
//定义我的坦克，成员变量
Hero hero=null; //定义敌人的坦克组 Vector<EnemyTank> ets=new Vector<EnemyTank>();
int enSize=3; public void paint (Graphics g)
{
super.paint(g);
g.fillRect(0,0,400,300); //画出自己的坦克
this.drawTank(hero.getX(), hero.getY(), g, this.hero.direct, 1); //画出子弹
if (hero.s!=null&&hero.s.isLive==true)
{
g.draw3DRect(hero.s.x, hero.s.y, 1, 1, false); } //画出敌人的坦克
for(int i=0;i<ets.size();i++)
{ this.drawTank(ets.get(i).getX(),ets.get(i).getY(), g,ets.get(i).getDirect(), 0); } } //画出坦克函数（扩展）
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:
//画出我的坦克（到时候再封装成一个函数）
//1.画出左面的矩形
//g.drawRect(hero.getX(), hero.getY(), 5, 30);
g.fill3DRect(x,y,5,30,false); //2.画出右边的矩形
g.fill3DRect(x+15,y,5,30,false); //3.画出坦克的中间矩形
g.fill3DRect(x+5, y+5, 10, 20,false);
//画出中间的圆
g.fillOval(x+4, y+10,10,10);
//画出线
g.drawLine(x+9, y+15, x+9, y);
break;
case 1:
//炮筒向右
//画出上面的矩形
g.fill3DRect(x,y,30, 5, false);
g.fill3DRect(x, y+15, 30, 5, false);
g.fill3DRect(x+5, y+5, 20, 10, false);
g.fillOval(x+10, y+5, 10, 10);
g.drawLine(x+15, y+10, x+30, y+10); break;
case 2:
//向下
g.fill3DRect(x,y,5,30,false);
g.fill3DRect(x+15,y,5,30,false);
g.fill3DRect(x+5, y+5, 10, 20,false);
g.fillOval(x+4, y+10,10,10);
g.drawLine(x+10, y+15, x+10, y+30);
break; case 3:
//向左
g.fill3DRect(x,y,30, 5, false);
g.fill3DRect(x, y+15, 30, 5, false);
g.fill3DRect(x+5, y+5, 20, 10, false);
g.fillOval(x+10, y+5, 10, 10);
g.drawLine(x+15, y+10, x, y+10);
break;
} } public MyPanel()
{
hero=new Hero(100,100); //初始化敌人的坦克
for(int i=0;i<enSize;i++)
{
//创建敌人的坦克对象
EnemyTank et=new EnemyTank((i+1)*50,0);
et.setColor(0);
et.setDirect(2);
ets.add(et);
} } //键按下处理a表示左，s表示向下，w表示向上，d表示向右
public void keyPressed(KeyEvent e)
{
if(e.getKeyCode()==KeyEvent.VK_UP)
{
// 设置我的坦克的方向
this.hero.setDirect(0);
this.hero.moveUp();
} else if (e.getKeyCode()==KeyEvent.VK_DOWN)
{
this.hero.setDirect(2);
this.hero.moveDown();
} else if (e.getKeyCode()==KeyEvent.VK_RIGHT)
{
this.hero.setDirect(1);
this.hero.moveRight(); }
else if (e.getKeyCode()==KeyEvent.VK_LEFT)
{
this.hero.setDirect(3);
this.hero.moveLeft();
} if (e.getKeyCode()==KeyEvent.VK_SPACE)
{
this.hero.shotEnemy(); } //必须重新绘制Panel
this.repaint();
} public void keyReleased(KeyEvent e) //有什么用？！！！！！！！！！！！
{ }
public void keyTyped(KeyEvent e)
{ }
public void run()
{
//每个一百毫秒去重画子弹
while(true)
{
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
this.repaint(); }
} } class Tank
{ //设置坦克的速度
int speed=1;
public int getSpeed()
{
return speed;
}
public void setSpeed(int speed)
{
this.speed = speed;
}
//表示坦克的横坐标
int x=0;
//坦克的纵坐标
int y=0;
int direct=0;
int color; //坦克方向，0表示上，1表示右，2表示下，3表示左
public int getColor() {
return color;
}
public void setColor(int color) {
this.color = color;
}
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;
} } class EnemyTank extends Tank
{
public EnemyTank(int x,int y)
{
super(x,y); //super的用法？？？ }
} //我的坦克
class Hero extends Tank
{
//子弹
Shot s=null;
public Hero(int x, int y)
{
super(x,y);
}
//坦克向上移动 //坦克的开火的能力和动作
public void shotEnemy()
{
switch(this.direct)
{
case 0:
s=new Shot(x+9,y-1,0);
break;
case 1:
s=new Shot(x+30,y+10,1);
break;
case 2:
s=new Shot(x+9,y+30,2);
break;
case 3:
s=new Shot(x-1,y+9,3);
break;
} Thread t=new Thread(s);
t.start(); } public void moveUp()
{
this.y-=speed;
}
public void moveRight()
{
this.x+=speed;
} public void moveDown()
{
this.y+=speed;
}
public void moveLeft()
{
this.x-=speed;
}
} class Shot implements Runnable //runnable的用法？？？？
{
int x;
int y;
int direct;
int speed=1;
//是否活着 boolean isLive=true;
public Shot(int x,int y,int direct)
{
this.x=x;
this.y=y;
this.direct=direct;
}
public void run()
{
while(true)
{
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
} switch(direct)
{
case 0:
//向上
y-=speed;break;
case 1:
x+=speed;break;
case 2:
y+=speed;break;
case 3:
x-=speed;break; } //判断该子弹是否碰到边缘
if(x<0||x>400||y<0||y>300)
{
this.isLive=false;
break; } } }
}
Tank大战 version3.0
java练习---->坦克大战3.0
实现功能：
1.有敌方tank与我方tank;
2.我方tank可以控制移动，可以发射炮弹；
3.写一个函数专门判断子弹是否击中敌人坦克；
4.判断tank是否活着；
（注：本版本中，Tank是不可以发射炮弹的······）
package TankGame3; import java.awt.*;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.util.*;
import javax.swing.*;
import java.util.Vector;
public class MyTankGame4 extends JFrame
{
MyPanel mp=null;
public static void main(String[] args)
{
MyTankGame4 mytankgame1=new MyTankGame4();
} public MyTankGame4()
{
mp=new MyPanel();
//启动mp线程 Thread t=new Thread(mp);
t.start(); this.add(mp);
this.addKeyListener(mp); this.setSize(400,300);
this.setVisible(true);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
}
}
class MyPanel extends JPanel implements KeyListener,Runnable
{
//定义我的坦克，成员变量
Hero hero=null; //定义敌人的坦克组 Vector<EnemyTank> ets=new Vector<EnemyTank>();
int enSize=3; public void paint (Graphics g)
{
super.paint(g);
g.fillRect(0,0,400,300); //画出自己的坦克
this.drawTank(hero.getX(), hero.getY(), g, this.hero.direct, 1); //从Vector ss中取出每一颗子弹，并画出
for(int i=0;i<this.hero.ss.size();i++)
{
Shot myShot=hero.ss.get(i); //画出子弹,只画一颗子弹
if (myShot!=null&&myShot.isLive==true)
{
g.draw3DRect(myShot.x, myShot.y, 1, 1, false); }
if (myShot.isLive==false)
{
//从ss中删除该子弹
hero.ss.remove(myShot); }
} //画出敌人的坦克
for(int i=0;i<ets.size();i++)
{
EnemyTank et=ets.get(i);
if(et.isLive)
{
this.drawTank(ets.get(i).getX(),ets.get(i).getY(), g,ets.get(i).getDirect(), 0);
}
} } //写一个函数专门判断子弹是否击中敌人坦克
public void hitTank(Shot s,EnemyTank et)
{
//判断该坦克的方向
switch(et.direct)
{
//如果敌人的方向是上或者是下
case 0:
case 2:
if (s.x>et.x&&s.x<(et.x+20)&&s.y>et.y&&s.y<(et.y+30))
{
//击中了
//子弹死亡
s.isLive=false;
//敌人坦克也要死亡
et.isLive=false;
}
case 1:
case 3:
if (s.x>et.x&&s.x<(et.x+30)&&s.y>et.y&&s.y<(et.y+20))
{
//击中了
//子弹死亡
s.isLive=false;
//敌人坦克也要死亡
et.isLive=false; } } } //画出坦克函数（扩展）
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:
//画出我的坦克（到时候再封装成一个函数）
//1.画出左面的矩形
//g.drawRect(hero.getX(), hero.getY(), 5, 30);
g.fill3DRect(x,y,5,30,false); //2.画出右边的矩形
g.fill3DRect(x+15,y,5,30,false); //3.画出坦克的中间矩形
g.fill3DRect(x+5, y+5, 10, 20,false);
//画出中间的圆
g.fillOval(x+4, y+10,10,10);
//画出线
g.drawLine(x+9, y+15, x+9, y);
break;
case 1:
//炮筒向右
//画出上面的矩形
g.fill3DRect(x,y,30, 5, false);
g.fill3DRect(x, y+15, 30, 5, false);
g.fill3DRect(x+5, y+5, 20, 10, false);
g.fillOval(x+10, y+5, 10, 10);
g.drawLine(x+15, y+10, x+30, y+10); break;
case 2:
//向下
g.fill3DRect(x,y,5,30,false);
g.fill3DRect(x+15,y,5,30,false);
g.fill3DRect(x+5, y+5, 10, 20,false);
g.fillOval(x+4, y+10,10,10);
g.drawLine(x+10, y+15, x+10, y+30);
break; case 3:
//向左
g.fill3DRect(x,y,30, 5, false);
g.fill3DRect(x, y+15, 30, 5, false);
g.fill3DRect(x+5, y+5, 20, 10, false);
g.fillOval(x+10, y+5, 10, 10);
g.drawLine(x+15, y+10, x, y+10);
break;
} } public MyPanel()
{
hero=new Hero(100,100); //初始化敌人的坦克
for(int i=0;i<enSize;i++)
{
//创建敌人的坦克对象
EnemyTank et=new EnemyTank((i+1)*50,0);
et.setColor(0);
et.setDirect(2);
ets.add(et);
} } //键按下处理a表示左，s表示向下，w表示向上，d表示向右
public void keyPressed(KeyEvent e)
{
if(e.getKeyCode()==KeyEvent.VK_W)
{
// 设置我的坦克的方向
this.hero.setDirect(0);
this.hero.moveUp();
} else if (e.getKeyCode()==KeyEvent.VK_S)
{
this.hero.setDirect(2);
this.hero.moveDown();
} else if (e.getKeyCode()==KeyEvent.VK_D)
{
this.hero.setDirect(1);
this.hero.moveRight(); }
else if (e.getKeyCode()==KeyEvent.VK_A)
{
this.hero.setDirect(3);
this.hero.moveLeft();
} if (e.getKeyCode()==KeyEvent.VK_J)
{
this.hero.shotEnemy();
} //必须重新绘制Panel
this.repaint();
}
public void keyReleased(KeyEvent e)
{ }
public void keyTyped(KeyEvent e)
{ }
public void run()
{
//每个一百毫秒去重画子弹
while(true)
{
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} for(int i=0;i<hero.ss.size();i++)
{
Shot myShot=hero.ss.get(i);
//判断子弹是否有效
if(myShot.isLive)
{
//取出每个坦克，与它判断
for(int j=0;j<ets.size();j++)
{
//取出坦克
EnemyTank et=ets.get(j);
if(et.isLive)
{
this.hitTank(myShot,et); } } }
} this.repaint(); }
} } //package MyTankGame4;
//import java.util.Vector;
//import MyTankGame4.Shot;
//import MyTankGame4.Tank;
class Tank
{ //设置坦克的速度
int speed=1;
public int getSpeed()
{
return speed;
}
public void setSpeed(int speed)
{
this.speed = speed;
}
//表示坦克的横坐标
int x=0;
//坦克的纵坐标
int y=0;
int direct=0;
int color; //坦克方向，0表示上，1表示右，2表示下，3表示左
public int getColor() {
return color;
}
public void setColor(int color) {
this.color = color;
}
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;
} } class EnemyTank extends Tank
{
boolean isLive=true;
public EnemyTank(int x,int y)
{
super(x,y); }
} //我的坦克
class Hero extends Tank
{
//子弹
//Shot s=null;
Vector<Shot> ss=new Vector<Shot>();
Shot s=null; public Hero(int x, int y)
{
super(x,y);
}
//坦克向上移动 //坦克的开火的能力和动作
public void shotEnemy()
{
switch(this.direct)
{
case 0:
s=new Shot(x+9,y-1,0);
ss.add(s);
break;
case 1:
s=new Shot(x+30,y+10,1);
ss.add(s);
break;
case 2:
s=new Shot(x+9,y+30,2);
ss.add(s);
break;
case 3:
s=new Shot(x-1,y+9,3); ss.add(s);
ss.add(s);
break;
} Thread t=new Thread(s);
t.start(); } public void moveUp()
{
this.y-=speed;
}
public void moveRight()
{
this.x+=speed;
} public void moveDown()
{
this.y+=speed;
}
public void moveLeft()
{
this.x-=speed;
}
}
class Shot implements Runnable
{
int x;
int y;
int direct;
int speed=1;
//是否活着 boolean isLive=true;
public Shot(int x,int y,int direct)
{
this.x=x;
this.y=y;
this.direct=direct;
}
public void run()
{
while(true)
{
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
} switch(direct)
{
case 0:
//向上
y-=speed;break;
case 1:
x+=speed;break;
case 2:
y+=speed;break;
case 3:
x-=speed;break; } //判断该子弹是否碰到边缘
if(x<0||x>400||y<0||y>300)
{
this.isLive=false;
break; } } }
}
Tank大战 version4.0
java练习---->坦克大战4.0
实现功能：
1.有敌方tank与我方tank;
2.双方都可以控制移动，可以发射炮弹；
3.敌方坦克可以被击中消失
4.有爆炸效果；
5.可以计算生命值和炸弹生命；
package TankGame4;
//package MyTankGame4;
import java.util.Vector;
import java.awt.*;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.util.*;
import javax.swing.*;
public class MyTankGame4 extends JFrame
{
MyPanel mp=null;
public static void main(String[] args)
{
MyTankGame4 mytankgame1=new MyTankGame4();
} public MyTankGame4()
{
mp=new MyPanel();
//启动mp线程 Thread t=new Thread(mp); t.start(); this.add(mp);
this.addKeyListener(mp); this.setSize(400,300);
this.setVisible(true);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
}
}
class MyPanel extends JPanel implements KeyListener,Runnable
{
//定义我的坦克，成员变量
Hero hero=null; //定义敌人的坦克组 Vector<EnemyTank> ets=new Vector<EnemyTank>();
int enSize=5; //定义炸弹集合
Vector<Bomb> bombs=new Vector<Bomb>(); public void run()
{
//每个一百毫秒去重画子弹
while(true)
{
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} for(int i=0;i<hero.ss.size();i++)
{
Shot myShot=hero.ss.get(i);
//判断子弹是否有效
if(myShot.isLive)
{
//取出每个坦克，与它判断
for(int j=0;j<ets.size();j++)
{
//取出坦克
EnemyTank et=ets.get(j);
if(et.isLive)
{
this.hitTank(myShot,et); }
} }
} this.repaint();
//判断是否需要给坦克加入新的子弹
for(int i=0;i<ets.size();i++)
{
EnemyTank et=ets.get(i);
if(et.isLive)
{
if (et.ss.size()<5&&(int)(100*Math.random())>75)
{
//每辆坦克的子弹少于5发的话
//添加
Shot s=null;
switch(et.direct)
{
case 0:
s=new Shot(et.x+9,et.y-1,0);
et.ss.add(s);
break;
case 1:
s=new Shot(et.x+30,et.y+10,1);
et.ss.add(s);
break;
case 2:
s=new Shot(et.x+9,et.y+30,2);
et.ss.add(s);
break;
case 3:
s=new Shot(et.x-1,et.y+9,3);
et.ss.add(s);
break;
} //启动子弹线程
Thread t=new Thread(s);
t.start(); } }
} } } public void paint (Graphics g)
{
super.paint(g);
g.fillRect(0,0,400,300); //画出自己的坦克
this.drawTank(hero.getX(), hero.getY(), g, this.hero.direct, 1); //从Vector ss中取出每一颗子弹，并画出
for(int i=0;i<this.hero.ss.size();i++)
{
Shot myShot=hero.ss.get(i); //画出子弹,只画一颗子弹
if (myShot!=null&&myShot.isLive==true)
{
g.draw3DRect(myShot.x, myShot.y, 1, 1, false); }
if (myShot.isLive==false)
{
//从ss中删除该子弹
hero.ss.remove(myShot); }
} //画出炸弹
for(int i=0;i<bombs.size();i++)
{
// 取出炸弹
Bomb b=bombs.get(i); if(b.life>6)
{
g.drawImage(image1, b.x, b.y, 30,30,this);
}
else if(b.life>3)
{
g.drawImage(image2, b.x, b.y, 30,30,this);
}
else
{
g.drawImage(image3, b.x, b.y, 30,30,this);
}
//让b的生命值减小
b.lifeDown();
//如果炸弹的生命值为0，我们就剔除
if(b.life==0) bombs.remove(b); } //画出敌人的坦克
for(int i=0;i<ets.size();i++)
{
EnemyTank et=ets.get(i);
if(et.isLive)
{
this.drawTank(ets.get(i).getX(),ets.get(i).getY(), g,ets.get(i).getDirect(), 0);
//画出敌人的子弹 for(int j=0;j<et.ss.size();j++)
{
//取出子弹
Shot enemyShot=et.ss.get(j);
if(enemyShot.isLive)
{
g.draw3DRect(enemyShot.x, enemyShot.y, 1, 1, false);
}
else
{
//如果敌人的坦克死亡就从Vector去掉
et.ss.remove(enemyShot); } }
}
} } //写一个函数专门判断子弹是否击中敌人坦克
public void hitTank(Shot s,EnemyTank et)
{
//判断该坦克的方向
switch(et.direct)
{
//如果敌人的方向是上或者是下
case 0:
case 2:
if (s.x>et.x&&s.x<(et.x+20)&&s.y>et.y&&s.y<(et.y+30))
{
//击中了
//子弹死亡
s.isLive=false;
//敌人坦克也要死亡
et.isLive=false;
//创建一个炸弹，放入Vector
Bomb b=new Bomb(et.x,et.y);
//放入Vector
bombs.add(b);
}
case 1:
case 3:
if (s.x>et.x&&s.x<(et.x+30)&&s.y>et.y&&s.y<(et.y+20))
{
//击中了
//子弹死亡
s.isLive=false;
//敌人坦克也要死亡
et.isLive=false;
//创建一个炸弹，放入Vector
Bomb b=new Bomb(et.x,et.y);
//放入Vector
bombs.add(b);
} } } //画出坦克函数（扩展）
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:
//画出我的坦克（到时候再封装成一个函数）
//1.画出左面的矩形
//g.drawRect(hero.getX(), hero.getY(), 5, 30);
g.fill3DRect(x,y,5,30,false); //2.画出右边的矩形
g.fill3DRect(x+15,y,5,30,false); //3.画出坦克的中间矩形
g.fill3DRect(x+5, y+5, 10, 20,false);
//画出中间的圆
g.fillOval(x+4, y+10,10,10);
//画出线
g.drawLine(x+9, y+15, x+9, y);
break;
case 1:
//炮筒向右
//画出上面的矩形
g.fill3DRect(x,y,30, 5, false);
g.fill3DRect(x, y+15, 30, 5, false);
g.fill3DRect(x+5, y+5, 20, 10, false);
g.fillOval(x+10, y+5, 10, 10);
g.drawLine(x+15, y+10, x+30, y+10); break;
case 2:
//向下
g.fill3DRect(x,y,5,30,false);
g.fill3DRect(x+15,y,5,30,false);
g.fill3DRect(x+5, y+5, 10, 20,false);
g.fillOval(x+4, y+10,10,10);
g.drawLine(x+10, y+15, x+10, y+30);
break; case 3:
//向左
g.fill3DRect(x,y,30, 5, false);
g.fill3DRect(x, y+15, 30, 5, false);
g.fill3DRect(x+5, y+5, 20, 10, false);
g.fillOval(x+10, y+5, 10, 10);
g.drawLine(x+15, y+10, x, y+10);
break;
} } //定义三张图片,三张图片切换组成一颗炸弹
Image image1=null;
Image image2=null;
Image image3=null; //构造函数
public MyPanel()
{
hero=new Hero(100,100); //初始化敌人的坦克
for(int i=0;i<enSize;i++)
{
//创建敌人的坦克对象
EnemyTank et=new EnemyTank((i+1)*50,0);
et.setColor(0);
et.setDirect(2);
//启动敌人的坦克 Thread t=new Thread(et);
t.start();
//给敌人坦克添加一颗子弹
Shot s=new Shot(et.x+10,et.y+30,2);
et.ss.add(s);
Thread t2=new Thread(s);
t2.start();
//加入 ets.add(et);
} image1=Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/33.jpg"));
image2=Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/22.jpg"));
image3=Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/11.jpg")); } //键按下处理向左，向下，向上，向右
public void keyPressed(KeyEvent e)
{
if(e.getKeyCode()==KeyEvent.VK_UP)
{
// 设置我的坦克的方向
this.hero.setDirect(0);
this.hero.moveUp();
} else if (e.getKeyCode()==KeyEvent.VK_DOWN)
{
this.hero.setDirect(2);
this.hero.moveDown();
} else if (e.getKeyCode()==KeyEvent.VK_RIGHT)
{
this.hero.setDirect(1);
this.hero.moveRight(); }
else if (e.getKeyCode()==KeyEvent.VK_LEFT)
{
this.hero.setDirect(3);
this.hero.moveLeft();
} if (e.getKeyCode()==KeyEvent.VK_J)
{
this.hero.shotEnemy(); }
//必须重新绘制Panel
this.repaint();
}
public void keyReleased(KeyEvent e)
{ }
public void keyTyped(KeyEvent e)
{ } } class Tank
{ //设置坦克的速度
int speed=3;
public int getSpeed()
{
return speed;
}
public void setSpeed(int speed)
{
this.speed = speed;
}
//表示坦克的横坐标
int x=0;
//坦克的纵坐标
int y=0;
int direct=0;
int color; //坦克方向，0表示上，1表示右，2表示下，3表示左
public int getColor() {
return color;
}
public void setColor(int color) {
this.color = color;
}
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;
} } class EnemyTank extends Tank implements Runnable
{
boolean isLive=true; //定义一个向量，可以存放敌人的子弹 Vector<Shot> ss=new Vector<Shot>();
//敌人添加子弹应该在刚刚创建坦克和坦克子弹死亡之后 public EnemyTank(int x,int y)
{
super(x,y); }
public void run() {
while(true)
{ //移动前进
switch(this.direct)
{
case 0:
for(int i=0;i<(int)(100*Math.random());i++)
{
try
{
Thread.sleep(50);
}
catch (Exception e)
{
e.printStackTrace();
}
if(y>=speed)
{
y-=speed;
}
}
break;
case 1:
for(int i=0;i<(int)(100*Math.random());i++)
{
try
{
Thread.sleep(50);
}
catch (Exception e)
{
e.printStackTrace();
}
if(x<=400-(speed+30))
{
x+=speed;
}
}
break;
case 2:
for(int i=0;i<(int)(100*Math.random());i++)
{
try
{
Thread.sleep(50);
}
catch (Exception e)
{
e.printStackTrace();
}
if(y<=300-(speed+30))
{
y+=speed;
}
}
break;
case 3:
for(int i=0;i<(int)(100*Math.random());i++)
{
try
{
Thread.sleep(50);
}
catch (Exception e)
{
e.printStackTrace();
}
if(x>=speed)
{
x-=speed;
} }
break; } //让坦克随机产生一个新的方向
if(Math.random()>0.50)
this.direct=(int)(Math.random()*4); //判断敌人坦克是否死亡
if(this.isLive==false)
{
//让坦克死亡后，退出线程
break;
} } }
} //我的坦克
class Hero extends Tank
{
//子弹
//Shot s=null;
Vector<Shot> ss=new Vector<Shot>();
Shot s=null; public Hero(int x, int y)
{
super(x,y);
}
//坦克向上移动 //坦克的开火的能力和动作
public void shotEnemy()
{
switch(this.direct)
{
case 0:
s=new Shot(x+9,y-1,0);
ss.add(s);
break;
case 1:
s=new Shot(x+30,y+10,1);
ss.add(s);
break;
case 2:
s=new Shot(x+9,y+30,2);
ss.add(s);
break;
case 3:
s=new Shot(x-1,y+9,3); ss.add(s);
ss.add(s);
break;
} Thread t=new Thread(s);
t.start(); } public void moveUp()
{
this.y-=speed;
}
public void moveRight()
{
this.x+=speed;
} public void moveDown()
{
this.y+=speed;
}
public void moveLeft()
{
this.x-=speed;
}
} class Shot implements Runnable
{
int x;
int y;
int direct;
int speed=1;
//是否活着 boolean isLive=true;
public Shot(int x,int y,int direct)
{
this.x=x;
this.y=y;
this.direct=direct;
}
public void run()
{
while(true)
{
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
} switch(direct)
{
case 0:
//向上
y-=speed;break;
case 1:
x+=speed;break;
case 2:
y+=speed;break;
case 3:
x-=speed;break; } //子弹何时死亡？
//判断该子弹是否碰到边缘
if(x<0||x>400||y<0||y>300)
{
this.isLive=false;
break; } } }
}
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 {this.isLive=false;} } }
Tank大战 version5.0
java练习---->坦克大战5.0
实现功能：
1.在原有基础啊上进行优化和功能完善；
2.增加闯关功能等；
3.完结版！！！！！
package TankGame5; import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.*;
import java.io.*;
import java.util.Vector;
import javax.imageio.ImageIO;
import javax.swing.*; public class MyTankGame5 extends JFrame implements ActionListener
{
//声明一个标志
int flag=0;
// 声明一个运行面板
MyPanel mp=null;
//定义一个开始的面板
MyStartPanel msp=null; //做出我需要的菜单
JMenuBar jmb=null;
//开始游戏
JMenu jm1=null;
JMenuItem jmi1=null;
//退出系统
JMenuItem jmi2=null;
JMenuItem jmi3=null;
JMenuItem jmi4=null; public static void main(String[] args)
{
MyTankGame5 mytankgame1=new MyTankGame5();
mytankgame1.setLocationRelativeTo(null);//将JFrame设置在中间
// mytankgame1.setLocation(210,140);//设置JFrame的位置
} public MyTankGame5() //构造
{//初始化菜单栏
jmb=new JMenuBar();
jm1=new JMenu("游戏(G)"); //设置快捷方式
jm1.setMnemonic('G');
jmi1=new JMenuItem("开始新游戏(N)");
jmi2=new JMenuItem("退出游戏(E)");
jmi3=new JMenuItem("存盘退出(C)");
jmi4=new JMenuItem("继续上次游戏(L)"); jmi1.setMnemonic('N');
jmi2.setMnemonic('E');
jmi3.setMnemonic('C');
jmi4.setMnemonic('L'); //对jmi1响应，注册监听，标记消息源
jmi1.addActionListener(this);
jmi1.setActionCommand("new game"); jmi2.addActionListener(this);
jmi2.setActionCommand("exit"); jmi3.addActionListener(this);
jmi3.setActionCommand("save and exit"); jmi4.addActionListener(this);
jmi4.setActionCommand("continue game"); jm1.add(jmi1);
jm1.add(jmi2);
jm1.add(jmi3);
jm1.add(jmi4);
jmb.add(jm1); // 声明初始化面板 msp=new MyStartPanel(); Thread t=new Thread(msp);
t.start();
// 初始化窗口，构造函数的重点
this.setJMenuBar(jmb);//千万注意啊！！！！ this.add(msp);
this.setSize(400,300);
this.setVisible(true);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
}
public void actionPerformed(ActionEvent e)
{
//对用户不同的点击做出不同的处理
// 首先得到command字符串，判断消息源
if(e.getActionCommand().equals("new game"))
{
this.setSize(600,500);
mp=new MyPanel(flag);
//启动mp线程 Thread t1=new Thread(mp); t1.start();
//先删除旧的面板
this.remove(msp); this.add(mp);
//注册监听
this.addKeyListener(mp);
//显示
this.setVisible(true);
}
else if(e.getActionCommand().equals("exit"))
{
//用户退出
//保存击毁敌人数量
Recorder.keepRecording();
System.exit(0);
} else if(e.getActionCommand().equals("save and exit"))
{
Recorder.keepRecAndEnemyTank(mp.ets);
if(this.mp.hero.isLive==true)
{
Recorder.keepRecAndMyTank(this.mp.hero); }
System.exit(0);
}
else if(e.getActionCommand().equals("continue game"))
{
this.setSize(600,500);
flag=1;
mp=new MyPanel(flag);
//启动mp线程 Thread t1=new Thread(mp); t1.start();
//先删除旧的面板
this.remove(msp); this.add(mp);
//注册监听
this.addKeyListener(mp);
//显示
this.setVisible(true);
}
}
} //开始面板起一个提示的作用
class MyStartPanel extends JPanel implements Runnable
{
int times=0;
public void paint(Graphics g)
{
super.paint(g);
g.fillRect(0, 0, 400, 300);
//提示信息
if(times%2==0)
{
g.setColor(Color.yellow);
//开关信息的字体
try{
Font myFont=new Font("华文新魏",Font.BOLD,30);
g.setFont(myFont);
} catch(Exception e){e.printStackTrace();} g.drawString("stage:1", 150, 150);
}
}
public void run()
{
while(true)
{
try {
Thread.sleep(500);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
this.repaint();
times++;
if(times==1000) times=0;
}
} } class MyPanel extends JPanel implements KeyListener,Runnable
{
//定义我的坦克，成员变量
Hero hero=null; //判断是续上局还是新的游戏
String flag="newGame"; //定义敌人的坦克组 Vector<EnemyTank> ets=new Vector<EnemyTank>();
// 全局变量，声明，敌人坦克数量
static int enSize=5;
public static int getEnSize() {
return enSize;
}
//定义炸弹集合
Vector<Bomb> bombs=new Vector<Bomb>();
// paint 方法被面板适时自动调用
public void paint (Graphics g)
{
super.paint(g);
g.fillRect(0,0,400,300); //画出提示信息
this.showInfo(g); //画出自己的坦克
if(hero.isLive==true)
{
this.drawTank(hero.getX(), hero.getY(), g, this.hero.direct, 1);
}
//从Vector ss中取出每一颗子弹，并画出，如果有子弹
for(int i=0;i<this.hero.ss.size();i++)
{
Shot myShot=hero.ss.get(i); //画出子弹,只画一颗子弹
if (myShot!=null&&myShot.isLive==true)
{
g.draw3DRect(myShot.x, myShot.y, 1, 1, false); }
if (myShot.isLive==false)
{
//从ss中删除该子弹
hero.ss.remove(myShot); }
} //画出炸弹
for(int i=0;i<bombs.size();i++)
{
// 取出炸弹
Bomb b=bombs.get(i); if(b.life>6)
{
g.drawOval(b.x, b.y, 30, 30);
// g.drawImage(image1, b.x, b.y, 30,30,this);
}
else if(b.life>3)
{
g.drawOval(b.x, b.y, 20, 20);
// g.drawImage(image2, b.x, b.y, 30,30,this); }
else
{
g.drawOval(b.x, b.y, 10, 10);
// g.drawImage(image3, b.x, b.y, 30,30,this);
}
//让b的生命值减小
b.lifeDown();
//如果炸弹的生命值为0，我们就剔除
if(b.life==0) bombs.remove(b); } //画出敌人的坦克
for(int i=0;i<ets.size();i++)
{
EnemyTank et=ets.get(i);
if(et.isLive)
{
this.drawTank(ets.get(i).getX(),ets.get(i).getY(), g,ets.get(i).getDirect(), 0);
//画出敌人的子弹 for(int j=0;j<et.ss.size();j++)
{
//取出子弹
Shot enemyShot=et.ss.get(j);
if(enemyShot.isLive)
{
g.draw3DRect(enemyShot.x, enemyShot.y, 1, 1, false);
}
else
{
//如果敌人的坦克死亡就从Vector去掉
et.ss.remove(enemyShot); } }
}
} }
//判断我是否被击中了
public void hitMe()
{
//取出敌人的每一颗子弹 for(int i=0;i<this.ets.size();i++)
{
//取出坦克
EnemyTank et=ets.get(i); //取出每一颗子弹
for (int j=0;j<et.ss.size();j++)
{
//取出子弹
Shot enemyShot=et.ss.get(j);
if(hero.isLive)//&&Recorder.getMyLife()>=1
{
this.hitTank(enemyShot, hero);
//Recorder.setMyLife(Recorder.getMyLife()-1);
} } } } //判断我的子弹是否击中敌人的坦克
public void hitEnemyTank()
{
for(int i=0;i<hero.ss.size();i++)
{
Shot myShot=hero.ss.get(i);
//判断子弹是否有效
if(myShot.isLive)
{
//取出每个坦克，与它判断
for(int j=0;j<ets.size();j++)
{
//取出坦克
EnemyTank et=ets.get(j);
if(et.isLive)
{
this.hitTank(myShot,et); }
} }
} } //写一个函数专门判断子弹是否击中敌人坦克
public void hitTank(Shot s,Tank et)
{
//判断该坦克的方向
switch(et.direct)
{
//如果敌人的方向是上或者是下
case 0:
case 2:
if (s.x>et.x&&s.x<(et.x+20)&&s.y>et.y&&s.y<(et.y+30))
{
//击中了
//子弹死亡
s.isLive=false;
//敌人坦克也要死亡
et.isLive=false;
//减少敌人数量
if (et.getClass()==EnemyTank.class)//反射机制
{
Recorder.reduceEnNum();
//增加我的记录
Recorder.addEnNumRec();
} if (et.getClass()==Hero.class)//反射机制
{ }
//创建一个炸弹，放入Vector
Bomb b=new Bomb(et.x,et.y);
//放入Vector
bombs.add(b);
}
case 1:
case 3:
if (s.x>et.x&&s.x<(et.x+30)&&s.y>et.y&&s.y<(et.y+20))
{
//击中了
//子弹死亡
s.isLive=false;
//敌人坦克也要死亡
et.isLive=false;
//减少敌人数量
if (et.getClass()==EnemyTank.class)//反射机制
{
Recorder.reduceEnNum();
//增加我的记录
Recorder.addEnNumRec();
} if (et.getClass()==Hero.class)//反射机制
{
Recorder.setMyLife(Recorder.getMyLife() - 1);
}
//创建一个炸弹，放入Vector
Bomb b=new Bomb(et.x,et.y);
//放入Vector
bombs.add(b);
} } } //画出坦克函数（扩展）
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:
//画出我的坦克（到时候再封装成一个函数）
//1.画出左面的矩形
//g.drawRect(hero.getX(), hero.getY(), 5, 30);
g.fill3DRect(x,y,5,30,false); //2.画出右边的矩形
g.fill3DRect(x+15,y,5,30,false); //3.画出坦克的中间矩形
g.fill3DRect(x+5, y+5, 10, 20,false);
//画出中间的圆
g.fillOval(x+4, y+10,10,10);
//画出线
g.drawLine(x+9, y+15, x+9, y);
break;
case 1:
//炮筒向右
//画出上面的矩形
g.fill3DRect(x,y,30, 5, false);
g.fill3DRect(x, y+15, 30, 5, false);
g.fill3DRect(x+5, y+5, 20, 10, false);
g.fillOval(x+10, y+5, 10, 10);
g.drawLine(x+15, y+10, x+30, y+10); break;
case 2:
//向下
g.fill3DRect(x,y,5,30,false);
g.fill3DRect(x+15,y,5,30,false);
g.fill3DRect(x+5, y+5, 10, 20,false);
g.fillOval(x+4, y+10,10,10);
g.drawLine(x+10, y+15, x+10, y+30);
break; case 3:
//向左
g.fill3DRect(x,y,30, 5, false);
g.fill3DRect(x, y+15, 30, 5, false);
g.fill3DRect(x+5, y+5, 20, 10, false);
g.fillOval(x+10, y+5, 10, 10);
g.drawLine(x+15, y+10, x, y+10);
break;
} } public void run()
{
//每个一百毫秒去重画子弹
while(true)
{
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
} this.hitEnemyTank(); //函数，判断敌人的子弹是否击中我了
this.hitMe(); this.repaint();
//判断是否需要给坦克加入新的子弹
for(int i=0;i<ets.size();i++)
{
EnemyTank et=ets.get(i);
if(et.isLive)
{
if (et.ss.size()<3)
{
//没有子弹了
//添加
Shot s=null;
switch(et.direct)
{
case 0:
s=new Shot(et.x+9,et.y-1,0);
et.ss.add(s);
break;
case 1:
s=new Shot(et.x+30,et.y+10,1);
et.ss.add(s);
break;
case 2:
s=new Shot(et.x+9,et.y+30,2);
et.ss.add(s);
break;
case 3:
s=new Shot(et.x-1,et.y+9,3);
et.ss.add(s);
break;
} //启动子弹线程
Thread t=new Thread(s);
t.start();
}
}
}
}
}
//定义三张图片,三张图片切换组成一颗炸弹
Image image1=null;
Image image2=null;
Image image3=null;
int flagOfContinue;
//构造函数
public MyPanel(int flag)
{ this.flagOfContinue=flag;
//恢复记录
Recorder.getRecording(); if(this.flagOfContinue==0)
{
//如果不是继续上次就直接建一个
hero=new Hero(100,100);
//初始化敌人的坦克
for(int i=0;i<enSize;i++)
{
//创建敌人的坦克对象
EnemyTank et=new EnemyTank((i+1)*60,0);
et.setColor(0);
et.setDirect(2);
//将MyPanel的敌人坦克向量交给该敌人坦克
et.setEts(ets); //启动敌人的坦克 Thread t=new Thread(et);
t.start();
//给敌人坦克添加一颗子弹
Shot s=new Shot(et.x+10,et.y+30,2);
et.ss.add(s);
Thread t2=new Thread(s);
t2.start();
//加入 ets.add(et);
}
}
else if(this.flagOfContinue==1)
{
//如果是继续上次的就读取坐标
Vector<Node> nodes1=new Vector<Node>();
nodes1=Recorder.getNodes(); //初始化敌人的坦克
for(int i=0;i<nodes1.size();i++)
{
if(nodes1.get(i).type==0)
{
//创建敌人的坦克对象
EnemyTank et=new EnemyTank(nodes1.get(i).x,nodes1.get(i).y);
et.setColor(0);
et.setDirect(nodes1.get(i).direct);
//将MyPanel的敌人坦克向量交给该敌人坦克
et.setEts(ets); //启动敌人的坦克 Thread t=new Thread(et);
t.start();
//给敌人坦克添加一颗子弹
Shot s=new Shot(et.x+10,et.y+30,2);
et.ss.add(s);
Thread t2=new Thread(s);
t2.start();
//加入 ets.add(et);
}
else if(nodes1.get(i).type==1)
{
//如果保存有我上次的坦克的信息，就按照信息保存
hero=new Hero(nodes1.get(i).x,nodes1.get(i).y);
hero.setDirect(nodes1.get(i).direct);
}
} } // image1=Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/33.jpg"));//文件应该放在src文件夹里面
// image2=Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/22.jpg"));
// image3=Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/11.jpg"));
//关于图像我们使用好一点的方法，引入java.io.File;和java.io.IOException;
try
{
image1=ImageIO.read(new File("33.jpg"));//此时文件应该放在工程的根目录里面
image2=ImageIO.read(new File("22.jpg"));
image3=ImageIO.read(new File("11.jpg"));
}
catch (IOException e)
{
e.printStackTrace();
} }
//画出提示信息
public void showInfo(Graphics g)
{
//画出提示信息的坦克 ，该坦克不参加战斗
this.drawTank(80,330,g,0,0);
g.setColor(Color.black);
g.drawString(Recorder.getEnNum()+"",110,350); this.drawTank(150,330,g,0,1);
g.setColor(Color.black);
g.drawString(Recorder.getMyLife()+"",180,350);
//画出玩家的总成绩 g.setColor(Color.black);
try{
Font f=new Font("宋体",Font.BOLD,20);
g.setFont(f);
}catch(Exception e){ e.printStackTrace();}
g.drawString("您的总成绩：",420,40); this.drawTank(420, 60, g, 0, 0); g.setColor(Color.BLACK);
g.drawString(Recorder.getAllEnemy()+"",460,80); } //键按下处理a表示左，s表示向下，w表示向上，d表示向右
public void keyPressed(KeyEvent e)
{
if(hero.isLive)
{
if(e.getKeyCode()==KeyEvent.VK_UP&&hero.getY()>0)
{
// 设置我的坦克的方向
this.hero.setDirect(0);
this.hero.moveUp();
} else if (e.getKeyCode()==KeyEvent.VK_DOWN&&hero.getY()<270)
{
this.hero.setDirect(2);
this.hero.moveDown();
} else if (e.getKeyCode()==KeyEvent.VK_RIGHT&&hero.getX()<370)
{
this.hero.setDirect(1);
this.hero.moveRight(); }
else if (e.getKeyCode()==KeyEvent.VK_LEFT&&hero.getX()>0)
{
this.hero.setDirect(3);
this.hero.moveLeft();
} if (e.getKeyCode()==KeyEvent.VK_SPACE)
{
this.hero.shotEnemy();
} //必须重新绘制Panel
this.repaint();
}
}
public void keyReleased(KeyEvent e)
{ }
public void keyTyped(KeyEvent e)
{ } } //---------------------------------------------------- class Node
{
int x;
int y;
int direct;
int type;
public Node(int x,int y,int direct,int type)
{
this.x=x;
this.y=y;
this.direct=direct;
this.type=type;
} } //记录类
class Recorder
{
public static int getEnNum() {
return enNum;
}
public static void setEnNum(int enNum) {
Recorder.enNum = enNum;
}
public static int getMyLife() {
return myLife;
}
public static void setMyLife(int myLife) {
Recorder.myLife = myLife;
}
//记录每关多少敌人
private static int enNum=MyPanel.getEnSize();
//设置我有多少可以用的人
public static int myLife=3;
//记录总共消灭了多少敌人
private static int allEnNum=0;
//从文件中恢复记录点
static Vector<Node> nodes=new Vector<Node>();
private static FileWriter fw=null;
private static BufferedWriter bw=null;
private static FileReader fr=null;
private static BufferedReader br=null; public static Vector<Node> getNodes()
{
try {
fr=new FileReader("d:\\myRecording.txt");
br=new BufferedReader(fr);
String n=""; n=br.readLine();//读第一行
allEnNum=Integer.parseInt(n);
while((n=br.readLine())!=null)
{
String []xyz=n.split(" ");//按照空格返回数组，新技能
Node node=new Node(Integer.parseInt(xyz[0]),Integer.parseInt(xyz[1]),Integer.parseInt(xyz[2]),Integer.parseInt(xyz[3]));
nodes.add(node);
}
} catch (Exception e)
{
e.printStackTrace();
}
finally
{
try {
br.close();
fr.close();
} catch (Exception e) {
e.printStackTrace();
}
}
return nodes;
}
public static void keepRecAndEnemyTank(Vector<EnemyTank> ets)
{
try
{
//创建
fw=new FileWriter("d:\\myRecording.txt");
bw=new BufferedWriter(fw); bw.write(allEnNum+"\r\n"); //保存当前还活着的敌人坐标和方向
for(int i=0;i<ets.size();i++)
{
//取出第一个坦克
EnemyTank et=ets.get(i);
if(et.isLive)
{
//活着的保存
String record=et.x+" "+et.y+" "+et.direct+" "+0;
//写入
bw.write(record+"\r\n");
}
} }
catch (Exception e)
{
e.printStackTrace();
}
finally
{
//关闭流
try {
//谁先开谁后关
bw.close();
fw.close();
} catch (Exception e2) {
}
} } public static void keepRecAndMyTank(Hero hero)
{
try
{
//创建
fw=new FileWriter("d:\\myRecording.txt",true);//追加
bw=new BufferedWriter(fw); //保存当前我的坐标和方向
String record=hero.x+" "+hero.y+" "+hero.direct+" "+1;
//写入
bw.write(record+"\r\n"); } catch (Exception e)
{
e.printStackTrace();
}
finally
{
//关闭流
try
{
//谁先开谁后关
bw.close();
fw.close();
}
catch (Exception e2)
{
e2.printStackTrace();
}
} } //从文件中读取记录
public static void getRecording()
{
try {
fr=new FileReader("d:\\myRecording.txt");
br=new BufferedReader(fr);
String n=br.readLine();
allEnNum=Integer.parseInt(n);
}
catch (Exception e)
{
e.printStackTrace();
}
finally
{
try {
br.close();
fr.close();
} catch (Exception e) {
e.printStackTrace();
}
} }
//把玩家击毁敌人的坦克数量保存到文件中
public static void keepRecording()
{
try
{
//创建
fw=new FileWriter("d:\\myRecording.txt");
bw=new BufferedWriter(fw); bw.write(allEnNum+"\r\n");
}
catch (Exception e)
{
e.printStackTrace();
}
finally
{
//关闭流
try {
//谁先开谁后关
bw.close();
fw.close();
} catch (Exception e2) {
}
}
} public static int getAllEnemy() {
return allEnNum;
}
public static void reduceEnNum()
{
enNum--;
} //消灭敌人
public static void addEnNumRec()
{
allEnNum++;
} } 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 {this.isLive=false;} }
} class Tank
{ //设置坦克的速度
int speed=3;
public int getSpeed()
{
return speed;
}
public void setSpeed(int speed)
{
this.speed = speed;
}
//表示坦克的横坐标
int x=0;
//坦克的纵坐标
int y=0;
int direct=0;
int color;
boolean isLive=true; //坦克方向，0表示上，1表示右，2表示下，3表示左
public int getColor() {
return color;
}
public void setColor(int color) {
this.color = color;
}
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;
} } class EnemyTank extends Tank implements Runnable
{
//定义一个向量，可以访问到MyPanel上所有敌人的坦克
Vector<EnemyTank> ets=new Vector<EnemyTank>(); //定义一个向量，可以存放敌人的子弹 Vector<Shot> ss=new Vector<Shot>();
//敌人添加子弹应该在刚刚创建坦克和坦克子弹死亡之后
public EnemyTank(int x,int y)
{
super(x,y);
} //得到MyPanel的敌人坦克向量
public void setEts(Vector<EnemyTank> vv)
{
this.ets=vv; } //判断是否碰到了别人的坦克
public boolean isTouchOtherEnemy()
{
boolean b=false; switch(this.direct)
{
case 0: //我的坦克向上
//取出所有的敌人坦克
for(int i=0;i<ets.size();i++)
{
//取出第一个坦克
EnemyTank et=ets.get(i);
//如果不是自己
if(et!=this)
{
//如果敌人的方向向上或者是向下
if(et.direct==0||et.direct==2)
{
if(this.x>=et.x&&this.x<=et.x+20&&this.y>=et.y&&this.y<=et.y+30)
{
return true;
}
if(this.x+20>=et.x&&this.x<=et.x+20&&this.y>=et.y&&this.y<=et.y+30)
{
return true;
} } if(et.direct==1||et.direct==3)
{
if(this.x>=et.x&&this.x<=et.x+30&&this.y>=et.y&&this.y<=et.y+20)
{
return true;
}
if(this.x+20>=et.x && this.x+20<=et.x+30&&this.y>=et.y&&this.y<=et.y+30)
{
return true;
}
}
} } break;
case 1:
//坦克向右
//取出所有的敌人坦克
for(int i=0;i<ets.size();i++)
{
//取出第一个坦克
EnemyTank et=ets.get(i);
//如果不是自己
if(et!=this)
{
//如果敌人的方向向上或者是向下
if(et.direct==0||et.direct==2)
{
if(this.x+30>=et.x&&this.x+30<=et.x+20&&this.y>=et.y&&this.y<=et.y+30)
{
return true;
}
if(this.x+30>=et.x&&this.x+30<=et.x+20&&this.y+20>=et.y&&this.y+20<=et.y+30)
{
return true;
} } if(et.direct==1||et.direct==3)
{
if(this.x+30>=et.x&&this.x+30<=et.x+30&&this.y>=et.y&&this.y<=et.y+20)
{
return true;
}
if(this.x+30>=et.x && this.x+30<=et.x+30&&this.y+20>=et.y&&this.y+20<=et.y+20)
{
return true;
}
}
} } case 2:
//坦克向下
//取出所有的敌人坦克
for(int i=0;i<ets.size();i++)
{
//取出第一个坦克
EnemyTank et=ets.get(i);
//如果不是自己
if(et!=this)
{
//如果敌人的方向向上或者是向下
if(et.direct==0||et.direct==2)
{
if(this.x>=et.x&&this.x<=et.x+20&&this.y+30>=et.y&&this.y+30<=et.y+30)
{
return true;
}
if(this.x+20>=et.x&&this.x<=et.x+20&&this.y+30>=et.y&&this.y+30<=et.y+30)
{
return true;
} } if(et.direct==1||et.direct==3)
{
if(this.x+20>=et.x&&this.x+20<=et.x+30&&this.y+30>=et.y&&this.y+30<=et.y+20)
{
return true;
}
if(this.x+20>=et.x && this.x+20<=et.x+30&&this.y+30>=et.y&&this.y+30<=et.y+30)
{
return true;
}
}
} }
break;
case 3 :
//坦克向左
//取出所有的敌人坦克
for(int i=0;i<ets.size();i++)
{
//取出第一个坦克
EnemyTank et=ets.get(i);
//如果不是自己
if(et!=this)
{
//如果敌人的方向向上或者是向下
if(et.direct==0||et.direct==2)
{
if(this.x>=et.x&&this.x<=et.x+20&&this.y>=et.y&&this.y<=et.y+30)
{
return true;
}
if(this.x>=et.x&&this.x<=et.x+20&&this.y>=et.y&&this.y<=et.y+30)
{
return true;
} } if(et.direct==1||et.direct==3)
{
if(this.x>=et.x&&this.x<=et.x+30&&this.y+20>=et.y&&this.y+20<=et.y+20)
{
return true;
}
if(this.x>=et.x && this.x<=et.x+30&&this.y+20>=et.y&&this.y+20<=et.y+20)
{
return true;
}
}
} }
} return b;
} public void run() {
while(true)
{
switch(this.direct)
{
case 0:
for(int i=0;i<(int)(100*Math.random());i++)
{
try
{
Thread.sleep(50);
}
catch (Exception e)
{
e.printStackTrace();
}
if(y>=speed && !this.isTouchOtherEnemy())
{
y-=speed;
}
}
break;
case 1:
for(int i=0;i<(int)(100*Math.random());i++)
{
try
{
Thread.sleep(50);
}
catch (Exception e)
{
e.printStackTrace();
}
if(x<=(400-(speed+30))&& !this.isTouchOtherEnemy())
{
x+=speed;
}
}
break;
case 2:
for(int i=0;i<(int)(100*Math.random());i++)
{
try
{
Thread.sleep(50);
}
catch (Exception e)
{
e.printStackTrace();
}
if(y<=(300-(speed+30))&& !this.isTouchOtherEnemy())
{
y+=speed;
}
}
break;
case 3:
for(int i=0;i<(int)(100*Math.random());i++)
{
try
{
Thread.sleep(50);
}
catch (Exception e)
{
e.printStackTrace();
}
if(x>=speed && !this.isTouchOtherEnemy())
{
x-=speed;
} }
break; } //让坦克随机产生一个新的方向
this.direct=(int)(Math.random()*4); //判断敌人坦克是否死亡
if(this.isLive==false)
{
//让坦克死亡后，退出线程
break;
} } }
} //我的坦克
class Hero extends Tank
{
//子弹
//Shot s=null;
Vector<Shot> ss=new Vector<Shot>();
Shot s=null; public Hero(int x, int y)
{
super(x,y);
}
//坦克向上移动 //坦克的开火的能力和动作
public void shotEnemy()
{
switch(this.direct)
{
case 0:
s=new Shot(x+9,y-1,0);
ss.add(s);
break;
case 1:
s=new Shot(x+30,y+10,1);
ss.add(s);
break;
case 2:
s=new Shot(x+9,y+30,2);
ss.add(s);
break;
case 3:
s=new Shot(x-1,y+9,3); ss.add(s);
ss.add(s);
break;
} Thread t=new Thread(s);
t.start(); } public void moveUp()
{
this.y-=speed;
}
public void moveRight()
{
this.x+=speed;
} public void moveDown()
{
this.y+=speed;
}
public void moveLeft()
{
this.x-=speed;
}
} class Shot implements Runnable
{
int x;
int y;
int direct;
int speed=2;
//是否活着 boolean isLive=true;
public Shot(int x,int y,int direct)
{
this.x=x;
this.y=y;
this.direct=direct;
}
public void run()
{
while(true)
{
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
} switch(direct)
{
case 0:
//向上
y-=speed;break;
case 1:
x+=speed;break;
case 2:
y+=speed;break;
case 3:
x-=speed;break; } //子弹何时死亡？
//判断该子弹是否碰到边缘
if(x<0||x>400||y<0||y>300)
{
this.isLive=false;
break; } } }
}
注：如果大家很多java基础内容不是很清楚，可以观看韩顺平的java学习视频，跟着教程做程序，效果很明显！(●ˇ∀ˇ●)