项目-坦克大战2

已于 2024-05-20 16:43:30 修改
阅读量667 收藏 6
点赞数 11
文章标签： java 开发语言
于 2024-05-15 21:03:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：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();
        }
    }
}
Islucas
关注
  • 11
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Unity项目 - 坦克大战3D TankBattle
dhj66039的博客
07-27 1447
目录 游戏原型 项目演示 绘图资源 代码实现 技术探讨 参考来源 游戏原型 游戏玩法：在有界的战场上，玩家将驾驶坦克，代表绿色阵营，与你的队友一起击溃红蓝阵营的敌人，在这场三方大战中夺得胜利！ 操作指南： 移动：WASD 开火：Space 第一/第三人称视角转换：PgDn 第三人称下的视角转动：← → 项目演示 Github项目地址：3D坦克大战 TankBattle...
JAVA基础项目-坦克大战.zip
10-23
matlab算法，毕设、课设程序，全部源码均已进行严格测试，可以直接运行！ matlab算法，毕设、课设程序，全部源码均已进行严格测试，可以直接运行！ matlab算法，毕设、课设程序，全部源码均已进行严格测试，可以直接运行！ matlab算法，毕设、课设程序，全部源码均已进行严格测试，可以直接运行！ matlab算法，毕设、课设程序，全部源码均已进行严格测试，可以直接运行！ matlab算法，毕设、课设程序，全部源码均已进行严格测试，可以直接运行！ matlab算法，毕设、课设程序，全部源码均已进行严格测试，可以直接运行！ matlab算法，毕设、课设程序，全部源码均已进行严格测试，可以直接运行！ matlab算法，毕设、课设程序，全部源码均已进行严格测试，可以直接运行！
项目-坦克大战-设计报告.doc
10-07
项目-坦克大战-设计报告.doc
JavaSE实战项目-坦克大战网络编程.ppt
10-29
JavaSE实战项目-坦克大战网络编程.ppt
Python项目-坦克大战游戏开发项目(Python).zip
03-05
适合学习/练手、毕业设计、课程设计、期末/期中/大作业、工程实训、相关项目/竞赛学习等。 项目具有较高的学习借鉴价值，也可直接拿来修改复现。可以在这些基础上学习借鉴进行修改和扩展，实现其它功能。 可放心下载学习借鉴，你会有所收获。 可放心下载学习借鉴，你会有所收获。 可放心下载学习借鉴，你会有所收获。 —— 博主领域：嵌入式领域&人工智能&软件开发。 有任何使用问题欢迎随时与博主沟通(公主呺：阿齐Archie)。 # 注意 1. 本资源仅用于开源学习和技术交流。不可商用等，一切后果由使用者承担。 2. 部分字体以及插图等来自网络，若是侵权请联系删除。
项目-坦克大战3
Islucas的博客
05-20 228
EnemyTank类MyPanel类。
python-坦克大战游戏项目
weixin_65962607的博客
01-28 4534
'''尚学堂学习笔记，用于复习''' 一.下载pygame，在cmd输入命令pip install pygame(也可以直接在pycharm中import pygame, 提示你没有pygame,然后直接安装即可) 二.分析项目需求: 坦克大战游戏的基本需求： 1).项目中需要定义的类 2).每个类对应的方法 1.坦克类 显示坦克 移动 射击 2.子弹 显示子弹 移动 击中敌方坦克时产生的影响 3.墙壁类 显示墙壁（是否可以通过） 4.击中地方坦克爆炸效果 展示爆炸效果
Java基础 - 游戏项目 - 坦克大战（第一章，入门机制分析与学习规划）
qq_39123467的博客
01-12 6143
此章容纳java基础所有知识，并包含IO流/多线程，数据库操作，在做项目同时学习新内容、巩固旧知识
C语言-坦克大战小游戏(纯控制台显示)
12-05
关于该C语言小游戏的介绍如下：https://blog.csdn.net/zahngzhic/article/details/120165371
Android项目--坦克大战
qq_41951731的博客
06-26 2143
要求 项目的内容主要实现我方坦克与敌方坦克进行对打，消灭对方坦克则成功，相反则游戏失败，完成对我方坦克的移动攻击以及相关的随机道具对坦克进行强化，敌方坦克也进行道具的获取和强化，游戏分为四个难度可以使用的坦克类型也不相同。对于的坦克的造型以及道具的UI的选取就很重要，对于炮弹对敌人造成的伤害以及不同难度下自己所受到的伤害都有所不同，不同的坦克的护甲血量以及攻击力也不相同，对应的不同的难度的敌人的A...
JavaSE练习项目-坦克大战
qq_44486437的博客
07-27 1339
写文章之前呢，先引用一句名言，是这几天在喜马拉雅听书上面听秦汉所学到的：“丈夫为志，穷当益坚，老当益壮”，这句名言出自《马援传》，对历史感兴趣的朋友多去了解一下，用这句话来激励下自己。 自从放了暑假就再也没碰过Java，哦，其实现在还是寒假！请原谅我还是一如既往的菜，都没有学习框架的勇气，偶然间看到了马士兵的JavaSE练习项目-坦克大战，又激起了我敲代码的兴趣，首先呢，附上视频的地址马士兵-坦克大战，接下来呢，为了满足下我浅浅的虚荣心，我先来展示下我的项目作品。 好了，接下来我也不一 一ctrl+c .
Java项目开发—坦克大战（附源码）
m0_72882572的博客
10-27 2848
今天给小伙伴们分享一个坦克大战游戏的详细编写流程，即使你是刚入门java的新手，只要你简单掌握了该游戏所需要的javase基础知识，便可以跟随教程视频完成属于你自己的坦克大战游戏！同时还可以加深和巩固你对面向对象知识的理解。
java基础项目编写--坦克大战
m0_46543237的博客
08-17 36
实战
C# --- 坦克大战项目（1）--- 类型转换与多线程
qq_51947882的博客
08-18 662
8.多线程的时候，线程之间的运行顺序从宏观角度来讲是并发的（即同时进行的），但这是一种假并发，从微观的角度的来看Cpu在一定时间里依然只是执行一个线程，只不过此时Cpu采用的是时间片方式执行线程 --- 所谓的时间片就是我们设定每10毫秒就是一个时间片段，Cpu每执行一个线程一个时间片段就会结束这个进程去执行另一个进程，就这样执行了所有的进程之后再开始一轮进程执行循环，这种方式就称为时间片管理。答案是可以的，人们基于原本的单道批处理系统（内存中只能存储一个程序）开发出了功能更加强大的多道批处理处理系统。..
JAVAEE之多线程进阶（2）_ CAS概念、实现原理、ABA问题及解决方案
最新发布
2301_80653026的博客
05-29 1344
CAS全称Compare and swap，字面意思:”比较并交换“，它是一条 CPU 并发原语，用于判断内存中某个值是否为预期值，如果是则更改为新的值，这个过程是原子的。全称 Compare and swap, 即 “比较并交换”. 相当于通过一个原子的操作, 同时完成 “读取内存, 比较是否相等, 修改内存” 这三个步骤. 本质上需要 CPU 指令的支撑。
java学习和项目总结
2301_79390585的博客
05-24 909
JRE：JRE是Java 运行时环境，主要包括了两个运行需要的组件：JVM 和 Java 核心类库，如果不进行java开发只想运行就可以只下载JRE。而Java语言，它的代码会先通过javac编译成字节码，再通过jvm将字节码转换成机器码（0和1）执行，即解释运行和编译运行配合使用，所以是混合型。在程序运行之前，通过编译器将源程序编译成机器码可运行的二进制，以后执行这个程序时，就不用再进行编译了。JVM：JVM是java进行编译的虚拟机，是Java 能够跨平台运行的核心。特点：执行速度慢、效率低；
【STM32学习】HAL库点灯学习
2301_78895982的博客
05-26 834
STM32基于HAL库流水灯实验_hel库安装教程中文版-CSDN博客t=N7T8。
Java高级面试精粹：问题与解答集锦（一）
Layla_c的博客
05-23 1605
答案多态是Java中的一个核心概念，它允许不同类的对象对同一消息做出响应，但具体的行为会根据对象的实际类型而有所不同。重载（Overloading）：当多个方法具有相同的名称，但参数列表不同时，这称为方法重载。编译器根据方法调用时传递的参数类型和数量来确定调用哪个方法。重写（Overriding）：当子类有一个与父类同名、同参数列表的方法时，子类可以提供特定的实现来覆盖父类的方法。运行时，Java虚拟机（JVM）会根据对象的实际类型调用相应的方法，这个过程称为动态绑定或晚期绑定。答案。
java坦克大战项目代码
04-21
Java坦克大战项目是一个经典的游戏项目，它模拟了坦克战斗的场景。下面是一个简单的Java坦克大战项目代码的示例： ```java import java.awt.*; import java.awt.event.*; public class TankGame extends Frame { public static void main(String[] args) { new TankGame().launchFrame(); } public void launchFrame() { setSize(800, 600); setLocation(400, 300); setVisible(true); } class MyKeyListener extends KeyAdapter { public void keyPressed(KeyEvent e) { int keyCode = e.getKeyCode(); switch (keyCode) { case KeyEvent.VK_UP: // 坦克向上移动的逻辑 break; case KeyEvent.VK_DOWN: // 坦克向下移动的逻辑 break; case KeyEvent.VK_LEFT: // 坦克向左移动的逻辑 break; case KeyEvent.VK_RIGHT: // 坦克向右移动的逻辑 break; default: break; } } } class Tank { int x, y; public void move() { // 坦克移动的逻辑 } public void draw(Graphics g) { // 绘制坦克的逻辑 } } class TankClient extends Frame { Tank myTank = new Tank(); public void paint(Graphics g) { myTank.draw(g); } } } ``` 以上是一个简单的Java坦克大战项目代码示例，其中包含了坦克的移动和绘制逻辑。你可以根据这个示例代码进行扩展和完善，实现更多的功能和特效。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值