Java坦克大战(四)

时间:2023-03-08 16:23:17

这是我的坦克游戏大战的最后一版,里面添加很多新的功能。这个坦克大战的有很多不足之处,但是对于初学者来说依然是一个很好的练习项目,从中我们可以学习Java基础知识,将知识与项目结合,学习面向对象编程思想,最主要的是编程的逻辑练习,代码往往不像是写文章从上到下一气呵成完成,中间很可能为增加一个功能来添加一个类一个方法等,中间有很多细节需要我们考虑。文章最后会附加该坦克大战涉及的相关素材。

功能:

1.防止坦克重叠

2.可以分关(闪烁效果)

3.记录成绩(小型游戏都是写在文件中)

4.存盘退出,可以记录但是敌人坦克的坐标

5.可以恢复上局,继续玩

6.坦克的声音

坦克大战最终版本(2.1)

MyTanKGame类:

/*
* 功能:
* 1.防止坦克重叠
* 2.可以分关(闪烁效果)
* 3.记录成绩(小型游戏都是写在文件中)
* 4.存盘退出,可以记录但是敌人坦克的坐标
* 5.可以恢复上局,继续玩
* 6.坦克的声音
*/
package com.fanghua6; import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.util.Vector;
import javax.swing.*; public class MyTankGame1_7 extends JFrame implements ActionListener { Mypanel1_2 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) {
new MyTankGame1_7();
} // 构造函数
public MyTankGame1_7() {
// mp = new Mypanel1_2(); // 启动mp线程
// Thread t = new Thread(mp);
// t.start(); // this.add(mp);
// 注册监听
// this.addKeyListener(mp);
// 创建菜单及菜单选项
jmb = new JMenuBar();
jm1 = new JMenu("游戏(G)");
jm1.setMnemonic('G');
jmi1 = new JMenuItem("开始新游戏(N)");
jmi1.setMnemonic('N'); jmi2 = new JMenuItem("退出游戏(E)");
jmi2.setMnemonic('E'); jmi3 = new JMenuItem("存盘退出(C)");
jmi3.setMnemonic('C'); jmi4 = new JMenuItem("继续上局(S)");
jmi4.setMnemonic('S'); // jmi1相应
jmi1.addActionListener(this);
jmi1.setActionCommand("newgame");
jmi2.addActionListener(this);
jmi2.setActionCommand("exit");
jmi3.addActionListener(this);
jmi3.setActionCommand("saveExit");
jmi4.addActionListener(this);
jmi4.setActionCommand("conGame"); jm1.add(jmi1);
jm1.add(jmi2);
jm1.add(jmi3);
jm1.add(jmi4); jmb.add(jm1); // 加了开始面板(上面的全注释掉)
msp = new MyStartPanel();
this.add(msp);
// 启动msp面板
Thread t = new Thread(msp);
t.start(); this.setJMenuBar(jmb); this.setSize(600, 500);
this.setTitle("我的坦克大战");
ImageIcon icon = new ImageIcon("images\\tanke.png");
this.setIconImage(icon.getImage());
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setVisible(true); } @Override
public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub
// 对用户不同的点击做出不同的处理
if (e.getActionCommand().equals("newgame")) { // 创建战场面板
mp = new Mypanel1_2("newGame");
// 启动mp线程
Thread t = new Thread(mp);
t.start();
// 先把msp删掉,再加mp
this.remove(msp);
this.add(mp);
// 注册监听
this.addKeyListener(mp);
// 显示,刷新JFrame(这个很重要)
this.setVisible(true);
} else if (e.getActionCommand().equals("exit")) { // 用户退出系统的菜单(保存击毁敌人数量)
Recorder.keepRecording(); System.exit(0);
}// 对存盘退出的处理
else if (e.getActionCommand().equals("saveExit")) { /*
* 当时这里这样处理的,大错特错。new两次 工作 new Recorder().setEts(mp.ets);new
* 保存击毁敌人的数量和敌人的坐标 Recorder().keepRecAndEnemyTank();
*/ // 工作
Recorder rd = new Recorder();
rd.setEts(mp.ets);
// 保存击毁敌人的数量和敌人的坐标
rd.keepRecAndEnemyTank(); // 退出
System.exit(0);
} else if (e.getActionCommand().equals("conGame")) {
// 继续游戏
// 创建战场面板
mp = new Mypanel1_2("con"); // 不在这:mp.nodes = new Recorder().getNodesAndEnNums();
// 启动mp线程
Thread t = new Thread(mp);
t.start();
// 先把msp删掉,再加mp
this.remove(msp);
this.add(mp);
// 注册监听
this.addKeyListener(mp);
// 显示,刷新JFrame(这个很重要)
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);
// 开关信息的字体
Font myFont = new Font("华文新魏", Font.BOLD, 30);
g.setFont(myFont);// 别忘了
g.drawString("stage: 1", 140, 200);
}
} @Override
public void run() {
// TODO Auto-generated method stub
while (true) {
// 休眠
try {
Thread.sleep(500);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
times++;
// 重画
this.repaint();
}
} } // 我的面板,拓宽思路:Panel本身就是一个刷新体
class Mypanel1_2 extends JPanel implements java.awt.event.KeyListener, Runnable { // 定义我的坦克
Hero1_2 hero = null; // 判断是续上局,还是新游戏 // 定义敌人的坦克(不止一辆,线程安全,集合)
Vector<EnemyTank> ets = new Vector<EnemyTank>();
Vector<Node> nodes = new Vector<Node>(); // 定义炸弹集合
Vector<Bomb> bombs = new Vector<Bomb>(); int enSize = 4;// 敌人坦克保持4个 // 定义三张图片(三张图片才能组成一颗炸弹)
Image image1 = null;
Image image2 = null;
Image image3 = null; // 构造函数(续局,变成含参的构造函数)
public Mypanel1_2(String flag) { // 恢复记录(写在这里)
Recorder.getRecoring(); hero = new Hero1_2(70, 100); if (flag.equals("newGame")) {
// 初始化敌人的坦克
for (int i = 0; i < enSize; i++) {
// 创建一辆敌人的坦克
EnemyTank et = new EnemyTank((i + 1) * 50, 0);
et.setColor(0);
// 坦克默认反向是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 { nodes = new Recorder().getNodesAndEnNums(); for (int i = 0; i < nodes.size(); i++) { Node node = nodes.get(i);
// 创建一辆敌人的坦克
EnemyTank et = new EnemyTank(node.x, node.y);
et.setColor(0);
et.setDirect(node.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);
}
}
// 初始话图片,这样做击中第一个坦克,爆炸的效果不明显。下面优化
image1 = Toolkit.getDefaultToolkit().getImage(
Panel.class.getResource("/bomb_1.gif"));
image2 = Toolkit.getDefaultToolkit().getImage(
Panel.class.getResource("/bomb_2.gif"));
image3 = Toolkit.getDefaultToolkit().getImage(
Panel.class.getResource("/bomb_3.gif")); // 引包:import javax.imageio.ImagesssIO;
// try {
// image1=ImageIO.read(new File("/bomsb_1.gif"));
// image2=ImageIO.read(new File("/bomb_2.gif"));
// image3=ImageIO.read(new File("/bomb_3.gif"));
// } catch (IOException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// } // 在Mypanel1_2初始化里,放置开战音效,加载即播放
// 以后再添加爆炸效果的声音也是这样做的思路
AePlayWave apw = new AePlayWave("E:\\111.wav");
apw.start(); } // 提示信息(只需要画笔即可)
public void showInfo(Graphics g) {
// 画出提示信息坦克
this.drawTank(70, 310, g, 0, 0);
g.setColor(Color.black);
g.drawString(Recorder.getEnNum() + "", 100, 330); this.drawTank(70, 360, g, 0, 1);
g.setColor(Color.black);
g.drawString(Recorder.getMyLife() + "", 100, 380); // 画出玩家的总成绩
g.setColor(Color.black);
Font f = new Font("宋体", Font.BOLD, 20);
g.setFont(f);
g.drawString("你的总成绩", 410, 30);
this.drawTank(410, 60, g, 0, 0); g.setColor(Color.black);
g.drawString(Recorder.getAllEnNum() + "", 440, 80);
} // 重写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);
}
// 从ss中取出每一颗子弹,并画出
for (int i = 0; i < 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); /*
* 画出一颗子弹(后添加 hero.s.isLive==true,节省资源) if (hero.s != null
* &&hero.s.isLive == true) { g.draw3DRect(hero.s.x, hero.s.y,
* 1, 1,false); }
*/
}
if (myShot.isLive == false) {
// 从ss(向量)中删除该子弹
// hero.ss.remove(i);会报异常。
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 > 4) {
g.drawImage(image2, b.x, b.y, 30, 30, this);
} else {
g.drawImage(image3, b.x, b.y, 30, 30, this);
}
// 让b的生命值减小
b.lifeDown();
// 如果炸弹生命值为零,就把该炸弹从bombs向量中去掉
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(et.getX(), et.getY(), g, et.getDirect(), 0); // 画出敌人的子弹
for (int j = 0; j < et.ss.size(); j++) {
// 取出子弹
Shot enemyShot = et.ss.get(j);
if (enemyShot != null && enemyShot.isLive == true) {
g.draw3DRect(enemyShot.x, enemyShot.y, 1, 1, false);
}
if (enemyShot.isLive == false) {
// 如果敌人的坦克死亡了,就从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) {
if (this.hitTank(enemyShot, hero)) { }
}
}
}
} // 判断我的子弹是否击中敌人的坦克
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) {
if (this.hitTank(myShot, et)) { // 减少敌人数量
Recorder.reduceEnNum();
// 增加我的记录
Recorder.addEnNumRec();
}
} }
}
}
} // 写一个函数 专门判断是否击中敌人坦克(原来第二参数: EnemyTank et)
// void改成boolean 判断击中的目标是谁 public boolean hitTank(Shot s, Tank1_2 et) {
boolean b2 = false; // 判断该坦克的方向
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;
b2 = true;
// 创建一颗炸弹,放入Vector
Bomb b = new Bomb(et.x, et.y);
// 放入Vector
bombs.add(b); } break;
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;
b2 = true;
// 创建一颗炸弹,放入Vector
Bomb b = new Bomb(et.x, et.y);
// 放入Vector
bombs.add(b); }
break;
} return b2; } // 画出坦克的函数
public void drawTank(int x, int y, Graphics g, int direct, int type) {
// 坦克类型
switch (type) {
case 0:
g.setColor(Color.green);
break;
case 1:
g.setColor(Color.yellow);
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.drawLine(x + 10, y + 15, x + 10, 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 + 5, 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;
} } @Override
public void keyPressed(KeyEvent e) {
// TODO Auto-generated method stub
// 已更正为顺时针
if (e.getKeyCode() == KeyEvent.VK_UP || e.getKeyCode() == KeyEvent.VK_W) {
this.hero.moveUp();
this.hero.setDirect(0);
} else if (e.getKeyCode() == KeyEvent.VK_RIGHT
|| e.getKeyCode() == KeyEvent.VK_D) {
this.hero.setDirect(1);
this.hero.moveRight();
} else if (e.getKeyCode() == KeyEvent.VK_DOWN
|| e.getKeyCode() == KeyEvent.VK_S) {
this.hero.moveDown();
this.hero.setDirect(2);
} else if (e.getKeyCode() == KeyEvent.VK_LEFT
|| e.getKeyCode() == KeyEvent.VK_A) {
this.hero.moveLeft();
this.hero.setDirect(3);
} else if (e.getKeyCode() == KeyEvent.VK_J) {
// 将J键设置为发出子弹
// 子弹连发,J被按几下,发几颗:this.hero.shotEnemy();
// this.repaint();在run函数里,不应该设计在这里
if (this.hero.ss.size() <= 4) {
this.hero.shotEnemy();
}
}
// 必须重新绘制Panel
this.repaint();
} @Override
public void keyReleased(KeyEvent e) {
// TODO Auto-generated method stub } @Override
public void keyTyped(KeyEvent e) {
// TODO Auto-generated method stub } @Override
public void run() {
// TODO Auto-generated method stub
// 每隔100毫秒去重绘
while (true) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} // 谨记这里:由于这里多写了这些,线程每次都被重新调用
// showInfo的信息不会动态改变 调了好久好久。苦笑脸
// 判断是否击中(写在这里,虽然在每次重绘的时候都要调用,但是没办法)
// 每一颗子弹都要和每个坦克进行匹配
// 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.hitEnemyTank(); this.hitMe(); // 重绘
this.repaint();
}
}
}

Menbers类:

package com.fanghua6;

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.Vector;
import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioInputStream;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.DataLine;
import javax.sound.sampled.SourceDataLine; //播放声音的类
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;
} 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();
}
}
} // 继续上一局的记记录点的类
class Node {
int x;
int y;
int direct; public Node(int x, int y, int direct) {
this.x = x;
this.y = y;
this.direct = direct;
}
} // 记录类,同时也可以保存玩家的设置(一般都是事先写在缓存里面的)
class Recorder {
// 记录每关有多少敌人
private static int enNum = 20;
// 设置我有多少可以用的坦克
private 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; private Vector<EnemyTank> ets = new Vector<EnemyTank>(); // 完成读取的函数(记录点和敌人的数量)
public Vector<Node> getNodesAndEnNums() {
try {
fr = new FileReader("E:/Tanke.txt");
br = new BufferedReader(fr);
String n = "";
n = br.readLine();// 设置先读第一行
allEnNum = Integer.parseInt(n);
// 接着读
while ((n = br.readLine()) != null) {
String[] xyz = n.split(" ");
// 在知道只有三条数据的情况下,用了这个方法。否则要用for循环
Node node = new Node(Integer.parseInt(xyz[0]),
Integer.parseInt(xyz[1]), Integer.parseInt(xyz[2]));
nodes.add(node);
} } catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
try {
br.close();
fr.close();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
return nodes;
} public Vector<EnemyTank> getEts() {
return ets;
} public void setEts(Vector<EnemyTank> ets) {
this.ets = ets;
} // 保存击毁敌人的数量和击毁敌人坦克的坐标、方向
public void keepRecAndEnemyTank() {
try {
fw = new FileWriter("E:/Tanke.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 recode = et.x + " " + et.y + " " + et.direct;
// 写入
bw.write(recode + "\r\n"); }
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
try {
bw.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
fw.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
} // 从文件中读取,记录
public static void getRecoring() {
try {
fr = new FileReader("E:/Tanke.txt");
br = new BufferedReader(fr);
String n = br.readLine();
allEnNum = Integer.parseInt(n);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
try {
br.close();
fr.close();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} } // 把玩家击毁敌人坦克数量保存到文件中
public static void keepRecording() {
try {
fw = new FileWriter("E:/Tanke.txt");
bw = new BufferedWriter(fw); bw.write(allEnNum + "\r\n");
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
try {
bw.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
fw.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} } } public static int getAllEnNum() {
return allEnNum;
} public static void setAllEnNum(int allEnNum) {
Recorder.allEnNum = allEnNum;
} public static int getEnNum() {
return enNum;
} public static void setEnNum(int enNum) {
Recorder.enNum = enNum;
} public static int getMyLife() {
return myLife;
} public void setMyLife(int myLife) {
Recorder.myLife = myLife;
} // 减少敌人数
public static void reduceEnNum() {
enNum--;
} // 消灭敌人
public static void addEnNumRec() {
allEnNum++;
} } // 炸弹类(没必要定义为线程,因为它不会移动,没有坐标改变)
class Bomb {
// 定义炸弹的坐标
int x, y;
int life = 9;// 炸弹的生命(三张图片)
// 可以看出isLive很有用,它可以决定类(或者对象)要不要展现在面板上
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 Shot implements Runnable {
int x;
int y;
int direct;
// 设置子弹的消亡(默认活着的)
boolean isLive = true;
// speed要给个初始值1,之前给0,按J键,子弹没有动
int speed = 1; public Shot(int x, int y, int direct) {
super();
this.x = x;
this.y = y;
this.direct = direct; } @Override
public void run() {
// TODO Auto-generated method stub while (true) {
// 设置子弹休息50毫秒 try {
Thread.sleep(50);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} 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 > 400 || y < 0 || y > 300) {
this.isLive = false;
break;
}
}
}
} // 坦克类
class Tank1_2 { int x = 0;
int y = 0;
boolean isLive = true; // 坦克方向:0表示上,1表示右,2表示下,3表示左
int direct = 0;
int speed = 1;
// 坦克的颜色
int color; public int getColor() {
return color;
} public void setColor(int color) {
this.color = color;
} public int getSpeed() {
return speed;
} public void setSpeed(int speed) {
this.speed = speed;
} public int getDirect() {
return direct;
} public void setDirect(int direct) {
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 Tank1_2(int x, int y) {
this.x = x;
this.y = y; } } // 敌人的坦克(做成线程,会移动)
class EnemyTank extends Tank1_2 implements Runnable { int times = 0;
// 定义一个向量,可以访问MyPanel上所有敌人的坦克
Vector<EnemyTank> ets = new Vector<EnemyTank>();
// 定义向量,可以存放敌人的子弹
Vector<Shot> ss = new Vector<Shot>(); // 敌人添加子弹,应该刚刚创建坦克和敌人子弹死亡后 public EnemyTank(int x, int y) {
super(x, y);
} // 得到MyPaneld的敌人坦克向量
public void setEts(Vector<EnemyTank> vv) {
// 此时拥有一种能力,可以拿到yPan el上所有敌人的坦克
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 + 20 <= 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 + 20) {
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;
}
}
}
}
break;
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 + 20 <= 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 >= et.x && this.x <= 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 + 20) {
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 + 20 >= et.y
&& this.y + 20 <= 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 >= et.x && this.x <= et.x + 30
&& this.y + 20 >= et.y
&& this.y + 20 <= et.y + 20) {
return true;
}
}
}
}
break;
}
return b;
} @Override
public void run() {
// TODO Auto-generated method stub
while (true) {
try {
// 设置坦克休息一会
Thread.sleep(50);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
switch (this.direct) {
case 0:
// 说明坦克正在向上运动(继续往上走,符合实际)
// y -= speed;设置坦克平滑移动的效果
for (int i = 0; i < 30; i++) {
if (y > 0 && !this.isTouchOtherEnemy()) {
y -= speed;
}
try {
Thread.sleep(50);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
break;
case 1:
for (int i = 0; i < 30; i++) {
// 这里注意坐标起点问题不是(400x300)
if (x < 400 && !this.isTouchOtherEnemy()) {
x += speed;
}
try {
Thread.sleep(50);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
break;
case 2:
for (int i = 0; i < 30; i++) {
if (y < 300 && !this.isTouchOtherEnemy()) {
y += speed;
}
try {
Thread.sleep(50);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
break;
case 3:
for (int i = 0; i < 30; i++) {
if (x > 0 && !this.isTouchOtherEnemy()) {
x -= speed;
}
try {
Thread.sleep(50);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
break;
}
this.times++;
// 设置3秒发一颗子弹
if (times % 2 == 0) {
if (isLive) {
if (ss.size() < 5) {
Shot s = null;
// 没有子弹,添加
switch (direct) {
case 0:
s = new Shot(x + 10, y, 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 + 10, y + 30, 2);
ss.add(s);
break;
case 3:
s = new Shot(x, y + 10, 3);
ss.add(s);
break;
}
// 启动子弹线程
Thread t = new Thread(s);
t.start();
}
}
}
// 让坦克随机产生一个新的方向
this.direct = (int) (Math.random() * 4);
// 判断敌人坦克是否死亡了(双等号)
if (this.isLive == false) {
// 让坦克死亡,后退出线程
return;
} }
}
} // 我的坦克
class Hero1_2 extends Tank1_2 {
// 多个子弹,用向量创建
Vector<Shot> ss = new Vector<Shot>();
// 子弹
Shot s = null; public Hero1_2(int x, int y) {
super(x, y);
} // 坦克开火
public void shotEnemy() { switch (this.direct) {
case 0:
s = new Shot(x + 10, y, 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 + 10, y + 30, 2);
// 把子弹加入向量
ss.add(s);
break; case 3:
s = new Shot(x, y + 10, 3);
// 把子弹加入向量
ss.add(s);
break;
}
// 启动子弹线程(创建线程,赶紧传参,我在这里吃了大亏!)
Thread t = new Thread(s);
t.start();
} public void moveUp() {
y -= speed;
} public void moveRight() {
x += speed;
} public void moveDown() {
y += speed;
} public void moveLeft() {
x -= speed;
}
}

实现图片:

Java坦克大战(四)

相关素材:

1.爆炸效果的图片(3张)

Java坦克大战(四)Java坦克大战(四)Java坦克大战(四)

2.游戏声音素材

这个自己下载一个好啦(我的是上面命名为111.wav的文件,这里不支持上传)