Пример #1
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);
        }
Пример #2
0
        // Token: 0x06000661 RID: 1633 RVA: 0x0001EFF0 File Offset: 0x0001D1F0
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            AbilityHelper abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

            if (comboModeMenu != null)
            {
                EarthshakerComboModeMenu earthshakerComboModeMenu;
                if ((earthshakerComboModeMenu = (comboModeMenu as EarthshakerComboModeMenu)) != null && earthshakerComboModeMenu.PreferEnchantTotem)
                {
                    return(this.TotemCombo(targetManager, abilityHelper));
                }
                if (comboModeMenu is EarthshakerEchoSlamComboModeMenu)
                {
                    return(this.EchoSlamCombo(targetManager, abilityHelper));
                }
            }
            if (abilityHelper.UseAbility(this.echo, true))
            {
                return(true);
            }
            if (abilityHelper.UseDoubleBlinkCombo(this.force, this.blink, 0f))
            {
                return(true);
            }
            if (abilityHelper.UseAbilityIfCondition(this.blink, new UsableAbility[]
            {
                this.echo
            }))
            {
                UpdateManager.BeginInvoke(delegate
                {
                    this.echo.ForceUseAbility(targetManager, this.ComboSleeper);
                    this.OrbwalkSleeper.ExtendSleep(0.1f);
                    this.ComboSleeper.ExtendSleep(0.1f);
                }, 111);
                return(true);
            }
            if (abilityHelper.UseAbilityIfCondition(this.blink, new UsableAbility[]
            {
                this.totem
            }))
            {
                UpdateManager.BeginInvoke(delegate
                {
                    this.totem.ForceUseAbility(targetManager, this.ComboSleeper);
                    this.OrbwalkSleeper.ExtendSleep(0.2f);
                    this.ComboSleeper.ExtendSleep(0.2f);
                }, 111);
                return(true);
            }
            return(abilityHelper.UseAbility(this.force, 500f, 100f) || abilityHelper.UseAbility(this.fissure, true) || abilityHelper.UseAbility(this.totem, true));
        }
Пример #3
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));
        }
Пример #4
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);
        }
Пример #5
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)));
 }
Пример #6
0
        // Token: 0x06000991 RID: 2449 RVA: 0x00029C60 File Offset: 0x00027E60
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            AbilityHelper abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

            if (abilityHelper.UseAbility(this.abyssal, true))
            {
                return(true);
            }
            if (!targetManager.Target.IsRuptured && abilityHelper.UseAbilityIfAny(this.euls, new UsableAbility[]
            {
                this.blood
            }))
            {
                return(true);
            }
            if (abilityHelper.UseAbilityIfCondition(this.blood, new UsableAbility[]
            {
                this.euls,
                this.rupture
            }))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.rupture, true))
            {
                this.rupture.Sleeper.ExtendSleep(1f);
                base.ComboSleeper.ExtendSleep(0.25f);
                return(true);
            }
            return(abilityHelper.UseAbility(this.rage, true) || abilityHelper.UseAbility(this.bladeMail, 600f) || abilityHelper.UseAbility(this.mjollnir, 600f) || abilityHelper.UseAbility(this.phase, true));
        }
Пример #7
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));
        }
Пример #8
0
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            var abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

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

            if (!targetManager.Target.IsRuptured)
            {
                if (abilityHelper.UseAbilityIfAny(this.euls, this.blood))
                {
                    return(true);
                }
            }

            if (abilityHelper.UseAbilityIfCondition(this.blood, this.euls, this.rupture))
            {
                return(true);
            }

            if (abilityHelper.UseAbility(this.rupture))
            {
                this.rupture.Sleeper.ExtendSleep(1f);
                this.ComboSleeper.ExtendSleep(0.25f);
                return(true);
            }

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

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

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

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

            return(false);
        }
Пример #9
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));
        }
Пример #10
0
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            if (this.ultSleeper)
            {
                return(false);
            }

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

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

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

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

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

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

            if (abilityHelper.UseAbilityIfCondition(this.thunder, this.blink))
            {
                this.ComboSleeper.Sleep(this.thunder.Ability.CastPoint + 0.1f);
                return(true);
            }

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

            return(false);
        }
Пример #11
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.cinder))
            {
                return(true);
            }

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

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

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

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

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

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

            return(false);
        }
Пример #12
0
        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);
        }
        // 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));
        }
Пример #14
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));
        }
Пример #15
0
        // Token: 0x06000148 RID: 328 RVA: 0x0000C418 File Offset: 0x0000A618
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            AbilityHelper abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

            if (this.powershot.CancelChanneling(targetManager))
            {
                base.ComboSleeper.Sleep(0.1f);
                return(true);
            }
            if (abilityHelper.UseAbilityIfCondition(this.blink, new UsableAbility[]
            {
                this.shackleshot
            }))
            {
                abilityHelper.ForceUseAbility(this.shackleshot, false, true);
                base.OrbwalkSleeper.Sleep(0.5f);
                return(true);
            }
            if (!abilityHelper.CanBeCasted(this.shackleshot, false, false, true, true) && abilityHelper.UseAbility(this.blink, base.Owner.GetAttackRange(targetManager.Target, 0f) + 100f, 400f))
            {
                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.shackleshot, true))
            {
                return(true);
            }
            if (abilityHelper.CanBeCasted(this.shackleshot, false, true, true, true))
            {
                bool    flag         = abilityHelper.CanBeCasted(this.windrun, false, false, true, true);
                Vector3 movePosition = this.shackleshot.GetMovePosition(targetManager, comboModeMenu, flag);
                if (!movePosition.IsZero && base.Move(movePosition))
                {
                    if ((base.Owner.Distance(movePosition) > 100f || targetManager.Target.IsMoving) && flag)
                    {
                        abilityHelper.ForceUseAbility(this.windrun, false, true);
                    }
                    base.OrbwalkSleeper.Sleep(0.1f);
                    base.ComboSleeper.Sleep(0.1f);
                    return(true);
                }
            }
            if (abilityHelper.UseAbilityIfCondition(this.powershot, new UsableAbility[]
            {
                this.shackleshot,
                this.blink
            }))
            {
                base.ComboSleeper.ExtendSleep(0.2f);
                base.OrbwalkSleeper.ExtendSleep(0.2f);
                return(true);
            }
            return(abilityHelper.UseAbilityIfCondition(this.focusFire, new UsableAbility[]
            {
                this.powershot
            }) || abilityHelper.UseAbility(this.windrun, true) || abilityHelper.UseAbility(this.phase, true));
        }
Пример #16
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));
        }
Пример #17
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));
        }
Пример #18
0
        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);
        }
Пример #19
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);
        }
Пример #20
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);
        }
Пример #21
0
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            var abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

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

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

            if (abilityHelper.UseAbility(this.veil))
            {
                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.nullifier))
            {
                return(true);
            }

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

            if (abilityHelper.UseAbilityIfCondition(this.eul, this.crown))
            {
                return(true);
            }

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

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

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

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

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

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

            return(false);
        }
Пример #22
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);
        }
Пример #23
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);
        }
Пример #24
0
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            var abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

            if (abilityHelper.UseAbilityIfCondition(this.dive, this.nova))
            {
                if (abilityHelper.CanBeCasted(this.shiva, false))
                {
                    this.shiva.ForceUseAbility(targetManager, this.ComboSleeper);
                }

                return(true);
            }

            if (!comboModeMenu.IsHarassCombo)
            {
                if (this.dive.AutoStop(targetManager))
                {
                    this.ComboSleeper.Sleep(0.1f);
                    return(true);
                }
            }

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

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

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

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

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

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

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

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

            if (abilityHelper.CanBeCasted(this.nova, false) && (this.dive.IsFlying || this.Owner.Distance(targetManager.Target) < 600))
            {
                var spiritsCount = this.Owner.GetModifier("modifier_phoenix_fire_spirit_count")?.StackCount ?? 0;
                var enemies      = targetManager.EnemyHeroes.Where(x => x.Distance(this.Owner) < this.spirits.Ability.CastRange).ToList();
                var count        = Math.Min(spiritsCount, enemies.Count);

                for (var i = 0; i < count; i++)
                {
                    this.spirits.Ability.UseAbility(enemies[i], HitChance.Low, i != 0);
                }

                if (count > 0)
                {
                    this.ComboSleeper.Sleep(0.2f);
                    return(true);
                }

                if ((this.Owner.Distance(targetManager.Target) < 600 ||
                     (this.dive.CastPosition != Vector3.Zero &&
                      this.Owner.Distance(this.dive.CastPosition) < this.nova.Ability.CastRange)) &&
                    abilityHelper.UseAbility(this.nova))
                {
                    return(true);
                }
            }

            if (!this.dive.IsFlying &&
                (!abilityHelper.CanBeCasted(this.spirits) || this.Owner.HasModifier("modifier_phoenix_fire_spirit_count")))
            {
                if (comboModeMenu.IsAbilityEnabled(this.ray.Ability))
                {
                    if (this.ray.AutoControl(targetManager, this.ComboSleeper, 0.6f))
                    {
                        return(true);
                    }
                }
            }

            return(false);
        }
Пример #25
0
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            var abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

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

            if (abilityHelper.UseAbilityIfCondition(this.blink, this.shackleshot))
            {
                abilityHelper.ForceUseAbility(this.shackleshot);
                this.OrbwalkSleeper.Sleep(0.5f);
                return(true);
            }

            if (!abilityHelper.CanBeCasted(this.shackleshot, false, false))
            {
                if (abilityHelper.UseAbility(this.blink, this.Owner.GetAttackRange(targetManager.Target) + 100, 400))
                {
                    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.shackleshot))
            {
                return(true);
            }

            if (abilityHelper.CanBeCasted(this.shackleshot, false))
            {
                var castWindrun  = abilityHelper.CanBeCasted(this.windrun, false, false);
                var movePosition = this.shackleshot.GetMovePosition(targetManager, comboModeMenu, castWindrun);
                //if ((movePosition.IsZero  || Owner.Distance(movePosition) > 300 || targetManager.Target.IsMoving) && abilityHelper.CanBeCasted(this.force, false, false))
                //{
                //    var forcePosition = this.shackleshot.GetForceStaffPosition(targetManager, this.force);
                //    if (!forcePosition.IsZero)
                //    {
                //        if (Owner.GetAngle(forcePosition) > 0.1)
                //        {
                //            this.Move(forcePosition);
                //            OrbwalkSleeper.Sleep(0.1f);
                //            this.ComboSleeper.Sleep(0.1f);
                //            return true;
                //        }

                //        abilityHelper.ForceUseAbility(this.force, true);
                //        return true;
                //    }
                //}

                if (!movePosition.IsZero && this.Move(movePosition))
                {
                    if ((this.Owner.Distance(movePosition) > 100 || targetManager.Target.IsMoving) && castWindrun)
                    {
                        abilityHelper.ForceUseAbility(this.windrun);
                    }

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

            if (abilityHelper.UseAbilityIfCondition(this.powershot, this.shackleshot, this.blink))
            {
                this.ComboSleeper.ExtendSleep(0.2f);
                this.OrbwalkSleeper.ExtendSleep(0.2f);
                return(true);
            }

            if (abilityHelper.UseAbilityIfCondition(this.focusFire, this.powershot))
            {
                return(true);
            }

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

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

            return(false);
        }
Пример #26
0
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            var abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

            if (abilityHelper.UseDoubleBlinkCombo(this.force, this.blink))
            {
                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.CanBeCastedIfCondition(this.blink, this.crush))
            {
                if (abilityHelper.UseAbility(this.bkb))
                {
                    return(true);
                }
            }

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

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

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

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

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

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

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

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

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

            if (!abilityHelper.CanBeCasted(this.crush) && abilityHelper.UseAbility(this.amplify))
            {
                return(true);
            }

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

            return(false);
        }
Пример #27
0
        // Token: 0x060009A3 RID: 2467 RVA: 0x0002A098 File Offset: 0x00028298
        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.blade, true))
            {
                return(true);
            }
            if (abilityHelper.CanBeCasted(this.blade, false, true, true, true) && !abilityHelper.CanBeCasted(this.blade, true, true, true, true) && abilityHelper.UseAbility(this.blink, 200f, 0f))
            {
                return(true);
            }
            if (abilityHelper.UseDoubleBlinkCombo(this.force, this.blink, 0f))
            {
                return(true);
            }
            if (abilityHelper.CanBeCastedIfCondition(this.blink, new UsableAbility[]
            {
                this.call
            }) && abilityHelper.UseAbility(this.bkb, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.call, true))
            {
                this.call.Sleeper.ExtendSleep(1f);
                return(true);
            }
            if (abilityHelper.CanBeCasted(this.meteor, true, true, true, true) && targetManager.Target.HasModifier("modifier_axe_berserkers_call") && abilityHelper.UseAbility(this.meteor, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbilityIfCondition(this.blink, new UsableAbility[]
            {
                this.call
            }))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.force, 500f, 0f))
            {
                return(true);
            }
            if (!abilityHelper.CanBeCasted(this.call, false, true, true, true) && abilityHelper.UseAbility(this.bladeMail, 400f))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.mjollnir, 400f))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.shiva, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.dagon, true))
            {
                return(true);
            }
            if (abilityHelper.CanBeCasted(this.hunger, true, true, true, true))
            {
                if (abilityHelper.CanBeCasted(this.call, true, true, true, true))
                {
                    return(false);
                }
                if (abilityHelper.CanBeCasted(this.meteor, true, true, true, true))
                {
                    DisableAbility disableAbility = this.call;
                    if (disableAbility != null && disableAbility.Sleeper.IsSleeping)
                    {
                        return(false);
                    }
                }
                if (abilityHelper.UseAbility(this.hunger, true))
                {
                    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.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);
        }
Пример #29
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);
        }
Пример #30
0
        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.blade))
            {
                return(true);
            }

            if (abilityHelper.CanBeCasted(this.blade, false) && !abilityHelper.CanBeCasted(this.blade))
            {
                if (abilityHelper.UseAbility(this.blink, 200, 0))
                {
                    return(true);
                }
            }

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

            if (abilityHelper.CanBeCastedIfCondition(this.blink, this.call))
            {
                if (abilityHelper.UseAbility(this.bkb))
                {
                    return(true);
                }
            }

            if (abilityHelper.UseAbility(this.call))
            {
                this.call.Sleeper.ExtendSleep(1);
                return(true);
            }

            if (abilityHelper.CanBeCasted(this.meteor))
            {
                if (targetManager.Target.HasModifier("modifier_axe_berserkers_call") && abilityHelper.UseAbility(this.meteor))
                {
                    return(true);
                }
            }

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

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

            if (!abilityHelper.CanBeCasted(this.call, false))
            {
                if (abilityHelper.UseAbility(this.bladeMail, 400))
                {
                    return(true);
                }
            }

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

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

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

            if (abilityHelper.CanBeCasted(this.hunger))
            {
                if (abilityHelper.CanBeCasted(this.call))
                {
                    return(false);
                }

                if (abilityHelper.CanBeCasted(this.meteor) && this.call?.Sleeper.IsSleeping == true)
                {
                    return(false);
                }

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

            return(false);
        }