示例#1
0
        /// <summary>
        ///     Fired when the game is updated.
        /// </summary>
        public void OnTick(EntropyEventArgs args)
        {
            if (UtilityClass.Player.IsDead)
            {
                return;
            }

            /// <summary>
            ///     Initializes the Killsteal events.
            /// </summary>
            Killsteal(args);

            /// <summary>
            ///     Initializes the Automatic actions.
            /// </summary>
            Automatic(args);

            /// <summary>
            ///     Initializes the orbwalkingmodes.
            /// </summary>
            switch (Orbwalker.Mode)
            {
            case OrbwalkingMode.Combo:
                Combo(args);
                break;

            case OrbwalkingMode.LaneClear:
                Laneclear(args);
                break;
            }
        }
示例#2
0
        /// <summary>
        ///     Fired when the game is updated.
        /// </summary>
        public void Harass(EntropyEventArgs args)
        {
            /// <summary>
            ///     The Q Combo Logic.
            /// </summary>
            if (SpellClass.Q.Ready &&
                UtilityClass.Player.EnemyHeroesCount(UtilityClass.Player.GetAutoAttackRange()) > 0 &&
                UtilityClass.Player.MPPercent()
                > ManaManager.GetNeededMana(SpellClass.Q.Slot, MenuClass.Q["harass"]) &&
                MenuClass.Q["harass"].Enabled)
            {
                SpellClass.Q.Cast();
            }

            /// <summary>
            ///     The W Harass Logic.
            /// </summary>
            if (SpellClass.W.Ready &&
                UtilityClass.Player.MPPercent()
                > ManaManager.GetNeededMana(SpellClass.W.Slot, MenuClass.W["harass"]) &&
                MenuClass.W["harass"].Enabled)
            {
                var bestTarget = Extensions.GetBestEnemyHeroTargetInRange(SpellClass.W.Range / 2);
                if (bestTarget != null &&
                    !Invulnerable.Check(bestTarget) &&
                    MenuClass.W["whitelist"][bestTarget.CharName.ToLower()].Enabled)
                {
                    SpellClass.W.Cast(bestTarget);
                }
            }
        }
示例#3
0
        /// <summary>
        ///     Fired when the game is updated.
        /// </summary>
        public void Killsteal(EntropyEventArgs args)
        {
            /// <summary>
            ///     The Q KillSteal Logic.
            /// </summary>
            if (SpellClass.Q.Ready &&
                MenuClass.Spells["q"]["killsteal"].As <MenuBool>().Enabled)
            {
                foreach (var target in Extensions.GetBestSortedTargetsInRange(SpellClass.Q.Range).Where(t =>
                                                                                                        !t.IsValidTarget(UtilityClass.Player.GetAutoAttackRange(t)) &&
                                                                                                        UtilityClass.Player.GetSpellDamage(t, SpellSlot.Q) >= t.GetRealHealth()))
                {
                    SpellClass.Q.Cast(target);
                    break;
                }
            }

            /// <summary>
            ///     The R KillSteal Logic.
            /// </summary>
            if (SpellClass.R.Ready &&
                MenuClass.Spells["r"]["killsteal"].As <MenuBool>().Enabled)
            {
                foreach (var target in Extensions.GetBestSortedTargetsInRange(SpellClass.R.Range).Where(t =>
                                                                                                        UtilityClass.Player.GetSpellDamage(t, SpellSlot.R, HasBigOne() ? DamageStage.Empowered : DamageStage.Default) >= t.GetRealHealth()))
                {
                    SpellClass.R.Cast(target);
                    break;
                }
            }
        }
示例#4
0
        /// <summary>
        ///     Called on tick update.
        /// </summary>
        public void JungleClear(EntropyEventArgs args)
        {
            var jungleTarget = Extensions.GetGenericJungleMinionsTargets()
                               .MinBy(m => m.Distance(Hud.CursorPositionUnclipped));

            if (jungleTarget == null)
            {
                return;
            }

            /// <summary>
            ///     The Jungleclear Q Logics.
            /// </summary>
            if (SpellClass.Q.Ready &&
                jungleTarget.IsValidTarget(SpellClass.Q.Range) &&
                UtilityClass.Player.MPPercent()
                > ManaManager.GetNeededMana(SpellClass.Q.Slot, MenuClass.Q["jungleclear"]) &&
                MenuClass.Q["jungleclear"].As <MenuSliderBool>().Enabled)
            {
                SpellClass.Q.CastOnUnit(jungleTarget);
            }

            /// <summary>
            ///     The Jungleclear E Logics.
            /// </summary>
            if (SpellClass.E.Ready &&
                jungleTarget.IsValidTarget(SpellClass.E.Range) &&
                UtilityClass.Player.MPPercent()
                > ManaManager.GetNeededMana(SpellClass.E.Slot, MenuClass.E["jungleclear"]) &&
                MenuClass.E["jungleclear"].As <MenuSliderBool>().Enabled&&
                jungleTarget?.HP > UtilityClass.Player.GetAutoAttackDamage(jungleTarget) * 4)
            {
                SpellClass.E.Cast(jungleTarget);
            }
        }
示例#5
0
        /// <summary>
        ///     Fired when the game is updated.
        /// </summary>
        public void Killsteal(EntropyEventArgs args)
        {
            /// <summary>
            ///     The Q KillSteal Logic.
            /// </summary>
            if (SpellClass.Q.Ready &&
                MenuClass.Spells["q"]["killsteal"].As <MenuBool>().Enabled)
            {
                foreach (var target in Extensions.GetBestSortedTargetsInRange(SpellClass.Q.Range).Where(t =>
                                                                                                        GetRealPiercingArrowDamage(t) >= t.GetRealHealth() &&
                                                                                                        !t.IsValidTarget(UtilityClass.Player.GetAutoAttackRange(t))))
                {
                    if (IsChargingPiercingArrow())
                    {
                        SpellClass.Q.Cast(target);
                    }
                    else
                    {
                        if (SpellClass.W.Ready &&
                            MenuClass.Spells["w"]["killsteal"].As <MenuBool>().Enabled)
                        {
                            SpellClass.W.Cast();
                        }

                        PiercingArrowLogicalCast(target);
                    }
                    break;
                }
            }

            /// <summary>
            ///     The E KillSteal Logic.
            /// </summary>
            if (SpellClass.E.Ready &&
                MenuClass.Spells["e"]["killsteal"].As <MenuBool>().Enabled)
            {
                foreach (var target in Extensions.GetBestSortedTargetsInRange(SpellClass.E.Range).Where(t =>
                                                                                                        GetRealHailOfArrowsDamage(t) >= t.GetRealHealth() &&
                                                                                                        !t.IsValidTarget(UtilityClass.Player.GetAutoAttackRange(t))))
                {
                    SpellClass.E.Cast(target);
                    break;
                }
            }

            /// <summary>
            ///     The R KillSteal Logic.
            /// </summary>
            if (SpellClass.R.Ready &&
                MenuClass.Spells["r"]["killsteal"].As <MenuBool>().Enabled)
            {
                foreach (var target in Extensions.GetBestSortedTargetsInRange(SpellClass.R.Range).Where(t =>
                                                                                                        GetRealChainOfCorruptionDamage(t) >= t.GetRealHealth() &&
                                                                                                        !t.IsValidTarget(UtilityClass.Player.GetAutoAttackRange(t))))
                {
                    SpellClass.R.Cast(target);
                    break;
                }
            }
        }
示例#6
0
        public static void OnTick(EntropyEventArgs args)
        {
            if (LocalPlayer.Instance.IsDead() || LocalPlayer.Instance.IsRecalling() || GameConsole.IsOpen)
            {
                return;
            }

            switch (Orbwalker.Mode)
            {
            case OrbwalkingMode.Combo:
                Combo.Execute();
                break;

            case OrbwalkingMode.Harass:
                Harass.Execute();
                break;

            case OrbwalkingMode.Laneclear:
                LaneClear.Execute();
                JungleClear.Execute();
                break;

            case OrbwalkingMode.Lasthit:
                LastHit.Execute();
                break;
            }
        }
示例#7
0
        /// <summary>
        ///     Fired when the game is updated.
        /// </summary>
        public void Combo(EntropyEventArgs args)
        {
            /// <summary>
            ///     The E Engager Logic.
            /// </summary>
            if (SpellClass.E.Ready &&
                MenuClass.E["engage"].Enabled)
            {
                var bestTarget =
                    Extensions.GetBestEnemyHeroTargetInRange(UtilityClass.Player.GetAutoAttackRange() + 300);
                if (bestTarget != null &&
                    !Invulnerable.Check(bestTarget) &&
                    !bestTarget.IsValidTarget(UtilityClass.Player.GetAutoAttackRange(bestTarget)))
                {
                    SpellClass.E.Cast();
                }
            }

            /// <summary>
            ///     The Q Combo Logic.
            /// </summary>
            if (SpellClass.Q.Ready &&
                UtilityClass.Player.EnemyHeroesCount(UtilityClass.Player.GetAutoAttackRange()) >=
                MenuClass.Q["combo"].Value &&
                MenuClass.Q["combo"].Enabled)
            {
                SpellClass.Q.Cast();
            }
        }
示例#8
0
        public static void ExtendedQ(EntropyEventArgs args)
        {
            var extendedQHarass = BaseMenu.Root["harass"]["extendedQ"];

            if (!extendedQHarass.Enabled ||
                LocalPlayer.Instance.MPPercent() <= ManaManager.GetNeededMana(Champion.Q.Slot, extendedQHarass))
            {
                return;
            }

            foreach (var target in Extensions.GetBestSortedTargetsInRange(Spells.ExtendedQ.Range)
                     .Where(t =>
                            !t.IsValidTarget(Champion.Q.Range) &&
                            BaseMenu.Root["harass"]["whitelists"]["extendedQ"][t.CharName.ToLower()].Enabled))
            {
                foreach (var minion in Extensions.GetAllGenericUnitTargetsInRange(Champion.Q.Range))
                {
                    if (!Definitions.QRectangle(minion).IsInsidePolygon(Spells.ExtendedQ.GetPrediction(target).CastPosition))
                    {
                        continue;
                    }

                    Champion.Q.CastOnUnit(minion);
                    break;
                }
            }
        }
示例#9
0
        /// <summary>
        ///     Called on tick update.
        /// </summary>
        public void Harass(EntropyEventArgs args)
        {
            /// <summary>
            ///     The Q Harass Logic.
            /// </summary>
            if (SpellClass.Q.Ready &&
                (IsNearWorkedGround() ||
                 UtilityClass.Player.MPPercent()
                 > ManaManager.GetNeededMana(SpellClass.Q.Slot, MenuClass.Q["harass"])) &&
                MenuClass.Q["harass"].Enabled)
            {
                var bestTarget = Extensions.GetBestEnemyHeroTargetInRange(SpellClass.Q.Range - 100f);
                if (bestTarget != null &&
                    !Invulnerable.Check(bestTarget, DamageType.Magical) &&
                    MenuClass.Q["whitelist"][bestTarget.CharName.ToLower()].Enabled)
                {
                    switch (MenuClass.Q["modes"]["harass"].Value)
                    {
                    case 0:
                        if (!IsNearWorkedGround())
                        {
                            SpellClass.Q.Cast(bestTarget);
                        }

                        break;

                    case 1:
                        SpellClass.Q.Cast(bestTarget);
                        break;
                    }
                }
            }
        }
示例#10
0
        public static void OnTick(EntropyEventArgs args)
        {
            if (LocalPlayer.Instance.IsDead() || LocalPlayer.Instance.IsRecalling() || GameConsole.IsOpen)
            {
                return;
            }

            if (W.Ready)
            {
                Automatic.ExecuteW();
            }

            switch (Orbwalker.Mode)
            {
            case OrbwalkingMode.Combo when W.Ready:
                Combo.ExecuteW();
                break;

            case OrbwalkingMode.Harass when W.Ready:
                Harass.ExecuteW();
                break;

            case OrbwalkingMode.Laneclear when W.Ready:
                LaneClear.ExecuteW();
                JungleClear.ExecuteW();
                break;
            }
        }
示例#11
0
        /// <summary>
        ///     Initializes the drawings.
        /// </summary>
        public void OnRender(EntropyEventArgs args)
        {
            /// <summary>
            ///     Loads the Q drawing.
            /// </summary>
            if (SpellClass.Q.Ready &&
                MenuClass.Drawings["q"].Enabled)
            {
                Renderer.DrawCircularRangeIndicator(UtilityClass.Player.Position, SpellClass.Q.Range, Color.LightGreen);
            }

            /// <summary>
            ///     Loads the W drawing.
            /// </summary>
            if (SpellClass.W.Ready &&
                MenuClass.Drawings["w"].Enabled)
            {
                Renderer.DrawCircularRangeIndicator(UtilityClass.Player.Position, SpellClass.W.Range, Color.Yellow);
            }

            /// <summary>
            ///     Loads the E drawing.
            /// </summary>
            if (SpellClass.E.Ready &&
                MenuClass.Drawings["e"].Enabled)
            {
                Renderer.DrawCircularRangeIndicator(UtilityClass.Player.Position, SpellClass.E.Range, Color.Cyan);
            }
        }
示例#12
0
        /// <summary>
        ///     Fired when the game is updated.
        /// </summary>
        public void Killsteal(EntropyEventArgs args)
        {
            /// <summary>
            ///     The E KillSteal Logic.
            /// </summary>
            if (SpellClass.E.Ready &&
                MenuClass.Spells["e"]["killsteal"].As <MenuBool>().Enabled)
            {
                foreach (var target in Extensions.GetBestSortedTargetsInRange(SpellClass.E.Range).Where(t =>
                                                                                                        UtilityClass.Player.GetSpellDamage(t, SpellSlot.E, IsWhiplashEmpowered() ? DamageStage.Empowered : DamageStage.Default) >= t.GetRealHealth()))
                {
                    SpellClass.E.CastOnUnit(target);
                    break;
                }
            }

            /// <summary>
            ///     The R KillSteal Logic.
            /// </summary>
            if (SpellClass.R.Ready &&
                MenuClass.Spells["r"]["killsteal"].As <MenuBool>().Enabled)
            {
                foreach (var target in Extensions.GetBestSortedTargetsInRange(SpellClass.R.Range).Where(t =>
                                                                                                        UtilityClass.Player.GetSpellDamage(t, SpellSlot.R, t.HPPercent() < 30 ? DamageStage.Empowered : DamageStage.Default) >= t.GetRealHealth()))
                {
                    SpellClass.R.Cast(target.Position);
                    break;
                }
            }
        }
示例#13
0
        /// <summary>
        ///     Initializes the drawings.
        /// </summary>
        public void OnRender(EntropyEventArgs args)
        {
            /// <summary>
            ///     Loads the Q drawing.
            /// </summary>
            if (SpellClass.Q.Ready &&
                MenuClass.Drawings["q"].Enabled)
            {
                Renderer.DrawCircularRangeIndicator(UtilityClass.Player.Position, SpellClass.Q.Range, Color.LightGreen);
            }

            /// <summary>
            ///     Loads the W drawing.
            /// </summary>
            if (SpellClass.W.Ready &&
                MenuClass.Drawings["w"].Enabled)
            {
                Renderer.DrawCircularRangeIndicator(UtilityClass.Player.Position, SpellClass.W.Range, Color.Yellow);
            }

            /// <summary>
            ///     Loads the E drawing.
            /// </summary>
            if (SpellClass.E.Ready &&
                MenuClass.Drawings["e"].Enabled)
            {
                Renderer.DrawCircularRangeIndicator(UtilityClass.Player.Position, SpellClass.E.Range, Color.Cyan);
            }

            /// <summary>
            ///     Loads the R drawing.
            /// </summary>
            if (SpellClass.R.Ready &&
                MenuClass.Drawings["r"].Enabled)
            {
                Renderer.DrawCircularRangeIndicator(UtilityClass.Player.Position, SpellClass.R.Range, Color.Red);
            }

            /// <summary>
            ///     Loads the WorkedGrounds drawing.
            /// </summary>
            if (MenuClass.Drawings["grounds"].Enabled)
            {
                foreach (var ground in WorkedGrounds)
                {
                    CircleRendering.Render(Color.Brown, WorkedGroundWidth, ground.Key);
                }
            }

            /// <summary>
            ///     Loads the MineFields drawing.
            /// </summary>
            if (MenuClass.Drawings["boulders"].Enabled)
            {
                foreach (var boulder in MineField)
                {
                    CircleRendering.Render(Color.Brown, BouldersWidth, boulder.Key);
                }
            }
        }
示例#14
0
        public void OnEndScene(EntropyEventArgs args)
        {
            /// <summary>
            ///     Draws the Passive damage to healthbar.
            /// </summary>
            if (MenuClass.Drawings["passivedmg"].Enabled)
            {
                foreach (var hero in ObjectCache.EnemyHeroes.Where(h => h.GetBuffCount("kaisapassivemarker") == 4))
                {
                    DamageIndicatorRendering.Render(hero, UtilityClass.Player.GetAutoAttackDamage(hero));
                }

                var bigJungleMinions =
                    Extensions.GetLargeJungleMinionsTargets().Concat(Extensions.GetLegendaryJungleMinionsTargets());
                foreach (var jungleMob in bigJungleMinions.Where(h => h.GetBuffCount("kaisapassivemarker") == 4))
                {
                    DamageIndicatorRendering.Render(jungleMob, UtilityClass.Player.GetAutoAttackDamage(jungleMob));
                }

                foreach (var mob in ObjectCache.EnemyLaneMinions.Where(h => h.GetBuffCount("kaisapassivemarker") == 4))
                {
                    DamageIndicatorRendering.Render(mob, UtilityClass.Player.GetAutoAttackDamage(mob));
                }
            }
        }
示例#15
0
        /// <summary>
        ///     Fired when the game is updated.
        /// </summary>
        public void Combo(EntropyEventArgs args)
        {
            /// <summary>
            ///     The W Combo Logic.
            /// </summary>
            if (SpellClass.W.Ready &&
                MenuClass.W["combo"].Enabled)
            {
                var bestTarget = Extensions.GetBestEnemyHeroTargetInRange(SpellClass.W.Range - 150f);
                if (bestTarget != null &&
                    !Invulnerable.Check(bestTarget, DamageType.Magical) &&
                    UtilityClass.PlayerData.TotalAbilityDamage() >= GetMinimumApForApMode())
                {
                    SpellClass.W.Cast(bestTarget);
                }
            }

            /// <summary>
            ///     The Q Combo Logic.
            /// </summary>
            if (SpellClass.Q.Ready &&
                MenuClass.Q["combo"].Enabled)
            {
                var bestTarget = Extensions.GetBestEnemyHeroTargetInRange(SpellClass.Q.Range - 100f);
                if (bestTarget != null &&
                    !Invulnerable.Check(bestTarget) &&
                    !bestTarget.IsValidTarget(UtilityClass.Player.GetAutoAttackRange(bestTarget)))
                {
                    SpellClass.Q.Cast(bestTarget);
                }
            }
        }
示例#16
0
        public void OnEndScene(EntropyEventArgs args)
        {
            /// <summary>
            ///     Loads the R drawings.
            /// </summary>
            if (SpellClass.R.Ready)
            {
                /// <summary>
                ///     Draws the R range into minimap.
                /// </summary>
                if (MenuClass.Drawings["rmm"].Enabled)
                {
                    var scale = (TacticalMap.ScaleX + TacticalMap.ScaleY) / 4.5;
                    TacticalMapRendering.Render(Color.White, UtilityClass.Player.Position, (float)(SpellClass.R.Range / scale));
                }

                /// <summary>
                ///     Draws the R damage into enemy healthbar.
                /// </summary>
                if (MenuClass.Drawings["rdmg"].Enabled)
                {
                    foreach (var hero in ObjectCache.EnemyHeroes.Where(t => t.IsValidTarget(SpellClass.R.Range)))
                    {
                        DamageIndicatorRendering.Render(hero, GetRDamage(hero));
                    }
                }
            }

            /// <summary>
            ///     Draws the Passive damage to healthbar.
            /// </summary>
            if (MenuClass.Drawings["passivedmg"].Enabled)
            {
                foreach (var hero in ObjectCache.EnemyHeroes.Where(t => t.IsValidTarget(1250f)))
                {
                    if (UtilityClass.Player.HasBuff("caitlynheadshot") ||
                        UtilityClass.Player.HasBuff("caitlynheadshotrangecheck") &&
                        hero.HasBuff("caitlynyordletrapinternal"))
                    {
                        DamageIndicatorRendering.Render(hero, UtilityClass.Player.GetAutoAttackDamage(hero));
                    }
                }

                if (UtilityClass.Player.HasBuff("caitlynheadshot"))
                {
                    var bigJungleMinions =
                        Extensions.GetLargeJungleMinionsTargets().Concat(Extensions.GetLegendaryJungleMinionsTargets());
                    foreach (var jungleMob in bigJungleMinions.Where(t => t.IsValidTarget(1250f)))
                    {
                        DamageIndicatorRendering.Render(jungleMob, UtilityClass.Player.GetAutoAttackDamage(jungleMob));
                    }

                    foreach (var mob in ObjectCache.EnemyLaneMinions.Where(t => t.IsValidTarget(1250f)))
                    {
                        DamageIndicatorRendering.Render(mob, UtilityClass.Player.GetAutoAttackDamage(mob));
                    }
                }
            }
        }
示例#17
0
        /// <summary>
        ///     Fired when the game is updated.
        /// </summary>
        public void JungleClear(EntropyEventArgs args)
        {
            if (GetBall() == null)
            {
                return;
            }

            /// <summary>
            ///     The Jungleclear W Logic.
            /// </summary>
            if (SpellClass.W.Ready &&
                UtilityClass.Player.MPPercent()
                > ManaManager.GetNeededMana(SpellClass.W.Slot, MenuClass.W["jungleclear"]) &&
                MenuClass.W["jungleclear"].Enabled)
            {
                if (Extensions.GetGenericJungleMinionsTargets().Any(m => m.IsValidTarget(SpellClass.W.Width, GetBall().Position)))
                {
                    SpellClass.W.Cast();
                }
            }


            var jungleTarget = Extensions.GetGenericJungleMinionsTargetsInRange(SpellClass.Q.Range)
                               .MinBy(m => m.Distance(Hud.CursorPositionUnclipped));

            if (jungleTarget == null ||
                jungleTarget.HP < UtilityClass.Player.GetAutoAttackDamage(jungleTarget) * 3)
            {
                return;
            }

            /// <summary>
            ///     The Jungleclear E Logic.
            /// </summary>
            if (SpellClass.E.Ready &&
                UtilityClass.Player.MPPercent()
                > ManaManager.GetNeededMana(SpellClass.E.Slot, MenuClass.E["jungleclear"]) &&
                MenuClass.E["jungleclear"].Enabled)
            {
                if (ERectangle(jungleTarget).IsInsidePolygon((Vector2)jungleTarget.Position))
                {
                    SpellClass.E.CastOnUnit(UtilityClass.Player);
                }
            }

            /// <summary>
            ///     The Jungleclear Q Logic.
            /// </summary>
            if (SpellClass.Q.Ready &&
                jungleTarget.IsValidTarget(SpellClass.Q.Range) &&
                UtilityClass.Player.MPPercent()
                > ManaManager.GetNeededMana(SpellClass.Q.Slot, MenuClass.Q["jungleclear"]) &&
                MenuClass.Q["jungleclear"].Enabled)
            {
                SpellClass.Q.GetPredictionInput(jungleTarget).From = GetBall().Position;
                SpellClass.Q.Cast(SpellClass.Q.GetPrediction(jungleTarget).CastPosition);
            }
        }
示例#18
0
        public static void OnTick(EntropyEventArgs args)
        {
            if (LocalPlayer.Instance.IsDead)
            {
                return;
            }

            if (Definitions.IsCulling())
            {
                DelayAction.Queue(() => { Orbwalker.Move(Hud.CursorPositionUnclipped); },
                                  100 + EnetClient.Ping);
            }

            if (Orbwalker.IsWindingUp)
            {
                return;
            }

            switch (Orbwalker.Mode)
            {
            case OrbwalkingMode.Combo:
                if (E.Ready)
                {
                    Combo.E(args);
                }

                if (R.Ready)
                {
                    Combo.R(args);
                }
                break;

            case OrbwalkingMode.LaneClear:
                if (Q.Ready)
                {
                    Laneclear.Q(args);
                }

                if (W.Ready)
                {
                    Laneclear.W(args);
                }
                break;

            case OrbwalkingMode.Harass:
                if (Q.Ready)
                {
                    Harass.Q(args);
                    Harass.ExtendedQ(args);
                }

                if (W.Ready)
                {
                    Harass.W(args);
                }
                break;
            }
        }
示例#19
0
        /// <summary>
        ///     Fired when the game is updated.
        /// </summary>
        public void Automatic(EntropyEventArgs args)
        {
            if (UtilityClass.Player.IsRecalling())
            {
                return;
            }

            /// <summary>
            ///     The Anti-Grab Logic.
            /// </summary>
            if (SpellClass.E.Ready &&
                UtilityClass.Player.IsBeingGrabbed() &&
                MenuClass.E["antigrab"].Enabled)
            {
                var firstTower = ObjectCache.AllyTurrets
                                 .Where(t => t.IsValidTarget(isAllyAllowed: true))
                                 .MinBy(t => t.DistanceToPlayer());
                if (firstTower != null)
                {
                    SpellClass.E.Cast(UtilityClass.Player.Position.Extend(firstTower.Position, SpellClass.E.Range));
                }
            }

            /// <summary>
            ///     The Tear Stacking Logic.
            /// </summary>
            if (SpellClass.Q.Ready &&
                UtilityClass.Player.IsTearLikeItemReady() &&
                UtilityClass.Player.EnemyHeroesCount(1500f) == 0 &&
                Orbwalker.Mode == OrbwalkingMode.None &&
                !Extensions.GetEnemyLaneMinionsTargetsInRange(SpellClass.Q.Range).Any() &&
                UtilityClass.Player.MPPercent()
                > ManaManager.GetNeededMana(SpellClass.Q.Slot, MenuClass.Miscellaneous["tear"]) &&
                MenuClass.Miscellaneous["tear"].Enabled)
            {
                SpellClass.Q.Cast(Hud.CursorPositionUnclipped);
            }

            /// <summary>
            ///     The Semi-Automatic R Logic.
            /// </summary>
            if (SpellClass.R.Ready &&
                MenuClass.R["bool"].Enabled &&
                MenuClass.R["key"].As <MenuKeyBind>().Enabled)
            {
                var bestTarget = ObjectCache.EnemyHeroes.Where(t =>
                                                               t.IsValidTarget(2000f) &&
                                                               !Invulnerable.Check(t, DamageType.Magical, false) &&
                                                               MenuClass.R["whitelist"][t.CharName.ToLower()].Enabled)
                                 .MinBy(o => o.GetRealHealth(DamageType.Magical));
                if (bestTarget != null)
                {
                    SpellClass.R.Cast(bestTarget);
                }
            }
        }
示例#20
0
        /// <summary>
        ///     Fired when the game is updated.
        /// </summary>
        public void Automatic(EntropyEventArgs args)
        {
            Orbwalker.MovingEnabled    = !IsUltimateShooting();
            Orbwalker.AttackingEnabled = !IsUltimateShooting();

            if (UtilityClass.Player.IsRecalling())
            {
                return;
            }

            /// <summary>
            ///     The Automatic W Logic.
            /// </summary>
            if (SpellClass.W.Ready &&
                MenuClass.W["logical"].As <MenuBool>().Enabled)
            {
                foreach (var target in ObjectCache.EnemyHeroes.Where(t =>
                                                                     t.HasBuff("jhinespotteddebuff") &&
                                                                     t.IsImmobile(SpellClass.W.Delay) &&
                                                                     t.IsValidTarget(SpellClass.W.Range) &&
                                                                     !Invulnerable.Check(t, DamageType.Magical, false)))
                {
                    SpellClass.W.Cast(target.Position);
                }
            }

            /// <summary>
            ///     The Automatic E Logic.
            /// </summary>
            if (SpellClass.E.Ready &&
                MenuClass.E["logical"].As <MenuBool>().Enabled)
            {
                foreach (var target in ObjectCache.EnemyHeroes.Where(t =>
                                                                     t.IsImmobile(SpellClass.E.Delay) &&
                                                                     t.DistanceToPlayer() < SpellClass.E.Range))
                {
                    SpellClass.E.Cast(target.Position);
                }
            }

            /// <summary>
            ///     The Automatic E on Teleport Logic.
            /// </summary>
            if (SpellClass.E.Ready &&
                MenuClass.E["teleport"].As <MenuBool>().Enabled)
            {
                foreach (var minion in ObjectCache.AllAiBaseClients.Where(m =>
                                                                          m.IsEnemy() &&
                                                                          m.DistanceToPlayer() <= SpellClass.E.Range &&
                                                                          m.GetActiveBuffs().Any(b => b.Name.Equals("teleport_target"))))
                {
                    SpellClass.E.Cast(minion.Position);
                }
            }
        }
示例#21
0
        /// <summary>
        ///     Fired when the game is updated.
        /// </summary>
        public void Automatic(EntropyEventArgs args)
        {
            Orbwalker.AttackingEnabled = !IsFlying();
            Orbwalker.MovingEnabled    = Game.ClockTime - LastCastedETime >= 0.55;

            if (UtilityClass.Player.IsRecalling())
            {
                return;
            }

            /// <summary>
            ///     The Automatic R Orbwalking.
            /// </summary>
            if (IsFlying())
            {
                DelayAction.Queue(() =>
                {
                    Orbwalker.Move(Hud.CursorPositionUnclipped);
                }, 100 + EnetClient.Ping);
            }

            /// <summary>
            ///     The E Before death Logic.
            /// </summary>
            if (SpellClass.E.Ready &&
                MenuClass.E["beforedeath"].Enabled &&
                LocalPlayer.Instance.HPPercent() <= MenuClass.E["beforedeath"].Value)
            {
                SpellClass.E.Cast();
            }

            /// <summary>
            ///     The Semi-Automatic R Management.
            /// </summary>
            if (SpellClass.R.Ready &&
                MenuClass.R["bool"].As <MenuBool>().Enabled&&
                MenuClass.R["key"].As <MenuKeyBind>().Enabled)
            {
                var bestTarget = ObjectCache.EnemyHeroes
                                 .Where(t =>
                                        !Invulnerable.Check(t) &&
                                        t.IsValidTarget(SpellClass.R.Range) &&
                                        MenuClass.R["whitelist"][t.CharName.ToLower()].As <MenuBool>().Enabled)
                                 .MinBy(o => o.GetRealHealth(DamageType.Physical));
                if (bestTarget != null)
                {
                    if (MenuClass.R["mode"].As <MenuList>().Value == 1)
                    {
                        SpellClass.Q.Cast(bestTarget);
                    }

                    SpellClass.R.Cast(bestTarget);
                }
            }
        }
示例#22
0
        /// <summary>
        ///     Fired when the game is updated.
        /// </summary>
        public void Killsteal(EntropyEventArgs args)
        {
            /// <summary>
            ///     The Q Killsteal Logics.
            /// </summary>
            if (SpellClass.Q.Ready)
            {
                /// <summary>
                ///     Normal.
                /// </summary>
                if (MenuClass.Q["killsteal"].Enabled)
                {
                    foreach (var target in Extensions.GetBestSortedTargetsInRange(SpellClass.Q.Range).Where(t =>
                                                                                                            GetQDamage(t) >= t.GetRealHealth(DamageType.Physical)))
                    {
                        SpellClass.Q.CastOnUnit(target);
                        break;
                    }
                }

                /// <summary>
                ///     Extended.
                /// </summary>
                if (MenuClass.Q3["killsteal"].Enabled)
                {
                    foreach (var target in Extensions.GetBestSortedTargetsInRange(SpellClass.Q2.Range).Where(t =>
                                                                                                             !t.IsValidTarget(SpellClass.Q.Range) &&
                                                                                                             GetQDamage(t) >= t.GetRealHealth(DamageType.Physical)))
                    {
                        foreach (var minion in Extensions.GetAllGenericUnitTargetsInRange(SpellClass.Q.Range))
                        {
                            if (QRectangle(minion).IsInsidePolygon(SpellClass.Q.GetPrediction(target).CastPosition))
                            {
                                SpellClass.Q.CastOnUnit(minion);
                                break;
                            }
                        }
                    }
                }
            }

            /// <summary>
            ///     The KillSteal W Logic.
            /// </summary>
            if (SpellClass.W.Ready &&
                MenuClass.W["killsteal"].Enabled)
            {
                foreach (var target in Extensions.GetBestSortedTargetsInRange(SpellClass.W.Range).Where(t =>
                                                                                                        GetWDamage(t) >= t.GetRealHealth(DamageType.Magical)))
                {
                    SpellClass.W.Cast(target);
                    break;
                }
            }
        }
示例#23
0
        /// <summary>
        ///     Fired when the game is updated.
        /// </summary>
        public void LaneClear(EntropyEventArgs args)
        {
            var minions = Extensions.GetEnemyLaneMinionsTargets();

            /// <summary>
            ///     The Q Laneclear Logic.
            /// </summary>
            if (SpellClass.Q.Ready &&
                UtilityClass.Player.MPPercent()
                > ManaManager.GetNeededMana(SpellClass.Q.Slot, MenuClass.Spells["q"]["laneclear"]) &&
                MenuClass.Spells["q"]["laneclear"].As <MenuSliderBool>().Enabled)
            {
                /*
                 * var farmLocation = SpellClass.Q.GetCircularFarmLocation(minions, SpellClass.Q.Width);
                 * if (farmLocation.MinionsHit >= MenuClass.Spells["q"]["customization"]["laneclear"].As<MenuSlider>().Value)
                 * {
                 *  SpellClass.Q.Cast(farmLocation.Position);
                 * }
                 */
            }

            /// <summary>
            ///     The E Laneclear Logic.
            /// </summary>
            if (SpellClass.E.Ready &&
                UtilityClass.Player.MPPercent()
                > ManaManager.GetNeededMana(SpellClass.E.Slot, MenuClass.Spells["e"]["laneclear"]) &&
                MenuClass.Spells["e"]["laneclear"].As <MenuSliderBool>().Enabled)
            {
                var target = Orbwalker.GetOrbwalkingTarget() as AIMinionClient;
                if (target != null &&
                    minions.Contains(target) &&
                    minions.Count(m => m.Distance(target) <= SpellClass.E.Width) >= MenuClass.Spells["e"]["customization"]["laneclear"].As <MenuSlider>().Value)
                {
                    SpellClass.E.Cast();
                }
            }

            /// <summary>
            ///     The R Laneclear Logic.
            /// </summary>
            if (SpellClass.R.Ready &&
                UtilityClass.Player.MPPercent()
                > ManaManager.GetNeededMana(SpellClass.R.Slot, MenuClass.Spells["r"]["laneclear"]) &&
                MenuClass.Spells["r"]["laneclear"].As <MenuSliderBool>().Enabled)
            {
                /*
                 * var farmLocation = SpellClass.R.GetCircularFarmLocation(minions, this.HasBigOne() ? SpellClass.R2.Width : SpellClass.R.Width);
                 * if (farmLocation.MinionsHit >= MenuClass.Spells["q"]["customization"]["laneclear"].As<MenuSlider>().Value)
                 * {
                 *  SpellClass.Q.Cast(farmLocation.Position);
                 * }
                 */
            }
        }
示例#24
0
        /// <summary>
        ///     Fired when the game is updated.
        /// </summary>
        public void LaneClear(EntropyEventArgs args)
        {
            /// <summary>
            ///     The Q Laneclear Logic.
            /// </summary>
            if (SpellClass.Q.Ready &&
                UtilityClass.Player.MPPercent()
                > ManaManager.GetNeededMana(SpellClass.Q.Slot, MenuClass.Spells["q"]["laneclear"]) &&
                MenuClass.Spells["q"]["laneclear"].As <MenuSliderBool>().Enabled)
            {
                var bestMinion = Extensions.GetEnemyLaneMinionsTargetsInRange(SpellClass.Q.Range)
                                 .Where(m => m.HP < UtilityClass.Player.GetSpellDamage(m, SpellSlot.Q))
                                 .FirstOrDefault(m => Extensions.GetEnemyLaneMinionsTargetsInRange(SpellClass.Q2.Range)
                                                 .Any(m2 =>
                                                      m2.NetworkID != m.NetworkID &&
                                                      QCone(m).IsInside((Vector2)m2.Position) &&
                                                      m2.HP < UtilityClass.Player.GetSpellDamage(m2, SpellSlot.Q, DamageStage.Empowered) + GetMinionLoveTapDamageMultiplier()));
                if (bestMinion != null)
                {
                    SpellClass.Q.CastOnUnit(bestMinion);
                }
            }

            /// <summary>
            ///     The Laneclear W Logic.
            /// </summary>
            if (SpellClass.W.Ready &&
                UtilityClass.Player.MPPercent()
                > ManaManager.GetNeededMana(SpellClass.W.Slot, MenuClass.Spells["w"]["laneclear"]) &&
                MenuClass.Spells["w"]["laneclear"].As <MenuSliderBool>().Enabled)
            {
                if (Extensions.GetEnemyLaneMinionsTargetsInRange(UtilityClass.Player.GetAutoAttackRange()).Any())
                {
                    SpellClass.W.Cast();
                }
            }

            /// <summary>
            ///     The Laneclear E Logic.
            /// </summary>
            if (SpellClass.E.Ready &&
                UtilityClass.Player.MPPercent()
                > ManaManager.GetNeededMana(SpellClass.E.Slot, MenuClass.Spells["e"]["laneclear"]) &&
                MenuClass.Spells["e"]["laneclear"].As <MenuSliderBool>().Enabled)
            {
                /*
                 * var farmLocation = SpellClass.E.GetCircularFarmLocation(Extensions.GetEnemyLaneMinionsTargets(), SpellClass.E.Width);
                 * if (farmLocation.MinionsHit >= MenuClass.Spells["e"]["customization"]["laneclear"].As<MenuSlider>().Value)
                 * {
                 *  SpellClass.E.Cast(farmLocation.Position);
                 * }
                 */
            }
        }
示例#25
0
 public void OnEndScene(EntropyEventArgs args)
 {
     /// <summary>
     ///     Loads the R minimap drawing.
     /// </summary>
     if (SpellClass.R.Ready &&
         MenuClass.Drawings["rmm"].Enabled)
     {
         var scale = (TacticalMap.ScaleX + TacticalMap.ScaleY) / 4.5;
         TacticalMapRendering.Render(Color.White, UtilityClass.Player.Position, (float)(SpellClass.R.Range / scale));
     }
 }
示例#26
0
        /// <summary>
        ///     Fired when the game is updated.
        /// </summary>
        public void Harass(EntropyEventArgs args)
        {
            /// <summary>
            ///     The Q Harass Logic.
            /// </summary>
            if (SpellClass.Q.Ready &&
                UtilityClass.Player.MPPercent()
                > ManaManager.GetNeededMana(SpellClass.Q.Slot, MenuClass.Spells["q"]["harass"]) &&
                MenuClass.Spells["q"]["harass"].As <MenuSliderBool>().Enabled)
            {
                var bestTarget = Extensions.GetBestEnemyHeroTargetInRange(SpellClass.Q.Range);
                if (bestTarget != null &&
                    !Invulnerable.Check(bestTarget, DamageType.Magical) &&
                    MenuClass.Spells["q"]["whitelist"][bestTarget.CharName.ToLower()].As <MenuBool>().Enabled)
                {
                    SpellClass.Q.Cast(bestTarget);
                }
            }

            /// <summary>
            ///     The E Harass Logic.
            /// </summary>
            if (SpellClass.E.Ready &&
                UtilityClass.Player.MPPercent()
                > ManaManager.GetNeededMana(SpellClass.E.Slot, MenuClass.Spells["e"]["harass"]) &&
                MenuClass.Spells["e"]["harass"].As <MenuSliderBool>().Enabled)
            {
                var bestTarget = Extensions.GetBestEnemyHeroTargetInRange(SpellClass.E.Range);
                if (bestTarget != null &&
                    !Invulnerable.Check(bestTarget, DamageType.Magical) &&
                    MenuClass.Spells["e"]["whitelist"][bestTarget.CharName.ToLower()].As <MenuBool>().Enabled)
                {
                    SpellClass.E.Cast();
                }
            }

            /// <summary>
            ///     The R Harass Logic.
            /// </summary>
            if (SpellClass.R.Ready &&
                UtilityClass.Player.MPPercent()
                > ManaManager.GetNeededMana(SpellClass.R.Slot, MenuClass.Spells["r"]["harass"]) &&
                MenuClass.Spells["r"]["harass"].As <MenuSliderBool>().Enabled)
            {
                var bestTarget = Extensions.GetBestEnemyHeroTargetInRange(SpellClass.R.Range);
                if (bestTarget != null &&
                    !Invulnerable.Check(bestTarget, DamageType.Magical) &&
                    MenuClass.Spells["r"]["whitelist"][bestTarget.CharName.ToLower()].As <MenuBool>().Enabled)
                {
                    SpellClass.R.Cast(bestTarget);
                }
            }
        }
示例#27
0
        /// <summary>
        ///     Fired when the game is updated.
        /// </summary>
        public void Automatic(EntropyEventArgs args)
        {
            var passiveObject = ObjectManager.Get <GameObject>().FirstOrDefault(o => o.IsValid && o.Name == "MissFortune_Base_P_Mark.troy");

            if (passiveObject != null)
            {
                var passiveUnit = ObjectManager.Get <AttackableUnit>()
                                  .MinBy(o => o.Distance(passiveObject));

                LoveTapTargetNetworkId = passiveUnit?.NetworkID ?? 0;
            }
            else
            {
                LoveTapTargetNetworkId = 0;
            }

            if (UtilityClass.Player.IsRecalling())
            {
                return;
            }

            /// <summary>
            ///     The Semi-Automatic R Management.
            /// </summary>
            if (SpellClass.R.Ready &&
                MenuClass.Spells["r"]["bool"].As <MenuBool>().Enabled)
            {
                var bestTarget = GameObjects.EnemyHeroes
                                 .Where(t =>
                                        !Invulnerable.Check(t) &&
                                        t.IsValidTarget(SpellClass.R.Range) &&
                                        MenuClass.Spells["r"]["whitelist"][t.CharName.ToLower()].As <MenuBool>().Enabled)
                                 .MinBy(o => o.EnemyHeroesCount(300f));

                if (bestTarget != null &&
                    !IsUltimateShooting() &&
                    MenuClass.Spells["r"]["key"].As <MenuKeyBind>().Enabled)
                {
                    if (SpellClass.E.Ready &&
                        bestTarget.IsValidTarget(SpellClass.E.Range))
                    {
                        SpellClass.E.Cast(bestTarget.Position);
                    }

                    SpellClass.R.Cast(bestTarget.Position);
                }
                else if (IsUltimateShooting() &&
                         !MenuClass.Spells["r"]["key"].As <MenuKeyBind>().Enabled)
                {
                    UtilityClass.Player.IssueOrder(OrderType.MoveTo, Hud.CursorPositionUnclipped);
                }
            }
        }
示例#28
0
        /// <summary>
        ///     Fired when the game is updated.
        /// </summary>
        public void LaneClear(EntropyEventArgs args)
        {
            /// <summary>
            ///     The Laneclear Q Logic.
            /// </summary>
            if (SpellClass.Q.Ready &&
                UtilityClass.Player.MPPercent()
                > ManaManager.GetNeededMana(SpellClass.Q.Slot, MenuClass.Spells["q"]["laneclear"]) &&
                MenuClass.Spells["q"]["laneclear"].As <MenuSliderBool>().Enabled)
            {
                /*
                 * var farmLocation = SpellClass.Q.GetCircularFarmLocation(minions, SpellClass.Q.Width);
                 * if (farmLocation.MinionsHit >= MenuClass.Spells["q"]["customization"]["laneclear"].As<MenuSlider>().Value)
                 * {
                 *  SpellClass.Q.Cast(farmLocation.Position);
                 * }
                 */
            }

            /// <summary>
            ///     The Laneclear W Logic.
            /// </summary>
            if (SpellClass.W.Ready &&
                UtilityClass.Player.MPPercent()
                > ManaManager.GetNeededMana(SpellClass.W.Slot, MenuClass.Spells["w"]["laneclear"]) &&
                MenuClass.Spells["w"]["laneclear"].As <MenuSliderBool>().Enabled)
            {
                /*
                 * var farmLocation = SpellClass.W.GetCircularFarmLocation(minions, SpellClass.W.Width);
                 * if (farmLocation.MinionsHit >= MenuClass.Spells["w"]["customization"]["laneclear"].As<MenuSlider>().Value)
                 * {
                 *  SpellClass.W.Cast(farmLocation.Position);
                 * }
                 */
            }

            /// <summary>
            ///     The Laneclear E Logic.
            /// </summary>
            if (SpellClass.E.Ready &&
                UtilityClass.Player.MPPercent()
                > ManaManager.GetNeededMana(SpellClass.E.Slot, MenuClass.Spells["e"]["laneclear"]) &&
                MenuClass.Spells["e"]["laneclear"].As <MenuSliderBool>().Enabled)
            {
                /*
                 * var farmLocation = SpellClass.E.GetConicalFarmLocation(minions, SpellClass.E.Width);
                 * if (farmLocation.MinionsHit >= MenuClass.Spells["e"]["customization"]["laneclear"].As<MenuSlider>().Value)
                 * {
                 *  SpellClass.E.Cast(farmLocation.Position);
                 * }
                 */
            }
        }
示例#29
0
        /// <summary>
        ///     Fired when the game is updated.
        /// </summary>
        public void Automatic(EntropyEventArgs args)
        {
            if (UtilityClass.Player.Spellbook.GetSpell(SpellSlot.E).Level == 5)
            {
                SpellClass.E.Width = UtilityClass.GetAngleByDegrees(60);
            }

            if (UtilityClass.Player.Spellbook.GetSpell(SpellSlot.R).Level == 3)
            {
                SpellClass.R.Range = 750f;
            }
        }
示例#30
0
 /// <summary>
 ///     Fired as fast as possible.
 /// </summary>
 public void ExpungeAutomatic(EntropyEventArgs args)
 {
     /// <summary>
     ///     The Automatic E Logics.
     /// </summary>
     if (SpellClass.E.Ready &&
         MenuClass.Spells["e"]["ondeath"].As <MenuBool>().Enabled&&
         ImplementationClass.IHealthPrediction.GetPrediction(UtilityClass.Player, 1000 + Game.Ping) <= 0)
     {
         SpellClass.E.Cast();
     }
 }