Example #1
0
        internal static void Orbwalking_AfterAttack(AttackableUnit unit, AttackableUnit target)
        {
            if (!unit.IsValid || !unit.IsMe)
            {
                return;
            }

            if (ProSeries.CanCombo())
            {
                if (ProSeries.Config.Item("usecomboq", true).GetValue <bool>() &&
                    target.IsValid <AIHeroClient>())
                {
                    Q.Cast();
                }
            }

            if (ProSeries.CanHarass())
            {
                if (ProSeries.Config.Item("useharassq", true).GetValue <bool>() &&
                    target.IsValid <AIHeroClient>() && ProSeries.IsWhiteListed((AIHeroClient)target))
                {
                    Q.Cast();
                }
            }

            if (ProSeries.CanClear())
            {
                if (ProSeries.Config.Item("useclearq", true).GetValue <bool>() &&
                    target.IsValid <Obj_AI_Minion>())
                {
                    Q.Cast();
                }
            }
        }
Example #2
0
        private static void Orbwalking_OnAfterAttack(AttackableUnit unit, AttackableUnit target)
        {
            if (!unit.IsValid || !unit.IsMe)
            {
                return;
            }

            if (ProSeries.CanCombo())
            {
                if (ProSeries.Config.Item("usecombow", true).GetValue <bool>() &&
                    target.IsValid <Obj_AI_Hero>())
                {
                    W.Cast();
                }
            }

            if (ProSeries.CanHarass())
            {
                if (ProSeries.Config.Item("useharassw", true).GetValue <bool>() &&
                    target.IsValid <Obj_AI_Hero>() && ProSeries.IsWhiteListed((Obj_AI_Hero)target))
                {
                    W.Cast();
                }
            }

            if (ProSeries.CanClear())
            {
                if (ProSeries.Config.Item("useclearw", true).GetValue <bool>() &&
                    target.IsValid <Obj_AI_Minion>())
                {
                    W.Cast();
                }
            }
        }
Example #3
0
        internal static void Game_OnUpdate(EventArgs args)
        {
            var findTargetRange = 550 + (7 * (ProSeries.Player.Level - 1)) + 65;

            if (ProSeries.CanCombo())
            {
                var etarget = TargetSelector.GetTarget(findTargetRange, TargetSelector.DamageType.Physical);
                if (etarget.IsValidTarget() && E.IsReady() && Orbwalking.InAutoAttackRange(etarget))
                {
                    if (ProSeries.Config.Item("usecomboe", true).GetValue <bool>())
                    {
                        E.CastOnUnit(etarget);
                    }
                }
            }

            if (ProSeries.CanHarass())
            {
                var etarget = TargetSelector.GetTarget(findTargetRange, TargetSelector.DamageType.Physical);
                if (!ProSeries.IsWhiteListed(etarget))
                {
                    return;
                }

                if (etarget.IsValidTarget() && E.IsReady() && Orbwalking.InAutoAttackRange(etarget))
                {
                    if (ProSeries.Config.Item("useharasse", true).GetValue <bool>())
                    {
                        E.CastOnUnit(etarget);
                    }
                }
            }

            if (R.IsReady())
            {
                var target = TargetSelector.GetTarget(findTargetRange, TargetSelector.DamageType.Physical);
                if (target.IsValidTarget() && !target.IsZombie && Orbwalking.InAutoAttackRange(target))
                {
                    if (ProSeries.Config.Item("usecombor", true).GetValue <bool>())
                    {
                        if (target.Health <= ProSeries.Player.GetSpellDamage(target, SpellSlot.R))
                        {
                            R.CastOnUnit(target);
                        }
                    }
                }
            }
        }
Example #4
0
        internal static void Game_OnUpdate(EventArgs args)
        {
            TrueRange = 545 + (7 * ProSeries.Player.Level);

            if (ProSeries.CanCombo())
            {
                var etarget = TargetSelector.GetTarget(TrueRange, TargetSelector.DamageType.Physical);
                if (etarget.IsValid <Obj_AI_Hero>() && E.IsReady())
                {
                    if (ProSeries.Config.Item("usecomboe", true).GetValue <bool>())
                    {
                        E.CastOnUnit(etarget);
                    }
                }
            }

            if (ProSeries.CanHarass())
            {
                var etarget = TargetSelector.GetTarget(TrueRange, TargetSelector.DamageType.Physical);
                if (etarget.IsValid <Obj_AI_Hero>() && ProSeries.IsWhiteListed(etarget))
                {
                    if (ProSeries.Config.Item("useharasse", true).GetValue <bool>())
                    {
                        E.CastOnUnit(etarget);
                    }
                }
            }

            if (R.IsReady())
            {
                var target = TargetSelector.GetTarget(TrueRange, TargetSelector.DamageType.Physical);
                if (target.IsValidTarget() && !target.IsZombie)
                {
                    if (ProSeries.Config.Item("usecombor", true).GetValue <bool>())
                    {
                        if (target.Health <= ProSeries.Player.GetSpellDamage(target, SpellSlot.R))
                        {
                            R.CastOnUnit(target);
                        }
                    }
                }
            }
        }
Example #5
0
        void Obj_AI_Base_OnProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
        {
            if (!sender.IsMe || !args.SData.IsAutoAttack())
            {
                return;
            }

            if (!args.Target.IsValid <AIHeroClient>())
            {
                return;
            }

            if (ProSeries.CanHarass() && Q.IsReady())
            {
                var qtarget = ObjectManager.Get <AIHeroClient>().First(x => x.NetworkId == args.Target.NetworkId);
                if (qtarget.IsValidTarget() && ProSeries.IsWhiteListed(qtarget))
                {
                    if (ProSeries.Config.Item("useharassq", true).GetValue <bool>())
                    {
                        foreach (var buff in ProSeries.Player.Buffs)
                        {
                            if (buff.Name == "AsheQ" && buff.Count >= 3)
                            {
                                Q.Cast();
                            }
                        }
                    }
                }
            }

            if (ProSeries.CanCombo() && Q.IsReady())
            {
                var qtarget = ObjectManager.Get <AIHeroClient>().First(x => x.NetworkId == args.Target.NetworkId);
                if (qtarget.IsValidTarget() && ProSeries.Player.HasBuff("asheqcastready", true))
                {
                    if (ProSeries.Config.Item("usecomboq", true).GetValue <bool>())
                    {
                        Q.Cast();
                    }
                }
            }
        }
Example #6
0
        internal static void Game_OnGameUpdate(EventArgs args)
        {
            if (ProSeries.CanCombo())
            {
                var target = TargetSelector.GetTarget(QCombo.Range, TargetSelector.DamageType.Physical);
                if (target.IsValidTarget() && ProSeries.Config.Item("usecomboq", true).GetValue <bool>())
                {
                    CastQ(false);
                }
            }

            if (ProSeries.CanHarass())
            {
                var target = TargetSelector.GetTarget(QHarass.Range, TargetSelector.DamageType.Physical);
                if (target.IsValidTarget() && ProSeries.IsWhiteListed(target))
                {
                    if (ProSeries.Config.Item("useharassq", true).GetValue <bool>())
                    {
                        CastQ(false);
                    }
                }
            }

            if (QCombo.IsReady())
            {
                foreach (var target in ObjectManager.Get <Obj_AI_Hero>().Where(h => h.IsValidTarget(QCombo.Range)))
                {
                    if (ProSeries.Config.Item("useqimm", true).GetValue <bool>())
                    {
                        QCombo.CastIfHitchanceEquals(target, HitChance.Immobile);
                    }

                    if (ProSeries.Config.Item("useqdash", true).GetValue <bool>())
                    {
                        QCombo.CastIfHitchanceEquals(target, HitChance.Dashing);
                    }
                }
            }
        }
Example #7
0
        private static float GetRDamage(AIHeroClient target)
        {
            if (target == null)
            {
                return(0f);
            }

            var units    = new List <Obj_AI_Base>();
            var maxdist  = ProSeries.Player.Distance(target.ServerPosition) > 750;
            var maxrdist = ProSeries.Config.Item("maxrdist", true).GetValue <Slider>().Value;

            // impact physical damage
            var idmg = R.IsReady() &&
                       ProSeries.CountInPath(ProSeries.Player.ServerPosition, target.ServerPosition, R.Width + 50,
                                             (maxrdist * 2), out units) <= 1
                ? (maxdist ? R.GetDamage(target, 1) : R.GetDamage(target, 0))
                : 0;

            // explosion damage
            var edmg = R.IsReady() &&
                       ProSeries.CountInPath(ProSeries.Player.ServerPosition, target.ServerPosition, R.Width + 50,
                                             (maxrdist * 2), out units) > 1 &&
                       target.Distance(units.OrderBy(x => x.Distance(ProSeries.Player.ServerPosition))
                                       .First(t => t.NetworkId != target.NetworkId).ServerPosition) <= R.Width + 100 // explosion radius? :^)
                ? (maxdist
                    ? (float)                                                                                        // maximum explosion dmage
                   (ProSeries.Player.CalcDamage(target, Damage.DamageType.Physical,
                                                new double[] { 160, 224, 288 }[R.Level - 1] +
                                                new double[] { 20, 24, 28 }[R.Level - 1] / 100 * (target.MaxHealth - target.Health) +
                                                0.8 * ProSeries.Player.FlatPhysicalDamageMod))
                    : (float) // minimum explosion damage
                   (ProSeries.Player.CalcDamage(target, Damage.DamageType.Physical,
                                                new double[] { 20, 28, 36 }[R.Level - 1] +
                                                new double[] { 20, 24, 28 }[R.Level - 1] / 100 * (target.MaxHealth - target.Health) +
                                                0.08 * ProSeries.Player.FlatPhysicalDamageMod)))
                : 0;

            return(idmg + edmg);
        }
Example #8
0
        internal static void Game_OnUpdate(EventArgs args)
        {
            if (ProSeries.CanCombo())
            {
                var qtarget = TargetSelector.GetTargetNoCollision(Q);
                if (qtarget.IsValidTarget() && Q.IsReady())
                {
                    if (ProSeries.Config.Item("usecomboq", true).GetValue <bool>())
                    {
                        Q.Cast(qtarget);
                    }
                }

                var wtarget = TargetSelector.GetTarget(W.Range, TargetSelector.DamageType.Physical);
                if (wtarget.IsValidTarget() && W.IsReady())
                {
                    if (ProSeries.Config.Item("usecombow", true).GetValue <bool>())
                    {
                        W.Cast(wtarget);
                    }
                }
            }

            if (ProSeries.CanHarass())
            {
                var qtarget = TargetSelector.GetTargetNoCollision(Q);
                if (qtarget.IsValidTarget() && Q.IsReady() && ProSeries.IsWhiteListed(qtarget))
                {
                    if (ProSeries.Config.Item("usecomboq", true).GetValue <bool>())
                    {
                        Q.Cast(qtarget);
                    }
                }

                var wtarget = TargetSelector.GetTarget(W.Range, TargetSelector.DamageType.Physical);
                if (wtarget.IsValidTarget() && W.IsReady() && ProSeries.IsWhiteListed(wtarget))
                {
                    if (ProSeries.Config.Item("useharassw", true).GetValue <bool>())
                    {
                        W.Cast(wtarget);
                    }
                }
            }

            if (Q.IsReady())
            {
                foreach (var target in ObjectManager.Get <AIHeroClient>().Where(h => h.IsValidTarget(Q.Range)))
                {
                    if (ProSeries.Config.Item("useqimm", true).GetValue <bool>())
                    {
                        Q.CastIfHitchanceEquals(target, HitChance.Immobile);
                    }

                    if (ProSeries.Config.Item("useqdash", true).GetValue <bool>())
                    {
                        Q.CastIfHitchanceEquals(target, HitChance.Dashing);
                    }
                }
            }

            if (ProSeries.CanClear())
            {
                foreach (var neutral in ProSeries.JungleMobsInRange(650))
                {
                    if (ProSeries.Config.Item("useclearq", true).GetValue <bool>())
                    {
                        Q.Cast(neutral);
                    }
                }

                foreach (var minion in ObjectManager.Get <Obj_AI_Minion>().Where(m => m.IsValidTarget(Q.Range)))
                {
                    if (ProSeries.Player.GetSpellDamage(minion, Q.Slot) >= minion.Health &&
                        ProSeries.Config.Item("useclearq", true).GetValue <bool>())
                    {
                        if (!minion.Name.Contains("Ward"))
                        {
                            Q.Cast(minion);
                        }
                    }
                }
            }

            if (ProSeries.Config.Item("usecombor", true).GetValue <bool>())
            {
                var maxDistance = ProSeries.Config.Item("maxrdist", true).GetValue <Slider>().Value;
                foreach (var target in ObjectManager.Get <AIHeroClient>().Where(h => h.IsValidTarget(maxDistance)))
                {
                    var aaDamage = Orbwalking.InAutoAttackRange(target)
                        ? ProSeries.Player.GetAutoAttackDamage(target, true)
                        : 0;

                    if (!target.IsZombie &&
                        target.Health - aaDamage <= ProSeries.Player.GetSpellDamage(target, SpellSlot.R))
                    {
                        R.Cast(target);
                    }
                }
            }
        }
Example #9
0
        internal static void Game_OnUpdate(EventArgs args)
        {
            if (ProSeries.CanCombo())
            {
                var wtarget = TargetSelector.GetTarget(W.Range, TargetSelector.DamageType.Physical);
                if (wtarget.IsValidTarget() && W.IsReady())
                {
                    if (ProSeries.Config.Item("usecombow", true).GetValue <bool>())
                    {
                        W.Cast(wtarget);
                    }
                }
            }

            if (ProSeries.CanHarass())
            {
                var wtarget = TargetSelector.GetTarget(W.Range, TargetSelector.DamageType.Physical);
                if (wtarget.IsValidTarget() && W.IsReady() && ProSeries.IsWhiteListed(wtarget))
                {
                    if (ProSeries.Config.Item("useharassw", true).GetValue <bool>())
                    {
                        W.Cast(wtarget);
                    }
                }
            }

            if (W.IsReady())
            {
                foreach (var target in ObjectManager.Get <AIHeroClient>().Where(h => h.IsValidTarget(W.Range)))
                {
                    if (ProSeries.Config.Item("usewimm", true).GetValue <bool>())
                    {
                        W.CastIfHitchanceEquals(target, HitChance.Immobile);
                    }

                    if (ProSeries.Config.Item("usewdash", true).GetValue <bool>())
                    {
                        W.CastIfHitchanceEquals(target, HitChance.Dashing);
                    }
                }
            }

            if (ProSeries.CanCombo() || ProSeries.Config.Item("usesemir", true).GetValue <KeyBind>().Active)
            {
                var maxDistance = ProSeries.Config.Item("maxrdist", true).GetValue <Slider>().Value;
                foreach (var target in ObjectManager.Get <AIHeroClient>().Where(h => h.IsValidTarget(maxDistance)))
                {
                    var aaDamage = Orbwalking.InAutoAttackRange(target)
                        ? ProSeries.Player.GetAutoAttackDamage(target, true)
                        : 0;

                    if (!target.IsZombie && R.IsReady() &&
                        (ProSeries.Player.GetSpellDamage(target, SpellSlot.R) >= target.Health - aaDamage ||
                         ProSeries.Config.Item("usesemir", true).GetValue <KeyBind>().Active))
                    {
                        var units = new List <Obj_AI_Base>();
                        if (ProSeries.CountInPath(ProSeries.Player.ServerPosition,
                                                  target.ServerPosition, R.Width, maxDistance, out units) <= 1)
                        {
                            R.Cast(target);
                        }
                    }
                }
            }
        }
Example #10
0
        private static void Game_OnGameUpdate(EventArgs args)
        {
            RocketRange = new[] { 75, 75, 100, 125, 150, 175 }[Q.Level];
            var minigunOut = ProSeries.Player.GetSpell(SpellSlot.Q).ToggleState == 1;

            if (ProSeries.CanCombo())
            {
                if (!minigunOut && ProSeries.Config.Item("usecomboq", true).GetValue <bool>())
                {
                    if (ProSeries.Player.ManaPercent < 35 &&
                        HeroManager.Enemies.Any(
                            i => i.IsValidTarget(590 + RocketRange + 10) &&
                            ProSeries.Player.GetAutoAttackDamage(i, true) * 3 < i.Health))
                    {
                        Q.Cast();
                    }
                }

                var qtarget = TargetSelector.GetTarget(525 + RocketRange + 250, TargetSelector.DamageType.Physical);
                if (qtarget.IsValidTarget() && Q.IsReady())
                {
                    if (ProSeries.Config.Item("usecomboq", true).GetValue <bool>())
                    {
                        if (minigunOut && (ProSeries.Player.ManaPercent > 35 ||
                                           ProSeries.Player.GetAutoAttackDamage(qtarget, true) * 3 > qtarget.Health) &&
                            qtarget.Distance(ProSeries.Player.ServerPosition) > 590)
                        {
                            Q.Cast();
                        }

                        if (!minigunOut && ProSeries.Player.ManaPercent < 35)
                        {
                            Q.Cast();
                        }

                        if (!minigunOut && qtarget.Distance(ProSeries.Player.ServerPosition) <= 590)
                        {
                            Q.Cast();
                        }
                    }
                }

                var wtarget = TargetSelector.GetTarget(W.Range, TargetSelector.DamageType.Physical);
                if (wtarget.IsValidTarget() && W.IsReady())
                {
                    if (ProSeries.Config.Item("usecombow", true).GetValue <bool>())
                    {
                        if (wtarget.Distance(ProSeries.Player.ServerPosition) > 525)
                        {
                            if (ProSeries.Player.GetAutoAttackDamage(wtarget, true) * 2 < wtarget.Health)
                            {
                                W.CastIfHitchanceEquals(wtarget, HitChance.High);
                            }
                        }
                    }
                }

                if (ProSeries.Config.Item("usecomboe", true).GetValue <bool>() && E.IsReady())
                {
                    foreach (var target in ObjectManager.Get <AIHeroClient>().Where(h => h.IsValidTarget(400) && h.IsMelee()))
                    {
                        E.CastIfHitchanceEquals(target, HitChance.VeryHigh);
                    }
                }
            }

            if (ProSeries.CanHarass())
            {
                var qtarget = TargetSelector.GetTarget(525 + RocketRange + 250, TargetSelector.DamageType.Physical);
                if (!qtarget.IsValidTarget() && !minigunOut)
                {
                    if (ProSeries.Config.Item("useharassq", true).GetValue <bool>())
                    {
                        Q.Cast();
                    }
                }

                if (qtarget.IsValidTarget() && Q.IsReady() && ProSeries.IsWhiteListed(qtarget))
                {
                    if (ProSeries.Config.Item("useharassq", true).GetValue <bool>())
                    {
                        if (!minigunOut && ProSeries.Player.ManaPercent < 20)
                        {
                            Q.Cast();
                        }

                        if (minigunOut && ProSeries.Player.ManaPercent > 20)
                        {
                            if (qtarget.Distance(ProSeries.Player.ServerPosition) > 590)
                            {
                                Q.Cast();
                            }
                        }

                        if (!minigunOut && qtarget.Distance(ProSeries.Player.ServerPosition) <= 590)
                        {
                            Q.Cast();
                        }
                    }
                }

                var wtarget = TargetSelector.GetTarget(W.Range, TargetSelector.DamageType.Physical);
                if (wtarget.IsValidTarget() && W.IsReady() && ProSeries.IsWhiteListed(wtarget))
                {
                    if (ProSeries.Config.Item("useharassw", true).GetValue <bool>())
                    {
                        W.CastIfHitchanceEquals(wtarget, HitChance.High);
                    }
                }
            }

            if (ProSeries.CanClear() && Q.IsReady())
            {
                if (ProSeries.Config.Item("useclearq", true).GetValue <bool>())
                {
                    if (GetCenterMinion().IsValidTarget())
                    {
                        if (minigunOut)
                        {
                            Q.Cast();
                        }

                        if (!minigunOut)
                        {
                            ProSeries.Orbwalker.ForceTarget(GetCenterMinion());
                        }
                    }

                    else
                    {
                        if (!minigunOut)
                        {
                            Q.Cast();
                        }
                    }
                }
            }

            if (ProSeries.Player.GetSpell(SpellSlot.Q).ToggleState == 2 && Q.IsReady())
            {
                if (ProSeries.Config.Item("useclearq", true).GetValue <bool>())
                {
                    if (ProSeries.Config.Item("useclear").GetValue <KeyBind>().Active)
                    {
                        if (ProSeries.Player.ManaPercent <=
                            ProSeries.Config.Item("clearmana").GetValue <Slider>().Value)
                        {
                            Q.Cast();
                        }
                    }
                }
            }

            if (E.IsReady())
            {
                foreach (var target in ObjectManager.Get <AIHeroClient>().Where(h => h.IsValidTarget(E.Range)))
                {
                    if (ProSeries.Config.Item("useeimm", true).GetValue <bool>())
                    {
                        E.CastIfHitchanceEquals(target, HitChance.Immobile);
                    }

                    if (ProSeries.Config.Item("useedash", true).GetValue <bool>())
                    {
                        E.CastIfHitchanceEquals(target, HitChance.Dashing);
                    }
                }
            }

            if (ProSeries.Config.Item("usecombor", true).GetValue <bool>())
            {
                var maxDistance = ProSeries.Config.Item("maxrdist", true).GetValue <Slider>().Value;

                foreach (var target in ObjectManager.Get <AIHeroClient>().Where(h => h.IsValidTarget(maxDistance)))
                {
                    var canr = !TargetSelector.IsInvulnerable(target, TargetSelector.DamageType.Physical);

                    var aaDamage = Orbwalking.InAutoAttackRange(target)
                        ? ProSeries.Player.GetAutoAttackDamage(target, true)
                        : 0;

                    if (target.Health - aaDamage <= GetRDamage(target) && canr)
                    {
                        R.Cast(target);
                    }
                }
            }
        }
Example #11
0
        internal static void Game_OnUpdate(EventArgs args)
        {
            R.Range = ProSeries.Player.Buffs.Any(
                h => h.Name.ToLower().Contains("corkimissilebarragecounterbig")) ? 1500f : 1300f;

            if (ProSeries.CanCombo())
            {
                var qtarget = TargetSelector.GetTarget(Q.Range, TargetSelector.DamageType.Magical);
                if (qtarget.IsValidTarget() && Q.IsReady())
                {
                    if (ProSeries.Config.Item("usecomboq", true).GetValue <bool>())
                    {
                        Q.CastIfHitchanceEquals(qtarget, HitChance.High);
                    }
                }

                var etarget = HeroManager.Enemies.FirstOrDefault(h => h.IsValidTarget(E.Range));
                if (etarget.IsValidTarget() && E.IsReady())
                {
                    if (ProSeries.Config.Item("usecomboe", true).GetValue <bool>() &&
                        E.Cast(etarget) == Spell.CastStates.SuccessfullyCasted)
                    {
                        return;
                    }
                }

                var rtarget = TargetSelector.GetTarget(R.Range, TargetSelector.DamageType.Magical);
                if (rtarget.IsValidTarget() && R.IsReady())
                {
                    if (ProSeries.Config.Item("usecombor", true).GetValue <bool>())
                    {
                        R.CastIfHitchanceEquals(rtarget, HitChance.High);
                    }
                }
            }

            if (ProSeries.CanHarass())
            {
                var qtarget = TargetSelector.GetTarget(Q.Range, TargetSelector.DamageType.Magical);
                if (qtarget.IsValidTarget() && Q.IsReady() && ProSeries.IsWhiteListed(qtarget))
                {
                    if (ProSeries.Config.Item("useharassq", true).GetValue <bool>())
                    {
                        Q.CastIfHitchanceEquals(qtarget, HitChance.High);
                    }
                }

                var etarget = HeroManager.Enemies.FirstOrDefault(h => h.IsValidTarget(E.Range));
                if (etarget.IsValidTarget() && E.IsReady() && ProSeries.IsWhiteListed(etarget))
                {
                    if (ProSeries.Config.Item("useharasse", true).GetValue <bool>())
                    {
                        if (E.Cast(etarget) == Spell.CastStates.SuccessfullyCasted)
                        {
                            return;
                        }
                    }
                }

                var rtarget = TargetSelector.GetTarget(R.Range, TargetSelector.DamageType.Magical);
                if (rtarget.IsValidTarget() && R.IsReady() && ProSeries.IsWhiteListed(rtarget))
                {
                    if (ProSeries.Config.Item("useharassr", true).GetValue <bool>() && R.Instance.Ammo > 3)
                    {
                        R.CastIfHitchanceEquals(rtarget, HitChance.High);
                    }
                }
            }

            if (ProSeries.CanClear())
            {
                foreach (var neutral in ProSeries.JungleMobsInRange(650))
                {
                    if (ProSeries.Config.Item("useclearq", true).GetValue <bool>() && Q.IsReady())
                    {
                        Q.Cast(neutral);
                    }
                    if (ProSeries.Config.Item("usecleare", true).GetValue <bool>() && E.IsReady())
                    {
                        if (E.Cast(neutral) == Spell.CastStates.SuccessfullyCasted)
                        {
                            return;
                        }
                    }
                }

                if (E.IsReady() && ProSeries.Config.Item("usecleare", true).GetValue <bool>())
                {
                    if (ObjectManager.Get <Obj_AI_Minion>().Count(h => h.IsValidTarget(E.Range) && !h.Name.Contains("Ward")) >= 3)
                    {
                        if (E.Cast(ObjectManager.Get <Obj_AI_Minion>().FirstOrDefault(h => h.IsValidTarget(E.Range))) ==
                            Spell.CastStates.SuccessfullyCasted)
                        {
                            return;
                        }
                    }
                }

                if (Q.IsReady() && ProSeries.Config.Item("useclearq", true).GetValue <bool>())
                {
                    var farmLocation = Q.GetCircularFarmLocation(MinionManager.GetMinions(Q.Range));
                    if (farmLocation.MinionsHit >= 3)
                    {
                        Q.Cast(farmLocation.Position);
                    }
                }
            }
        }
Example #12
0
        private void Game_OnUpdate(EventArgs args)
        {
            WRange = ProSeries.Player.HasBuff("KogMawBioArcaneBarrage", true)
                ? 500 + new[] { 130, 150, 170, 190, 210 }[W.Level - 1]
                : 500;

            if (E.IsReady())
            {
                foreach (var target in ObjectManager.Get <AIHeroClient>().Where(h => h.IsValidTarget(E.Range)))
                {
                    if (ProSeries.Config.Item("useeimm", true).GetValue <bool>())
                    {
                        E.CastIfHitchanceEquals(target, HitChance.Immobile);
                    }
                }
            }

            if (ProSeries.CanCombo())
            {
                var qtarget = TargetSelector.GetTargetNoCollision(Q);
                if (qtarget.IsValidTarget() && Q.IsReady())
                {
                    if (ProSeries.Config.Item("usecomboq", true).GetValue <bool>())
                    {
                        Q.Cast(qtarget);
                    }
                }

                var wtarget = TargetSelector.GetTarget(W.Range + new[] { 130, 150, 170, 190, 210 }[W.Level - 1], TargetSelector.DamageType.Physical);
                if (wtarget.IsValidTarget() && W.IsReady())
                {
                    if (ProSeries.Config.Item("usecombow", true).GetValue <bool>())
                    {
                        W.Cast();
                    }
                }

                var rtarget = TargetSelector.GetTarget(new[] { 1200f, 1500f, 1800f }[R.Level - 1], TargetSelector.DamageType.Physical);
                if (rtarget.IsValidTarget() && R.IsReady())
                {
                    if (ProSeries.Player.Buffs.Count(b => b.Name == "kogmawlivingartillery") < 6)
                    {
                        if (ProSeries.Config.Item("usecombor", true).GetValue <bool>())
                        {
                            R.Cast(rtarget);
                        }
                    }

                    if (R.GetDamage(rtarget) * 2 >= rtarget.Health)
                    {
                        if (ProSeries.Config.Item("usecombor", true).GetValue <bool>())
                        {
                            R.Cast(rtarget);
                        }
                    }
                }
            }

            if (ProSeries.CanHarass())
            {
                var qtarget = TargetSelector.GetTargetNoCollision(Q);
                if (qtarget.IsValidTarget() && Q.IsReady() && ProSeries.IsWhiteListed(qtarget))
                {
                    if (ProSeries.Config.Item("useharassq", true).GetValue <bool>())
                    {
                        Q.Cast(qtarget);
                    }
                }

                var wtarget = TargetSelector.GetTarget(W.Range + new[] { 130, 150, 170, 190, 210 }[W.Level - 1], TargetSelector.DamageType.Physical);
                if (wtarget.IsValidTarget() && W.IsReady() && ProSeries.IsWhiteListed(wtarget))
                {
                    if (ProSeries.Config.Item("useharassw", true).GetValue <bool>())
                    {
                        W.Cast();
                    }
                }

                var rtarget = TargetSelector.GetTarget(new[] { 1200f, 1500f, 1800f }[R.Level - 1], TargetSelector.DamageType.Physical);
                if (rtarget.IsValidTarget() && R.IsReady() && ProSeries.IsWhiteListed(rtarget))
                {
                    if (ProSeries.Player.Buffs.Count(b => b.Name == "kogmawlivingartillery") < 3)
                    {
                        if (ProSeries.Config.Item("useharassr", true).GetValue <bool>())
                        {
                            R.Cast(rtarget);
                        }
                    }
                }
            }
        }
Example #13
0
        internal static void Game_OnUpdate(EventArgs args)
        {
            if (ProSeries.CanCombo())
            {
                var etarget = TargetSelector.GetTarget(E.Range, TargetSelector.DamageType.Physical);
                if (etarget.IsValidTarget() && E.IsReady())
                {
                    foreach (var buff in etarget.Buffs)
                    {
                        if (buff.Name == "twitchdeadlyvenom" && buff.Count == 6 &&
                            ProSeries.Config.Item("usecomboe", true).GetValue <bool>())
                        {
                            E.Cast();
                        }
                    }
                }

                var wtarget = TargetSelector.GetTarget(W.Range, TargetSelector.DamageType.Physical);
                if (wtarget.IsValidTarget() && W.IsReady())
                {
                    if (ProSeries.Config.Item("usecombow", true).GetValue <bool>())
                    {
                        W.Cast(wtarget);
                    }
                }
            }

            if (ProSeries.CanHarass())
            {
                var etarget = TargetSelector.GetTarget(E.Range, TargetSelector.DamageType.Physical);
                if (etarget.IsValidTarget() && E.IsReady() && ProSeries.IsWhiteListed(etarget))
                {
                    foreach (var buff in etarget.Buffs)
                    {
                        if (buff.Name == "twitchdeadlyvenom" && buff.Count == 3 &&
                            ProSeries.Config.Item("useharasse", true).GetValue <bool>())
                        {
                            E.Cast();
                        }
                    }
                }

                var wtarget = TargetSelector.GetTarget(W.Range, TargetSelector.DamageType.Physical);
                if (wtarget.IsValidTarget() && W.IsReady() && ProSeries.IsWhiteListed(wtarget))
                {
                    if (ProSeries.Config.Item("useharassw", true).GetValue <bool>())
                    {
                        W.Cast(wtarget);
                    }
                }
            }

            if (ProSeries.CanClear() && E.IsReady())
            {
                var minionList = MinionManager.GetMinions(E.Range).Where(m => m.HasBuff("twitchdeadlyvenom", true));
                if (minionList.Count(m => m.Health <= ProSeries.Player.GetSpellDamage(m, SpellSlot.E)) >= 3)
                {
                    E.Cast();
                }
            }

            if (W.IsReady() && !ProSeries.Player.HasBuff("twitchhideinshadows", true))
            {
                foreach (var target in ObjectManager.Get <Obj_AI_Hero>().Where(h => h.IsValidTarget(W.Range)))
                {
                    if (ProSeries.Config.Item("usewimm", true).GetValue <bool>())
                    {
                        W.CastIfHitchanceEquals(target, HitChance.Immobile);
                    }

                    if (ProSeries.Config.Item("usewdash", true).GetValue <bool>())
                    {
                        W.CastIfHitchanceEquals(target, HitChance.Dashing);
                    }
                }
            }
        }