坦克大战---可能带BUG

原创

a7272706 2013-11-07 00:02:49 博主文章分类：Java小案例 ©著作权

文章标签 java 代码游戏 package 文章分类 Java 后端开发

©著作权归作者所有：来自51CTO博客作者a7272706的原创作品，请联系作者获取转载授权，否则将追究法律责任

坦克体积缩小
坦克相互攻击
无敌模式
数量超过3000停止增加
由于坦克×××是共享的数组类型容易抛异常，限制为只有3个敌坦克可发弹
纯属娱乐

/***************************MyWar.java*****************************/

package tank;

import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.util.Arrays;
import java.util.Random;
import java.util.Timer;
import java.util.TimerTask;

import javax.swing.JFrame;
import javax.swing.JPanel;

public class MyWar {
public static void main(String[] args) {
JFrame frame = new JFrame("坦克大战");// 新建一个窗口
War war = new War();// 创建一个War类的对象
frame.add(war);// 把war添加到窗口中
frame.setSize(750, 530);// 窗口宽高
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);// 关闭时结束进程
frame.setLocationRelativeTo(null);// 使窗口居中
frame.setVisible(true);// 这句是干啥的?
war.action();// 启动(war)战斗,亲,可以游戏了!
}
}

class War extends JPanel {
private boolean sUp, sDown, sRight, sLeft, sH;// 定义右边坦克按键的开关
private boolean sW, sD, sS, sA, sL;// 定义左边坦克按键的开关
public static final int WIDTH = 750;// 定义地图宽度
public static final int HEIGHT = 530;// 定义地图高度
private int score;// 设置分数
private boolean gameOver;// gameover=false表示游戏没有结束
private Timer timer;// 刚学的东西
private int shootNum, shootNum1;// 可以射击的×××数,防止作弊
MyTank[] myTank = new MyTank[2];// 定义一个我方坦克对象数组
EnemyTanks[] enemyTank = new EnemyTanks[5];// 初始化敌人坦克的数量
EnemyTanks newEnemyTank;// 用来产生一辆敌人的坦克,补充死去的T_T
Random r = new Random();

/** 用于产生一辆新的敌人坦克,返回参数是EnemyTanks类型 */
public EnemyTanks nextTank() {
int x = r.nextInt(2) * WIDTH;// 随机x的值,坦克出生在角落
int y = r.nextInt(2) * HEIGHT;// 随机y的值,坦克出生在角落
int step = r.nextInt(4) + 1;// 速度
int direct = r.nextInt(4) + 1;// 方向
int who = r.nextInt(3) + 1;// 谁?
newEnemyTank = new EnemyTanks(x, y, step, direct, who, true);
return newEnemyTank;// 返回一个新坦克
}

public void action() {
startGame();// 开始游戏函数
KeyAdapter l = new KeyAdapter() {// 键盘监听
public void keyPressed(KeyEvent e) {
int key = e.getKeyCode();
if (key == KeyEvent.VK_Q) {
System.exit(0);// Q关闭进程结束游戏
}
if (gameOver) {
if (key == KeyEvent.VK_Y) {
startGame();// Y键开始游戏
}
return;
}
switch (key) {
case KeyEvent.VK_W:
sW = true;
break;
case KeyEvent.VK_A:
sA = true;
break;
case KeyEvent.VK_D:
sD = true;
break;
case KeyEvent.VK_S:
sS = true;
break;
case KeyEvent.VK_L:
sL = true;
break;
case KeyEvent.VK_RIGHT:
sRight = true;
break;
case KeyEvent.VK_LEFT:
sLeft = true;
break;
case KeyEvent.VK_DOWN:
sDown = true;
break;
case KeyEvent.VK_UP:
sUp = true;
break;
case KeyEvent.VK_H:
sH = true;
break;
}
repaint();
}

public void keyReleased(KeyEvent e) {
int key = e.getKeyCode();
switch (key) {
case KeyEvent.VK_W:
sW = false;
break;
case KeyEvent.VK_A:
sA = false;
break;
case KeyEvent.VK_D:
sD = false;
break;
case KeyEvent.VK_S:
sS = false;
break;
case KeyEvent.VK_H:
sH = false;
break;
case KeyEvent.VK_RIGHT:
sRight = false;
break;
case KeyEvent.VK_LEFT:
sLeft = false;
break;
case KeyEvent.VK_DOWN:
sDown = false;
break;
case KeyEvent.VK_UP:
sUp = false;
break;
case KeyEvent.VK_L:
sL = false;
break;
}
}
};
this.requestFocus();
this.addKeyListener(l);

}

public void level() {// 每5分增加一辆敌人的坦克
// int length = score/5+5;
int length = score + 5;
if (length > enemyTank.length) {
enemyTank = Arrays.copyOf(enemyTank, enemyTank.length + 1);// 坦克数组扩容
enemyTank[enemyTank.length - 1] = nextTank();// 初始化数组最后的一辆坦克
enemyTank[enemyTank.length - 1].start();// 启动这个坦克的线程
}
}

public void startGame() {
cleanShoot();// 清空×××
shootNum = 5;// 可以发射的×××数为5
shootNum1 = 5;
score = 0;
myTank[0] = new MyTank(550, 370, 4, 1, -1, true);// 初始化我的坦克
myTank[1] = new MyTank(100, 100, 4, 1, 0, true);
for (int i = 0; i < enemyTank.length; i++) {// 初始化敌人的坦克
if (gameOver) {// 游戏结束,关闭每个坦克的线程
enemyTank[i].s = false;
}
}
enemyTank = new EnemyTanks[5];
for (int i = 0; i < enemyTank.length; i++) {// 初始化敌人的坦克
enemyTank[i] = nextTank();
}
gameOver = false;// 游戏没有结束,表示开始
myTank[0].start();// 启动我的坦克线程
myTank[1].start();
for (int i = 0; i < enemyTank.length; i++) {// 启动敌人坦克线程
enemyTank[i].start();
}
timer = new Timer();// 匿名内部类Timer
timer.schedule(new TimerTask() {
public void run() {// 重写run()函数
repaint();
shootAndRun();
}
}, 0, 50);// 50毫秒执行一次
}

/** 检查游戏是否结束 */
public void checkGameOver() {// 模仿俄罗斯方块里面写的
if (myTank[0].isLive() || myTank[1].isLive()) {
return;
}
gameOver = true;
// gameOver = true;
timer.cancel();
repaint();
}

public void shootAndRun() {
if (sW) {// 如果开关sW=true就执行{}里面的代码
myTank[1].moveUp();
} else if (sD) {
myTank[1].moveRight();
} else if (sS) {
myTank[1].moveDown();
} else if (sA) {
myTank[1].moveLeft();
}
if (sH && myTank[1].isLive()) {// 如果sL=true并且坦克是活的,就执行
if (shootNum1 >= 0) {// 如果允许的×××数小于于0了,不执行
myTank[1].shoot();
shootNum1--;// 控制×××数量,射击一次,×××减少,消失加1
}
}
if (sUp) {
myTank[0].moveUp();
} else if (sRight) {
myTank[0].moveRight();
} else if (sLeft) {
myTank[0].moveLeft();
} else if (sDown) {
myTank[0].moveDown();
}
if (sL && myTank[0].isLive()) {
if (shootNum >= 0) {
myTank[0].shoot();
shootNum--;// 控制×××数量,射击一次,×××减少,消失加1
}
}
}

public void paint(Graphics g) {

g.setColor(Color.white);
g.fillRect(0, 0, this.getWidth(), this.getHeight());// 画背景
paintWall(g);// 画墙
// 画我的坦克
paintTank(myTank[1].getX(), myTank[1].getY(), g, myTank[1].getDirect(),
myTank[1].getWho(), myTank[1].isLive());
paintTank(myTank[0].getX(), myTank[0].getY(), g, myTank[0].getDirect(),
myTank[0].getWho(), myTank[0].isLive());
for (int i = 0; i < enemyTank.length; i++) {// 画敌人的坦克
paintTank(enemyTank[i].getX(), enemyTank[i].getY(), g, enemyTank[i]
.getDirect(), enemyTank[i].getWho(), enemyTank[i].isLive());
}
paintShoot(g);// 画我射击的×××
paintEemyShoot(g);// 画敌人发出的×××
paintScore(g);// 画分数,及字符
// paintMap(g);
}

// public void paintMap(Graphics g){//这是个方法可以生成漂亮的东西
// for (int j = 0; j < 3; j++) {
// Random color=new Random(); //通过Random生成随机颜色
// int r = color.nextInt(256);
// int g1 = color.nextInt(256);
// int b = color.nextInt(256);
// g.setColor(new Color(r, g1, b));
// g.fillOval(color.nextInt(750), color.nextInt(530), 5, 5);
// }
//
// }

public void paintScore(Graphics g) {// 画字符相关的
if (enemyTank.length >= 3000) {
Shoot.canShoot = false;

}
g.setColor(Color.lightGray);
Font f = getFont();
Font font = new Font(f.getName(), Font.BOLD, 0x1e);
int x = 130;
int y = 275;
String str = "SCORE:" + this.score;
g.setFont(font);
g.drawString(str, x, y);
str = "TANK:" + enemyTank.length;
x += 170;
g.drawString(str, x, y);
x += 140;
str = "[Q]Quit!";
if (gameOver) {
str = "[Y]Start!";
}
g.drawString(str, x, y);
}

public void paintWall(Graphics g) {// 画中间的柱子
g.setColor(Color.LIGHT_GRAY);
g.fill3DRect(WIDTH / 2 - 45, 150, 40, HEIGHT - 300, false);
g.fill3DRect(130, HEIGHT / 2 - 20, WIDTH - 300, 40, false);
}

/** 画自己坦克×××,同时判断×××有没有击中敌人 */
public void paintShoot(Graphics g) {
ShootDispeal();
for (int i = 0; i < Shoot.myShoot.length; i += 4) {
if (Shoot.myShoot[i] == 0 && Shoot.myShoot[i + 1] == 0) {
continue;
}
g.setColor(Color.RED);
g.fillOval(Shoot.myShoot[i], Shoot.myShoot[i + 1], 10, 10);
int x = Shoot.myShoot[i];
int y = Shoot.myShoot[i + 1];
for (int j = 0; j < enemyTank.length; j++) {
int ex = enemyTank[j].getX();
int ey = enemyTank[j].getY();
if (x > ex && x < ex + 40 && y > ey && y < ey + 40) {
score += 1;
level();
enemyTank[j].s = false;// 坦克死亡,线程关闭
enemyTank[j] = nextTank();
enemyTank[j].start();
Shoot.myShoot[i] = 0;
Shoot.myShoot[i + 1] = 0;// ×××消失
Shoot.myShoot[i + 2] = 0;
Shoot.myShoot[i + 3] = 0;
shootNum++;
shootNum1++;
}
}
Shoot.myShoot[i] += Shoot.myShoot[i + 2];
Shoot.myShoot[i + 1] += Shoot.myShoot[i + 3];
}
}

/** 画敌人发出的×××,同时判断是否击中了我的坦克 */
public void paintEemyShoot(Graphics g) {
ShootDispeal();
for (int i = 0; i < Shoot.enemyShoot.length; i += 4) {
if (Shoot.enemyShoot[i] == 0 && Shoot.enemyShoot[i + 1] == 0) {
continue;
}
g.setColor(Color.blue);
g.fillOval(Shoot.enemyShoot[i], Shoot.enemyShoot[i + 1], 10, 10);
int x = Shoot.enemyShoot[i];
int y = Shoot.enemyShoot[i + 1];
// int mx = myTank[0].getX();
// int my = myTank[0].getY();
// int mx1 = myTank[1].getX();
// int my1 = myTank[1].getY();

for (int j = 0; j < enemyTank.length; j++) {
int ex = enemyTank[j].getX();
int ey = enemyTank[j].getY();
if (x > ex && x < ex + 40 && y > ey && y < ey + 40) {
score += 1;
level();
enemyTank[j].s = false;// 坦克死亡,线程关闭
enemyTank[j] = nextTank();
enemyTank[j].start();
Shoot.enemyShoot[i] = 0;
Shoot.enemyShoot[i + 1] = 0;
Shoot.enemyShoot[i + 2] = 0;
Shoot.enemyShoot[i + 3] = 0;
// Shoot.myShoot[i]=0;Shoot.myShoot[i+1]=0;//×××消失
// Shoot.myShoot[i+2]=0;Shoot.myShoot[i+3]=0;
// shootNum++;
// shootNum1++;
}
}

// if(x>mx&&x<mx+40&&y>my&&y<my+40){
// myTank[0].setLive(true);
// checkGameOver();
// }
// if(x>mx1&&x<mx1+40&&y>my1&&y<my1+40){
// myTank[1].setLive(true);
// checkGameOver();
// }

Shoot.enemyShoot[i] += Shoot.enemyShoot[i + 2];// 根据步伐,改变×××的坐标
Shoot.enemyShoot[i + 1] += Shoot.enemyShoot[i + 3];
}
}

/** 画坦克 */
public void paintTank(int x, int y, Graphics g, int direct, int who,
boolean isLive) {
Color color = null;// 设置颜色
if (isLive) {
if (who == 0) {// 我的坦克
color = Color.green;
} else if (who == -1) {
color = Color.yellow;
} else if (who == 1) {// 1,2,3敌人的坦克,3种颜色
color = Color.red;
} else if (who == 2) {
color = Color.magenta;
} else if (who == 3) {
color = Color.CYAN;
}
switch (direct) {// 根据方向画出不同方向的坦克
case 1:
g.setColor(color);
paintUpTank(x, y, g);
break;
case 2:
g.setColor(color);
paintRightTank(x, y, g);
break;
case 3:
g.setColor(color);
paintDownTank(x, y, g);
break;
case 4:
g.setColor(color);
paintLeftTank(x, y, g);
break;
}
}
}

/** 纯画图打造坦克 */
public void paintUpTank(int x, int y, Graphics g) {
g.fill3DRect(x, y, 15 / 2, 50 / 2, false);
g.fill3DRect(x + 35 / 2, y, 15 / 2, 50 / 2, false);
g.fill3DRect(x + 15 / 2, y + 10 / 2, 20 / 2, 30 / 2, false);
g.setColor(Color.black);
g.fill3DRect(x + 23 / 2, y - 10 / 2, 5 / 2, 33 / 2, false);
g.setColor(Color.yellow);
g.fillOval(x + 20 / 2, y + 18 / 2, 10 / 2, 10 / 2);
}

public void paintLeftTank(int x, int y, Graphics g) {
g.fill3DRect(x, y, 50 / 2, 15 / 2, false);
g.fill3DRect(x, y + 35 / 2, 50 / 2, 15 / 2, false);
g.fill3DRect(x + 10 / 2, y + 15 / 2, 30 / 2, 20 / 2, false);
g.setColor(Color.black);
g.fill3DRect(x - 10 / 2, y + 22 / 2, 33 / 2, 5 / 2, false);
g.setColor(Color.yellow);
g.fillOval(x + 20 / 2, y + 18 / 2, 10 / 2, 10 / 2);
}

public void paintDownTank(int x, int y, Graphics g) {
g.fill3DRect(x, y, 15 / 2, 50 / 2, false);
g.fill3DRect(x + 35 / 2, y, 15 / 2, 50 / 2, false);
g.fill3DRect(x + 15 / 2, y + 10 / 2, 20 / 2, 30 / 2, false);
g.setColor(Color.black);
g.fill3DRect(x + 23 / 2, y + 25 / 2, 5 / 2, 33 / 2, false);
g.setColor(Color.yellow);
g.fillOval(x + 20 / 2, y + 18 / 2, 10 / 2, 10 / 2);
}

public void paintRightTank(int x, int y, Graphics g) {
g.fill3DRect(x, y, 50 / 2, 15 / 2, false);
g.fill3DRect(x, y + 35 / 2, 50 / 2, 15 / 2, false);
g.fill3DRect(x + 10 / 2, y + 15 / 2, 30 / 2, 20 / 2, false);
g.setColor(Color.black);
g.fill3DRect(x + 23 / 2, y + 22 / 2, 33 / 2, 5 / 2, false);
g.setColor(Color.yellow);
g.fillOval(x + 20 / 2, y + 18 / 2, 10 / 2, 10 / 2);
}

/** 重新开始游戏的时候会清空×××数组里面的数据 */
public void cleanShoot() {
for (int i = 0; i < Shoot.enemyShoot.length; i++) {
Shoot.enemyShoot[i] = 0;
}
for (int i = 0; i < Shoot.myShoot.length; i++) {
Shoot.myShoot[i] = 0;
}
}

/** ×××消失了 */
public void ShootDispeal() {
for (int i = 0; i < Shoot.myShoot.length; i += 4) {// 撞到边缘
if (Shoot.myShoot[i] < 0 || Shoot.myShoot[i] > WIDTH
|| Shoot.myShoot[i + 1] < 0
|| Shoot.myShoot[i + 1] > HEIGHT) {
Shoot.myShoot[i] = 0;
Shoot.myShoot[i + 1] = 0;
Shoot.myShoot[i + 2] = 0;
Shoot.myShoot[i + 3] = 0;
shootNum++;
shootNum1++;
}
int x = Shoot.myShoot[i];
int y = Shoot.myShoot[i + 1];
// 撞到柱子
if ((x > 330 && x < 360 && y > 150 && y < 380)
|| (x > 130 && x < 570 && y > 240 && y < 280)) {
Shoot.myShoot[i] = 0;
Shoot.myShoot[i + 1] = 0;
Shoot.myShoot[i + 2] = 0;
Shoot.myShoot[i + 3] = 0;
shootNum++;
shootNum1++;
}
}
for (int i = 0; i < Shoot.enemyShoot.length; i += 4) {// 撞到边缘
if (Shoot.enemyShoot[i] < 0 || Shoot.enemyShoot[i] > WIDTH
|| Shoot.enemyShoot[i + 1] < 0
|| Shoot.enemyShoot[i + 1] > HEIGHT) {
Shoot.enemyShoot[i] = 0;
Shoot.enemyShoot[i + 1] = 0;
Shoot.enemyShoot[i + 2] = 0;
Shoot.enemyShoot[i + 3] = 0;
}
int x = Shoot.enemyShoot[i];
int y = Shoot.enemyShoot[i + 1];
// 撞到柱子
if ((x > 330 && x < 360 && y > 150 && y < 380)
|| (x > 130 && x < 570 && y > 240 && y < 280)) {
Shoot.enemyShoot[i] = 0;
Shoot.enemyShoot[i + 1] = 0;
Shoot.enemyShoot[i + 2] = 0;
Shoot.enemyShoot[i + 3] = 0;
}

}
}
}

/******************************************************************/

/*************************************Tanks.java*******************************************/

package tank;

import java.util.Random;

/** 坦克父类,继承了线程 */
public class Tanks extends Thread {
private int x;// 坦克坐标x
private int y;// 坦克坐标y
private int step;// 坦克的速度
private int direct;// 方向,1表示向上,2表示向右,3表示向下,4表示向左
private int who;// 坦克标识,0和-1表示自己的坦克,1,2,3表示敌人的坦克,颜色随机.
private boolean isLive = true;// 判断坦克是否死亡
Shoot shoot;// shoot坦克的射击

public Tanks(int x, int y, int step, int direct, int who, boolean isLive) {
super();
this.x = x;
this.y = y;
this.step = step + 2;
this.direct = direct;
this.who = who;
this.isLive = isLive;
}

public boolean canMove() {// boolean返回值类型.判断坦克是否能移动,比如撞墙了.
if (x < 0) {
x = 0;
return false;
} else if (x > 690) {
x = 690;
return false;
} else if (y < 0) {
y = 0;
return false;
} else if (y > 450) {
y = 450;
return false;
} else if (x > 270 && x < 370 && y > 100 && y < 380) {// 撞到竖着的柱子
if (x - 270 < 20) {
x = 270;
} else {
x = 370;
}
return false;
} else if (x > 85 && x < 570 && y > 195 && y < 290) {// 撞到横着的柱子
if (y - 195 < 10) {
y = 190;
} else {
y = 290;
}
return false;
}
return true;
}

public void moveUp() {// 坦克向上移动一步
if (canMove()) {
y -= step;
direct = 1;
}
}

public void moveDown() {// 坦克向下移动一步
if (canMove()) {
y += step;
direct = 3;
}
}

public void moveLeft() {// 坦克向左移动一步
if (canMove()) {
x -= step;
direct = 4;
}
}

public void moveRight() {// 坦克向右移动一步
if (canMove()) {
x += step;
direct = 2;
}
}

public void shoot() {// 每次射击调用此函数

switch (direct) {
case 1:
shoot = new Shoot(x, y - 40, direct, step, who);
break;
case 2:
shoot = new Shoot(x + 40, y, direct, step, who);
break;
case 3:
shoot = new Shoot(x, y + 40, direct, step, who);
break;
case 4:
shoot = new Shoot(x - 40, y, direct, step, who);
break;
default:
break;
}

}

public String toString() {// 用于调试
return "Tanks [direct=" + direct + ", isLive=" + isLive + ", step="
+ step + ", x=" + x + ", y=" + y + "]";
}

/** 以下是get() set()函数 */
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 getStep() {
return step;
}

public void setStep(int step) {
this.step = step;
}

public int getDirect() {
return direct;
}

public void setDirect(int direct) {
this.direct = direct;
}

public boolean isLive() {
return isLive;
}

public void setLive(boolean isLive) {
this.isLive = isLive;
}

public void setWho(int who) {
this.who = who;
}

public int getWho() {
return who;
}
}

class MyTank extends Tanks {// 我的坦克继承了Tanks
public MyTank(int x, int y, int step, int direct, int who, boolean isLive) {
super(x, y, step, direct, who, isLive);
}
}

class EnemyTanks extends Tanks {// 敌人的坦克继承了tanks,也继承了父类的线程
private int time = 500;// 线程占用时间500毫秒
boolean s = true;// 定义一个boolean的开关,坦克死亡,关闭开关,线程死亡.

public EnemyTanks(int x, int y, int step, int direct, int who,
boolean isLive) {
super(x, y, step, direct, who, isLive);
}

public void move() {// 敌人的坦克自己移动
Random r = new Random();
int random = r.nextInt(50);
int r1 = r.nextInt(4);
if (!(r1 == 0)) {// 如果r1=0,就射击一次
if (Shoot.canShoot) {

shoot();

}
}
for (int i = 0; i < random; i++) {// random表示坦克的一次随机移动的距离
try {
Thread.sleep(50);// 线程sleep,移动使移动看起来自然一点
} catch (InterruptedException e) {
e.printStackTrace();
}
if (r1 == 0) {// 根据r1的值判断,此次移动往那个方向
if (this.getY() == 0 || this.getY() == 290) {
r1 = 3;
} else {
moveUp();
}
} else if (r1 == 1) {
if (this.getX() == 690 || this.getX() == 270) {
r1 = 2;
} else {
moveRight();
}
} else if (r1 == 2) {
if (this.getX() == 0 || this.getX() == 370) {
r1 = 1;
} else {
moveLeft();
}
} else if (r1 == 3) {
if (this.getY() == 450 || this.getY() == 190) {
r1 = 0;
} else {
moveDown();

}
}
}
}

public void run() {// 继承线程功能,必须实现run()函数
while (s) {// s=true表示坦克没有死亡.s=false跳出死循环,坦克死亡
move();
try {
Thread.sleep(time);// 每次线程占用时间500毫秒
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}

/****************************************************************************/

/*********************************Shoot.java***********************************/

package tank;

public class Shoot {
static int[] myShoot = new int[40];// 我的坦克×××放在数组里面
static int[] enemyShoot = new int[12];// 所有敌人共享这个数组
private int direct;// 坦克的方向
private int who;// 是敌人的坦克?还是自己的坦克
private int x1;// 根据情况调整后×××x的坐标
private int y1;// 根据情况调整后×××y的坐标
private int stepx;// ×××在x轴上移动的速度
private int stepy;// ×××在y轴上移动的速度
private int speed;// 坦克的速度
static int indexMy = 0;// 我的×××索引,数组满了之后indexMy=0;每次加4
static int indexEnemy = 0;// 敌人×××索引,数组满了之后indexEnemy=0;每次加4
static boolean canShoot = true;

public Shoot(int x, int y, int direct, int step, int who) {
if (canShoot) {
speed = step + 8;// 根据坦克的速度,设定×××的速度
this.direct = direct;
this.who = who;
if (direct == 1) {// if else用来调整×××射击出去的位置
x1 = x + 20;
y1 = y;
stepx = 0;
stepy = -speed;
} else if (direct == 2) {
x1 = x + 40;
y1 = y + 20;
stepx = speed;
stepy = 0;
} else if (direct == 3) {
x1 = x + 20;
y1 = y + 40;
stepx = 0;
stepy = speed;
} else if (direct == 4) {
x1 = x;
y1 = y + 20;
stepx = -speed;
stepy = 0;
}
if (indexEnemy == enemyShoot.length - 4) {// 表示数组满了
indexEnemy = 0;
}
if (indexMy == 4) {// 表示数组满了
indexMy = 0;
}
if (who == 1 || who == 2 || who == 3) {// 敌人的坦克
if (indexEnemy > 11) {
indexEnemy = 0;
}
enemyShoot[indexEnemy] = x1;// ×××的坐标x
enemyShoot[indexEnemy + 1] = y1;// ×××的坐标y
enemyShoot[indexEnemy + 2] = stepx;// ×××在x轴移动的步伐
enemyShoot[indexEnemy + 3] = stepy;// 在t轴移动的步伐
indexEnemy += 4;

} else if (who == 0 || who == -1) {// 我的坦克
if (indexEnemy > 12) {
indexEnemy = 0;
}
myShoot[indexMy] = x1;
myShoot[indexMy + 1] = y1;
myShoot[indexMy + 2] = stepx;
myShoot[indexMy + 3] = stepy;
indexMy += 4;

}

}
}
}

/**************************************************************************/