• 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 objList = new ArrayList<>();
    44.     ArrayList redList = new ArrayList<>();// 红色方
    45.     ArrayList blueList = new ArrayList<>();// 蓝色方
    46.     public ArrayList 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 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 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 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();
    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 targetList = new ArrayList();
    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 objList);
    30.  
    31.     public void findTarget(ArrayList 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 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 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 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 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

  • 相关阅读:
    Chromium VIZ架构详解
    【CSDN｜每日一练】幼稚班作业
    C4D坐标与渲染
    C盘扩容（微PE工具箱）
    常用对称加密算法之AES算法-CBC模式
    文心一言 VS 讯飞星火 VS chatgpt （105）-- 算法导论10.1 3题
    2.1 向量与线性方程组
    搭建一个干净整洁的vue前端开发环境
    python实现五子棋-人机对战/人人对战（动图演示+源码分享）
    重要活动 | 林乐博士受邀出席“绿色金融创新策略与应用”论坛
  • 原文地址：https://blog.csdn.net/nmy15570188135/article/details/134630396