예제 #1
0
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            var abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);
            var target        = targetManager.Target;

            if (!abilityHelper.CanBeCasted(this.blink) || this.Owner.Distance(target) < 400)
            {
                if (abilityHelper.UseAbility(this.ravage))
                {
                    return(true);
                }
            }

            if (abilityHelper.UseDoubleBlinkCombo(this.force, this.blink))
            {
                return(true);
            }

            if (abilityHelper.UseAbilityIfCondition(this.blink, this.ravage))
            {
                return(true);
            }

            if (!abilityHelper.CanBeCasted(this.ravage, false, false))
            {
                if (abilityHelper.UseAbility(this.blink, 400, 0))
                {
                    return(true);
                }

                if (abilityHelper.UseAbility(this.force, 400, 0))
                {
                    return(true);
                }
            }

            if (abilityHelper.UseAbility(this.shiva))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.bladeMail, 400))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.smash))
            {
                return(true);
            }

            if (abilityHelper.CanBeCasted(this.refresher) || abilityHelper.CanBeCasted(this.refresherShard))
            {
                if (abilityHelper.CanBeCasted(this.ravage, true, true, true, false) && !this.ravage.Ability.IsReady)
                {
                    var useRefresher = abilityHelper.CanBeCasted(this.refresherShard) ? this.refresherShard : this.refresher;

                    if (abilityHelper.HasMana(this.ravage, useRefresher))
                    {
                        if (abilityHelper.UseAbility(useRefresher))
                        {
                            return(true);
                        }
                    }
                }
            }

            if (abilityHelper.UseAbility(this.gush))
            {
                return(true);
            }

            return(false);
        }
예제 #2
0
        // Token: 0x0600076B RID: 1899 RVA: 0x00022A04 File Offset: 0x00020C04
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            AbilityHelper abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

            return(abilityHelper.UseAbility(this.blink, 700f, 450f) || abilityHelper.UseAbility(this.bind, true) || abilityHelper.UseAbility(this.hex, true) || abilityHelper.UseAbility(this.bloodthorn, true) || abilityHelper.UseAbility(this.orchid, true) || abilityHelper.UseAbility(this.nullifier, true) || abilityHelper.UseAbility(this.halberd, true) || abilityHelper.UseAbility(this.atos, true) || abilityHelper.UseAbility(this.veil, true) || abilityHelper.UseAbility(this.dagon, true) || abilityHelper.UseAbility(this.shiva, true) || abilityHelper.UseAbility(this.embrace, true) || abilityHelper.UseAbility(this.ethereal, true) || abilityHelper.UseAbility(this.ink, true) || abilityHelper.UseAbility(this.stroke, true));
        }
예제 #3
0
 // Token: 0x0600014C RID: 332 RVA: 0x00002ECC File Offset: 0x000010CC
 protected override bool MoveComboUseBuffs(AbilityHelper abilityHelper)
 {
     return(base.MoveComboUseBuffs(abilityHelper) || abilityHelper.UseMoveAbility(this.windrunMove));
 }
예제 #4
0
파일: Leshrac.cs 프로젝트: vana41203/O9K
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            var abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

            if (abilityHelper.UseAbility(this.blink, 550, 350))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.veil))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.shiva))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.ethereal))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.hex))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.atos))
            {
                return(true);
            }

            if (abilityHelper.UseAbilityIfAny(this.euls, this.splitEarth))
            {
                return(true);
            }

            if (abilityHelper.CanBeCasted(this.nova, false, false))
            {
                if (this.nova.AutoToggle(targetManager))
                {
                    return(true);
                }
            }

            if (abilityHelper.UseAbilityIfCondition(this.diabolic, this.splitEarth))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.lightning))
            {
                this.euls?.Sleeper.Sleep(0.5f);
                return(true);
            }

            if (abilityHelper.UseAbilityIfNone(this.splitEarth, this.lightning, this.euls, this.atos))
            {
                return(true);
            }

            return(false);
        }
예제 #5
0
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            var abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);
            var distance      = this.Owner.Distance(targetManager.Target);

            if (abilityHelper.CanBeCasted(this.duel, false, false) &&
                ((distance <= 1400 && abilityHelper.CanBeCasted(this.blink)) ||
                 distance < 500))
            {
                if (abilityHelper.CanBeCasted(this.attack, false))
                {
                    if (abilityHelper.ForceUseAbility(this.attack))
                    {
                        return(true);
                    }
                }

                if (abilityHelper.CanBeCasted(this.bladeMail, false))
                {
                    if (abilityHelper.ForceUseAbility(this.bladeMail))
                    {
                        return(true);
                    }
                }

                if (abilityHelper.CanBeCasted(this.bkb, false))
                {
                    if (abilityHelper.ForceUseAbility(this.bkb))
                    {
                        return(true);
                    }
                }

                if (abilityHelper.CanBeCasted(this.mjollnir, false))
                {
                    if (abilityHelper.ForceUseAbility(this.mjollnir))
                    {
                        return(true);
                    }
                }

                if (abilityHelper.CanBeCasted(this.armlet, false))
                {
                    if (abilityHelper.ForceUseAbility(this.armlet))
                    {
                        return(true);
                    }
                }

                if (!abilityHelper.CanBeCasted(this.duel) && abilityHelper.CanBeCasted(this.blink, false))
                {
                    if (abilityHelper.ForceUseAbility(this.blink))
                    {
                        return(true);
                    }
                }
            }

            if (abilityHelper.UseAbility(this.abyssal))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.orchid))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.bloodthorn))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.nullifier))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.halberd))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.bkb, 500))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.bladeMail, 500))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.mjollnir, 400))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.medallion))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.solar))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.attack, 400))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.armlet, 300))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.duel))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.blink, 300, 0))
            {
                return(true);
            }

            if (abilityHelper.CanBeCasted(this.odds) && !abilityHelper.CanBeCasted(this.duel) &&
                !abilityHelper.CanBeCasted(this.blink) &&
                this.blink?.Sleeper.IsSleeping != true)
            {
                if (abilityHelper.UseAbility(this.odds))
                {
                    return(true);
                }
            }

            if (abilityHelper.UseAbility(this.phase))
            {
                return(true);
            }

            return(false);
        }
        // Token: 0x060001F1 RID: 497 RVA: 0x0000E9A4 File Offset: 0x0000CBA4
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            AbilityHelper abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

            return(abilityHelper.UseAbility(this.missile, true) || abilityHelper.UseAbility(this.swap, true) || abilityHelper.UseAbility(this.vessel, true) || abilityHelper.UseAbility(this.urn, true) || abilityHelper.UseAbility(this.wave, true) || abilityHelper.UseAbility(this.solar, true) || abilityHelper.UseAbility(this.medallion, true) || abilityHelper.UseAbility(this.force, 550f, 400f) || abilityHelper.UseAbility(this.pike, 550f, 400f));
        }
예제 #7
0
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            var abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

            if (this.Owner.HasModifier("modifier_void_spirit_dissimilate_phase"))
            {
                this.ComboSleeper.Sleep(0.1f);
                this.OrbwalkSleeper.Sleep(0.1f);
                return(this.Owner.Move(targetManager.Target.Position));
            }

            if (abilityHelper.UseAbility(this.hex))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.nullifier))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.bloodthorn))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.orchid))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.veil))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.dagon))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.bkb, 500))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.mjollnir, 500))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.vessel))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.urn))
            {
                return(true);
            }

            if (abilityHelper.CanBeCasted(this.remnant) && targetManager.Target.GetImmobilityDuration() <= 0)
            {
                if (abilityHelper.CanBeCasted(this.eul, false, false))
                {
                    if (abilityHelper.UseAbility(this.eul) || (this.forceEul && abilityHelper.ForceUseAbility(this.eul)))
                    {
                        this.forceRemnant.Sleep(0.5f);
                        this.forceEul.Reset();
                        return(true);
                    }
                }
            }

            if (this.forceRemnant && abilityHelper.CanBeCasted(this.remnant, true, false) &&
                abilityHelper.ForceUseAbility(this.remnant, true))
            {
                this.forceRemnant.Reset();
                return(true);
            }

            if (this.Owner.Distance(targetManager.Target) > 300)
            {
                if (abilityHelper.UseAbility(this.step))
                {
                    this.forceEul.Sleep(0.5f);
                    return(true);
                }
            }

            if (!abilityHelper.CanBeCasted(this.step, false) || this.Owner.Distance(targetManager.Target) < 500 ||
                !targetManager.Target.CanMove())
            {
                if (abilityHelper.UseAbility(this.remnant))
                {
                    return(true);
                }
            }

            if (abilityHelper.UseAbility(this.dissimilate))
            {
                return(true);
            }

            if (abilityHelper.UseAbilityIfNone(this.shiva, this.dissimilate))
            {
                return(true);
            }

            if (!this.Owner.HasAghanimsScepter || !targetManager.Target.IsSilenced)
            {
                if (abilityHelper.UseAbility(this.pulse))
                {
                    this.pulse.Sleeper.ExtendSleep(0.2f);
                    return(true);
                }
            }

            if (abilityHelper.UseAbility(this.phase))
            {
                return(true);
            }

            return(false);
        }
예제 #8
0
파일: Mars.cs 프로젝트: vana41203/O9K
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            var abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

            if (abilityHelper.UseAbility(this.bkb, 400))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.hex))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.abyssal))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.bloodthorn))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.orchid))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.nullifier))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.halberd))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.solar))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.medallion))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.blink, 400, 0))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.armlet, 400))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.arena))
            {
                return(true);
            }

            if (this.arena?.Sleeper.IsSleeping == true || targetManager.Target.HasModifier("modifier_mars_arena_of_blood_leash"))
            {
                if (abilityHelper.UseAbility(this.rebuke))
                {
                    return(true);
                }

                if (abilityHelper.UseAbility(this.spear))
                {
                    return(true);
                }
            }
            else
            {
                if (abilityHelper.UseAbility(this.spear))
                {
                    return(true);
                }

                if (abilityHelper.UseAbility(this.rebuke))
                {
                    return(true);
                }
            }

            if (abilityHelper.UseAbility(this.bladeMail, 400))
            {
                return(true);
            }

            return(false);
        }
예제 #9
0
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            var abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

            if (this.blast?.Release(targetManager, this.ComboSleeper) == true)
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.hex))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.veil))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.coldFeet))
            {
                this.ComboSleeper.ExtendSleep(0.3f);
                return(true);
            }

            if (abilityHelper.UseAbility(this.vortex))
            {
                return(true);
            }

            var coldFeedModifier = targetManager.Target.GetModifier("modifier_cold_feet");

            if (coldFeedModifier?.ElapsedTime < 1)
            {
                if (abilityHelper.UseAbility(this.eul))
                {
                    this.ComboSleeper.ExtendSleep(0.5f);
                    return(true);
                }
            }

            if (abilityHelper.UseAbility(this.touch))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.atos))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.gungir))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.vessel))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.urn))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.blast))
            {
                return(true);
            }

            return(true);
        }
예제 #10
0
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            var abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

            if (abilityHelper.UseAbility(this.hex))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.abyssal))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.orchid))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.bloodthorn))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.blink, 400, 0))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.nullifier))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.diffusal))
            {
                this.pounce?.Sleeper.Sleep(0.3f);
                return(true);
            }

            if (abilityHelper.UseAbility(this.pounce))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.medallion))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.solar))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.silver))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.shadow))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.pact))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.dance))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.phase))
            {
                return(true);
            }

            return(false);
        }
예제 #11
0
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            var abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

            if (this.spring.CancelChanneling(targetManager))
            {
                this.ComboSleeper.Sleep(0.1f);
                return(true);
            }

            if (abilityHelper.UseAbility(this.abyssal))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.diffusal))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.spring))
            {
                return(true);
            }

            if (abilityHelper.CanBeCastedHidden(this.spring))
            {
                if (abilityHelper.UseAbility(this.treeDance))
                {
                    return(true);
                }
            }

            var target = targetManager.Target;

            if (!target.IsRooted && !target.IsStunned && !target.IsHexed)
            {
                if (abilityHelper.UseAbility(this.treeDance, 500, 0))
                {
                    return(true);
                }
            }

            var distance = this.Owner.Distance(target);

            if (this.Owner.HasModifier("modifier_monkey_king_quadruple_tap_bonuses") ||
                (distance > 600 || (distance > this.Owner.GetAttackRange(target) && target.Speed > this.Owner.Speed &&
                                    target.GetImmobilityDuration() <= 0)))
            {
                if (abilityHelper.UseAbility(this.strike))
                {
                    return(true);
                }
            }

            if (abilityHelper.UseAbility(this.command))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.phase))
            {
                return(true);
            }

            return(false);
        }
예제 #12
0
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            var abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

            if (abilityHelper.UseAbility(this.abyssal))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.hex))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.bloodthorn))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.orchid))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.nullifier))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.diffusal))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.shadowStep))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.haunt))
            {
                return(true);
            }

            if (this.haunt?.Ability.TimeSinceCasted < 10 || this.shadowStep?.Ability.TimeSinceCasted < 10)
            {
                if (abilityHelper.UseAbility(this.reality))
                {
                    return(true);
                }
            }

            if (abilityHelper.UseAbility(this.bkb))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.dagger))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.manta, this.Owner.GetAttackRange()))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.vessel))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.urn))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.phase))
            {
                return(true);
            }

            return(false);
        }
예제 #13
0
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            var abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);
            var target        = targetManager.Target;

            if (abilityHelper.UseAbility(this.hex))
            {
                return(true);
            }

            if (abilityHelper.CanBeCasted(this.vortex) && (target.CanBecomeMagicImmune || target.CanBecomeInvisible))
            {
                if (abilityHelper.UseAbility(this.vortex))
                {
                    return(true);
                }
            }

            if (abilityHelper.UseAbility(this.bloodthorn))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.orchid))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.nullifier))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.dagon))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.shiva))
            {
                return(true);
            }

            var overloaded = this.Owner.CanAttack(target, 25) && this.Owner.HasModifier("modifier_storm_spirit_overload");
            var projectile = ObjectManager.TrackingProjectiles.FirstOrDefault(
                x => x.Source?.Handle == this.Handle && x.Target?.Handle == target.Handle && x.IsAutoAttackProjectile());

            if (overloaded)
            {
                if (projectile == null)
                {
                    return(false);
                }

                var distance = target.IsMoving && target.GetAngle(projectile.Position) > 1.5f ? 250 : 350;
                if (projectile.Position.Distance2D(projectile.TargetPosition) > distance)
                {
                    return(false);
                }
            }
            else
            {
                if (projectile != null)
                {
                    var overload = this.Owner.Abilities.FirstOrDefault(x => x.Id == AbilityId.storm_spirit_overload);
                    if (overload != null)
                    {
                        var attackDamage   = this.Owner.GetAttackDamage(target);
                        var overloadDamage = overload.GetDamage(target);
                        var health         = target.Health;

                        if (attackDamage < health && attackDamage + overloadDamage > health)
                        {
                            if (abilityHelper.CanBeCasted(this.remnant, false, false) && abilityHelper.ForceUseAbility(this.remnant, true))
                            {
                                return(true);
                            }

                            if (abilityHelper.CanBeCasted(this.ball, false, false))
                            {
                                var distance = projectile.Position.Distance2D(projectile.TargetPosition);
                                var time     = distance / projectile.Speed;

                                if (time > this.ball.Ability.CastPoint && abilityHelper.ForceUseAbility(this.ball, true))
                                {
                                    return(true);
                                }
                            }
                        }
                    }
                }
            }

            if (abilityHelper.UseAbility(this.vortex))
            {
                this.ComboSleeper.ExtendSleep(0.1f);
                this.remnant?.Sleeper.Sleep(1f);
                this.ball?.Sleeper.Sleep(1f);
                return(true);
            }

            if (abilityHelper.UseAbility(this.remnant))
            {
                this.ComboSleeper.ExtendSleep(0.1f);
                this.ball?.Sleeper.Sleep(1f);
                return(true);
            }

            if (abilityHelper.UseAbilityIfCondition(this.ball, this.remnant, this.vortex))
            {
                this.ComboSleeper.ExtendSleep(0.3f);
                return(true);
            }

            return(false);
        }
예제 #14
0
 // Token: 0x060004F9 RID: 1273 RVA: 0x0000494D File Offset: 0x00002B4D
 protected override bool MoveComboUseBlinks(AbilityHelper abilityHelper)
 {
     return(base.MoveComboUseBlinks(abilityHelper) || abilityHelper.UseMoveAbility(this.treeDance));
 }
예제 #15
0
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            var abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

            if (this.drain?.Ability.IsChanneling == true)
            {
                if (this.dagon?.Ability.CanBeCasted(false) == true && this.dagon.Ability.CanHit(targetManager.Target) &&
                    this.dagon.Ability.GetDamage(targetManager.Target)
                    > targetManager.Target.Health)
                {
                    this.Owner.Stop();
                    this.ComboSleeper.Sleep(0.1f);
                    return(true);
                }
            }

            if (abilityHelper.UseAbility(this.blink, 700, 350))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.veil))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.hex))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.bloodthorn))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.orchid))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.nullifier))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.atos))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.gungir))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.decrepify))
            {
                this.ComboSleeper.ExtendSleep(0.1f);
                return(true);
            }

            if (abilityHelper.UseAbility(this.dagon))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.blast))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.dagon))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.ward))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.drain))
            {
                return(true);
            }

            return(false);
        }
예제 #16
0
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            var abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);
            var target        = targetManager.Target;

            if (abilityHelper.UseAbility(this.bloodthorn))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.orchid))
            {
                return(true);
            }

            if (!abilityHelper.CanBeCasted(this.blink) || this.Owner.Distance(target) < 400)
            {
                if (abilityHelper.UseAbility(this.nova))
                {
                    return(true);
                }
            }

            if (abilityHelper.UseAbility(this.shiva))
            {
                return(true);
            }

            if (abilityHelper.UseAbilityIfCondition(this.blink, this.nova))
            {
                return(true);
            }

            if (!abilityHelper.CanBeCasted(this.nova, false, false))
            {
                if (abilityHelper.UseAbility(this.blink, 500, 300))
                {
                    return(true);
                }

                if (abilityHelper.UseAbility(this.force, 500, 300))
                {
                    return(true);
                }
            }

            if (abilityHelper.UseAbility(this.veil))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.gale))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.ward))
            {
                return(true);
            }

            return(false);
        }
예제 #17
0
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            var abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

            if (abilityHelper.UseAbility(this.hex))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.orchid))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.bloodthorn))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.nullifier))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.veil))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.chains))
            {
                return(true);
            }

            if (abilityHelper.CanBeCasted(this.blink, false) && abilityHelper.CanBeCasted(this.chains, false) &&
                abilityHelper.CanBeCasted(this.fist, false))
            {
                var fistRange = this.fist.Ability.Range;
                var range     = this.blink.Ability.Range + fistRange;
                var target    = targetManager.Target;
                var distance  = this.Owner.Distance(target);

                if (range > distance && distance > fistRange)
                {
                    if (abilityHelper.UseAbility(this.blink, target.Position))
                    {
                        return(true);
                    }
                }
            }

            if (!this.Owner.IsInvulnerable && abilityHelper.UseAbility(this.blink, 700, 0))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.fist))
            {
                return(true);
            }

            if (abilityHelper.CanBeCasted(this.remnantActivate, false))
            {
                if (!this.remnant.Sleeper.IsSleeping)
                {
                    if (abilityHelper.ForceUseAbility(this.remnantActivate, true))
                    {
                        return(true);
                    }
                }

                //if (abilityHelper.UseAbility(this.remnantActivate))
                //{
                //    return true;
                //}
            }

            if (abilityHelper.CanBeCasted(this.remnant) && abilityHelper.HasMana(this.remnantActivate) && !this.Owner.IsInvulnerable)
            {
                var target   = targetManager.Target;
                var distance = target.Distance(this.Owner);

                if (target.GetImmobilityDuration() > 0.8 || distance < 400)
                {
                    var damage = this.remnant.GetDamage(targetManager);
                    if (damage + 100 > target.Health)
                    {
                        for (var i = 0; i < this.remnant.GetRequiredRemnants(targetManager); i++)
                        {
                            abilityHelper.ForceUseAbility(this.remnant);
                        }

                        this.ComboSleeper.Sleep((this.Owner.Distance(target) / this.remnant.Ability.Speed) * 0.6f);
                        return(true);
                    }
                }

                if (distance > 350 && abilityHelper.UseAbility(this.remnant))
                {
                    return(true);
                }
            }

            if (abilityHelper.UseAbility(this.shiva))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.shield, 400))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.mjollnir, 600))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.bladeMail, 500))
            {
                return(true);
            }

            return(false);
        }
예제 #18
0
        // Token: 0x06000741 RID: 1857 RVA: 0x000221D0 File Offset: 0x000203D0
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            AbilityHelper abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

            return(abilityHelper.UseAbility(this.abyssal, true) || abilityHelper.UseAbility(this.orchid, true) || abilityHelper.UseAbility(this.bloodthorn, true) || abilityHelper.UseAbility(this.nullifier, true) || abilityHelper.UseAbility(this.diffusal, true) || abilityHelper.UseAbility(this.omni, true) || abilityHelper.UseAbility(this.blink, 400f, 0f) || abilityHelper.UseAbility(this.ward, true) || abilityHelper.UseAbility(this.bladeFury, true) || abilityHelper.UseAbility(this.manta, base.Owner.GetAttackRange(null, 0f)) || abilityHelper.UseAbility(this.mjollnir, 600f) || abilityHelper.UseAbility(this.phase, true));
        }
 // Token: 0x060001F2 RID: 498 RVA: 0x000035A4 File Offset: 0x000017A4
 protected override bool MoveComboUseDisables(AbilityHelper abilityHelper)
 {
     return(base.MoveComboUseDisables(abilityHelper) || abilityHelper.UseMoveAbility(this.missile));
 }
예제 #20
0
 // Token: 0x06000743 RID: 1859 RVA: 0x00005B35 File Offset: 0x00003D35
 protected override bool MoveComboUseShields(AbilityHelper abilityHelper)
 {
     return(base.MoveComboUseShields(abilityHelper) || abilityHelper.UseMoveAbility(this.bladeFuryShield));
 }
예제 #21
0
        // Token: 0x06000529 RID: 1321 RVA: 0x0001AA58 File Offset: 0x00018C58
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            AbilityHelper abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

            if (abilityHelper.UseAbility(this.bkb, 400f))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.abyssal, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.bloodthorn, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.orchid, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.nullifier, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.halberd, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.blink, 400f, 0f))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.armlet, 400f))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.arena, true))
            {
                base.ComboSleeper.ExtendSleep(0.1f);
                return(true);
            }
            if (targetManager.Target.HasModifier("modifier_mars_arena_of_blood_leash"))
            {
                if (abilityHelper.UseAbility(this.rebuke, true))
                {
                    return(true);
                }
                if (abilityHelper.UseAbility(this.spear, true))
                {
                    return(true);
                }
            }
            else
            {
                if (abilityHelper.UseAbility(this.spear, true))
                {
                    return(true);
                }
                if (abilityHelper.UseAbility(this.rebuke, true))
                {
                    return(true);
                }
            }
            return(abilityHelper.UseAbility(this.bladeMail, 400f));
        }
예제 #22
0
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            var abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

            if (this.tricks?.CancelChanneling(targetManager) == true)
            {
                this.ComboSleeper.Sleep(0.1f);
                return(true);
            }

            if (abilityHelper.UseAbility(this.atos))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.gungir))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.blinkStrike))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.abyssal))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.nullifier))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.bloodthorn))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.orchid))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.diffusal))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.solar))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.medallion))
            {
                return(true);
            }

            if (!abilityHelper.CanBeCasted(this.blinkStrike))
            {
                if (abilityHelper.UseAbility(this.blink, 500, 0))
                {
                    return(true);
                }
            }

            if (abilityHelper.UseAbilityIfNone(this.smoke, this.blinkStrike))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.tricks))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.phase))
            {
                return(true);
            }

            return(false);
        }
예제 #23
0
        // Token: 0x06000634 RID: 1588 RVA: 0x0001E5C4 File Offset: 0x0001C7C4
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            AbilityHelper abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

            if (abilityHelper.CanBeCasted(this.blackHole, true, true, true, true))
            {
                if (abilityHelper.CanBeCasted(this.bkb, false, false, true, true) && abilityHelper.ForceUseAbility(this.bkb, false, true))
                {
                    return(true);
                }
                if (abilityHelper.HasMana(new UsableAbility[]
                {
                    this.pulse,
                    this.blackHole
                }) && abilityHelper.UseAbility(this.pulse, true))
                {
                    return(true);
                }
                if (abilityHelper.HasMana(new UsableAbility[]
                {
                    this.shiva,
                    this.blackHole
                }) && abilityHelper.UseAbility(this.shiva, true))
                {
                    return(true);
                }
                if (abilityHelper.UseAbility(this.blackHole, true))
                {
                    return(true);
                }
            }
            if (abilityHelper.CanBeCastedIfCondition(this.blink, new UsableAbility[]
            {
                this.blackHole
            }))
            {
                if (abilityHelper.CanBeCasted(this.bkb, false, false, true, true) && abilityHelper.ForceUseAbility(this.bkb, false, true))
                {
                    return(true);
                }
                if (abilityHelper.CanBeCasted(this.ghost, false, false, true, true) && abilityHelper.ForceUseAbility(this.ghost, false, true))
                {
                    return(true);
                }
            }
            if (abilityHelper.UseAbilityIfCondition(this.blink, new UsableAbility[]
            {
                this.blackHole
            }))
            {
                return(true);
            }
            if ((abilityHelper.CanBeCasted(this.refresher, true, true, true, true) || abilityHelper.CanBeCasted(this.refresherShard, true, true, true, true)) && abilityHelper.CanBeCasted(this.blackHole, true, true, true, false) && !this.blackHole.Ability.IsReady)
            {
                UntargetableAbility untargetableAbility = abilityHelper.CanBeCasted(this.refresherShard, true, true, true, true) ? this.refresherShard : this.refresher;
                if (abilityHelper.HasMana(new UsableAbility[]
                {
                    this.blackHole,
                    untargetableAbility
                }) && abilityHelper.UseAbility(untargetableAbility, true))
                {
                    return(true);
                }
            }
            return(abilityHelper.UseAbility(this.malefice, true));
        }
예제 #24
0
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            var abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

            if (abilityHelper.UseAbility(this.bloodthorn))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.orchid))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.armlet, 600))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.bkb, 600))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.bolt))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.rift))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.blink, 500, 0))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.halberd))
            {
                return(true);
            }

            if (abilityHelper.CanBeCasted(this.phantasm))
            {
                if (abilityHelper.UseAbility(this.armlet))
                {
                    this.ComboSleeper.ExtendSleep(0.5f);
                    return(true);
                }

                if (abilityHelper.UseAbility(this.phantasm))
                {
                    return(true);
                }
            }

            if (abilityHelper.UseAbility(this.manta, 600))
            {
                return(true);
            }

            return(false);
        }
예제 #25
0
        protected override bool MoveComboUseBlinks(AbilityHelper abilityHelper)
        {
            if (this.moveSleeper || this.Owner.HasModifier("modifier_phantom_lancer_phantom_edge_boost"))
            {
                return(false);
            }

            if (base.MoveComboUseBlinks(abilityHelper))
            {
                return(true);
            }

            var rush = (ToggleAbility)this.Owner.Abilities.FirstOrDefault(x => x.Id == AbilityId.phantom_lancer_phantom_edge);

            if (rush?.Enabled == false && rush.CanBeCasted())
            {
                var mousePosition = GameManager.MousePosition;
                var range         = rush.Range;
                var target        = EntityManager9.Units
                                    .Where(
                    x => x.IsUnit && x.IsVisible && x.IsAlive && !x.IsAlly(this.Owner) && !x.IsInvulnerable && !x.IsAttackImmune &&
                    x.Distance(this.Owner) < range)
                                    .OrderBy(x => x.DistanceSquared(mousePosition))
                                    .FirstOrDefault(x => x.Distance(mousePosition) < 700 && x.Distance(this.Owner) > 500);

                if (target != null && target.Distance(mousePosition) < this.Owner.Distance(mousePosition))
                {
                    if (this.Owner.Attack(target))
                    {
                        this.moveSleeper.Sleep(0.3f);
                        this.OrbwalkSleeper.Sleep(0.3f);
                        return(true);
                    }

                    return(false);
                }
            }

            if (abilityHelper.UseMoveAbility(this.doppelBlink))
            {
                return(true);
            }

            if (this.Owner.IsAttacking)
            {
                this.OrbwalkSleeper.Reset();
                this.MoveSleeper.Reset();
                return(true);
            }

            //if (this.moveIllusion?.IsValid != true)
            //{
            //    this.moveIllusion = EntityManager9.Units.Where(x => x.IsIllusion && x.IsAlly(Owner) && x.IsMyControllable && x.IsAlive)
            //        .OrderBy(x => x.DistanceSquared(Owner.Position))
            //        .FirstOrDefault();

            //    if (this.moveIllusion != null)
            //    {
            //        this.moveIllusion.Move(Vector3.Zero);
            //        return true;
            //    }
            //}

            return(false);
        }
예제 #26
0
        public bool KickToAllyCombo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            var abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

            if (this.Owner.HasModifier("modifier_tusk_snowball_movement"))
            {
                var ally = EntityManager9.Heroes.FirstOrDefault(
                    x => !x.Equals(this.Owner) && x.IsAlly(this.Owner) && x.IsAlive && !x.IsInvulnerable && x.Distance(this.Owner) < 200);

                if (ally != null)
                {
                    if (this.Owner.Attack(ally))
                    {
                        this.ComboSleeper.Sleep(0.1f);
                        return(true);
                    }
                }
            }

            if (abilityHelper.UseAbility(this.punch))
            {
                return(true);
            }

            if (abilityHelper.UseAbilityIfCondition(this.kick))
            {
                return(true);
            }

            if (targetManager.Target.HasModifier("modifier_tusk_walrus_kick_slow"))
            {
                if (abilityHelper.UseAbilityIfNone(this.snowball))
                {
                    return(true);
                }
            }

            if (!this.Owner.IsInvulnerable)
            {
                if (abilityHelper.UseAbilityIfNone(this.shards, this.snowball, this.punch, this.kick))
                {
                    return(true);
                }

                if (abilityHelper.UseAbilityIfNone(this.tag, this.snowball, this.punch, this.kick))
                {
                    return(true);
                }
            }

            if (abilityHelper.CanBeCasted(this.blink) && abilityHelper.CanBeCasted(this.kick, false) &&
                !abilityHelper.CanBeCasted(this.kick))
            {
                var position = targetManager.Target.Position.Extend2D(EntityManager9.EnemyFountain, 100);
                if (this.Owner.Distance(position) > this.blink.Ability.Range)
                {
                    return(false);
                }

                if (abilityHelper.UseAbility(this.blink, position))
                {
                    return(true);
                }
            }

            return(false);
        }
예제 #27
0
        // Token: 0x06000453 RID: 1107 RVA: 0x000176F0 File Offset: 0x000158F0
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            AbilityHelper abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

            if (abilityHelper.UseAbilityIfCondition(this.dive, new UsableAbility[]
            {
                this.nova
            }))
            {
                if (abilityHelper.CanBeCasted(this.shiva, false, true, true, true))
                {
                    this.shiva.ForceUseAbility(targetManager, base.ComboSleeper);
                }
                return(true);
            }
            if (!comboModeMenu.IsHarassCombo && this.dive.AutoStop(targetManager))
            {
                base.ComboSleeper.Sleep(0.1f);
                return(true);
            }
            if (abilityHelper.UseAbility(this.veil, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.hex, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.halberd, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.atos, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.urn, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.vessel, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.spirits, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.shiva, true))
            {
                return(true);
            }
            if (abilityHelper.CanBeCasted(this.nova, false, true, true, true) && (this.dive.IsFlying || base.Owner.Distance(targetManager.Target) < 600f))
            {
                Modifier     modifier = base.Owner.GetModifier("modifier_phoenix_fire_spirit_count");
                int          val      = (modifier != null) ? modifier.StackCount : 0;
                List <Unit9> list     = (from x in targetManager.EnemyHeroes
                                         where x.Distance(base.Owner) < this.spirits.Ability.CastRange
                                         select x).ToList <Unit9>();
                int num = Math.Min(val, list.Count);
                for (int i = 0; i < num; i++)
                {
                    this.spirits.Ability.UseAbility(list[i], 1, i != 0, false);
                }
                if (num > 0)
                {
                    base.ComboSleeper.Sleep(0.2f);
                    return(true);
                }
                if ((base.Owner.Distance(targetManager.Target) < 600f || (this.dive.CastPosition != Vector3.Zero && base.Owner.Distance(this.dive.CastPosition) < this.nova.Ability.CastRange)) && abilityHelper.UseAbility(this.nova, true))
                {
                    return(true);
                }
            }
            return(!this.dive.IsFlying && (!abilityHelper.CanBeCasted(this.spirits, true, true, true, true) || base.Owner.HasModifier("modifier_phoenix_fire_spirit_count")) && comboModeMenu.IsAbilityEnabled(this.ray.Ability) && this.ray.AutoControl(targetManager, base.ComboSleeper, 0.6f));
        }
예제 #28
0
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            if (comboModeMenu.SimplifiedName == "kicktoallycombo")
            {
                return(this.KickToAllyCombo(targetManager, comboModeMenu));
            }

            var abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

            if (abilityHelper.UseAbility(this.bloodthorn))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.orchid))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.blink))
            {
                this.ComboSleeper.ExtendSleep(0.2f);
                return(true);
            }

            if (abilityHelper.UseAbility(this.solar))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.medallion))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.tag))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.punch))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.snowball))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.shards))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.vessel))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.urn))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.bladeMail, 400))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.kick))
            {
                return(true);
            }

            return(false);
        }
예제 #29
0
 // Token: 0x0600014D RID: 333 RVA: 0x00002EEA File Offset: 0x000010EA
 protected override bool MoveComboUseDisables(AbilityHelper abilityHelper)
 {
     return(base.MoveComboUseDisables(abilityHelper) || abilityHelper.UseAbility(this.shackleshot, true));
 }
예제 #30
0
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            var abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

            if (abilityHelper.UseAbility(this.bkb, 600))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.hex))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.bloodthorn))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.orchid))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.nullifier))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.veil))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.shiva))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.scream))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.mjollnir, 500))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.shadowStrike))
            {
                return(true);
            }

            var target = targetManager.Target;

            if (abilityHelper.CanBeCasted(this.shadowStrike) || abilityHelper.CanBeCasted(this.scream) ||
                abilityHelper.CanBeCasted(this.sonic) || this.Owner.Distance(target)
                > this.Owner.GetAttackRange(target))
            {
                if (abilityHelper.UseAbility(this.blink))
                {
                    return(true);
                }
            }

            if (abilityHelper.UseAbility(this.sonic))
            {
                return(true);
            }

            return(false);
        }