コード例 #1
0
        protected override bool MoveComboUseDisables(AbilityHelper abilityHelper)
        {
            if (abilityHelper.CanBeCasted(this.smash))
            {
                if (abilityHelper.UseAbility(this.smash))
                {
                    return(true);
                }

                if (abilityHelper.CanBeCasted(this.stone, false))
                {
                    if (this.stone.UseAbility(abilityHelper.TargetManager, this.ComboSleeper, this.smash))
                    {
                        return(true);
                    }
                }
                else
                {
                    if (abilityHelper.ForceUseAbility(this.smash, true))
                    {
                        return(true);
                    }
                }
            }

            return(false);
        }
コード例 #2
0
        // Token: 0x06000214 RID: 532 RVA: 0x0000F174 File Offset: 0x0000D374
        public bool KickToAllyCombo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            AbilityHelper abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

            if (base.Owner.HasModifier("modifier_tusk_snowball_movement"))
            {
                Hero9 hero = EntityManager9.Heroes.FirstOrDefault((Hero9 x) => !x.Equals(base.Owner) && x.IsAlly(base.Owner) && x.IsAlive && !x.IsInvulnerable && x.Distance(base.Owner) < 200f);
                if (hero != null && base.Owner.Attack(hero))
                {
                    base.ComboSleeper.Sleep(0.1f);
                    return(true);
                }
            }
            if (abilityHelper.UseAbility(this.punch, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbilityIfCondition(this.kick, new UsableAbility[0]))
            {
                return(true);
            }
            if (targetManager.Target.HasModifier("modifier_tusk_walrus_kick_slow") && abilityHelper.UseAbilityIfNone(this.snowball, new UsableAbility[0]))
            {
                return(true);
            }
            if (!base.Owner.IsInvulnerable)
            {
                if (abilityHelper.UseAbilityIfNone(this.shards, new UsableAbility[]
                {
                    this.snowball,
                    this.punch,
                    this.kick
                }))
                {
                    return(true);
                }
                if (abilityHelper.UseAbilityIfNone(this.tag, new UsableAbility[]
                {
                    this.snowball,
                    this.punch,
                    this.kick
                }))
                {
                    return(true);
                }
            }
            if (abilityHelper.CanBeCasted(this.blink, true, true, true, true) && abilityHelper.CanBeCasted(this.kick, false, true, true, true) && !abilityHelper.CanBeCasted(this.kick, true, true, true, true))
            {
                Vector3 vector = Vector3Extensions.Extend2D(targetManager.Target.Position, EntityManager9.EnemyFountain, 100f);
                if (base.Owner.Distance(vector) > this.blink.Ability.Range)
                {
                    return(false);
                }
                if (abilityHelper.UseAbility(this.blink, vector))
                {
                    return(true);
                }
            }
            return(false);
        }
コード例 #3
0
ファイル: Warlock.cs プロジェクト: vana41203/O9K
        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.atos))
            {
                return(true);
            }

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

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

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

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

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

                    if (abilityHelper.HasMana(this.chaos, useRefresher))
                    {
                        if (abilityHelper.UseAbility(useRefresher))
                        {
                            this.ComboSleeper.ExtendSleep(0.2f);
                            this.upheaval?.Sleeper.Sleep(0.5f);
                            return(true);
                        }
                    }
                }
            }

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

            return(false);
        }
コード例 #4
0
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            var abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

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

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

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

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

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

            if (abilityHelper.UseAbilityIfNone(this.stomp, this.euls))
            {
                return(true);
            }

            if (abilityHelper.CanBeCasted(this.hammer, false, false))
            {
                var target             = targetManager.Target;
                var immobilityDuration = target.GetImmobilityDuration();

                if (immobilityDuration > this.hammer.Ability.GetHitTime(target) - 0.5f)
                {
                    if (abilityHelper.UseAbility(this.hammer))
                    {
                        return(true);
                    }
                }
            }

            if (!abilityHelper.CanBeCasted(this.euls) && !abilityHelper.CanBeCasted(this.stomp, false, false))
            {
                if (abilityHelper.UseAbilityIfNone(this.splitter))
                {
                    return(true);
                }
            }

            return(false);
        }
コード例 #5
0
        // Token: 0x060002AD RID: 685 RVA: 0x00011088 File Offset: 0x0000F288
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            AbilityHelper abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);
            Unit9         target        = targetManager.Target;

            if ((!abilityHelper.CanBeCasted(this.blink, true, true, true, true) || base.Owner.Distance(target) < 400f) && abilityHelper.UseAbility(this.ravage, true))
            {
                return(true);
            }
            if (abilityHelper.UseDoubleBlinkCombo(this.force, this.blink, 0f))
            {
                return(true);
            }
            if (abilityHelper.UseAbilityIfCondition(this.blink, new UsableAbility[]
            {
                this.ravage
            }))
            {
                return(true);
            }
            if (!abilityHelper.CanBeCasted(this.ravage, false, false, true, true))
            {
                if (abilityHelper.UseAbility(this.blink, 400f, 0f))
                {
                    return(true);
                }
                if (abilityHelper.UseAbility(this.force, 400f, 0f))
                {
                    return(true);
                }
            }
            if (abilityHelper.UseAbility(this.shiva, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.bladeMail, 400f))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.smash, true))
            {
                return(true);
            }
            if ((abilityHelper.CanBeCasted(this.refresher, true, true, true, true) || abilityHelper.CanBeCasted(this.refresherShard, true, true, true, true)) && abilityHelper.CanBeCasted(this.ravage, true, true, true, false) && !this.ravage.Ability.IsReady)
            {
                UntargetableAbility untargetableAbility = abilityHelper.CanBeCasted(this.refresherShard, true, true, true, true) ? this.refresherShard : this.refresher;
                if (abilityHelper.HasMana(new UsableAbility[]
                {
                    this.ravage,
                    untargetableAbility
                }) && abilityHelper.UseAbility(untargetableAbility, true))
                {
                    return(true);
                }
            }
            return(abilityHelper.UseAbility(this.gush, true));
        }
コード例 #6
0
        // Token: 0x06000662 RID: 1634 RVA: 0x0001F130 File Offset: 0x0001D330
        public bool TotemCombo(TargetManager targetManager, AbilityHelper abilityHelper)
        {
            float num = base.Owner.Distance(targetManager.Target);

            if (num < 250f && base.Owner.HasModifier("modifier_earthshaker_enchant_totem"))
            {
                return(false);
            }
            if (abilityHelper.UseAbility(this.totem, true))
            {
                return(true);
            }
            if (abilityHelper.UseDoubleBlinkCombo(this.force, this.blink, 0f))
            {
                return(true);
            }
            if (abilityHelper.UseAbilityIfCondition(this.blink, new UsableAbility[]
            {
                this.totem
            }))
            {
                if (!base.Owner.HasModifier("modifier_earthshaker_enchant_totem"))
                {
                    UpdateManager.BeginInvoke(delegate
                    {
                        this.totem.ForceUseAbility(targetManager, this.ComboSleeper);
                        this.OrbwalkSleeper.ExtendSleep(0.2f);
                        this.ComboSleeper.ExtendSleep(0.2f);
                    }, 111);
                }
                else if (base.Owner.BaseUnit.Attack(targetManager.Target.BaseUnit))
                {
                    base.OrbwalkSleeper.ExtendSleep(0.1f);
                    base.ComboSleeper.ExtendSleep(0.1f);
                    return(true);
                }
                return(true);
            }
            if (abilityHelper.UseAbility(this.force, 500f, 100f))
            {
                return(true);
            }
            if (!abilityHelper.CanBeCasted(this.totem, true, true, true, true) && (!abilityHelper.CanBeCasted(this.blink, true, true, true, true) || num < 300f) && abilityHelper.UseAbility(this.fissure, true))
            {
                base.OrbwalkSleeper.ExtendSleep(0.1f);
                return(true);
            }
            return(abilityHelper.UseAbility(this.echo, true));
        }
コード例 #7
0
 // Token: 0x06000663 RID: 1635 RVA: 0x0001F2B4 File Offset: 0x0001D4B4
 private bool EchoSlamCombo(TargetManager targetManager, AbilityHelper abilityHelper)
 {
     if (abilityHelper.UseDoubleBlinkCombo(this.force, this.blink, 0f))
     {
         return(true);
     }
     if (abilityHelper.UseAbility(this.echo, true))
     {
         base.ComboSleeper.ExtendSleep(0.1f);
         base.OrbwalkSleeper.ExtendSleep(0.1f);
         return(true);
     }
     if (abilityHelper.UseAbilityIfCondition(this.blink, new UsableAbility[]
     {
         this.echo
     }))
     {
         UpdateManager.BeginInvoke(delegate
         {
             this.echo.ForceUseAbility(targetManager, this.ComboSleeper);
             this.ComboSleeper.ExtendSleep(0.2f);
             this.OrbwalkSleeper.ExtendSleep(0.2f);
         }, 111);
         return(true);
     }
     return(!abilityHelper.CanBeCasted(this.echo, false, false, true, true) && (abilityHelper.UseAbility(this.totem, true) || abilityHelper.UseAbility(this.fissure, true)));
 }
コード例 #8
0
ファイル: Gyrocopter.cs プロジェクト: vana41203/O9K
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            var abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

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

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

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

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

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

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

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

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

            if (abilityHelper.CanBeCasted(this.pike) && !this.MoveSleeper.IsSleeping)
            {
                if (this.pike.UseAbilityOnTarget(targetManager, this.ComboSleeper))
                {
                    return(true);
                }
            }

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

            return(false);
        }
コード例 #9
0
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            var damagingChakrams = this.chakrams.Count(x => comboModeMenu.IsAbilityEnabled(x.Ability) && x.IsDamaging(targetManager));
            var returnChakram    = this.chakrams.Find(
                x => comboModeMenu.IsAbilityEnabled(x.Ability) && x.ShouldReturnChakram(targetManager, damagingChakrams));

            if (returnChakram?.Return() == true)
            {
                return(true);
            }

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

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

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

            if (abilityHelper.UseAbilityIfCondition(this.blink, this.timberChain, this.whirlingDeath))
            {
                if (abilityHelper.CanBeCasted(this.whirlingDeath, false, false))
                {
                    abilityHelper.ForceUseAbility(this.whirlingDeath, true);
                }

                return(true);
            }

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

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

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

            var chakram = this.chakrams.Find(x => x.Ability.CanBeCasted());

            if (abilityHelper.UseAbility(chakram))
            {
                return(true);
            }

            return(false);
        }
コード例 #10
0
        // Token: 0x06000939 RID: 2361 RVA: 0x00028E7C File Offset: 0x0002707C
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            AbilityHelper abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

            if (abilityHelper.CanBeCasted(this.field, 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.field,
                    this.glimmer
                }) && abilityHelper.CanBeCasted(this.glimmer, false, false, true, true) && abilityHelper.ForceUseAbility(this.glimmer, false, true))
                {
                    return(true);
                }
                if (abilityHelper.HasMana(new UsableAbility[]
                {
                    this.field,
                    this.atos
                }) && abilityHelper.UseAbility(this.atos, true))
                {
                    return(true);
                }
                if (abilityHelper.HasMana(new UsableAbility[]
                {
                    this.field,
                    this.frostbite
                }) && abilityHelper.UseAbility(this.frostbite, true))
                {
                    return(true);
                }
                if (abilityHelper.UseAbility(this.field, true))
                {
                    return(true);
                }
            }
            return(abilityHelper.UseAbilityIfCondition(this.blink, new UsableAbility[]
            {
                this.field
            }) || abilityHelper.UseAbility(this.force, 600f, 400f) || abilityHelper.UseAbility(this.atos, true) || abilityHelper.UseAbility(this.frostbite, true) || abilityHelper.UseAbility(this.nova, true));
        }
コード例 #11
0
        // Token: 0x060004B9 RID: 1209 RVA: 0x00018EDC File Offset: 0x000170DC
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            AbilityHelper abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

            if (abilityHelper.UseAbility(this.blink, 700f, 300f))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.hex, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.bloodthorn, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.orchid, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.veil, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.nullifier, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.atos, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.dagon, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.shiva, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.pulse, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.scythe, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.shroud, 300f))
            {
                base.ComboSleeper.ExtendSleep(0.3f);
                return(true);
            }
            return((!base.Owner.IsAttackImmune && !abilityHelper.CanBeCasted(this.shroud, true, true, true, true) && abilityHelper.UseAbility(this.bladeMail, 500f)) || abilityHelper.UseAbility(this.phase, true));
        }
コード例 #12
0
        // Token: 0x06000656 RID: 1622 RVA: 0x0001ED0C File Offset: 0x0001CF0C
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            AbilityHelper abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

            if (abilityHelper.UseAbility(this.force, 550f, 400f))
            {
                return(true);
            }
            if (abilityHelper.UseAbilityIfAny(this.euls, new UsableAbility[]
            {
                this.stomp,
                this.hammer
            }))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.atos, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.spirit, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbilityIfNone(this.stomp, new UsableAbility[]
            {
                this.euls
            }))
            {
                return(true);
            }
            if (abilityHelper.CanBeCasted(this.hammer, false, false, true, true))
            {
                Unit9 target = targetManager.Target;
                if (target.GetImmobilityDuration() > this.hammer.Ability.GetHitTime(target) - 0.5f && abilityHelper.UseAbility(this.hammer, true))
                {
                    return(true);
                }
            }
            return(!abilityHelper.CanBeCasted(this.euls, true, true, true, true) && !abilityHelper.CanBeCasted(this.stomp, false, false, true, true) && abilityHelper.UseAbilityIfNone(this.splitter, new UsableAbility[0]));
        }
コード例 #13
0
        // Token: 0x060001DC RID: 476 RVA: 0x0000E5B8 File Offset: 0x0000C7B8
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            AbilityHelper abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);
            Unit9         target        = targetManager.Target;

            if (abilityHelper.UseAbility(this.bloodthorn, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.orchid, true))
            {
                return(true);
            }
            if ((!abilityHelper.CanBeCasted(this.blink, true, true, true, true) || base.Owner.Distance(target) < 400f) && abilityHelper.UseAbility(this.nova, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.shiva, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbilityIfCondition(this.blink, new UsableAbility[]
            {
                this.nova
            }))
            {
                return(true);
            }
            if (!abilityHelper.CanBeCasted(this.nova, false, false, true, true))
            {
                if (abilityHelper.UseAbility(this.blink, 500f, 300f))
                {
                    return(true);
                }
                if (abilityHelper.UseAbility(this.force, 500f, 300f))
                {
                    return(true);
                }
            }
            return(abilityHelper.UseAbility(this.veil, true) || abilityHelper.UseAbility(this.gale, true) || abilityHelper.UseAbility(this.ward, true));
        }
コード例 #14
0
        // Token: 0x0600078B RID: 1931 RVA: 0x00022F68 File Offset: 0x00021168
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            AbilityHelper abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

            return(abilityHelper.UseAbility(this.bkb, 500f) || ((!abilityHelper.CanBeCasted(this.timeWalk, false, true, true, true) || base.Owner.Distance(targetManager.Target) < 400f) && abilityHelper.UseAbility(this.chronosphere, true)) || abilityHelper.UseAbilityIfCondition(this.timeWalk, new UsableAbility[]
            {
                this.chronosphere
            }) || abilityHelper.UseAbility(this.diffusal, true) || abilityHelper.UseAbility(this.dilation, true) || abilityHelper.UseAbility(this.silver, true) || abilityHelper.UseAbility(this.mjollnir, 600f) || abilityHelper.UseAbility(this.manta, 300f) || (!abilityHelper.CanBeCasted(this.chronosphere, false, false, true, true) && abilityHelper.UseAbilityIfNone(this.mom, new UsableAbility[]
            {
                this.timeWalk
            })) || abilityHelper.UseAbility(this.phase, true));
        }
コード例 #15
0
        // Token: 0x060001C7 RID: 455 RVA: 0x0000E1A0 File Offset: 0x0000C3A0
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            AbilityHelper abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

            if (abilityHelper.UseAbility(this.chaos, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.force, 600f, 500f))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.bonds, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.word, true))
            {
                return(true);
            }
            if ((abilityHelper.CanBeCasted(this.refresher, true, true, true, true) || abilityHelper.CanBeCasted(this.refresherShard, true, true, true, true)) && abilityHelper.CanBeCasted(this.chaos, true, true, true, false) && !this.chaos.Ability.IsReady)
            {
                UntargetableAbility untargetableAbility = abilityHelper.CanBeCasted(this.refresherShard, true, true, true, true) ? this.refresherShard : this.refresher;
                if (abilityHelper.HasMana(new UsableAbility[]
                {
                    this.chaos,
                    untargetableAbility
                }) && abilityHelper.UseAbility(untargetableAbility, true))
                {
                    base.ComboSleeper.ExtendSleep(0.2f);
                    DebuffAbility debuffAbility = this.upheaval;
                    if (debuffAbility != null)
                    {
                        debuffAbility.Sleeper.Sleep(0.5f);
                    }
                    return(true);
                }
            }
            return(abilityHelper.UseAbility(this.upheaval, true));
        }
コード例 #16
0
 // Token: 0x06000915 RID: 2325 RVA: 0x0000691B File Offset: 0x00004B1B
 protected override bool MoveComboUseBuffs(AbilityHelper abilityHelper)
 {
     if (base.MoveComboUseBuffs(abilityHelper))
     {
         return(true);
     }
     if (abilityHelper.CanBeCasted(this.surge, false, false, true, true))
     {
         abilityHelper.ForceUseAbility(this.surge, false, true);
         return(true);
     }
     return(false);
 }
コード例 #17
0
        // Token: 0x06000950 RID: 2384 RVA: 0x000292DC File Offset: 0x000274DC
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            AbilityHelper abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

            if (abilityHelper.UseAbility(this.bloodthorn, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.orchid, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.armlet, 600f))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.bkb, 600f))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.bolt, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.rift, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.blink, 500f, 0f))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.halberd, true))
            {
                return(true);
            }
            if (abilityHelper.CanBeCasted(this.phantasm, true, true, true, true))
            {
                if (abilityHelper.UseAbility(this.armlet, true))
                {
                    base.ComboSleeper.ExtendSleep(0.5f);
                    return(true);
                }
                if (abilityHelper.UseAbility(this.phantasm, true))
                {
                    return(true);
                }
            }
            return(abilityHelper.UseAbility(this.manta, 600f));
        }
コード例 #18
0
        // Token: 0x06000274 RID: 628 RVA: 0x000104E4 File Offset: 0x0000E6E4
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            int     damagingChakrams = this.chakrams.Count((Chakram x) => comboModeMenu.IsAbilityEnabled(x.Ability) && x.IsDamaging(targetManager));
            Chakram chakram          = this.chakrams.Find((Chakram x) => comboModeMenu.IsAbilityEnabled(x.Ability) && x.ShouldReturnChakram(targetManager, damagingChakrams));

            if (chakram != null && chakram.Return())
            {
                return(true);
            }
            AbilityHelper abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

            if (abilityHelper.UseAbility(this.whirlingDeath, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.hex, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbilityIfCondition(this.blink, new UsableAbility[]
            {
                this.timberChain,
                this.whirlingDeath
            }))
            {
                if (abilityHelper.CanBeCasted(this.whirlingDeath, false, false, true, true))
                {
                    abilityHelper.ForceUseAbility(this.whirlingDeath, true, true);
                }
                return(true);
            }
            if (abilityHelper.UseAbility(this.shiva, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.bladeMail, 400f))
            {
                return(true);
            }
            if (abilityHelper.UseAbilityIfCondition(this.timberChain, new UsableAbility[]
            {
                this.blink
            }))
            {
                return(true);
            }
            Chakram ability = this.chakrams.Find((Chakram x) => x.Ability.CanBeCasted(true));

            return(abilityHelper.UseAbility(ability, true));
        }
コード例 #19
0
        // Token: 0x060002C0 RID: 704 RVA: 0x000114A0 File Offset: 0x0000F6A0
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            if (comboModeMenu.IsHarassCombo)
            {
                return(false);
            }
            AbilityHelper abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

            if (abilityHelper.UseAbility(this.refraction, 1300f))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.blink, 500f, 0f))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.force, 500f, 0f))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.pike, 500f, 0f))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.hex, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.solar, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.medallion, true))
            {
                return(true);
            }
            if (abilityHelper.CanBeCasted(this.meld, false, true, true, true))
            {
                this.preventAttackSleeper.Sleep(0.05f);
                if (!base.AttackSleeper.IsSleeping && abilityHelper.UseAbility(this.meld, true))
                {
                    float num = base.Owner.GetAttackPoint(null) + 0.1f;
                    base.ComboSleeper.ExtendSleep(num);
                    base.MoveSleeper.Sleep(num);
                    base.AttackSleeper.Sleep(num);
                    return(true);
                }
            }
            return(abilityHelper.UseAbility(this.orchid, true) || abilityHelper.UseAbility(this.bloodthorn, true) || abilityHelper.UseAbility(this.nullifier, true) || ((!abilityHelper.CanBeCasted(this.blink, true, true, true, true) || base.Owner.Distance(targetManager.Target) < 1000f) && abilityHelper.UseAbility(this.trap, true)));
        }
コード例 #20
0
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            var abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

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

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

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

            if (abilityHelper.UseAbilityIfNone(this.wall, this.vacuum))
            {
                return(true);
            }

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

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

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

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

            return(false);
        }
コード例 #21
0
        // Token: 0x060003E9 RID: 1001 RVA: 0x00015CFC File Offset: 0x00013EFC
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            AbilityHelper abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

            if (abilityHelper.UseAbility(this.bkb, 600f))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.hex, 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.veil, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.shiva, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.scream, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.mjollnir, 500f))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.shadowStrike, true))
            {
                return(true);
            }
            Unit9 target = targetManager.Target;

            return(((abilityHelper.CanBeCasted(this.shadowStrike, true, true, true, true) || abilityHelper.CanBeCasted(this.scream, true, true, true, true) || abilityHelper.CanBeCasted(this.sonic, true, true, true, true) || base.Owner.Distance(target) > base.Owner.GetAttackRange(target, 0f)) && abilityHelper.UseAbility(this.blink, true)) || abilityHelper.UseAbility(this.sonic, true));
        }
コード例 #22
0
        // Token: 0x060005AB RID: 1451 RVA: 0x0001C918 File Offset: 0x0001AB18
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            AbilityHelper abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

            return(abilityHelper.UseAbility(this.blink, 550f, 350f) || abilityHelper.UseAbility(this.veil, true) || abilityHelper.UseAbility(this.shiva, true) || abilityHelper.UseAbility(this.ethereal, true) || abilityHelper.UseAbility(this.hex, true) || abilityHelper.UseAbility(this.atos, true) || abilityHelper.UseAbilityIfAny(this.euls, new UsableAbility[]
            {
                this.splitEarth
            }) || (abilityHelper.CanBeCasted(this.nova, false, false, true, true) && this.nova.AutoToggle(targetManager)) || abilityHelper.UseAbilityIfCondition(this.diabolic, new UsableAbility[]
            {
                this.splitEarth
            }) || abilityHelper.UseAbility(this.lightning, true) || abilityHelper.UseAbilityIfNone(this.splitEarth, new UsableAbility[]
            {
                this.lightning,
                this.euls,
                this.atos
            }));
        }
コード例 #23
0
ファイル: Earthshaker.cs プロジェクト: vana41203/O9K
        private bool EchoSlamCombo(TargetManager targetManager, AbilityHelper abilityHelper)
        {
            if (abilityHelper.UseDoubleBlinkCombo(this.force, this.blink))
            {
                return(true);
            }

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

            if (abilityHelper.UseAbilityIfCondition(this.blink, this.echo))
            {
                UpdateManager.BeginInvoke(
                    () =>
                {
                    this.echo.ForceUseAbility(targetManager, this.ComboSleeper);
                    this.ComboSleeper.ExtendSleep(0.2f);
                    this.OrbwalkSleeper.ExtendSleep(0.2f);
                },
                    111);
                return(true);
            }

            if (abilityHelper.CanBeCasted(this.echo, false, false))
            {
                return(false);
            }

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

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

            return(false);
        }
コード例 #24
0
ファイル: ShadowShaman.cs プロジェクト: vana41203/O9K
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            var abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

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

            if (abilityHelper.CanBeCasted(this.wards, true, false))
            {
                if (abilityHelper.UseAbility(this.euls))
                {
                    return(true);
                }
            }

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

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

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

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

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

            return(false);
        }
コード例 #25
0
        // Token: 0x060001A1 RID: 417 RVA: 0x0000DB78 File Offset: 0x0000BD78
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            AbilityHelper abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

            if (abilityHelper.UseAbility(this.dagon, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.end, true))
            {
                return(true);
            }
            if (this.end.Ability.IsChanneling && targetManager.Target.HasModifier("modifier_oracle_purifying_flames") && base.Owner.BaseUnit.Stop())
            {
                base.ComboSleeper.Sleep(0.1f);
                return(true);
            }
            return((abilityHelper.CanBeCasted(this.flames, true, true, false, true) && this.end.Ability.IsChanneling && !this.end.FullChannelTime(comboModeMenu) && abilityHelper.ForceUseAbility(this.flames, false, true)) || abilityHelper.UseAbility(this.flames, true) || abilityHelper.UseAbility(this.urn, true) || abilityHelper.UseAbility(this.vessel, true));
        }
コード例 #26
0
 // Token: 0x06000456 RID: 1110 RVA: 0x00017A38 File Offset: 0x00015C38
 protected override bool MoveComboUseBlinks(AbilityHelper abilityHelper)
 {
     if (base.MoveComboUseBlinks(abilityHelper))
     {
         return(true);
     }
     if (abilityHelper.CanBeCasted(this.dive, false, false, true, true))
     {
         this.dive.Ability.UseAbility(Game.MousePosition, false, false);
         base.ComboSleeper.Sleep(0.3f);
         this.dive.Sleeper.Sleep(0.3f);
         return(true);
     }
     if (this.dive.AutoStop(null))
     {
         base.ComboSleeper.Sleep(0.1f);
         return(true);
     }
     return(false);
 }
コード例 #27
0
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            if (targetManager.TargetSleeper.IsSleeping)
            {
                return(false);
            }

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

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

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

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

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

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

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

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

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

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

            if (abilityHelper.UseKillStealAbility(this.dragon, false))
            {
                return(true);
            }

            if (abilityHelper.UseKillStealAbility(this.laguna))
            {
                this.ComboSleeper.ExtendSleep(0.2f);
                return(true);
            }

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

            if (abilityHelper.CanBeCasted(this.euls, false) && abilityHelper.CanBeCasted(this.array, false))
            {
                if (this.Owner.Speed > targetManager.Target.Speed + 50)
                {
                    this.preventAttackSleeper.Sleep(0.5f);
                    return(true);
                }
            }

            if (abilityHelper.UseAbility(this.array, false))
            {
                return(true);
            }

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

            if (abilityHelper.UseAbility(this.dragon, false))
            {
                return(true);
            }

            if (abilityHelper.CanBeCasted(this.pike) && !this.MoveSleeper.IsSleeping)
            {
                if (this.pike.UseAbilityOnTarget(targetManager, this.ComboSleeper))
                {
                    return(true);
                }
            }

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

            return(false);
        }
コード例 #28
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.nullifier))
            {
                return(true);
            }

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

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

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

            if (targetManager.Target.HasModifier("modifier_pudge_meat_hook"))
            {
                if (abilityHelper.CanBeCasted(this.bloodthorn, true, false))
                {
                    abilityHelper.ForceUseAbility(this.bloodthorn);
                    return(true);
                }

                if (abilityHelper.CanBeCasted(this.nullifier, true, false) &&
                    !targetManager.Target.Abilities.Any(x => x.Id == AbilityId.item_aeon_disk && x.IsReady))
                {
                    abilityHelper.ForceUseAbility(this.nullifier);
                    return(true);
                }

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

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

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

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

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

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

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

                if (abilityHelper.CanBeCasted(this.nullifier, true, false) &&
                    !targetManager.Target.Abilities.Any(x => x.Id == AbilityId.item_aeon_disk && x.IsReady))
                {
                    abilityHelper.ForceUseAbility(this.nullifier);
                    return(true);
                }

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

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

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

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

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

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

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

                abilityHelper.ForceUseAbility(this.dismember);
                return(true);
            }

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

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

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

            if (abilityHelper.CanBeCasted(this.force))
            {
                if (this.force.UseAbilityOnTarget(targetManager, this.ComboSleeper))
                {
                    return(true);
                }
            }

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

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

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

            return(false);
        }
コード例 #29
0
        // Token: 0x060002E6 RID: 742 RVA: 0x00011E14 File Offset: 0x00010014
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            AbilityHelper abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);
            Unit9         target        = targetManager.Target;

            if (abilityHelper.UseAbility(this.hex, true))
            {
                return(true);
            }
            if (abilityHelper.CanBeCasted(this.vortex, true, true, true, true) && (target.CanBecomeMagicImmune || target.CanBecomeInvisible) && abilityHelper.UseAbility(this.vortex, 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.dagon, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.shiva, true))
            {
                return(true);
            }
            bool flag = base.Owner.CanAttack(target, 25f) && base.Owner.HasModifier("modifier_storm_spirit_overload");
            TrackingProjectile trackingProjectile = ObjectManager.TrackingProjectiles.FirstOrDefault(delegate(TrackingProjectile x)
            {
                Entity source             = x.Source;
                EntityHandle?entityHandle = (source != null) ? new EntityHandle?(source.Handle) : null;
                if (((entityHandle != null) ? new uint?(entityHandle.GetValueOrDefault()) : null) == this.Handle)
                {
                    Entity target = x.Target;
                    entityHandle  = ((target != null) ? new EntityHandle?(target.Handle) : null);
                    if (((entityHandle != null) ? new uint?(entityHandle.GetValueOrDefault()) : null) == target.Handle)
                    {
                        return(ProjectileExtensions.IsAutoAttackProjectile(x));
                    }
                }
                return(false);
            });

            if (flag)
            {
                if (trackingProjectile == null)
                {
                    return(false);
                }
                int num = (target.IsMoving && target.GetAngle(trackingProjectile.Position, false) > 1.5f) ? 250 : 450;
                if (trackingProjectile.Position.Distance2D(trackingProjectile.TargetPosition, false) > (float)num)
                {
                    return(false);
                }
            }
            else
            {
                if (trackingProjectile != null)
                {
                    Ability9 ability = base.Owner.Abilities.FirstOrDefault((Ability9 x) => x.Id == AbilityId.storm_spirit_overload);
                    if (ability != null)
                    {
                        int   attackDamage = base.Owner.GetAttackDamage(target, 0, 0f);
                        int   damage       = ability.GetDamage(target);
                        float health       = target.Health;
                        if ((float)attackDamage < health && (float)(attackDamage + damage) > health)
                        {
                            if (abilityHelper.CanBeCasted(this.remnant, false, false, true, true) && abilityHelper.ForceUseAbility(this.remnant, true, true))
                            {
                                return(true);
                            }
                            if (abilityHelper.CanBeCasted(this.ball, false, false, true, true) && trackingProjectile.Position.Distance2D(trackingProjectile.TargetPosition, false) / (float)trackingProjectile.Speed > this.ball.Ability.CastPoint && abilityHelper.ForceUseAbility(this.ball, true, true))
                            {
                                return(true);
                            }
                        }
                    }
                }
                if (abilityHelper.UseAbility(this.vortex, true))
                {
                    base.ComboSleeper.ExtendSleep(0.1f);
                    BallLightning ballLightning = this.ball;
                    if (ballLightning != null)
                    {
                        ballLightning.Sleeper.Sleep(1f);
                    }
                    return(true);
                }
                if (abilityHelper.UseAbility(this.remnant, true))
                {
                    base.ComboSleeper.ExtendSleep(0.1f);
                    BallLightning ballLightning2 = this.ball;
                    if (ballLightning2 != null)
                    {
                        ballLightning2.Sleeper.Sleep(1f);
                    }
                    return(true);
                }
            }
            return(abilityHelper.UseAbility(this.ball, true));
        }
コード例 #30
0
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            var abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

            if (abilityHelper.UseAbility(this.glimpse))
            {
                this.blink?.Sleeper.Sleep(3f);
                this.force?.Sleeper.Sleep(3f);
                return(true);
            }

            if (abilityHelper.CanBeCasted(this.glimpse, false))
            {
                if (abilityHelper.UseAbility(this.blink, this.glimpse.Ability.CastRange, this.glimpse.Ability.CastRange - 500))
                {
                    return(true);
                }
            }
            else
            {
                if (abilityHelper.UseAbility(this.blink, 800, 500))
                {
                    return(true);
                }
            }

            if (abilityHelper.UseAbility(this.force, this.glimpse.Ability.CastRange, this.glimpse.Ability.CastRange - 500))
            {
                return(true);
            }

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

            var glimpseTime = this.glimpse.Ability.TimeSinceCasted;

            if (glimpseTime < 1.8)
            {
                if (this.glimpseParticle?.IsValid == true && !targetManager.Target.IsMagicImmune)
                {
                    var position = this.glimpseParticle.GetControlPoint(1);

                    if (abilityHelper.CanBeCasted(this.field, false))
                    {
                        if (this.field.UseAbility(position, this.ComboSleeper))
                        {
                            return(true);
                        }
                    }

                    var glimpseParticleTime = this.glimpseParticle.GetControlPoint(2).X;
                    if (glimpseTime + 0.35f > glimpseParticleTime && abilityHelper.CanBeCasted(this.storm, false))
                    {
                        if (this.storm.UseAbility(position, targetManager, this.ComboSleeper))
                        {
                            return(true);
                        }
                    }

                    if (this.Owner.Distance(position) > this.storm.Ability.CastRange - 100)
                    {
                        this.Owner.BaseUnit.Move(position.Extend2D(this.Owner.Position, 500));
                        return(true);
                    }
                }

                this.OrbwalkSleeper.Sleep(0.1f);
                return(true);
            }

            if (glimpseTime > 2 && abilityHelper.UseAbilityIfNone(this.field, this.glimpse))
            {
                return(true);
            }

            if (abilityHelper.CanBeCasted(this.storm))
            {
                var fieldCastTime = this.field.Ability.TimeSinceCasted;
                if (fieldCastTime <= 4)
                {
                    if (this.storm.UseAbility(this.field.CastPosition, targetManager, this.ComboSleeper))
                    {
                        return(true);
                    }
                }
                else
                {
                    if (abilityHelper.UseAbility(this.storm))
                    {
                        return(true);
                    }
                }
            }

            if (abilityHelper.CanBeCasted(this.thunder))
            {
                var mana = this.Owner.Mana - this.thunder.Ability.ManaCost;

                if (abilityHelper.CanBeCasted(this.field))
                {
                    mana -= this.field.Ability.ManaCost;
                }

                if (abilityHelper.CanBeCasted(this.storm))
                {
                    mana -= this.storm.Ability.ManaCost;
                }

                if (mana > 0)
                {
                    abilityHelper.UseAbility(this.thunder);
                }
            }

            return(false);
        }