项目-坦克大战2

Islucas

已于 2024-05-20 16:43:30 修改

阅读量738

点赞数 11

文章标签： java 开发语言

于 2024-05-15 21:03:57 首次发布

本文链接：https://blog.csdn.net/Islucas/article/details/138918123

版权

增加功能

我方坦克在发射的子弹消亡后，才能发射新的子弹。同时实现发多颗子弹

1，在按下J键，我们判断当前hero对象的子弹，是否已经销毁
2，如果没有销毁，就不去触发shotEnemyTank
3，如果已经销毁，才去触发shotEnemyTank
4，如果要发射多颗子弹，就使用Vector保存（hero类）
5，在绘制我方子弹时，需要遍历Vector，在按键J时，再次调用shotEnemyTank
6，如果需要控制在我们的面板上最多只有5颗子弹：用if语句进行判断即可（hero类），

Hero类

import java.util.Vector;

//自己的坦克，继承坦克父类
public class Hero extends Tank {
    //定义一个Shot对象，表示一个射击（线程）
    Shot shot = null;
    //可以发射多颗子弹
    Vector<Shot> shots = new Vector<>();
    public Hero(int x, int y) {
        super(x, y);
    }
    public void  shotEnemyTank(){
        //发多颗子弹怎么办？ 控制在我们的面板上，最多只有5颗子弹
        if (shots.size()==5){
            return;
        }
        //创建Shot对象，根据当前Hero对象的位置和方向来创建Shot
        switch (getDirect()){//得到Hero对象方向
            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();
    }
}

画板类
改变keyPressed方法

 //当某个键按下，该方法会触发
    @Override
    public void keyPressed(KeyEvent e) {

        if (e.getKeyCode() == KeyEvent.VK_W) {//上
            //改变坦克方向
            hero.setDirect(0);
            //让坦克动起来
            if (hero.getY()>0){
                hero.moveUp();
            }
        } else if (e.getKeyCode() == KeyEvent.VK_S) {//下
            hero.setDirect(2);
            if (hero.getY()+60<750){
                hero.moveDown();
            }
        } else if (e.getKeyCode() == KeyEvent.VK_A) {//左
            hero.setDirect(3);
            if (hero.getX()>0){
                hero.moveLeft();
            }
        } else if (e.getKeyCode() == KeyEvent.VK_D) {//右
            hero.setDirect(1);
            if (hero.getX()+60<1000)
            hero.moveRight();
        }

        //如果用户按下的是J，就发射
        if (e.getKeyCode() == KeyEvent.VK_J) {
            //判断hero的子弹是否销毁---发射一颗子弹
            if (hero.shot==null|| !hero.shot.isLive) {
                //线程销毁后，不代表shot对象为空,所以还需要判断shot的声明周期，才可以继续发子弹
                hero.shotEnemyTank();
            }
            //发射多颗子弹
            hero.shotEnemyTank();
        }

        //重绘
        repaint();
    }

在paint方法中遍历Vector集合

  @Override
    public void paint(Graphics g) {
        super.paint(g);
        //3，通过画笔填充一个矩形区域   g.fillRect();
        g.fillRect(0, 0, 1000, 750);//填充矩形，默认为黑色

        //画出自己的坦克
        drawTank(hero.getX(), hero.getY(), g, hero.getDirect(), 1);
//        drawTank(hero.getX() +100,hero.getY(),g,hero.getDirect(),0);
//        drawTank(hero.getX() +200,hero.getY(),g,hero.getDirect(),0);
//        drawTank(hero.getX() +300,hero.getY(),g,hero.getDirect(),1);
        //判断何时画子弹
//        if (hero.shot != null && hero.shot.isLive == true) {
//            g.setColor(Color.white);
//            g.draw3DRect(hero.shot.x, hero.shot.y, 1, 1, false);
//
//        }
        //将hero的子弹集合shots，遍历取出绘制
        for (int i = 0; i < hero.shots.size(); i++) {
            Shot shot = hero.shots.get(i);
            if (shot != null && shot.isLive == true) {
            g.setColor(Color.white);
            g.draw3DRect(shot.x, shot.y, 1, 1, false);
        }else {//如果该shot对象已经无效，就从shots集合中拿掉
                hero.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);
            }
        }
        //画出敌人的坦克
        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) {//isLive=true
                        g.setColor(Color.white);
                        g.draw3DRect(shot.x, shot.y, 1, 1, false);
                    } else {
                        //从Vector 移除
                        enemyTank.shots.remove(shot);
                    }
                }
            }
        }
    }

让敌人坦克发射的子弹消亡后，可以再发射子弹

1，在敌人坦克类中的run方法中判断 Vector集合的数量
2，如果仍然存活且数量小于1，则执行相关业务代码

//敌人坦克
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()<1){
                Shot s = null;
                //判断坦克的方向，创建对应的子弹
                switch (getDirect()){
                    case 0:
                        s=new Shot(getX()+20,getY(),0);
                    case 1:
                        s=new Shot(getX()+60,getY()+20,0);
                    case 2:
                        s=new Shot(getX()+20,getY()+60,0);
                    case 3:
                        s=new Shot(getX(),getY()+20,0);
                }
                 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) {
                            throw new RuntimeException(e);
                        }
                    }
                    break;
                case 1://向右
                    //让坦克保持一个方向，走30步
                    for (int i = 0; i < 30; i++) {
                        if (getX()+60<1000){
                            moveRight();
                        }
                        //休眠50好眠
                        try {
                            Thread.sleep(50);
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }
                    break;
                case 2://向下
                    //让坦克保持一个方向，走30步
                    for (int i = 0; i < 30; i++) {
                        if (getY()+60<750){
                            moveDown();
                        }
                        //休眠50好眠
                        try {
                            Thread.sleep(50);
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }
                    break;
                case 3://向左
                    //让坦克保持一个方向，走30步
                    for (int i = 0; i < 10; i++) {
                        if (getX()>0){
                            moveLeft();
                        }

                        //休眠50好眠
                        try {
                            Thread.sleep(50);
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }

                    break;
            }
            //休眠50好眠
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            // 然后随机的改变坦克方向0-3
            setDirect((int) (Math.random() * 4));  //0-3

            //一旦写并发程序，一定要考虑清楚，该线程什么时候结束
            if (!isLive) {
                break;
            }
        }
    }
}

当敌人的坦克击中我方坦克时，我方坦克消失，并出现爆炸效果

1，编写方法，判断敌人坦克是否击中我方坦克
2，在run方法中调用该方法

//画板类
public class MyPanel extends JPanel implements KeyListener, Runnable {
    //定义我的坦克
    Hero hero = 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() {//初始化自己的坦克
        hero = new Hero(100, 100);
        hero.setSpeed(5);

        //初始化敌人的坦克
        for (int i = 0; i < enemyTankSize; i++) {
            //创建一个敌人的坦克
            EnemyTank enemyTank = new EnemyTank(100 * (i + 1), 0);
            //启动敌人坦克线程，让他动起来
            new Thread(enemyTank).start();
            //设置方向
            enemyTank.setDirect(2);
            //给该enemyTank 加入一颗子弹
            Shot shot = new Shot(enemyTank.getX() + 20, enemyTank.getY() + 60, enemyTank.getDirect());
            enemyTank.shots.add(shot);
            //启动shot对象
            new Thread(shot).start();
            //把敌人的坦克加入的总的坦克对象中
            enemyTanks.add(enemyTank);
        }
//        image1 = Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/1.gif"));
//        image2 = Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/2.gif"));
//        image3 = Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/3.gif"));
        //初始化照片对象
        image1 = new ImageIcon("image/1.gif").getImage();
        image2 = new ImageIcon("image/2.gif").getImage();
        image3 = new ImageIcon("image/3.gif").getImage();

    }

    @Override
    public void paint(Graphics g) {
        super.paint(g);
        //3，通过画笔填充一个矩形区域   g.fillRect();
        g.fillRect(0, 0, 1000, 750);//填充矩形，默认为黑色
        if (hero != null && hero.isLive){
        //画出自己的坦克
        drawTank(hero.getX(), hero.getY(), g, hero.getDirect(), 1);}
//        drawTank(hero.getX() +100,hero.getY(),g,hero.getDirect(),0);
//        drawTank(hero.getX() +200,hero.getY(),g,hero.getDirect(),0);
//        drawTank(hero.getX() +300,hero.getY(),g,hero.getDirect(),1);
        //判断何时画子弹
//        if (hero.shot != null && hero.shot.isLive == true) {
//            g.setColor(Color.white);
//            g.draw3DRect(hero.shot.x, hero.shot.y, 1, 1, false);
//
//        }
        //将hero的子弹集合shots，遍历取出绘制
        for (int i = 0; i < hero.shots.size(); i++) {
            Shot shot = hero.shots.get(i);
            if (shot != null && shot.isLive == true) {
            g.setColor(Color.white);
            g.draw3DRect(shot.x, shot.y, 1, 1, false);
        }else {//如果该shot对象已经无效，就从shots集合中拿掉
                hero.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);
            }
        }
        //画出敌人的坦克
        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) {//isLive=true
                        g.setColor(Color.white);
                         g.draw3DRect(shot.x, shot.y, 1, 1, false);
                    } else {
                        //从Vector 移除
                        enemyTank.shots.remove(shot);
                    }
                }
            }
        }
    }
    /*
    int x 坦克的横坐标
    int y 坦克的纵坐标
    Graphics g  画笔
    int direct  坦克的方向
    int 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("暂时没有处理");
        }
    }
    //编写方法，判断敌人坦克是否击中我方坦克
    public void hitHero(){
        //遍历所有的敌人坦克
        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 (hero.isLive&&shot.isLive){
                    hitTank( shot,hero);

                }
            }

        }
    }
    public void hitEnemy(){
        //判断我们的子弹是否击中了敌人坦克
        if (hero.shot != null && hero.shot.isLive) {//当我方的子弹还存活
            //遍历敌人所有的坦克
            for (int i = 0; i < enemyTanks.size(); i++) {
                EnemyTank enemyTank = enemyTanks.get(i);
                hitTank(hero.shot, enemyTank);
            }
        }
    }

    //编写方法：判断我方子弹是否击敌人坦克
    //什么时候判断，我方坦克是否击中敌人坦克？  run方法
    public void hitTank(Shot s, Tank tank) {
        //判断s 击中坦克
        switch (tank.getDirect()) {
            case 0://敌人坦克向上
            case 2://敌人坦克向下
                if (s.x > tank.getX() && s.y < tank.getY() + 40 &&
                        s.y > tank.getY() && s.y < tank.getY() + 60) {
                    s.isLive = false;
                    tank.isLive = false;
                    //当我的子弹击中敌人坦克后，将enenmyTank 从Vector 拿掉
                    enemyTanks.remove(tank);
                    //这里敌人坦克被击中
                    //创建Bomb对象，加入到bombs集合
                    Bomb bomb = new Bomb(tank.getX(), tank.getY());
                    bombs.add(bomb);
                }
                break;
            case 1://敌人坦克向右
            case 3://敌人坦克向下
                if (s.x > tank.getX() && s.y < tank.getY() + 60 &&
                        s.y > tank.getY() && s.y < tank.getY() + 40) {
                    s.isLive = false;
                    tank.isLive = false;
                    Bomb bomb = new Bomb(tank.getX(), tank.getY());
                    bombs.add(bomb);
                }
                break;

        }

    }

    //有字符输出时，该方法就会触发
    @Override
    public void keyTyped(KeyEvent e) {

    }

    //当某个键按下，该方法会触发
    @Override
    public void keyPressed(KeyEvent e) {

        if (e.getKeyCode() == KeyEvent.VK_W) {//上
            //改变坦克方向
            hero.setDirect(0);
            //让坦克动起来
            if (hero.getY()>0){
                hero.moveUp();
            }
        } else if (e.getKeyCode() == KeyEvent.VK_S) {//下
            hero.setDirect(2);
            if (hero.getY()+60<750){
                hero.moveDown();
            }
        } else if (e.getKeyCode() == KeyEvent.VK_A) {//左
            hero.setDirect(3);
            if (hero.getX()>0){
                hero.moveLeft();
            }
        } else if (e.getKeyCode() == KeyEvent.VK_D) {//右
            hero.setDirect(1);
            if (hero.getX()+60<1000)
            hero.moveRight();
        }

        //如果用户按下的是J，就发射
        if (e.getKeyCode() == KeyEvent.VK_J) {
            //判断hero的子弹是否销毁---发射一颗子弹
            if (hero.shot==null|| !hero.shot.isLive) {
                //线程销毁后，不代表shot对象为空,所以还需要判断shot的声明周期，才可以继续发子弹
                hero.shotEnemyTank();
            }
            //发射多颗子弹
            hero.shotEnemyTank();
        }

        //重绘
        repaint();
    }

    //当某个键释放(松开)，该方法会触发
    @Override
    public void keyReleased(KeyEvent e) {

    }

    //添加线程的方法，确保子弹可以重绘
    @Override
    public void run() {//每隔 100毫秒，重绘区域，刷新绘图区域，子弹就移动
        while (true) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            //判断我们坦克是否击中别人
            hitEnemy();
            //判断敌人坦克是否击中我们
            hitHero();
            this.repaint();
        }
    }
}