Example #1
0
        public static void ExecuteKillsteal()
        {
            foreach (var Enemy in EntityManager.Heroes.Enemies.Where(e => !e.IsDead && e.IsValidTarget(SpellsManager.Q.Range)))
            {
                if ((Enemy == null) || Enemy.IsInvulnerable)
                {
                    return;
                }

                if (KillStealMenu["Q"].Cast <CheckBox>().CurrentValue&& SpellsManager.Q.IsReady() && Enemy.Health < Enemy.GetRealDamage(SpellSlot.Q))
                {
                    SpellsManager.Q.Cast(Enemy);
                }

                if (KillStealMenu["R"].Cast <CheckBox>().CurrentValue&& SpellsManager.R.IsReady() && Enemy.IsValidTarget(SpellsManager.R.Range) && Enemy.Health < Enemy.GetRealDamage(SpellSlot.R))// && Enemy.Health > Enemy.GetRealDamage(SpellSlot.R) * 0.30f)
                {
                    SpellsManager.R.Cast(Enemy.Position);
                }

                // Hextech KS
                if (Enemy.Health < SpellsManager.HextechGunbladeDamage() && Hextech.IsOwned() && Hextech.IsReady() && Enemy.IsValidTarget(700))
                {
                    Hextech.Cast(Enemy);
                }
            }
        }
Example #2
0
        private static void OnTick(EventArgs args)
        {
            if (!Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo))
            {
                return;
            }

            var target = Orbwalker.LastTarget as AIHeroClient;

            if (target == null)
            {
                return;
            }

            if (Cutlass.IsOwned())
            {
                UseItem3(Cutlass, target);
            }
            if (Hextech.IsOwned())
            {
                UseItem4(Hextech, target);
            }
            if (Omen.IsOwned())
            {
                UseItem5(Omen);
            }
            if (Glory.IsOwned())
            {
                UseItem6(Glory);
            }
            if (Solari.IsOwned())
            {
                UseItem7(Solari);
            }
        }
Example #3
0
        // normal Combo Q E W
        public static void ExecuteCombo()
        {
            var target = TargetSelector.GetTarget(SpellsManager.Q.Range, DamageType.Magical);


            if ((target == null) || target.IsInvulnerable)
            {
                return;
            }


            if (ComboMenu["Q"].Cast <CheckBox>().CurrentValue&& target.IsValidTarget(SpellsManager.Q.Range) && SpellsManager.Q.IsReady())
            {
                SpellsManager.Q.Cast(target);
            }

            if (SpellsManager.W.IsReady() && ComboMenu["W"].Cast <CheckBox>().CurrentValue&& myhero.Distance(target) < myhero.AttackRange + 150 && !target.IsDead)
            {
                SpellsManager.W.Cast();
            }

            if (ComboMenu["R"].Cast <CheckBox>().CurrentValue&& SpellsManager.R.IsReady() && target.IsValidTarget(SpellsManager.R.Range) && Player.Instance.Spellbook.GetSpell(SpellSlot.R).Ammo >= ComboMenu["RAmmo"].Cast <Slider>().CurrentValue&& lastRCast + 3000 < Environment.TickCount)
            {
                var prediction = SpellsManager.R.GetPrediction(target);
                SpellsManager.R.Cast(SpellsManager.R.GetPrediction(target).CastPosition);
                lastRCast = Environment.TickCount;
            }

            var Summ = TargetSelector.GetTarget(Ignite.Range, DamageType.Mixed);

            if ((Summ == null) || Summ.IsInvulnerable)
            {
                return;
            }
            //Ignite
            if (ComboMenu["Ignite"].Cast <CheckBox>().CurrentValue)
            {
                if (Player.Instance.CountEnemyChampionsInRange(600) >= 1 && Ignite.IsReady() && Ignite.IsLearned && Summ.IsValidTarget(Ignite.Range) && target.HealthPercent <= ComboMenu["IgniteHealth"].Cast <Slider>().CurrentValue&& target.Health > target.GetRealDamage())
                {
                    Ignite.Cast(Summ);
                }
            }


            if (ComboMenu["Hextech"].Cast <CheckBox>().CurrentValue&& (KillStealMenu["HextechKS"].Cast <CheckBox>().CurrentValue == false || myhero.CountAllyChampionsInRange(800) >= 1))
            {
                if (Hextech.IsOwned() && Hextech.IsReady() && target.IsValidTarget(700))
                {
                    Hextech.Cast(target);
                }
                if (Bilgewater.IsOwned() && Bilgewater.IsReady() && target.IsValidTarget(700))
                {
                    Bilgewater.Cast(target);
                }
            }
        }
Example #4
0
        public static void Execute()
        {
            var target = TargetSelector.GetTarget(1000, DamageType.Mixed);

            if (target == null)
            {
                var manamune = Player.Instance.Spellbook.Spells.FirstOrDefault(s => s.Name.ToLower().Contains("manamune"));

                if (manamune != null && manamune.ToggleState == 2)
                {
                    Manamune.Cast();
                }
            }

            if (Activator.lastUsed > Environment.TickCount)
            {
                return;
            }

            if (target != null && !Player.Instance.IsRecalling() &&
                (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo) ||
                 Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.LaneClear)))
            {
                if (Settings.Bilgewater && BilgewaterCutlass.IsOwned() && BilgewaterCutlass.IsReady() &&
                    target.IsValidTarget(BilgewaterCutlass.Range))
                {
                    if (target.HealthPercent < Settings.BilgewaterTargetHp)
                    {
                        BilgewaterCutlass.Cast(target);
                        Activator.lastUsed = Environment.TickCount + Misc.DelayBetweenOff;
                    }
                }

                if (Settings.Blade && BladeOfTheRuinedKing.IsOwned() && BladeOfTheRuinedKing.IsReady() &&
                    target.IsValidTarget(BladeOfTheRuinedKing.Range))
                {
                    if (Settings.BladeMyHp > Player.Instance.HealthPercent &&
                        target.HealthPercent < Settings.BladeTargetHp)
                    {
                        BladeOfTheRuinedKing.Cast(target);
                        Activator.lastUsed = Environment.TickCount + Misc.DelayBetweenOff;
                    }
                }

                var minions = EntityManager.MinionsAndMonsters.EnemyMinions.Count(m => m.IsValidTarget(Tiamat.Range));
                if (Settings.Tiamat && Tiamat.IsOwned() && Tiamat.IsReady() && target.IsValidTarget(Tiamat.Range) ||
                    minions > 2)
                {
                    if (target.HealthPercent < Settings.TiamatTargetHp && Misc.AACancel
                        ? EventsManager.CanAACancel
                        : Tiamat.IsReady())
                    {
                        Tiamat.Cast();
                        Activator.lastUsed = Environment.TickCount + Misc.DelayBetweenOff;
                    }
                }

                if (Settings.Hydra && Hydra.IsOwned() && Hydra.IsReady() && target.IsValidTarget(Hydra.Range) ||
                    minions > 2)
                {
                    if (target.HealthPercent < Settings.HydraTargetHp && Misc.AACancel
                        ? EventsManager.CanAACancel
                        : Hydra.IsReady())
                    {
                        Hydra.Cast();
                        Activator.lastUsed = Environment.TickCount + Misc.DelayBetweenOff;
                    }
                }

                if (Settings.Titanic && TitanicHydra.IsOwned() && TitanicHydra.IsReady() &&
                    target.IsValidTarget(TitanicHydra.Range) || minions > 2)
                {
                    if (target.HealthPercent < Settings.TitanicTargetHp && Misc.AACancel
                        ? EventsManager.CanAACancel
                        : TitanicHydra.IsReady())
                    {
                        TitanicHydra.Cast();
                        Activator.lastUsed = Environment.TickCount + Misc.DelayBetweenOff;
                    }
                }

                if (Settings.Youmuu && Youmuu.IsOwned() && Youmuu.IsReady() && target.IsValidTarget(Youmuu.Range))
                {
                    if (target.HealthPercent < Settings.YoumuuTargetHp)
                    {
                        Youmuu.Cast();
                        Activator.lastUsed = Environment.TickCount + Misc.DelayBetweenOff;
                    }
                }

                if (Settings.Hextech && Hextech.IsOwned() && Hextech.IsReady() && target.IsValidTarget(Hextech.Range))
                {
                    if (target.HealthPercent < Settings.HextechTargetHp)
                    {
                        Hextech.Cast(target);
                        Activator.lastUsed = Environment.TickCount + Misc.DelayBetweenOff;
                    }
                }

                if (Settings.Manamune && Manamune.IsOwned() && Manamune.IsReady() && target.IsValidTarget(Manamune.Range))
                {
                    if (target.HealthPercent < Settings.ManamuneTargetHP && Player.Instance.ManaPercent > Settings.ManamuneMana)
                    {
                        var manamune = Player.Instance.Spellbook.Spells.FirstOrDefault(s => s.Name.ToLower().Contains("manamune"));
                        if (manamune != null && manamune.ToggleState == 1)
                        {
                            Manamune.Cast();
                        }
                    }
                }
            }
        }