Exemple #1
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.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);
        }
Exemple #2
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));
        }
        // 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));
        }
Exemple #4
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));
        }
        // 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));
        }
        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);
        }
Exemple #7
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);
        }
Exemple #8
0
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            var abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

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

            if (!abilityHelper.CanBeCasted(this.polarity, false, false, false) && !abilityHelper.CanBeCasted(this.skewer))
            {
                if (abilityHelper.UseAbility(this.shiva))
                {
                    return(true);
                }
            }

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

            if (abilityHelper.UseAbilityIfCondition(this.blink, this.polarity))
            {
                UpdateManager.BeginInvoke(() => this.polarity.ForceUseAbility(targetManager, this.ComboSleeper, comboModeMenu), 50);
                return(true);
            }

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

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

            if (abilityHelper.CanBeCasted(this.skewer, false, false))
            {
                var canCastBlink = abilityHelper.CanBeCasted(this.blink, false, false);
                var canCastForce = abilityHelper.CanBeCasted(this.force, false, false);

                if (this.skewer.UseAbilityIfCondition(
                        targetManager,
                        this.ComboSleeper,
                        comboModeMenu,
                        this.polarity,
                        canCastBlink,
                        canCastForce))
                {
                    return(true);
                }
            }

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

            if (abilityHelper.CanBeCasted(this.skewer, false, false) && abilityHelper.CanBeCasted(this.shockwave, false) &&
                !abilityHelper.CanBeCasted(this.polarity, false, false))
            {
                if (this.skewer.UseAbilityOnTarget(targetManager, this.ComboSleeper))
                {
                    return(true);
                }
            }

            if (abilityHelper.UseAbilityIfCondition(this.shockwave, this.blink, this.force, this.skewer, this.polarity))
            {
                return(true);
            }

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

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

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

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

                if (abilityHelper.HasMana(this.pulse, this.blackHole) && abilityHelper.UseAbility(this.pulse))
                {
                    return(true);
                }

                if (abilityHelper.HasMana(this.shiva, this.blackHole) && abilityHelper.UseAbility(this.shiva))
                {
                    return(true);
                }

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

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

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

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

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

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

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

            return(false);
        }
        // Token: 0x0600054A RID: 1354 RVA: 0x0001B424 File Offset: 0x00019624
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            AbilityHelper abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

            if (abilityHelper.UseAbility(this.polarity, true))
            {
                return(true);
            }
            if (!abilityHelper.CanBeCasted(this.polarity, false, false, false, true) && !abilityHelper.CanBeCasted(this.skewer, true, true, true, true) && abilityHelper.UseAbility(this.shiva, true))
            {
                return(true);
            }
            if (abilityHelper.UseDoubleBlinkCombo(this.force, this.blink, 0f))
            {
                return(true);
            }
            if (abilityHelper.UseAbilityIfCondition(this.blink, new UsableAbility[]
            {
                this.polarity
            }))
            {
                UpdateManager.BeginInvoke(delegate
                {
                    this.polarity.ForceUseAbility(targetManager, this.ComboSleeper, comboModeMenu);
                }, 50);
                return(true);
            }
            if (abilityHelper.UseAbility(this.force, 500f, 100f))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.skewer, true))
            {
                return(true);
            }
            if (abilityHelper.CanBeCasted(this.skewer, false, false, true, true))
            {
                bool flag  = abilityHelper.CanBeCasted(this.blink, false, false, true, true);
                bool flag2 = abilityHelper.CanBeCasted(this.force, false, false, true, true);
                if (this.skewer.UseAbilityIfCondition(targetManager, base.ComboSleeper, comboModeMenu, this.polarity, flag, flag2))
                {
                    return(true);
                }
            }
            if (abilityHelper.UseAbilityIfCondition(this.skewer, new UsableAbility[]
            {
                this.blink,
                this.force
            }))
            {
                return(true);
            }
            if (abilityHelper.CanBeCasted(this.skewer, false, false, true, true) && abilityHelper.CanBeCasted(this.shockwave, false, true, true, true) && !abilityHelper.CanBeCasted(this.polarity, false, false, true, true) && this.skewer.UseAbilityOnTarget(targetManager, base.ComboSleeper))
            {
                return(true);
            }
            if (abilityHelper.UseAbilityIfCondition(this.shockwave, new UsableAbility[]
            {
                this.blink,
                this.force,
                this.skewer,
                this.polarity
            }))
            {
                return(true);
            }
            if ((abilityHelper.CanBeCasted(this.refresher, true, true, true, true) || abilityHelper.CanBeCasted(this.refresherShard, true, true, true, true)) && abilityHelper.CanBeCasted(this.polarity, true, true, true, false) && !this.polarity.Ability.IsReady)
            {
                UntargetableAbility untargetableAbility = abilityHelper.CanBeCasted(this.refresherShard, true, true, true, true) ? this.refresherShard : this.refresher;
                if (abilityHelper.HasMana(new UsableAbility[]
                {
                    this.polarity,
                    untargetableAbility
                }) && abilityHelper.UseAbility(untargetableAbility, true))
                {
                    return(true);
                }
            }
            return(false);
        }
        // Token: 0x060007BF RID: 1983 RVA: 0x000238D8 File Offset: 0x00021AD8
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            AbilityHelper abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

            if (abilityHelper.UseAbility(this.hex, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.orchid, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.bloodthorn, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.nullifier, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.veil, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.chains, true))
            {
                return(true);
            }
            if (abilityHelper.CanBeCasted(this.blink, false, true, true, true) && abilityHelper.CanBeCasted(this.chains, false, true, true, true) && abilityHelper.CanBeCasted(this.fist, false, true, true, true))
            {
                float range  = this.fist.Ability.Range;
                float num    = this.blink.Ability.Range + range;
                Unit9 target = targetManager.Target;
                float num2   = base.Owner.Distance(target);
                if (num > num2 && num2 > range && abilityHelper.UseAbility(this.blink, target.Position))
                {
                    return(true);
                }
            }
            if (!base.Owner.IsInvulnerable && abilityHelper.UseAbility(this.blink, 700f, 0f))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.fist, true))
            {
                return(true);
            }
            if (abilityHelper.CanBeCasted(this.remnantActivate, false, true, true, true) && !this.remnant.Sleeper.IsSleeping && abilityHelper.ForceUseAbility(this.remnantActivate, true, true))
            {
                return(true);
            }
            if (abilityHelper.CanBeCasted(this.remnant, true, true, true, true) && abilityHelper.HasMana(new UsableAbility[]
            {
                this.remnantActivate
            }) && !base.Owner.IsInvulnerable)
            {
                Unit9 target2 = targetManager.Target;
                float num3    = target2.Distance(base.Owner);
                if (((double)target2.GetImmobilityDuration() > 0.8 || num3 < 400f) && this.remnant.GetDamage(targetManager) + 100f > target2.Health)
                {
                    int num4 = 0;
                    while ((float)num4 < this.remnant.GetRequiredRemnants(targetManager))
                    {
                        abilityHelper.ForceUseAbility(this.remnant, false, true);
                        num4++;
                    }
                    base.ComboSleeper.Sleep(base.Owner.Distance(target2) / this.remnant.Ability.Speed * 0.6f);
                    return(true);
                }
                if (num3 > 350f && abilityHelper.UseAbility(this.remnant, true))
                {
                    return(true);
                }
            }
            return(abilityHelper.UseAbility(this.shiva, true) || abilityHelper.UseAbility(this.shield, 400f) || abilityHelper.UseAbility(this.mjollnir, 600f) || abilityHelper.UseAbility(this.bladeMail, 500f));
        }
Exemple #12
0
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            var abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

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

                if (abilityHelper.HasMana(this.field, this.glimmer) && abilityHelper.CanBeCasted(this.glimmer, false, false))
                {
                    if (abilityHelper.ForceUseAbility(this.glimmer))
                    {
                        return(true);
                    }
                }

                if (abilityHelper.HasMana(this.field, this.atos) && abilityHelper.UseAbility(this.atos))
                {
                    return(true);
                }

                if (abilityHelper.HasMana(this.field, this.frostbite) && abilityHelper.UseAbility(this.frostbite))
                {
                    return(true);
                }

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

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

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

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

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

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

            return(false);
        }