devbox
Gausst松鼠会
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Java 简易版王者荣耀_王者荣耀java下载

作者：Gausst松鼠会 | 2024-02-17 00:15:10

赞

踩

王者荣耀java下载

所有包和类 

GameFrame类

  1. package newKingOfHonor;
  2.  
  3. import java.awt.*;
  4. import java.awt.event.ActionEvent;
  5. import java.awt.event.ActionListener;
  6. import java.awt.event.KeyAdapter;
  7. import java.awt.event.KeyEvent;
  8. import java.io.File;
  9. import java.util.ArrayList;
  10.  
  11. import javax.sound.sampled.AudioInputStream;
  12. import javax.sound.sampled.AudioSystem;
  13. import javax.sound.sampled.Clip;
  14. import javax.sound.sampled.FloatControl;
  15. import javax.swing.JButton;
  16. import javax.swing.JFrame;
  17.  
  18. public class GameFrame extends JFrame {
  19.     // 游戏开始 0， 游戏胜利1，游戏失败2
  20.     int state = 0;
  21.     // 窗口尺寸
  22.     final int windowWidth = 1400;
  23.     final  int windowHeight = 700;
  24.     // 双缓冲图片
  25.     private Image offScreenImage = null;
  26.     // 攻击图片
  27.     private Image attack = Toolkit.getDefaultToolkit().getImage("img/王者荣耀图片/attack.jpg");
  28.     //游戏胜利失败图片
  29.     private Image gameWin = Toolkit.getDefaultToolkit().getImage("img/王者荣耀图片/gameWin.png");
  30.     private Image gameLose = Toolkit.getDefaultToolkit().getImage("img/王者荣耀图片/gameLose.png");
  31.     // 游戏背景
  32.     Background background = new Background(this);
  33.     // 游戏玩家
  34.     Champion player = new ChampionDaji(this);
  35.     // 双方小兵
  36.     MinionBlue mb = new MinionBlue(this);
  37.     MinionRed mr = new MinionRed(this);
  38.     //野怪
  39.     public Beast beast = new Beast(this);
  40.     // 防御塔
  41.     Turret turret = new Turret(this);
  42.     // 游戏元素列表
  43.    public ArrayList<GameObject> objList = new ArrayList<>();
  44.     ArrayList<GameObject> redList = new ArrayList<>();// 红色方
  45.     ArrayList<GameObject> blueList = new ArrayList<>();// 蓝色方
  46.     public ArrayList<GameObject> removeList = new ArrayList<>();// 存放将要删除的元素
  47.  
  48.     public void launch() {
  49.         // 设置尺寸
  50.         setSize(windowWidth, windowHeight);
  51.         // 窗口居中
  52.         setLocationRelativeTo(null);
  53.         // 关闭事件
  54.         setDefaultCloseOperation(3);
  55.         // 用户不能调整窗口大小
  56.         setResizable(false);
  57.         // 标题
  58.         setTitle("王者荣耀");
  59.         // 窗口可见
  60.         setVisible(true);
  61.         // 添加键盘监视器
  62.         this.addKeyListener(new GameFrame.KeyMonitor());
  63.         // 添加游戏元素
  64.         objList.add(background);
  65.         objList.add(player);
  66.         objList.addAll(beast.beastList);
  67.         objList.addAll(turret.turretList);
  68.        for (int i = 0; i < 4; i++) {
  69.             blueList.add(turret.turretList.get(i));
  70.         }
  71.         for (int i = 4; i < 8; i++) {
  72.             redList.add(turret.turretList.get(i));
  73.         }
  74.  
  75.  
  76.         /**
  77.          * 攻击按钮
  78.          */
  79.         JButton button = new JButton();
  80.         button.setSize(130, 132);
  81.         button.setLocation(1150, 430);
  82.         button.addActionListener(new ActionListener() {
  83.             @Override
  84.             public void actionPerformed(ActionEvent e) {
  85.                 // 按钮事件
  86.                 player.attack(redList);
  87.             }
  88.         });
  89.         this.add(button);
  90.         player.addButton();
  91.         while (true) {
  92.  
  93.             mb.createMinion(this, blueList);
  94.             mr.createMinion(this, redList);
  95.             repaint();
  96.             try {
  97.                 Thread.sleep(25);
  98.             } catch (Exception e) {
  99.                 e.printStackTrace();
  100.             }
  101.         }
  102.     }
  103.  
  104.     public void paint(Graphics g) {
  105.         if (offScreenImage == null) {
  106.             offScreenImage = this.createImage(5984, 4452);
  107.         }
  108.         Graphics gImage = offScreenImage.getGraphics();
  109.        if(state==0){
  110.            turret.isLive();
  111.             for (int i = 0; i < objList.size(); i++) {
  112.                 objList.get(i).paintSelf(gImage);
  113.             }
  114.             // 绘制攻击图片
  115.            gImage.drawImage(attack, player.getX() + 500, player.getY() + 100, null);
  116.  
  117.             objList.removeAll(removeList);
  118.         } else if (state ==1) {//游戏胜利
  119.  
  120.             gImage.drawImage(gameWin, player.getX()-700, player.getY()-300 , null);
  121.         } else if (state == 2) {//游戏失败
  122.             gImage.drawImage(gameLose, player.getX()-700, player.getY()-300, null);
  123.         }
  124.         g.drawImage(offScreenImage, -player.getX() + 700, -player.getY() + 350, null);
  125.          // 添加按钮后不能调用键盘事件 因为程序的焦点变成了按钮 this.requestFocus() 把焦点重新改变到游戏界面上
  126.  
  127.         this.requestFocus();
  128.     }
  129.  
  130.     // main方法
  131.     public static void main(String[] args) {
  132.         GameFrame gameFrame = new GameFrame();
  133.         gameFrame.launch();
  134.  
  135.     }
  136.     // 键盘事件
  137.     private class KeyMonitor extends KeyAdapter {
  138.         @Override
  139.         public void keyPressed(KeyEvent e) {
  140.             int key = e.getKeyCode();
  141.             player.keyPressed(e);
  142.         }
  143.  
  144.         @Override
  145.         public void keyReleased(KeyEvent e) {
  146.             int key = e.getKeyCode();
  147.             player.keyReleased(e);
  148.         }
  149.     }
  150.     static Clip clip;
  151.  
  152.  
  153. }

GameObject类

  1. package newKingOfHonor;
  2.  
  3. import java.awt.*;
  4. import java.util.ArrayList;
  5.  
  6. //游戏元素的父类
  7. public abstract class GameObject {
  8.     // 坐标
  9.     private int x;
  10.     private int y;
  11.     // 图片
  12.     private Image img;
  13.     // 游戏界面
  14.     public GameFrame gameFrame;
  15.     // 速度
  16.     private int spd;
  17.     // 初始生命值
  18.     private int hp;
  19.     // 当前生命值
  20.     private int currentHp;
  21.     // 攻击目标
  22.     private GameObject target;
  23.     // 是否有目标
  24.     private boolean hasTarget = false;
  25.     // 攻击距离
  26.     private int dis;
  27.     // 攻击时间间隔
  28.     private int attackCoolDownTime;
  29.     // 攻击是否冷却
  30.     private boolean attackCoolDown = true;
  31.     // 是否存活
  32.     private boolean alive = true;
  33.     //是否被控制
  34.     boolean beControlled = false;
  35.  
  36.     public GameObject(GameFrame gameFrame) {
  37.         this.gameFrame = gameFrame;
  38.     }
  39.  
  40.     public GameObject(int x, int y, GameFrame gameFrame) {
  41.         this.x = x;
  42.         this.y = y;
  43.         this.gameFrame = gameFrame;
  44.     }
  45.  
  46.     public GameObject() {
  47.     }
  48.     public void addHp(Graphics g, int difX, int difY, int width, int height, Color color) {
  49.         // 绘制外部轮廓
  50.         g.setColor(Color.black);
  51.         g.drawRect(getX() - difX, getY() - difY, width, height);
  52.         // 填充矩形
  53.         g.setColor(color);
  54.         g.fillRect(getX() - difX, getY() - difY, (int) (width * getCurrentHp() / getHp()), height);
  55.     }
  56.  
  57.     public double getDis(int x1, int y1, int x2, int y2) {
  58.         return Math.sqrt(Math.pow(x1 - x2, 2) + Math.pow(y1 - y2, 2));
  59.     }
  60.  
  61.     // 矩形矩形碰撞检测
  62.     public boolean recIntersectsRec(Rectangle r1, Rectangle r2) {
  63.         return r1.intersects(r2);
  64.     }
  65.  
  66.     public boolean recIntersectsCir(Rectangle rec, int x, int y, int r) {
  67.         // 矩形于圆相交： 圆心到至少一个矩形定点的距离小于r
  68.         if ((getDis(x, y, rec.x, rec.y) < r) || (getDis(x, y, rec.x, rec.y + rec.height) < r)
  69.                 || (getDis(x, y, rec.x + rec.width, rec.y) < r)
  70.                 || (getDis(x, y, rec.x + rec.width, rec.y + rec.height) < r)) {
  71.             return true;
  72.         }
  73.         return false;
  74.     }
  75.  
  76.     // 攻击方法
  77.     public void attack(ArrayList<GameObject> gameObjList) {
  78.         if (hasTarget) {
  79.             // 目标离开范围后寻找新的目标
  80.             if (!recIntersectsCir(target.getRec(), getX(), getY(), getDis())) {
  81.                 setHasTarget(false);
  82.             }
  83.             // 目标死亡，寻找新目标
  84.             else if (!target.isAlive()) {
  85.                 setHasTarget(false);
  86.             } else if (isAttackCoolDown() && isAlive()) {
  87.                 Bullet bullet = null;
  88.                 // 防御塔攻击
  89.                 if (Turret.class.isAssignableFrom(getClass())) {
  90.                     bullet = new Bullet(gameFrame, this, getTarget(), 500, 50);
  91.                 }
  92.                 // 小兵攻击
  93.                 else if (Minion.class.isAssignableFrom(getClass())) {
  94.                     bullet = new Bullet(gameFrame, this, getTarget(), 50, 30);
  95.                 }
  96.                 // 玩家攻击
  97.                 else if (this instanceof Champion) {
  98.                     bullet = new Bullet(gameFrame, this, getTarget(), 500, 50);
  99.                 }
  100.                 gameFrame.objList.add(bullet);
  101.                 // 线程开始
  102.                 new AttackCD().start();
  103.             }
  104.         } else {
  105.             // 遍历列表
  106.             for (GameObject obj : gameObjList) {
  107.                 // 判断攻击范围（圆形）与敌方（矩形）是否相交
  108.                 if (recIntersectsCir(obj.getRec(), getX(), getY(), getDis())) {
  109.                     // 找到目标
  110.                     setTarget(obj);
  111.                     setHasTarget(true);
  112.                     // 跳出循环
  113.                     break;
  114.                 }
  115.             }
  116.             // 玩家是否在攻击范围内
  117.             if (!hasTarget && gameObjList == gameFrame.blueList) {
  118.                 if (recIntersectsCir(gameFrame.player.getRec(), getX(), getY(), getDis())) {
  119.                     // 找到目标
  120.                     setTarget(gameFrame.player);
  121.                     setHasTarget(true);
  122.                 }
  123.             }
  124.             else {
  125.                 //野怪是否在攻击范围内
  126.                 for (GameObject obj : gameFrame.beast.beastList) {
  127.                     // 判断攻击范围（圆形）与敌方（矩形）是否相交
  128.                     if (recIntersectsCir(obj.getRec(), getX(), getY(), getDis())) {
  129.                         // 找到目标
  130.                         setTarget(obj);
  131.                         setHasTarget(true);
  132.                         // 跳出循环
  133.                         break;
  134.                     }
  135.                 }
  136.             }
  137.         }
  138.     }
  139.  
  140.     //public abstract void addTurret();
  141.  
  142.     class AttackCD extends Thread {
  143.         public void run() {
  144.             // 将攻击功能设置为冷却状态
  145.             setAttackCoolDown(false);
  146.             // 线程休眠
  147.             try {
  148.                 Thread.sleep(attackCoolDownTime);
  149.             } catch (Exception e) {
  150.                 e.printStackTrace();
  151.             }
  152.             // 将攻击功能设置为攻击状态
  153.             setAttackCoolDown(true);
  154.             // 线程终止
  155.             this.interrupt();
  156.         }
  157.     }
  158.  
  159.     // 绘制元素
  160.     public abstract void paintSelf(Graphics g);
  161.  
  162.     // 返回矩形
  163.     public abstract Rectangle getRec();
  164.     public int getX() {
  165.         return x;
  166.     }
  167.     public void setX(int x) {
  168.         this.x = x;
  169.     }
  170.     public int getY() {
  171.         return y;
  172.     }
  173.     public void setY(int y) {
  174.         this.y = y;
  175.     }
  176.     public Image getImg() {
  177.         return img;
  178.     }
  179.     public void setImg(String img) {
  180.         this.img = Toolkit.getDefaultToolkit().getImage(img);
  181.     }
  182.     public int getSpd() {
  183.         return spd;
  184.     }
  185.     public void setSpd(int spd) {
  186.         this.spd = spd;
  187.     }
  188.     public int getHp() {
  189.         return hp;
  190.     }
  191.     public void setHp(int hp) {
  192.         this.hp = hp;
  193.     }
  194.     public int getCurrentHp() {
  195.         return currentHp;
  196.     }
  197.     public void setCurrentHp(int currentHp) {
  198.         this.currentHp = currentHp;
  199.     }
  200.     public GameObject getTarget() {
  201.         return target;
  202.     }
  203.     public void setTarget(GameObject target) {
  204.         this.target = target;
  205.     }
  206.     public boolean isHasTarget() {
  207.         return hasTarget;
  208.     }
  209.     public void setHasTarget(boolean hasTarget) {
  210.         this.hasTarget = hasTarget;
  211.     }
  212.     public int getDis() {
  213.         return dis;
  214.     }
  215.     public void setDis(int dis) {
  216.         this.dis = dis;
  217.     }
  218.     public int getAttackCoolDownTime() {
  219.         return attackCoolDownTime;
  220.     }
  221.     public void setAttackCoolDownTime(int attackCoolDownTime) {
  222.         this.attackCoolDownTime = attackCoolDownTime;
  223.     }
  224.     public boolean isAttackCoolDown() {
  225.         return attackCoolDown;
  226.     }
  227.     public void setAttackCoolDown(boolean attackCoolDown) {
  228.         this.attackCoolDown = attackCoolDown;
  229.     }
  230.     public boolean isAlive() {
  231.         return alive;
  232.     }
  233.     public void setAlive(boolean alive) {
  234.         this.alive = alive;
  235.     }
  236. }

Turret类

  1. package newKingOfHonor;
  2.  
  3.  
  4.  
  5. import java.awt.*;
  6. import java.util.ArrayList;
  7. //防御塔类
  8. public  class Turret extends GameObject{
  9.  
  10.     ArrayList<Turret> turretList = new ArrayList<>();
  11.     public Turret turretBlueOne;
  12.     public Turret turretBlueTwo;
  13.     public Turret turretBlueThree;
  14.     public Turret turretBlueBase;
  15.     public Turret turretRedOne;
  16.     public Turret turretRedTwo;
  17.     public Turret turretRedThree;
  18.     public Turret turretRedBase;
  19.  
  20.     public Turret(GameFrame gameFrame) {
  21.         super(gameFrame);
  22.         setImg("img/王者荣耀图片/turret.png");
  23.  
  24.         // 初始化八个防御塔
  25.         turretList.add(turretBlueOne = new TurretBlue(1860, 3790, gameFrame));
  26.         turretList.add(turretBlueTwo = new TurretBlue(2650, 3820, gameFrame));
  27.         turretList.add(turretBlueThree = new TurretBlue(3995, 3830, gameFrame));
  28.         turretList.add(turretBlueBase = new TurretBlue(1130, 3650, gameFrame));
  29.         turretList.add(turretRedOne = new TurretRed(5100, 3030, gameFrame));
  30.         turretList.add(turretRedTwo = new TurretRed(5120, 2100, gameFrame));
  31.         turretList.add(turretRedThree = new TurretRed(5060, 1570, gameFrame));
  32.         turretList.add(turretRedBase = new TurretRed(4850, 1100, gameFrame));
  33.  
  34.     }
  35.  
  36.     public Turret(int x, int y, GameFrame gameFrame) {
  37.         super(x, y, gameFrame);
  38.         setImg("img/王者荣耀图片/turret.png");
  39.         setHp(6000);
  40.         setCurrentHp(getHp());
  41.         setAttackCoolDownTime(1000);
  42.         setDis(300);
  43.     }
  44.     public void isLive(){
  45.         if(gameFrame.turret.turretBlueBase.getCurrentHp()==0){
  46.             gameFrame.state=2;
  47.         }
  48.         if(gameFrame.turret.turretRedBase.getCurrentHp()==0){
  49.             gameFrame.state=1;
  50.         }
  51.     }
  52.     @Override
  53.     public void paintSelf(Graphics g) {
  54.         // 生命值为0
  55.         if (getCurrentHp() <= 0) {
  56.             setAlive(false);
  57.             gameFrame.removeList.add(this);
  58.             if (this instanceof TurretBlue) {
  59.                 gameFrame.blueList.remove(this);
  60.             } else {
  61.                 gameFrame.redList.remove(this);
  62.             }
  63.         } else {
  64.             // 添加生命值
  65.             if (this instanceof TurretBlue) {
  66.                 this.addHp(g, 50, 130, 100, 20, Color.GREEN);
  67.                 attack(gameFrame.redList);
  68.             } else {
  69.                 this.addHp(g, 50, 130, 100, 20, Color.RED);
  70.                 attack(gameFrame.blueList);
  71.             }
  72.             g.drawImage(getImg(), getX() - 50, getY() - 100, null);
  73.             g.fillOval(getX(), getY(), 10, 10);
  74.             g.drawRect(getX() - 50, getY() - 100, 100, 180);
  75.             g.drawOval(getX() - 300, getY() - 300, 600, 600);
  76.         }
  77.     }
  78.  
  79.     @Override
  80.     public Rectangle getRec() {
  81.         return new Rectangle(getX() - 50, getY() - 100, 100, 180);
  82.     }
  83. }

TurretBlue类

  1. package newKingOfHonor;
  2.  
  3.  
  4. //蓝方防御塔
  5. public class TurretBlue extends Turret{
  6.   public TurretBlue(GameFrame gameFrame){
  7.       super(gameFrame);
  8.   }
  9.   public TurretBlue(int x,int y,GameFrame gameFrame){
  10.       super(x,y,gameFrame);
  11.   }
  12. }

TurretRed类

  1. package newKingOfHonor;
  2.  
  3.  
  4. //蓝方防御塔
  5. public class TurretRed extends Turret{
  6.   public TurretRed(GameFrame gameFrame){
  7.       super(gameFrame);
  8.   }
  9.   public TurretRed(int x,int y,GameFrame gameFrame){
  10.       super(x,y,gameFrame);
  11.   }
  12. }

Champion类

  1. package newKingOfHonor;
  2.  
  3. import java.awt.*;
  4. import java.awt.event.ActionEvent;
  5. import java.awt.event.ActionListener;
  6. import java.awt.event.KeyEvent;
  7.  
  8. import javax.swing.JButton;
  9.  
  10. //游戏英雄类
  11. public abstract class Champion extends GameObject {
  12.     // 移动
  13.     public boolean up, down, left, right;
  14.     // 移动图集
  15.     static String[] imgs = new String[8];
  16.     // 第几张图片
  17.     int moveCount = 1;
  18.     //技能图片
  19.     Image abilityOne;
  20.     Image abilityTwo;
  21.     Image abilityThree;
  22.     //技能冷却时间
  23.     int coolDownTimeOne;
  24.     int coolDownTimeTwo;
  25.     int coolDownTimeThree;
  26.     //三个技能是否处于冷却状态
  27.     boolean coolDownOne = true;
  28.     boolean coolDownTwo = true;
  29.     boolean coolDownThree = true;
  30.  
  31.     static {
  32.         for (int i = 1; i < 8; i++) {
  33.             imgs[i] = "img/王者荣耀图片/move/" + i +".png";
  34.             }
  35.         }
  36.     
  37.     public Champion(GameFrame gameFrame) {
  38.         super(gameFrame);
  39.  
  40.         //定义英雄的图片和坐标
  41.         setImg("img/王者荣耀图片/stand.png");
  42.         setX(700);
  43.         setY(3800);
  44.         setSpd(75);
  45.         setHp(24000);
  46.         setDis(250);
  47.         setAttackCoolDownTime(100);
  48.         setCurrentHp(getHp());
  49.     }
  50.  
  51.     public void keyPressed(KeyEvent e) {
  52.         int key = e.getKeyCode();
  53.         if (key == KeyEvent.VK_D) {
  54.             right = true;}
  55.         if (key == KeyEvent.VK_A) {
  56.             left = true;}
  57.         if (key == KeyEvent.VK_W) {
  58.             up = true;}
  59.         if (key == KeyEvent.VK_S) {
  60.             down = true;}
  61.     }
  62.  
  63.     public void keyReleased(KeyEvent e) {
  64.         int key = e.getKeyCode();
  65.         if (key == KeyEvent.VK_D) {
  66.             right = false;}
  67.         if (key == KeyEvent.VK_A) {
  68.             left = false;}
  69.         if (key == KeyEvent.VK_W) {
  70.             up = false;}
  71.         if (key == KeyEvent.VK_S) {
  72.             down = false;}
  73.     }
  74.     public void move() {
  75.         if (up) {
  76.             setY(getY() - getSpd());
  77.         }
  78.         if (down) {
  79.             setY(getY() + getSpd());
  80.         }
  81.         if (left) {
  82.             setX(getX() - getSpd());
  83.         }
  84.         if (right) {
  85.             setX(getX() + getSpd());
  86.         }
  87.         if (up || down || left || right) {
  88.             setImg(imgs[moveCount]);
  89.             moveCount++;
  90.             if (moveCount == 8) {
  91.                 moveCount = 1;
  92.             }
  93.         } else {
  94.             setImg("img/王者荣耀图片/stand.png");
  95.         }
  96.     }
  97.  
  98.     //添加三个技能按钮
  99.  
  100.     public void addButton() {
  101.         JButton button1 = new JButton();
  102.         button1.setSize(100, 100);
  103.         button1.setLocation(1056, 513);
  104.         button1.addActionListener(new ActionListener() {
  105.             @Override
  106.             public void actionPerformed(ActionEvent e) {
  107.                 abilityOne();
  108.             }
  109.         });
  110.         JButton button2 = new JButton();
  111.         button2.setSize(100, 100);
  112.         button2.setLocation(1090, 370);
  113.         button2.addActionListener(new ActionListener() {
  114.             @Override
  115.             public void actionPerformed(ActionEvent e) {
  116.                 abilityTwo();
  117.             }
  118.         });
  119.         JButton button3 = new JButton();
  120.         button3.setSize(100, 100);
  121.         button3.setLocation(1220, 300);
  122.         button3.addActionListener(new ActionListener() {
  123.             @Override
  124.             public void actionPerformed(ActionEvent e) {
  125.                 abilityThree();
  126.             }
  127.         });
  128.         gameFrame.add(button1);
  129.         gameFrame.add(button2);
  130.         gameFrame.add(button3);
  131.     }
  132.  
  133.     public abstract void abilityOne();
  134.     public abstract void abilityTwo();
  135.     public abstract void abilityThree();
  136.     public abstract void abilityEffect(Graphics g);
  137.  
  138.     @Override
  139.     public void paintSelf(Graphics g) {
  140.         // 生命值为0
  141.         if (getCurrentHp() <= 0) {
  142.             setAlive(false);
  143.             gameFrame.removeList.add(this);
  144.  
  145.         } else {
  146.             // 添加生命值
  147.             addHp(g, 30, 80, 80, 20, Color.GREEN);
  148.             //绘制技能图片
  149.             g.drawImage(abilityOne, getX() + 360, getY() + 180, null);
  150.             g.drawImage(abilityTwo, getX() + 400, getY() + 40, null);
  151.             g.drawImage(abilityThree, getX() + 520, getY() - 30, null);
  152.             // 绘制图片
  153.             g.drawImage(this.getImg(), getX() - 33, getY() - 50, null);
  154.             // 改变画笔颜色
  155.             g.setColor(Color.GREEN);
  156.             // 绘制中心圆点
  157.             g.fillOval(getX(), getY(), 10, 10);
  158.             // 绘制矩形边框
  159.             g.drawRect(getX() - 23, getY() - 50, 60, 120);
  160.             move();
  161.             abilityEffect(g);
  162.         }
  163.     }
  164.  
  165.     @Override
  166.     public Rectangle getRec() {
  167.         return new Rectangle(getX() - 30, getY() - 60, 60, 120);
  168.     }
  169.  
  170. }

ChampionDaji类

  1. package newKingOfHonor;
  2.  
  3. import java.awt.Color;
  4. import java.awt.Graphics;
  5. import java.awt.Polygon;
  6. import java.awt.Toolkit;
  7. import java.awt.event.MouseAdapter;
  8. import java.awt.event.MouseEvent;
  9. import java.util.ArrayList;
  10. import java.util.Random;
  11.  
  12.  
  13.  
  14. public class ChampionDaji extends Champion {
  15.  
  16.     // 技能是否处于释放状态
  17.     boolean ifAbilityOne = false;
  18.     boolean ifAbilityTwo = false;
  19.     // 鼠标监视器
  20.    MouseMonitor m;
  21.     // 一技能多边形
  22.     Polygon p;
  23.     // 一技能三角函数
  24.     double sin;
  25.     double cos;
  26.     // 一技能已经攻击过的目标
  27.     ArrayList<GameObject> attacked;
  28.     // 一技能移动次数
  29.     int step = 0;
  30.     // 技能二目标
  31.     GameObject abilityTwoTarget;
  32.     // 技能二子弹
  33.     Bullet abilityTwoBullet;
  34.     // 三技能的五个子弹，释放三技能后重新定义
  35.     Bullet[] bulletList = { new Bullet(), new Bullet(), new Bullet(), new Bullet(), new Bullet() };
  36.  
  37.     public ChampionDaji(GameFrame gameFrame) {
  38.         super(gameFrame);
  39.         abilityOne = Toolkit.getDefaultToolkit().getImage("img/王者荣耀图片/Daji/abilityOne.jpg");
  40.         abilityTwo = Toolkit.getDefaultToolkit().getImage("img/王者荣耀图片/Daji/abilityTwo.jpg");
  41.         abilityThree = Toolkit.getDefaultToolkit().getImage("img/王者荣耀图片/Daji/abilityThree.jpg");
  42.         // 三个技能冷却时间
  43.         coolDownTimeOne = 3000;
  44.         coolDownTimeTwo = 5000;
  45.         coolDownTimeThree = 8000;
  46.     }
  47.  
  48.     public void exit() {
  49.         this.gameFrame.removeMouseListener(m);
  50.     }
  51.  
  52.     public void abilityOneMove() {
  53.         p.translate((int) (50 * cos), -(int) (50 * sin));
  54.         for (GameObject redObj : gameFrame.redList) {
  55.             // 是红色方小兵 && 发生碰撞 && 没在attacked列表里
  56.             if (redObj instanceof MinionRed && p.intersects(redObj.getRec()) && attacked.indexOf(redObj) == -1) {
  57.                 // 小兵扣血，添加到attacked里
  58.                 redObj.setCurrentHp(redObj.getCurrentHp() - 400);
  59.                 attacked.add(redObj);
  60.             }
  61.         }
  62.     }
  63.  
  64.     @Override
  65.     public void abilityOne() {
  66.         if (coolDownOne) {
  67.             m = new MouseMonitor();
  68.             p = new Polygon();
  69.             gameFrame.addMouseListener(m);
  70.             attacked = new ArrayList<GameObject>();
  71.         }
  72.     }
  73.  
  74.  
  75.     public void abilityTwo() {
  76.         if (coolDownTwo) {
  77.             boolean find = false;
  78.             for (GameObject redObj : gameFrame.objList) {
  79.                 // 是红色小兵 && 距离小于250 && 存活
  80.                 if (redObj instanceof MinionRed && recIntersectsCir(redObj.getRec(), getX(), getY(), 250)
  81.                         && redObj.isAlive()) {
  82.                     // 添加子弹
  83.                     abilityTwoBullet = new Bullet(gameFrame, this, redObj, 250, 60, "img/王者荣耀图片/Daji/abilityTwoBullet.png");
  84.                     gameFrame.objList.add(abilityTwoBullet);
  85.                     // 给目标赋值
  86.                     abilityTwoTarget = redObj;
  87.                     // 释放二技能
  88.                     ifAbilityTwo = true;
  89.                     find = true;
  90.                     break;
  91.                 }
  92.             }
  93.             if (find) {
  94.                 new AbilityTwoCD().start();
  95.                 find = false;
  96.             }
  97.         }
  98.     }
  99.  
  100.     /**
  101.      * 点击技能三释放技能 先将技能范围内目标储存到targetList里 提前定义五个子弹 技能释放时初始化五个子弹 子弹目标从targetList里随机选择
  102.      * 如果期间目标死亡，制作一个目标替身，生命值设置为true 子弹与目标或替身碰撞后消失
  103.      */
  104.     @Override
  105.     public void abilityThree() {
  106.         if (coolDownThree) {
  107.             // 创建列表来储存目标
  108.             ArrayList<GameObject> targetList = new ArrayList<GameObject>();
  109.             // 遍历redList，找到符合条件的目标，储存到列表里
  110.             for (int i = 0; i < gameFrame.objList.size(); i++) {
  111.                 GameObject target = gameFrame.objList.get(i);
  112.                 // 是红色小兵 && 在技能范围里 && 存活
  113.                 if (target instanceof MinionRed && recIntersectsCir(target.getRec(), getX(), getY(), 250)
  114.                         && target.isAlive()) {
  115.                     targetList.add(target);
  116.                 }
  117.             }
  118.             // 找到目标
  119.             if (targetList.size() != 0) {
  120.                 // 创建五个子弹，随机攻击列表里的目标
  121.                 Random random = new Random();
  122.                 int count = 0; // 统计三技能发射子弹数量
  123.                 while (count < 5) {
  124.                     int r = random.nextInt(targetList.size());
  125.                     if (!targetList.get(r).isAlive()) {
  126.                         GameObject substitute = targetList.get(r);
  127.                         substitute.setAlive(true);
  128.                         bulletList[count] = new Bullet(gameFrame, this, substitute, 150, 60,
  129.                         		"img/王者荣耀图片/Daji/abilityTwoBullet.png");
  130.                     } else {
  131.                         bulletList[count] = new Bullet(gameFrame, this, targetList.get(r), 150, 60,
  132.                         		"img/王者荣耀图片/Daji/abilityTwoBullet.png");
  133.                     }
  134.                     count++;
  135.                 }
  136.                 new AbilityThreeBulletCD().start();
  137.                 // 三技能进入冷却
  138.                 new AbilityThreeCD().start();
  139.             }
  140.         }
  141.     }
  142.  
  143.     @Override
  144.     public void abilityEffect(Graphics g) {
  145.         if (ifAbilityOne) {
  146.             g.setColor(Color.RED);
  147.             g.fillPolygon(p);
  148.             abilityOneMove();
  149.             step++;
  150.             if (step == 10) {
  151.                 step = 0;
  152.                 ifAbilityOne = false;
  153.             }
  154.         }
  155.         if (ifAbilityTwo) {
  156.             System.out.println(abilityTwoTarget.beControlled);
  157.             if (abilityTwoBullet.getRec().intersects(abilityTwoTarget.getRec())) {
  158.                 new AbilityControllCD().start();
  159.                 ifAbilityTwo = false;
  160.             }
  161.         }
  162.     }
  163.  
  164.     // 技能一冷却时间
  165.     class AbilityOneCD extends Thread {
  166.         public void run() {
  167.             // 将技能一设置为冷却状态
  168.             coolDownOne = false;
  169.             // 线程休眠
  170.             try {
  171.                 // one来表示一技能冷却时间
  172.                 int one = coolDownTimeOne;
  173.                 while (one > 0) {
  174.                     Thread.sleep(1000);
  175.                     System.out.println("一技能冷却时间： " + one / 1000);
  176.                     one -= 1000;
  177.                 }
  178.             } catch (Exception e) {
  179.                 e.printStackTrace();
  180.             }
  181.             // 将技能一设置为攻击状态
  182.             coolDownOne = true;
  183.             // 线程终止
  184.             this.interrupt();
  185.         }
  186.     }
  187.  
  188.     // 技能二冷却时间
  189.     class AbilityTwoCD extends Thread {
  190.         public void run() {
  191.             // 将技能二设置为冷却状态
  192.             coolDownTwo = false;
  193.             // 线程休眠
  194.             try {
  195.                 // one来表示二技能冷却时间
  196.                 int two = coolDownTimeTwo;
  197.                 while (two > 0) {
  198.                     Thread.sleep(1000);
  199.                     System.out.println("二技能冷却时间： " + two / 1000);
  200.                     two -= 1000;
  201.                 }
  202.             } catch (Exception e) {
  203.                 e.printStackTrace();
  204.             }
  205.             // 将技能二设置为攻击状态
  206.             coolDownTwo = true;
  207.             // 线程终止
  208.             this.interrupt();
  209.         }
  210.     }
  211.  
  212.     // 技能二控制时间
  213.     class AbilityControllCD extends Thread {
  214.         public void run() {
  215.             abilityTwoTarget.beControlled = true;
  216.             // 线程休眠
  217.             try {
  218.                 Thread.sleep(20000);
  219.             } catch (Exception e) {
  220.                 e.printStackTrace();
  221.             }
  222.             abilityTwoTarget.beControlled = false;
  223.             this.interrupt();
  224.         }
  225.  
  226.     }
  227.     //技能三冷却状态
  228.     class AbilityThreeCD extends Thread {
  229.         public void run() {
  230.             // 将攻击功能设置为冷却状态
  231.             coolDownThree = false;
  232.             // 休眠
  233.             try {
  234.                 int three = coolDownTimeThree;
  235.                 while (coolDownTimeThree > 0) {
  236.                     Thread.sleep(1000);
  237.                     System.out.println("技能三冷却时间： " + coolDownTimeThree / 1000);
  238.                     coolDownTimeThree -= 1000;
  239.                 }
  240.                 coolDownTimeThree = three;
  241.             } catch (Exception e) {
  242.                 e.printStackTrace();
  243.             }
  244.             // 将攻击功能解除冷却状态
  245.             coolDownThree = true;
  246.             // 线程终止
  247.             this.interrupt();
  248.         }
  249.     }
  250.  
  251.     class AbilityThreeBulletCD extends Thread {
  252.         public void run() {
  253.             // 休眠
  254.             try {
  255.                 System.out.println("Thread start");
  256.                 gameFrame.objList.add(bulletList[0]);
  257.                 Thread.sleep(100);
  258.                 gameFrame.objList.add(bulletList[1]);
  259.                 Thread.sleep(100);
  260.                 gameFrame.objList.add(bulletList[2]);
  261.                 Thread.sleep(100);
  262.                 gameFrame.objList.add(bulletList[3]);
  263.                 Thread.sleep(100);
  264.                 gameFrame.objList.add(bulletList[4]);
  265.             } catch (Exception e) {
  266.                 e.printStackTrace();
  267.             }
  268.             // 线程终止
  269.             this.interrupt();
  270.         }
  271.     }
  272.  
  273.     // 鼠标监视器
  274.     private class MouseMonitor extends MouseAdapter {
  275.         @Override
  276.         public void mousePressed(MouseEvent e) {// 当鼠标点击时
  277.             int mouseX = e.getX(), mouseY = e.getY(), playerX = 700, playerY = 350;
  278.             double dis = getDis(mouseX, mouseY, playerX, playerY);
  279.             // 三角函数
  280.             cos = (mouseX - playerX) / dis;
  281.             sin = -(mouseY - playerY) / dis;
  282.             // 坐标差
  283.             int difX = (int) (60 * sin);
  284.             int difY = (int) (60 * cos);
  285.             p.addPoint(getX() - difX, getY() - difY);
  286.             p.addPoint(getX() + difX, getY() + difY);
  287.             p.addPoint(getX() + difX + (int) (20 * cos), getY() + difY - (int) (20 * sin));
  288.             p.addPoint(getX() - difX + (int) (20 * cos), getY() - difY - (int) (20 * sin));
  289.             exit();
  290.             new AbilityOneCD().start();
  291.             ifAbilityOne = true;
  292.         }
  293.     }
  294. }

Minion类

  1. package newKingOfHonor;
  2.  
  3. import java.awt.*;
  4. import java.util.ArrayList;
  5.  
  6. public abstract class Minion extends GameObject{
  7.  
  8.     // 是否生成下一个小兵
  9.     private boolean nextMinion = true;
  10.     // 是否生成下一波小兵
  11.     private boolean nextLine = true;
  12.     // 生成小兵数量
  13.     private int minionCount = 0;
  14.     // 是否检测到目标
  15.     private boolean ifFindTarget = false;
  16.  
  17.     public Minion(GameFrame gameFrame) {
  18.         super(gameFrame);
  19.         setHp(800);
  20.         setCurrentHp(getHp());
  21.         setDis(100);
  22.         setAttackCoolDownTime(2000);
  23.     }
  24.  
  25.     /**
  26.      * (1325, 3750) (4425, 3750) (5050, 3125) (5050, 1125)
  27.      */
  28.  
  29.     public abstract void move(ArrayList<GameObject> objList);
  30.  
  31.     public void findTarget(ArrayList<GameObject> objList) {
  32.         for (GameObject obj : objList) {
  33.             if (recIntersectsCir(obj.getRec(), getX(), getY(), 200)) {
  34.                 setTarget(obj);
  35.                 setIfFindTarget(true);
  36.             }
  37.         }
  38.         if (objList == gameFrame.blueList) {
  39.             if (recIntersectsCir(gameFrame.player.getRec(), getX(), getY(), 200)) {
  40.                 setTarget(gameFrame.player);
  41.                 setIfFindTarget(true);
  42.             }
  43.         }
  44.     }
  45.  
  46.     public void moveToTarget() {
  47.         int dis = (int) getDis(getX(), getY(), getTarget().getX(), getTarget().getY());
  48.         if(dis!=0) {
  49.             int xSpeed =  (getSpd() * (getTarget().getX() - getX()) / dis);
  50.             int ySpeed = (getSpd() * (getTarget().getY() - getY()) / dis);
  51.             setX(getX() + xSpeed);
  52.             setY(getY() + ySpeed);
  53.         }
  54.     }
  55.  
  56.     public void createMinion(GameFrame gameFrame, ArrayList<GameObject> minionList) {
  57.         if (nextLine) {
  58.             if (nextMinion) {
  59.                 // 蓝色方小兵
  60.                 if (minionList == this.gameFrame.blueList) {
  61.                     MinionBlue mb = new MinionBlue(gameFrame);
  62.                     gameFrame.objList.add(mb);
  63.                     minionList.add(mb);
  64.                 }
  65.                 // 红色方小兵
  66.                 else {
  67.                     MinionRed mr = new MinionRed(gameFrame);
  68.                     gameFrame.objList.add(mr);
  69.                     minionList.add(mr);
  70.                 }
  71.                 minionCount++;
  72.                 new NextMinion().start();
  73.             }
  74.             if (minionCount == 3) {
  75.                 minionCount = 0;
  76.                 new NextLine().start();
  77.             }
  78.         }
  79.     }
  80.  
  81.     // 每个小兵生成时间
  82.     class NextMinion extends Thread {
  83.         public void run() {
  84.             nextMinion = false;
  85.             // 休眠1.5s
  86.             try {
  87.                 Thread.sleep(1500);
  88.             } catch (Exception e) {
  89.                 e.printStackTrace();
  90.             }
  91.             nextMinion = true;
  92.             // 线程终止
  93.             this.interrupt();
  94.         }
  95.     }
  96.  
  97.     // 每波小兵生成时间
  98.     class NextLine extends Thread {
  99.         public void run() {
  100.             nextLine = false;
  101.             // 休眠15s
  102.             try {
  103.                 Thread.sleep(15000);
  104.             } catch (Exception e) {
  105.                 e.printStackTrace();
  106.             }
  107.             nextLine = true;
  108.             // 线程终止
  109.             this.interrupt();
  110.         }
  111.     }
  112.  
  113.     @Override
  114.     public void paintSelf(Graphics g) {
  115.         // 生命值为0
  116.         if (getCurrentHp() <= 0) {
  117.             setAlive(false);
  118.             gameFrame.removeList.add(this);
  119.             if (this instanceof MinionBlue) {
  120.                 gameFrame.blueList.remove(this);
  121.             } else {
  122.                 gameFrame.redList.remove(this);
  123.             }
  124.         } else {
  125.             // 添加生命值
  126.             if (this instanceof MinionBlue) {
  127.                 this.addHp(g, 17, 28, 45, 10, Color.GREEN);
  128.             } else {
  129.                 this.addHp(g, 17, 28, 45, 10, Color.RED);
  130.             }
  131.             g.drawImage(getImg(), getX() - 16, getY() - 16, null);
  132.             g.setColor(Color.RED);
  133.             g.fillOval(getX(), getY(), 10, 10);
  134.             g.drawRect(getX() - 16, getY() - 16, 45, 45);
  135.             g.drawOval(getX() - 200, getY() - 200, 400, 400);
  136.             // 小兵移动
  137.             if (!beControlled) {
  138.                 if (this instanceof MinionBlue) {
  139.                     move(gameFrame.redList);
  140.                 } else {
  141.                     move(gameFrame.blueList);
  142.                 }
  143.             }
  144.         }
  145.     }
  146.  
  147.     @Override
  148.     public Rectangle getRec() {
  149.         return new Rectangle(getX() - 16, getY() - 16, 45, 45);
  150.     }
  151.  
  152.     public boolean isIfFindTarget() {
  153.         return ifFindTarget;
  154.     }
  155.     public void setIfFindTarget(boolean ifFindTarget) {
  156.         this.ifFindTarget = ifFindTarget;
  157.     }
  158.  
  159. }

MinionBlue类

  1. package newKingOfHonor;
  2.  
  3. import java.util.ArrayList;
  4.  
  5. public  class MinionBlue extends Minion{
  6.  
  7.     public MinionBlue(GameFrame gameFrame) {
  8.         super(gameFrame);
  9.         setImg("img/王者荣耀图片/minion/blue.jpg");
  10.         setX(1325);
  11.         setY(3750);
  12.     }
  13.  
  14.     @Override
  15.     public void move(ArrayList<GameObject> objList) {
  16.         if(isIfFindTarget()) {
  17.             //离开检测范围
  18.             if(!recIntersectsCir(getTarget().getRec(), getX(), getY(), 200)) {
  19.                 setIfFindTarget(false);
  20.             }else {
  21.                 if(!isHasTarget()) {
  22.                     moveToTarget();
  23.                 }
  24.                 attack(objList);
  25.             }
  26.         }else {
  27.             findTarget(objList);
  28.             //原路线移动
  29.             if(getX() < 4425) {
  30.                 setSpd(5);
  31.                 setX(getX() + getSpd());
  32.             }else if(getX() < 5100 && getX() >= 4425) {
  33.                 setSpd(20);
  34.                 setX(getX() + getSpd());
  35.                 setY(getY() - getSpd());
  36.             }else if(getX() >= 4900) {
  37.                 setSpd(18);
  38.                 setY(getY() - getSpd());
  39.             }
  40.         }
  41.     }
  42. }

MinionRed类

  1. package newKingOfHonor;
  2.  
  3. import java.util.ArrayList;
  4.  
  5. public  class MinionRed extends Minion {
  6.     public MinionRed(GameFrame gameFrame) {
  7.         super(gameFrame);
  8.         setImg("img/王者荣耀图片/minion/red.jpg");
  9.         setX(5050);
  10.         setY(1125);
  11.     }
  12.  
  13.     @Override
  14.     public void move(ArrayList<GameObject> objList) {
  15.         if (isIfFindTarget()) {
  16.             // 离开检测范围
  17.             if (!recIntersectsCir(getTarget().getRec(), getX(), getY(), 200)) {
  18.                 setIfFindTarget(false);
  19.             } else {
  20.                 if (!isHasTarget()) {
  21.                     moveToTarget();
  22.                 }
  23.                 attack(objList);
  24.             }
  25.         } else {
  26.             findTarget(objList);
  27.             // 原路线移动
  28.             if (getY() < 3125) {
  29.                 setSpd(28);
  30.                 setY(getY() + getSpd());
  31.             } else if (getY() < 3750 && getY() >= 3125) {
  32.                 setSpd(20);
  33.                 setY(getY() + getSpd());
  34.                 setX(getX() - getSpd());
  35.             } else if (getY() >= 3750) {
  36.                 setSpd(25);
  37.                 setX(getX() - getSpd());
  38.             }
  39.         }
  40.     }
  41.  
  42.  
  43.  
  44.  
  45. }

Bullet类

  1. package newKingOfHonor;
  2.  
  3. import java.awt.*;
  4.  
  5. //子弹类
  6. public  class Bullet extends GameObject {
  7.  
  8.     //发射子弹的游戏元素
  9.     GameObject attacker;
  10.     //目标
  11.     GameObject target;
  12.     //攻击力
  13.     int ad;
  14.  
  15.     public Bullet(GameFrame gameFrame, GameObject attacker, GameObject target, int ad, int spd) {
  16.         super(attacker.getX(), attacker.getY(), gameFrame);
  17.         this.attacker = attacker;
  18.         this.target = target;
  19.         setAd(ad);
  20.         setSpd(spd);
  21.     }
  22.  
  23.     public Bullet(GameFrame gameFrame, GameObject attacker, GameObject target, int ad, int spd, String img) {
  24.         super(attacker.getX(), attacker.getY(), gameFrame);
  25.         this.attacker = attacker;
  26.         this.target = target;
  27.         setImg(img);
  28.         setAd(ad);
  29.         setSpd(spd);
  30.     }
  31.  
  32.     public Bullet() {
  33.         super();
  34.     }
  35.  
  36.     public void move() {
  37.         //子弹与目标碰撞，子弹消失，目标减血
  38.         if (recIntersectsRec(getRec(), target.getRec())) {
  39.             target.setCurrentHp(target.getCurrentHp() - getAd());
  40.             gameFrame.removeList.add(this);
  41.         }
  42.         int dis = (int) getDis(getX(), getY(), target.getX(), target.getY());
  43.         if (dis != 0) {
  44.             int xSpeed =  (getSpd() * (target.getX() - getX()) / dis);
  45.             int ySpeed =  (getSpd() * (target.getY() - getY()) / dis);
  46.             setX(getX() + xSpeed);
  47.             setY(getY() + ySpeed);
  48.         }
  49.     }
  50.  
  51.     @Override
  52.     public void paintSelf(Graphics g) {
  53.         g.drawImage(getImg(), getX()-16, getY()-16, null);
  54.         g.setColor(Color.BLACK);
  55.         g.fillOval(getX()-5, getY()-5, 10, 10);
  56.         g.drawRect(getX()-5, getY()-5, 10, 10);
  57.         move();
  58.     }
  59.  
  60.     @Override
  61.     public Rectangle getRec() {
  62.         return new Rectangle(getX()-5, getY()-5, 10, 10);
  63.     }
  64.     public int getAd() {
  65.         return ad;
  66.     }
  67.  
  68.     public void setAd(int ad) {
  69.         this.ad = ad;
  70.     }
  71. }

Background类

  1. package newKingOfHonor;
  2.  
  3. import java.awt.*;
  4. //背景类
  5. public  class Background extends GameObject{
  6.     public Background(GameFrame gameFrame) {
  7.         super(gameFrame);
  8.     }
  9.  
  10.     Image bg = Toolkit.getDefaultToolkit().getImage("img/王者荣耀图片/Map.jpg");
  11.  
  12.     public void paintSelf(Graphics g){
  13.         g.drawImage(bg,0,0,null);
  14.  
  15.     }
  16.     @Override
  17.     public Rectangle getRec() {
  18.         return null;
  19.     }
  20. }

Beast类

  1. package newKingOfHonor;
  2.  
  3. import java.awt.Color;
  4. import java.awt.Graphics;
  5. import java.awt.Rectangle;
  6. import java.util.ArrayList;
  7.  
  8.  
  9.  
  10. public class Beast extends GameObject {
  11.  
  12.     public ArrayList<Beast> beastList = new ArrayList<>();
  13.     int width;
  14.     int height;
  15.     // 复活的元素
  16.     Beast beast = null;
  17.  
  18.     public Beast(GameFrame gameFrame) {
  19.         super(gameFrame);
  20.         beastList.add(new RedBuff(3045, 3170, gameFrame));
  21.         beastList.add(new Bear(2800, 2855, gameFrame));
  22.         beastList.add(new Bird(3570, 3380, gameFrame));
  23.         beastList.add(new Lizard(4585, 2365, gameFrame));
  24.         beastList.add(new BlueBuff(4025, 2295, gameFrame));
  25.         beastList.add(new Wolf(4235, 1945, gameFrame));
  26.     }
  27.  
  28.     public Beast(int x, int y, GameFrame gameFrame) {
  29.         super(x, y, gameFrame);
  30.         setHp(1000);
  31.         setCurrentHp(getHp());
  32.         beast = this;
  33.     }
  34.  
  35.  
  36.     @Override
  37.     public void paintSelf(Graphics g) {
  38.         if (getCurrentHp() <= 0) {
  39.             System.out.println("beast die");
  40.             setAlive(false);
  41.             gameFrame.removeList.add(this);
  42.             gameFrame.beast.beastList.remove(this);
  43.             new ReviveCD().start();
  44.         } else {
  45.             // 添加生命值
  46.             addHp(g, width / 2, 80, width, 20, Color.GREEN);
  47.             g.drawImage(getImg(), getX() - width / 2, getY() - height / 2, null);
  48.             g.setColor(Color.RED);
  49.             g.fillOval(getX(), getY(), 10, 10);
  50.             g.drawOval(getX() - getDis(), getY() - getDis(), 2 * getDis(), 2 * getDis());
  51.         }
  52.     }
  53.  
  54.     @Override
  55.     public Rectangle getRec() {
  56.         return new Rectangle(getX() - width / 2, getY() - height / 2, width, height);
  57.     }
  58.     //野怪复活
  59.     class ReviveCD extends Thread {
  60.         public void run() {
  61.             // 线程休眠
  62.             try {
  63.                 Thread.sleep(5000);
  64.             } catch (Exception e) {
  65.                 e.printStackTrace();
  66.             }
  67.             Beast reviveBeast;
  68.             if (beast instanceof RedBuff) {
  69.                 reviveBeast = new RedBuff(3045, 3170, gameFrame);
  70.             } else if (beast instanceof Bear) {
  71.                 reviveBeast = new Bear(2800, 2855, gameFrame);
  72.             } else if (beast instanceof Bird) {
  73.                 reviveBeast = new Bird(3570, 3380, gameFrame);
  74.             } else if (beast instanceof Lizard) {
  75.                 reviveBeast = new Lizard(4585, 2365, gameFrame);
  76.             } else if (beast instanceof BlueBuff) {
  77.                 reviveBeast = new BlueBuff(4025, 2295, gameFrame);
  78.             } else {
  79.                 reviveBeast = new Wolf(4235, 1945, gameFrame);
  80.             }
  81.             gameFrame.objList.add(reviveBeast);
  82.             gameFrame.beast.beastList.add(reviveBeast);
  83.         }
  84.     }
  85.  
  86. }

Bear类

  1. package newKingOfHonor;
  2.  
  3. public class Bear extends Beast {
  4.     public Bear(int x, int y, GameFrame gameFrame) {
  5.         super(x, y, gameFrame);
  6.         setImg("img/王者荣耀图片/beast/bear.jpg");
  7.         width = 85;
  8.         height = 112;
  9.         setDis(65);
  10.     }
  11.  
  12. }

Bird类

  1. package newKingOfHonor;
  2.  
  3. public class Bird extends Beast {
  4.     public Bird(int x, int y, GameFrame gameFrame) {
  5.         super(x, y, gameFrame);
  6.         setImg("img/王者荣耀图片/beast/红隼.jpg");
  7.         width = 122;
  8.         height = 98;
  9.         setDis(125);
  10.     }
  11.  
  12. }

BlueBuff类

  1. package newKingOfHonor;
  2.  
  3. public class BlueBuff extends Beast {
  4.     public BlueBuff(int x, int y, GameFrame gameFrame) {
  5.         super(x, y, gameFrame);
  6.         setImg("img/王者荣耀图片/beast/blueBuff.jpg");
  7.         width = 142;
  8.         height = 176;
  9.         setDis(70);
  10.     }
  11.  
  12. }

RedBuff类

  1. package newKingOfHonor;
  2.  
  3. public class RedBuff extends Beast {
  4.     public RedBuff(int x, int y, GameFrame gameFrame) {
  5.         super(x, y, gameFrame);
  6.         setImg("img/王者荣耀图片/beast/redBuff.jpg");
  7.         width = 103;
  8.         height = 150;
  9.         setDis(70);
  10.     }
  11. }

Wolf类

  1. package 王者荣耀;
  2.  
  3.  
  4. public class Wolf extends Beast {
  5.  
  6.     public Wolf(int x, int y, GameFrame gameFrame) {
  7.         super(x, y, gameFrame);
  8.         setImg("C:\\Users\\czl21\\Desktop\\java\\王者荣耀图片\\beast\\wolf.jpg");
  9.         width = 145;
  10.         height = 140;
  11.         setDis(65);
  12.     }
  13.  
  14. }

Lizard类

  1. package newKingOfHonor;
  2.  
  3.  
  4. public class Lizard extends Beast {
  5.  
  6.     public Lizard(int x, int y, GameFrame gameFrame) {
  7.         super(x, y, gameFrame);
  8.         setImg("img/王者荣耀图片/beast/蜥蜴.jpg");
  9.         width = 111;
  10.         height = 65;
  11.         setDis(125);
  12.     }
  13. }

 运行结果

 

主要的代码来源

 00_王者荣耀_宣传片_哔哩哔哩_bilibili

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Gausst松鼠会/article/detail/98142
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号