Example #1
0
        public static void Combo()
        {
            var target = TargetSelector2.GetTarget(GetDynamicRange() + 100, DamageType.Magical);
            var t = TargetSelector2.GetTarget(Program.R.Range, DamageType.Magical);
            var summonerIgnite = Player.Spells.FirstOrDefault(o => o.SData.Name == "summonerdot"); // Thanks finn

            if (target == null) return;

            var manaPre = _Player.ManaPercent > Program.MinNumberManaC;

            if (!manaPre)
            {
                return;
            }

            if (summonerIgnite != null)
            {
                SpellSlot igSlot = extent.GetSpellSlotFromName(_Player, "summonerdot");
                ignite = new Spell.Targeted(igSlot, 600);
                if (Program.ComboMenu["igniteKill"].Cast<CheckBox>().CurrentValue && ignite.IsReady())
                {
                    if (getIgniteDamage() >= target.Health - 5) //-5 on enemy health for safecheck & HP regen
                    {
                        ignite.Cast(target);
                    }
                }
                else if (Program.ComboMenu["igniteAlways"].Cast<CheckBox>().CurrentValue && ignite.IsReady())
                {
                    ignite.Cast(target);
                }
            }

            if (Program.ComboMenu["useRCombo"].Cast<CheckBox>().CurrentValue && Program.R.IsReady() && target.IsValidTarget(Program.R.Range))
            {
                Program.R.Cast(target);
            }
            if (Program.ComboMenu["useECombo"].Cast<CheckBox>().CurrentValue && Program.E.IsReady() && target.IsValidTarget(Program.E.Range))
            {
                Program.E.Cast(target);
                if (_Player.Spellbook.GetSpell(SpellSlot.E).Name == "fizzjumptwo")
                {
                    EloBuddy.SDK.Core.DelayAction(() => { Program.E.Cast(target); }, 50);
                }
            }
            if (Program.ComboMenu["useWCombo"].Cast<CheckBox>().CurrentValue && Program.W.IsReady())
            {
                Program.W.Cast();
            }
            if (Program.ComboMenu["useQCombo"].Cast<CheckBox>().CurrentValue && Program.Q.IsReady())
            {
                Program.Q.Cast(target);
            }
        }
Example #2
0
        public static void Game_OnUpdate(EventArgs args)
        {
            var hedef = TargetSelector.GetTarget(1000, DamageType.Physical);

            if (hedef.IsValid())
            {
                return;
            }
            if (Orbwalker.ActiveModesFlags == Orbwalker.ActiveModes.Combo)
            {
                if (Q.IsReady() && ComboMenu["KomboQ"].Cast <CheckBox>().CurrentValue)
                {
                    Q.Cast();
                }
                if (W.IsReady() && _Player.Distance(hedef) <= W.Range + _Player.GetAutoAttackRange() && ComboMenu["KomboW"].Cast <CheckBox>().CurrentValue)
                {
                    W.Cast(hedef);
                }
                if (E.IsReady() && E.IsInRange(hedef) && ComboMenu["KomboE"].Cast <CheckBox>().CurrentValue)
                {
                    E.Cast(hedef);
                }
                if (R.IsReady() && R.IsInRange(hedef) && ComboMenu["KomboR"].Cast <CheckBox>().CurrentValue)
                {
                    R.Cast(hedef);
                }
            }
        }
Example #3
0
        public static void Game_OnUpdate(EventArgs args)
        {
            var target = TargetSelector.GetTarget(Q.Range, DamageType.Physical);
            var comboQ = ComboMenu["Qcombo"].Cast <CheckBox>().CurrentValue;
            var comboE = ComboMenu["Ecombo"].Cast <CheckBox>().CurrentValue;
            var comboR = ComboMenu["Rcombo"].Cast <CheckBox>().CurrentValue;

            if (target == null)
            {
                return;
            }

            if (target.HasBuffOfType(BuffType.Stun) || target.HasBuffOfType(BuffType.Snare))
            {
                if (Q.IsReady() && Q.IsReady() && !target.IsZombie && target.IsValidTarget(Q.Range))
                {
                    Q.Cast(target);
                }
            }
            if (comboE && E.IsReady() && !target.IsZombie && target.IsValidTarget(150))
            {
                E.Cast();
            }
            if (comboR && R.IsReady() && !target.IsZombie && target.IsValidTarget(R.Range))
            {
                R.Cast();
            }
        }
Example #4
0
        private static void CastSpellLogic(bool useQ          = false, bool useW = false, bool useE = false,
                                           Obj_AI_Base target = null)
        {
            if (useQ)
            {
                var enemy = TargetSelector.GetTarget(Q.Range, DamageType.Magical);

                if (enemy != null && enemy.IsValidTarget(Q.Range))
                {
                    Q.Cast();
                }
            }

            if (useW)
            {
                if (SpellMenu["wtc"].Cast <CheckBox>().CurrentValue&& Player.CountEnemiesInRange(700) >= 2)
                {
                    W.Cast();
                }
            }
            if (useE && E.IsReady() && TickManager.NoLag(3))
            {
                var enemy = TargetSelector.GetTarget(E.Range, DamageType.Mixed);

                if (enemy != null && enemy.IsValidTarget(E.Range))
                {
                    E.Cast(enemy);
                }
            }
        }
        public static void UseSmite(List <Obj_AI_Base> enemies, bool ks)
        {
            Spell.Targeted blueSmite = new Spell.Targeted(JarvanIV.GetSpellSlotFromName("S5_SummonerSmitePlayerGanker"), 500, DamageType.True);
            Spell.Targeted redSmite  = new Spell.Targeted(JarvanIV.GetSpellSlotFromName("S5_SummonerSmiteDuel"), 500, DamageType.True);

            if (blueSmite.Slot != SpellSlot.Unknown && blueSmite.IsReady())
            {
                var target = enemies.Where(a => a.MeetsCriteria() && a.IsTargetable && a.IsInRange(JarvanIV, blueSmite.Range) && (!ks || (a.Type == GameObjectType.AIHeroClient && a.Health <= 54 + 6 * JarvanIV.Level) || (a.Type != GameObjectType.AIHeroClient && a.Health <= Calculations.Smite()))).FirstOrDefault();

                if (target != null)
                {
                    blueSmite.Cast(target);
                }
            }

            if (redSmite.Slot != SpellSlot.Unknown && redSmite.IsReady())
            {
                var target = enemies.Where(a => a.MeetsCriteria() && a.IsTargetable && a.IsInRange(JarvanIV, redSmite.Range) && a.IsInRange(JarvanIV, JarvanIV.GetAutoAttackRange()) && (!ks || (a.Type == GameObjectType.AIHeroClient && a.Health <= 54 + 6 * JarvanIV.Level) || (a.Type != GameObjectType.AIHeroClient && a.Health <= Calculations.Smite()))).FirstOrDefault();

                if (target != null)
                {
                    redSmite.Cast(target);
                }
            }
        }
Example #6
0
 private static void Interrupter_OnInterruptableSpell(Obj_AI_Base sender, Interrupter.InterruptableSpellEventArgs e)
 {
     if (sender.IsEnemy && sender.IsValid)
     {
         if (PantheonMenu.CheckBox(PantheonMenu.Misc, "Interrupter"))
         {
             if (sender.IsValidTarget(W.Range))
             {
                 if (W.IsReady())
                 {
                     W.Cast(sender);
                 }
             }
         }
     }
 }
Example #7
0
        public static void KillSteal()
        {
            var useQ = KsMenu["KsQ"].Cast <CheckBox>().CurrentValue;
            var useW = KsMenu["KsW"].Cast <CheckBox>().CurrentValue;
            var useE = KsMenu["KsE"].Cast <CheckBox>().CurrentValue;

            foreach (AIHeroClient e in EntityManager.Heroes.Enemies)
            {
                if (e.IsValidTarget(Q.Range))
                {
                    if (useQ && Q.IsReady() && (_Player.GetSpellDamage(e, SpellSlot.Q) >= e.Health))
                    {
                        Q.Cast(e);
                    }
                    if (useW && W.IsReady() && (_Player.GetSpellDamage(e, SpellSlot.W) >= e.Health))
                    {
                        W.Cast(e);
                    }
                    if (useE && E.IsReady() && (_Player.GetSpellDamage(e, SpellSlot.E) >= e.Health))
                    {
                        E.Cast(e);
                    }
                    if (Ignite != null && KsMenu["KsIgnite"].Cast <CheckBox>().CurrentValue&& Ignite.IsReady())
                    {
                        if (e.Health < _Player.GetSummonerSpellDamage(e, DamageLibrary.SummonerSpells.Ignite))
                        {
                            Ignite.Cast(e);
                        }
                    }
                }
            }
        }
Example #8
0
        private static void KillSteal()
        {
            var KsQ = KillStealMenu["KsQ"].Cast <CheckBox>().CurrentValue;
            var KsE = KillStealMenu["KsE"].Cast <CheckBox>().CurrentValue;

            foreach (var target in EntityManager.Heroes.Enemies.Where(hero => hero.IsValidTarget(E.Range) && !hero.HasBuff("JudicatorIntervention") && !hero.HasBuff("kindredrnodeathbuff") && !hero.HasBuff("Undying Rage") && !hero.IsDead && !hero.IsZombie))
            {
                if (KsQ && Q.IsReady() && target.IsValidTarget(250))
                {
                    if (target.Health + target.AttackShield <= QDamage(target))
                    {
                        Q.Cast();
                        Player.IssueOrder(GameObjectOrder.AttackUnit, target);
                    }
                }

                if (KsE && E.IsReady() && target.IsValidTarget(E.Range))
                {
                    if (target.Health + target.AttackShield <= EDamage(target))
                    {
                        E.Cast(target.Position);
                    }
                }

                if (Ignite != null && KillStealMenu["ign"].Cast <CheckBox>().CurrentValue&& Ignite.IsReady())
                {
                    if (target.Health < _Player.GetSummonerSpellDamage(target, DamageLibrary.SummonerSpells.Ignite))
                    {
                        Ignite.Cast(target);
                    }
                }
            }
        }
Example #9
0
        private static void Combo()
        {
            var target = TargetSelector.GetTarget(E.Range, DamageType.Physical);
            var useW   = ComboMenu["ComboW"].Cast <CheckBox>().CurrentValue;
            var useE   = ComboMenu["ComboE"].Cast <CheckBox>().CurrentValue;
            var E2dis  = ComboMenu["ekc"].Cast <Slider>().CurrentValue;
            var useR   = ComboMenu["ultiR"].Cast <CheckBox>().CurrentValue;
            var minR   = ComboMenu["MinR"].Cast <Slider>().CurrentValue;

            if (target != null)
            {
                if (useW && W.IsReady() && W.IsInRange(target) && !target.IsDead && !target.IsZombie)
                {
                    W.Cast(target);
                }
                var pos = E.GetPrediction(target).CastPosition.Extend(Player.Instance.Position, -80);
                if (useE && E.IsReady() && E.IsInRange(target) && E2dis <= target.Distance(Player.Instance))
                {
                    E.Cast(pos.To3DWorld());
                }
                if (useR && _Player.HealthPercent <= minR && target.IsValidTarget(R.Range))
                {
                    if (ComboMenu["useRCombo" + target.ChampionName].Cast <CheckBox>().CurrentValue)
                    {
                        R.Cast(target);
                    }
                }
            }
        }
Example #10
0
        private void Game_OnUpdate(EventArgs args)
        {
            var enemies = EntityManager.Heroes.Enemies.ToList();

            enemies.RemoveAll(x => x.Distance(AutoWalker.p) > E.Range * 2.5f);
            if (!enemies.Any() && EIsActive)
            {
                E.Cast(AutoWalker.p);
            }
            foreach (var enemy in EntityManager.Heroes.Enemies)
            {
                if (enemy.Distance(AutoWalker.p) > 800)
                {
                    return;
                }
                var missingHealth = enemy.TotalMissingHealth();
                var damage        = new[] { 0f, 175f, 350f, 525f }[R.Level] +new[] { 0f, 0.286f, 0.333f, 0.4f }[R.Level] *missingHealth;
                var predict       = AutoWalker.p.CalculateDamageOnUnit(enemy, DamageType.Magical, damage);
                if (predict >= enemy.Health && R.CanCast(enemy))
                {
                    R.Cast(enemy);
                    return;
                }
            }
        }
Example #11
0
 internal static void RCast(AIHeroClient target)
 {
     if (target.IsKillable(R.Range) && !Config.MiscMenu.CheckBoxValue(target.Name()) && R.IsReady())
     {
         R.Cast(target);
     }
 }
Example #12
0
        public static void KillSteal()
        {
            var KsE = KillStealMenu["KsE"].Cast <CheckBox>().CurrentValue;
            var KsW = KillStealMenu["KsW"].Cast <CheckBox>().CurrentValue;

            foreach (var target in EntityManager.Heroes.Enemies.Where(hero => hero.IsValidTarget(E.Range) && !hero.HasBuff("kindredrnodeathbuff") && !hero.IsDead && !hero.IsZombie && (hero.HealthPercent <= 25)))
            {
                if (KsE && E.IsReady() && target.IsValidTarget(E.Range))
                {
                    if (target.Health + target.AttackShield < EDamage(target))
                    {
                        E.Cast();
                    }
                }
                if (KsW && W.IsReady() && target.IsValidTarget(W.Range))
                {
                    if (target.Health + target.AttackShield < Player.Instance.GetSpellDamage(target, SpellSlot.W))
                    {
                        var Wpred = W.GetPrediction(target);
                        if (Wpred.HitChancePercent >= 70)
                        {
                            W.Cast(Wpred.CastPosition);
                        }
                    }
                }
                if (Ignite != null && KillStealMenu["ign"].Cast <CheckBox>().CurrentValue&& Ignite.IsReady() && target.IsValidTarget(Ignite.Range))
                {
                    if (target.Health + target.AttackShield < _Player.GetSummonerSpellDamage(target, DamageLibrary.SummonerSpells.Ignite))
                    {
                        Ignite.Cast(target);
                    }
                }
            }
        }
Example #13
0
        static void CastSpells()
        {
            if (TargetIn != null)
            {
                AIHeroClient target = TargetIn;

                if (W.IsReady())
                {
                    W.Cast(target);
                }

                if (E.IsReady())
                {
                    E.Cast(target);
                }

                if (QQ.IsReady())
                {
                    QQ.Cast(target);
                }
            }
            else if (TargetOut != null)
            {
                if (Q.IsReady())
                {
                    Q.Cast(TargetOut);
                }
            }
        }
Example #14
0
        public static void KillSteal()
        {
            var KsQ = KillStealMenu["KsQ"].Cast <CheckBox>().CurrentValue;
            var KsW = KillStealMenu["KsW"].Cast <CheckBox>().CurrentValue;
            var KsR = KillStealMenu["KsR"].Cast <CheckBox>().CurrentValue;

            foreach (var target in EntityManager.Heroes.Enemies.Where(hero => hero.IsValidTarget(W.Range) && !hero.HasBuff("JudicatorIntervention") && !hero.HasBuff("kindredrnodeathbuff") && !hero.HasBuff("Undying Rage") && !hero.IsDead && !hero.IsZombie))
            {
                if (KsQ && Q.IsReady())
                {
                    if (target != null)
                    {
                        if (_Player.Distance(target) > 150)
                        {
                            if (target.Health + target.AttackShield <= QDamage(target))
                            {
                                Q.Cast(target);
                            }
                        }
                        else
                        {
                            if (target.Health + target.AttackShield <= QDamage(target) * 1.5f)
                            {
                                Q.Cast(target);
                            }
                        }
                    }
                }

                if (KsW && W.IsReady())
                {
                    if (target != null)
                    {
                        if (target.Health + target.AttackShield <= WDamage(target))
                        {
                            W.Cast(target);
                        }
                    }
                }

                if (KsR && R.IsReady() && target.IsValidTarget(500))
                {
                    if (target != null)
                    {
                        if (target.Health + target.AttackShield <= RDamage(target))
                        {
                            R.Cast();
                        }
                    }
                }

                if (Ignite != null && KillStealMenu["ign"].Cast <CheckBox>().CurrentValue&& Ignite.IsReady())
                {
                    if (target.Health + target.AttackShield < _Player.GetSummonerSpellDamage(target, DamageLibrary.SummonerSpells.Ignite))
                    {
                        Ignite.Cast(target);
                    }
                }
            }
        }
Example #15
0
        private static void AntiGapCloser(AIHeroClient sender, Gapcloser.GapcloserEventArgs e)
        {
            if (!sender.IsEnemy)
            {
                return;
            }

            if (sender.IsValidTarget(Q.Range) && FiddleTheTrollMeNu.GapcloserQ() && Player.Distance(e.End) < 150)
            {
                Q.Cast(sender);
            }
            if (sender.IsValidTarget(E.Range) && FiddleTheTrollMeNu.GapcloserE() && Player.Distance(e.End) < 150)
            {
                E.Cast(sender);
            }
        }
Example #16
0
        private static void Game_OnUpdate(EventArgs args)
        {
            var target = TargetSelector.GetTarget(600, DamageType.Physical);

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

            var comboQ = ComboMenu["comboQ"].Cast <CheckBox>().CurrentValue;
            var comboE = ComboMenu["comboE"].Cast <CheckBox>().CurrentValue;
            var comboR = ComboMenu["comboR"].Cast <CheckBox>().CurrentValue;

            if (Orbwalker.ActiveModesFlags != Orbwalker.ActiveModes.Combo)
            {
                return;
            }
            {
                if (comboQ && Q.IsReady())
                {
                    Q.Cast(target);
                }
                if (comboE && E.IsReady())
                {
                    E.Cast();
                }
                if (comboR && R.IsReady())
                {
                    R.Cast();
                }
            }
        }
Example #17
0
        private void Game_OnTick(System.EventArgs args)
        {
            if (Orbwalker.CanAutoAttack && Logic.SurviLogic.DangerValue < -20000)
            {
                AIHeroClient toShoot =
                    EntityManager.Heroes.Enemies.Where(
                        en =>
                        en.HasBuff("caitlynyordletrapinternal") &&
                        en.Distance(AutoWalker.P) < AutoWalker.P.AttackRange * 2 + en.BoundingRadius)
                    .OrderBy(e => e.HealthPercent())
                    .FirstOrDefault();
                if (toShoot != null)
                {
                    Player.IssueOrder(GameObjectOrder.AttackUnit, toShoot);
                }
            }

            if (!R.IsReady())
            {
                return;
            }
            AIHeroClient vic =
                EntityManager.Heroes.Enemies.FirstOrDefault(
                    v => v.IsVisible() &&
                    v.Health < AutoWalker.P.GetSpellDamage(v, SpellSlot.R) &&
                    v.Distance(AutoWalker.P) > 670 + v.BoundingRadius &&
                    AutoWalker.P.Distance(v) < 2000 && Logic.SurviLogic.DangerValue < -10000);

            if (vic == null)
            {
                return;
            }
            R.Cast(vic);
        }
Example #18
0
        private static void Killsteal()
        {
            var enemy = TargetSelector.GetTarget(Q.Range, DamageType.Magical);

            if (MiscMenu["ksq"].Cast <CheckBox>().CurrentValue&& Q.IsReady())
            {
                try
                {
                    foreach (
                        var qtarget in
                        EntityManager.Heroes.Enemies.Where(
                            hero => hero.IsValidTarget(Q.Range) && !hero.IsDead && !hero.IsZombie))
                    {
                        if (Vlad.GetSpellDamage(qtarget, SpellSlot.Q) >= qtarget.Health)
                        {
                            Q.Cast(enemy);
                            if (MiscMenu["debug"].Cast <CheckBox>().CurrentValue)
                            {
                                Chat.Print("q-ks");
                            }
                        }
                    }
                }
                catch
                {
                }
            }
        }
Example #19
0
        public static void KillSteal()
        {
            var KsQ = KillStealMenu["KsQ"].Cast <CheckBox>().CurrentValue;
            var KsE = KillStealMenu["KsE"].Cast <CheckBox>().CurrentValue;

            foreach (var target in EntityManager.Heroes.Enemies.Where(hero => hero.IsValidTarget(Q.Range) && !hero.HasBuff("JudicatorIntervention") && !hero.HasBuff("kindredrnodeathbuff") && !hero.HasBuff("Undying Rage") && !hero.IsDead && !hero.IsZombie))
            {
                if (KsQ && Q.IsReady())
                {
                    var pos = Q.GetPrediction(target).CastPosition.Extend(Player.Instance.Position, -80);
                    if (target.Health <= Player.Instance.GetSpellDamage(target, SpellSlot.Q))
                    {
                        Q.Cast(pos.To3DWorld());
                    }
                }

                if (KsE && E.IsReady())
                {
                    if (target.Health <= Player.Instance.GetSpellDamage(target, SpellSlot.E))
                    {
                        E.Cast(target);
                    }
                }

                if (Ignite != null && KillStealMenu["KsIgnite"].Cast <CheckBox>().CurrentValue&& Ignite.IsReady())
                {
                    if (target.Health <= _Player.GetSummonerSpellDamage(target, DamageLibrary.SummonerSpells.Ignite))
                    {
                        Ignite.Cast(target);
                    }
                }
            }
        }
Example #20
0
// KillSteal

        private static void KillSteal()
        {
            var useQ    = KillstealMenu["QKs"].Cast <CheckBox>().CurrentValue;
            var useR    = KillstealMenu["RKs"].Cast <CheckBox>().CurrentValue;
            var Ignites = KillstealMenu["ign"].Cast <CheckBox>().CurrentValue;

            foreach (var target in EntityManager.Heroes.Enemies.Where(e => e.IsValidTarget(R.Range) && !e.HasBuff("JudicatorIntervention") && !e.HasBuff("kindredrnodeathbuff") && !e.HasBuff("Undying Rage") && !e.IsDead && !e.IsZombie))
            {
                if (useR && R.IsReady() && target.Health <= Player.Instance.GetSpellDamage(target, SpellSlot.R))
                {
                    var RPred = R.GetPrediction(target);
                    if (RPred.HitChance >= HitChance.Medium)
                    {
                        R.Cast(RPred.CastPosition);
                    }
                }

                if (useQ && Q.IsReady() && target.Health <= Player.Instance.GetSpellDamage(target, SpellSlot.Q))
                {
                    var Pred = Q.GetPrediction(target);
                    if (Pred.HitChance >= HitChance.Medium)
                    {
                        Q.Cast(Pred.CastPosition);
                    }
                }

                if (Ignite != null && Ignites && Ignite.IsReady())
                {
                    if (target.Health < _Player.GetSummonerSpellDamage(target, DamageLibrary.SummonerSpells.Ignite))
                    {
                        Ignite.Cast(target);
                    }
                }
            }
        }
Example #21
0
        private static void Game_OnTick(EventArgs args)
        {
            if (ObjectManager.Player.IsDead || !IG.IsReady() || !SelectionsMenu["Active"].Cast <CheckBox>().CurrentValue)
            {
                return;
            }

            //if (SelectionsMenu["Lowest"].Cast<CheckBox>().CurrentValue)
            //{
            //    var target =
            //        HeroManager.Enemies.Where(hero => hero.IsValidTarget(IG.Range)).OrderBy(hero => hero.Hero).First();
            //    IG.Cast(target);
            //}

            if (SelectionsMenu["KS"].Cast <CheckBox>().CurrentValue)
            {
                var target2 = ObjectManager.Get <AIHeroClient>()
                              .Where(
                    h =>
                    h.IsValidTarget(IG.Range) &&
                    h.Health <
                    ObjectManager.Player.GetSummonerSpellDamage(h, DamageLibrary.SummonerSpells.Ignite));

                IG.Cast(target2.First());
            }
        }
Example #22
0
        private static void ProtectorOnTick()
        {
            var champS = ProtectSpells.Spells.FirstOrDefault(s => s.Champ == Player.Instance.Hero);

            if (champS != null)
            {
                if (!ProtectMenu.GetCheckBoxValue("checkProtector"))
                {
                    return;
                }

                var spell = Player.GetSpell(champS.Slot);
                if (spell != null && ProtectMenu.GetCheckBoxValue("canUseSpell" + spell.Slot))
                {
                    var range = spell.SData.CastRadius <= 0 ? spell.SData.CastRadius : spell.SData.CastRangeDisplayOverride;

                    _protectSpell = new Spell.Targeted(spell.Slot, (uint)range);

                    var ally =
                        EntityManager.Heroes.Allies.FirstOrDefault(
                            a =>
                            a.IsValidTarget(_protectSpell.Range) && ProtectMenu.GetCheckBoxValue("canUseSpellOn" + a.ChampionName) &&
                            a.IsInDanger(ProtectMenu.GetSliderValue("protectallyhealth")));

                    if (ally != null)
                    {
                        _protectSpell?.Cast(ally);
                    }
                }
            }
        }
Example #23
0
 static void KInterrupter(Obj_AI_Base sender, Interrupter.InterruptableSpellEventArgs args)
 {
     if (args.DangerLevel == DangerLevel.High && sender.IsEnemy && sender is AIHeroClient && sender.Distance(_Player) < R.Range && R.IsReady())
     {
         R.Cast(Player.Instance);
     }
 }
Example #24
0
        private static void KillSteal()
        {
            var KsE = KillStealMenu["KsE"].Cast <CheckBox>().CurrentValue;
            var KsR = KillStealMenu["KsR"].Cast <CheckBox>().CurrentValue;

            foreach (var target in EntityManager.Heroes.Enemies.Where(hero => hero.IsValidTarget(R.Range) && !hero.HasBuff("FioraW") && !hero.HasBuff("JudicatorIntervention") && !hero.HasBuff("kindredrnodeathbuff") && !hero.HasBuff("Undying Rage") && !hero.HasBuff("SpellShield") && !hero.HasBuff("NocturneShield") && !hero.IsDead && !hero.IsZombie))
            {
                if (KsE && E.IsReady() && target.IsValidTarget(E.Range))
                {
                    if (target.Health + target.AttackShield < Player.Instance.GetSpellDamage(target, SpellSlot.E))
                    {
                        E.Cast(target);
                    }
                }

                if (KsR && R.IsReady() && target.IsValidTarget(R.Range))
                {
                    if (target.Health + target.AttackShield < RDamage(target))
                    {
                        R.Cast();
                    }
                }

                if (Ignite != null && KillStealMenu["ign"].Cast <CheckBox>().CurrentValue&& Ignite.IsReady())
                {
                    if (target.Health < _Player.GetSummonerSpellDamage(target, DamageLibrary.SummonerSpells.Ignite))
                    {
                        Ignite.Cast(target);
                    }
                }
            }
        }
Example #25
0
        private static void KillSteal()
        {
            var KsQ = KillStealMenu["KsQ"].Cast <CheckBox>().CurrentValue;
            var KsR = KillStealMenu["KsR"].Cast <CheckBox>().CurrentValue;

            foreach (var target in EntityManager.Heroes.Enemies.Where(hero => hero.IsValidTarget(R.Range) && !hero.HasBuff("JudicatorIntervention") && !hero.HasBuff("kindredrnodeathbuff") && !hero.HasBuff("Undying Rage") && !hero.IsDead && !hero.IsZombie))
            {
                if (KsQ && Q.IsReady() && target.IsValidTarget(Q.Range))
                {
                    if (target.Health + target.AttackShield < Player.Instance.GetSpellDamage(target, SpellSlot.Q))
                    {
                        Q.Cast(target);
                    }
                }

                if (KsR && R.IsReady() && target.IsValidTarget(R.Range))
                {
                    var Rpred = R.GetPrediction(target);
                    if (target.Health + target.AttackShield < RDamege(target) && Rpred.HitChance >= HitChance.Medium)
                    {
                        R.Cast(Rpred.CastPosition);
                    }
                }

                if (Ignite != null && KillStealMenu["ign"].Cast <CheckBox>().CurrentValue&& Ignite.IsReady())
                {
                    if (target.Health < _Player.GetSummonerSpellDamage(target, DamageLibrary.SummonerSpells.Ignite))
                    {
                        Ignite.Cast(target);
                    }
                }
            }
        }
Example #26
0
        public static void KillSteal()
        {
            var KsQ = KillStealMenu["KsQ"].Cast <CheckBox>().CurrentValue;
            var KsE = KillStealMenu["KsE"].Cast <CheckBox>().CurrentValue;

            foreach (var target in EntityManager.Heroes.Enemies.Where(hero => hero.IsValidTarget(1200) && !hero.IsDead && !hero.IsZombie && (hero.HealthPercent <= 25)))
            {
                if (KsQ && Q.IsReady())
                {
                    if (target.Health + target.AttackShield < Player.Instance.GetSpellDamage(target, SpellSlot.Q))
                    {
                        var Qpred = Q.GetPrediction(target);
                        if (Qpred.HitChancePercent >= 70)
                        {
                            Q.Cast(Qpred.CastPosition);
                        }
                    }
                }

                if (KsE && E.IsReady())
                {
                    if (target.Health + target.AttackShield < Player.Instance.GetSpellDamage(target, SpellSlot.E))
                    {
                        E.Cast(target);
                    }
                }
                if (Ignite != null && KillStealMenu["KsIgnite"].Cast <CheckBox>().CurrentValue&& Ignite.IsReady())
                {
                    if (target.Health < _Player.GetSummonerSpellDamage(target, DamageLibrary.SummonerSpells.Ignite))
                    {
                        Ignite.Cast(target);
                    }
                }
            }
        }
Example #27
0
 private static void Killsteal()
 {
     if (MiscMenu["ksq"].Cast <CheckBox>().CurrentValue&& Q.IsReady())
     {
         foreach (
             var qtarget in
             EntityManager.Heroes.Enemies.Where(
                 hero => hero.IsValidTarget(Q.Range) && !hero.IsDead && !hero.IsZombie))
         {
             if (Shen.GetSpellDamage(qtarget, SpellSlot.Q) >= qtarget.Health)
             {
                 Q.Cast(qtarget);
             }
         }
     }
 }
Example #28
0
        private static void Game_OnUpdate(EventArgs args)
        {
            if (!SmiteMenu["smiteEnabled"].Cast <KeyBind>().CurrentValue || Smite == null)
            {
                return;
            }

            SetSmiteSlot();

            var minion = ObjectManager.Get <Obj_AI_Base>().Where(a => SmiteableUnits.Contains(a.BaseSkinName) && SmiteMenu[a.BaseSkinName].Cast <CheckBox>() != null && SmiteMenu[a.BaseSkinName].Cast <CheckBox>().CurrentValue).OrderByDescending(a => a.MaxHealth).FirstOrDefault(a => a.IsValidTarget(1400));

            if (minion == null)
            {
                return;
            }
            if (Smite.IsReady() && minion.IsValidTarget(Smite.Range) && minion.Health <= GetSmiteDamage() && SmiteMenu["regularSmite"].Cast <CheckBox>().CurrentValue || ForceSmite && Player.Instance.Distance(minion) < 100)
            {
                Smite.Cast(minion);
                ForceSmite = false;
                return;
            }
            if (SpellsManager.Q.IsReady() && minion.HasQBuff() && SmiteMenu["QSmite"].Cast <CheckBox>().CurrentValue&& minion.Health <= SpellsManager.Q2Damage(minion, GetSmiteDamage(), true) + GetSmiteDamage())
            {
                SpellsManager.Q2.Cast();
                ForceSmite = true;
                return;
            }
            if (SpellsManager.Q.IsReady() && SmiteMenu["QSmite"].Cast <CheckBox>().CurrentValue&& SpellsManager.Q.Name == Extensions.Spellss["Q1"] && minion.IsValidTarget(SpellsManager.Q.Range) &&
                minion.Health <=
                SpellsManager.QDamage(minion) + SpellsManager.Q2Damage(minion, SpellsManager.Q2Damage(minion) + GetSmiteDamage(), true) +
                GetSmiteDamage())
            {
                SpellsManager.Q.Cast(minion);
            }
        }
Example #29
0
        private static void KS()
        {
            var targets = EntityManager.Heroes.Enemies.Where(t => t.IsValidTarget(R.Range));

            foreach (var target in targets)
            {
                if (target.Health < PossibleDamage(target, SpellSlot.R) &&
                    !Player.Instance.IsInAutoAttackRange(target) &&
                    CanCastSpell(SpellSlot.R, target) &&
                    Misc.IsChecked(ComboMenu, "comboR"))
                {
                    R.Cast(target);
                }

                if (target.Health < PossibleDamage(target, SpellSlot.Q) && !Player.Instance.IsInAutoAttackRange(target) && CanCastSpell(SpellSlot.Q, target))
                {
                    Q.Cast(Q.GetPrediction(target).CastPosition);
                }

                if (target.Health < PossibleDamage(target, SpellSlot.E) && CanCastSpell(SpellSlot.E, target))
                {
                    E.Cast(E.GetPrediction(target).CastPosition);
                }
            }
        }
Example #30
0
        private static void Auto()
        {
            var w = TargetSelector.GetTarget(W.Range, DamageType.Physical);

            if (w == null)
            {
                return;
            }

            if (w.IsValidTarget(W.Range) && MiscMenu["AutoW"].Cast <CheckBox>().CurrentValue)
            {
                W.Cast();
            }
            if (_Player.HasBuffOfType(BuffType.Stun) || _Player.HasBuffOfType(BuffType.Taunt) || _Player.HasBuffOfType(BuffType.Polymorph) || _Player.HasBuffOfType(BuffType.Frenzy) || _Player.HasBuffOfType(BuffType.Fear) || _Player.HasBuffOfType(BuffType.Snare) || _Player.HasBuffOfType(BuffType.Suppression))
            {
                DoQSS();
            }
            if (MiscMenu["AutoIgnite"].Cast <CheckBox>().CurrentValue)
            {
                if (!_ignite.IsReady() || _Player.IsDead)
                {
                    return;
                }
                foreach (
                    var source in
                    EntityManager.Heroes.Enemies
                    .Where(
                        a => a.IsValidTarget(_ignite.Range) &&
                        a.Health < 50 + 20 * _Player.Level - (a.HPRegenRate / 5 * 3)))
                {
                    _ignite.Cast(source);
                    return;
                }
            }
        }
Example #31
0
        private static void KillSteal()
 {
     foreach (var enemy in EntityManager.Heroes.Enemies)
     {
         if (enemy.IsValidTarget(E.Range) && enemy.HealthPercent <= 40)
         {
             var damageI = GetBestCombo(enemy);
             if (damageI.Damage >= enemy.TotalShieldHealth())
             {
                 if (SubMenu["KillSteal"]["Q"].Cast<CheckBox>().CurrentValue &&
                     (Damage(enemy, Q.Slot) >= enemy.TotalShieldHealth() || damageI.Q))
                 {
                     CastQ(enemy);
                 }
                 if (SubMenu["KillSteal"]["W"].Cast<CheckBox>().CurrentValue &&
                     (Damage(enemy, W.Slot) >= enemy.TotalShieldHealth() || damageI.W))
                 {
                     CastW(enemy);
                 }
                 if (SubMenu["KillSteal"]["E"].Cast<CheckBox>().CurrentValue &&
                     (Damage(enemy, E.Slot) >= enemy.TotalShieldHealth() || damageI.E))
                 {
                     CastE(enemy);
                 }
             }
             if (Ignite != null && SubMenu["KillSteal"]["Ignite"].Cast<CheckBox>().CurrentValue &&
                 Ignite.IsReady() &&
                 myHero.GetSummonerSpellDamage(enemy, DamageLibrary.SummonerSpells.Ignite) >= enemy.TotalShieldHealth())
             {
                 Ignite.Cast(enemy);
             }
         }
     }
 }
Example #32
0
        public static void Combo()
        {
            var target = TargetSelector2.GetTarget(GetDynamicRange() + 100, DamageType.Magical);
            var t = TargetSelector2.GetTarget(Program.R.Range, DamageType.Magical);
            var summonerIgnite = Player.Spells.FirstOrDefault(o => o.SData.Name == "summonerdot"); // Thanks finn

            float rdmg = EloBuddy.SDK.DamageLibrary.GetSpellDamage(_Player, target, EloBuddy.SpellSlot.R); // damage of cho R

            if (target == null) return;

            var manaPre = _Player.ManaPercent > Program.MinNumberManaC;

            if (!manaPre)
            {
                return;
            }

            if (summonerIgnite != null)
            {
                SpellSlot igSlot = extent.GetSpellSlotFromName(_Player, "summonerdot");
                ignite = new Spell.Targeted(igSlot, 600);
                if (Program.ComboMenu["igniteKill"].Cast<CheckBox>().CurrentValue && ignite.IsReady())
                {
                    if (getIgniteDamage() > target.Health - 10) //-10 on enemy health for safecheck
                    {
                        ignite.Cast(target);
                    }
                }
            }

            if (Program.ComboMenu["useQCombo"].Cast<CheckBox>().CurrentValue && Program.Q.IsReady() && target.IsValidTarget(Program.Q.Range))
            {
                var qPred = Program.Q.GetPrediction(target);
                if (qPred.HitChance >= HitChance.High)
                {
                    Program.Q.Cast(target);
                }
            }
            if (Program.ComboMenu["useWCombo"].Cast<CheckBox>().CurrentValue && Program.W.IsReady() && target.IsValidTarget(Program.W.Range))
            {
                Program.W.Cast(target);
            }
            if (Program.ComboMenu["useRCombo"].Cast<CheckBox>().CurrentValue && Program.ComboMenu["useRKill"].Cast<CheckBox>().CurrentValue && Program.R.IsReady() && rdmg > target.Health - 10)
            {
                Program.R.Cast(target);
            }
            if (Program.ComboMenu["useRCombo"].Cast<CheckBox>().CurrentValue && !Program.ComboMenu["useRKill"].Cast<CheckBox>().CurrentValue && Program.R.IsReady())
            {
                Program.R.Cast(target);
            }
        }
Example #33
0
        private static void Game_OnUpdate(EventArgs args)
        {
            if (MobsToSmite["killsmite"].Cast<CheckBox>().CurrentValue)
            {
                var KillEnemy =
                    EntityManager.Heroes.Enemies.FirstOrDefault(hero => hero.IsValidTarget(500f)
                        && SmiteChampDamage() >= hero.Health);
                if (KillEnemy != null)
                    Player.CastSpell(Smite.Slot, KillEnemy);
            }
                if (SmiteGHMenu["active"].Cast<CheckBox>().CurrentValue || SmiteGHMenu["activekey"].Cast<KeyBind>().CurrentValue)
                {
                    double SpellDamage = 0;
                    Monster = GetNearest(ObjectManager.Player.ServerPosition);
                        if (Monster != null && MobsToSmite[Monster.BaseSkinName].Cast<CheckBox>().CurrentValue)
                        {
                            if (SupportedChampions.Contains(ObjectManager.Player.ChampionName))
                            {
                                if (SmiteGHMenu["disable"].Cast<CheckBox>().CurrentValue)
                                {
                                    switch (ObjectManager.Player.ChampionName)
                                    {
                                        #region Diana
                                        case "Diana":
                                            {
                                                Spell.Skillshot Q = new Spell.Skillshot(SpellSlot.Q, (uint)895, SkillShotType.Circular);
                                                Spell.Targeted R = new Spell.Targeted(SpellSlot.R, (uint)825);

                                                //Smite and Spell  ==> OKAY
                                                if (Smite.IsReady() && Q.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Q.Range
                                                    && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    SpellDamage = GetDamages.DianaQ(Q.Level) + GetDamages.DianaR(R.Level);
                                                    TotalDamage = SpellDamage + GetSmiteDamage();
                                                    if (Monster.Health <= TotalDamage)
                                                    {
                                                        Q.Cast(Monster.ServerPosition);
                                                        //Smite.Cast(Monster);
                                                    }
                                                }
                                                else if (Smite.IsReady() && R.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < R.Range
                                                && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range && GetDamages.HasBuffs(Monster, "dianamoonlight"))
                                                {
                                                    SpellDamage = GetDamages.DianaR(R.Level);
                                                    TotalDamage = SpellDamage + GetSmiteDamage();
                                                    if (Monster.Health <= TotalDamage)
                                                    {
                                                        R.Cast(Monster);
                                                        //Smite.Cast(Monster);
                                                    }
                                                }
                                                //If Spell is busy, Go Smite only! ^_^
                                                else if (Smite.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    if (Monster.Health <= GetSmiteDamage())
                                                    {
                                                        Smite.Cast(Monster);
                                                    }
                                                    TotalDamage = 0;
                                                }
                                                break;
                                            }
                                        #endregion
                                        #region Evelynn
                                        case "Evelynn":
                                            {
                                                Spell.Targeted E = new Spell.Targeted(SpellSlot.E, (uint)(225f + 2 * 65f));
                                                //Smite and Spell  ==> OKAY
                                                if (Smite.IsReady() && E.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < E.Range
                                                    && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    SpellDamage = GetDamages.Evelynn(E.Level);
                                                    TotalDamage = SpellDamage + GetSmiteDamage();
                                                    if (Monster.Health <= TotalDamage)
                                                    {
                                                        E.Cast(Monster);
                                                        //Smite.Cast(Monster);
                                                    }
                                                }
                                                //If Spell is busy, Go Smite only! ^_^
                                                else if (Smite.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    if (Monster.Health <= GetSmiteDamage())
                                                    {
                                                        Smite.Cast(Monster);
                                                    }
                                                    TotalDamage = 0;
                                                }
                                                break;
                                            }
                                        #endregion
                                        #region Irelia
                                        case "Irelia":
                                            {
                                                Spell.Targeted Q = new Spell.Targeted(SpellSlot.Q, (uint)650f + 20);
                                                //Smite and Spell  ==> OKAY
                                                if (Smite.IsReady() && Q.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Q.Range
                                                    && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    SpellDamage = GetDamages.Irelia(Q.Level);
                                                    TotalDamage = SpellDamage + GetSmiteDamage();
                                                    if (Monster.Health <= TotalDamage)
                                                    {
                                                        Q.Cast(Monster);
                                                        //Smite.Cast(Monster);
                                                    }
                                                }
                                                //If Spell is busy, Go Smite only! ^_^
                                                else if (Smite.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    if (Monster.Health <= GetSmiteDamage())
                                                    {
                                                        Smite.Cast(Monster);
                                                    }
                                                    TotalDamage = 0;
                                                }
                                                break;
                                            }
                                        #endregion
                                        #region Amumu
                                        case "Amumu":
                                            {
                                                Spell.Skillshot Q = new Spell.Skillshot(SpellSlot.Q, (uint)1100f + 20, SkillShotType.Linear);
                                                //Smite and Spell  ==> OKAY
                                                if (Smite.IsReady() && Q.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Q.Range
                                                    && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    SpellDamage = GetDamages.Amumu(Q.Level);
                                                    TotalDamage = SpellDamage + GetSmiteDamage();
                                                    if (Monster.Health <= TotalDamage)
                                                    {
                                                        Q.Cast(Monster);
                                                        //Smite.Cast(Monster);
                                                    }
                                                }
                                                //If Spell is busy, Go Smite only! ^_^
                                                else if (Smite.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    if (Monster.Health <= GetSmiteDamage())
                                                    {
                                                        Smite.Cast(Monster);
                                                    }
                                                    TotalDamage = 0;
                                                }
                                                break;
                                            }
                                        #endregion
                                        #region Hecarim
                                        case "Hecarim":
                                            {
                                                Spell.Active Q = new Spell.Active(SpellSlot.Q, (uint)350f + 20);
                                                //Smite and Spell  ==> OKAY
                                                if (Smite.IsReady() && Q.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Q.Range
                                                    && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    SpellDamage = GetDamages.Hecarim(Q.Level);
                                                    TotalDamage = SpellDamage + GetSmiteDamage();
                                                    if (Monster.Health <= TotalDamage)
                                                    {
                                                        Q.Cast();
                                                        //Smite.Cast(Monster);
                                                    }
                                                }
                                                //If Spell is busy, Go Smite only! ^_^
                                                else if (Smite.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    if (Monster.Health <= GetSmiteDamage())
                                                    {
                                                        Smite.Cast(Monster);
                                                    }
                                                    TotalDamage = 0;
                                                }
                                                break;
                                            }
                                        #endregion
                                        #region MonkeyKing
                                        case "MonkeyKing":
                                            {
                                                Spell.Active Q = new Spell.Active(SpellSlot.Q, (uint)100f + 20);
                                                //Smite and Spell  ==> OKAY
                                                if (Smite.IsReady() && Q.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Q.Range
                                                    && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    SpellDamage = GetDamages.MonkeyKing(Q.Level);
                                                    TotalDamage = SpellDamage + GetSmiteDamage();
                                                    if (Monster.Health <= TotalDamage)
                                                    {
                                                        Q.Cast();
                                                        //Smite.Cast(Monster);
                                                    }
                                                }
                                                //If Spell is busy, Go Smite only! ^_^
                                                else if (Smite.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    if (Monster.Health <= GetSmiteDamage())
                                                    {
                                                        Smite.Cast(Monster);
                                                    }
                                                    TotalDamage = 0;
                                                }
                                                break;
                                            }
                                        #endregion
                                        #region Pantheon
                                        case "Pantheon":
                                            {
                                                Spell.Targeted Q = new Spell.Targeted(SpellSlot.Q, (uint)600f + 20);
                                                //Smite and Spell  ==> OKAY
                                                if (Smite.IsReady() && Q.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Q.Range
                                                    && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    SpellDamage = GetDamages.Pantheon(Q.Level, Monster);
                                                    TotalDamage = SpellDamage + GetSmiteDamage();
                                                    if (Monster.Health <= TotalDamage)
                                                    {
                                                        Q.Cast(Monster);
                                                        //Smite.Cast(Monster);
                                                    }
                                                }
                                                //If Spell is busy, Go Smite only! ^_^
                                                else if (Smite.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    if (Monster.Health <= GetSmiteDamage())
                                                    {
                                                        Smite.Cast(Monster);
                                                    }
                                                    TotalDamage = 0;
                                                }
                                                break;
                                            }
                                        #endregion
                                        #region Olaf
                                        case "Olaf":
                                            {
                                                Spell.Targeted E = new Spell.Targeted(SpellSlot.E, (uint)325f + 20);
                                                //Smite and Spell  ==> OKAY
                                                if (Smite.IsReady() && E.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < E.Range
                                                    && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    SpellDamage = GetDamages.Olaf(E.Level);
                                                    TotalDamage = SpellDamage + GetSmiteDamage();
                                                    if (Monster.Health <= TotalDamage)
                                                    {
                                                        E.Cast(Monster);
                                                        //Smite.Cast(Monster);
                                                    }
                                                }
                                                //If Spell is busy, Go Smite only! ^_^
                                                else if (Smite.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    if (Monster.Health <= GetSmiteDamage())
                                                    {
                                                        Smite.Cast(Monster);
                                                    }
                                                    TotalDamage = 0;
                                                }
                                                break;
                                            }
                                        #endregion
                                        #region Volibear
                                        case "Volibear":
                                            {
                                                Spell.Targeted W = new Spell.Targeted(SpellSlot.W, (uint)400f + 20);
                                                //Smite and Spell  ==> OKAY
                                                if (Smite.IsReady() && W.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < W.Range
                                                    && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    SpellDamage = GetDamages.Volibear(W.Level, Monster);
                                                    TotalDamage = SpellDamage + GetSmiteDamage();
                                                    if (Monster.Health <= TotalDamage)
                                                    {
                                                        W.Cast(Monster);
                                                        //Smite.Cast(Monster);
                                                    }
                                                }
                                                //If Spell is busy, Go Smite only! ^_^
                                                else if (Smite.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    if (Monster.Health <= GetSmiteDamage())
                                                    {
                                                        Smite.Cast(Monster);
                                                    }
                                                    TotalDamage = 0;
                                                }
                                                break;
                                            }
                                        #endregion
                                        #region WarWick
                                        case "Warwick":
                                            {
                                                Spell.Targeted Q = new Spell.Targeted(SpellSlot.Q, (uint)400f + 20);
                                                //Smite and Spell  ==> OKAY
                                                if (Smite.IsReady() && Q.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Q.Range
                                                    && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    SpellDamage = GetDamages.Warwick(Q.Level, Monster);
                                                    TotalDamage = SpellDamage + GetSmiteDamage();
                                                    if (Monster.Health <= TotalDamage)
                                                    {
                                                        Player.CastSpell(Q.Slot, Monster);
                                                        //Smite.Cast(Monster);
                                                    }
                                                }
                                                //If Spell is busy, Go Smite only! ^_^
                                                else if (Smite.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    if (Monster.Health <= GetSmiteDamage())
                                                    {
                                                        Smite.Cast(Monster);
                                                    }
                                                    TotalDamage = 0;
                                                }
                                                break;
                                            }
                                        #endregion
                                        //Will add Spell's E too soon! ^-^
                                        #region LeeSin
                                        case "LeeSin":
                                            {
                                                Spell.Skillshot Q = new Spell.Skillshot(SpellSlot.Q, (uint)1300f, SkillShotType.Linear);
                                                Spell.Active Q2 = new Spell.Active(SpellSlot.Q, (uint)1500f);
                                                //Smite and Spell  ==> OKAY
                                                if (Smite.IsReady() && Q.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Q.Range
                                                    && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    if (GetDamages.BuffedEnemy != null)
                                                        SpellDamage = GetDamages.Q2Damage(Monster, Q2.Level);
                                                    else
                                                        SpellDamage = GetDamages.QDamage(Monster, Q.Level - 1) + GetDamages.Q2Damage(Monster, Q2.Level - 1);
                                                    TotalDamage = SpellDamage + GetSmiteDamage();
                                                    if (Monster.Health <= TotalDamage)
                                                    {
                                                        if (GetDamages.BuffedEnemy != null)
                                                            Q2.Cast(Monster);
                                                        else
                                                            Q.Cast(Monster);
                                                        //Smite.Cast(Monster);
                                                    }
                                                }
                                                //If Spell is busy, Go Smite only! ^_^
                                                else if (Smite.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    if (Monster.Health <= GetSmiteDamage())
                                                    {
                                                        Smite.Cast(Monster);
                                                    }
                                                    TotalDamage = 0;
                                                }
                                                break;
                                            }
                                        #endregion
                                        #region Nunu
                                        case "Nunu":
                                            {
                                                Spell.Targeted Q = new Spell.Targeted(SpellSlot.Q, (uint)200f);
                                                //Smite and Spell  ==> OKAY
                                                if (Smite.IsReady() && Q.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Q.Range
                                                    && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    SpellDamage = GetDamages.Nunu(Q.Level);
                                                    TotalDamage = SpellDamage + GetSmiteDamage();
                                                    if (Monster.Health <= TotalDamage)
                                                    {
                                                        Player.CastSpell(Q.Slot, Monster);
                                                        //Smite.Cast(Monster);
                                                    }
                                                }
                                                //If Spell is busy, Go Smite only! ^_^
                                                else if (Smite.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    if (Monster.Health <= GetSmiteDamage())
                                                    {
                                                        Smite.Cast(Monster);
                                                    }
                                                    TotalDamage = 0;
                                                }
                                                break;
                                            }
                                        #endregion
                                        #region ChoGath
                                        case "Chogath":
                                            {
                                                Spell.Targeted R = new Spell.Targeted(SpellSlot.R, (uint)175f);
                                                //Smite and Spell  ==> OKAY
                                                if (Smite.IsReady() && R.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < R.Range
                                                    && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    SpellDamage = GetDamages.ChoGath();
                                                    TotalDamage = SpellDamage + GetSmiteDamage();
                                                    if (Monster.Health <= TotalDamage)
                                                    {
                                                        Player.CastSpell(R.Slot, Monster);
                                                        // Smite.Cast(Monster);
                                                    }
                                                }
                                                //If Spell is busy, Go Smite only! ^_^
                                                else if (Smite.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    if (Monster.Health <= GetSmiteDamage())
                                                    {
                                                        Smite.Cast(Monster);
                                                    }
                                                    TotalDamage = 0;
                                                }
                                                break;
                                            }
                                        #endregion
                                        #region Shaco
                                        case "Shaco":
                                            {
                                                Spell.Targeted E = new Spell.Targeted(SpellSlot.E, (uint)625f);
                                                //Smite and Spell  ==> OKAY
                                                if (Smite.IsReady() && E.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < E.Range
                                                    && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    SpellDamage = GetDamages.Shaco(E.Level);
                                                    TotalDamage = SpellDamage + GetSmiteDamage();
                                                    if (Monster.Health <= TotalDamage)
                                                    {
                                                        Player.CastSpell(E.Slot, Monster);
                                                        //  Smite.Cast(Monster);
                                                    }
                                                }
                                                //If Spell is busy, Go Smite only! ^_^
                                                else if (Smite.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    if (Monster.Health <= GetSmiteDamage())
                                                    {
                                                        Smite.Cast(Monster);
                                                    }
                                                    TotalDamage = 0;
                                                }
                                                break;
                                            }
                                        #endregion
                                        #region Vi
                                        case "Vi":
                                            {
                                                Spell.Active E = new Spell.Active(SpellSlot.E, (uint)600f);
                                                //Smite and Spell  ==> OKAY
                                                if (Smite.IsReady() && E.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < E.Range
                                                    && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    SpellDamage = GetDamages.Vi(E.Level);
                                                    TotalDamage = SpellDamage + GetSmiteDamage();
                                                    if (Monster.Health <= TotalDamage)
                                                    {
                                                        Player.CastSpell(E.Slot, Monster);
                                                        //  Smite.Cast(Monster);
                                                    }
                                                }
                                                //If Spell is busy, Go Smite only! ^_^
                                                else if (Smite.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    if (Monster.Health <= GetSmiteDamage())
                                                    {
                                                        Smite.Cast(Monster);
                                                    }
                                                    TotalDamage = 0;
                                                }
                                                break;
                                            }
                                        #endregion
                                        #region MasterYi
                                        case "MasterYi":
                                            {
                                                Spell.Targeted Q = new Spell.Targeted(SpellSlot.Q, (uint)600f);
                                                //Smite and Spell  ==> OKAY
                                                if (Smite.IsReady() && Q.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Q.Range
                                                    && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    SpellDamage = GetDamages.Master(Q.Level);
                                                    TotalDamage = SpellDamage + GetSmiteDamage();
                                                    if (Monster.Health <= TotalDamage)
                                                    {
                                                        Player.CastSpell(Q.Slot, Monster);
                                                        //Smite.Cast(Monster);
                                                    }
                                                }
                                                //If Spell is busy, Go Smite only! ^_^
                                                else if (Smite.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    if (Monster.Health <= GetSmiteDamage())
                                                    {
                                                        Smite.Cast(Monster);
                                                    }
                                                    TotalDamage = 0;
                                                }
                                                break;
                                            }
                                        #endregion
                                        #region Rengar
                                        case "Rengar":
                                            {
                                                Spell.Active Q = new Spell.Active(SpellSlot.Q, (uint)ObjectManager.Player.AttackRange);
                                                //Smite and Spell  ==> OKAY
                                                if (Smite.IsReady() && Q.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Q.Range
                                                    && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    SpellDamage = GetDamages.Rengar(Q.Level);
                                                    TotalDamage = SpellDamage + GetSmiteDamage();
                                                    if (Monster.Health <= TotalDamage)
                                                    {
                                                        Player.CastSpell(Q.Slot, Monster);
                                                        //Smite.Cast(Monster);
                                                    }
                                                }
                                                //If Spell is busy, Go Smite only! ^_^
                                                else if (Smite.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    if (Monster.Health <= GetSmiteDamage())
                                                    {
                                                        Smite.Cast(Monster);
                                                    }
                                                    TotalDamage = 0;
                                                }
                                                break;
                                            }
                                        #endregion
                                        #region Nasus
                                        case "Nasus":
                                            {
                                                Spell.Active Q = new Spell.Active(SpellSlot.Q, (uint)ObjectManager.Player.AttackRange);
                                                //Smite and Spell  ==> OKAY
                                                if (Smite.IsReady() && Q.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Q.Range
                                                    && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    SpellDamage = GetDamages.Nasus(Q.Level);
                                                    TotalDamage = SpellDamage + GetSmiteDamage();
                                                    if (Monster.Health <= TotalDamage)
                                                    {
                                                        Player.CastSpell(Q.Slot, Monster);
                                                        //Smite.Cast(Monster);
                                                    }
                                                }
                                                //If Spell is busy, Go Smite only! ^_^
                                                else if (Smite.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    if (Monster.Health <= GetSmiteDamage())
                                                    {
                                                        Smite.Cast(Monster);
                                                    }
                                                    TotalDamage = 0;
                                                }
                                                break;
                                            }
                                        #endregion
                                        #region KhaZix
                                        case "Khazix":
                                            {
                                                Spell.Targeted Q = new Spell.Targeted(SpellSlot.Q, (uint)325f);
                                                //Smite and Spell  ==> OKAY
                                                if (Smite.IsReady() && Q.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Q.Range
                                                    && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    SpellDamage = GetDamages.Khazix(Q.Level);
                                                    TotalDamage = SpellDamage + GetSmiteDamage();
                                                    if (Monster.Health <= TotalDamage)
                                                    {
                                                        Player.CastSpell(Q.Slot, Monster);
                                                        // Smite.Cast(Monster);
                                                    }
                                                }
                                                //If Spell is busy, Go Smite only! ^_^
                                                else if (Smite.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    if (Monster.Health <= GetSmiteDamage())
                                                    {
                                                        Smite.Cast(Monster);
                                                    }
                                                    TotalDamage = 0;
                                                }
                                                break;
                                            }
                                        #endregion
                                        #region Fizz
                                        case "Fizz":
                                            {
                                                Spell.Targeted Q = new Spell.Targeted(SpellSlot.Q, (uint)550f);
                                                //Smite and Spell  ==> OKAY
                                                if (Smite.IsReady() && Q.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Q.Range
                                                    && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    SpellDamage = GetDamages.Fizz(Q.Level);
                                                    TotalDamage = SpellDamage + GetSmiteDamage();
                                                    if (Monster.Health <= TotalDamage)
                                                    {
                                                        Player.CastSpell(Q.Slot, Monster);
                                                        //    Smite.Cast(Monster);
                                                    }
                                                }
                                                //If Spell is busy, Go Smite only! ^_^
                                                else if (Smite.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    if (Monster.Health <= GetSmiteDamage())
                                                    {
                                                        Smite.Cast(Monster);
                                                    }
                                                    TotalDamage = 0;
                                                }
                                                break;
                                            }
                                        #endregion
                                        #region Elise
                                        case "Elise":
                                            {
                                                Spell.Targeted Q = new Spell.Targeted(SpellSlot.Q, (uint)475f);
                                                //Smite and Spell  ==> OKAY
                                                if (Smite.IsReady() && Q.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Q.Range
                                                    && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    SpellDamage = GetDamages.Elise(Q.Level, Monster);
                                                    TotalDamage = SpellDamage + GetSmiteDamage();
                                                    if (Monster.Health <= TotalDamage)
                                                    {
                                                        Player.CastSpell(Q.Slot, Monster);
                                                        // Smite.Cast(Monster);
                                                    }
                                                }
                                                //If Spell is busy, Go Smite only! ^_^
                                                else if (Smite.IsReady() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                {
                                                    if (Monster.Health <= GetSmiteDamage())
                                                    {
                                                        Smite.Cast(Monster);
                                                    }
                                                    TotalDamage = 0;
                                                }
                                                break;
                                            }
                                        #endregion

                                        default:
                                            {
                                                if (Smite.IsReady() && Monster.Health <= GetSmiteDamage() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                                                    Smite.Cast(Monster);
                                                TotalDamage = 0;
                                            }
                                            break;
                                    }
                                }
                            }

                            if (Smite.IsReady() && Monster.Health <= GetSmiteDamage() && Vector3.Distance(ObjectManager.Player.ServerPosition, Monster.ServerPosition) < Smite.Range)
                            {
                                Smite.Cast(Monster);
                                TotalDamage = 0;
                            }
                        }
                }
        }
Example #34
0
        public static void UseSmite(List<Obj_AI_Base> enemies, bool ks)
        {
            Spell.Targeted blueSmite = new Spell.Targeted(Vi.GetSpellSlotFromName("S5_SummonerSmitePlayerGanker"), 500, DamageType.True);
            Spell.Targeted redSmite = new Spell.Targeted(Vi.GetSpellSlotFromName("S5_SummonerSmiteDuel"), 500, DamageType.True);

            if (blueSmite.Slot != SpellSlot.Unknown && blueSmite.IsReady())
            {
                var target = enemies.Where(a => a.MeetsCriteria() && a.IsTargetable && a.IsInRange(Vi, blueSmite.Range) && (!ks || (a.Type == GameObjectType.AIHeroClient && a.Health <= 54 + 6 * Vi.Level) || (a.Type != GameObjectType.AIHeroClient && a.Health <= Calculations.Smite()))).FirstOrDefault();

                if(target != null)
                    blueSmite.Cast(target);
            }

            if (redSmite.Slot != SpellSlot.Unknown && redSmite.IsReady())
            {
                var target = enemies.Where(a => a.MeetsCriteria() && a.IsTargetable && a.IsInRange(Vi, redSmite.Range) && a.IsInRange(Vi, Vi.GetAutoAttackRange()) && (!ks || (a.Type == GameObjectType.AIHeroClient && a.Health <= 54 + 6 * Vi.Level) || (a.Type != GameObjectType.AIHeroClient && a.Health <= Calculations.Smite()))).FirstOrDefault();

                if (target != null)
                    redSmite.Cast(target);
            }
        }
Example #35
0
 /// <summary>
 /// Handles ignite (doesn't work always/buggy?)
 /// </summary>
 /// <param name="target"></param>
 private static void HandleIgnite()
 {
     if(!KillStealMenu["useignite"].Cast<CheckBox>().CurrentValue) return;
     var ignite = new Spell.Targeted(IgniteSlot, 600);
     if(ignite.IsReady() && ignite.IsInRange(target) && target != null) ignite.Cast(target);
 }
Example #36
0
        public static void KS()
        {
            var target = TargetSelector2.GetTarget(GetDynamicRange() + 100, DamageType.Magical);
            float qdmg = EloBuddy.SDK.DamageLibrary.GetSpellDamage(_Player, target, EloBuddy.SpellSlot.Q); // damage of cho Q
            float wdmg = EloBuddy.SDK.DamageLibrary.GetSpellDamage(_Player, target, EloBuddy.SpellSlot.W); // damage of cho W
            float rdmg = EloBuddy.SDK.DamageLibrary.GetSpellDamage(_Player, target, EloBuddy.SpellSlot.R); // damage of cho R
            var summonerIgnite = Player.Spells.FirstOrDefault(o => o.SData.Name == "summonerdot"); // Thanks finn

            if (summonerIgnite != null)
            {
                SpellSlot igSlot = extent.GetSpellSlotFromName(_Player, "summonerdot");
                ignite = new Spell.Targeted(igSlot, 600);
                if (Program.KSMenu["igniteKill"].Cast<CheckBox>().CurrentValue && ignite.IsReady())
                {
                    if (getIgniteDamage() > target.Health - 10) //-10 on enemy health for safecheck
                    {
                        ignite.Cast(target);
                    }
                }
            }

            if (Program.KSMenu["qKS"].Cast<CheckBox>().CurrentValue && qdmg >= target.Health - 10 && Program.Q.IsReady() && target.IsValidTarget(Program.Q.Range))
            {
                var qPred = Program.Q.GetPrediction(target);
                if (qPred.HitChance >= HitChance.High)
                {
                    Program.Q.Cast(target);
                }
            }
            else if (Program.KSMenu["wKS"].Cast<CheckBox>().CurrentValue && wdmg >= target.Health - 10 && Program.W.IsReady() && target.IsValidTarget(Program.W.Range))
            {
                Program.W.Cast(target);
            }
            else if (Program.KSMenu["rKS"].Cast<CheckBox>().CurrentValue && rdmg >= target.Health - 10 && Program.R.IsReady() && target.IsValidTarget(Program.R.Range))
            {
                Program.R.Cast(target);
            }
        }
Example #37
0
        public static void UseIgnite(List<Obj_AI_Base> enemies, bool ks)
        {
            Spell.Targeted ignite = new Spell.Targeted(Vi.GetSpellSlotFromName("SummonerDot"), 600, DamageType.True);

            if (ignite.Slot == SpellSlot.Unknown || !ignite.IsReady())
                return;

            Obj_AI_Base unit = enemies.Where(a =>
                a.IsInRange(Vi, ignite.Range)
                && (!ks || Calculations.Ignite(a) >= a.Health)
                && a.MeetsCriteria()).FirstOrDefault();

            if (unit != null)
                hasDoneActionThisTick = ignite.Cast(unit);
        }
Example #38
0
        public static void Combo()
        {
            var target = TargetSelector2.GetTarget(GetDynamicRange() + 100, DamageType.Magical);
            var t = TargetSelector2.GetTarget(Program.R.Range, DamageType.Magical);
            var summonerIgnite = Player.Spells.FirstOrDefault(o => o.SData.Name == "summonerdot"); // Thanks finn
            var hpPre = _Player.HealthPercent > Program.MinHQNoQ;
            var manaPre = _Player.ManaPercent > Program.MinNumberManaC;

            if (target == null) return;

            if (manaPre == false)
            {
                return;
            }

            if (summonerIgnite != null)
            {
                SpellSlot igSlot = extent.GetSpellSlotFromName(_Player, "summonerdot");
                ignite = new Spell.Targeted(igSlot, 600);
                if (Program.ComboMenu["igniteKill"].Cast<CheckBox>().CurrentValue && ignite.IsReady())
                {
                    if (getIgniteDamage() >= target.Health - 5) //-5 on enemy health for safecheck
                    {
                        ignite.Cast(target);
                    }
                }
                if (Program.ComboMenu["igniteAlways"].Cast<CheckBox>().CurrentValue && ignite.IsReady())
                {
                    if (summonerIgnite != null)
                    {
                        ignite.Cast(target);
                    }
                }
            }

            if (Program.ComboMenu["useWCombo"].Cast<CheckBox>().CurrentValue && Program.W.IsReady())
            {
                Program.W.Cast();
            }
            if (Program.ComboMenu["useQCombo"].Cast<CheckBox>().CurrentValue && Program.Q.IsReady() && target.IsValidTarget(Program.Q.Range) && hpPre && Program.MiscMenu["grab" + target.ChampionName].Cast<CheckBox>().CurrentValue)
            {
                CheckCollisionAndCastQ(target, HitChance.High);
            }
            if (Program.ComboMenu["useECombo"].Cast<CheckBox>().CurrentValue && Program.E.IsReady() && target.IsValidTarget(Program.E.Range))
            {
                Program.E.Cast();
                Orbwalker.ResetAutoAttack();
            }
            if (Program.ComboMenu["useRCombo"].Cast<CheckBox>().CurrentValue && Program.R.IsReady() && t.CountEnemiesInRange(Program.R.Range) >= Program.MinNumberR)
            {
                Program.R.Cast();
            }
        }