人生在勤,不索何获。——张衡
本讲内容:坦克大战8.0版(面向对象的思想)
一、解决:防止敌人坦克重叠运动
1、定义一个Vector容器,装所有敌人的坦克(为了得到所有坦克坐标)
2、定义一个方法getEts()可以得到敌人的坦克(为了得到所有坦克坐标)
3、在我的我的面板的构造方法调用getEts()
4、定义一个判断是否碰到了别的敌人的坦克的方法isTouchOtherEnemy()
5、在设置敌人坦克随机走动那调用isTouchOtherEnemy()
二、解决:我方坦克死亡(即隐身)后,该处被子弹击中不再发生爆炸
1、在敌人的子弹是否击中我方的hitMe()中加入我方坦克有生命时才调用
三、同一个包下建二个文件分别为:MyTankGame、Members(负责其它成员譬如:制造坦克、子弹等)
MyTankGame类
package a;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.*;
/**
* 功能:坦克游戏的8.0版本
* 1:画出坦克
* 2:实现我方坦克可以上下左右移动
* 3:可以發射子彈,子彈可以連發(最多可以发5颗)
* 4:画出敌人的坦克
* 5:当我方坦克击中敌人坦克时,敌人的坦克就消失
* 6:消失时显示爆炸效果图
* 7:让敌人的坦克也可以自由随机的上下左右移动并在规定范围内移动。
* 8:让敌人坦克可以发射子弹
* 9:当敌人坦克打到我方会爆炸
* 10:防止敌人坦克重叠运动和我方坦克死亡(即隐身)后,该处被子弹击中不再发生爆炸
*/
public class MyTankGame extends JFrame {
MyPanel mp = null;
public static void main(String[] args) {
MyTankGame mtg = new MyTankGame();
}
// 构造函数
public MyTankGame() {
mp = new MyPanel();
this.addKeyListener(mp);// 注册监听
// 启东mp线程
Thread t = new Thread(mp);
t.start();
this.add(mp);
// 设置窗体属性
this.setTitle("坦克大战7.0版—小劲");
this.setLocation(300, 300);
this.setSize(500, 400);
this.setVisible(true);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
// 我的面板
class MyPanel extends JPanel implements KeyListener, Runnable {
// 定义一个坦克
Tank tank = null;
// 定义一个我的坦克
MyTank myTank = null;
// 定义敌人的坦克
Vector<EnemyTank> ets = new Vector<EnemyTank>();
// 定义炸弹的集合 (在击中中创建然后在Panel画出)
Vector<Bomb> bombs = new Vector<Bomb>();
int enSize = 10;
// 定义三张爆炸需要的图片,组成一颗炸弹
Image image1 = null;
Image image2 = null;
Image image3 = null;
// 构造函数
public MyPanel() { // 我的坦克
myTank = new MyTank(150, 250);
// 初始化敌人的坦克
for (int i = 0; i < enSize; i++) { // 创建一个敌人坦克
EnemyTank et = new EnemyTank((i + 1) * 50, 0);
et.setColor(0);
et.setDirect(2);
//将MyPanel的敌人的坦克容器交给该敌人的坦克
et.getEts(ets);
// 启东敌人的坦克
Thread t = new Thread(et);
t.start();
// 加入到面板中
ets.add(et);
}
// 初始化图片
image1 = Toolkit.getDefaultToolkit().getImage(
Panel.class.getResource("/bzxg1.gif"));
image2 = Toolkit.getDefaultToolkit().getImage(
Panel.class.getResource("/bzxg2.gif"));
image3 = Toolkit.getDefaultToolkit().getImage(
Panel.class.getResource("/bzxg3.gif"));
}
public void paint(Graphics g) {
super.paint(g);
/*
* 因为当打到第一辆坦克的时候才创建一个炸弹,第一次爆炸的时候图还没加载(加载图片内存太大)。 所以第一次就不能正常显示了,
* 所以才会出现第一辆坦克没有爆炸效果,因为在击中第一辆坦克之前,
* vector里并没有放入炸弹。想要第一辆坦克有爆炸效果,那么在击中第一辆坦克之前就创建一颗炸弹
*/
g.drawImage(image1, 100, 100, 30, 30, this);
g.drawImage(image2, 100, 100, 30, 30, this);
g.drawImage(image3, 100, 100, 30, 30, this);
// 设置图像的背景色
g.fillRect(0, 0, 600, 400);
// 畫出自己的坦克
if(myTank.isLive){
this.drawTank(myTank.getX(), myTank.getY(), g, myTank.direct, 1);
}
// 画出敌人的坦克
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);
}
}
}
}
// 画出炸弹
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); // 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();
// 如果炸弹的生命值为0,就把炸弹bombs去掉
if (b.life == 0) {
bombs.remove(b);
}
}
// 我的坦克从ss中取出每一颗子弹并画出
for (int i = 0; i < myTank.ss.size(); i++) {
Shot myShot = myTank.ss.get(i);
// 画子弹,畫出一顆子彈
if (myShot != null && myTank.s.isLive == true) {
g.draw3DRect(myShot.x, myShot.y, 1, 1, false);
}
// 删除符合条件的子弹
if (myShot.isLive == false) {
// 从ss中删掉该子弹
myTank.ss.remove(myShot);// 不要写i
}
}
}
//判断我的子弹是否击中敌人的坦克
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) {
this.hitTank(myShot, et);
}
}
}
}
}
//敌人的子弹是否击中我方
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(myTank.isLive){
this.hitTank(enemyShot, myTank);
}
}
}
}
// 写一个函数专门判断子弹对否击中敌人的坦克(考虑在什么地方调用函数?在Panel中run())
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;
// 创建一颗炸弹,放入到Vcetor
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;
// 创建一颗炸弹,放入到Vcetor
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.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);
// 4:画出圆形
g.fillOval(x + 5, y + 10, 10, 10);
// 5:绘制炮筒
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: // 向下
// 1:绘制左边的矩形
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);
// 4:画出圆形
g.fillOval(x + 5, y + 10, 10, 10);
// 5:绘制炮筒
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 - 3, y + 10);
break;
}
}
// 键按下处理 a s w d
public void keyPressed(KeyEvent e) {
if (e.getKeyCode() == KeyEvent.VK_W) {
// 向上 前进
this.myTank.setDirect(0);
this.myTank.moveUp();
} else if (e.getKeyCode() == KeyEvent.VK_D) {
// 向右前进
this.myTank.setDirect(1);
this.myTank.moveRight();
} else if (e.getKeyCode() == KeyEvent.VK_S) {
// 向下前进
this.myTank.setDirect(2);
this.myTank.moveDown();
} else if (e.getKeyCode() == KeyEvent.VK_A) {
// 向左前进
this.myTank.setDirect(3);
this.myTank.moveLeft();
}
if (e.getKeyCode() == KeyEvent.VK_J) {// 不用else if是為了防止走動時發不了子彈
// 判断玩家是否按下J键 開火
if (this.myTank.ss.size() < 5) {// 使最多发5颗子弹
this.myTank.shotEnemy();
}
}
// 重新绘制窗口
this.repaint();
}
public void keyReleased(KeyEvent e) {
}
public void keyTyped(KeyEvent e) {
}
public void run() {
// 每隔100毫秒重新绘制子弹
while (true) {
try {
Thread.sleep(100);
} catch (Exception e) {
e.printStackTrace();
}
this.hitEnemyTank();
//调用 判断敌人的子弹是否击中我的方法
this.hitMe();
// 重新绘制窗口
this.repaint();
}
}
}
Members类
package a;
import java.util.Vector;
//炸弹类
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 Shot implements Runnable {// 创建线程使子弹跑起来 //子弹在哪创建就在启动线程
int x;
int y;
int direct;
int speed = 5;
// 是否还活着
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 (Exception e) {
// TODO: handle exception
}
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="+y);
// 子弹何时死亡
// 判断该子弹是否碰到边缘
if (x < 0 || x > 500 || y < 0 || y > 400) {
this.isLive = false;
break;
}
}
}
}
// 定义一个坦克类
class Tank {
// 表示坦克的横坐标x 和纵坐标y
int x = 0;
int y = 0;
// 定义方向 0表示向上 1表示右, 2表示下 3表示左
int direct = 0;
// 坦克颜色
int color = 0;
// 坦克速度
int speed = 5;
boolean isLive = true;
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;
}
public int getDirect() {
return direct;
}
public void setDirect(int direct) {
this.direct = direct;
}
public int getSpeed() {
return speed;
}
public void setSpeed(int speed) {
this.speed = speed;
}
public int getColor() {
return color;
}
public void setColor(int color) {
this.color = color;
}
}
// 敌人的坦克
class EnemyTank extends Tank implements Runnable {
int times;
// 子弹
Shot s = null;
// 定义子弹容器使可以連發
Vector<Shot> ss = new Vector<Shot>();
// 定义一个容器,可以访问到MyPanel 上所有的坦克
Vector<EnemyTank> ets = new Vector<EnemyTank>();
public EnemyTank(int x, int y) {
super(x, y);
}
// 得到MyPanel中的敌人的坦克容器(在哪调用)
public void getEts(Vector<EnemyTank> ets) {
this.ets = ets;
}
// 判断是否碰到了别的敌人的坦克
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 >= 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 == 3 || et.direct == 1) {
if (this.x >= et.x && this.x <= et.x + 20
&& this.y >= 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 >= 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 == 3 || et.direct == 1) {
if (this.x + 30 >= et.x && this.x + 30 <= et.x + 20
&& this.y >= 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 >= 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 == 3 || et.direct == 1) {
if (this.x >= et.x && this.x <= et.x + 20
&& this.y + 30 >= 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 >= 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 == 3 || et.direct == 1) {
if (this.x + 20 >= et.x && this.x + 20 <= et.x + 20
&& this.y >= 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;
}
public void run() {
while (true) {
switch (this.direct) {
case 0:// 说明坦克正在向上移动
for (int i = 0; i < 30; i++) {
if (y > 0 && !this.isTouchOtherEnemy()) {// 在规定范围行动
y -= speed;
}
try {
Thread.sleep(50);
} catch (Exception e) {
e.printStackTrace();
}
}
break;
case 1:// 说明坦克正在向右移动
for (int i = 0; i < 30; i++) {
if (x < 440 && !this.isTouchOtherEnemy()) {// 注意坐标是左上边
x += speed;
}
try {
Thread.sleep(50);
} catch (Exception e) {
e.printStackTrace();
}
}
break;
case 2:// 说明坦克正在向下移动
for (int i = 0; i < 30; i++) {
if (y < 340 && this.isTouchOtherEnemy()) {
y += speed;
}
try {
Thread.sleep(50);
} catch (Exception e) {
e.printStackTrace();
}
}
break;
case 3:// 说明坦克正在向左移动
for (int i = 0; i < 30; i++) {
if (x > 0 && !this.isTouchOtherEnemy()) {
x -= speed;
}
try {
Thread.sleep(50);
} catch (Exception e) {
e.printStackTrace();
}
}
break;
}
this.times++;
// 判断是否需要给坦克加入新的子弹
if (times % 2 == 0) {// 使3秒添加一次(因为sleep1.5秒)
if (isLive) {
if (ss.size() < 5) {
// 每辆每3秒添加子弹
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) {
// 让坦克死亡后推出线程
break;
}
}
}
}
// 我的坦克
class MyTank extends Tank {
// 子弹
Shot s = null;
// 定义子弹容器使可以連發
Vector<Shot> ss = new Vector<Shot>();
public MyTank(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);// 放入子弹容器 然后在JPanel畫出來
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;
}
}
本讲就到这里,Take your time and enjoy it