java零基础Ⅱ-- 9.坦克大战[2]
坦克大战0.3
在坦克大战游戏(0.2)基础上添加版本如下功能：
当玩家按一下 j 键，就发射一颗子弹。
分析
分析如何实现当用户按下J键，我们的坦克就发射一颗子弹：
思路：
- 当发射一颗子弹后，就相当于启动一个线程
- MyTank 有子弹的对象，当按下J键时，我们就启动一个发射行为(线程)，让子弹不停的移动，形成一个射击效果
- 我们MyPanel 需要不停的重绘，才能出现该效果
- 当子弹移动到面板的边界时，就应销毁(把启动的子弹的线程销毁)
让自己的坦克发射子弹
package com.zzpedu.tankgame3;
/**
* @author zzp
*/
public class Tank {
private int x;//坦克的横坐标
private int y;//坦克的纵坐标
private int direct;//坦克的方向 0上 1右 2下 3左
private int speed = 5;//坦克的速度
public Tank(int x, int y) {
this.x = x;
this.y = y;
}
//上右下左移动方法
public void moveUp(){
y -= speed;
}
public void moveRight(){
x += speed;
}
public void moveDown(){
y += speed;
}
public void moveLeft(){
x -= speed;
}
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; }
}
package com.zzpedu.tankgame3;
/**
* 自己的坦克
* @author zzp
*/
public class MyTank extends Tank {
//定义一个shot对象，表示一个射击行为/线程
Shot shot = null;
public MyTank(int x, int y) {
super(x, y);
}
//射击
public void shotEnemyTank(){
//创建 Shot 对象，根据当前对象MyTank对象的位置和方向来创建Shot
switch (getDirect()){//得到MyTank对象方向
case 0://向上
shot = new Shot(getX() + 20,getY(),0);
break;
case 1://向右
shot = new Shot(getX() + 60,getY() + 20,1);
break;
case 2://向下
shot = new Shot(getX() + 20,getY() + 60,2);
break;
case 3://向左
shot = new Shot(getX() ,getY() + 20,3);
break;
}
//启动我们的Shot线程
new Thread(shot).start();
}
}
package com.zzpedu.tankgame3;
/**
* 敌人的坦克
* @author zzp
*/
public class EnemyTank extends Tank {
public EnemyTank(int x, int y) {
super(x, y);
}
}
package com.zzpedu.tankgame3;
/**
* 射击子弹
*/
public class Shot implements Runnable{
int x;//子弹x坐标
int y;//子弹y坐标
int direct = 0;//子弹方向
int speed = 2;//子弹速度
boolean isLive = true;//子弹是否还存活
//构造器
public Shot(int x, int y, int direct) {
this.x = x;
this.y = y;
this.direct = direct;
}
@Override
public void run() {//射击行为
while (true){
//让线程休眠50毫秒
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
//根据方向来改变x,y坐标
switch (direct){
case 0://向上
y -= speed;
break;
case 1://向右
x += speed;
break;
case 2://向下
y += speed;
break;
case 3://向左
x -= speed;
break;
}
//测试，这里我们输出x,y的坐标
System.out.println("子弹 x=" + x + " y=" + y);
//当子弹移动到面板的边界时，就应销毁(把启动的子弹的线程销毁)
if(!(x >= 0 && x<= 1000 && y >=0 && y <= 750)){
System.out.println("子弹移动到边界了 退出~ x=" + x + " y=" + y );
isLive = false;
break;
}
}
}
}
package com.zzpedu.tankgame3;
import javax.swing.*;
import java.awt.*;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.util.Vector;
/**
* 坦克大战的绘图区域
* @author zzp
*/
//为了监听键盘事件，要实现KeyListener
//为了让Panel 不停的重绘子弹，需要加 MyPanel 实现Runnable，当做一个线程使用
public class MyPanel extends JPanel implements KeyListener,Runnable {
//定义我的坦克
MyTank myTank = null;
//定义敌人坦克，放入Vector中
Vector<EnemyTank> enemyTanks = new Vector<>();
int enemyTankSize = 3;
public MyPanel(){
myTank = new MyTank(100,100);//初始化自己的坦克
myTank.setSpeed(3);
//初始化敌人的坦克
for(int i = 0; i < enemyTankSize; i++){
//创建一个敌人的坦克
EnemyTank enemyTank = new EnemyTank((100 * (i + 1)), 0);
//设置方向
enemyTank.setDirect(2);
//加入
enemyTanks.add(enemyTank);
}
}
//绘图
@Override
public void paint(Graphics g){
super.paint(g);
g.fillRect(0,0,1000,750);//填充矩形，默认是黑色
//画出自己坦克-封装方法
drawTank(myTank.getX(),myTank.getY(),g,myTank.getDirect(),1);
//画出myTank射击的子弹
if(myTank.shot != null && myTank.shot.isLive == true){
System.out.println("子弹被绘制~");
//g.fill3DRect(myTank.shot.x,myTank.shot.y,1,1,false);
g.draw3DRect(myTank.shot.x,myTank.shot.y,2,2,false);
}
//画出敌人的坦克,遍历Vector
for(int i = 0; i < enemyTanks.size(); i++){
EnemyTank enemyTank = enemyTanks.get(i);
drawTank(enemyTank.getX(),enemyTank.getY(),g,enemyTank.getDirect(),0);
}
}
/**
* 编写方法，画出坦克
* @param x 坦克的左上角x坐标
* @param y 坦克的左上角y坐标
* @param g 画笔
* @param direct 坦克的方向（上下左右）
* @param type 坦克类型
*/
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;
}
//根据坦克的方向，来绘制对应形状的坦克
//direct 表示方向(0:向上 1:向右 2:向下 3:向左)
switch (direct){
case 0://表示向上方向
g.fill3DRect(x,y,10,60,false);//画出坦克左边的轮子
g.fill3DRect(x + 30,y,10,60,false);//画出坦克右边的轮子
g.fill3DRect(x + 10,y + 10,20,40,false);//画出坦克盖子
g.fillOval(x + 10,y + 20,20,20);//画出坦克圆盖子
g.drawLine(x + 20,y + 30, x + 20,y);//画出炮筒
break;
case 1://表示向右
g.fill3DRect(x,y,60,10,false);//画出坦克上边的轮子
g.fill3DRect(x ,y + 30,60,10,false);//画出坦克下边的轮子
g.fill3DRect(x + 10,y + 10,40,20,false);//画出坦克盖子
g.fillOval(x + 20,y + 10,20,20);//画出坦克圆盖子
g.drawLine(x + 30,y + 20, x + 60,y + 20);//画出炮筒
break;
case 2://表示向下
g.fill3DRect(x,y,10,60,false);//画出坦克左边的轮子
g.fill3DRect(x + 30,y,10,60,false);//画出坦克右边的轮子
g.fill3DRect(x + 10,y + 10,20,40,false);//画出坦克盖子
g.fillOval(x + 10,y + 20,20,20);//画出坦克圆盖子
g.drawLine(x + 20,y + 30, x + 20,y + 60);//画出炮筒
break;
case 3://表示向左
g.fill3DRect(x,y,60,10,false);//画出坦克上边的轮子
g.fill3DRect(x ,y + 30,60,10,false);//画出坦克下边的轮子
g.fill3DRect(x + 10,y + 10,40,20,false);//画出坦克盖子
g.fillOval(x + 20,y + 10,20,20);//画出坦克圆盖子
g.drawLine(x + 30,y + 20, x,y + 20);//画出炮筒
break;
default:
System.out.println("暂时没有处理");
}
}
@Override
public void keyTyped(KeyEvent e) {
}
//处理按键事件 wdsa
@Override
public void keyPressed(KeyEvent e) {
if(e.getKeyCode() == KeyEvent.VK_W){//按下W键
//改变坦克方向 上
myTank.setDirect(0);
//修改坦克的坐标 y -= 1
myTank.moveUp();
}else if(e.getKeyCode() == KeyEvent.VK_D){//按下D键
//改变坦克方向 右
myTank.setDirect(1);
myTank.moveRight();
}else if(e.getKeyCode() == KeyEvent.VK_S){//按下S键
//改变坦克方向 下
myTank.setDirect(2);
myTank.moveDown();
}else if(e.getKeyCode() == KeyEvent.VK_A){//按下A键
//改变坦克方向 左
myTank.setDirect(3);
myTank.moveLeft();
}
//如果用户按下的是J键，就发射子弹
if(e.getKeyCode() == KeyEvent.VK_J){
System.out.println("用户按下了J，开始射击~");
myTank.shotEnemyTank();
}
//让面板重绘
this.repaint();
}
@Override
public void keyReleased(KeyEvent e) {
}
@Override
public void run() {//每个 100毫秒 重绘区域，刷新绘图区域，子弹移动起来
while (true){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.repaint();
}
}
}
package com.zzpedu.tankgame3;
import javax.swing.*;
/**
* @author zzp
*/
public class ZzpTankGame03 extends JFrame {
//定义MyPanel
MyPanel mp = null;
public static void main(String[] args) {
ZzpTankGame03 zzpTankGame03 = new ZzpTankGame03();
}
public ZzpTankGame03() {//构造器
mp = new MyPanel();
//将mp 放入Thread，并启动
new Thread(mp).start();
this.add(mp);//把面板(就是游戏的绘图区域)
this.setSize(1000,750);
//让JFrame 监听mp键盘事件
this.addKeyListener(mp);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setVisible(true);
}
}
运行效果：
坦克大战0.4版
增加功能[ZzpTankGame04]
1、人敌人的坦克能够发射子弹(可以有多颗子弹)
2、当我方坦克击中坦克，敌人的坦克就消失，如果能做出爆炸效果更好
3、让敌人的坦克也可以自由随机的上下左右移动
4、控制我方的坦克和敌人的坦克在规定的范围移动
敌人发射子弹
人敌人的坦克能够发射子弹(可以有多颗子弹)
1、在敌人坦克类，使用Vector 保存多个Shot
2、当每创建敌人坦克时，给该敌人坦克对象初始化一个Shot对象，同时启动Shot
3、在绘制坦克时，需要遍历敌人坦克对象Vector，绘制使用的子弹。当子弹isLive == false 时，就从 Vector 移除
package com.zzpedu.tankgame4;
import java.util.Vector;
/**
* 敌人的坦克
* @author zzp
*/
public class EnemyTank extends Tank {
//敌人的坦克类，使用Vector 保存多个Shot
Vector<Shot> shots = new Vector<>();
public EnemyTank(int x, int y) {
super(x, y);
}
}
package com.zzpedu.tankgame4;
import javax.swing.*;
import java.awt.*;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.util.Vector;
/**
* 坦克大战的绘图区域
* @author zzp
*/
//为了监听键盘事件，要实现KeyListener
//为了让Panel 不停的重绘子弹，需要加 MyPanel 实现Runnable，当做一个线程使用
public class MyPanel extends JPanel implements KeyListener,Runnable {
//定义我的坦克
MyTank myTank = null;
//定义敌人坦克，放入Vector中
Vector<EnemyTank> enemyTanks = new Vector<>();
int enemyTankSize = 3;
public MyPanel(){
myTank = new MyTank(100,100);//初始化自己的坦克
myTank.setSpeed(3);
//初始化敌人的坦克
for(int i = 0; i < enemyTankSize; i++){
//创建一个敌人的坦克
EnemyTank enemyTank = new EnemyTank((100 * (i + 1)), 0);
//设置方向
enemyTank.setDirect(2);
//给该enemyTank 加入一颗子弹
Shot shot = new Shot(enemyTank.getX() + 20, enemyTank.getY() + 60, enemyTank.getDirect());
//加入enemyTank的Vector 成员
enemyTank.shots.add(shot);
//启动shot 对象
new Thread(shot).start();
//加入
enemyTanks.add(enemyTank);
}
}
//绘图
@Override
public void paint(Graphics g){
super.paint(g);
g.fillRect(0,0,1000,750);//填充矩形，默认是黑色
//画出自己坦克-封装方法
drawTank(myTank.getX(),myTank.getY(),g,myTank.getDirect(),1);
//画出myTank射击的子弹
if(myTank.shot != null && myTank.shot.isLive == true){
//System.out.println("子弹被绘制~");
//g.fill3DRect(myTank.shot.x,myTank.shot.y,1,1,false);
g.draw3DRect(myTank.shot.x,myTank.shot.y,2,2,false);
}
//画出敌人的坦克,遍历Vector
for(int i = 0; i < enemyTanks.size(); i++){
EnemyTank enemyTank = enemyTanks.get(i);
drawTank(enemyTank.getX(),enemyTank.getY(),g,enemyTank.getDirect(),0);
//画出 enemyTank 所有子弹
for(int j = 0; j < enemyTank.shots.size(); j++){
//取出子弹
Shot shot = enemyTank.shots.get(j);
//绘制
if(shot.isLive){// shot.isLive == true
g.draw3DRect(shot.x,shot.y,2,2,false);
}else {
//从Vector移除
enemyTank.shots.remove(shot);
}
}
}
}
....
}
运行效果：
敌方坦克消失
添加敌人的坦克存活状态
package com.zzpedu.tankgame4;
import java.util.Vector;
/**
* 敌人的坦克
* @author zzp
*/
public class EnemyTank extends Tank {
//敌人的坦克类，使用Vector 保存多个Shot
Vector<Shot> shots = new Vector<>();
boolean isLive = true;//坦克是否还存活
public EnemyTank(int x, int y) {
super(x, y);
}
}
在MyPanel 类，编写hitTank方法，判断我方的子弹是否击中敌人坦克，在run方法添加进去，修改paint方法
package com.zzpedu.tankgame4;
import javax.swing.*;
import java.awt.*;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.util.Vector;
/**
* 坦克大战的绘图区域
* @author zzp
*/
//为了监听键盘事件，要实现KeyListener
//为了让Panel 不停的重绘子弹，需要加 MyPanel 实现Runnable，当做一个线程使用
public class MyPanel extends JPanel implements KeyListener,Runnable {
...
//绘图
@Override
public void paint(Graphics g){
super.paint(g);
g.fillRect(0,0,1000,750);//填充矩形，默认是黑色
//画出自己坦克-封装方法
drawTank(myTank.getX(),myTank.getY(),g,myTank.getDirect(),1);
//画出myTank射击的子弹
if(myTank.shot != null && myTank.shot.isLive == true){
//System.out.println("子弹被绘制~");
//g.fill3DRect(myTank.shot.x,myTank.shot.y,1,1,false);
g.draw3DRect(myTank.shot.x,myTank.shot.y,2,2,false);
}
//画出敌人的坦克,遍历Vector
for(int i = 0; i < enemyTanks.size(); i++){
//从Vector 取出坦克
EnemyTank enemyTank = enemyTanks.get(i);
//判断当前坦克是否还存活
if (enemyTank.isLive){//当敌人坦克是存活的，才画出该坦克
drawTank(enemyTank.getX(),enemyTank.getY(),g,enemyTank.getDirect(),0);
//画出 enemyTank 所有子弹
for(int j = 0; j < enemyTank.shots.size(); j++){
//取出子弹
Shot shot = enemyTank.shots.get(j);
//绘制
if(shot.isLive){// shot.isLive == true
g.draw3DRect(shot.x,shot.y,2,2,false);
}else {
//从Vector移除
enemyTank.shots.remove(shot);
}
}
}
}
}
//编写方法，判断我方的子弹是否击中敌人坦克
//什么时候判断 我方子弹是否击中敌人坦克？ 在run方法 判断
public static void hitTank(Shot shot,EnemyTank enemyTank){
//判断shot 击中坦克
switch (enemyTank.getDirect()){
case 0://坦克向上
case 2://坦克向下
if(shot.x > enemyTank.getX() && shot.x < enemyTank.getX() + 40
&& shot.y > enemyTank.getY() && shot.y < enemyTank.getY() + 60 ){
//击中
shot.isLive = false;
enemyTank.isLive = false;
}
break;
case 1://坦克向右
case 3://坦克向左
if(shot.x > enemyTank.getX() && shot.x < enemyTank.getX() + 60
&& shot.y > enemyTank.getY() && shot.y < enemyTank.getY() + 40 ){
//击中
shot.isLive = false;
enemyTank.isLive = false;
}
break;
}
}
...
@Override
public void run() {//每个 100毫秒 重绘区域，刷新绘图区域，子弹移动起来
while (true){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
//判断是否击中 敌人的坦克
if(myTank.shot != null && myTank.shot.isLive){//当我方子弹还存活
//遍历敌人所以坦克
for (int i = 0; i < enemyTanks.size(); i++) {
EnemyTank enemyTank = enemyTanks.get(i);
hitTank(myTank.shot,enemyTank);
}
}
this.repaint();
}
}
}
修改Shot类run方法，判断子弹存活状态
package com.zzpedu.tankgame4;
/**
* 射击子弹
*/
public class Shot implements Runnable{
...
@Override
public void run() {//射击行为
while (true){
//让线程休眠50毫秒
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
//根据方向来改变x,y坐标
switch (direct)...
//测试，这里我们输出x,y的坐标
System.out.println("子弹 x=" + x + " y=" + y);
//当子弹移动到面板的边界时，就应销毁(把启动的子弹的线程销毁)
//当子弹碰到敌人坦克时，也应该结束线程
if(!(x >= 0 && x<= 1000 && y >=0 && y <= 750 && isLive)){
System.out.println("子弹移动到边界了 退出~ x=" + x + " y=" + y );
isLive = false;
break;
}
}
}
}
运行效果：
爆炸效果
先准备几张图片，图片就是坦克爆炸的图片（快速切换图片）
定义Bomb类
package com.zzpedu.tankgame4;
/**
* 炸弹
*/
public 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--;
}
//这里是为了显示第一次爆炸效果(时间间隔太小，看不到效果)，暂时为找到原因
try {
Thread.sleep(5);
} catch (InterruptedException e) {
e.printStackTrace();
}
if(life == 0){
isLive = false;
}
}
}
在MyPanel类，定义图片效果，事先准备图片，修改hitTank方法，判断我方的子弹是否击中敌人坦克，移除坦克
package com.zzpedu.tankgame4;
import javafx.scene.layout.Pane;
import javax.swing.*;
import java.awt.*;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.util.Vector;
/**
* 坦克大战的绘图区域
* @author zzp
*/
//为了监听键盘事件，要实现KeyListener
//为了让Panel 不停的重绘子弹，需要加 MyPanel 实现Runnable，当做一个线程使用
public class MyPanel extends JPanel implements KeyListener,Runnable {
//定义我的坦克
MyTank myTank = null;
//定义敌人坦克，放入Vector中
Vector<EnemyTank> enemyTanks = new Vector<>();
int enemyTankSize = 3;
//定义一个Vector，用于存放炸弹
//说明，当子弹击中坦克时，加入一个Bomb对象到bombs
Vector<Bomb> bombs = new Vector<>();
//定义三张炸弹图片，用于显示爆炸效果
Image image1 = null;
Image image2 = null;
Image image3 = null;
public MyPanel(){
myTank = new MyTank(100,100);//初始化自己的坦克
myTank.setSpeed(1);
//初始化敌人的坦克
for(int i = 0; i < enemyTankSize; i++){
//创建一个敌人的坦克
EnemyTank enemyTank = new EnemyTank((100 * (i + 1)), 0);
//设置方向
enemyTank.setDirect(2);
//给该enemyTank 加入一颗子弹
Shot shot = new Shot(enemyTank.getX() + 20, enemyTank.getY() + 60, enemyTank.getDirect());
//加入enemyTank的Vector 成员
enemyTank.shots.add(shot);
//启动shot 对象
new Thread(shot).start();
//加入
enemyTanks.add(enemyTank);
}
//初始化图片对象
image1 = Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/bomb1.png"));
image2 = Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/bomb2.png"));
image3 = Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/bomb3.png"));
}
//绘图
@Override
public void paint(Graphics g){
super.paint(g);
g.fillRect(0,0,1000,750);//填充矩形，默认是黑色
//画出自己坦克-封装方法
drawTank(myTank.getX(),myTank.getY(),g,myTank.getDirect(),1);
//画出myTank射击的子弹
if(myTank.shot != null && myTank.shot.isLive == true){
//System.out.println("子弹被绘制~");
//g.fill3DRect(myTank.shot.x,myTank.shot.y,1,1,false);
g.draw3DRect(myTank.shot.x,myTank.shot.y,2,2,false);
}
//如果bombs 集合中有对象，就画出
for (int i = 0; i < bombs.size(); i++) {
//取出炸弹
Bomb bomb = bombs.get(i);
//根据当前这个bomb对象的life值去画出对应的图片
if(bomb.life > 6){
g.drawImage(image1,bomb.x,bomb.y,60,60,this);
}else if(bomb.life > 3){
g.drawImage(image2,bomb.x,bomb.y,60,60,this);
}else {
g.drawImage(image3,bomb.x,bomb.y,60,60,this);
}
//让炸弹的生命值减少
bomb.lifeDown();
//如果bomb life 为0，就从bombs 的集合中删除
if(bomb.life == 0){
bombs.remove(bomb);
}
}
//画出敌人的坦克,遍历Vector
for(int i = 0; i < enemyTanks.size(); i++){
//从Vector 取出坦克
EnemyTank enemyTank = enemyTanks.get(i);
//判断当前坦克是否还存活
if (enemyTank.isLive){//当敌人坦克是存活的，才画出该坦克
drawTank(enemyTank.getX(),enemyTank.getY(),g,enemyTank.getDirect(),0);
//画出 enemyTank 所有子弹
for(int j = 0; j < enemyTank.shots.size(); j++){
//取出子弹
Shot shot = enemyTank.shots.get(j);
//绘制
if(shot.isLive){// shot.isLive == true
g.draw3DRect(shot.x,shot.y,2,2,false);
}else {
//从Vector移除
enemyTank.shots.remove(shot);
}
}
}
}
}
....
//编写方法，判断我方的子弹是否击中敌人坦克
//什么时候判断 我方子弹是否击中敌人坦克？ 在run方法 判断
public void hitTank(Shot shot,EnemyTank enemyTank){
//判断shot 击中坦克
switch (enemyTank.getDirect()){
case 0://坦克向上
case 2://坦克向下
if(shot.x > enemyTank.getX() && shot.x < enemyTank.getX() + 40
&& shot.y > enemyTank.getY() && shot.y < enemyTank.getY() + 60 ){
//击中
shot.isLive = false;
enemyTank.isLive = false;
//当我的子弹击中敌人坦克后，将enemyTank 从Vector 拿掉
enemyTanks.remove(enemyTank);
//创建Bomb对象，加入bombs集合
Bomb bomb = new Bomb(enemyTank.getX(), enemyTank.getY());
bombs.add(bomb);
}
break;
case 1://坦克向右
case 3://坦克向左
if(shot.x > enemyTank.getX() && shot.x < enemyTank.getX() + 60
&& shot.y > enemyTank.getY() && shot.y < enemyTank.getY() + 40 ){
//击中
shot.isLive = false;
enemyTank.isLive = false;
//当我的子弹击中敌人坦克后，将enemyTank 从Vector 拿掉
enemyTanks.remove(enemyTank);
//创建Bomb对象，加入bombs集合
Bomb bomb = new Bomb(enemyTank.getX(), enemyTank.getY());
bombs.add(bomb);
}
break;
}
}
...
}
运行效果：
让敌方坦克自由移动
让敌人的坦克也可以自由随机的上下左右移动
思路分析：
1、因为要求敌人坦克，可以自由移动，因此需要将坦克当做线程使用
2、我们要EnemyTank implements Runnable
3、在run方法写上我们相应的代码块
4、在创建敌人坦克对象时，启动线程
在EnemyTank类实现Runnable接口，在run方法添加业务代码
package com.zzpedu.tankgame4;
import java.util.Vector;
/**
* 敌人的坦克
* @author zzp
*/
public class EnemyTank extends Tank implements Runnable{
//敌人的坦克类，使用Vector 保存多个Shot
Vector<Shot> shots = new Vector<>();
boolean isLive = true;//坦克是否还存活
public EnemyTank(int x, int y) {
super(x, y);
}
@Override
public void run() {
while (true){
//根据坦克的方向来继续移动
switch (getDirect()){
case 0://向上
//让坦克保持一个方向，走30步
for (int i = 0; i < 30; i++) {
moveUp();
//休眠50毫秒
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
break;
case 1://向右
for (int i = 0; i < 30; i++) {
moveRight();
//休眠50毫秒
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
break;
case 2://向下
for (int i = 0; i < 30; i++) {
moveDown();
//休眠50毫秒
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
break;
case 3://向左
for (int i = 0; i < 30; i++) {
moveLeft();
//休眠50毫秒
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
break;
}
//然后随机的改变坦克方向 0-3
setDirect((int)(Math.random() * 4));
//写并发程序，一定要考虑清楚，该线程什么时候结束
if(!isLive){
break;//退出线程
}
}
}
}
在MyPanel类，构造器中启动敌人坦克线程
public class MyPanel extends JPanel implements KeyListener,Runnable {
//定义我的坦克
MyTank myTank = null;
//定义敌人坦克，放入Vector中
Vector<EnemyTank> enemyTanks = new Vector<>();
int enemyTankSize = 3;
...
public MyPanel(){
myTank = new MyTank(100,100);//初始化自己的坦克
myTank.setSpeed(1);
//初始化敌人的坦克
for(int i = 0; i < enemyTankSize; i++){
//创建一个敌人的坦克
EnemyTank enemyTank = new EnemyTank((100 * (i + 1)), 0);
//设置方向
enemyTank.setDirect(2);
//启动敌人坦克线程，让其动起来
new Thread(enemyTank).start();
//给该enemyTank 加入一颗子弹
Shot shot = new Shot(enemyTank.getX() + 20, enemyTank.getY() + 60, enemyTank.getDirect());
//加入enemyTank的Vector 成员
enemyTank.shots.add(shot);
//启动shot 对象
new Thread(shot).start();
//加入
enemyTanks.add(enemyTank);
}
...
}
...
}
运行效果：
控制坦克的移动范围
修改EnemyTank类，控制敌人坦克范围
public class EnemyTank extends Tank implements Runnable{
//敌人的坦克类，使用Vector 保存多个Shot
Vector<Shot> shots = new Vector<>();
boolean isLive = true;//坦克是否还存活
public EnemyTank(int x, int y) {
super(x, y);
}
@Override
public void run() {
while (true){
//根据坦克的方向来继续移动
switch (getDirect()){
case 0://向上
//让坦克保持一个方向，走30步
for (int i = 0; i < 30; i++) {
//判断范围
if(getY() > 0){
moveUp();
}
//休眠50毫秒
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
break;
case 1://向右
for (int i = 0; i < 30; i++) {
if((getX() + 60) < 1000){
moveRight();
}
//休眠50毫秒
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
break;
case 2://向下
for (int i = 0; i < 30; i++) {
if((getY() + 60) < 750){
moveDown();
}
//休眠50毫秒
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
break;
case 3://向左
for (int i = 0; i < 30; i++) {
if(getX() > 0){
moveLeft();
}
//休眠50毫秒
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
break;
}
//然后随机的改变坦克方向 0-3
//setDirect(3);//测试指定方向
setDirect((int)(Math.random() * 4));
//写并发程序，一定要考虑清楚，该线程什么时候结束
if(!isLive){
break;//退出线程
}
}
}
}
修改MyPanel类，keyPressed按键方法，控制我方坦克范围
public class MyPanel extends JPanel implements KeyListener,Runnable {
...
//处理按键事件 wdsa
@Override
public void keyPressed(KeyEvent e) {
if(e.getKeyCode() == KeyEvent.VK_W){//按下W键
//改变坦克方向 上
myTank.setDirect(0);
//修改坦克的坐标 y -= 1
if(myTank.getY() > 0){
myTank.moveUp();
}
}else if(e.getKeyCode() == KeyEvent.VK_D){//按下D键
//改变坦克方向 右
myTank.setDirect(1);
if((myTank.getX() + 60) < 1000){
myTank.moveRight();
}
}else if(e.getKeyCode() == KeyEvent.VK_S){//按下S键
//改变坦克方向 下
myTank.setDirect(2);
if((myTank.getY() + 60) < 750){
myTank.moveDown();
}
}else if(e.getKeyCode() == KeyEvent.VK_A){//按下A键
//改变坦克方向 左
myTank.setDirect(3);
if(myTank.getX() > 0){
myTank.moveLeft();
}
}
//如果用户按下的是J键，就发射子弹
if(e.getKeyCode() == KeyEvent.VK_J){
System.out.println("用户按下了J，开始射击~");
myTank.shotEnemyTank();
}
//让面板重绘
this.repaint();
}
}
运行效果：
坦克大战0.4版本
增加功能[ZzpTankGame04.java]
1、我方坦克在发射的子弹消亡后，才能发射新的子弹 ==> 扩展(发多颗子弹怎么办)
2、让敌人坦克发射的子弹消亡后，可以再发射子弹
3、方敌人的坦克击中我方坦克时，我方坦克消失，并出现爆炸效果
坦克发射多颗子弹
我方坦克在发射的子弹消亡后，才能发射新的子弹 ==> 扩展(发多颗子弹怎么办)
思路：
1、在按下J键，我们判断当前myTank对象的子弹，是否已经销毁
2、如果没有销毁，就不去触发 shotEnemyTank方法
3、如果已经销毁，才去触发 shotEnemyTank方法
4、如果要发射多颗子弹，就使用Vector集合保存
5、在绘制我方子弹需要变量该Vector集合
修改MyTank类
public class MyTank extends Tank {
//定义一个shot对象，表示一个射击行为/线程
Shot shot = null;
//可以发射多颗子弹
Vector<Shot> shots = new Vector<>();
public MyTank(int x, int y) {
super(x, y);
}
//射击
public void shotEnemyTank(){
//控制发射子弹，最多有 5 颗
if(shots.size() == 5){
return;
}
//创建 Shot 对象，根据当前对象MyTank对象的位置和方向来创建Shot
switch (getDirect()){//得到MyTank对象方向
case 0://向上
shot = new Shot(getX() + 20,getY(),0);
break;
case 1://向右
shot = new Shot(getX() + 60,getY() + 20,1);
break;
case 2://向下
shot = new Shot(getX() + 20,getY() + 60,2);
break;
case 3://向左
shot = new Shot(getX() ,getY() + 20,3);
break;
}
//把新创建的shot放入shots集合中
shots.add(shot);
//启动我们的Shot线程
new Thread(shot).start();
}
}
修改MyPanel类
public class MyPanel extends JPanel implements KeyListener,Runnable {
//绘图
@Override
public void paint(Graphics g){
super.paint(g);
g.fillRect(0,0,1000,750);//填充矩形，默认是黑色
//画出自己坦克-封装方法
drawTank(myTank.getX(),myTank.getY(),g,myTank.getDirect(),1);
//画出myTank射击的子弹
// if(myTank.shot != null && myTank.shot.isLive == true){
// g.draw3DRect(myTank.shot.x,myTank.shot.y,2,2,false);
// }
//将myTank的子弹集合 shots，遍历取出绘制
for (int i = 0; i < myTank.shots.size(); i++) {
Shot shot = myTank.shots.get(i);
if(shot != null && shot.isLive){
g.draw3DRect(shot.x,shot.y,2,2,false);
}else {//如果该对象shot对象已经无效，就从shots集合中删除
myTank.shots.remove(shot);
}
}
//画出敌人的坦克,遍历Vector
for(int i = 0; i < enemyTanks.size(); i++){
//从Vector 取出坦克
EnemyTank enemyTank = enemyTanks.get(i);
//判断当前坦克是否还存活
if (enemyTank.isLive){//当敌人坦克是存活的，才画出该坦克
drawTank(enemyTank.getX(),enemyTank.getY(),g,enemyTank.getDirect(),0);
//画出 enemyTank 所有子弹
for(int j = 0; j < enemyTank.shots.size(); j++){
//取出子弹
Shot shot = enemyTank.shots.get(j);
//绘制
if(shot.isLive){// shot.isLive == true
g.draw3DRect(shot.x,shot.y,2,2,false);
}else {
//从Vector移除
enemyTank.shots.remove(shot);
}
}
}
}
//如果bombs 集合中有对象，就画出
for (int i = 0; i < bombs.size(); i++) {
//取出炸弹
Bomb bomb = bombs.get(i);
//根据当前这个bomb对象的life值去画出对应的图片
if(bomb.life > 6){
g.drawImage(image1,bomb.x,bomb.y,60,60,this);
}else if(bomb.life > 3){
g.drawImage(image2,bomb.x,bomb.y,60,60,this);
}else {
g.drawImage(image3,bomb.x,bomb.y,60,60,this);
}
//让炸弹的生命值减少
bomb.lifeDown();
//如果bomb life 为0，就从bombs 的集合中删除
if(bomb.life == 0){
bombs.remove(bomb);
}
}
}
//如果我们的坦克可以发射多个子弹
//在判断我方子弹是否击中敌人坦克时，需要把我们的子弹集合中
//使用子弹，都取出和敌人使用坦克,进行判断
public void hitEnemyTank(){
//遍历我们的子弹
for (int j = 0; j < myTank.shots.size(); j++){
Shot shot = myTank.shots.get(j);
//判断是否击中 敌人的坦克
if(shot != null && shot.isLive){//当我方子弹还存活
//遍历敌人所以坦克
for (int i = 0; i < enemyTanks.size(); i++) {
EnemyTank enemyTank = enemyTanks.get(i);
hitTank(shot,enemyTank);
}
}
}
}
//处理按键事件 wdsa
@Override
public void keyPressed(KeyEvent e) {
if(e.getKeyCode() == KeyEvent.VK_W){//按下W键
//改变坦克方向 上
myTank.setDirect(0);
//修改坦克的坐标 y -= 1
if(myTank.getY() > 0){
myTank.moveUp();
}
}else if(e.getKeyCode() == KeyEvent.VK_D){//按下D键
//改变坦克方向 右
myTank.setDirect(1);
if((myTank.getX() + 60) < 1000){
myTank.moveRight();
}
}else if(e.getKeyCode() == KeyEvent.VK_S){//按下S键
//改变坦克方向 下
myTank.setDirect(2);
if((myTank.getY() + 60) < 750){
myTank.moveDown();
}
}else if(e.getKeyCode() == KeyEvent.VK_A){//按下A键
//改变坦克方向 左
myTank.setDirect(3);
if(myTank.getX() > 0){
myTank.moveLeft();
}
}
//如果用户按下的是J键，就发射子弹
if(e.getKeyCode() == KeyEvent.VK_J){
System.out.println("用户按下了J，开始射击~");
//判断myTank的子弹是否销毁，发射一颗子弹的情况
// if(myTank.shot == null || !myTank.shot.isLive){
// myTank.shotEnemyTank();
// }
//发射多颗子弹的情况
myTank.shotEnemyTank();
}
//让面板重绘
this.repaint();
}
@Override
public void keyReleased(KeyEvent e) {
}
@Override
public void run() {//每个 100毫秒 重绘区域，刷新绘图区域，子弹移动起来
while (true){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
// //判断是否击中 敌人的坦克
// if(myTank.shot != null && myTank.shot.isLive){//当我方子弹还存活
// //遍历敌人所以坦克
// for (int i = 0; i < enemyTanks.size(); i++) {
// EnemyTank enemyTank = enemyTanks.get(i);
// hitTank(myTank.shot,enemyTank);
// }
// }
hitEnemyTank();
this.repaint();
}
}
}
运行效果：
敌人移动发射子弹
修改EnemyTank类
public class EnemyTank extends Tank implements Runnable{
//敌人的坦克类，使用Vector 保存多个Shot
Vector<Shot> shots = new Vector<>();
boolean isLive = true;//坦克是否还存活
public EnemyTank(int x, int y) {
super(x, y);
}
@Override
public void run() {
while (true){
//这里我们判断如果shots size() < 0,创建一颗子弹，放入到
//shots集合中，并启动(这里演示效果，把子弹数量设置大点)
if(isLive && shots.size() < 3){
Shot s = null;//临时变量
//判断坦克的方向，创建对应的子弹
switch (getDirect()){
case 0://向上
s = new Shot(getX() + 20,getY(),0);
break;
case 1://向右
s = new Shot(getX() + 60,getY() + 20,1);
break;
case 2://向下
s = new Shot(getX() + 20,getY() + 60,2);
break;
case 3://向左
s = new Shot(getX(),getY() + 20,3);
break;
}
shots.add(s);
//启动
new Thread(s).start();
}
//根据坦克的方向来继续移动
switch (getDirect()){
case 0://向上
//让坦克保持一个方向，走30步
for (int i = 0; i < 30; i++) {
//判断范围
if(getY() > 0){
moveUp();
}
//休眠50毫秒
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
break;
case 1://向右
for (int i = 0; i < 30; i++) {
if((getX() + 60) < 1000){
moveRight();
}
//休眠50毫秒
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
break;
case 2://向下
for (int i = 0; i < 30; i++) {
if((getY() + 60) < 750){
moveDown();
}
//休眠50毫秒
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
break;
case 3://向左
for (int i = 0; i < 30; i++) {
if(getX() > 0){
moveLeft();
}
//休眠50毫秒
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
break;
}
//然后随机的改变坦克方向 0-3
//setDirect(3);//测试指定方向
setDirect((int)(Math.random() * 4));
//写并发程序，一定要考虑清楚，该线程什么时候结束
if(!isLive){
break;//退出线程
}
}
}
}
运行效果：
我方坦克被击中爆炸
思路：
1、编写方法，判断敌人的坦克是否击中我方坦克
在Tank类，添加属性
public class Tank {
private int x;//坦克的横坐标
private int y;//坦克的纵坐标
private int direct;//坦克的方向 0上 1右 2下 3左
private int speed = 1;//坦克的速度
boolean isLive = true;
...
}
在MyPanel类添加方法
public class MyPanel extends JPanel implements KeyListener,Runnable {
//绘图
@Override
public void paint(Graphics g){
super.paint(g);
g.fillRect(0,0,1000,750);//填充矩形，默认是黑色
if(myTank != null && myTank.isLive){
//画出自己坦克-封装方法
drawTank(myTank.getX(),myTank.getY(),g,myTank.getDirect(),1);
}
...
}
//编写方法，判断敌人的坦克是否击中我方坦克
public void hitMyTank(){
//遍历使用的敌人坦克
for (int i = 0; i < enemyTanks.size(); i++) {
//取出敌人坦克
EnemyTank enemyTank = enemyTanks.get(i);
//遍历enemyTank对象的所以子弹
for (int j = 0; j < enemyTank.shots.size(); j++) {
//取出子弹
Shot shot = enemyTank.shots.get(j);
//判断 shot 是否击中我方坦克
if(myTank.isLive && shot.isLive){
hitTank(shot,myTank);
}
}
}
}
@Override
public void run() {//每个 100毫秒 重绘区域，刷新绘图区域，子弹移动起来
while (true){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
// //判断是否击中 敌人的坦克
// if(myTank.shot != null && myTank.shot.isLive){//当我方子弹还存活
// //遍历敌人所以坦克
// for (int i = 0; i < enemyTanks.size(); i++) {
// EnemyTank enemyTank = enemyTanks.get(i);
// hitTank(myTank.shot,enemyTank);
// }
// }
hitEnemyTank();
//判断敌人坦克是否击中我方坦克
hitMyTank();
this.repaint();
}
}
}
运行效果：
189
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
