Exemple #1
0
            public static void Combo()
            {
                if (QSS.IsReady() && (Player.HasBuffOfType(BuffType.Charm) || Player.HasBuffOfType(BuffType.Blind) || Player.HasBuffOfType(BuffType.Fear) || Player.HasBuffOfType(BuffType.Polymorph) || Player.HasBuffOfType(BuffType.Silence) || Player.HasBuffOfType(BuffType.Sleep) || Player.HasBuffOfType(BuffType.Snare) || Player.HasBuffOfType(BuffType.Stun) || Player.HasBuffOfType(BuffType.Suppression) || Player.HasBuffOfType(BuffType.Taunt)))
                {
                    QSS.Cast();
                }

                if (Q.IsReady() && Target.IsValidTarget(Q.Range - 80) && !Player.IsDashing())
                {
                    Q.Cast();
                }

                else if (W.IsReady() && Q.IsReady() && Target.IsValidTarget(625) && Player.Mana >= (Player.Spellbook.GetSpell(SpellSlot.W).SData.ManaCostArray[W.Level - 1] + Player.Spellbook.GetSpell(SpellSlot.Q).SData.ManaCostArray[Q.Level - 1]))
                {
                    WQ(); Combing = true;
                }

                if (Exhaust != null && Menu["UseExhaust?"].Cast <CheckBox>().CurrentValue&& TargetSelector.GetPriority(Target) > 3 && Target.IsValidTarget(Exhaust.Range) && Exhaust.IsReady())
                {
                    Exhaust.Cast(Target);
                }

                if (Target.IsValidTarget(Bilgewater.Range) && Bilgewater.IsReady())
                {
                    Bilgewater.Cast(Target);
                }

                if (Target.IsValidTarget(Randuin.Range) && Randuin.IsReady())
                {
                    Randuin.Cast();
                }

                return;
            }
Exemple #2
0
 private void Defensive()
 {
     if (Randuin.IsReady() && getCheckBoxItem("Randuin") && Player.CountEnemiesInRange(Randuin.Range) > 0)
     {
         Randuin.Cast();
     }
 }
Exemple #3
0
 private void Defensive()
 {
     if (Randuin.IsReady && Config["activator"]["defensives"].GetValue <MenuBool>("Randuin").Value&& Player.CountEnemyHeroesInRange(Randuin.Range) > 0)
     {
         Randuin.Cast();
     }
 }
Exemple #4
0
 private void Defensive()
 {
     if (Randuin.IsReady() && Config.Item("Randuin").GetValue <bool>() && Player.CountEnemiesInRange(Randuin.Range) > 0)
     {
         Randuin.Cast();
     }
 }
Exemple #5
0
 private static void Defensive()
 {
     if (Randuin.IsReady() && DefensivesMenu["ro"].Cast <CheckBox>().CurrentValue&&
         Player.CountEnemiesInRange(Randuin.Range) > 0)
     {
         Randuin.Cast();
     }
 }
Exemple #6
0
 private static void RanduinU()
 {
     if (Randuin.IsReady() && Randuin.IsOwned())
     {
         var randuin = MiscMenu["randuin"].Cast <CheckBox>().CurrentValue;
         if (randuin && Me.HealthPercent <= 15 && Me.CountEnemiesInRange(Randuin.Range) >= 1 ||
             Me.CountEnemiesInRange(Randuin.Range) >= 2)
         {
             Randuin.Cast();
         }
     }
 }
Exemple #7
0
        public static void Execute()
        {
            if (Player.Instance.IsInShopRange() || Player.Instance.CountAlliesInRange(Misc.RangeEnemy) < Misc.EnemyCount ||
                Activator.lastUsed >= Environment.TickCount)
            {
                return;
            }

            #region Self

            if (Zhonyas.IsReady() && Zhonyas.IsOwned() && Player.Instance.InDanger(Settings.ZhonyasMyHp) &&
                Settings.Zhonyas)
            {
                Zhonyas.Cast();
                Activator.lastUsed = Environment.TickCount + 1500;
            }

            if (Seraph.IsReady() && Seraph.IsOwned() && Player.Instance.InDanger(Settings.MYHPSeraph) &&
                Settings.UseSeraph)
            {
                Seraph.Cast();
                Activator.lastUsed = Environment.TickCount + 1500;
            }

            if (Talisman.IsReady() && Player.Instance.CountAlliesInRange(450) >= 2 && Talisman.IsOwned() &&
                Player.Instance.InDanger(30))
            {
                Talisman.Cast();
                Activator.lastUsed = Environment.TickCount + 1500;
            }

            if (Randuin.IsReady() && Player.Instance.CountEnemiesInRange(Randuin.Range) >= 2 && Randuin.IsOwned() &&
                Player.Instance.InDanger(30))
            {
                Randuin.Cast();
                Activator.lastUsed = Environment.TickCount + 500;
            }
            //Allies
            if (FaceOfTheMountain.IsReady() && FaceOfTheMountain.IsOwned())
            {
                var allyFace = EntityManager.Heroes.Allies.FirstOrDefault(a => a.InDanger(Settings.AllyHPFaceOfTheMountain));
                if (allyFace != null)
                {
                    FaceOfTheMountain.Cast(allyFace);
                    Activator.lastUsed = Environment.TickCount + 500;
                }
            }

            if (Mikael.IsReady() && Player.Instance.HasCCs() && Mikael.IsOwned())
            {
                var allyMikael = EntityManager.Heroes.Allies.FirstOrDefault(a => a.InDanger(Settings.AllyHPMikaelHeal));
                if (allyMikael != null)
                {
                    Mikael.Cast(allyMikael);
                    Activator.lastUsed = Environment.TickCount + 500;
                }
            }

            if (Solari.IsReady() && Solari.IsOwned())
            {
                var allySolari = EntityManager.Heroes.Allies.FirstOrDefault(a => a.InDanger(Settings.AllyHealthSolari));
                if (allySolari != null)
                {
                    Solari.Cast();
                    Activator.lastUsed = Environment.TickCount + 1500;
                }
            }

            if (Ohm.IsReady() && Ohm.IsOwned())
            {
                var turret   = EntityManager.Turrets.Enemies.FirstOrDefault(t => t.IsAttackingPlayer);
                var allyFace = EntityManager.Heroes.Allies.FirstOrDefault(a => a.InDanger(Settings.OhmHealth));
                if (allyFace != null && turret != null)
                {
                    Ohm.Cast(turret);
                    Activator.lastUsed = Environment.TickCount + 500;
                }
            }

            //CC

            if (DerbishBlade.IsReady() && DerbishBlade.IsOwned() && Settings.DerbishBlade && Player.Instance.HasCCs())
            {
                Core.DelayAction(() => DerbishBlade.Cast(), Settings.CleanseDelay);
                Activator.lastUsed = Environment.TickCount + 1500;
            }

            if (Mercurial.IsReady() && Mercurial.IsOwned() && Settings.Mercurial && Player.Instance.HasCCs())
            {
                Core.DelayAction(() => Mercurial.Cast(), Settings.CleanseDelay);
                Activator.lastUsed = Environment.TickCount + 1500;
            }

            if (QuickSilver.IsReady() && QuickSilver.IsOwned() && Settings.QuickSilver && Player.Instance.HasCCs())
            {
                Core.DelayAction(() => QuickSilver.Cast(), Settings.CleanseDelay);
                Activator.lastUsed = Environment.TickCount + 1500;
            }

            var ally = EntityManager.Heroes.Allies.FirstOrDefault(a => a.IsValidTarget(Mikael.Range));
            if (ally == null)
            {
                return;
            }
            if (!ally.HasCCs())
            {
                return;
            }

            if (Mikael.IsReady() && Mikael.IsOwned() && Settings.MikaelCleanse)
            {
                Core.DelayAction(() => Mikael.Cast(ally), Settings.CleanseDelay);
                Activator.lastUsed = Environment.TickCount + 1500;
            }

            #endregion Self
        }
Exemple #8
0
            //----------------------------------------------Combo()------------------------------------------------

            public static void Combo()
            {
                if ((Scimitar.IsReady() || QSS.IsReady()) && Player.HasBuffOfType(BuffType.Charm) || Player.HasBuffOfType(BuffType.Blind) || Player.HasBuffOfType(BuffType.Fear) || Player.HasBuffOfType(BuffType.Polymorph) || Player.HasBuffOfType(BuffType.Silence) || Player.HasBuffOfType(BuffType.Sleep) || Player.HasBuffOfType(BuffType.Snare) || Player.HasBuffOfType(BuffType.Stun) || Player.HasBuffOfType(BuffType.Suppression) || Player.HasBuffOfType(BuffType.Taunt))
                {
                    Scimitar.Cast(); QSS.Cast();
                }

                if (Menu["UseQCombo"].Cast <CheckBox>().CurrentValue&& QIsReady && QRange)
                {
                    if (Menu["SmartQ"].Cast <CheckBox>().CurrentValue)
                    {
                        QLogic();
                    }
                    else if (Menu["SaveQDodge"].Cast <CheckBox>().CurrentValue)
                    {
                    }
                    else
                    {
                        Q.Cast(Target);
                    }
                }

                if (Smite != null)
                {
                    if (Target.IsValidTarget(Smite.Range) && Smite.IsReady())
                    {
                        if (Smite.Name.Contains("gank"))
                        {
                            Smite.Cast(Target);
                        }
                        else if (Smite.Name.Contains("duel") && AARange)
                        {
                            Smite.Cast(Target);
                        }
                    }
                }

                if (Menu["UseRCombo"].Cast <CheckBox>().CurrentValue&& R.IsReady() && Player.Distance(Target) <= Player.GetAutoAttackRange(Target) + 300)
                {
                    R.Cast();
                }

                if (Menu["UseECombo"].Cast <CheckBox>().CurrentValue&& EIsReady && AARange)
                {
                    E.Cast();
                }

                if (QRange && GhostBlade.IsReady())
                {
                    GhostBlade.Cast();
                }

                if (Target.IsValidTarget(550) && BOTRK.IsReady())
                {
                    BOTRK.Cast(Target);
                }

                if (Target.IsValidTarget(550) && Bilgewater.IsReady())
                {
                    Bilgewater.Cast(Target);
                }

                if (Target.IsValidTarget(350) && Tiamat.IsReady())
                {
                    Tiamat.Cast();
                }

                if (Target.IsValidTarget(100) && Titanic.IsReady() && Titanic.Cast())
                {
                    Orbwalker.ResetAutoAttack();
                }

                if (Target.IsValidTarget(350) && Hydra.IsReady())
                {
                    Hydra.Cast();
                }

                if (Target.IsValidTarget(450) && Randuin.IsReady())
                {
                    Randuin.Cast();
                }

                if (Target.IsValidTarget(700) && Hextech.IsReady())
                {
                    Hextech.Cast(Target);
                }

                return;
            }
Exemple #9
0
        //-------------------------------------------Game_OnTick----------------------------------------------

        static void Game_OnTick(EventArgs args)
        {
            if (_Player.IsDead)
            {
                return;
            }
            var useItems = AutoMenu["useItems"].Cast <CheckBox>().CurrentValue;

            if (_Player.CountEnemiesInRange(1000) > 0)
            {
                foreach (AIHeroClient enemy in EntityManager.Heroes.Enemies)
                {
                    foreach (AIHeroClient ally in EntityManager.Heroes.Allies)
                    {
                        if (ally.IsFacing(enemy) && ally.HealthPercent <= 30 && _Player.Distance(ally) <= 750)
                        {
                            if (useItems && FOTMountain.IsReady())
                            {
                                FOTMountain.Cast(ally);
                            }


                            if ((useItems && ally.HasBuffOfType(BuffType.Charm) || ally.HasBuffOfType(BuffType.Fear) || ally.HasBuffOfType(BuffType.Poison) || ally.HasBuffOfType(BuffType.Polymorph) || ally.HasBuffOfType(BuffType.Silence) || ally.HasBuffOfType(BuffType.Sleep) || ally.HasBuffOfType(BuffType.Slow) || ally.HasBuffOfType(BuffType.Snare) || ally.HasBuffOfType(BuffType.Stun) || ally.HasBuffOfType(BuffType.Taunt)) && Mikael.IsReady())
                            {
                                Mikael.Cast(ally);
                            }
                        }

                        if (ally.HasBuffOfType(BuffType.Slow))
                        {
                            E.Cast(ally);
                        }

                        if (ally.IsFacing(enemy) && ally.HealthPercent <= 30 && _Player.Distance(ally) <= 600)
                        {
                            if (useItems && IronSolari.IsReady())
                            {
                                IronSolari.Cast();
                            }
                        }
                    }
                }
            }

            if (!_Player.HasBuff("recall"))
            {
                foreach (AIHeroClient allys in EntityManager.Heroes.Allies)
                {
                    if (W.IsReady() && allys != _Player && EntityManager.Heroes.Allies.Where(ally => ally.HealthPercent <= AutoMenu["AutoWV"].Cast <Slider>().CurrentValue&& W.IsInRange(ally)).Any() && _Player.ManaPercent >= AutoMenu["ManaToW"].Cast <Slider>().CurrentValue)
                    {
                        W.Cast(allys);
                    }
                }
            }



            //-------------------------------------------------Harass-------------------------------------------

            if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Harass))
            {
                Target = TargetSelector.GetTarget(875, DamageType.Magical);
                var HarassUseQ = HarassMenu["HarassUseQ"].Cast <CheckBox>().CurrentValue;
                var HarassUseW = HarassMenu["HarassUseW"].Cast <CheckBox>().CurrentValue;
                var HarassUseE = HarassMenu["HarassUseE"].Cast <CheckBox>().CurrentValue;
                if (HarassUseQ && Q.IsReady() && Target.IsValidTarget(Q.Range - 35))
                {
                    Q.Cast(Target);
                }


                if (HarassUseW && W.IsReady() && Target.IsValidTarget(W.Range))
                {
                    W.Cast(Target);
                }
                foreach (AIHeroClient enemy in EntityManager.Heroes.Enemies)
                {
                    foreach (AIHeroClient ally in EntityManager.Heroes.Allies)
                    {
                        if (HarassUseE && E.IsReady() && _Player.Distance(enemy) <= 1000 && _Player.Distance(ally) <= 725)
                        {
                            E.Cast(ally);
                        }
                    }
                }
            }

            //---------------------------------------------------Combo--------------------------------------------

            if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo))
            {
                var ComboUseQ = ComboMenu["ComboUseQ"].Cast <CheckBox>().CurrentValue;
                var ComboUseW = ComboMenu["ComboUseW"].Cast <CheckBox>().CurrentValue;
                var ComboUseE = ComboMenu["ComboUseE"].Cast <CheckBox>().CurrentValue;
                var ComboUseR = ComboMenu["ComboUseR"].Cast <CheckBox>().CurrentValue;
                Target = TargetSelector.GetTarget(875, DamageType.Magical);
                foreach (AIHeroClient enemy in EntityManager.Heroes.Enemies)
                {
                    foreach (AIHeroClient ally in EntityManager.Heroes.Allies)
                    {
                        if (ComboUseE && E.IsReady() && ally != _Player && _Player.Distance(enemy) <= 1000 && _Player.Distance(ally) <= 725)
                        {
                            E.Cast(ally);
                        }
                        var AutoRCount = AutoMenu["AutoRCount"].Cast <Slider>().CurrentValue;
                        if (ComboUseR && enemy.IsFacing(ally) && _Player.CountEnemiesInRange(2000) > AutoRCount)
                        {
                            R.Cast(enemy);
                        }
                    }
                }
                if (useItems && QSS.IsReady() && (_Player.HasBuffOfType(BuffType.Charm) || _Player.HasBuffOfType(BuffType.Blind) || _Player.HasBuffOfType(BuffType.Fear) || _Player.HasBuffOfType(BuffType.Polymorph) || _Player.HasBuffOfType(BuffType.Silence) || _Player.HasBuffOfType(BuffType.Sleep) || _Player.HasBuffOfType(BuffType.Snare) || _Player.HasBuffOfType(BuffType.Stun) || _Player.HasBuffOfType(BuffType.Suppression) || _Player.HasBuffOfType(BuffType.Taunt)))
                {
                    QSS.Cast();
                }
                if (ComboUseQ && Q.IsReady() && Target.IsValidTarget(Q.Range))
                {
                    Q.Cast(Target);
                }

                if (ComboUseW && W.IsReady() && Target.IsValidTarget(W.Range))
                {
                    W.Cast(Target);
                }

                if (useItems && Target.IsValidTarget(Bilgewater.Range) && Bilgewater.IsReady())
                {
                    Bilgewater.Cast(Target);
                }

                if (useItems && Target.IsValidTarget(Randuin.Range) && Randuin.IsReady())
                {
                    Randuin.Cast();
                }
            }
        }
Exemple #10
0
            //---------------------------------------------Combo()------------------------------------------------

            public static void Combo()
            {
                bool AARange = Player.IsInAutoAttackRange(Target);

                if ((Scimitar.IsReady() || QSS.IsReady()) && Player.HasBuffOfType(BuffType.Charm) || Player.HasBuffOfType(BuffType.Blind) || Player.HasBuffOfType(BuffType.Fear) || Player.HasBuffOfType(BuffType.Polymorph) || Player.HasBuffOfType(BuffType.Silence) || Player.HasBuffOfType(BuffType.Sleep) || Player.HasBuffOfType(BuffType.Snare) || Player.HasBuffOfType(BuffType.Stun) || Player.HasBuffOfType(BuffType.Suppression) || Player.HasBuffOfType(BuffType.Taunt))
                {
                    Scimitar.Cast(); QSS.Cast();
                }

                if (E.IsReady() && !Player.HasBuff("JaxCounterStrike") && Menu["UseECombo"].Cast <CheckBox>().CurrentValue)
                {
                    if (Target.IsValidTarget(Q.Range))
                    {
                        E.Cast();
                        ETick = Environment.TickCount;
                    }
                }

                if (R.IsReady() && Menu["UseRCombo"].Cast <CheckBox>().CurrentValue)
                {
                    if (Player.CountEnemiesInRange(650) >= Menu["Min Enemies R"].Cast <Slider>().CurrentValue)
                    {
                        R.Cast();
                    }
                    else if (Menu["Use1v1RLogic"].Cast <CheckBox>().CurrentValue&& Target.IsValidTarget(600) && (Player.HealthPercent <= 42 || Target.HealthPercent > 30))
                    {
                        R.Cast();
                    }
                }

                if (Menu["UseQCombo"].Cast <CheckBox>().CurrentValue&& Q.IsReady() && Target.IsValidTarget(Q.Range))
                {
                    if (Menu["QOnDash"].Cast <CheckBox>().CurrentValue&& Player.Distance(Target) <= Player.GetAutoAttackRange() + 100)
                    {
                        if (Target.IsDashing())
                        {
                            Q.Cast(Target);
                        }
                    }
                    else if (Environment.TickCount - ETick >= Menu["QDelayCombo"].Cast <Slider>().CurrentValue)
                    {
                        Q.Cast(Target);
                    }
                }

                if (Smite != null)
                {
                    if (Target.IsValidTarget(Smite.Range) && Smite.IsReady())
                    {
                        if (Smite.Name.Contains("gank"))
                        {
                            Smite.Cast(Target);
                        }
                        else if (Smite.Name.Contains("duel") && AARange)
                        {
                            Smite.Cast(Target);
                        }
                    }
                }

                if (Target.IsValidTarget(Q.Range) && GhostBlade.IsReady())
                {
                    GhostBlade.Cast();
                }

                if (Target.IsValidTarget(550) && BOTRK.IsReady())
                {
                    BOTRK.Cast(Target);
                }

                if (Target.IsValidTarget(550) && Bilgewater.IsReady())
                {
                    Bilgewater.Cast(Target);
                }

                if (Target.IsValidTarget(400) && Tiamat.IsReady())
                {
                    Tiamat.Cast();
                }

                if (Target.IsValidTarget(400) && Hydra.IsReady())
                {
                    Hydra.Cast();
                }

                if (Target.IsValidTarget(500) && Randuin.IsReady())
                {
                    Randuin.Cast();
                }

                if (Target.IsValidTarget(700) && Hextech.IsReady())
                {
                    Hextech.Cast(Target);
                }

                return;
            }
Exemple #11
0
            //---------------------------------------------Combo()------------------------------------------------

            public static void Combo()
            {
                if (!EBuff())
                {
                    if (Menu["UseECombo"].Cast <CheckBox>().CurrentValue&& EIsReady && ERange)
                    {
                        E.Cast();
                    }
                    if (Menu["UseQCombo"].Cast <CheckBox>().CurrentValue&& QIsReady && QRange)
                    {
                        Q.HitChanceCast(Target, 75);
                    }
                }

                if (Menu["UseRCombo"].Cast <CheckBox>().CurrentValue&& Player.CountEnemiesInRange(R.Range) >= Menu["Min Enemies R"].Cast <Slider>().CurrentValue)
                {
                    R.Cast();
                }

                if (Menu["UseWCombo"].Cast <CheckBox>().CurrentValue&& WIsReady && WRange && Target.HasBuff("kennenmarkofstorm"))
                {
                    W.Cast();
                }

                if (Smite != null)
                {
                    if (Smite.IsInRange(Target) && Smite.IsReady())
                    {
                        if (Smite.Name.Contains("gank"))
                        {
                            Smite.Cast(Target);
                        }
                        else if (Smite.Name.Contains("duel") && Player.IsInAutoAttackRange(Target))
                        {
                            Smite.Cast(Target);
                        }
                    }
                }

                if (Talisma.IsReady() && CountAlliesInRange(650) > 0)
                {
                    Talisma.Cast();
                }

                if (Exhaust != null && Menu["UseExhaust?"].Cast <CheckBox>().CurrentValue&& TargetSelector.GetPriority(Target) > 3 && Target.IsValidTarget(Exhaust.Range))
                {
                    Exhaust.Cast(Target);
                }

                if (ERange && GhostBlade.IsReady())
                {
                    GhostBlade.Cast();
                }

                if (Target.IsValidTarget(550) && BOTRK.IsReady())
                {
                    BOTRK.Cast(Target);
                }

                if (Target.IsValidTarget(550) && Bilgewater.IsReady())
                {
                    Bilgewater.Cast(Target);
                }

                if (Target.IsValidTarget(500) && Randuin.IsReady())
                {
                    Randuin.Cast();
                }

                if (Target.IsValidTarget(700) && Hextech.IsReady())
                {
                    Hextech.Cast(Target);
                }

                return;
            }
Exemple #12
0
            //---------------------------------------------Combo()------------------------------------------------

            public static void Combo()
            {
                if (R.IsReady() && Menu["UseRCombo"].Cast <CheckBox>().CurrentValue&& R.IsInRange(Target) && SpellDamage(Target, SpellSlot.R) >= Target.Health)
                {
                    R.HitChanceCast(Target, 70);
                }

                if (W.IsReady() && (WRange || (Q.IsReady() && QRange)) && Menu["UseWCombo"].Cast <CheckBox>().CurrentValue)
                {
                    var WPos = Prediction.Position.PredictUnitPosition(Target, 1000).To3D(); W.Cast(CorrectRange(WPos, W.Range));
                }

                else if (Orbwalker.ValidAzirSoldiers.Any())
                {
                    if (Q.IsReady() && Menu["UseQCombo"].Cast <CheckBox>().CurrentValue&& QRange)
                    {
                        Q.HitChanceCast(Target, Menu["QHitChanceCombo"].Cast <Slider>().CurrentValue);
                    }
                    if (E.IsReady() && Menu["UseECombo"].Cast <CheckBox>().CurrentValue)
                    {
                        CastE(Target);
                    }
                }

                if (Smite != null)
                {
                    if (Smite.IsInRange(Target) && Smite.IsReady())
                    {
                        if (Smite.Name.Contains("gank"))
                        {
                            Smite.Cast(Target);
                        }
                        else if (Smite.Name.Contains("duel") && Player.IsInAutoAttackRange(Target))
                        {
                            Smite.Cast(Target);
                        }
                    }
                }

                if (Talisma.IsReady() && Player.CountAlliesInRange(600) > 0)
                {
                    Talisma.Cast();
                }

                if (Exhaust != null && Menu["UseExhaust?"].Cast <CheckBox>().CurrentValue&& TargetSelector.GetPriority(Target) > 3 && Target.IsValidTarget(Exhaust.Range))
                {
                    Exhaust.Cast(Target);
                }

                if (Target.IsValidTarget(500) && Randuin.IsReady())
                {
                    Randuin.Cast();
                }

                if (Target.IsValidTarget(700) && Hextech.IsReady())
                {
                    Hextech.Cast(Target);
                }

                return;
            }
Exemple #13
0
        public static void Execute()
        {
            if (Player.Instance.IsInShopRange() || Player.Instance.CountAlliesInRange(Misc.RangeEnemy) < Misc.EnemyCount ||
                Activator.lastUsed >= Environment.TickCount)
            {
                return;
            }
            #region Self

            if (Zhonyas.IsReady() && Zhonyas.IsOwned() && Player.Instance.InDanger(Settings.ZhonyasMyHp) && Settings.Zhonyas)
            {
                Zhonyas.Cast();
                Activator.lastUsed = Environment.TickCount + 1500;
            }

            if (ArchengelStaff.IsReady() && ArchengelStaff.IsOwned() && Player.Instance.InDanger(Settings.MYHPArchengelStaff) && Settings.UseArchengelStaff)
            {
                ArchengelStaff.Cast();
                Activator.lastUsed = Environment.TickCount + 1500;
            }

            if (FaceOfTheMountain.IsReady() && FaceOfTheMountain.IsOwned() && Player.Instance.InDanger(30))
            {
                FaceOfTheMountain.Cast(Player.Instance);
                Activator.lastUsed = Environment.TickCount + 1500;
            }

            if (Talisman.IsReady() && Player.Instance.CountAlliesInRange(450) >= 2 && Talisman.IsOwned() &&
                Player.Instance.InDanger(30))
            {
                Talisman.Cast();
                Activator.lastUsed = Environment.TickCount + 1500;
            }

            if (Mikael.IsReady() && Player.Instance.HasCC() && Mikael.IsOwned() && Player.Instance.InDanger(30))
            {
                Mikael.Cast(Player.Instance);
                Activator.lastUsed = Environment.TickCount + 1500;
            }

            if (Solari.IsReady() && Solari.IsOwned() && Player.Instance.InDanger(30))
            {
                Solari.Cast();
                Activator.lastUsed = Environment.TickCount + 1500;
            }

            if (Ohm.IsReady() && Ohm.IsOwned() && Player.Instance.InDanger(30))
            {
                var turret = EntityManager.Turrets.Enemies.FirstOrDefault(t => t.IsAttackingPlayer);
                if (turret != null)
                {
                    Ohm.Cast(turret);
                    Activator.lastUsed = Environment.TickCount + 1500;
                }
            }

            if (Randuin.IsReady() && Player.Instance.CountEnemiesInRange(Randuin.Range) >= 2 && Randuin.IsOwned() &&
                Player.Instance.InDanger(30))
            {
                Randuin.Cast();
                Activator.lastUsed = Environment.TickCount + 1500;
            }

            //CC

            if (!Player.Instance.HasCC())
            {
                return;
            }

            if (DerbishBlade.IsReady() && DerbishBlade.IsOwned())
            {
                DerbishBlade.Cast();
                Activator.lastUsed = Environment.TickCount + 1500;
            }

            if (Mercurial.IsReady() && Mercurial.IsOwned())
            {
                Mercurial.Cast();
                Activator.lastUsed = Environment.TickCount + 1500;
            }

            if (QuickSilver.IsReady() && QuickSilver.IsOwned())
            {
                QuickSilver.Cast();
                Activator.lastUsed = Environment.TickCount + 1500;
            }

            #endregion Self
        }
Exemple #14
0
            //---------------------------------------------Combo()------------------------------------------------

            public static void Combo()
            {
                if ((Scimitar.IsReady() || QSS.IsReady()) && Player.HasBuffOfType(BuffType.Charm) || Player.HasBuffOfType(BuffType.Blind) || Player.HasBuffOfType(BuffType.Fear) || Player.HasBuffOfType(BuffType.Polymorph) || Player.HasBuffOfType(BuffType.Silence) || Player.HasBuffOfType(BuffType.Sleep) || Player.HasBuffOfType(BuffType.Snare) || Player.HasBuffOfType(BuffType.Stun) || Player.HasBuffOfType(BuffType.Suppression) || Player.HasBuffOfType(BuffType.Taunt))
                {
                    Scimitar.Cast(); QSS.Cast();
                }

                if (Smite != null)
                {
                    if (Target.IsValidTarget(Smite.Range) && Smite.IsReady())
                    {
                        if (Smite.Name.Contains("gank"))
                        {
                            Smite.Cast(Target);
                        }
                        else if (Smite.Name.Contains("duel") && Player.IsInAutoAttackRange(Target))
                        {
                            Smite.Cast(Target);
                        }
                    }
                }

                if (Menu["UseQCombo"].Cast <CheckBox>().CurrentValue&& Q.IsReady() && Target.IsValidTarget(Player.GetAutoAttackRange() + 300) && !Menu["QAfterAA"].Cast <CheckBox>().CurrentValue)
                {
                    Q.Cast();
                }

                if (Menu["UseWCombo"].Cast <CheckBox>().CurrentValue&& W.IsReady() && Player.IsFacing(Target) && Target.IsValidTarget(Player.GetAutoAttackRange() + 300))
                {
                    W.Cast();
                }

                if (Menu["UseECombo"].Cast <CheckBox>().CurrentValue&& E.IsReady() && Target.IsValidTarget(E.Range) && !Player.HasBuff("GarenE"))
                {
                    if (Menu["JEBQ"].Cast <CheckBox>().CurrentValue&& Q.IsReady())
                    {
                        if (Target.HasBuffOfType(BuffType.Silence))
                        {
                            E.Cast();
                        }
                    }
                    else
                    {
                        E.Cast();
                    }
                }

                if (R.IsReady())
                {
                    if (Menu["UseRCombo"].Cast <CheckBox>().CurrentValue&& Target.IsValidTarget(R.Range) && SpellDamage(Target, SpellSlot.R) > (Target.Health + (Target.HasBuff("garenpassiveenemytarget") ? 0 : Target.MagicShield)) + 20)
                    {
                        if (Player.HasBuff("GarenE"))
                        {
                            E.Cast();
                        }
                        R.Cast(Target);
                    }
                }

                if (Target.IsValidTarget(Player.GetAutoAttackRange() + 300) && GhostBlade.IsReady())
                {
                    GhostBlade.Cast();
                }

                if (Target.IsValidTarget(550) && BOTRK.IsReady())
                {
                    BOTRK.Cast(Target);
                }

                if (Target.IsValidTarget(550) && Bilgewater.IsReady())
                {
                    Bilgewater.Cast(Target);
                }

                if (Target.IsValidTarget(400) && Tiamat.IsReady())
                {
                    Tiamat.Cast();
                }

                if (Target.IsValidTarget(400) && Hydra.IsReady())
                {
                    Hydra.Cast();
                }

                if (Target.IsValidTarget(500) && Randuin.IsReady())
                {
                    Randuin.Cast();
                }

                return;
            }
Exemple #15
0
            //---------------------------------------------Combo()------------------------------------------------

            public static void Combo()
            {
                if (R.IsInRange(Target) && R.IsReady())
                {
                    PosAndHits = GetBestRPos(Target.ServerPosition.To2D());

                    if (Menu["UseRCombo"].Cast <CheckBox>().CurrentValue&& PosAndHits.First().Value >= Menu["Min Enemies R"].Cast <Slider>().CurrentValue)
                    {
                        if (EntityManager.Heroes.Allies.Where(ally => ally != Player && ally.Distance(Player) <= 700).Count() > 0)
                        {
                            if (Glory.IsReady())
                            {
                                Glory.Cast();
                            }
                            if (Talisma.IsReady())
                            {
                                Talisma.Cast();
                            }
                        }
                        R.Cast(PosAndHits.First().Key.To3D());
                    }
                }

                if (Smite != null)
                {
                    if (Target.IsValidTarget(Smite.Range) && Smite.IsReady())
                    {
                        if (Smite.Name.Contains("gank"))
                        {
                            Smite.Cast(Target);
                        }
                        else if (Smite.Name.Contains("duel") && Player.IsInAutoAttackRange(Target))
                        {
                            Smite.Cast(Target);
                        }
                    }
                }

                if (Menu["UseQCombo"].Cast <CheckBox>().CurrentValue&& QIsReady && QRange)
                {
                    Q.Cast(Target);
                }

                if (Menu["UseECombo"].Cast <CheckBox>().CurrentValue&& EIsReady && ERange)
                {
                    E.Cast();
                }

                if (Menu["UseWCombo"].Cast <CheckBox>().CurrentValue&& WIsReady && WRange)
                {
                    W.Cast();
                }

                if (Randuin.IsReady() && Target.IsValidTarget(500))
                {
                    Randuin.Cast();
                }

                if (Bilgewater.IsReady() && Target.IsValidTarget(550))
                {
                    Bilgewater.Cast(Target);
                }

                if (BOTRK.IsReady() && Target.IsValidTarget(550))
                {
                    BOTRK.Cast(Target);
                }

                if (Tiamat.IsReady() && Target.IsValidTarget(400))
                {
                    Tiamat.Cast();
                }

                if (Hydra.IsReady() && Target.IsValidTarget(400))
                {
                    Hydra.Cast();
                }

                return;
            }
Exemple #16
0
        public static void Execute()
        {
            var target =
                EntityManager.Heroes.Enemies.FirstOrDefault(e => !e.IsDead && e.IsInRange(Player.Instance, 1500));

            if (Player.Instance.IsInShopRange() || target == null || DamageHandler.LastItemCast > Environment.TickCount)
            {
                return;
            }

            #region Self

            if (Zhonyas.IsReady() && Player.Instance.InDanger() && Zhonyas.IsOwned())
            {
                Zhonyas.Cast();
                DamageHandler.LastItemCast = Environment.TickCount + 450;
            }

            if (ArchengelStaff.IsReady() && Player.Instance.InDanger() && ArchengelStaff.IsOwned())
            {
                ArchengelStaff.Cast();
                DamageHandler.LastItemCast = Environment.TickCount + 450;
            }

            if (FaceOfTheMountain.IsReady() && Player.Instance.InDanger() && FaceOfTheMountain.IsOwned())
            {
                FaceOfTheMountain.Cast(Player.Instance);
                DamageHandler.LastItemCast = Environment.TickCount + 450;
            }

            if (Talisman.IsReady() && Player.Instance.CountAlliesInRange(450) >= 2 ||
                Player.Instance.InDanger() && FaceOfTheMountain.IsOwned())
            {
                FaceOfTheMountain.Cast();
                DamageHandler.LastItemCast = Environment.TickCount + 450;
            }

            if (Mikael.IsReady() && Player.Instance.InDanger() || Player.Instance.HasCC() && Mikael.IsOwned())
            {
                Mikael.Cast(Player.Instance);
                DamageHandler.LastItemCast = Environment.TickCount + 450;
            }

            if (Solari.IsReady() && Player.Instance.InDanger() && Solari.IsOwned())
            {
                Solari.Cast();
                DamageHandler.LastItemCast = Environment.TickCount + 450;
            }

            if (Ohm.IsReady() && Ohm.IsOwned())
            {
                var turret = EntityManager.Turrets.Enemies.FirstOrDefault(t => t.IsAttackingPlayer);
                if (turret != null)
                {
                    Ohm.Cast(turret);
                    DamageHandler.LastItemCast = Environment.TickCount + 450;
                }
            }

            if (Randuin.IsReady() && Player.Instance.CountEnemiesInRange(Randuin.Range) >= 2 && Randuin.IsOwned())
            {
                Randuin.Cast();
                DamageHandler.LastItemCast = Environment.TickCount + 450;
            }

            //CC

            if (!Player.Instance.HasCC())
            {
                return;
            }

            if (DerbishBlade.IsReady() && DerbishBlade.IsOwned())
            {
                DerbishBlade.Cast();
                DamageHandler.LastItemCast = Environment.TickCount + 450;
            }

            if (Mercurial.IsReady() && Mercurial.IsOwned())
            {
                Mercurial.Cast();
                DamageHandler.LastItemCast = Environment.TickCount + 450;
            }

            if (QuickSilver.IsReady() && QuickSilver.IsOwned())
            {
                QuickSilver.Cast();
                DamageHandler.LastItemCast = Environment.TickCount + 450;
            }

            #endregion Self

            #region Ally

            if (DamageHandler.LastItemCast < Environment.TickCount)
            {
                if (FaceOfTheMountain.IsReady() && FaceOfTheMountain.IsOwned())
                {
                    foreach (
                        var ally in
                        EntityManager.Heroes.Allies.Where(
                            a => DamageHandler.Damages.ContainsKey(a.NetworkId) && a.InDanger()))
                    {
                        FaceOfTheMountain.Cast(ally);
                        DamageHandler.LastItemCast = Environment.TickCount + 450;
                    }
                }
            }

            if (Talisman.IsReady() && Player.Instance.CountAlliesInRange(450) >= 2 ||
                Player.Instance.InDanger() && FaceOfTheMountain.IsOwned())
            {
                foreach (
                    var ally in
                    EntityManager.Heroes.Allies.Where(
                        a => DamageHandler.Damages.ContainsKey(a.NetworkId) && a.InDanger()))
                {
                    FaceOfTheMountain.Cast(ally);
                    DamageHandler.LastItemCast = Environment.TickCount + 450;
                }
            }

            if (Mikael.IsReady() && Player.Instance.InDanger() || Player.Instance.HasCC() && Mikael.IsOwned())
            {
                foreach (
                    var ally in
                    EntityManager.Heroes.Allies.Where(
                        a => DamageHandler.Damages.ContainsKey(a.NetworkId) && a.InDanger()))
                {
                    Mikael.Cast(ally);
                    DamageHandler.LastItemCast = Environment.TickCount + 450;
                }
            }

            if (Solari.IsReady() && Player.Instance.InDanger() && Solari.IsOwned())
            {
                foreach (
                    var ally in
                    EntityManager.Heroes.Allies.Where(
                        a => DamageHandler.Damages.ContainsKey(a.NetworkId) && a.InDanger()))
                {
                    Solari.Cast(ally);
                    DamageHandler.LastItemCast = Environment.TickCount + 450;
                }
            }

            if (Ohm.IsReady() && Ohm.IsOwned())
            {
                foreach (var objAiTurret in EntityManager.Turrets.AllTurrets)
                {
                    if (DamageHandler.LastTargetTurrets.ContainsKey(objAiTurret.NetworkId))
                    {
                        var turrettarget = DamageHandler.LastTargetTurrets[objAiTurret.NetworkId];
                        if (!turrettarget.IsValidTarget() || !turrettarget.IsAlly)
                        {
                            continue;
                        }
                        Ohm.Cast();
                        DamageHandler.LastItemCast = Environment.TickCount + 450;
                    }
                }
            }
        }
Exemple #17
0
            private static void Items()
            {
                if (ObjectManager.GetLocalPlayer().IsDead || ObjectManager.GetLocalPlayer().IsRecalling() ||
                    ObjectManager.GetLocalPlayer().IsInFountainRange() ||
                    !ItemsMenu["SharpShooter.UtilityMenu.ItemsMenu.Enabled"].Enabled)
                {
                    return;
                }

                #region Youmuu

                if (ItemsMenu["SharpShooter.UtilityMenu.ItemsMenu.YoumuusEnabled"].Enabled && Youmuus.IsMine && Youmuus.Ready)
                {
                    var target = GetTarget(800);

                    if (target != null && target.IsValidTarget(800) && MyLogic.Orbwalker.Mode == OrbwalkingMode.Combo)
                    {
                        Youmuus.Cast();
                        return;
                    }
                }

                #endregion

                #region Cutlass

                if (ItemsMenu["SharpShooter.UtilityMenu.ItemsMenu.CutlassEnabled"].Enabled && Cutlass.IsMine && Cutlass.Ready)
                {
                    var target = GetTarget(Cutlass.Range);

                    if (target != null && target.IsValidTarget(Cutlass.Range))
                    {
                        if (Cutlass.GetDamage(target) > target.Health)
                        {
                            Cutlass.CastOnUnit(target);
                            return;
                        }

                        if (MyLogic.Orbwalker.Mode == OrbwalkingMode.Combo)
                        {
                            if (target.IsValidAutoRange())
                            {
                                Cutlass.CastOnUnit(target);
                                return;
                            }
                        }
                    }
                }

                #endregion

                #region Botrk

                if (ItemsMenu["SharpShooter.UtilityMenu.ItemsMenu.BOTRKEnabled"].Enabled && Botrk.IsMine && Botrk.Ready)
                {
                    var target = GetTarget(Botrk.Range);

                    if (target != null && target.IsValidTarget(Botrk.Range))
                    {
                        if (Botrk.GetDamage(target) > target.Health)
                        {
                            Botrk.CastOnUnit(target);
                            return;
                        }

                        if (MyLogic.Orbwalker.Mode == OrbwalkingMode.Combo)
                        {
                            if (target.IsValidAutoRange())
                            {
                                Botrk.CastOnUnit(target);
                                return;
                            }
                        }
                    }
                }

                #endregion

                #region Hextech

                if (ItemsMenu["SharpShooter.UtilityMenu.ItemsMenu.GunbladeEnabled"].Enabled && Hextech.IsMine && Hextech.Ready)
                {
                    var target = GetTarget(Hextech.Range);

                    if (target != null && target.IsValidTarget(Hextech.Range))
                    {
                        if (Hextech.GetDamage(target) > target.Health)
                        {
                            Hextech.CastOnUnit(target);
                            return;
                        }

                        if (MyLogic.Orbwalker.Mode == OrbwalkingMode.Combo)
                        {
                            if (target.IsValidAutoRange())
                            {
                                if (target.HealthPercent() <= 80)
                                {
                                    Hextech.CastOnUnit(target);
                                    return;
                                }
                            }
                        }
                    }
                }

                #endregion

                #region Randuin

                if (ItemsMenu["SharpShooter.UtilityMenu.ItemsMenu.RanduinsOmenEnabled"].Enabled && Randuin.IsMine && Randuin.Ready)
                {
                    if (MyLogic.Orbwalker.Mode == OrbwalkingMode.Combo)
                    {
                        if (ObjectManager.GetLocalPlayer().CountEnemyHeroesInRange(Randuin.Range) >= 3)
                        {
                            Randuin.Cast();
                        }
                    }
                }

                #endregion
            }
Exemple #18
0
        static void Game_OnTick(EventArgs args)
        {
            var UseFOT    = (Auto["AutoFOT"].Cast <CheckBox>().CurrentValue);
            var UseMikael = (Auto["AutoMikael"].Cast <CheckBox>().CurrentValue);

            if (Player.IsDead)
            {
                return;
            }

            if (Player.CountEnemiesInRange(1000) > 0)
            {
                foreach (AIHeroClient enemy in EntityManager.Heroes.Enemies)
                {
                    foreach (AIHeroClient ally in EntityManager.Heroes.Allies)
                    {
                        if (ally.IsFacing(enemy) && ally.HealthPercent <= 30 && Player.Distance(ally) <= 750)
                        {
                            if (UseFOT && FOTMountain.IsReady())
                            {
                                FOTMountain.Cast(ally);
                            }

                            if (UseMikael && (ally.HasBuffOfType(BuffType.Charm) || ally.HasBuffOfType(BuffType.Fear) || ally.HasBuffOfType(BuffType.Polymorph) || ally.HasBuffOfType(BuffType.Silence) || ally.HasBuffOfType(BuffType.Sleep) || ally.HasBuffOfType(BuffType.Snare) || ally.HasBuffOfType(BuffType.Stun) || ally.HasBuffOfType(BuffType.Taunt) || ally.HasBuffOfType(BuffType.Polymorph)) && Mikael.IsReady())
                            {
                                Mikael.Cast(ally);
                            }
                        }
                    }
                }
            }

            Target = TargetSelector.GetTarget(700, DamageType.Magical);
            var useGlory   = (Auto["AutoGlory"].Cast <CheckBox>().CurrentValue);
            var useRanduin = (Auto["AutoRanduin"].Cast <CheckBox>().CurrentValue);
            var rCount     = Combo["rCount"].Cast <Slider>().CurrentValue;

            if (Target != null)
            {
                if (Target.IsValidTarget())
                {
                    if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo))
                    {
                        var useQ  = Combo["ComboUseQ"].Cast <CheckBox>().CurrentValue;
                        var useW  = Combo["ComboUseW"].Cast <CheckBox>().CurrentValue;
                        var useE  = Combo["ComboUseE"].Cast <CheckBox>().CurrentValue;
                        var useR  = Combo["ComboUseR"].Cast <CheckBox>().CurrentValue;
                        var level = 15 * Player.Level;
                        if (QSS.IsReady() && (Player.HasBuffOfType(BuffType.Charm) || Player.HasBuffOfType(BuffType.Blind) || Player.HasBuffOfType(BuffType.Fear) || Player.HasBuffOfType(BuffType.Polymorph) || Player.HasBuffOfType(BuffType.Silence) || Player.HasBuffOfType(BuffType.Sleep) || Player.HasBuffOfType(BuffType.Snare) || Player.HasBuffOfType(BuffType.Stun) || Player.HasBuffOfType(BuffType.Suppression) || Player.HasBuffOfType(BuffType.Taunt)))
                        {
                            QSS.Cast();
                        }

                        foreach (AIHeroClient ally in EntityManager.Heroes.Allies)
                        {
                            if (EntityManager.Heroes.Enemies.Where(enemy => enemy != Player && enemy.Distance(Player) <= 1000).Count() > 0 && ally.Distance(Player) <= 600 && Solari.IsReady())
                            {
                                if (ally.HealthPercent < 50)
                                {
                                    Solari.Cast();
                                }
                            }
                        }
                        if (Q.IsReady() && Target.IsValidTarget(Q.Range) && !Player.IsDashing() && useQ)
                        {
                            Q.Cast(Target);
                        }

                        foreach (AIHeroClient enemy in EntityManager.Heroes.Enemies)
                        {
                            foreach (AIHeroClient ally in EntityManager.Heroes.Allies)
                            {
                                if (W.IsReady() && Target.CanCast && useW)
                                {
                                    W.Cast(ally);
                                    if (E.IsReady() && useE)
                                    {
                                        E.Cast(Target);
                                    }
                                }
                            }
                        }
                        if (EntityManager.Heroes.Allies.Where(ally => ally != Player && ally.Distance(Player) <= 700).Count() > 0 && Glory.IsReady() && useGlory)
                        {
                            Glory.Cast();
                            if (Q.IsReady() && useQ)
                            {
                                Q.Cast(Target);
                            }
                        }

                        foreach (AIHeroClient enemie in EntityManager.Heroes.Enemies)
                        {
                            if (Combo["rCount"].Cast <Slider>().CurrentValue > 0 && R.IsReady() && EntityManager.Heroes.Enemies.Where(enemy => enemy != Player && enemy.Distance(Player) <= 1200).Count() >= rCount && R.IsReady() && !enemie.IsDead && !enemie.IsZombie && useR)
                            {
                                R.Cast(enemie);
                            }
                        }

                        if (Target.IsValidTarget(Bilgewater.Range) && Bilgewater.IsReady())
                        {
                            Bilgewater.Cast(Target);
                        }

                        if (useRanduin && Target.IsValidTarget(Randuin.Range) && Randuin.IsReady())
                        {
                            Randuin.Cast();
                        }
                    }
                    if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Harass))
                    {
                        if (Q.IsReady() && Target.IsValidTarget(Q.Range))
                        {
                            Q.Cast(Target);
                        }
                    }
                    foreach (AIHeroClient allie in EntityManager.Heroes.Allies)
                    {
                        if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Flee))
                        {
                            if (EntityManager.Heroes.Allies.Where(ally => ally != Player && ally.Distance(Player) <= 700).Count() > 0)
                            {
                                W.Cast(allie);
                            }
                        }
                    }
                }
            }

            return;
        }
Exemple #19
0
            //----------------------------------------------Combo()------------------------------------------------

            public static void Combo()
            {
                if ((Scimitar.IsReady() || QSS.IsReady()) && Player.HasBuffOfType(BuffType.Charm) || Player.HasBuffOfType(BuffType.Blind) || Player.HasBuffOfType(BuffType.Fear) || Player.HasBuffOfType(BuffType.Polymorph) || Player.HasBuffOfType(BuffType.Silence) || Player.HasBuffOfType(BuffType.Sleep) || Player.HasBuffOfType(BuffType.Snare) || Player.HasBuffOfType(BuffType.Stun) || Player.HasBuffOfType(BuffType.Suppression) || Player.HasBuffOfType(BuffType.Taunt))
                {
                    Scimitar.Cast(); QSS.Cast();
                }

                if (Menu["UseQCombo"].Cast <CheckBox>().CurrentValue&& QIsReady)
                {
                    if (QRange)
                    {
                        if (Menu["SmartQ"].Cast <CheckBox>().CurrentValue)
                        {
                            QLogic();
                        }
                        else if (Menu["UseWBeforeQCombo"].Cast <CheckBox>().CurrentValue&& WIsReady)
                        {
                            W.Cast();
                            Core.DelayAction(() => Q.Cast(Target), Game.Ping + W.CastDelay);
                        }
                        else
                        {
                            Q.Cast(Target);
                        }
                    }

                    else if (GapCloseTarget != null && Menu["QGapCloserCombo"].Cast <CheckBox>().CurrentValue)
                    {
                        if (Item.HasItem(ItemId.Trinity_Force))
                        {
                            var Minions = EntityManager.MinionsAndMonsters.CombinedAttackable.Where(it => it.IsValidTarget(Q.Range) && it.Distance(Game.CursorPos) <= 500 && SpellDamage(it, SpellSlot.Q) >= it.Health);

                            if (Minions.Any())
                            {
                                var Minion = Minions.OrderBy(it => it.Distance(GapCloseTarget)).First();
                                Q.Cast(Minion);
                            }

                            else if (R.IsReady() && Menu["UseRGapCloser"].Cast <CheckBox>().CurrentValue)
                            {
                                Minions = EntityManager.MinionsAndMonsters.CombinedAttackable.Where(it => it.IsValidTarget(Q.Range) && it.Distance(Game.CursorPos) <= 500 && SpellDamage(it, SpellSlot.Q) + SpellDamage(it, SpellSlot.R) >= it.Health);

                                if (Minions.Any())
                                {
                                    var Minion = Minions.OrderBy(it => it.Distance(GapCloseTarget)).First();

                                    if (R.Cast(Minion))
                                    {
                                        Core.DelayAction(() => Q.Cast(Minion), Game.Ping + R.CastDelay + 400);
                                    }
                                }
                            }
                        }

                        else if (Item.HasItem(ItemId.Sheen))
                        {
                            var Minions = EntityManager.MinionsAndMonsters.CombinedAttackable.Where(it => it.IsValidTarget(Q.Range) && it.Distance(Game.CursorPos) <= 500 && SpellDamage(it, SpellSlot.Q) >= it.Health);

                            if (Minions.Any())
                            {
                                var Minion = Minions.OrderBy(it => it.Distance(GapCloseTarget)).First();
                                Q.Cast(Minion);
                            }

                            else if (R.IsReady() && Menu["UseRGapCloser"].Cast <CheckBox>().CurrentValue)
                            {
                                Minions = EntityManager.MinionsAndMonsters.CombinedAttackable.Where(it => it.IsValidTarget(Q.Range) && it.Distance(Game.CursorPos) <= 500 && SpellDamage(it, SpellSlot.Q) + SpellDamage(it, SpellSlot.R) >= it.Health);

                                if (Minions.Any())
                                {
                                    var Minion = Minions.OrderBy(it => it.Distance(GapCloseTarget)).First();

                                    if (R.Cast(Minion))
                                    {
                                        Core.DelayAction(() => Q.Cast(Minion), Game.Ping + R.CastDelay + 400);
                                    }
                                }
                            }
                        }

                        else
                        {
                            var Minions = EntityManager.MinionsAndMonsters.CombinedAttackable.Where(it => it.IsValidTarget(Q.Range) && it.Distance(Game.CursorPos) <= 500 && SpellDamage(it, SpellSlot.Q) >= it.Health);

                            if (Minions.Any())
                            {
                                var Minion = Minions.OrderBy(it => it.Distance(GapCloseTarget)).First();
                                Q.Cast(Minion);
                            }
                        }
                    }
                }

                if (Smite != null)
                {
                    if (Target.IsValidTarget(Smite.Range) && Smite.IsReady())
                    {
                        if (Smite.Name.Contains("gank"))
                        {
                            Smite.Cast(Target);
                        }
                        else if (Smite.Name.Contains("duel") && AARange)
                        {
                            Smite.Cast(Target);
                        }
                    }
                }

                if (Menu["UseWCombo"].Cast <CheckBox>().CurrentValue&& WIsReady && (!QIsReady || !Menu["UseWBeforeQCombo"].Cast <CheckBox>().CurrentValue) && AARange)
                {
                    W.Cast();
                }

                if (Menu["UseRCombo"].Cast <CheckBox>().CurrentValue&& R.IsReady() && Player.Distance(Target) <= 900)
                {
                    var RPred = R.GetPrediction(Target);

                    if (RPred.HitChancePercent >= 75)
                    {
                        if (Menu["UseRSelfActived"].Cast <CheckBox>().CurrentValue)
                        {
                            if (Player.HasBuff("ireliatranscendentbladesspell"))
                            {
                                R.Cast(RPred.CastPosition);
                            }
                        }
                        else
                        {
                            R.Cast(RPred.CastPosition);
                        }
                    }
                }

                if (Menu["UseECombo"].Cast <CheckBox>().CurrentValue&& EIsReady && E.IsInRange(Target))
                {
                    if (Menu["OnlyEStunCombo"].Cast <CheckBox>().CurrentValue)
                    {
                        if (Player.HealthPercent <= Target.HealthPercent)
                        {
                            E.Cast(Target);
                        }
                    }
                    else
                    {
                        E.Cast(Target);
                    }
                }

                if (QRange && GhostBlade.IsReady())
                {
                    GhostBlade.Cast();
                }

                if (Target.IsValidTarget(550) && BOTRK.IsReady())
                {
                    BOTRK.Cast(Target);
                }

                if (Target.IsValidTarget(550) && Bilgewater.IsReady())
                {
                    Bilgewater.Cast(Target);
                }

                if (Target.IsValidTarget(400) && Tiamat.IsReady())
                {
                    Tiamat.Cast();
                }

                if (Target.IsValidTarget(400) && Hydra.IsReady())
                {
                    Hydra.Cast();
                }

                if (Target.IsValidTarget(500) && Randuin.IsReady())
                {
                    Randuin.Cast();
                }

                if (Target.IsValidTarget(700) && Hextech.IsReady())
                {
                    Hextech.Cast(Target);
                }

                return;
            }