坦克大战实验报告论文.doc

坦克大战实验报告
班 级： 姓 名： 学 号：
一、系统简介
使用JAVA编写一个人机游戏，有开始启动面板(Stage 1)，并有闪烁效果。在开始面板中有游戏（G）和帮助（H）两个菜单。其中游戏（G）菜单中有开始游戏（N）、退出游戏（E）、保存游戏（S）、继续游戏（C）选项；帮助（H）菜单中有关于坦克如何操作的提示信息。
玩家有1辆坦克（有3条命），电脑有6辆坦克，我的坦克可以通过键盘控制进行移动和发射子弹，敌人坦克可自由运动并自动发射子弹。敌人坦克相互之间不能重叠，敌人坦克与我的坦克不能重叠，我的坦克与敌人坦克不能重叠。当子弹击中坦克时坦克死亡，并显示爆炸效果。当我的坦克生命为0时游戏结束（显示GAMEOVER)，当敌方的所有坦克死亡时游戏结束(显示VICTORY)。
二、需求分析
设计一个图形用户界面，将所有游戏的元素都能在此用于界面上表现出来，界面能够接受用户的操作，具有人机交互功能。用户可以选择开始游戏(N)，退出游戏(E)，保存游戏(S)，继续游戏(C)，游戏帮助(H)。
界面中包含我的坦克和敌人坦克以及坦克发出的子弹和爆炸后的效果。
坦克：坦克分为两种，敌人坦克和我的坦克。我的坦克和敌人坦克均可以发射子弹，可以改变路径行走，且在行走过程中碰到边界或碰到其它坦克会自动换方向，坦克之间不能相互穿越。
子弹：子弹可以由敌方坦克和我的坦克发射，且发射出去的子弹可以直线移动，直到碰到其它坦克或超越边界就消失。坦克受到一颗子弹攻击便死亡，死亡后坦克消失。
爆炸：当子弹射击到坦克身上时，要产生爆炸效果。
方向：坦克和子弹都有方向，可以选择上下左右四个方向，且子弹的方向从属于坦克的方向。
具体功能：
1、 坦克可以上下左右移动
2、 坦克可以发子弹（可以连发，最多5发子弹）
3、 当坦克中弹时，坦克消失，并显示爆炸效果。
4、 我的坦克被击中后显示爆炸效果
5、 防止敌人坦克重叠运动、我的坦克与敌人坦克重叠运动、敌人坦克与我的坦克重叠运动
6、 玩游戏时可以保存游戏和继续游戏
7、 记录玩家的成绩
三、 系统设计
程序流程图：

总体框架：
项目名： TankGame1
主类文件： MyFrame.java
坦克父类文件：Tank.java
坦克子类（我的坦克）：MyTank.java
坦克子类（敌人坦克）：EnemyTank.java
我的面板：MyPanel.java
子弹类：Shot.java
开始面板：MyStartPanel.java
记录类：Recorder.java
爆炸类：Bomb.java
四、详细设计
(一) 、画坦克
1、Tank类
class Tank{
int x,y;//坦克的位置
int direct;//坦克的方向
int color;//坦克的颜色，值为0时为的我的坦克，为1时为敌人的坦克
int speed;
public Tank(int x, int y) {
this.x = x;
this.y = y;
}
setter与getter方法（代码略）
public void moveUp(){//向上移动，y坐标值减，方向值为0
y-=speed;
this.setDirect(0);
}
public void moveDown(){//向下移动，y坐标值增，方向值为2
y+=speed;
this.setDirect(0);
}
public void moveRight(){//向右移动，x坐标值增，方向值为1
x+=speed;
this.setDirect(0);
}
public void moveLeft(){//向左移动，x坐标值减，方向值为3
x-=speed;
this.setDirect(0);
}
}
2、我的坦克类MyTank
class MyTank extends Tank{

public MyTank(int x, int y) {
super(x, y);
}
}

3、主类MyFrame
public class MyFrame extends JFrame{
MyPanel mp=null;

public static void main(String[] args) {
MyFrame tankGame1=new MyFrame();
MyFrame.setVisible(true);
}

public MyFrame() {
mp=new MyPanel();
this.add(mp);
this.setBounds(200,200,600,500);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
4、在MyFrame.java中创建MyPanel类
class MyPanel extends JPanel
{
MyTank mytank=null;
public MyPanel()
{
mytank=new MyTank(200,200);//创建我的坦克并设置其初始位置
}
//重载MyPanel类的paint函数以实现画坦克
public void paint(Graphics g)//窗口大小改变或重绘窗口时，执行repaint()时会自动调用
{
super.paint(g);
g.fillRect(0,0,600,500);
this.drawTank(mytank.getX(),mytank.getY(),mytank.getDirect(),mytank.getColor(), 5, g);
}

//在MyPanel画坦克的函数，参数包括坦克的位置、方向、类型（用于设置颜色）、画笔：
public void drawTank(int x, int y, int direct, int color, int size,
Graphics g) {

switch (color) {
case 0://我的坦克的颜色
g.setColor(Color.cyan);
break;
case 1:
g.setColor(Color.yellow);
break;
case 2://敌人坦克的颜色
g.setColor(Color.green);
break;
}
switch (direct) {
case 0:
g.fill3DRect(x, y, size, 6 * size, false);
g.fill3DRect(x + 3 * size, y, size, 6 * size, false);
g.fill3DRect(x + size, y + size, 2 * size, 4 * size, false);
g.fillOval(x + size, y + 2 * size, 2 * size, 2 * size);
g.drawLine(x + 2 * size, y, x + 2 * size, y + 3 * size);
break;
case 3:
g.fill3DRect(x, y, 6 * size, size, false);
g.fill3DRect(x, y + 3 * size, 6 * size, size, false);
g.fill3DRect(x + size, y + size, 4 * size, 2 * size, false);
g.fillOval(x + 2 * size, y + size, 2 * size, 2 * size);
g.drawLine(x, y + 2 * size, x + 3 * size, y + 2 * size);
break;
case 1:
g.fill3DRect(x, y, 6 * size, size, false);
g.fill3DRect(x, y + 3 * size, 6 * size, size, false);
g.fill3DRect(x + size, y + size, 4 * size, 2 * size, false);
g.fillOval(x + 2 * size, y + size, 2 * size, 2 * size);
g.drawLine(x + 6 * size, y + 2 * size, x + 3 * size, y + 2 * size);
break;
case 2:
g.fill3DRect(x, y, size, 6 * size, false);
g.fill3DRect(x + 3 * size, y, size, 6 * size, false);
g.fill3DRect(x + size, y + size, 2 * size, 4 * size, false);
g.fillOval(x + size, y + 2 * size, 2 * size, 2 * size);
g.drawLine(x + 2 * size, y + 6 * size, x + 2 * size, y + 3 * size);
break;
}
}

(二)、移动坦克(事件监听)
l 在主类注册键盘事件监听，在MyPanel类中实现事件监听。
l 在这里，本文通过另一种新的方法来实现坦克的移动，通过实现keyPressed(KeyEvent e)与keyReleased(KeyEvent e)这两个事件处理方法，再创建一个action()方法，即可达到坦克移动更加敏捷顺畅，并且可为后面坦克发射子弹做重要铺垫，即可做到坦克边移动，边发射子弹的效果。
//L表示向左，R表示向右，U表示向上，D表示向下
boolean L = false, R = false, U = false, D = false；

@Override
public void keyPressed(KeyEvent e) {
if (e.getKeyCode() == KeyEvent.VK_W) {
U = true;
} else if (e.getKeyCode() == KeyEvent.VK_D) {
R = true;
} else if (e.getKeyCode() == KeyEvent.VK_S) {
D = true;
} else if (e.getKeyCode() == KeyEvent.VK_A) {
L = true;
}
}

@Override
public void keyReleased(KeyEvent e) {
if (e.getKeyCode() == KeyEvent.VK_W) {
U = false;
} else if (e.getKeyCode() == KeyEvent.VK_D) {
R = false;
} else if (e.getKeyCode() == KeyEvent.VK_S) {
D = false;
} else if (e.getKeyCode() == KeyEvent.VK_A) {
L = false;
}
}

public void action() {
if (U) {
this.mytank.setDirect(0);
this.mytank.moveUp();
} else if (R) {
this.mytank.setDirect(1);
this.mytank.moveRight();
} else if (D) {
this.mytank.setDirect(2);
this.mytank.moveDown();
} else if (L) {
this.mytank.setDirect(3);
this.mytank.moveLeft();
}
}
// 重新绘制窗口
this.repaint();
}
再将action()方法放到run()中。

(三)、画出敌人的坦克
1、.创建敌人的坦克类EnemyTank.java
public class EnemyTank extends Tank
{
public EnemyTank(int x,int y)
{
super(x,y);
}
}
2、在MyPanel中，创建敌人的坦克组
ArrayList<EnemyTank> ets = new ArrayList<EnemyTank>();

EnemyTank et = null;
public static int ensize=6;
在构造函数中初始化敌人的坦克：
// 创建敌人坦克
for (int i = 0; i < ensize; i++) {
et = new EnemyTank(20 + i * 50, 0);
}
在paint中画出敌人的坦克

public void paint(Graphics g) {
super.paint(g);
// 画出我的坦克
if (mytank.isLive()) {
this.drawTank(mytank.getX(), mytank.getY(), mytank.getDirect(),
mytank.getColor(), 5, g);
}
// 画出敌人的坦克
for (int i = 0; i < ets.size(); i++) {
et = ets.get(i);
drawTank(et.getX(), et.getY(), et.getDirect(), et.getColor(), 5, g);
}

(四)、线程----让坦克能发射子弹并击中敌人坦克
坦克要能发射子弹（按J键时发射子弹），子弹要以一定的速度移动，发射子弹的频率不能过快，当子弹击中敌人的坦克时，子弹死亡，敌人的坦克生命值减少。
基本思路：
l 创建一个子弹类线程，在该类中定义子弹的属性，并通过run方法实现子弹的移动
l 在我的坦克类MyTank()中创建子弹集合，添加一个方法shotEnemy用于按方向创建并子弹，同时将创建的子弹添加到子弹集合中，然后启动子弹线程
l 在MyPanel类中添加发射子弹的事件处理：按J键时调用MyTank()类的shotEnemy方法创建子弹在paint方法中画出子弹。
l 将MyPanel类改为线程类，并在其run方法中调用相关方法判断子弹是否击中坦克
实现爆炸效果。
1、创建子弹类Shot.java
在members.java中定义子弹类，该类通过Runnable实现线程
package TankWar;
public class Shot implements Runnable{
private int x;
private int y;
private int direct;
private int speed=6;
private boolean isLive=true;

public Shot(){}

public Shot(int x, int y, int direct) {
this.x = x;
this.y = y;
this.direct = direct;
}
@Override
public void run() {
while(true)
{
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
switch(this.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>=480||y<=0||y>=360)
{
isLive=false;
break;
}
}
}
}
2.、在MyTank类中创建子弹集，并定义一个方法ShotEnemy，创建子弹并将子弹添加到子弹集中，启动子弹线程 。
在MyTank类中添加向量ss用于存放子弹：
// 创建子弹集
ArrayList<Shot> ss = new ArrayList<Shot>();
Shot s = null;
在MyTank类添加一个创建子弹并启动子弹线程的方法
// ShotEnemy创建子弹并将子弹添加到子弹集中，启动子弹线程
public void shotEnemy() {
switch (this.direct) {
case 0:
s = new Shot(x + 2 * size, y, 0);
ss.add(s);
break;
case 1:
s = new Shot(x + 6 * size, y + 2 * size, 1);
ss.add(s);
break;
case 2:
s = new Shot(x + 2 * size, y + 6 * size, 2);
ss.add(s);
break;
case 3:
s = new Shot(x, y + 2 * size, 3);
ss.add(s);
break;
}
// 启动子弹线程
Thread t = new Thread(s);
t.start();
}
3、发射子弹的键盘事件的实现
分别在MyPanel的public void keyPressed(KeyEvent e) 和public void keyReleased(KeyEvent e)中添加按j键的事件。
Boolean SHOT = false；
public void keyPressed(KeyEvent e) {
if (e.getKeyCode() == KeyEvent.VK_J) {
SHOT = true;
}
}
@Override
public void keyReleased(KeyEvent e) {
if (e.getKeyCode() == KeyEvent.VK_J) {
SHOT = false;
}
}
public void action() {
if (SHOT) {
if (this.mytank.isLive() && this.mytank.ss.size() <= 4)// 最多可连续发5枚子弹
{
this.mytank.shotEnemy();
}
}
}
4、画出子弹
(1) 在paint方法中画出子弹：
// 从ss,中取出每颗子弹，并画出
for (int i = 0; i < mytank.ss.size(); i++) {
Shot myShot = mytank.ss.get(i);// 从子弹集合中取出子弹
if (myShot != null && myShot.isLive() == true)// 若子弹集不空，且子弹没有消
{
g.draw3DRect(myShot.getX(), myShot.getY(), 1, 1, false);
}
if (myShot.isLive() == false)// 子弹消失
{
// 从ss中删除掉该子弹
mytank.ss.remove(myShot);
}
}
（2）、使子弹能自动移动：
S1：在MyPanel中的接口中加入Runnable：
public class MyPanel extends JPanel implements Runnable
S2：实现接口中的抽象方法run:
@Override
public void run() {
// 每隔100毫秒去重绘
while (true) {
action();
try {
Thread.sleep(100);

} catch (Exception e) {
e.printStackTrace();
}
// 重绘
this.repaint();
}

S3：创建并启动MyPanel线程
在主类的构造函数中创建我的面板线程并启动。
mp=new MyPanel();//创建我的面板
Thread t=new Thread(mp);
t.start();//线程启动

5、当子弹击中坦克时坦克消失
(1)、在Tank类中添加一个变量用于判断坦克是否死亡
boolean isLive=true;
(2)、在MyPanel中添加下面两个函数用于判断子弹是否击中目标
// 写一个函数专门判断子弹是否击中敌人坦克
public boolean hitTank(Shot s, Tank et) {
boolean b2 = false;// 用于判断子弹是否击中坦克
switch (et.direct) {
// 如果敌人坦克的方向是上或者是下
case 0:
case 2:
if (s.getX() > et.x && s.getX() < et.x + 20 && s.getY() > et.y
&& s.getY() < et.y + 30) {
s.setLive(false);// 子弹死亡
et.setLive(false); // 敌人坦克死亡
b2 = true;
Bomb b = new Bomb(et.x, et.y);// 创建一颗炸弹,放入ArrayList
bombs.add(b); // 放入ArrayList
}
break;
case 1:
case 3:
if (s.getX() > et.x && s.getX() < et.x + 30 && s.getY() > et.y
&& s.getY() < et.y + 20) {
s.setLive(false);// 子弹死亡
et.setLive(false); // 敌人坦克死亡
b2 = true;
Bomb b = new Bomb(et.x, et.y);// 创建一颗炸弹,放入ArrayList
bombs.add(b); // 放入ArrayList
}
}
return b2;
}

// 判断我的子弹是否击中敌人的坦克
public void hitEnemyTank() {
// 判断是否击中敌人的坦克
for (int i = 0; i < mytank.ss.size(); i++) {
// 取出子弹
Shot myShot = mytank.ss.get(i);
// 判断子弹是否有效
if (myShot.isLive()) {
// 取出每个坦克
for (int j = 0; j < ets.size(); j++) {
EnemyTank et = ets.get(j);
if (et.isLive())// 如果坦克还存在
{// 调用函数判断子弹是否击中坦克
if (this.hitTank(myShot, et))// 如果击中
{
ets.remove(j);// 将敌人的坦克从集合中去除
total++;
ensize--;
}
}
}
}
}
}
(3)、在MyPanel类的run函数中添加下面代码，用于处理是否击中目标坦克
if (mytank.isLive()) {
this.hitEnemyTank();
}

（五）、.爆炸效果
基本原理：当子弹击中敌人的坦克时创建一枚炸弹并加入到炸弹集中，在paint方法中画出炸弹（从大到小显示三张图片，每张图片显示一定的时间（通过生命和paint函数的调用间隔确定））
1、引入爆炸图片并将其复制到scr中
2、创建一个炸弹类
package TankWar;
public class Bomb {
// 定义炸弹的坐标
int x, y;
// 炸弹的生命
int life = 9;
boolean isLive = true;

public Bomb(){}

public Bomb(int x, int y) {
this.x = x;
this.y = y;
}
// 减少生命值
public void lifeDown() {
if (life > 0) {
life--;
} else {
this.isLive = false;
}
}
}
3、在MyPanel中定义三张图片和定义爆炸集合，并在构造函数中初始化
// 定义三张图片,三张图片才能组成一颗炸弹
Image image1 = null;
Image image2 = null;
Image image3 = null;
// 定义炸弹集合
ArrayList<Bomb> bombs = new ArrayList<Bomb>();
Recorder recorder = null;

用另一种新的方法初始化图片，使能够第一次击中坦克时会产生爆炸效果。
image1 = ImageIO.read(MyPanel.class.getResourceAsStream("bomb_1.gif"));
image2 = ImageIO.read(MyPanel.class.getResourceAsStream("bomb_2.gif"));
image3 = ImageIO.read(MyPanel.class.getResourceAsStream("bomb_3.gif"));

4、在hitTank()中的switch结构中创建炸弹
switch (et.direct) {
// 如果敌人坦克的方向是上或者是下
case 0:
case 2:
if (s.getX() > et.x && s.getX() < et.x + 20 && s.getY() > et.y
&& s.getY() < et.y + 30) {
s.setLive(false);// 子弹死亡
et.setLive(false); // 敌人坦克死亡
b2 = true;
Bomb b = new Bomb(et.x, et.y);// 创建一颗炸弹,放入ArrayList
bombs.add(b); // 放入ArrayList
}
break;
case 1:
case 3:
if (s.getX() > et.x && s.getX() < et.x + 30 && s.getY() > et.y
&& s.getY() < et.y + 20) {
s.setLive(false);// 子弹死亡
et.setLive(false); // 敌人坦克死亡
b2 = true;
Bomb b = new Bomb(et.x, et.y);// 创建一颗炸弹,放入ArrayList
bombs.add(b); // 放入ArrayList
}
}

5、在MyPanel的paint函数中画出炸弹
// 画出炸弹
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,就把该炸弹从bombs向量去掉
if (b.life == 0) {
bombs.remove(b);
}
}
（六）、让敌人的坦克动起来并发射子弹
1、把敌人的坦克修改为线程类
public class EnemyTank extends Tank implements Runnable
2、重载抽象方法run用于敌人坦克的运动
@Override
public void run() {
// 敌人坦克改变方向
switch (this.direct) {
case 0:
// 前进一段距离后改变方向
for (int i = 0; i < 30; i++) {
if (y > 6 * size + speed && !this.isTouchOtherTank())
this.moveUp();
else
break;
try {
Thread.sleep(50);
} catch (InterruptedException ex) {
}
}
break;
case 1:
for (int i = 0; i < 30; i++) {
if (x < 600 - 6 * size - speed && !this.isTouchOtherTank())
this.moveRight();
else
break;
try {
Thread.sleep(50);
} catch (InterruptedException ex) {
}
}
break;
case 2:// 前进一段距离后改变方向
for (int i = 0; i < 30; i++) {
if (y < 500 - 6 * size - speed && !this.isTouchOtherTank())
this.moveDown();
else
break;
try {
Thread.sleep(50);
} catch (InterruptedException ex) {
}
}
break;
case 3:
for (int i = 0; i < 30; i++) {
if (x > 6 * size + speed && !this.isTouchOtherTank())
this.moveLeft();
else
break;
try {
Thread.sleep(50);
} catch (InterruptedException ex) {
}
}
break;
}
j++;
if (j % 2 == 0)
this.direct = (int) (Math.random() * 4);
}
}

3、敌人的坦克之间不能重叠
在EnemyTank类中添加一个方法isTouchOtherEnemy()用于判断敌人的坦克之间是否相遇。
// isTouchOtherTank()用于判断敌人的坦克之间是否相遇
public boolean isTouchOtherTank() {
for (int i = 0; i < ets.size(); i++) {
EnemyTank et = ets.get(i);
if (et != this) {
switch (this.direct) {
case 0:// 方向向上，判断左上角和右上角顶点是否在另一两坦克内
if (et.direct == 0 || et.direct == 2) {
if (x >= et.x && x <= et.x + 4 * size &