王者荣耀游戏

追梦人的自留地

 关注

阅读 58

2023-11-29

游戏运行如下：

sxt

Background

 

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

 

 

Bullet
 

 

  1.  
    package sxt;
     
  3.  
    import java.awt.*;
     
  5.  
    //子弹类
     
  6.  
    public class Bullet extends GameObject {
     
  8.  
    //发射子弹的游戏元素
     
  9.  
    GameObject attacker;
     
  10.  
    //目标
     
  11.  
    GameObject target;
     
  12.  
    //攻击力
     
  13.  
    int ad;
     
  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.  
    }
     
  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.  
    }
     
  32.  
    public Bullet() {
     
  33.  
    super();
     
  34.  
    }
     
  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.  
    }
     
  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.  
    }
     
  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.  
    }
     
  68.  
    public void setAd(int ad) {
     
  69.  
    this.ad = ad;
     
  70.  
    }
     
  71.  
    }
     
 

 

 

Champion
 

 

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

 

 

ChampionDaji
 

 

  1.  
    package sxt;
     
  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;
     
  14.  
    public class ChampionDaji extends Champion {
     
  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() };
     
  37.  
    public ChampionDaji(GameFrame gameFrame) {
     
  38.  
    super(gameFrame);
     
  39.  
    abilityOne = Toolkit.getDefaultToolkit().getImage("C:\\Users\\24465\\Desktop\\王者荣耀图片(1)\\王者荣耀图片\\Daji\\abilityOne.jpg");
     
  40.  
    abilityTwo = Toolkit.getDefaultToolkit().getImage("C:\\Users\\24465\\Desktop\\王者荣耀图片(1)\\王者荣耀图片\\Daji\\abilityTwo.jpg");
     
  41.  
    abilityThree = Toolkit.getDefaultToolkit().getImage("C:\\Users\\24465\\Desktop\\王者荣耀图片(1)\\王者荣耀图片\\Daji\\abilityThree.jpg");
     
  42.  
    // 三个技能冷却时间
     
  43.  
    coolDownTimeOne = 3000;
     
  44.  
    coolDownTimeTwo = 5000;
     
  45.  
    coolDownTimeThree = 8000;
     
  46.  
    }
     
  48.  
    public void exit() {
     
  49.  
    this.gameFrame.removeMouseListener(m);
     
  50.  
    }
     
  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.  
    }
     
  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.  
    }
     
  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, "C:\\Users\\24465\\Desktop\\王者荣耀图片(1)\\王者荣耀图片\\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.  
    }
     
  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.  
    "C:\\Users\\24465\\Desktop\\王者荣耀图片(1)\\王者荣耀图片\\Daji\\abilityTwoBullet.png");
     
  130.  
    } else {
     
  131.  
    bulletList[count] = new Bullet(gameFrame, this, targetList.get(r), 150, 60,
     
  132.  
    "C:\\Users\\24465\\Desktop\\王者荣耀图片(1)\\王者荣耀图片\\Daji\\abilityTwoBullet.png");
     
  133.  
    }
     
  134.  
    count++;
     
  135.  
    }
     
  136.  
    new AbilityThreeBulletCD().start();
     
  137.  
    // 三技能进入冷却
     
  138.  
    new AbilityThreeCD().start();
     
  139.  
    }
     
  140.  
    }
     
  141.  
    }
     
  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.  
    }
     
  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.  
    }
     
  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.  
    }
     
  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.  
    }
     
  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.  
    }
     
  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.  
    }
     
  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.  
    }
     
 

 

 

GameFrame
 

 

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

 

 

GameObject
 

 

  1.  
    package sxt;
     
  3.  
    import java.awt.*;
     
  4.  
    import java.util.ArrayList;
     
  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;
     
  36.  
    public GameObject(GameFrame gameFrame) {
     
  37.  
    this.gameFrame = gameFrame;
     
  38.  
    }
     
  40.  
    public GameObject(int x, int y, GameFrame gameFrame) {
     
  41.  
    this.x = x;
     
  42.  
    this.y = y;
     
  43.  
    this.gameFrame = gameFrame;
     
  44.  
    }
     
  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.  
    }
     
  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.  
    }
     
  61.  
    // 矩形矩形碰撞检测
     
  62.  
    public boolean recIntersectsRec(Rectangle r1, Rectangle r2) {
     
  63.  
    return r1.intersects(r2);
     
  64.  
    }
     
  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.  
    }
     
  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.  
    }
     
  140.  
    //public abstract void addTurret();
     
  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.  
    }
     
  159.  
    // 绘制元素
     
  160.  
    public abstract void paintSelf(Graphics g);
     
  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.  
    }
     
 

 

 

Minion
 

 

  1.  
    package sxt;
     
  3.  
    import java.awt.*;
     
  4.  
    import java.util.ArrayList;
     
  6.  
    public abstract class Minion extends GameObject{
     
  8.  
    // 是否生成下一个小兵
     
  9.  
    private boolean nextMinion = true;
     
  10.  
    // 是否生成下一波小兵
     
  11.  
    private boolean nextLine = true;
     
  12.  
    // 生成小兵数量
     
  13.  
    private int minionCount = 0;
     
  14.  
    // 是否检测到目标
     
  15.  
    private boolean ifFindTarget = false;
     
  17.  
    public Minion(GameFrame gameFrame) {
     
  18.  
    super(gameFrame);
     
  19.  
    setHp(800);
     
  20.  
    setCurrentHp(getHp());
     
  21.  
    setDis(100);
     
  22.  
    setAttackCoolDownTime(2000);
     
  23.  
    }
     
  25.  
    /**
     
  26.  
    * (1325, 3750) (4425, 3750) (5050, 3125) (5050, 1125)
     
  27.  
    */
     
  29.  
    public abstract void move(ArrayList<GameObject> objList);
     
  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.  
    }
     
  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.  
    }
     
  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.  
    }
     
  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.  
    }
     
  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.  
    }
     
  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.  
    }
     
  147.  
    @Override
     
  148.  
    public Rectangle getRec() {
     
  149.  
    return new Rectangle(getX() - 16, getY() - 16, 45, 45);
     
  150.  
    }
     
  152.  
    public boolean isIfFindTarget() {
     
  153.  
    return ifFindTarget;
     
  154.  
    }
     
  155.  
    public void setIfFindTarget(boolean ifFindTarget) {
     
  156.  
    this.ifFindTarget = ifFindTarget;
     
  157.  
    }
     
  159.  
    }
     
 

 

 

MinionBlue
 

 

  1.  
    package sxt;
     
  3.  
    import java.util.ArrayList;
     
  5.  
    public class MinionBlue extends Minion{
     
  7.  
    public MinionBlue(GameFrame gameFrame) {
     
  8.  
    super(gameFrame);
     
  9.  
    setImg("C:\\Users\\24465\\Desktop\\王者荣耀图片(1)\\王者荣耀图片\\minion\\blue.jpg");
     
  10.  
    setX(1325);
     
  11.  
    setY(3750);
     
  12.  
    }
     
  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 sxt;
     
  3.  
    import java.util.ArrayList;
     
  5.  
    public class MinionRed extends Minion {
     
  6.  
    public MinionRed(GameFrame gameFrame) {
     
  7.  
    super(gameFrame);
     
  8.  
    setImg("C:\\Users\\24465\\Desktop\\王者荣耀图片(1)\\王者荣耀图片\\minion\\red.jpg");
     
  9.  
    setX(5050);
     
  10.  
    setY(1125);
     
  11.  
    }
     
  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.  
    }
     
  45.  
    }
     
 

 

 

Turret
 

 

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

 

 

TurretBlue
 

 

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

TurretRed
 

 

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

beast
 

Bear
 

 

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

Beast
 

 

  1.  
    package beast;
     
  3.  
    import java.awt.Color;
     
  4.  
    import java.awt.Graphics;
     
  5.  
    import java.awt.Rectangle;
     
  6.  
    import java.util.ArrayList;
     
  8.  
    import sxt.*;
     
  10.  
    public class Beast extends GameObject {
     
  12.  
    public ArrayList<Beast> beastList = new ArrayList<>();
     
  13.  
    int width;
     
  14.  
    int height;
     
  15.  
    // 复活的元素
     
  16.  
    Beast beast = null;
     
  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 Xiyi(4585, 2365, gameFrame));
     
  24.  
    beastList.add(new BlueBuff(4025, 2295, gameFrame));
     
  25.  
    beastList.add(new Wolf(4235, 1945, gameFrame));
     
  26.  
    }
     
  28.  
    public Beast(int x, int y, GameFrame gameFrame) {
     
  29.  
    super(x, y, gameFrame);
     
  30.  
    setHp(1000);
     
  31.  
    setCurrentHp(getHp());
     
  32.  
    beast = this;
     
  33.  
    }
     
  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.  
    }
     
  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 Xiyi) {
     
  75.  
    reviveBeast = new Xiyi(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.  
    }
     
  86.  
    }
     
 

 

 

Bird
 

 

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

BlueBuff
 

 

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

RedBuff
 

 

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

Wolf
 

 

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

Xiyi
 

 

  1.  
    package beast;
     
  2.  
    import sxt.GameFrame;
     
  3.  
    public class extends Beast {
     
  5.  
    public Xiyi(int x, int y, GameFrame gameFrame) {
     
  6.  
    super(x, y, gameFrame);
     
  7.  
    setImg("C:\\Users\\24465\\Desktop\\王者荣耀图片(1)\\王者荣耀图片\\beast\\蜥蜴.jpg");
     
  8.  
    width = 111;
     
  9.  
    height = 65;
     
  10.  
    setDis(125);
     
  11.  
    }
     
  12.  
    }
     
 
 
相关推荐
 
 
王者荣耀--游戏代码
 
 
 
c一段旅程c 69 0 0
 
Java游戏 王者荣耀
 
 
 
天行五煞 62 0 0
 
王者荣耀游戏制作
 
 
 
生命中最美的是成长 58 0 0
 
Java小游戏 王者荣耀
 
 
 
Sophia的玲珑阁 61 0 0
 
java游戏制作-王者荣耀游戏
 
 
 
一叶轻舟okok 62 0 0
 
Java游戏制作——王者荣耀
 
 
 
E_topia 54 0 0
 
Java实现王者荣耀小游戏
 
 
 
覃榜言 48 0 0
 
java简易制作-王者荣耀游戏
 
 
 
路西法阁下 58 0 0
 
王者荣耀，，，，，
 
 
 
我是芄兰 64 0 0
 
Java制作“简易王者荣耀”小游戏
 
 
 
时光已翩然轻擦 61 0 0
 
 
精彩评论（0）
 
 
 0 0 举报