Exemple #1
0
    private void Offensive()
    {
        if (Botrk.IsReady() && MainMenu.Item("Botrk").GetValue <bool>())
        {
            var t = TargetSelector.GetTarget(Botrk.Range, TargetSelector.DamageType.Physical);
            if (t.IsValidTarget())
            {
                if (MainMenu.Item("BotrkKS").GetValue <bool>() && Player.CalcDamage(t, Damage.DamageType.Physical, t.MaxHealth * 0.1) > t.Health - OktwCommon.GetIncomingDamage(t))
                {
                    Botrk.Cast(t);
                }
                if (MainMenu.Item("BotrkLS").GetValue <bool>() && Player.Health < Player.MaxHealth * 0.5 - OktwCommon.GetIncomingDamage(Player))
                {
                    Botrk.Cast(t);
                }
                if (MainMenu.Item("BotrkCombo").GetValue <bool>() && Program.Combo)
                {
                    Botrk.Cast(t);
                }
            }
        }

        if (GLP800.IsReady() && MainMenu.Item("GLP800").GetValue <bool>())
        {
            var t = TargetSelector.GetTarget(GLP800.Range, TargetSelector.DamageType.Magical);
            if (t.IsValidTarget())
            {
                if (MainMenu.Item("GLP800KS").GetValue <bool>() && Player.CalcDamage(t, Damage.DamageType.Magical, 200 + Player.FlatMagicDamageMod * 0.35) > t.Health - OktwCommon.GetIncomingDamage(t))
                {
                    GLP800.Cast(Prediction.GetPrediction(t, 0.5f).CastPosition);
                }
                if (MainMenu.Item("GLP800Combo").GetValue <bool>() && Program.Combo)
                {
                    Program.debug("PRO");
                    GLP800.Cast(Prediction.GetPrediction(t, 0.5f).CastPosition);
                }
            }
        }

        if (Protobelt.IsReady() && MainMenu.Item("Protobelt").GetValue <bool>())
        {
            var t = TargetSelector.GetTarget(Protobelt.Range, TargetSelector.DamageType.Magical);
            if (t.IsValidTarget())
            {
                if (MainMenu.Item("ProtobeltKS").GetValue <bool>() && Player.CalcDamage(t, Damage.DamageType.Magical, 150 + Player.FlatMagicDamageMod * 0.35) > t.Health - OktwCommon.GetIncomingDamage(t))
                {
                    Protobelt.Cast(Prediction.GetPrediction(t, 0.5f).CastPosition);
                }
                if (MainMenu.Item("ProtobeltCombo").GetValue <bool>() && Program.Combo)
                {
                    Program.debug("PRO");
                    Protobelt.Cast(Prediction.GetPrediction(t, 0.5f).CastPosition);
                }
            }
        }

        if (Hextech.IsReady() && MainMenu.Item("Hextech").GetValue <bool>())
        {
            var t = TargetSelector.GetTarget(Hextech.Range, TargetSelector.DamageType.Magical);
            if (t.IsValidTarget())
            {
                if (MainMenu.Item("HextechKS").GetValue <bool>() && Player.CalcDamage(t, Damage.DamageType.Magical, 150 + Player.FlatMagicDamageMod * 0.4) > t.Health - OktwCommon.GetIncomingDamage(t))
                {
                    Hextech.Cast(t);
                }
                if (MainMenu.Item("HextechCombo").GetValue <bool>() && Program.Combo)
                {
                    Hextech.Cast(t);
                }
            }
        }

        if (Program.Combo && FrostQueen.IsReady() && MainMenu.Item("FrostQueen").GetValue <bool>() && Player.CountEnemiesInRange(800) > 0)
        {
            FrostQueen.Cast();
        }

        if (Cutlass.IsReady() && MainMenu.Item("Cutlass").GetValue <bool>())
        {
            var t = TargetSelector.GetTarget(Cutlass.Range, TargetSelector.DamageType.Magical);
            if (t.IsValidTarget())
            {
                if (MainMenu.Item("CutlassKS").GetValue <bool>() && Player.CalcDamage(t, Damage.DamageType.Magical, 100) > t.Health - OktwCommon.GetIncomingDamage(t))
                {
                    Cutlass.Cast(t);
                }
                if (MainMenu.Item("CutlassCombo").GetValue <bool>() && Program.Combo)
                {
                    Cutlass.Cast(t);
                }
            }
        }

        if (Youmuus.IsReady() && MainMenu.Item("Youmuus").GetValue <bool>() && Program.Combo)
        {
            var t = Orbwalker.GetTarget();

            if (t.IsValidTarget() && t is Obj_AI_Hero)
            {
                if (MainMenu.Item("YoumuusKS").GetValue <bool>() && t.Health < Player.MaxHealth)
                {
                    Youmuus.Cast();
                }
                if (MainMenu.Item("YoumuusCombo").GetValue <bool>())
                {
                    Youmuus.Cast();
                }
            }
        }

        if (MainMenu.Item("Hydra").GetValue <bool>())
        {
            if (Hydra.IsReady() && Player.CountEnemiesInRange(Hydra.Range) > 0)
            {
                Hydra.Cast();
            }
            else if (Hydra2.IsReady() && Player.CountEnemiesInRange(Hydra2.Range) > 0)
            {
                Hydra2.Cast();
            }
        }
    }
Exemple #2
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;
            }
Exemple #3
0
        public static void Execute()
        {
            var target = TargetSelector.GetTarget(1000, DamageType.Mixed);

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

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

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

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

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

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

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

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

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

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

                if (Settings.Manamune && Manamune.IsOwned() && Manamune.IsReady() && target.IsValidTarget(Manamune.Range))
                {
                    if (target.HealthPercent < Settings.ManamuneTargetHP && Player.Instance.ManaPercent > Settings.ManamuneMana)
                    {
                        var manamune = Player.Instance.Spellbook.Spells.FirstOrDefault(s => s.Name.ToLower().Contains("manamune"));
                        if (manamune != null && manamune.ToggleState == 1)
                        {
                            Manamune.Cast();
                        }
                    }
                }
            }
        }
Exemple #4
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 #5
0
        private void Clear()
        {
            SmiteMob();
            var minionObj = MinionManager.GetMinions(
                E.Range, MinionTypes.All, MinionTeam.NotAlly, MinionOrderTypes.MaxHealth);

            if (!minionObj.Any())
            {
                return;
            }
            if (GetValue <bool>("Clear", "Q") && Q.IsReady())
            {
                var pos = Q.GetCircularFarmLocation(
                    minionObj.Where(i => Q.IsInRange(i, Q.Range + Q.Width / 2)).ToList());
                if (pos.MinionsHit > 1)
                {
                    if (Q.Cast(pos.Position, PacketCast))
                    {
                        return;
                    }
                }
                else
                {
                    var obj = minionObj.FirstOrDefault(i => i.MaxHealth >= 1200);
                    if (obj != null && Q.IsInRange(obj, Q.Range + Q2.Width / 2) &&
                        Q2.CastIfHitchanceEquals(obj, HitChance.Medium, PacketCast))
                    {
                        return;
                    }
                }
            }
            if (GetValue <bool>("Clear", "E") && E.IsReady())
            {
                var pos = E.GetLineFarmLocation(minionObj);
                if (pos.MinionsHit > 0 && E.Cast(pos.Position, PacketCast))
                {
                    return;
                }
            }
            if (GetValue <bool>("Clear", "W") && W.IsReady())
            {
                if (Player.HealthPercent >=
                    (GetValue <bool>("Clear", "WPriority") ? 85 : GetValue <Slider>("Clear", "WHpU").Value))
                {
                    if (!HaveWDmg && W.Cast(PacketCast))
                    {
                        return;
                    }
                }
                else if (HaveWDmg && W.Cast(PacketCast))
                {
                    return;
                }
            }
            if (GetValue <bool>("Clear", "Item"))
            {
                var item = Hydra.IsReady() ? Hydra : Tiamat;
                if (item.IsReady() &&
                    (minionObj.Count(i => item.IsInRange(i)) > 2 ||
                     minionObj.Any(i => i.MaxHealth >= 1200 && i.Distance(Player) < item.Range - 80)))
                {
                    item.Cast();
                }
            }
        }
Exemple #6
0
        private void Combo()
        {
            var useQ                 = Config.Item("ComboUseQ").GetValue <bool>();
            var useW                 = Config.Item("ComboUseW").GetValue <bool>();
            var useE                 = Config.Item("ComboUseE").GetValue <bool>();
            var useR                 = Config.Item("ComboUseR").GetValue <bool>();
            var dontEUnderTurret     = Config.Item("ComboDontEUnderTurret").GetValue <bool>();
            var comboMinimumREnemies = Config.Item("ComboMinimumREnemies").GetValue <Slider>().Value;

            var target = TargetSelector.GetTarget(E.Range, TargetSelector.DamageType.Physical);

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

            if (useR && (Player.CountEnemiesInRange(E.Range) >= comboMinimumREnemies) && R.Instance.IsReady())
            {
                R.Cast();
            }

            if (useE && E.Instance.IsReady() && !Q.IsInRange(target))
            {
                if (target.UnderTurret() && dontEUnderTurret)
                {
                    return;
                }
                E.Cast(target.Position);
            }
            if (useQ && Q.Instance.IsReady())
            {
                Q.CastOnUnit(target);
            }
            if ((_isMidAir && target.IsValidTarget(Hydra.Range)) || target.IsValidTarget(Tiamat.Range) ||
                target.IsValidTarget(TitanicHydra.Range))
            {
                if (Hydra.IsReady())
                {
                    Hydra.Cast();
                }
                if (TitanicHydra.IsReady())
                {
                    TitanicHydra.Cast();
                }
                if (Tiamat.IsReady())
                {
                    Tiamat.Cast();
                }
            }
            if (useW && W.Instance.IsReady())
            {
                SebbySpell(W, target);
            }

            if (Youmuu.IsReady() && target.IsValidTarget(Player.AttackRange + 400))
            {
                Youmuu.Cast();
            }
            if (Hydra.IsReady() && target.IsValidTarget(Hydra.Range))
            {
                Hydra.Cast();
            }
            if (TitanicHydra.IsReady() && target.IsValidTarget(TitanicHydra.Range))
            {
                TitanicHydra.Cast();
            }
            if (Tiamat.IsReady() && target.IsValidTarget(Tiamat.Range))
            {
                Tiamat.Cast();
            }
        }
Exemple #7
0
        private static void DoCombo(bool useR = true)
        {
            var target = TargetSelector.GetTarget(Riven.EWRange, TargetSelector.DamageType.Physical);

            if (!target.IsValidTarget())
            {
                Riven.Orbwalker.SetOrbwalkingPoint(new Vector3());
                return;
            }

            Riven.LastTarget = target;

            if (Riven.GetBool("FollowTarget") && Orbwalking.CanMove(0))
            {
                Riven.Orbwalker.SetOrbwalkingPoint(
                    target.Distance(Riven.Player) < Orbwalking.GetRealAutoAttackRange(Riven.Player)
                        ? new Vector3()
                        : target.ServerPosition);
            }

            if (Ghostblade.IsReady())
            {
                Ghostblade.Cast();
            }

            if (Riven.RActivated && Riven.CanWindSlash && useR)
            {
                UseWindSlash(target);
            }

            // Use R logic
            if (CanHardEngage(target) && !Riven.RActivated && Riven.R.IsReady() &&
                target.HealthPercentage() > Riven.Menu.Item("UseRPercent").GetValue <Slider>().Value&& useR &&
                Riven.GetBool("UseR" + Riven.Orbwalker.ActiveMode))
            {
                NotificationHandler.ShowInfo("Using R!");

                // E -> R
                if (Riven.E.IsReady())
                {
                    var distE = Riven.Player.ServerPosition.Extend(target.Position, Riven.E.Range);

                    if (Riven.GetBool("DontEIntoWall") && distE.IsWall())
                    {
                        return;
                    }

                    Riven.E.Cast(target.ServerPosition);
                    Riven.R.Cast(Riven.Player);
                }
                // Q -> Q -> E -> R -> Q
                else if (Riven.QCount == 2 && Riven.Q.IsReady() && Riven.E.IsReady())
                {
                    Riven.E.Cast();
                    Riven.R.Cast(target);
                }
                // R -> W
                else if (Riven.W.IsReady() && ObjectManager.Get <AIHeroClient>().Any(x => x.IsValidTarget(Riven.W.Range)))
                {
                    Riven.R.Cast(Riven.Player);
                    Riven.W.Cast();
                }
                else if (Riven.GetBool("UseRIfCantCancel"))
                {
                    Riven.R.Cast(Riven.Player);
                }
                else
                {
                    NotificationHandler.ShowInfo("Could not use R! (CD)");
                }
            }

            if (target.Distance(Riven.Player) < Riven.EWRange &&
                (!Riven.Q.IsReady() || target.Distance(Riven.Player) > Riven.Q.Range) && Riven.E.IsReady() &&
                Riven.W.IsReady() && Riven.GetBool("UseE" + Riven.Orbwalker.ActiveMode) &&
                Riven.GetBool("UseW" + Riven.Orbwalker.ActiveMode))
            {
                var distE = Riven.Player.ServerPosition.Extend(target.Position, Riven.E.Range);

                if (Riven.GetBool("DontEIntoWall") && distE.IsWall())
                {
                    return;
                }

                Riven.E.Cast(target.Position);
                CastCircleThing();
                CastW();
            }
            else if ((Hydra.IsReady() || Tiamat.IsReady()) && Riven.W.IsReady() &&
                     Riven.GetBool("UseW" + Riven.Orbwalker.ActiveMode))
            {
                CastCircleThing();
                CastW();
            }
            else if (Riven.W.IsReady() && Riven.GetBool("UseW" + Riven.Orbwalker.ActiveMode))
            {
                CastW();
            }
            else if (Riven.E.IsReady() && Riven.GetBool("GapcloseE"))
            {
                if (target.Distance(Riven.Player) < Orbwalking.GetRealAutoAttackRange(Riven.Player) &&
                    Riven.GetBool("DontEInAARange"))
                {
                    return;
                }

                var distE = Riven.Player.ServerPosition.Extend(target.Position, Riven.E.Range);

                if (Riven.GetBool("DontEIntoWall") && distE.IsWall())
                {
                    return;
                }

                Riven.E.Cast(target.Position);
            }
            else if (Riven.Q.IsReady() && Environment.TickCount - Riven.LastQ >= 2000 &&
                     Riven.Player.Distance(target) > Riven.Q.Range && Riven.GetBool("GapcloseQ"))
            {
                Riven.Q.Cast(target.Position);
            }
        }
Exemple #8
0
        void Waveclear()
        {
            List <Obj_AI_Minion> allMinions = ObjectManager.Get <Obj_AI_Minion>().Where(x => x.LSIsValidTarget(W.Range) && !MinionManager.IsWard(x)).ToList();

            if (getCheckBoxItem(farm, "UseQFarm") && Q.IsReady())
            {
                var minion = Orbwalker.LastTarget as Obj_AI_Minion;
                if (minion != null && HealthPrediction.GetHealthPrediction(
                        minion, (int)(Khazix.LSDistance(minion) * 1000 / 1400)) >
                    0.35f * Khazix.GetSpellDamage(minion, SpellSlot.Q) && Khazix.LSDistance(minion) <= Q.Range)
                {
                    Q.Cast(minion);
                }
                else if (minion == null || !minion.IsValid)
                {
                    foreach (var min in allMinions.Where(x => x.LSIsValidTarget(Q.Range)))
                    {
                        if (HealthPrediction.GetHealthPrediction(
                                min, (int)(Khazix.LSDistance(min) * 1000 / 1400)) >
                            3 * Khazix.GetSpellDamage(min, SpellSlot.Q) && Khazix.LSDistance(min) <= Q.Range)
                        {
                            Q.Cast(min);
                            break;
                        }
                    }
                }
            }

            if (getCheckBoxItem(farm, "UseWFarm") && W.IsReady() && Khazix.HealthPercent <= getSliderItem(farm, "Farm.WHealth"))
            {
                var wmins = EvolvedW ? allMinions.Where(x => x.LSIsValidTarget(WE.Range)) : allMinions.Where(x => x.LSIsValidTarget(W.Range));
                MinionManager.FarmLocation farmLocation = MinionManager.GetBestCircularFarmLocation(wmins
                                                                                                    .Select(minion => minion.ServerPosition.LSTo2D())
                                                                                                    .ToList(), EvolvedW ? WE.Width : W.Width, EvolvedW ? WE.Range : W.Range);
                var distcheck = EvolvedW ? Khazix.LSDistance(farmLocation.Position) <= WE.Range : Khazix.LSDistance(farmLocation.Position) <= W.Range;
                if (distcheck)
                {
                    W.Cast(farmLocation.Position);
                }
            }

            if (getCheckBoxItem(farm, "UseEFarm") && E.IsReady())
            {
                MinionManager.FarmLocation farmLocation =
                    MinionManager.GetBestCircularFarmLocation(
                        MinionManager.GetMinions(Khazix.ServerPosition, E.Range)
                        .Select(minion => minion.ServerPosition.LSTo2D())
                        .ToList(), E.Width, E.Range);
                if (Khazix.LSDistance(farmLocation.Position) <= E.Range)
                {
                    E.Cast(farmLocation.Position);
                }
            }


            if (getCheckBoxItem(farm, "UseItemsFarm"))
            {
                MinionManager.FarmLocation farmLocation =
                    MinionManager.GetBestCircularFarmLocation(
                        MinionManager.GetMinions(Khazix.ServerPosition, Hydra.Range)
                        .Select(minion => minion.ServerPosition.LSTo2D())
                        .ToList(), Hydra.Range, Hydra.Range);

                if (Hydra.IsReady() && Khazix.LSDistance(farmLocation.Position) <= Hydra.Range && farmLocation.MinionsHit >= 2)
                {
                    Items.UseItem(3074, Khazix);
                }
                if (Tiamat.IsReady() && Khazix.LSDistance(farmLocation.Position) <= Tiamat.Range && farmLocation.MinionsHit >= 2)
                {
                    Items.UseItem(3077, Khazix);
                }
                if (Titanic.IsReady() && Khazix.LSDistance(farmLocation.Position) <= Titanic.Range && farmLocation.MinionsHit >= 2)
                {
                    Items.UseItem(3748, Khazix);
                }
            }
        }
Exemple #9
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 #10
0
        private void Offensive()
        {
            if (Botrk.IsReady() && Config.Item("Botrk").GetValue <bool>())
            {
                var t = TargetSelector.GetTarget(Botrk.Range, TargetSelector.DamageType.Physical);
                if (t.IsValidTarget())
                {
                    if (Config.Item("BotrkKS").GetValue <bool>() && Player.CalcDamage(t, Damage.DamageType.Physical, t.MaxHealth * 0.1) > t.Health)
                    {
                        Botrk.Cast(t);
                    }
                    if (Config.Item("BotrkLS").GetValue <bool>() && Player.Health < Player.MaxHealth * 0.5)
                    {
                        Botrk.Cast(t);
                    }
                    if (Config.Item("BotrkCombo").GetValue <bool>() && Program.Combo)
                    {
                        Botrk.Cast(t);
                    }
                }
            }

            if (Hextech.IsReady() && Config.Item("Hextech").GetValue <bool>())
            {
                var t = TargetSelector.GetTarget(Hextech.Range, TargetSelector.DamageType.Magical);
                if (t.IsValidTarget())
                {
                    if (Config.Item("HextechKS").GetValue <bool>() && Player.CalcDamage(t, Damage.DamageType.Magical, 150 + Player.FlatMagicDamageMod * 0.4) > t.Health)
                    {
                        Hextech.Cast(t);
                    }
                    if (Config.Item("HextechCombo").GetValue <bool>() && Program.Combo)
                    {
                        Hextech.Cast(t);
                    }
                }
            }

            if (Cutlass.IsReady() && Config.Item("Cutlass").GetValue <bool>())
            {
                var t = TargetSelector.GetTarget(Cutlass.Range, TargetSelector.DamageType.Magical);
                if (t.IsValidTarget())
                {
                    if (Config.Item("CutlassKS").GetValue <bool>() && Player.CalcDamage(t, Damage.DamageType.Magical, 100) > t.Health)
                    {
                        Cutlass.Cast(t);
                    }
                    if (Config.Item("CutlassCombo").GetValue <bool>() && Program.Combo)
                    {
                        Cutlass.Cast(t);
                    }
                }
            }

            if (Youmuus.IsReady() && Config.Item("Youmuus").GetValue <bool>())
            {
                var t = Orbwalker.GetTarget();

                if (t.IsValidTarget() && t is Obj_AI_Hero)
                {
                    if (Config.Item("YoumuusKS").GetValue <bool>() && t.Health < Player.MaxHealth * 0.6)
                    {
                        Youmuus.Cast();
                    }
                    if (Config.Item("YoumuusCombo").GetValue <bool>() && Program.Combo)
                    {
                        Youmuus.Cast();
                    }
                }
            }

            if (Config.Item("Hydra").GetValue <bool>())
            {
                if (Hydra.IsReady() && Player.CountEnemiesInRange(Hydra.Range) > 0)
                {
                    Hydra.Cast();
                }
                else if (Hydra2.IsReady() && Player.CountEnemiesInRange(Hydra2.Range) > 0)
                {
                    Hydra2.Cast();
                }
            }
        }
Exemple #11
0
 private static bool CanCastHydra()
 {
     return(Hydra != null && Hydra.IsReady());
 }
Exemple #12
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 #13
0
        public static void Execute()
        {
            if (LastRun > Environment.TickCount)
            {
                return;
            }

            var target =
                EntityManager.Heroes.Enemies.FirstOrDefault(e => !e.IsDead && e.IsInRange(Player.Instance, 1000));

            if (Player.Instance.IsRecalling() || Player.Instance.IsInShopRange() || target == null ||
                !Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo))
            {
                return;
            }

            if (Settings.Bilgewater && BilgewaterCutlass.IsOwned() && BilgewaterCutlass.IsReady())
            {
                if (Settings.BilgewaterMyHp >= Player.Instance.HealthPercent &&
                    target.HealthPercent <= Settings.BilgewaterTargetHp)
                {
                    BilgewaterCutlass.Cast(target);
                }
            }

            if (Settings.Blade && BladeOfTheRuinedKing.IsOwned() && BladeOfTheRuinedKing.IsReady())
            {
                if (Settings.BladeMyHp >= Player.Instance.HealthPercent &&
                    target.HealthPercent <= Settings.BladeTargetHp)
                {
                    BladeOfTheRuinedKing.Cast(target);
                }
            }

            if (Settings.Tiamat && Tiamat.IsOwned() && Tiamat.IsReady())
            {
                if (Settings.TiamatMyHp >= Player.Instance.HealthPercent &&
                    target.HealthPercent <= Settings.TiamatTargetHp)
                {
                    Tiamat.Cast();
                }
            }

            if (Settings.Hydra && Hydra.IsOwned() && Hydra.IsReady())
            {
                if (Settings.HydraMyHp >= Player.Instance.HealthPercent &&
                    target.HealthPercent <= Settings.HydraTargetHp)
                {
                    Hydra.Cast();
                }
            }

            if (Settings.Titanic && TitanicHydra.IsOwned() && TitanicHydra.IsReady())
            {
                if (Settings.TitanicMyHp >= Player.Instance.HealthPercent &&
                    target.HealthPercent <= Settings.TitanicTargetHp)
                {
                    TitanicHydra.Cast();
                }
            }

            if (Settings.Youmuu && Youmuu.IsOwned() && Youmuu.IsReady())
            {
                if (Settings.YoumuuMyHp >= Player.Instance.HealthPercent &&
                    target.HealthPercent <= Settings.YoumuuTargetHp)
                {
                    Youmuu.Cast();
                }
            }

            LastRun = Environment.TickCount + 200;
        }
Exemple #14
0
        private void LaneJungClear()
        {
            var minionObj = MinionManager.GetMinions(E.Range, MinionTypes.All, MinionTeam.NotAlly, MinionOrderTypes.MaxHealth);

            if (minionObj.Count == 0)
            {
                return;
            }
            if (GetValue <bool>("Clear", "Q") && Q.IsReady())
            {
                var Pos = Q.GetCircularFarmLocation(minionObj.FindAll(i => Q.IsInRange(i)));
                if (Pos.MinionsHit > 1)
                {
                    if (Pos.Position.IsValid() && Q.Cast(Pos.Position, PacketCast))
                    {
                        return;
                    }
                }
                else
                {
                    var Obj = minionObj.Find(i => i.MaxHealth >= 1200);
                    if (Obj != null && Q.IsInRange(Obj) && Q.CastIfWillHit(Obj, -1, PacketCast))
                    {
                        return;
                    }
                }
            }
            if (GetValue <bool>("Clear", "E") && E.IsReady())
            {
                var Pos = E.GetLineFarmLocation(minionObj);
                if (Pos.MinionsHit > 0 && Pos.Position.IsValid() && E.Cast(Pos.Position, PacketCast))
                {
                    return;
                }
            }
            if (GetValue <bool>("Clear", "W") && W.IsReady())
            {
                if (Player.HealthPercentage() >= (GetValue <bool>("Clear", "WPriority") ? 85 : GetValue <Slider>("Clear", "WHpU").Value))
                {
                    if (!Player.HasBuff("AatroxWPower") && W.Cast(PacketCast))
                    {
                        return;
                    }
                }
                else if (Player.HasBuff("AatroxWPower") && W.Cast(PacketCast))
                {
                    return;
                }
            }
            if (GetValue <bool>("Clear", "Item"))
            {
                var Item = Hydra.IsReady() ? Hydra : Tiamat;
                if (Item.IsReady() && (minionObj.Count(i => Item.IsInRange(i)) > 2 || minionObj.Any(i => i.MaxHealth >= 1200 && i.Distance(Player, true) <= Math.Pow(Item.Range - 80, 2))) && Item.Cast())
                {
                    return;
                }
            }
            if (GetValue <bool>("SmiteMob", "Smite") && Smite.IsReady())
            {
                var Obj = minionObj.Find(i => i.Team == GameObjectTeam.Neutral && CanSmiteMob(i.Name));
                if (Obj != null && CastSmite(Obj))
                {
                    return;
                }
            }
        }
Exemple #15
0
        void Waveclear()
        {
            List <Obj_AI_Minion> allMinions = ObjectManager.Get <Obj_AI_Minion>().OrderBy(x => x.MaxHealth).Where(x => x.IsValidTarget(W.Range) && !MinionManager.IsWard(x)).ToList();

            if (Config.GetBool("UseQFarm") && Q.IsReady() && !Orbwalking.CanAttack())
            {
                bool UsedQ  = false;
                var  minion = Orbwalker.GetTarget() as Obj_AI_Minion;
                if (minion != null)
                {
                    var hpred = HealthPrediction.GetHealthPrediction(minion, (int)(Khazix.Distance(minion) * 1000 / 1400));
                    var qdmg  = Khazix.GetSpellDamage(minion, SpellSlot.Q);
                    if ((hpred <= qdmg || hpred >= qdmg * 3) && Khazix.Distance(minion) <= Q.Range)
                    {
                        Q.Cast(minion);
                        UsedQ = true;
                    }
                }

                if (!UsedQ)
                {
                    var killable = allMinions.Find(x => x.IsInRange(Q.Range) && HealthPrediction.GetHealthPrediction(x, (int)(Khazix.Distance(x) * 1000 / 1400)) <= Khazix.GetSpellDamage(x, SpellSlot.Q));
                    if (killable != null)
                    {
                        Q.Cast(killable);
                    }

                    else
                    {
                        foreach (var min in allMinions.Where(x => x.IsValidTarget(Q.Range)))
                        {
                            if (HealthPrediction.GetHealthPrediction(
                                    min, (int)(Khazix.Distance(min) * 1000 / 1400)) >
                                3 * Khazix.GetSpellDamage(min, SpellSlot.Q) && Khazix.Distance(min) <= Q.Range)
                            {
                                Q.Cast(min);
                                break;
                            }
                        }
                    }
                }
            }

            if (Config.GetBool("UseWFarm") && W.IsReady() && Khazix.HealthPercent <= Config.GetSlider("Farm.WHealth"))
            {
                var wmins = EvolvedW ? allMinions.Where(x => x.IsValidTarget(WE.Range)) : allMinions.Where(x => x.IsValidTarget(W.Range));
                MinionManager.FarmLocation farmLocation = MinionManager.GetBestCircularFarmLocation(wmins
                                                                                                    .Select(minion => minion.ServerPosition.To2D())
                                                                                                    .ToList(), EvolvedW ? WE.Width : W.Width, EvolvedW ? WE.Range : W.Range);
                var distcheck = EvolvedW ? Khazix.Distance(farmLocation.Position) <= WE.Range : Khazix.Distance(farmLocation.Position) <= W.Range;
                if (distcheck)
                {
                    W.Cast(farmLocation.Position);
                }
            }

            if (Config.GetBool("UseEFarm") && E.IsReady())
            {
                MinionManager.FarmLocation farmLocation =
                    MinionManager.GetBestCircularFarmLocation(
                        MinionManager.GetMinions(Khazix.ServerPosition, E.Range)
                        .Select(minion => minion.ServerPosition.To2D())
                        .ToList(), E.Width, E.Range);
                if (Khazix.Distance(farmLocation.Position) <= E.Range)
                {
                    E.Cast(farmLocation.Position);
                }
            }


            if (Config.GetBool("UseItemsFarm") && !Orbwalking.CanAttack())
            {
                MinionManager.FarmLocation farmLocation =
                    MinionManager.GetBestCircularFarmLocation(
                        MinionManager.GetMinions(Khazix.ServerPosition, Hydra.Range)
                        .Select(minion => minion.ServerPosition.To2D())
                        .ToList(), Hydra.Range, Hydra.Range);

                if (Hydra.IsReady() && Khazix.Distance(farmLocation.Position) <= Hydra.Range && farmLocation.MinionsHit >= 2)
                {
                    Items.UseItem(3074, Khazix);
                }
                if (Tiamat.IsReady() && Khazix.Distance(farmLocation.Position) <= Tiamat.Range && farmLocation.MinionsHit >= 2)
                {
                    Items.UseItem(3077, Khazix);
                }
                if (Titanic.IsReady() && Khazix.Distance(farmLocation.Position) <= Titanic.Range && farmLocation.MinionsHit >= 2)
                {
                    Items.UseItem(3748, Khazix);
                }
            }
        }
Exemple #16
0
        void LH()
        {
            List <Obj_AI_Base> allMinions = MinionManager.GetMinions(Khazix.ServerPosition, Q.Range);

            if (getCheckBoxItem(farm, "UseQFarm") && Q.IsReady())
            {
                foreach (Obj_AI_Base minion in
                         allMinions.Where(
                             minion =>
                             minion.LSIsValidTarget() &&
                             HealthPrediction.GetHealthPrediction(
                                 minion, (int)(Khazix.LSDistance(minion) * 1000 / 1400)) <
                             0.75 * Khazix.GetSpellDamage(minion, SpellSlot.Q)))
                {
                    if (Vector3.Distance(minion.ServerPosition, Khazix.ServerPosition) >
                        Orbwalking.GetRealAutoAttackRange(Khazix) && Khazix.LSDistance(minion) <= Q.Range)
                    {
                        Q.CastOnUnit(minion);
                        return;
                    }
                }
            }
            if (getCheckBoxItem(farm, "UseWFarm") && W.IsReady())
            {
                MinionManager.FarmLocation farmLocation = MinionManager.GetBestCircularFarmLocation(
                    MinionManager.GetMinions(Khazix.ServerPosition, W.Range).Where(minion => HealthPrediction.GetHealthPrediction(
                                                                                       minion, (int)(Khazix.LSDistance(minion) * 1000 / 1400)) <
                                                                                   0.75 * Khazix.GetSpellDamage(minion, SpellSlot.W))
                    .Select(minion => minion.ServerPosition.LSTo2D())
                    .ToList(), W.Width, W.Range);
                if (farmLocation.MinionsHit >= 1)
                {
                    if (!EvolvedW)
                    {
                        if (Khazix.LSDistance(farmLocation.Position) <= W.Range)
                        {
                            W.Cast(farmLocation.Position);
                        }
                    }

                    if (EvolvedW)
                    {
                        if (Khazix.LSDistance(farmLocation.Position) <= W.Range)
                        {
                            W.Cast(farmLocation.Position);
                        }
                    }
                }
            }

            if (getCheckBoxItem(farm, "UseEFarm") && E.IsReady())
            {
                MinionManager.FarmLocation farmLocation =
                    MinionManager.GetBestCircularFarmLocation(
                        MinionManager.GetMinions(Khazix.ServerPosition, E.Range).Where(minion => HealthPrediction.GetHealthPrediction(
                                                                                           minion, (int)(Khazix.LSDistance(minion) * 1000 / 1400)) <
                                                                                       0.75 * Khazix.GetSpellDamage(minion, SpellSlot.W))
                        .Select(minion => minion.ServerPosition.LSTo2D())
                        .ToList(), E.Width, E.Range);

                if (farmLocation.MinionsHit >= 1)
                {
                    if (Khazix.LSDistance(farmLocation.Position) <= E.Range)
                    {
                        E.Cast(farmLocation.Position);
                    }
                }
            }


            if (getCheckBoxItem(farm, "UseItemsFarm"))
            {
                MinionManager.FarmLocation farmLocation =
                    MinionManager.GetBestCircularFarmLocation(
                        MinionManager.GetMinions(Khazix.ServerPosition, Hydra.Range)
                        .Select(minion => minion.ServerPosition.LSTo2D())
                        .ToList(), Hydra.Range, Hydra.Range);

                if (Hydra.IsReady() && Khazix.LSDistance(farmLocation.Position) <= Hydra.Range && farmLocation.MinionsHit >= 2)
                {
                    Items.UseItem(3074, Khazix);
                }
                if (Tiamat.IsReady() && Khazix.LSDistance(farmLocation.Position) <= Tiamat.Range && farmLocation.MinionsHit >= 2)
                {
                    Items.UseItem(3077, Khazix);
                }
            }
        }
Exemple #17
0
        void KillSteal()
        {
            //Avoid interrupting our assasination attempt
            if (jumpManager.MidAssasination)
            {
                return;
            }

            Obj_AI_Hero target = HeroList
                                 .Where(x => x.IsValidTarget() && x.Distance(Khazix.Position) < 1375f && !x.IsZombie)
                                 .MinOrDefault(x => x.Health);

            if (target != null)
            {
                if (Config.GetBool("UseIgnite") && Ignite.IsReady() && target.IsInRange(Ignite.Range))
                {
                    double igniteDmg = Khazix.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite);
                    if (igniteDmg > target.Health)
                    {
                        Ignite.Cast(target);
                        return;
                    }
                }

                if (Config.GetBool("UseQKs") && Q.IsReady() &&
                    Vector3.Distance(Khazix.ServerPosition, target.ServerPosition) <= Q.Range)
                {
                    double QDmg = GetQDamage(target);
                    if (!Jumping && target.Health <= QDmg)
                    {
                        Q.Cast(target);
                        return;
                    }
                }

                if (Config.GetBool("UseEKs") && E.IsReady() && !Jumping &&
                    Vector3.Distance(Khazix.ServerPosition, target.ServerPosition) <= E.Range && Vector3.Distance(Khazix.ServerPosition, target.ServerPosition) > Q.Range)
                {
                    double EDmg = Khazix.GetSpellDamage(target, SpellSlot.E);
                    if (!Jumping && target.Health < EDmg)
                    {
                        Utility.DelayAction.Add(
                            Game.Ping + Config.GetSlider("EDelay"), delegate
                        {
                            // PredictionOutput pred = E.GetPrediction(target);
                            if (target.IsValid && !target.IsDead)
                            {
                                if (Config.GetBool("Ksbypass") || ShouldJump(target.ServerPosition))
                                {
                                    E.Cast(target.ServerPosition);
                                }
                            }
                        });
                    }
                }

                if (W.IsReady() && !EvolvedW && Vector3.Distance(Khazix.ServerPosition, target.ServerPosition) <= W.Range &&
                    Config.GetBool("UseWKs"))
                {
                    double WDmg = Khazix.GetSpellDamage(target, SpellSlot.W);
                    if (target.Health <= WDmg)
                    {
                        var pred = W.GetPrediction(target);
                        if (pred.Hitchance >= HitChance.Medium)
                        {
                            W.Cast(pred.CastPosition);
                            return;
                        }
                    }
                }

                if (W.IsReady() && EvolvedW &&
                    Vector3.Distance(Khazix.ServerPosition, target.ServerPosition) <= W.Range &&
                    Config.GetBool("UseWKs"))
                {
                    double           WDmg = Khazix.GetSpellDamage(target, SpellSlot.W);
                    PredictionOutput pred = WE.GetPrediction(target);
                    if (target.Health <= WDmg && pred.Hitchance >= HitChance.Medium)
                    {
                        CastWE(target, pred.UnitPosition.To2D(), 0, Config.GetHitChance("WHitchance"));
                        return;
                    }

                    if (pred.Hitchance >= HitChance.Collision)
                    {
                        List <Obj_AI_Base> PCollision = pred.CollisionObjects;
                        var x =
                            PCollision
                            .FirstOrDefault(PredCollisionChar => Vector3.Distance(PredCollisionChar.ServerPosition, target.ServerPosition) <= 30);
                        if (x != null)
                        {
                            W.Cast(x.Position);
                            return;
                        }
                    }
                }


                // Mixed's EQ KS
                if (Q.IsReady() && E.IsReady() &&
                    Vector3.Distance(Khazix.ServerPosition, target.ServerPosition) <= E.Range + Q.Range &&
                    Config.GetBool("UseEQKs"))
                {
                    double QDmg = GetQDamage(target);
                    double EDmg = Khazix.GetSpellDamage(target, SpellSlot.E);
                    if ((target.Health <= QDmg + EDmg))
                    {
                        Utility.DelayAction.Add(Config.GetSlider("EDelay"), delegate
                        {
                            // PredictionOutput pred = E.GetPrediction(target);
                            if (target.IsValidTarget() && !target.IsZombie)
                            {
                                if (Config.GetBool("Ksbypass") || ShouldJump(target.ServerPosition))
                                {
                                    E.Cast(target.ServerPosition);
                                }
                            }
                        });
                    }
                }

                // MIXED EW KS
                if (W.IsReady() && E.IsReady() && !EvolvedW &&
                    Vector3.Distance(Khazix.ServerPosition, target.ServerPosition) <= W.Range + E.Range &&
                    Config.GetBool("UseEWKs"))
                {
                    double WDmg = Khazix.GetSpellDamage(target, SpellSlot.W);
                    if (target.Health <= WDmg)
                    {
                        Utility.DelayAction.Add(Config.GetSlider("EDelay"), delegate
                        {
                            // PredictionOutput pred = E.GetPrediction(target);
                            if (target.IsValid && !target.IsDead && ShouldJump(target.ServerPosition))
                            {
                                if (Config.GetBool("Ksbypass") || ShouldJump(target.ServerPosition))
                                {
                                    E.Cast(target.ServerPosition);
                                }
                            }
                        });
                    }
                }

                if (Tiamat.IsReady() &&
                    Vector2.Distance(Khazix.ServerPosition.To2D(), target.ServerPosition.To2D()) <= Tiamat.Range &&
                    Config.GetBool("UseTiamatKs"))
                {
                    double Tiamatdmg = Khazix.GetItemDamage(target, Damage.DamageItems.Tiamat);
                    if (target.Health <= Tiamatdmg)
                    {
                        Tiamat.Cast();
                        return;
                    }
                }

                if (Config.GetBool("UseSmiteKs"))
                {
                    if (SmiteManager.CanCast(target))
                    {
                        var dmg = SmiteManager.GetSmiteDamage(target);
                        if (dmg >= target.Health)
                        {
                            SmiteManager.Cast(target);
                        }
                    }
                }

                if (Hydra.IsReady() &&
                    Vector2.Distance(Khazix.ServerPosition.To2D(), target.ServerPosition.To2D()) <= Hydra.Range &&
                    Config.GetBool("UseTiamatKs"))
                {
                    double hydradmg = Khazix.GetItemDamage(target, Damage.DamageItems.Hydra);
                    if (target.Health <= hydradmg)
                    {
                        Hydra.Cast();
                    }
                }
            }
        }
Exemple #18
0
        void KillSteal()
        {
            AIHeroClient target = HeroList
                                  .Where(x => x.LSIsValidTarget() && x.LSDistance(Khazix.Position) < 1375f && !x.IsZombie)
                                  .MinOrDefault(x => x.Health);

            if (target != null && target.IsInRange(600))
            {
                if (getCheckBoxItem(safety, "Safety.autoescape") && !IsHealthy)
                {
                    var ally =
                        HeroList.FirstOrDefault(h => h.HealthPercent > 40 && h.CountEnemiesInRange(400) == 0 && !h.ServerPosition.PointUnderEnemyTurret());
                    if (ally != null && ally.IsValid)
                    {
                        E.Cast(ally.ServerPosition);
                        return;
                    }
                    var underTurret = EnemyTurrets.Any(x => x.Distance(Khazix.ServerPosition) <= 900f && !x.IsDead && x.IsValid);
                    if (underTurret || Khazix.CountEnemiesInRange(500) >= 1)
                    {
                        var bestposition = Khazix.ServerPosition.LSExtend(NexusPosition, E.Range);
                        E.Cast(bestposition);
                        return;
                    }
                }

                if (getCheckBoxItem(ks, "UseQKs") && Q.IsReady() &&
                    Vector3.Distance(Khazix.ServerPosition, target.ServerPosition) <= Q.Range)
                {
                    double QDmg = GetQDamage(target);
                    if (!Jumping && target.Health <= QDmg)
                    {
                        Q.Cast(target);
                        return;
                    }
                }

                if (getCheckBoxItem(ks, "UseEKs") && E.IsReady() && !Jumping &&
                    Vector3.Distance(Khazix.ServerPosition, target.ServerPosition) <= E.Range && Vector3.Distance(Khazix.ServerPosition, target.ServerPosition) > Q.Range)
                {
                    double EDmg = Khazix.GetSpellDamage(target, SpellSlot.E);
                    if (!Jumping && target.Health < EDmg)
                    {
                        LeagueSharp.Common.Utility.DelayAction.Add(
                            Game.Ping + getSliderItem(ks, "Edelay"), delegate
                        {
                            PredictionOutput pred = E.GetPrediction(target);
                            if (target.IsValid && !target.IsDead)
                            {
                                if (getCheckBoxItem(ks, "Ksbypass") || ShouldJump(pred.CastPosition))
                                {
                                    E.Cast(pred.CastPosition);
                                }
                            }
                        });
                    }
                }

                if (W.IsReady() && !EvolvedW && Vector3.Distance(Khazix.ServerPosition, target.ServerPosition) <= W.Range &&
                    getCheckBoxItem(ks, "UseWKs"))
                {
                    double WDmg = Khazix.GetSpellDamage(target, SpellSlot.W);
                    if (target.Health <= WDmg)
                    {
                        var pred = W.GetPrediction(target);
                        if (pred.Hitchance >= HitChance.Medium)
                        {
                            W.Cast(pred.CastPosition);
                            return;
                        }
                    }
                }

                if (W.IsReady() && EvolvedW &&
                    Vector3.Distance(Khazix.ServerPosition, target.ServerPosition) <= W.Range &&
                    getCheckBoxItem(ks, "UseWKs"))
                {
                    double           WDmg = Khazix.GetSpellDamage(target, SpellSlot.W);
                    PredictionOutput pred = WE.GetPrediction(target);
                    if (target.Health <= WDmg && pred.Hitchance >= HitChance.Medium)
                    {
                        CastWE(target, pred.UnitPosition.LSTo2D(), 0, Config.GetHitChance("WHitchance"));
                        return;
                    }

                    if (pred.Hitchance >= HitChance.Collision)
                    {
                        List <Obj_AI_Base> PCollision = pred.CollisionObjects;
                        var x =
                            PCollision
                            .FirstOrDefault(PredCollisionChar => Vector3.Distance(PredCollisionChar.ServerPosition, target.ServerPosition) <= 30);
                        if (x != null)
                        {
                            W.Cast(x.Position);
                            return;
                        }
                    }
                }


                // Mixed's EQ KS
                if (Q.IsReady() && E.IsReady() &&
                    Vector3.Distance(Khazix.ServerPosition, target.ServerPosition) <= E.Range + Q.Range &&
                    getCheckBoxItem(ks, "UseEQKs"))
                {
                    double QDmg = GetQDamage(target);
                    double EDmg = Khazix.GetSpellDamage(target, SpellSlot.E);
                    if ((target.Health <= QDmg + EDmg))
                    {
                        LeagueSharp.Common.Utility.DelayAction.Add(getSliderItem(ks, "Edelay"), delegate
                        {
                            PredictionOutput pred = E.GetPrediction(target);
                            if (target.LSIsValidTarget() && !target.IsZombie && target.IsVisible && target.IsHPBarRendered && ShouldJump(pred.CastPosition))
                            {
                                if (getCheckBoxItem(ks, "Ksbypass") || ShouldJump(pred.CastPosition))
                                {
                                    E.Cast(pred.CastPosition);
                                }
                            }
                        });
                    }
                }

                // MIXED EW KS
                if (W.IsReady() && E.IsReady() && !EvolvedW &&
                    Vector3.Distance(Khazix.ServerPosition, target.ServerPosition) <= W.Range + E.Range &&
                    getCheckBoxItem(ks, "UseEWKs"))
                {
                    double WDmg = Khazix.GetSpellDamage(target, SpellSlot.W);
                    if (target.Health <= WDmg)
                    {
                        LeagueSharp.Common.Utility.DelayAction.Add(getSliderItem(ks, "Edelay"), delegate
                        {
                            PredictionOutput pred = E.GetPrediction(target);
                            if (target.IsValid && !target.IsDead && target.IsVisible && target.IsHPBarRendered && ShouldJump(pred.CastPosition))
                            {
                                if (getCheckBoxItem(ks, "Ksbypass") || ShouldJump(pred.CastPosition))
                                {
                                    E.Cast(pred.CastPosition);
                                }
                            }
                        });
                    }
                }

                if (Tiamat.IsReady() &&
                    Vector2.Distance(Khazix.ServerPosition.LSTo2D(), target.ServerPosition.LSTo2D()) <= Tiamat.Range &&
                    getCheckBoxItem(ks, "UseTiamatKs"))
                {
                    double Tiamatdmg = Khazix.GetItemDamage(target, LeagueSharp.Common.Damage.DamageItems.Tiamat);
                    if (target.Health <= Tiamatdmg)
                    {
                        Tiamat.Cast();
                        return;
                    }
                }
                if (Hydra.IsReady() &&
                    Vector2.Distance(Khazix.ServerPosition.LSTo2D(), target.ServerPosition.LSTo2D()) <= Hydra.Range &&
                    getCheckBoxItem(ks, "UseTiamatKs"))
                {
                    double hydradmg = Khazix.GetItemDamage(target, LeagueSharp.Common.Damage.DamageItems.Hydra);
                    if (target.Health <= hydradmg)
                    {
                        Hydra.Cast();
                    }
                }
            }
        }
Exemple #19
0
        private static void Clear()
        {
            SmiteMob();
            var minionObj =
                Helper.GetMinions(E.Range, MinionTypes.All, MinionTeam.NotAlly, MinionOrderTypes.MaxHealth)
                .Cast <Obj_AI_Base>()
                .ToList();

            if (!minionObj.Any())
            {
                return;
            }
            if (clearQ && Q.IsReady())
            {
                var pos = Q.GetCircularFarmLocation(minionObj.Where(i => Q.IsInRange(i, Q.Range + Q.Width / 2)).ToList());
                if (pos.MinionsHit > 1)
                {
                    Q.Cast(pos.Position);
                    return;
                }
                var obj = minionObj.FirstOrDefault(i => i.MaxHealth >= 1200);
                if (obj != null && Q.IsInRange(obj, Q.Range + Q2.Width / 2) && Q.IsReady())
                {
                    Q.Cast(obj);
                    return;
                }
            }
            if (clearE && E.IsReady())
            {
                var pos = E.GetLineFarmLocation(minionObj);
                if (pos.MinionsHit > 0)
                {
                    E.Cast(pos.Position);
                    return;
                }
            }
            if (clearW && W.IsReady())
            {
                if (myHero.HealthPercent >= (WPriority ? 85 : ClearWHpU))
                {
                    if (!HaveWDmg)
                    {
                        W.Cast();
                        return;
                    }
                }
                else if (HaveWDmg)
                {
                    W.Cast();
                    return;
                }
            }
            if (Item)
            {
                var item = Hydra.IsReady() ? Hydra : Tiamat;
                if (item.IsReady() &&
                    (minionObj.Count(i => item.IsInRange(i)) > 2 ||
                     minionObj.Any(i => i.MaxHealth >= 1200 && i.Distance(myHero) < item.Range - 80)))
                {
                    item.Cast();
                }
            }
        }
Exemple #20
0
        private static void Clear()
        {
            SmiteMob();
            var minionObj = GetMinions(Q.Range, MinionTypes.All, MinionTeam.NotAlly, MinionOrderTypes.MaxHealth);

            if (!minionObj.Any())
            {
                return;
            }
            if (GetValue <bool>("Clear", "E") && E.IsReady() && !HaveE)
            {
                if (GetValue <bool>("Clear", "Q") && Q.IsReady() && !minionObj.Any(i => E.IsInRange(i)))
                {
                    var obj =
                        minionObj.MaxOrDefault(
                            i => GetMinions(i.ServerPosition, E.Range, MinionTypes.All, MinionTeam.NotAlly).Count > 1);
                    if (obj != null && E.Cast(PacketCast) && Q.CastOnUnit(obj, PacketCast))
                    {
                        return;
                    }
                }
                else if ((minionObj.Any(i => i.MaxHealth >= 1200 && E.IsInRange(i)) ||
                          minionObj.Count(i => E.IsInRange(i)) > 2) && E.Cast(PacketCast))
                {
                    return;
                }
            }
            if (GetValue <bool>("Clear", "W"))
            {
                if (W.IsReady() && GetValue <bool>("Clear", "Q") && Q.IsReady() &&
                    Player.Mana >= W.Instance.SData.Mana + Q.Instance.SData.Mana)
                {
                    var obj =
                        minionObj.FirstOrDefault(
                            i => i.MaxHealth >= 1200 && CanKill(i, GetBonusDmg(i) + Q.GetDamage(i)));
                    if (obj != null && W.Cast(PacketCast) && Q.CastOnUnit(obj, PacketCast))
                    {
                        return;
                    }
                }
                if (W.IsReady() || HaveW)
                {
                    var obj =
                        minionObj.Where(i => Orbwalk.InAutoAttackRange(i))
                        .FirstOrDefault(i => CanKill(i, GetBonusDmg(i)));
                    if (obj != null)
                    {
                        if (!HaveW)
                        {
                            W.Cast(PacketCast);
                        }
                        Orbwalk.Move   = false;
                        Orbwalk.Attack = false;
                        EloBuddy.Player.IssueOrder(GameObjectOrder.AttackUnit, obj);
                        Orbwalk.Move   = true;
                        Orbwalk.Attack = true;
                    }
                }
            }
            if (GetValue <bool>("Clear", "Q") && Q.IsReady())
            {
                var obj =
                    minionObj.FirstOrDefault(
                        i => i.MaxHealth >= 1200 && CanKill(i, Q.GetDamage(i) + (HaveW ? GetBonusDmg(i) : 0)));
                if (obj == null &&
                    (!minionObj.Any(i => Orbwalk.InAutoAttackRange(i, 40)) ||
                     (GetValue <bool>("Clear", "E") && E.IsReady() && HaveE && !minionObj.Any(i => E.IsInRange(i)))))
                {
                    obj = minionObj.MinOrDefault(i => i.Health);
                }
                if (obj != null && Q.CastOnUnit(obj, PacketCast))
                {
                    return;
                }
            }
            if (GetValue <bool>("Clear", "Item"))
            {
                var item = Hydra.IsReady() ? Hydra : Tiamat;
                if (item.IsReady() &&
                    (minionObj.Count(i => item.IsInRange(i)) > 2 ||
                     minionObj.Any(i => i.MaxHealth >= 1200 && i.Distance(Player) < item.Range - 80)))
                {
                    item.Cast();
                }
            }
        }
Exemple #21
0
 private static void Clear()
 {
     SmiteMob();
     if (GetValue <bool>("Clear", "E") && E.IsReady())
     {
         var minionObj = GetMinions(E.Range, MinionTypes.All, MinionTeam.NotAlly, MinionOrderTypes.MaxHealth);
         if (minionObj.Any())
         {
             var pos = E.GetCircularFarmLocation(minionObj.Cast <Obj_AI_Base>().ToList());
             if (pos.MinionsHit > 1)
             {
                 if (E.Cast(pos.Position, PacketCast))
                 {
                     if (GetValue <bool>("Clear", "Q") && Q.IsReady())
                     {
                         Q.Cast(pos.Position, PacketCast);
                     }
                     return;
                 }
             }
             else
             {
                 var obj = minionObj.FirstOrDefault(i => i.MaxHealth >= 1200);
                 if (obj != null && E.Cast(obj, PacketCast).IsCasted())
                 {
                     return;
                 }
             }
         }
     }
     if (GetValue <bool>("Clear", "Q") && Q.IsReady())
     {
         var minionObj =
             GetMinions(Q2.Range, MinionTypes.All, MinionTeam.NotAlly, MinionOrderTypes.MaxHealth)
             .Cast <Obj_AI_Base>()
             .ToList();
         if (minionObj.Any() &&
             (!GetValue <bool>("Clear", "E") ||
              (!E.IsReady() || (E.IsReady() && E.GetCircularFarmLocation(minionObj).MinionsHit == 1))))
         {
             if (GetValue <bool>("Clear", "E") &&
                 Flag.Where(i => minionObj.Count(a => Q2.WillHit(a, i.ServerPosition)) > 1)
                 .Any(i => Q.Cast(i.ServerPosition, PacketCast)))
             {
                 return;
             }
             var pos = Q.GetLineFarmLocation(minionObj.Where(i => Q.IsInRange(i)).ToList());
             if (pos.MinionsHit > 0 && Q.Cast(pos.Position, PacketCast))
             {
                 return;
             }
         }
     }
     if (GetValue <bool>("Clear", "W") && W.IsReady() &&
         Player.HealthPercent < GetValue <Slider>("Clear", "WHpU").Value&&
         GetMinions(W.Range, MinionTypes.All, MinionTeam.NotAlly).Any() && W.Cast(PacketCast))
     {
         return;
     }
     if (GetValue <bool>("Clear", "Item") && (Hydra.IsReady() || Tiamat.IsReady()))
     {
         var minionObj = GetMinions(
             (Hydra.IsReady() ? Hydra : Tiamat).Range, MinionTypes.All, MinionTeam.NotAlly);
         if (minionObj.Count > 2 ||
             minionObj.Any(
                 i => i.MaxHealth >= 1200 && i.Distance(Player) < (Hydra.IsReady() ? Hydra : Tiamat).Range - 80))
         {
             if (Tiamat.IsReady())
             {
                 Tiamat.Cast();
             }
             if (Hydra.IsReady())
             {
                 Hydra.Cast();
             }
         }
     }
 }
Exemple #22
0
        private void JungleClear()
        {
            var useQ     = Config.Item("JungleClearQ").GetValue <bool>();
            var useW     = Config.Item("JungleClearW").GetValue <bool>();
            var useE     = Config.Item("JungleClearE").GetValue <bool>();
            var useItems = Config.Item("JungleClearItems").GetValue <bool>();
            var jungleClearManaManager = Config.Item("JungleClearManaManager").GetValue <Slider>().Value;
            var minimumEJungleMobs     = Config.Item("MinimumEJungleMobs").GetValue <Slider>().Value;

            var junglemobsq =
                Cache.GetMinions(Player.Position, Q.Range, SebbyLib.MinionTeam.Neutral)
                .OrderByDescending(x => x.MaxHealth)
                .FirstOrDefault();

            if (useItems)
            {
                if (Hydra.IsReady() && junglemobsq.IsValidTarget(Hydra.Range))
                {
                    Hydra.Cast();
                }

                if (Tiamat.IsReady() && junglemobsq.IsValidTarget(Tiamat.Range))
                {
                    Tiamat.Cast();
                }
            }

            if (Player.ManaPercent < jungleClearManaManager)
            {
                return;
            }

            var minionselist = Cache.GetMinions(Player.Position, E.Range, SebbyLib.MinionTeam.Neutral);
            var minionsw     = minionselist.OrderByDescending(x => x.MaxHealth).FirstOrDefault();
            var minionse     = E.GetCircularFarmLocation(minionselist);

            if (minionsw == null)
            {
                return;
            }

            if (Config.Item("JungleClearDontEQRange").GetValue <bool>() && (Player.Distance(minionse.Position) > Q.Range))
            {
                if ((minionse.MinionsHit >= minimumEJungleMobs) && useE && E.Instance.IsReady())
                {
                    E.Cast(minionse.Position);
                }
            }
            else if (!Config.Item("JungleClearDontEQRange").GetValue <bool>())
            {
                if ((minionse.MinionsHit >= minimumEJungleMobs) && useE && E.Instance.IsReady())
                {
                    E.Cast(minionse.Position);
                }
            }

            if (junglemobsq.IsValidTarget() && useQ && Q.Instance.IsReady())
            {
                Q.CastOnUnit(junglemobsq);
            }

            if (minionsw.IsValidTarget() && useW && W.Instance.IsReady())
            {
                W.Cast(minionsw.Position);
            }
        }
Exemple #23
0
        private void Offensive()
        {
            if (Botrk.IsReady() && getCheckBoxItem("Botrk"))
            {
                var t = TargetSelector.GetTarget(Botrk.Range, DamageType.Physical);
                if (t.IsValidTarget())
                {
                    if (getCheckBoxItem("BotrkKS") && Player.CalcDamage(t, DamageType.Physical, t.MaxHealth * 0.1) > t.Health - OktwCommon.GetIncomingDamage(t))
                    {
                        Botrk.Cast(t);
                    }
                    if (getCheckBoxItem("BotrkLS") && Player.Health < Player.MaxHealth * 0.5 - OktwCommon.GetIncomingDamage(Player))
                    {
                        Botrk.Cast(t);
                    }
                    if (getCheckBoxItem("BotrkCombo") && Program.Combo)
                    {
                        Botrk.Cast(t);
                    }
                }
            }

            if (Hextech.IsReady() && getCheckBoxItem("Hextech"))
            {
                var t = TargetSelector.GetTarget(Hextech.Range, DamageType.Magical);
                if (t.IsValidTarget())
                {
                    if (getCheckBoxItem("HextechKS") && Player.CalcDamage(t, DamageType.Magical, 150 + Player.FlatMagicDamageMod * 0.4) > t.Health - OktwCommon.GetIncomingDamage(t))
                    {
                        Hextech.Cast(t);
                    }
                    if (getCheckBoxItem("HextechCombo") && Program.Combo)
                    {
                        Hextech.Cast(t);
                    }
                }
            }

            if (Program.Combo && FrostQueen.IsReady() && getCheckBoxItem("FrostQueen") && Player.CountEnemiesInRange(800) > 0)
            {
                FrostQueen.Cast();
            }

            if (Cutlass.IsReady() && getCheckBoxItem("Cutlass"))
            {
                var t = TargetSelector.GetTarget(Cutlass.Range, DamageType.Magical);
                if (t.IsValidTarget())
                {
                    if (getCheckBoxItem("CutlassKS") && Player.CalcDamage(t, DamageType.Magical, 100) > t.Health - OktwCommon.GetIncomingDamage(t))
                    {
                        Cutlass.Cast(t);
                    }
                    if (getCheckBoxItem("CutlassCombo") && Program.Combo)
                    {
                        Cutlass.Cast(t);
                    }
                }
            }

            if (Youmuus.IsReady() && getCheckBoxItem("Youmuus"))
            {
                var t = Orbwalker.LastTarget;

                if (t.IsValidTarget() && t is AIHeroClient)
                {
                    if (getCheckBoxItem("YoumuusKS") && t.Health < Player.MaxHealth)
                    {
                        Youmuus.Cast();
                    }
                    if (getCheckBoxItem("YoumuusCombo") && Program.Combo)
                    {
                        Youmuus.Cast();
                    }
                }
            }

            if (getCheckBoxItem("Hydra"))
            {
                if (Hydra.IsReady() && Player.CountEnemiesInRange(Hydra.Range) > 0)
                {
                    Hydra.Cast();
                }
                else if (Hydra2.IsReady() && Player.CountEnemiesInRange(Hydra2.Range) > 0)
                {
                    Hydra2.Cast();
                }
            }
        }
Exemple #24
0
        private void Offensive()
        {
            if (Botrk.IsReady() && Config.Item("Botrk").GetValue <bool>())
            {
                var t = TargetSelector.GetTarget(Botrk.Range, TargetSelector.DamageType.Physical);
                if (t.IsValidTarget())
                {
                    if (Config.Item("BotrkKS").GetValue <bool>() && Player.CalcDamage(t, Damage.DamageType.Physical, t.MaxHealth * 0.1) > t.Health)
                    {
                        Botrk.Cast(t);
                    }
                    if (Config.Item("BotrkLS").GetValue <bool>() && Player.Health < Player.MaxHealth * 0.5)
                    {
                        Botrk.Cast(t);
                    }
                    if (Config.Item("BotrkCombo").GetValue <bool>() && Program.Combo)
                    {
                        Botrk.Cast(t);
                    }
                }
            }

            if (Hextech.IsReady() && Config.Item("Hextech").GetValue <bool>())
            {
                var t = TargetSelector.GetTarget(Hextech.Range, TargetSelector.DamageType.Magical);
                if (t.IsValidTarget())
                {
                    if (Config.Item("HextechKS").GetValue <bool>() && Player.CalcDamage(t, Damage.DamageType.Magical, 150 + Player.FlatMagicDamageMod * 0.4) > t.Health)
                    {
                        Hextech.Cast(t);
                    }
                    if (Config.Item("HextechCombo").GetValue <bool>() && Program.Combo)
                    {
                        Hextech.Cast(t);
                    }
                }
            }

            if (Program.Combo && FrostQueen.IsReady() && Config.Item("FrostQueen").GetValue <bool>())
            {
                var t = TargetSelector.GetTarget(FrostQueen.Range, TargetSelector.DamageType.Magical);
                if (t.IsValidTarget())
                {
                    var predInput2 = new Core.PredictionInput
                    {
                        Aoe       = true,
                        Collision = false,
                        Speed     = 1200,
                        Delay     = 0.25f,
                        Range     = FrostQueen.Range,
                        From      = Player.ServerPosition,
                        Radius    = 200,
                        Unit      = t,
                        Type      = Core.SkillshotType.SkillshotCircle
                    };
                    var poutput2 = Core.Prediction.GetPrediction(predInput2);

                    if (poutput2.Hitchance >= Core.HitChance.High)
                    {
                        FrostQueen.Cast(poutput2.CastPosition);
                    }
                }
            }

            if (Cutlass.IsReady() && Config.Item("Cutlass").GetValue <bool>())
            {
                var t = TargetSelector.GetTarget(Cutlass.Range, TargetSelector.DamageType.Magical);
                if (t.IsValidTarget())
                {
                    if (Config.Item("CutlassKS").GetValue <bool>() && Player.CalcDamage(t, Damage.DamageType.Magical, 100) > t.Health)
                    {
                        Cutlass.Cast(t);
                    }
                    if (Config.Item("CutlassCombo").GetValue <bool>() && Program.Combo)
                    {
                        Cutlass.Cast(t);
                    }
                }
            }

            if (Youmuus.IsReady() && Config.Item("Youmuus").GetValue <bool>())
            {
                var t = Orbwalker.GetTarget();

                if (t.IsValidTarget() && t is Obj_AI_Hero)
                {
                    if (Config.Item("YoumuusKS").GetValue <bool>() && t.Health < Player.MaxHealth * 0.6)
                    {
                        Youmuus.Cast();
                    }
                    if (Config.Item("YoumuusCombo").GetValue <bool>() && Program.Combo)
                    {
                        Youmuus.Cast();
                    }
                }
            }

            if (Config.Item("Hydra").GetValue <bool>())
            {
                if (Hydra.IsReady() && Player.CountEnemiesInRange(Hydra.Range) > 0)
                {
                    Hydra.Cast();
                }
                else if (Hydra2.IsReady() && Player.CountEnemiesInRange(Hydra2.Range) > 0)
                {
                    Hydra2.Cast();
                }
            }
        }
Exemple #25
0
        private void LaneJungClear()
        {
            var minionObj = MinionManager.GetMinions(Q.Range, MinionTypes.All, MinionTeam.NotAlly, MinionOrderTypes.MaxHealth);

            if (minionObj.Count == 0)
            {
                return;
            }
            if (GetValue <bool>("Clear", "E") && E.IsReady() && !Player.HasBuff("JaxEvasion"))
            {
                if (GetValue <bool>("Clear", "Q") && Q.IsReady() && minionObj.Count(i => E.IsInRange(i)) == 0)
                {
                    foreach (var Obj in minionObj)
                    {
                        if (minionObj.Count(i => i.Distance(Obj, true) <= E.RangeSqr) > 1 && E.Cast(PacketCast) && Q.CastOnUnit(Obj, PacketCast))
                        {
                            return;
                        }
                    }
                }
                else if ((minionObj.Count(i => i.MaxHealth >= 1200 && E.IsInRange(i)) > 0 || minionObj.Count(i => E.IsInRange(i)) > 2) && E.Cast(PacketCast))
                {
                    return;
                }
            }
            if (GetValue <bool>("Clear", "W") && W.IsReady() && GetValue <bool>("Clear", "Q") && Q.IsReady() && Player.Mana >= W.Instance.ManaCost + Q.Instance.ManaCost)
            {
                var Obj = minionObj.Find(i => i.MaxHealth >= 1200 && CanKill(i, Q, Q.GetDamage(i) + GetBonusDmg(i)));
                if (Obj != null && W.Cast(PacketCast) && Q.CastOnUnit(Obj, PacketCast))
                {
                    return;
                }
            }
            if (GetValue <bool>("Clear", "Q") && Q.IsReady())
            {
                var Obj = minionObj.Find(i => i.MaxHealth >= 1200 && ((Player.HasBuff("JaxEmpowerTwo") && CanKill(i, Q, Q.GetDamage(i) + GetBonusDmg(i))) || CanKill(i, Q)));
                if (Obj == null && (minionObj.Count(i => Player.Distance(i, true) <= Math.Pow(Orbwalk.GetAutoAttackRange(Player, i) + 40, 2)) == 0 || (GetValue <bool>("Clear", "E") && E.IsReady() && Player.HasBuff("JaxEvasion") && minionObj.Count(i => E.IsInRange(i)) == 0)))
                {
                    Obj = minionObj.MinOrDefault(i => i.Health);
                }
                if (Obj != null && Q.CastOnUnit(Obj, PacketCast))
                {
                    return;
                }
            }
            if (GetValue <bool>("Clear", "Item"))
            {
                var Item = Hydra.IsReady() ? Hydra : Tiamat;
                if (Item.IsReady() && (minionObj.Count(i => Item.IsInRange(i)) > 2 || minionObj.Any(i => i.MaxHealth >= 1200 && i.Distance(Player, true) <= Math.Pow(Item.Range - 80, 2))) && Item.Cast())
                {
                    return;
                }
            }
            if (GetValue <bool>("SmiteMob", "Smite") && Smite.IsReady())
            {
                var Obj = minionObj.Find(i => i.Team == GameObjectTeam.Neutral && CanSmiteMob(i.Name));
                if (Obj != null && CastSmite(Obj))
                {
                    return;
                }
            }
        }
Exemple #26
0
            //-------------------------------------------LaneClear()-----------------------------------------------

            public static void LaneClear()
            {
                if (Q.IsReady())
                {
                    if (Menu["UseQJungleClear"].Cast <CheckBox>().CurrentValue&& Player.ManaPercent >= Menu["JungleClear, Mana %"].Cast <Slider>().CurrentValue)
                    {
                        var JungleMinion = EntityManager.MinionsAndMonsters.GetJungleMonsters(Player.Position, Q.Range).FirstOrDefault(it => it.IsValidTarget(Q.Range) && Player.GetAutoAttackDamage(it) < it.Health);

                        if (JungleMinion != null)
                        {
                            Q.Cast(JungleMinion);
                        }
                    }

                    if (Menu["UseQLaneClear"].Cast <CheckBox>().CurrentValue)
                    {
                        if (Menu["JustQIMWD"].Cast <CheckBox>().CurrentValue)
                        {
                            var QMinions = EntityManager.MinionsAndMonsters.GetLaneMinions(EntityManager.UnitTeam.Enemy, Player.Position, Q.Range);
                            if (QMinions.Any())
                            {
                                var QMinion = QMinions.FirstOrDefault(it => SpellDamage(it, SpellSlot.Q) >= it.Health && !Player.IsInAutoAttackRange(it));
                                if (QMinion != null)
                                {
                                    Q.Cast(QMinion);
                                }
                            }
                        }
                        else
                        {
                            var QMinions = EntityManager.MinionsAndMonsters.GetLaneMinions(EntityManager.UnitTeam.Enemy, Player.Position, Q.Range);
                            if (QMinions.Any())
                            {
                                var QMinion = QMinions.FirstOrDefault();
                                if (QMinion != default(Obj_AI_Minion) && QMinion != null)
                                {
                                    Q.Cast(QMinion);
                                }
                            }
                        }
                    }
                }

                if (E.IsReady() && !Player.HasBuff("JaxCounterStrike"))
                {
                    if (Menu["UseELaneClear"].Cast <CheckBox>().CurrentValue)
                    {
                        var EMinions = EntityManager.MinionsAndMonsters.GetLaneMinions(EntityManager.UnitTeam.Enemy, Player.Position, E.Range + 100);
                        if (EMinions.Any())
                        {
                            if (EMinions.Count() >= Menu["Min Minions E"].Cast <Slider>().CurrentValue)
                            {
                                E.Cast();
                            }
                        }
                    }

                    if (Menu["UseEJungleClear"].Cast <CheckBox>().CurrentValue&& Player.ManaPercent >= Menu["JungleClear, Mana %"].Cast <Slider>().CurrentValue)
                    {
                        var EJungleMinions = EntityManager.MinionsAndMonsters.GetJungleMonsters(Player.Position, E.Range);
                        if (EJungleMinions.Any())
                        {
                            if (Player.Level <= 6 && EJungleMinions.Any(it => it.Health >= 250))
                            {
                                E.Cast();
                            }
                            if (Player.Level > 6 && EJungleMinions.Any(it => it.Health >= 400))
                            {
                                E.Cast();
                            }
                        }
                    }
                }

                if (Tiamat != null)
                {
                    if (Tiamat.IsReady())
                    {
                        bool UseItem = EntityManager.MinionsAndMonsters.GetLaneMinions(EntityManager.UnitTeam.Enemy, Player.Position, Hydra.Range).Count() >= 3;
                        if (UseItem)
                        {
                            Tiamat.Cast();
                        }
                        UseItem = EntityManager.MinionsAndMonsters.GetJungleMonsters(Player.Position, Hydra.Range).Count() >= 2;
                        if (UseItem)
                        {
                            Tiamat.Cast();
                        }
                    }
                }

                if (Hydra != null)
                {
                    if (Hydra.IsReady())
                    {
                        bool UseItem = EntityManager.MinionsAndMonsters.GetLaneMinions(EntityManager.UnitTeam.Enemy, Player.Position, Hydra.Range).Count() >= 3;
                        if (UseItem)
                        {
                            Hydra.Cast();
                        }
                        UseItem = EntityManager.MinionsAndMonsters.GetJungleMonsters(Player.Position, Hydra.Range).Count() >= 2;
                        if (UseItem)
                        {
                            Hydra.Cast();
                        }
                    }
                }

                return;
            }
Exemple #27
0
        private static void DoJungleclear()
        {
            try
            {
                var minion =
                    MinionManager.GetMinions(
                        Player.ServerPosition,
                        E.Range,
                        MinionTypes.All,
                        MinionTeam.Neutral,
                        MinionOrderTypes.MaxHealth).OrderByDescending(x => x.MaxHealth).FirstOrDefault();

                if (minion == null)
                {
                    return;
                }

                if (Player.ManaPercent < Menu.Item("GFUELTalon.jungleclear.Mana").GetValue <Slider>().Value)
                {
                    return;
                }


                if (IsActive("GFUELTalon.jungleclear.E") && E.IsReady())
                {
                    E.CastOnUnit(minion);
                }

                if (IsActive("GFUELTalon.jungleclear.W") && W.IsReady() && minion.IsValidTarget(W.Range))
                {
                    W.Cast(minion);
                }

                if (IsActive("GFUELTalon.jungleclear.Q") && Q.IsReady() && minion.IsValidTarget(Q.Range))
                {
                    Q.Cast();
                }

                var min =
                    MinionManager.GetMinions(
                        Orbwalking.GetRealAutoAttackRange(Player),
                        MinionTypes.All,
                        MinionTeam.NotAlly).Count();

                if (min >= 1)
                {
                    if (Tiamat.IsReady())
                    {
                        Tiamat.Cast();
                    }

                    if (Hydra.IsReady())
                    {
                        Hydra.Cast();
                    }
                }
            }
            catch (Exception exception)
            {
                Console.WriteLine(exception);
            }
        }
Exemple #28
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 #29
0
        private static void Offensive()
        {
            if (Botrk.IsReady() && OffensivesMenu["botrk"].Cast <CheckBox>().CurrentValue)
            {
                var t = TargetSelector.GetTarget(Botrk.Range, DamageType.Physical);
                if (t.IsValidTarget())
                {
                    if (OffensivesMenu["botrkks"].Cast <CheckBox>().CurrentValue&&
                        Player.CalculateDamageOnUnit(t, DamageType.Physical, t.MaxHealth * (float)0.1) > t.Health)
                    {
                        Botrk.Cast(t);
                    }
                    if (OffensivesMenu["botrkls"].Cast <CheckBox>().CurrentValue&& Player.Health < Player.MaxHealth * 0.5)
                    {
                        Botrk.Cast(t);
                    }
                    if (OffensivesMenu["botrkc"].Cast <CheckBox>().CurrentValue&&
                        Orbwalker.ActiveModesFlags == Orbwalker.ActiveModes.Combo)
                    {
                        Botrk.Cast(t);
                    }
                }
            }

            if (Hextech.IsReady() && OffensivesMenu["hex"].Cast <CheckBox>().CurrentValue)
            {
                var t = TargetSelector.GetTarget(Hextech.Range, DamageType.Magical);
                if (t.IsValidTarget())
                {
                    if (OffensivesMenu["hexks"].Cast <CheckBox>().CurrentValue&&
                        Player.CalculateDamageOnUnit(t, DamageType.Magical, 150 + Player.FlatMagicDamageMod * (float)0.4) >
                        t.Health)
                    {
                        Hextech.Cast(t);
                    }
                    if (OffensivesMenu["hexc"].Cast <CheckBox>().CurrentValue&&
                        Orbwalker.ActiveModesFlags == Orbwalker.ActiveModes.Combo)
                    {
                        Hextech.Cast(t);
                    }
                }
            }

            if (Orbwalker.ActiveModesFlags == Orbwalker.ActiveModes.Combo && FrostQueen.IsReady() &&
                OffensivesMenu["fq"].Cast <CheckBox>().CurrentValue)
            {
                var t = TargetSelector.GetTarget(FrostQueen.Range, DamageType.Magical);
                if (t.IsValidTarget() && t.Distance(Player) < 1500)
                {
                    FrostQueen.Cast();
                }
            }

            if (Cutlass.IsReady() && OffensivesMenu["cut"].Cast <CheckBox>().CurrentValue)
            {
                var t = TargetSelector.GetTarget(Cutlass.Range, DamageType.Magical);
                if (t.IsValidTarget())
                {
                    if (OffensivesMenu["cutks"].Cast <CheckBox>().CurrentValue&&
                        Player.CalculateDamageOnUnit(t, DamageType.Magical, 100) > t.Health)
                    {
                        Cutlass.Cast(t);
                    }
                    if (OffensivesMenu["cutc"].Cast <CheckBox>().CurrentValue&&
                        Orbwalker.ActiveModesFlags == Orbwalker.ActiveModes.Combo)
                    {
                        Cutlass.Cast(t);
                    }
                }
            }

            if (Youmuus.IsReady() && OffensivesMenu["gb"].Cast <CheckBox>().CurrentValue&&
                Orbwalker.ActiveModesFlags == Orbwalker.ActiveModes.Combo)
            {
                var t = Orbwalker.LastTarget;

                if (t.IsValidTarget(Player.AttackRange) && t is AIHeroClient)
                {
                    Youmuus.Cast();
                }
            }

            if ((OffensivesMenu["tmat"].Cast <CheckBox>().CurrentValue ||
                 OffensivesMenu["rh"].Cast <CheckBox>().CurrentValue) && (Orbwalker.ActiveModesFlags == Orbwalker.ActiveModes.Combo || Orbwalker.ActiveModesFlags == Orbwalker.ActiveModes.Harass))
            {
                if (Hydra.IsReady() && Player.CountEnemiesInRange(Hydra.Range) > 0)
                {
                    Hydra.Cast();
                }
                else if (Tiamat.IsReady() && Player.CountEnemiesInRange(Tiamat.Range) > 0)
                {
                    Tiamat.Cast();
                }
            }
        }