コード例 #1
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);
        }
コード例 #2
0
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            var abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            return(false);
        }
コード例 #4
0
        // Token: 0x060005AB RID: 1451 RVA: 0x0001C918 File Offset: 0x0001AB18
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            AbilityHelper abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

            return(abilityHelper.UseAbility(this.blink, 550f, 350f) || abilityHelper.UseAbility(this.veil, true) || abilityHelper.UseAbility(this.shiva, true) || abilityHelper.UseAbility(this.ethereal, true) || abilityHelper.UseAbility(this.hex, true) || abilityHelper.UseAbility(this.atos, true) || abilityHelper.UseAbilityIfAny(this.euls, new UsableAbility[]
            {
                this.splitEarth
            }) || (abilityHelper.CanBeCasted(this.nova, false, false, true, true) && this.nova.AutoToggle(targetManager)) || abilityHelper.UseAbilityIfCondition(this.diabolic, new UsableAbility[]
            {
                this.splitEarth
            }) || abilityHelper.UseAbility(this.lightning, true) || abilityHelper.UseAbilityIfNone(this.splitEarth, new UsableAbility[]
            {
                this.lightning,
                this.euls,
                this.atos
            }));
        }
コード例 #5
0
        // Token: 0x06000656 RID: 1622 RVA: 0x0001ED0C File Offset: 0x0001CF0C
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            AbilityHelper abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

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

            return(abilityHelper.UseAbility(this.nullifier, true) || abilityHelper.UseAbility(this.bloodthorn, true) || abilityHelper.UseAbility(this.orchid, true) || abilityHelper.UseAbility(this.halberd, true) || abilityHelper.UseAbility(this.charge, true) || abilityHelper.UseAbility(this.bulldoze, 500f) || abilityHelper.UseAbility(this.bladeMail, 400f) || abilityHelper.UseAbility(this.vessel, true) || abilityHelper.UseAbility(this.urn, true) || abilityHelper.UseAbility(this.strike, true) || abilityHelper.UseAbilityIfNone(this.mom, new UsableAbility[]
            {
                this.charge,
                this.bulldoze,
                this.strike
            }) || abilityHelper.UseAbility(this.phase, true));
        }
コード例 #7
0
        // Token: 0x060003A4 RID: 932 RVA: 0x00014B84 File Offset: 0x00012D84
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            AbilityHelper abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

            if (abilityHelper.CanBeCastedIfCondition(this.epicenter, new UsableAbility[]
            {
                this.blink,
                this.burrow
            }))
            {
                if (abilityHelper.UseAbility(this.sandstorm, true))
                {
                    return(true);
                }
                if (abilityHelper.UseAbility(this.epicenter, true))
                {
                    return(true);
                }
            }
            if (abilityHelper.UseDoubleBlinkCombo(this.force, this.blink, 300f))
            {
                return(true);
            }
            if (abilityHelper.UseBlinkLineCombo(this.blink, this.burrow))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.burrow, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.force, 800f, this.burrow.Ability.CastRange))
            {
                return(true);
            }
            float num = base.Owner.Distance(targetManager.Target);

            if (num < 450f && abilityHelper.UseAbility(this.veil, true))
            {
                return(true);
            }
            if (num < 450f && abilityHelper.UseAbility(this.shiva, true))
            {
                return(true);
            }
            if (base.Owner.HasModifier("modifier_sand_king_epicenter") && num < 450f && abilityHelper.UseAbilityIfNone(this.sandstorm, new UsableAbility[]
            {
                this.epicenter,
                this.burrow
            }))
            {
                base.ComboSleeper.Sleep(0.2f);
                return(true);
            }
            return(false);
        }
コード例 #8
0
        // Token: 0x0600035F RID: 863 RVA: 0x000138C4 File Offset: 0x00011AC4
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            AbilityHelper abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

            return(abilityHelper.UseAbility(this.atos, true) || abilityHelper.UseAbility(this.hex, true) || abilityHelper.UseAbility(this.nullifier, true) || abilityHelper.UseAbility(this.seal, true) || abilityHelper.UseAbility(this.ethereal, true) || abilityHelper.UseAbility(this.dagon, true) || abilityHelper.UseAbility(this.concussive, true) || abilityHelper.UseAbility(this.veil, true) || abilityHelper.UseAbility(this.blink, 850f, 600f) || abilityHelper.UseAbility(this.force, 850f, 600f) || abilityHelper.UseAbilityIfNone(this.flare, new UsableAbility[]
            {
                this.atos
            }) || abilityHelper.UseAbility(this.bolt, true));
        }
コード例 #9
0
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            var abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

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

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

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

            if (!abilityHelper.CanBeCasted(this.timeWalk, false) || this.Owner.Distance(targetManager.Target) < 400)
            {
                if (abilityHelper.UseAbility(this.chronosphere))
                {
                    return(true);
                }
            }

            if (abilityHelper.UseAbilityIfCondition(this.timeWalk, this.chronosphere))
            {
                return(true);
            }

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

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

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

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

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

            if (!abilityHelper.CanBeCasted(this.chronosphere, false, false))
            {
                if (abilityHelper.UseAbilityIfNone(this.mom, this.timeWalk))
                {
                    return(true);
                }
            }

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

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

            return(false);
        }
コード例 #10
0
        // Token: 0x060003B9 RID: 953 RVA: 0x0001503C File Offset: 0x0001323C
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            AbilityHelper    abilityHelper    = new AbilityHelper(targetManager, comboModeMenu, this);
            TricksOfTheTrade tricksOfTheTrade = this.tricks;

            if (tricksOfTheTrade != null && tricksOfTheTrade.CancelChanneling(targetManager))
            {
                base.ComboSleeper.Sleep(0.1f);
                return(true);
            }
            return(abilityHelper.UseAbility(this.blinkStrike, true) || abilityHelper.UseAbility(this.abyssal, true) || abilityHelper.UseAbility(this.nullifier, true) || abilityHelper.UseAbility(this.bloodthorn, true) || abilityHelper.UseAbility(this.orchid, true) || abilityHelper.UseAbility(this.diffusal, true) || abilityHelper.UseAbility(this.solar, true) || abilityHelper.UseAbility(this.medallion, true) || (!abilityHelper.CanBeCasted(this.blinkStrike, true, true, true, true) && abilityHelper.UseAbility(this.blink, 500f, 0f)) || abilityHelper.UseAbilityIfNone(this.smoke, new UsableAbility[]
            {
                this.blinkStrike
            }) || abilityHelper.UseAbility(this.tricks, true) || abilityHelper.UseAbility(this.phase, true));
        }
コード例 #11
0
        // Token: 0x0600078B RID: 1931 RVA: 0x00022F68 File Offset: 0x00021168
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            AbilityHelper abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            if (abilityHelper.CanBeCastedIfCondition(this.epicenter, this.blink, this.burrow))
            {
                if (abilityHelper.UseAbility(this.sandstorm))
                {
                    return(true);
                }

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

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

            if (abilityHelper.UseBlinkLineCombo(this.blink, this.burrow))
            {
                return(true);
            }

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

            if (abilityHelper.UseAbility(this.force, 800, this.burrow.Ability.CastRange))
            {
                return(true);
            }

            var distance = this.Owner.Distance(targetManager.Target);

            if (distance < 450 && abilityHelper.UseAbility(this.veil))
            {
                return(true);
            }

            if (distance < 450 && abilityHelper.UseAbility(this.shiva))
            {
                return(true);
            }

            if (this.Owner.HasModifier("modifier_sand_king_epicenter") && distance < 450)
            {
                if (abilityHelper.UseAbilityIfNone(this.sandstorm, this.epicenter, this.burrow))
                {
                    this.ComboSleeper.Sleep(0.2f);
                    return(true);
                }
            }

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

            if (!comboModeMenu.IsHarassCombo && this.drain?.Ability.IsChanneling == true)
            {
                if (abilityHelper.CanBeCasted(this.hex, true, true, false) || abilityHelper.CanBeCasted(this.impale, true, true, false))
                {
                    this.Owner.BaseUnit.Stop();
                    this.ComboSleeper.Sleep(0.05f);
                    return(true);
                }
            }

            if (abilityHelper.UseKillStealAbility(this.finger))
            {
                return(true);
            }

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

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

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

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

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

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

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

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

            if (abilityHelper.UseAbilityIfNone(this.finger, this.hex, this.impale))
            {
                return(true);
            }

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

            return(false);
        }
コード例 #15
0
        // Token: 0x06000231 RID: 561 RVA: 0x0000F86C File Offset: 0x0000DA6C
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            AbilityHelper abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);
            Unit9         target        = targetManager.Target;
            float         num           = base.Owner.Distance(target);
            float         attackRange   = base.Owner.GetAttackRange(target, 0f);

            if (num < 225f || num > 575f)
            {
                if (base.Owner.IsRanged && abilityHelper.UseAbility(this.rage, true))
                {
                    return(true);
                }
            }
            else if (!base.Owner.IsRanged && abilityHelper.UseAbility(this.rage, true))
            {
                return(true);
            }
            return(abilityHelper.UseAbility(this.blink, 550f, 0f) || abilityHelper.UseAbility(this.abyssal, true) || abilityHelper.UseAbility(this.hex, true) || abilityHelper.UseAbility(this.diffusal, true) || abilityHelper.UseAbility(this.orchid, true) || abilityHelper.UseAbility(this.bloodthorn, true) || abilityHelper.UseAbility(this.nullifier, true) || abilityHelper.UseAbility(this.axeMelee, true) || (!base.Owner.IsRanged && num > 200f && abilityHelper.CanBeCastedHidden(this.axeRanged) && this.axeRanged.CanHit(targetManager, comboModeMenu) && abilityHelper.UseAbility(this.rage, true)) || abilityHelper.UseAbility(this.axeRanged, true) || abilityHelper.UseAbility(this.trance, attackRange) || abilityHelper.UseAbility(this.phase, true) || (!base.Owner.IsRanged && abilityHelper.UseAbilityIfNone(this.mom, new UsableAbility[]
            {
                this.axeMelee,
                this.trance
            })));
        }
コード例 #16
0
ファイル: SpiritBreaker.cs プロジェクト: vana41203/O9K
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            if (this.Owner.IsCharging)
            {
                return(false);
            }

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

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

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

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

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

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

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

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

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

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

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

            if (abilityHelper.UseAbilityIfNone(this.mom, this.charge, this.bulldoze, this.strike))
            {
                return(true);
            }

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

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

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

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

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

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

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

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

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

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

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

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

            if (abilityHelper.UseAbilityIfNone(this.flare, this.atos))
            {
                return(true);
            }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            return(false);
        }
コード例 #19
0
ファイル: Tusk.cs プロジェクト: ihatevim/Divine.Plugins
        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
        // Token: 0x06000914 RID: 2324 RVA: 0x000289B8 File Offset: 0x00026BB8
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            AbilityHelper abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

            return(abilityHelper.UseAbility(this.shiva, true) || abilityHelper.UseAbility(this.bladeMail, 400f) || abilityHelper.UseAbility(this.vacuum, true) || abilityHelper.UseAbilityIfNone(this.wall, new UsableAbility[]
            {
                this.vacuum
            }) || abilityHelper.UseAbility(this.blink, 600f, 400f) || abilityHelper.UseAbility(this.force, 600f, 400f) || abilityHelper.UseAbility(this.shell, true) || (abilityHelper.CanBeCasted(this.surge, false, false, true, true) && abilityHelper.ForceUseAbility(this.surge, false, true)));
        }
コード例 #21
0
ファイル: Leshrac.cs プロジェクト: vana41203/O9K
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            var abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

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

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

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

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

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

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

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

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

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

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

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

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

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

            var target      = targetManager.Target;
            var distance    = this.Owner.Distance(target);
            var attackRange = this.Owner.GetAttackRange(target);

            if (distance < 225 || distance > 575)
            {
                if (this.Owner.IsRanged && abilityHelper.UseAbility(this.rage))
                {
                    return(true);
                }
            }
            else
            {
                if (!this.Owner.IsRanged && abilityHelper.UseAbility(this.rage))
                {
                    return(true);
                }
            }

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

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

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

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

            if (!this.Owner.IsRanged && distance > 200 && abilityHelper.CanBeCastedHidden(this.axeRanged))
            {
                if (this.axeRanged.CanHit(targetManager, comboModeMenu) && abilityHelper.UseAbility(this.rage))
                {
                    return(true);
                }
            }

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

            if (this.Owner.HealthPercentage < 20 && abilityHelper.UseAbility(this.trance, attackRange))
            {
                return(true);
            }

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

            if (!this.Owner.IsRanged)
            {
                if (abilityHelper.UseAbilityIfNone(this.mom, this.axeMelee, this.trance))
                {
                    return(true);
                }
            }

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

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

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

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

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

            var glimpseTime = this.glimpse.Ability.TimeSinceCasted;

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

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

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

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

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

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

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

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

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

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

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

            return(false);
        }
コード例 #24
0
        // Token: 0x0600068A RID: 1674 RVA: 0x0001FA94 File Offset: 0x0001DC94
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            AbilityHelper abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

            if (abilityHelper.UseAbility(this.glimpse, true))
            {
                BlinkAbility blinkAbility = this.blink;
                if (blinkAbility != null)
                {
                    blinkAbility.Sleeper.Sleep(3f);
                }
                ForceStaff forceStaff = this.force;
                if (forceStaff != null)
                {
                    forceStaff.Sleeper.Sleep(3f);
                }
                return(true);
            }
            if (abilityHelper.CanBeCasted(this.glimpse, false, true, true, true))
            {
                if (abilityHelper.UseAbility(this.blink, this.glimpse.Ability.CastRange, this.glimpse.Ability.CastRange - 500f))
                {
                    return(true);
                }
            }
            else if (abilityHelper.UseAbility(this.blink, 800f, 500f))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.force, this.glimpse.Ability.CastRange, this.glimpse.Ability.CastRange - 500f))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.veil, true))
            {
                return(true);
            }
            float timeSinceCasted = this.glimpse.Ability.TimeSinceCasted;

            if ((double)timeSinceCasted < 1.8)
            {
                ParticleEffect particleEffect = this.glimpseParticle;
                if (particleEffect != null && particleEffect.IsValid && !targetManager.Target.IsMagicImmune)
                {
                    Vector3 controlPoint = this.glimpseParticle.GetControlPoint(1u);
                    if (abilityHelper.CanBeCasted(this.field, false, true, true, true) && this.field.UseAbility(controlPoint, base.ComboSleeper))
                    {
                        return(true);
                    }
                    float x = this.glimpseParticle.GetControlPoint(2u).X;
                    if (timeSinceCasted + 0.35f > x && abilityHelper.CanBeCasted(this.storm, false, true, true, true) && this.storm.UseAbility(controlPoint, targetManager, base.ComboSleeper))
                    {
                        return(true);
                    }
                    if (base.Owner.Distance(controlPoint) > this.storm.Ability.CastRange - 100f)
                    {
                        base.Owner.BaseUnit.Move(Vector3Extensions.Extend2D(controlPoint, base.Owner.Position, 500f));
                        return(true);
                    }
                }
                base.OrbwalkSleeper.Sleep(0.1f);
                return(true);
            }
            if (timeSinceCasted > 2f && abilityHelper.UseAbilityIfNone(this.field, new UsableAbility[]
            {
                this.glimpse
            }))
            {
                return(true);
            }
            if (abilityHelper.CanBeCasted(this.storm, true, true, true, true))
            {
                if (this.field.Ability.TimeSinceCasted <= 4f)
                {
                    if (this.storm.UseAbility(this.field.CastPosition, targetManager, base.ComboSleeper))
                    {
                        return(true);
                    }
                }
                else if (abilityHelper.UseAbility(this.storm, true))
                {
                    return(true);
                }
            }
            if (abilityHelper.CanBeCasted(this.thunder, true, true, true, true))
            {
                float num = base.Owner.Mana - this.thunder.Ability.ManaCost;
                if (abilityHelper.CanBeCasted(this.field, true, true, true, true))
                {
                    num -= this.field.Ability.ManaCost;
                }
                if (abilityHelper.CanBeCasted(this.storm, true, true, true, true))
                {
                    num -= this.storm.Ability.ManaCost;
                }
                if (num > 0f)
                {
                    abilityHelper.UseAbility(this.thunder, true);
                }
            }
            return(false);
        }