（1）我方Tank：

按J键可发射子弹，每次最多发射5颗子弹；

按K键可发射导弹（数量有限）；

按M键可发射核弹（数量有限）；

我方Tank可以由玩家控制移动方向，W、S、A、D代表上、下、左、右四个方向；

我方Tank有3条命，被敌方Tank子弹击中后会伤害一条生命值，若三条命都被击中则游戏结束；我方Tank击中所有敌方Tank游戏结束，玩家胜利。

（2）敌方Tank1：

敌方Tank1刚开局时产生15辆，横坐标为0，间隔50，随机分布，敌

方由Random类控制方向，随机移动；敌方Tank1被我方Tank子弹击    中两次后消失。

敌方Tank2：

每一辆敌方Tank1被击中消失，随机产生一辆敌方Tank2，功能同敌方Tank1， 敌方tank2被玩家Tank子弹击中3次后消失。

（3）Tank道具：

子弹：击中物体可产生爆炸效果；

子弹速度为8像素。

导弹：击中物体可产生爆炸效果，产生大面积伤害；

导弹速度为8像素。

核弹：清除当前屏幕下所有敌方Tank数量。

（4）可击破障碍物：

被任意一方Tank子弹击中后产生爆炸效果并消失。

（5）不可击破障碍物：

被任意一方Tank子弹击中后产生爆炸效果，不会消失。

（6）我方总部：

周围有可击破障碍物保护，当总部图标被Tank子弹击中，游戏结束。

在该项目中，主要运用了对javase里边GUI的一些运用，通过画板和画笔原理，一帧一帧绘制游戏。游戏中每个坦克包括玩家坦克和地方坦克都是一个单独的个体，对敌方坦克进行随机方向运动处理，利用随机函数，首先随机生成地方坦克的前进方向，并随机判断出敌方坦克是否发射子弹。

//坦克类
class Tank{
int x;
int y;
int direct;
    int speed=8;  
    boolean isLive=true;
public Tank(int x,int y){
this.x=x;
this.y=y;
}
public void moveUp(){
y-=speed;
if(y<0){
y=0;
}
}
public void moveDown(){
y+=speed;
if(y>570){
y=570;
}
}
public void moveLeft(){
x-=speed;
if(x<0){
x=0;
}
}
public void moveRight(){
x+=speed;
if(x>690){
x=690;
}
}
public int getX(){
return x;
}
public int getY(){
return y;
}
public void setDirect(int direct){
this.direct=direct;
}
public int getDirect(){
return direct;
}
public boolean isAcross(){
return false;
}
}
//玩家坦克类
class Hero extends Tank{
//定义子弹集合
Vector<Shot> ss=new Vector<Shot>();
Shot s=null;
//定义导弹集合
Vector<Missile> mis=new Vector<Missile>();
Missile missile=null;
int misSize=5;

//定义大炸弹数量
int c4=1;

int life=3;
public Hero(int x,int y){
super(x,y);
}
public void lifeDown(){
if(life>0){
life--;
}else{
this.isLive=false;
}
}
public void shotEnemy(){
s=new Shot(x,y,direct);
ss.add(s);
Thread t=new Thread(s);
t.start();
}
public void missileEnemy(){
if(this.misSize>0){
missile=new Missile(x,y,direct);
mis.add(missile);
Thread t=new Thread(missile);
t.start();
misSize--;
}
}
}
//敌人坦克类
class Enemy extends Tank implements Runnable{ //敌人坦克
int type;
int direct=1;
int life=1;
boolean begin=false;
Vector<Shot> es=new Vector<Shot>();
Shot enemyShot=null;//敌人子弹

Random r=new Random();

public Enemy(int x,int y,int type){
super(x,y);
this.type=type;
if(type==0){
life=1;
}
else if(type==1){
life=2;
}
}
public void lifeDown(){
if(life>0){
life--;
}
else{
isLive=false;
}
}
public int getType(){
return type;
}
public void run() {
while(isLive){
try{
Thread.sleep(200);
}catch (InterruptedException e){
e.printStackTrace();
}
if(this.begin){
if(r.nextInt(4)==1)
{
direct=r.nextInt(4);
}
switch(direct){
case 0:this.moveUp();break;
case 1:this.moveDown();break;
case 2:this.moveLeft();break;
case 3:this.moveRight();break;
}

if(r.nextInt(4)==1&&es.size()<2){
enemyShot=new Shot(x,y,direct);
es.add(enemyShot);
Thread t=new Thread(enemyShot);
t.start();
}
}

}
}
}
//子弹类
class Shot implements Runnable{
int x;//子弹初始坐标
int y;
int direct;//子弹发射方向
int speed=8;//子弹速度
boolean isLive=true;
public Shot(int x,int y,int direct){
switch(direct){
case 0:
this.x=x+15;
this.y=y-4;
break;
case 1:
this.x=x+15;
this.y=y+34;
break;
case 2:
this.x=x-4;
this.y=y+15;
break;
case 3:
this.x=x+34;
this.y=y+15;
break;
}
this.direct=direct;
}
public int getX(){
return x;
}
public int getY(){
return y;
}
public void run() {
while(isLive){
try{
Thread.sleep(60);
}catch (InterruptedException e){
e.printStackTrace();
}
switch(direct){
case 0:
y-=speed;
break;
case 1:
y+=speed;
break;
case 2:
x-=speed;
break;
case 3:
x+=speed;
break;
}
//子弹是否撞到墙壁
if(x<0||x>700||y<0||y>600){
isLive=false;
break;
}
//子弹是否击中敌方坦克
if(isLive==false){
break;
}
//子弹是否击中场景物品
}

}
}

通过一个坦克基类派生出玩家坦克类和地方坦克类，坦克基类包含了玩家坦克和地方坦克的共有属性和共有属性方法。

在游戏中会进行大量的碰撞处理，通过坐标，检测游戏中的物体与物体是否具有重叠面积，以此来判断出物体与物体是否相撞，并在某一方向上碰撞后停止前进。

//判断坦克是否撞击到墙体
public void strikeWall(){
//判断玩家是否撞到某一墙体
for(int i=0;i<walls.size();i++){
Wall wall=walls.get(i);
this.heroStrikeWall(this.hero, wall);
}
//判断敌人坦克是否撞击到墙体
for(int i=0;i<ets.size();i++){
Enemy enemy=ets.get(i);
if(enemy.isLive==true){
for(int j=0;j<walls.size();j++){
Wall wall=walls.get(j);
this.enemyStrikeWall(enemy, wall);
}
}
}
}
//判断玩家是否撞到某一墙体
public void heroStrikeWall(Hero hero,Wall wall){
switch(hero.direct){
case 0:
if((hero.x>wall.x&&hero.x<wall.x+40||hero.x+30>wall.x&&hero.x+30<wall.x+40)&&hero.y>wall.y&&hero.y<wall.y+40){
//撞击到墙体
hero.y=wall.y+40;
}
break;
case 1:
if((hero.x>wall.x&&hero.x<wall.x+40||hero.x+30>wall.x&&hero.x+30<wall.x+40)&&hero.y+30>wall.y&&hero.y+30<wall.y+40){
hero.y=wall.y-30;
}
break;
case 2:
if(hero.x>wall.x&&hero.x<wall.x+40&&(hero.y>wall.y&&hero.y<wall.y+40||hero.y+30>wall.y&&hero.y+30<wall.y+40)){
hero.x=wall.x+40;
}
break;
case 3:
if(hero.x+30>wall.x&&hero.x+30<wall.x+40&&(hero.y>wall.y&&hero.y<wall.y+40||hero.y+30>wall.y&&hero.y+30<wall.y+40)){
hero.x=wall.x-30;
}
break;
}
}