Justiciar.java

Go to the documentation of this file.

package com.runehive.game.world.entity.combat.strategy.npc.boss.magearena;
 
import com.runehive.game.Animation;
import com.runehive.game.Graphic;
import com.runehive.game.Projectile;
import com.runehive.game.UpdatePriority;
import com.runehive.game.task.impl.ForceMovementTask;
import com.runehive.game.world.World;
import com.runehive.game.world.entity.combat.CombatType;
import com.runehive.game.world.entity.combat.CombatUtil;
import com.runehive.game.world.entity.combat.attack.FightType;
import com.runehive.game.world.entity.combat.hit.CombatHit;
import com.runehive.game.world.entity.combat.hit.Hit;
import com.runehive.game.world.entity.combat.projectile.CombatProjectile;
import com.runehive.game.world.entity.combat.strategy.CombatStrategy;
import com.runehive.game.world.entity.combat.strategy.npc.MultiStrategy;
import com.runehive.game.world.entity.combat.strategy.npc.NpcMagicStrategy;
import com.runehive.game.world.entity.combat.strategy.npc.NpcMeleeStrategy;
import com.runehive.game.world.entity.combat.strategy.npc.NpcRangedStrategy;
import com.runehive.game.world.entity.mob.Direction;
import com.runehive.game.world.entity.mob.Mob;
import com.runehive.game.world.entity.mob.npc.Npc;
import com.runehive.game.world.entity.mob.player.ForceMovement;
import com.runehive.game.world.pathfinding.path.SimplePathChecker;
import com.runehive.game.world.position.Position;
import com.runehive.net.packet.out.SendMessage;
import com.runehive.util.RandomUtils;
import com.runehive.util.Utility;
 
import static com.runehive.game.world.entity.combat.CombatUtil.createStrategyArray;
import static com.runehive.game.world.entity.combat.CombatUtil.randomStrategy;
 
/**
 * Handles Justiciar Combat Strategy
 *
 * @author TJ#5762
 */
public class Justiciar extends MultiStrategy {
    private static Magic MAGIC = new Magic();
    private static Melee MELEE = new Melee();
    private static LightingRain LIGHTNING_RAIN = new LightingRain();
    private static TeleGrab TELE_GRAB = new TeleGrab();
 
    private static final CombatStrategy<Npc>[] FULL_STRATEGIES = createStrategyArray(NpcMeleeStrategy.get(), MAGIC,
            TELE_GRAB, LIGHTNING_RAIN);
    private static final CombatStrategy<Npc>[] MAGIC_STRATEGIES = createStrategyArray(MAGIC, MAGIC, MAGIC, TELE_GRAB,
            LIGHTNING_RAIN);
    private static final CombatStrategy<Npc>[] NON_MELEE = createStrategyArray(MAGIC, MELEE, MELEE, MAGIC, MAGIC,
            TELE_GRAB, LIGHTNING_RAIN);
 
    /** Constructs a new <code>Justiciar</code>. */
    public Justiciar() {
        currentStrategy = MAGIC;
        currentStrategy = MELEE;
    }
 
    @Override
    public boolean canAttack(Npc attacker, Mob defender) {
        if (!currentStrategy.withinDistance(attacker, defender)) {
            currentStrategy = randomStrategy(MAGIC_STRATEGIES);
            currentStrategy = randomStrategy(NON_MELEE);
        }
        return currentStrategy.canAttack(attacker, defender);
    }
 
    @Override
    public void block(Mob attacker, Npc defender, Hit hit, CombatType combatType) {
        currentStrategy.block(attacker, defender, hit, combatType);
        defender.getCombat().attack(attacker);
 
        if (!defender.getCombat().isAttacking()) {
            defender.animate(new Animation(7962, UpdatePriority.VERY_HIGH));
            defender.graphic(1196);
            defender.graphic(481);
            defender.speak("Night King, Lend me your powers for i am your faithful servant!");
 
            CombatUtil.areaAction(attacker, 64, 18, mob -> {
                if (RandomUtils.success(.65))
                    return;
 
                World.schedule(2, () -> {
                    Position destination = Utility.randomElement(defender.boundaries);
                    World.sendGraphic(new Graphic(481), destination);
                    attacker.move(destination);
 
                });
            });
        }
    }
 
    @Override
    public void finishOutgoing(Npc attacker, Mob defender) {
        currentStrategy.finishOutgoing(attacker, defender);
        if (NpcMeleeStrategy.get().withinDistance(attacker, defender)) {
            currentStrategy = randomStrategy(FULL_STRATEGIES);
        } else {
            currentStrategy = randomStrategy(MAGIC_STRATEGIES);
        }
    }
 
    @Override
    public int getAttackDelay(Npc attacker, Mob defender, FightType fightType) {
        return attacker.definition.getAttackDelay();
    }
 
    private static class Melee extends NpcRangedStrategy {
 
        public Melee() {
            super(CombatProjectile.getDefinition("EMPTY"));
        }
 
        @Override
        public void hit(Npc attacker, Mob defender, Hit hit) {
        }
 
        @Override
        public void attack(Npc attacker, Mob defender, Hit hit) {
        }
 
        @Override
        public void start(Npc attacker, Mob defender, Hit[] hits) {
 
            attacker.animate(new Animation(7962, UpdatePriority.VERY_HIGH));
            Projectile projectile = new Projectile(162, 50, 80, 85, 25);
            CombatHit hit = nextMeleeHit(attacker, defender, 21);
            defender.graphic(163);
            CombatUtil.areaAction(attacker, 64, 18, mob -> {
                projectile.send(attacker, defender);
                mob.damage(nextMagicHit(attacker, defender, 35));
            });
 
            /*
             * if (Utility.random(0, 8) == 1) { attacker.animate(new Animation(7965,
             * UpdatePriority.VERY_HIGH)); attacker.graphic(new Graphic(1296,
             * UpdatePriority.VERY_HIGH)); attacker.heal(50);
             * attacker.speak("Time To HEAL!"); System.out.println("It executes!");
             *
             * }
             */
 
        }
 
        @Override
        public CombatHit[] getHits(Npc attacker, Mob defender) {
            CombatHit hit = nextRangedHit(attacker, defender, 38);
            hit.setAccurate(false);
            return new CombatHit[] { hit };
        }
 
        @Override
        public int modifyAccuracy(Npc attacker, Mob defender, int roll) {
            return roll + 50_000;
        }
 
    }
 
    /** Jisticiar magic strategy. */
    private static class Magic extends NpcMagicStrategy {
        public Magic() {
            super(CombatProjectile.getDefinition("EMPTY"));
        }
 
        @Override
        public void hit(Npc attacker, Mob defender, Hit hit) {
        }
 
        @Override
        public void attack(Npc attacker, Mob defender, Hit hit) {
        }
 
        @Override
        public void start(Npc attacker, Mob defender, Hit[] hits) {
            Projectile projectile = new Projectile(393, 50, 80, 85, 25);
            attacker.animate(new Animation(7853, UpdatePriority.VERY_HIGH));
            CombatUtil.areaAction(attacker, 64, 18, mob -> {
                projectile.send(attacker, defender);
                defender.graphic(157);
                mob.damage(nextMagicHit(attacker, defender, 35));
 
            });
 
            if (Utility.random(0, 20) == 1) {
                attacker.animate(new Animation(7965, UpdatePriority.VERY_HIGH));
                attacker.graphic(new Graphic(1296, UpdatePriority.VERY_HIGH));
                attacker.heal(130);
                attacker.speak("Time To HEAL!");
 
            }
 
        }
 
        @Override
        public CombatHit[] getHits(Npc attacker, Mob defender) {
            CombatHit hit = nextMagicHit(attacker, defender, 38);
            hit.setAccurate(false);
            return new CombatHit[] { hit };
        }
 
        @Override
        public int modifyAccuracy(Npc attacker, Mob defender, int roll) {
            return roll + 50_000;
        }
    }
 
    private static class TeleGrab extends NpcMagicStrategy {
        TeleGrab() {
            super(CombatProjectile.getDefinition("EMPTY"));
        }
 
        @Override
        public void hit(Npc attacker, Mob defender, Hit hit) {
        }
 
        @Override
        public void attack(Npc attacker, Mob defender, Hit hit) {
        }
 
        @Override
        public void start(Npc attacker, Mob defender, Hit[] hits) {
 
            attacker.animate(new Animation(7964, UpdatePriority.VERY_HIGH));
            Projectile projectile = new Projectile(1479, 50, 80, 85, 25);
            projectile.send(attacker, defender);
            defender.damage(new Hit(Utility.random(20, 50)));
            attacker.speak("I AM A DECENDENT OF HELL!");
 
 
                }
 
 
 
        @Override
        public CombatHit[] getHits(Npc attacker, Mob defender) {
            CombatHit hit = nextMagicHit(attacker, defender, 38);
            hit.setAccurate(false);
            return new CombatHit[] { hit };
        }
    }
 
    private static class LightingRain extends NpcMagicStrategy {
        LightingRain() {
            super(CombatProjectile.getDefinition("Vorkath Frozen Special"));
        }
 
        @Override
        public void hit(Npc attacker, Mob defender, Hit hit) {
        }
 
        @Override
        public void attack(Npc attacker, Mob defender, Hit hit) {
        }
 
        @Override
        public void start(Npc attacker, Mob defender, Hit[] hits) {
            attacker.animate(new Animation(7962, UpdatePriority.VERY_HIGH));
            World.sendProjectile(attacker, defender, new Projectile(395, 46, 80, 43, 31));
            World.schedule(1, () -> {
                if (defender.isPlayer()) {
                    Position current = defender.getPosition();
                    Position best = Utility.findBestInside(defender, attacker);
                    int dx = current.getX() - best.getX();
                    int dy = current.getY() - best.getY();
                    int y = dy / (dx == 0 ? dy : dx);
 
                    Position destination = current.transform(dx, y);
                    if (SimplePathChecker.checkLine(defender, destination)) {
                    }
                    defender.damage(new Hit(Utility.random(1, 3)));
                    defender.interact(attacker);
 
                }
            });
        }
 
        @Override
        public CombatHit[] getHits(Npc attacker, Mob defender) {
            CombatHit hit = nextMagicHit(attacker, defender, 38);
            hit.setAccurate(false);
            return new CombatHit[] { hit };
        }
    }
}