예제 #1
0
 // Token: 0x060004E5 RID: 1253 RVA: 0x000048C5 File Offset: 0x00002AC5
 public override bool Orbwalk(Unit9 target, bool attack, bool move, ComboModeMenu comboMenu = null)
 {
     return(!this.morphling.IsMorphed && base.Orbwalk(target, attack, move, comboMenu));
 }
예제 #2
0
        // Token: 0x060003DA RID: 986 RVA: 0x0001597C File Offset: 0x00013B7C
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            AbilityHelper abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

            return(abilityHelper.UseAbility(this.bkb, 600f) || abilityHelper.UseAbility(this.bladeMail, 400f) || abilityHelper.UseAbility(this.shiva, true) || abilityHelper.UseAbility(this.plasma, true) || abilityHelper.UseAbility(this.halberd, true) || abilityHelper.UseAbility(this.force, 550f, 300f) || abilityHelper.UseAbility(this.pike, 550f, 300f) || abilityHelper.UseAbility(this.link, true) || abilityHelper.UseAbility(this.storm, true) || abilityHelper.UseAbility(this.phase, true));
        }
예제 #3
0
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            var abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            if (abilityHelper.UseAbility(this.omni))
            {
                this.slash?.Sleeper.Sleep(0.2f);
                return(true);
            }

            if (abilityHelper.UseAbility(this.slash))
            {
                this.omni?.Sleeper.Sleep(0.2f);
                return(true);
            }

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

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

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

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

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

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

            return(false);
        }
예제 #5
0
        // Token: 0x06000332 RID: 818 RVA: 0x00012EF4 File Offset: 0x000110F4
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            AbilityHelper abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

            return(abilityHelper.UseAbility(this.hex, true) || abilityHelper.UseAbility(this.abyssal, true) || abilityHelper.UseAbility(this.orchid, true) || abilityHelper.UseAbility(this.bloodthorn, true) || abilityHelper.UseAbility(this.blink, 400f, 0f) || abilityHelper.UseAbility(this.nullifier, true) || abilityHelper.UseAbility(this.diffusal, true) || abilityHelper.UseAbility(this.pounce, true) || abilityHelper.UseAbility(this.silver, true) || abilityHelper.UseAbility(this.shadow, true) || abilityHelper.UseAbility(this.pact, true) || abilityHelper.UseAbility(this.dance, true) || abilityHelper.UseAbility(this.phase, true));
        }
예제 #6
0
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            var abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

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

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

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

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

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

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

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

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

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

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

            if (!this.Owner.IsAttackImmune && !abilityHelper.CanBeCasted(this.shroud))
            {
                if (abilityHelper.UseAbility(this.bladeMail, 500))
                {
                    return(true);
                }
            }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            return(false);
        }
예제 #8
0
        // Token: 0x0600038C RID: 908 RVA: 0x00014284 File Offset: 0x00012484
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            AbilityHelper abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);
            Unit9         target        = targetManager.Target;

            if (this.UltCombo(targetManager, abilityHelper))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.hex, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.bloodthorn, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.orchid, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.veil, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.nullifier, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.ethereal, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.pike, 800f, 400f))
            {
                return(true);
            }
            if (abilityHelper.CanBeCasted(this.pike, true, true, true, true) && !base.MoveSleeper.IsSleeping && this.pike.UseAbilityOnTarget(targetManager, base.ComboSleeper))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.manta, base.Owner.GetAttackRange(null, 0f)))
            {
                return(true);
            }
            IEnumerable <NukeAbility> enumerable;

            if (target.GetAngle(base.Owner.Position, false) <= 1f && target.IsMoving)
            {
                enumerable = from x in this.razes
                             orderby x.Ability.Id descending
                             select x;
            }
            else
            {
                enumerable = from x in this.razes
                             orderby x.Ability.Id
                             select x;
            }
            foreach (NukeAbility nukeAbility in enumerable)
            {
                if (abilityHelper.CanBeCasted(nukeAbility, true, true, true, true) && !this.RazeCanWaitAttack(nukeAbility, target) && abilityHelper.UseAbility(nukeAbility, true))
                {
                    return(true);
                }
            }
            return(false);
        }
예제 #9
0
        public Vector3 GetMovePosition(TargetManager targetManager, ComboModeMenu comboModeMenu, bool windrun)
        {
            var menu = comboModeMenu.GetAbilitySettingsMenu <ShackleshotMenu>(this);

            if (!menu.MoveToShackle)
            {
                return(Vector3.Zero);
            }

            var target = targetManager.Target;

            if (target.IsMoving && this.Owner.Speed * (windrun ? 1.5f : 0.9f) < target.Speed)
            {
                return(Vector3.Zero);
            }

            var possiblePositions = new List <Vector3>();
            var targetPosition    = target.Position;

            foreach (var unit in targetManager.EnemyUnits)
            {
                if (unit.Equals(target))
                {
                    continue;
                }

                if (unit.Distance(target) > this.shackleshot.ShackleRange)
                {
                    continue;
                }

                var p1 = unit.Position.Extend2D(targetPosition, -200);
                var p2 = targetPosition.Extend2D(unit.Position, -200);

                if (this.Owner.Distance(p1) < 500 && !unit.IsBlockingAbilities)
                {
                    possiblePositions.Add(p1);
                }

                if (this.Owner.Distance(p2) < 500 && !target.IsBlockingAbilities)
                {
                    possiblePositions.Add(p2);
                }
            }

            if (!target.IsBlockingAbilities)
            {
                foreach (var tree in EntityManager9.Trees)
                {
                    if (targetPosition.Distance2D(tree.Position) > this.shackleshot.ShackleRange)
                    {
                        continue;
                    }

                    var p1 = targetPosition.Extend2D(tree.Position, -200);

                    if (this.Owner.Distance(p1) < 500)
                    {
                        possiblePositions.Add(p1);
                    }
                }
            }

            if (possiblePositions.Count > 0)
            {
                return(possiblePositions.OrderBy(x => this.Owner.Distance(x)).First());
            }

            return(Vector3.Zero);
        }
예제 #10
0
        // Token: 0x06000599 RID: 1433 RVA: 0x0001C4B0 File Offset: 0x0001A6B0
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            if (targetManager.TargetSleeper.IsSleeping)
            {
                return(false);
            }
            AbilityHelper abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

            if (abilityHelper.UseAbility(this.blink, 550f, 400f))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.force, 550f, 400f))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.pike, 550f, 400f))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.hex, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.atos, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.orchid, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.bloodthorn, true))
            {
                return(true);
            }
            if (abilityHelper.UseKillStealAbility(this.dragon, false))
            {
                return(true);
            }
            if (abilityHelper.UseKillStealAbility(this.laguna, true))
            {
                base.ComboSleeper.ExtendSleep(0.2f);
                return(true);
            }
            if (abilityHelper.UseAbilityIfAny(this.euls, new UsableAbility[]
            {
                this.array
            }))
            {
                return(true);
            }
            if (abilityHelper.CanBeCasted(this.euls, false, true, true, true) && abilityHelper.CanBeCasted(this.array, false, true, true, true) && base.Owner.Speed > targetManager.Target.Speed + 50f)
            {
                this.preventAttackSleeper.Sleep(0.5f);
                return(true);
            }
            if (abilityHelper.UseAbility(this.array, false))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.laguna, true))
            {
                base.ComboSleeper.ExtendSleep(0.2f);
                return(true);
            }
            return(abilityHelper.UseAbility(this.dragon, false) || (abilityHelper.CanBeCasted(this.pike, true, true, true, true) && !base.MoveSleeper.IsSleeping && this.pike.UseAbilityOnTarget(targetManager, base.ComboSleeper)) || abilityHelper.UseAbility(this.phase, true));
        }
예제 #11
0
        // Token: 0x06000412 RID: 1042 RVA: 0x0001662C File Offset: 0x0001482C
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            AbilityHelper abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

            if (abilityHelper.UseAbility(this.bloodthorn, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.nullifier, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.ethereal, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.dagon, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.shiva, true))
            {
                return(true);
            }
            if (targetManager.Target.HasModifier("modifier_pudge_meat_hook"))
            {
                if (abilityHelper.CanBeCasted(this.bloodthorn, true, false, true, true))
                {
                    abilityHelper.ForceUseAbility(this.bloodthorn, false, true);
                    return(true);
                }
                if (abilityHelper.CanBeCasted(this.nullifier, true, false, true, true))
                {
                    if (!targetManager.Target.Abilities.Any((Ability9 x) => x.Id == AbilityId.item_aeon_disk && x.IsReady))
                    {
                        abilityHelper.ForceUseAbility(this.nullifier, false, true);
                        return(true);
                    }
                }
                if (abilityHelper.CanBeCasted(this.ethereal, true, false, true, true))
                {
                    abilityHelper.ForceUseAbility(this.ethereal, false, true);
                    return(true);
                }
                if (abilityHelper.UseAbility(this.dagon, true))
                {
                    return(true);
                }
                if (abilityHelper.UseAbility(this.vessel, true))
                {
                    return(true);
                }
                if (abilityHelper.UseAbility(this.urn, true))
                {
                    return(true);
                }
            }
            if (!abilityHelper.CanBeCasted(this.dismember, true, true, true, true))
            {
                return(abilityHelper.UseAbilityIfCondition(this.blink, new UsableAbility[]
                {
                    this.dismember
                }) || abilityHelper.UseAbility(this.blink, 800f, 25f) || abilityHelper.UseAbility(this.atos, true) || (abilityHelper.CanBeCasted(this.force, true, true, true, true) && this.force.UseAbilityOnTarget(targetManager, base.ComboSleeper)) || abilityHelper.UseAbility(this.force, 400f, 800f) || abilityHelper.UseAbility(this.hook, true) || (abilityHelper.CanBeCasted(this.rot, false, false, true, true) && this.rot.AutoToggle(targetManager)));
            }
            if (abilityHelper.CanBeCasted(this.bloodthorn, true, false, true, true))
            {
                abilityHelper.ForceUseAbility(this.bloodthorn, false, true);
                return(true);
            }
            if (abilityHelper.CanBeCasted(this.nullifier, true, false, true, true))
            {
                if (!targetManager.Target.Abilities.Any((Ability9 x) => x.Id == AbilityId.item_aeon_disk && x.IsReady))
                {
                    abilityHelper.ForceUseAbility(this.nullifier, false, true);
                    return(true);
                }
            }
            if (abilityHelper.CanBeCasted(this.ethereal, true, false, true, true))
            {
                abilityHelper.ForceUseAbility(this.ethereal, false, true);
                return(true);
            }
            if (abilityHelper.UseAbility(this.dagon, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.bladeMail, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.vessel, true))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.urn, true))
            {
                return(true);
            }
            abilityHelper.ForceUseAbility(this.dismember, false, true);
            return(true);
        }
예제 #12
0
 // Token: 0x0600059A RID: 1434 RVA: 0x00004EF2 File Offset: 0x000030F2
 protected override bool Attack(Unit9 target, ComboModeMenu comboMenu)
 {
     return(!this.preventAttackSleeper.IsSleeping && base.Attack(target, comboMenu));
 }
예제 #13
0
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            var abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

            switch (comboModeMenu)
            {
            case EarthshakerComboModeMenu shakerMenu when shakerMenu.PreferEnchantTotem:
                return(this.TotemCombo(targetManager, abilityHelper));

            case EarthshakerEchoSlamComboModeMenu _:
                return(this.EchoSlamCombo(targetManager, abilityHelper));
            }

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

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

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

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

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

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

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

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

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

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

            if (abilityHelper.UseAbility(this.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);
        }
예제 #15
0
        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);
        }
예제 #16
0
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            if (comboModeMenu.IsHarassCombo)
            {
                return(false);
            }

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

            if (abilityHelper.CanBeCasted(this.blink) && !abilityHelper.CanBeCasted(this.xReturn))
            {
                var blinkEnemyRange = 0f;

                if (!abilityHelper.CanBeCasted(this.xMark))
                {
                    if (abilityHelper.CanBeCasted(this.xMark, false))
                    {
                        blinkEnemyRange = Math.Min(
                            this.xMark.Ability.CastRange - 100,
                            Math.Max(this.Owner.Distance(targetManager.Target) - this.xMark.Ability.CastRange, 0));
                    }

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

            if (abilityHelper.UseAbilityIfAny(this.xMark, this.torrent, this.ship))
            {
                this.ComboSleeper.ExtendSleep(0.1f);
                this.OrbwalkSleeper.ExtendSleep(0.1f);
                return(true);
            }

            if (abilityHelper.CanBeCasted(this.xReturn))
            {
                if (!this.xMark.Position.IsZero)
                {
                    if (abilityHelper.CanBeCasted(this.ship, false))
                    {
                        if (this.ship.UseAbility(this.xMark.Position, targetManager, this.ComboSleeper))
                        {
                            return(true);
                        }
                    }

                    if (abilityHelper.CanBeCasted(this.torrent, false))
                    {
                        if (this.torrent.UseAbility(this.xMark.Position, targetManager, this.ComboSleeper))
                        {
                            return(true);
                        }
                    }

                    if (this.torrent.ShouldReturn(this.xReturn.Ability, this.xMark.Position) ||
                        this.ship?.ShouldReturn(this.xReturn.Ability, this.xMark.Position) == true)
                    {
                        if (abilityHelper.UseAbility(this.xReturn))
                        {
                            return(true);
                        }
                    }
                }
            }
            else
            {
                if (abilityHelper.UseAbility(this.torrent))
                {
                    return(true);
                }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            return(false);
        }
예제 #18
0
 private void KeyOnValueChanged(object sender, KeyEventArgs e)
 {
     this.updateHandler.IsEnabled = e.NewValue;
     this.comboModeMenu           = this.comboMenus[(MenuHoldKey)sender];
 }
예제 #19
0
        // Token: 0x0600054A RID: 1354 RVA: 0x0001B424 File Offset: 0x00019624
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            AbilityHelper abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

            if (abilityHelper.UseAbility(this.polarity, true))
            {
                return(true);
            }
            if (!abilityHelper.CanBeCasted(this.polarity, false, false, false, true) && !abilityHelper.CanBeCasted(this.skewer, true, true, true, true) && abilityHelper.UseAbility(this.shiva, true))
            {
                return(true);
            }
            if (abilityHelper.UseDoubleBlinkCombo(this.force, this.blink, 0f))
            {
                return(true);
            }
            if (abilityHelper.UseAbilityIfCondition(this.blink, new UsableAbility[]
            {
                this.polarity
            }))
            {
                UpdateManager.BeginInvoke(delegate
                {
                    this.polarity.ForceUseAbility(targetManager, this.ComboSleeper, comboModeMenu);
                }, 50);
                return(true);
            }
            if (abilityHelper.UseAbility(this.force, 500f, 100f))
            {
                return(true);
            }
            if (abilityHelper.UseAbility(this.skewer, true))
            {
                return(true);
            }
            if (abilityHelper.CanBeCasted(this.skewer, false, false, true, true))
            {
                bool flag  = abilityHelper.CanBeCasted(this.blink, false, false, true, true);
                bool flag2 = abilityHelper.CanBeCasted(this.force, false, false, true, true);
                if (this.skewer.UseAbilityIfCondition(targetManager, base.ComboSleeper, comboModeMenu, this.polarity, flag, flag2))
                {
                    return(true);
                }
            }
            if (abilityHelper.UseAbilityIfCondition(this.skewer, new UsableAbility[]
            {
                this.blink,
                this.force
            }))
            {
                return(true);
            }
            if (abilityHelper.CanBeCasted(this.skewer, false, false, true, true) && abilityHelper.CanBeCasted(this.shockwave, false, true, true, true) && !abilityHelper.CanBeCasted(this.polarity, false, false, true, true) && this.skewer.UseAbilityOnTarget(targetManager, base.ComboSleeper))
            {
                return(true);
            }
            if (abilityHelper.UseAbilityIfCondition(this.shockwave, new UsableAbility[]
            {
                this.blink,
                this.force,
                this.skewer,
                this.polarity
            }))
            {
                return(true);
            }
            if ((abilityHelper.CanBeCasted(this.refresher, true, true, true, true) || abilityHelper.CanBeCasted(this.refresherShard, true, true, true, true)) && abilityHelper.CanBeCasted(this.polarity, true, true, true, false) && !this.polarity.Ability.IsReady)
            {
                UntargetableAbility untargetableAbility = abilityHelper.CanBeCasted(this.refresherShard, true, true, true, true) ? this.refresherShard : this.refresher;
                if (abilityHelper.HasMana(new UsableAbility[]
                {
                    this.polarity,
                    untargetableAbility
                }) && abilityHelper.UseAbility(untargetableAbility, true))
                {
                    return(true);
                }
            }
            return(false);
        }
예제 #20
0
        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);
        }
예제 #21
0
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            var abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

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

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

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

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

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

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

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

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

            if (!abilityHelper.CanBeCasted(this.avalanche, false) && abilityHelper.UseAbility(this.volley))
            {
                return(true);
            }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            return(false);
        }
예제 #23
0
        // Token: 0x06000845 RID: 2117 RVA: 0x00025E80 File Offset: 0x00024080
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            Unit9 target = targetManager.Target;

            return(this.Buffs.Use(target, comboModeMenu, new AbilityId[0]) || this.Shields.Use(target, comboModeMenu, new AbilityId[0]) || this.Debuffs.UseAmplifiers(target, comboModeMenu) || this.Disables.UseBlinkDisable(target, comboModeMenu) || this.Disables.Use(target, comboModeMenu, new AbilityId[0]) || this.Debuffs.Use(target, comboModeMenu, new AbilityId[0]) || this.Nukes.Use(target, comboModeMenu, new AbilityId[0]) || this.Harasses.Use(target, comboModeMenu, new AbilityId[0]) || this.Specials.Use(target, comboModeMenu, new AbilityId[0]) || this.Blinks.Use(target, comboModeMenu, new AbilityId[0]));
        }
예제 #24
0
        protected virtual bool ShouldCastBuff(Unit9 target, BlinkAbilityGroup blinks, ComboModeMenu menu)
        {
            var distance    = this.Ability.Owner.Distance(target);
            var attackRange = this.Ability.Owner.GetAttackRange(target);

            if (blinks.GetBlinkAbilities(this.Ability.Owner, menu).Any(x => x.Blink.Range > distance - attackRange))
            {
                return(true);
            }

            if (distance > attackRange + 125)
            {
                return(false);
            }

            return(true);
        }
예제 #25
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);
        }
예제 #26
0
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            var abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);

            if (abilityHelper.UseAbility(this.blink, 400, 200))
            {
                this.rolling?.Sleeper.Sleep(0.8f);
                this.ComboSleeper.ExtendSleep(0.1f);
                return(true);
            }

            if (abilityHelper.UseAbility(this.force, 400, 200))
            {
                this.rolling?.Sleeper.Sleep(0.8f);
                this.ComboSleeper.ExtendSleep(0.1f);
                return(true);
            }

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

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

                if (abilityHelper.CanBeCasted(this.stone, false))
                {
                    if (abilityHelper.ForceUseAbility(this.stone, true))
                    {
                        this.smash?.Sleeper.Sleep(1f);
                        return(true);
                    }
                }
                else
                {
                    if (abilityHelper.ForceUseAbility(this.rolling, true))
                    {
                        return(true);
                    }
                }
            }

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

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

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

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

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

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

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

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

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

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

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

            return(false);
        }
예제 #27
0
        public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
        {
            if (comboModeMenu.IsHarassCombo)
            {
                return(false);
            }

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

            if (abilityHelper.UseAbility(this.refraction, 1300))
            {
                return(true);
            }

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

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

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

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

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

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

            if (abilityHelper.CanBeCasted(this.meld, false))
            {
                this.preventAttackSleeper.Sleep(0.05f);

                if (!this.AttackSleeper.IsSleeping && abilityHelper.UseAbility(this.meld))
                {
                    var attackDelay = this.Owner.GetAttackPoint() + 0.1f;
                    this.ComboSleeper.ExtendSleep(attackDelay);
                    this.MoveSleeper.Sleep(attackDelay);
                    this.AttackSleeper.Sleep(attackDelay);
                    return(true);
                }
            }

            //if (abilityHelper.CanBeCasted(this.pike) && !MoveSleeper.Sleeping)
            //{
            //    if (this.pike.UseAbilityOnTarget(targetManager, ComboSleeper))
            //    {
            //        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.CanBeCasted(this.blink) || this.Owner.Distance(targetManager.Target) < 1000)
            {
                if (abilityHelper.UseAbility(this.trap))
                {
                    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.hex))
            {
                return(true);
            }

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

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

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

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

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

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

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

            if (this.end.Ability.IsChanneling)
            {
                if (targetManager.Target.HasModifier("modifier_oracle_purifying_flames"))
                {
                    if (this.Owner.BaseUnit.Stop())
                    {
                        this.ComboSleeper.Sleep(0.1f);
                        return(true);
                    }
                }
            }

            if (abilityHelper.CanBeCasted(this.flames, true, true, false))
            {
                if (this.end.Ability.IsChanneling && !this.end.FullChannelTime(comboModeMenu))
                {
                    if (abilityHelper.ForceUseAbility(this.flames))
                    {
                        return(true);
                    }
                }
            }

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

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

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

            return(false);
        }
예제 #29
0
 // Token: 0x06000897 RID: 2199 RVA: 0x000064D7 File Offset: 0x000046D7
 public override bool CanBeCasted(Unit9 target, ComboModeMenu menu, bool canHitCheck = true)
 {
     return(base.CanBeCasted(target, menu, canHitCheck) && target.Mana >= 100f);
 }
 // Token: 0x060008E7 RID: 2279 RVA: 0x000067CF File Offset: 0x000049CF
 public virtual bool CanBeCasted(Unit9 target, List <OldDisableAbility> disables, List <OldSpecialAbility> specials, ComboModeMenu menu)
 {
     return(this.CanBeCasted(target, menu, true));
 }