Example #1
0
        private static void ImplementationOnPostAttack(object enemy, PostAttackEventArgs events)
        {
            if (Player.IsDead || MenuGUI.IsChatOpen())
            {
                return;
            }

            var turret = GameObjects.EnemyTurrets.FirstOrDefault(t => !t.IsDead);

            if (Orbwalker.Implementation.Mode.Equals(OrbwalkingMode.Combo) && Setup.Combo["Q"].As <MenuBool>().Enabled&& Spells.Q.Ready)
            {
                Obj_AI_Hero target = events.Target as Obj_AI_Hero;
                if (target != null && Setup.Combo["Mana"].As <MenuSlider>().Value < Player.ManaPercent())
                {
                    var endPos = Player.ServerPosition.Extend(Game.CursorPos, 300);
                    if (endPos.CountEnemyHeroesInRange(850) < Setup.Misc["Qx"].As <MenuSlider>().Value&&
                        endPos.Distance(target.ServerPosition) < Player.AttackRange)
                    {
                        if (target.AttackRange < Player.AttackRange && endPos.Distance(target.ServerPosition) < target.AttackRange)
                        {
                            return;
                        }
                        if (endPos.Distance(turret.ServerPosition) < turret.AttackRange && Setup.Misc["Turret"].As <MenuBool>().Enabled)
                        {
                            return;
                        }
                        Spells.Q.Cast(endPos);
                    }
                }
            }

            if (Orbwalker.Implementation.Mode.Equals(OrbwalkingMode.Mixed) && Setup.Harass["Q"].As <MenuBool>().Enabled&& Spells.Q.Ready)
            {
                Obj_AI_Hero target = events.Target as Obj_AI_Hero;
                if (target != null && Setup.Harass["Mana"].As <MenuSlider>().Value < Player.ManaPercent() && Setup.Harass["Key"].Enabled)
                {
                    var endPos = Player.ServerPosition.Extend(Game.CursorPos, 300);
                    if (endPos.CountEnemyHeroesInRange(850) < Setup.Misc["Qx"].As <MenuSlider>().Value&&
                        endPos.Distance(target.ServerPosition) < Player.AttackRange)
                    {
                        if (target.AttackRange < Player.AttackRange && endPos.Distance(target.ServerPosition) < target.AttackRange)
                        {
                            return;
                        }
                        if (Setup.Harass["QW"].As <MenuBool>().Enabled&& target.GetBuffCount("vaynesilvereddebuff") != 2)
                        {
                            return;
                        }
                        if (endPos.Distance(turret.ServerPosition) < turret.AttackRange && Setup.Misc["Turret"].As <MenuBool>().Enabled)
                        {
                            return;
                        }
                        Spells.Q.Cast(endPos);
                    }
                }
            }

            if (Orbwalker.Implementation.Mode.Equals(OrbwalkingMode.Laneclear) && Setup.Clear["Q"].As <MenuBool>().Enabled&& Spells.Q.Ready)
            {
                Obj_AI_Minion target = events.Target as Obj_AI_Minion;
                if (target != null && Setup.Clear["Mana"].As <MenuSlider>().Value < Player.ManaPercent() && Setup.Clear["Key"].Enabled)
                {
                    var endPos = Player.ServerPosition.Extend(Game.CursorPos, 300);
                    if (endPos.CountEnemyHeroesInRange(850) < Setup.Misc["Qx"].As <MenuSlider>().Value&&
                        endPos.Distance(target.ServerPosition) < Player.AttackRange)
                    {
                        if (target.AttackRange < Player.AttackRange && endPos.Distance(target.ServerPosition) < target.AttackRange)
                        {
                            return;
                        }
                        if (endPos.Distance(turret.ServerPosition) < turret.AttackRange && Setup.Misc["Turret"].As <MenuBool>().Enabled)
                        {
                            return;
                        }
                        Spells.Q.Cast(endPos);
                    }
                }
            }
        }
Example #2
0
        private static void Game_OnUpdate()
        {
            if (Player.IsDead || MenuGUI.IsChatOpen())
            {
                return;
            }
            switch (Misc.Orbwalker.Mode)
            {
            case OrbwalkingMode.Combo:
                Combo();
                break;

            case OrbwalkingMode.Mixed:
                Harass();
                break;

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

            if (R.Ready && Main["combo"]["rKS"].As <MenuBool>().Enabled)
            {
                var target = GetBestEnemyHeroTargetInRange(R.Range);
                if (target != null && !Player.HasBuff("JarvanIVCataclysm"))
                {
                    if (target.Health < RDamage(target) && !Check(target))
                    {
                        if (Player.Distance(target.ServerPosition) < 650 && (Player.Distance(target.ServerPosition) > 450 && !E.Ready && !Q.Ready || Player.HealthPercent() < 15))
                        {
                            R.Cast(target);
                        }
                        if (Player.Distance(target.ServerPosition) > 870 && Player.Health > target.Health && target.CountEnemyHeroesInRange(700) <= 2)
                        {
                            FullCombo();
                        }
                    }
                }
            }
            if (Main["combo"]["autoR"].As <MenuSliderBool>().Enabled&& R.Ready)
            {
                var target = GetBestEnemyHeroTargetInRange(R.Range);
                if (target != null && !Player.HasBuff("JarvanIVCataclysm"))
                {
                    if (GameObjects.EnemyHeroes.Count(t => t.IsValidTarget(R2.Width, false, true, R2.GetPrediction(target).CastPosition)) >= Main["combo"]["autoR"].As <MenuSliderBool>().Value)
                    {
                        R.CastOnUnit(target);
                    }
                }
            }
            if (R.Ready && Main["combo"]["r"].As <MenuKeyBind>().Enabled)
            {
                var target = GetBestEnemyHeroTargetInRange(R.Range);
                if (target != null && !Player.HasBuff("JarvanIVCataclysm"))
                {
                    R.CastOnUnit(target);
                }
            }
            if (Main["combo"]["eqrKey"].As <MenuKeyBind>().Enabled)
            {
                FullCombo();
            }
            if (Main["combo"]["eqfKey"].As <MenuKeyBind>().Enabled)
            {
                EqFlash();
            }
            if (Main["combo"]["fleeKey"].As <MenuKeyBind>().Enabled)
            {
                if (Q.Ready && E.Ready && Player.Mana > Player.SpellBook.GetSpell(SpellSlot.E).Cost + Player.SpellBook.GetSpell(SpellSlot.Q).Cost)
                {
                    E.Cast(Game.CursorPos);
                    Q.Cast(Game.CursorPos);
                }
            }
            if (Main["harass"]["autoH"].As <MenuBool>().Enabled&& Misc.Orbwalker.Mode != OrbwalkingMode.Combo && Misc.Orbwalker.Mode != OrbwalkingMode.Mixed)
            {
                Harass();
            }
        }
Example #3
0
        /// <summary>
        ///     An application-defined function that processes messages sent to a window.
        /// </summary>
        /// <param name="message">The message.</param>
        /// <param name="wparam">Additional message information.</param>
        /// <param name="lparam">Additional message information.</param>
        public override void WndProc(uint message, uint wparam, int lparam)
        {
            //No need to process if the item does not belong to a menu yet
            if (this.Parent == null)
            {
                return;
            }

            if (this.Visible)
            {
                var x = lparam & 0xffff;
                var y = lparam >> 16;

                if (message == (ulong)WindowsMessages.WM_LBUTTONDOWN)
                {
                    if (!this.KeyIsBeingSet && this.GetBounds(this.Position).Contains(x, y))
                    {
                        if (!MenuManager.Instance.Theme.GetMenuBoolControlBounds(this.Position, this.Parent.Width).Contains(x, y))
                        {
                            this.KeyIsBeingSet = true;
                        }

                        else
                        {
                            this.UpdateValue(!this.Value);
                        }
                    }
                }

                if (this.KeyIsBeingSet && message == (ulong)WindowsMessages.WM_KEYUP)
                {
                    this.UpdateKey((KeyCode)wparam);
                    this.KeyIsBeingSet = false;
                }
            }

            if (this.Inactive || wparam != (ulong)this.Key || this.KeyIsBeingSet || MenuGUI.IsShopOpen() || MenuGUI.IsChatOpen())
            {
                return;
            }

            if (this.KeybindType == KeybindType.Press)
            {
                if (message == (ulong)WindowsMessages.WM_KEYDOWN)
                {
                    this.UpdateValue(true);
                }
                else if (message == (ulong)WindowsMessages.WM_KEYUP)
                {
                    this.UpdateValue(false);
                }
            }

            else if (message == (ulong)WindowsMessages.WM_KEYUP)
            {
                this.UpdateValue(!this.Value);
            }
        }
Example #4
0
        private static void Render_OnPresent()
        {
            if (Player.IsDead || MenuGUI.IsChatOpen())
            {
                return;
            }

            if (Setup.Draw["Q"].As <MenuBool>().Enabled&& Spells.Q.Ready)
            {
                Render.Circle(Player.Position, Spells.Q.Range, 30, Color.LimeGreen);
            }

            if (Setup.Orb["EAA"].As <MenuBool>().Enabled)
            {
                foreach (var enemy in GameObjects.EnemyHeroes)
                {
                    if (enemy.IsOnScreen && !enemy.IsDead)
                    {
                        Render.Circle(enemy.ServerPosition, enemy.AttackRange, 30, Color.Red);
                    }
                }
            }

            if (Setup.Orb["TAA"].As <MenuBool>().Enabled)
            {
                foreach (var turret in GameObjects.EnemyTurrets)
                {
                    if (turret.IsOnScreen && !turret.IsDead)
                    {
                        Render.Circle(turret.ServerPosition, 875, 30, Color.Red);
                    }
                }
            }
            foreach (var allyt in GameObjects.AllyTurrets)
            {
                if (allyt.IsOnScreen && !allyt.IsDead)
                {
                    Render.Circle(allyt.ServerPosition, 875, 30, Color.LimeGreen);
                }
            }

            if (Setup.Draw["S"].As <MenuBool>().Enabled)
            {
                Vector2 TextPos;
                var     playerpos = Render.WorldToScreen(Player.Position, out TextPos);
                var     xOffset   = (int)TextPos.X;
                var     yOffset   = (int)TextPos.Y;

                if (Setup.Clear["Key"].Enabled)
                {
                    Render.Text(xOffset - 50, yOffset + 20, Color.LimeGreen, "Clear with Spells: On");
                }
                if (!Setup.Clear["Key"].Enabled)
                {
                    Render.Text(xOffset - 50, yOffset + 20, Color.Red, "Clear with Spells: Off");
                }

                if (Setup.Harass["Key"].Enabled)
                {
                    Render.Text(xOffset - 50, yOffset + 40, Color.LimeGreen, "Harass with Spells: On");
                }
                if (!Setup.Harass["Key"].Enabled)
                {
                    Render.Text(xOffset - 50, yOffset + 40, Color.Red, "Harass with Spells: Off");
                }
            }

            if (Setup.Draw["D"].As <MenuBool>().Enabled)
            {
                ObjectManager.Get <Obj_AI_Base>()
                .Where(h => h is Obj_AI_Hero && h.IsValidTarget() && h.IsOnScreen)
                .ToList()
                .ForEach(
                    unit =>
                {
                    var heroUnit       = unit as Obj_AI_Hero;
                    int width          = 103;
                    int xOffset        = SxOffset(heroUnit);
                    int yOffset        = SyOffset(heroUnit);
                    var barPos         = unit.FloatingHealthBarPosition;
                    barPos.X          += xOffset + 22;
                    barPos.Y          += yOffset - 16;
                    var drawEndXPos    = barPos.X + width * (unit.HealthPercent() / 100);
                    var drawQStartXPos =
                        (float)(barPos.X + (unit.Health >
                                            Qdmg(unit)
                                             ? width * ((unit.Health - (Qdmg(unit)
                                                                        )) /
                                                        unit.MaxHealth * 100 / 100)
                                             : 0));

                    Render.Line(drawQStartXPos, barPos.Y, drawEndXPos, barPos.Y, 12, true,
                                unit.Health < Qdmg(unit) + Wdmg(unit) + Edmg(unit) + Rdmg(unit)
                                    ? Color.Purple
                                    : Color.LimeGreen);

                    var drawWStartXPos =
                        (float)(barPos.X + (unit.Health >
                                            Qdmg(unit) + Wdmg(unit)
                                             ? width * ((unit.Health - (Qdmg(unit) + Wdmg(unit)
                                                                        )) /
                                                        unit.MaxHealth * 100 / 100)
                                             : 0));

                    Render.Line(drawWStartXPos, barPos.Y, drawQStartXPos, barPos.Y, 12, true,
                                unit.Health < Qdmg(unit) + Wdmg(unit) + Edmg(unit) + Rdmg(unit)
                                    ? Color.Purple
                                    : Color.Cyan);

                    var drawEStartXPos =
                        (float)(barPos.X + (unit.Health >
                                            Qdmg(unit) + Wdmg(unit) + Edmg(unit)
                                             ? width * ((unit.Health - (Qdmg(unit) + Wdmg(unit) + Edmg(unit)
                                                                        )) /
                                                        unit.MaxHealth * 100 / 100)
                                             : 0));

                    Render.Line(drawEStartXPos, barPos.Y, drawWStartXPos, barPos.Y, 12, true,
                                unit.Health < Qdmg(unit) + Wdmg(unit) + Edmg(unit) + Rdmg(unit)
                                    ? Color.Purple
                                    : Color.Pink);

                    var drawRStartXPos =
                        (float)(barPos.X + (unit.Health >
                                            Qdmg(unit) + Wdmg(unit) + Edmg(unit) + Rdmg(unit)
                                             ? width * ((unit.Health - (Qdmg(unit) + Wdmg(unit) + Edmg(unit) + Rdmg(unit)
                                                                        )) /
                                                        unit.MaxHealth * 100 / 100)
                                             : 0));

                    Render.Line(drawRStartXPos, barPos.Y, drawEStartXPos, barPos.Y, 12, true,
                                unit.Health < Qdmg(unit) + Wdmg(unit) + Edmg(unit) + Rdmg(unit)
                                    ? Color.Purple
                                    : Color.DarkBlue);
                });
            }
        }
Example #5
0
        private static void Game_OnUpdate()
        {
            if (Player.IsDead || MenuGUI.IsChatOpen())
            {
                return;
            }
            switch (Misc.Orbwalker.Mode)
            {
            case OrbwalkingMode.Combo:
                Combo();
                break;

            case OrbwalkingMode.Mixed:
                Harass();
                break;

            case OrbwalkingMode.Laneclear:
                LaneClear();
                JungleClear();
                break;
            }
            if (Q.Ready && Main["combo"]["qEE"].As <MenuSliderBool>().Enabled&& Player.ManaPercent() > Main["combo"]["qEE"].As <MenuSliderBool>().Value)
            {
                foreach (var minion in GameObjects.EnemyMinions.Where(x => x.IsValidTarget(Q.Range, true)))
                {
                    if (minion != null)
                    {
                        var enemyInBounceRange = GameObjects.EnemyHeroes.FirstOrDefault(x => x.IsValidTarget(800, false, false, minion.ServerPosition));
                        if (enemyInBounceRange != null && enemyInBounceRange.Distance(Player) > 620)
                        {
                            if (minion.Distance(enemyInBounceRange) < 350 & minion.CountEnemyHeroesInRange(350) <= 3)
                            {
                                Q.CastOnUnit(minion);
                            }
                        }
                    }
                }
            }

            if (R.Ready && Main["combo"]["rKS"].As <MenuBool>().Enabled)
            {
                JhinR();
            }

            if (W.Ready && Main["combo"]["wKS"].As <MenuBool>().Enabled&& Misc.Orbwalker.Mode != OrbwalkingMode.Combo && !IsCastingR())
            {
                var target = TargetSelector.GetTarget(2800);
                if (target != null && target.Health <= WDamage(target))
                {
                    W.Cast(target);
                }
            }
            if (E.Ready && Main["combo"]["eCC"].As <MenuBool>().Enabled&& !IsCastingR())
            {
                foreach (var target in GameObjects.EnemyHeroes.Where(x => x.IsImmobile() && x.Distance(Player) < E.Range))
                {
                    E.Cast(target);
                }
                foreach (var minion in ObjectManager.Get <Obj_AI_Minion>().Where(x => x.IsEnemy && x.Distance(Player) <= W.Range && x.ValidActiveBuffs().Any(y => y.Name.Equals("teleport_target"))))
                {
                    E.Cast(minion.ServerPosition);
                }
            }
            if (Q.Ready && Main["harass"]["qA"].As <MenuSliderBool>().Enabled&& Player.ManaPercent() > Main["harass"]["qA"].As <MenuSliderBool>().Value&& !IsCastingR())
            {
                var target = GetBestEnemyHeroTargetInRange(Q.Range);
                if (target != null)
                {
                    var qHit = GameObjects.EnemyHeroes.Where(x => x.Distance(target) <= 400f).ToList();
                    if (qHit.Count >= Main["harass"]["qHit"].As <MenuSlider>().Value || target.Health <= QDamage(target))
                    {
                        Q.CastOnUnit(target);
                    }
                }
            }

            if (R.Ready && Main["combo"]["rKey"].As <MenuKeyBind>().Enabled)
            {
                R.Range = !IsCastingR() ? Main["combo"]["rMax"].As <MenuSlider>().Value : 3500;
                var targetR = GetBestEnemyHeroTargetInRange(R.Range);
                if (targetR != null && targetR.IsValidTarget())
                {
                    _rPosLast = R.GetPrediction(targetR).CastPosition;

                    if (!IsCastingR() && Player.CountEnemyHeroesInRange(800) == 0 && !Player.IsUnderEnemyTurret() && !Check(targetR) && !IsSpellHeroCollision(targetR, R))
                    {
                        R.Cast(_rPosLast); _rTargetLast = targetR;
                    }
                    if (IsCastingR())
                    {
                        if (InCone(targetR.ServerPosition))
                        {
                            R.Cast(targetR);
                        }
                        else
                        {
                            foreach (var enemy in GameObjects.EnemyHeroes.Where(enemy => enemy.IsValidTarget(R.Range) && InCone(targetR.ServerPosition)).OrderBy(enemy => enemy.Health))
                            {
                                R.Cast(targetR); _rPosLast = R.GetPrediction(enemy).CastPosition; _rTargetLast = enemy;
                            }
                        }
                    }
                }
                else if (IsCastingR() && _rTargetLast != null && !_rTargetLast.IsDead)
                {
                    if (!Main["combo"]["rVisable"].As <MenuBool>().Enabled&& InCone(_rTargetLast.Position) && InCone(_rPosLast))
                    {
                        R.Cast(_rPosLast);
                    }
                }
            }

            Misc.Orbwalker.MovingEnabled    = !IsCastingR();
            Misc.Orbwalker.AttackingEnabled = !IsCastingR();
        }
Example #6
0
        private static void Game_OnUpdate()
        {
            if (Lux.IsDead || MenuGUI.IsChatOpen())
            {
                return;
            }
            switch (Orbwalker.Mode)
            {
            case OrbwalkingMode.Combo:
                Combo();
                break;

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

            case OrbwalkingMode.Mixed:
                Harass();
                break;
            }
            if (Main["harass"]["autoHarass"].As <MenuBool>().Enabled)
            {
                Harass();
            }
            if (Main["combo"]["wAuto"].As <MenuSliderBool>().Enabled&& Lux.ManaPercent() > Main["combo"]["wAuto"].As <MenuSliderBool>().Value&& Orbwalker.Mode != OrbwalkingMode.Combo)
            {
                foreach (var ally in ObjectManager.Get <Obj_AI_Hero>().Where(x => x.IsInRange(_w.Range) && x.IsAlly && x.HealthPercent() <= Main["combo"]["wProtect"].Value && x.CountEnemyHeroesInRange(750) >= 1))
                {
                    if (ally.IsInRange(_w.Range) && !Lux.IsRecalling())
                    {
                        _w.CastOnUnit(ally);
                    }
                }
            }
            if (Main["jungleclear"]["jungSteal"].As <MenuKeyBind>().Enabled&& _r.Ready)
            {
                foreach (var jungSteal in ObjectManager.Get <Obj_AI_Minion>().Where(x => x.IsValidTarget(_r.Range) && Lux.GetSpellDamage(x, SpellSlot.R) >= x.Health))
                {
                    if (jungSteal.UnitSkinName.StartsWith("SRU_Dragon") || jungSteal.UnitSkinName.StartsWith("SRU_Baron") || jungSteal.UnitSkinName.StartsWith("SRU_RiftHerald"))
                    {
                        _r.Cast(jungSteal);
                    }
                }
            }
            if (_r.Ready && Main["combo"]["keyR"].As <MenuKeyBind>().Enabled)
            {
                var target = TargetSelector.GetTarget(_r.Range);
                if (target == null)
                {
                    return;
                }
                _r.Cast(target);
            }

            if (!_r.Ready || !Main["combo"]["rKillSteal"].As <MenuBool>().Enabled)
            {
                return;
            }
            {
                var target = TargetSelector.Implementation.GetOrderedTargets(_r.Range).FirstOrDefault(x => x.Health < Lux.GetSpellDamage(x, SpellSlot.R));
                if (target != null && Lux.Distance(target) > 350)
                {
                    _r.Cast(target);
                }
            }
        }
Example #7
0
        private void Game_OnUpdate()
        {
            if (Player.IsDead || MenuGUI.IsChatOpen())
            {
                return;
            }

            //Count kindred stacks to adjust E range
            //kindredmarkofthekindredstackcounter
            int stackCount = Player.GetBuffCount("kindredmarkofthekindredstackcounter");

            if (stackCount < 4)
            {
                erangemodifier = 0;
            }
            else if (stackCount >= 4 && stackCount < 7)
            {
                erangemodifier = 75;
            }
            else if (stackCount >= 7 && stackCount < 10)
            {
                erangemodifier = 100;
            }
            else if (stackCount >= 10 && stackCount < 13)
            {
                erangemodifier = 125;
            }
            else if (stackCount >= 13 && stackCount < 16)
            {
                erangemodifier = 150;
            }
            else if (stackCount >= 16 && stackCount < 19)
            {
                erangemodifier = 175;
            }
            else if (stackCount >= 19 && stackCount < 22)
            {
                erangemodifier = 200;
            }
            else if (stackCount >= 22 && stackCount < 25)
            {
                erangemodifier = 250;
            }
            else if (stackCount > 25)
            {
                erangemodifier = 250;
            }

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

            case OrbwalkingMode.Mixed:
                Mixed();
                break;

            case OrbwalkingMode.Laneclear:
                LaneClear();     //TODO
                JungleClear();
                break;
            }

            if (Champions.Kindred.MenuClass.rsettingsmenu["autor"].Enabled && R.Ready)
            {
                AutoR();
            }
        }
Example #8
0
        private static void Game_OnUpdate()
        {
            if (Player.IsDead || MenuGUI.IsChatOpen())
            {
                return;
            }
            switch (Misc.Orbwalker.Mode)
            {
            case OrbwalkingMode.Combo:
                Combo();
                break;

            case OrbwalkingMode.Mixed:
                Harass();
                break;

            case OrbwalkingMode.Laneclear:
                LaneClear();
                JungleClear();
                break;
            }
            if (Main["harass"]["autoHarass"].As <MenuBool>().Enabled&& Misc.Orbwalker.Mode != OrbwalkingMode.Mixed && Misc.Orbwalker.Mode != OrbwalkingMode.Combo)
            {
                Harass();
            }
            if (Q.Ready && Main["combo"]["qCC"].As <MenuBool>().Enabled)
            {
                foreach (var target in GameObjects.EnemyHeroes.Where(x => x.IsImmobile() && x.IsValidTarget(Q.Range) && !Check(x, DamageType.Magical)))
                {
                    CastQ(target);
                }
            }
            if (Q.Ready && Main["combo"]["qKS"].As <MenuBool>().Enabled)
            {
                var target = GetBestEnemyHeroTargetInRange(Q.Range);
                if (target != null)
                {
                    if (target.IsValidTarget() && target.Health < QDamage(target) && !Check(target, DamageType.Magical))
                    {
                        CastQ(target);
                    }
                }
            }
            if (E.Ready && Main["combo"]["eCC"].As <MenuBool>().Enabled)
            {
                foreach (var target in GameObjects.EnemyHeroes.Where(x => x.IsImmobile() && x.IsValidTarget(E.Range) && !Check(x, DamageType.Magical)))
                {
                    E.Cast(target, true);
                }
            }

            if (E.Ready && Main["combo"]["eKS"].As <MenuBool>().Enabled)
            {
                var target = GetBestEnemyHeroTargetInRange(E.Range - 100);
                if (target != null)
                {
                    if (target.IsValidTarget() && target.Health < QDamage(target) && !Check(target, DamageType.Magical))
                    {
                        var epred = E.GetPrediction(target);
                        if (epred.HitChance >= HitChance.VeryHigh)
                        {
                            E.Cast(epred.CastPosition);
                        }
                    }
                }
            }

            if (Player.HasBuff("LuxLightStrikeKugel"))
            {
                var ePosition = _eposition.CountEnemyHeroesInRange(350f);
                if (Main["combo"]["eSD"].As <MenuBool>().Enabled)
                {
                    var detonate = ePosition - _eposition.CountEnemyHeroesInRange(200f);

                    if (detonate > 0 || ePosition > 1)
                    {
                        E.Cast();
                    }
                }
                else
                {
                    if (ePosition > 0)
                    {
                        E.Cast();
                    }
                }
            }

            if (R.Ready && Main["combo"]["keyR"].As <MenuKeyBind>().Enabled)
            {
                var target = GetBestEnemyHeroTargetInRange(R.Range);
                if (target != null && target.IsValidTarget(R.Range))
                {
                    R.Cast(target, true);
                }
            }
            if (R.Ready && Main["combo"]["rKillSteal"].As <MenuBool>().Enabled)
            {
                var target = GetBestEnemyHeroTargetInRange(R.Range);
                var rpred  = R.GetPrediction(target);
                if (target != null)
                {
                    if (target.IsValidTarget() && Player.Distance(target) >= 800 && target.Health < RDamage(target) && !Check(target, DamageType.Magical))
                    {
                        if (rpred.HitChance >= HitChance.VeryHigh)
                        {
                            R.Cast(target);
                        }
                    }
                    if (target.IsImmobile() && target.IsValidTarget(E.Range))
                    {
                        var rDamage = RDamage(target);
                        if (E.Ready)
                        {
                            var eDamage = EDamage(target);
                            if (eDamage > target.Health)
                            {
                                return;
                            }
                            rDamage += eDamage;
                        }
                        if (target.IsValidTarget(800))
                        {
                            rDamage += BonusDmg(target);
                        }
                        if (rDamage > target.Health)
                        {
                            R.CastIfWillHit(target, 1);
                            R.Cast(target);
                        }
                    }
                }
            }

            if (R.Ready && (Main["jungSteal"]["keyJR"].As <MenuKeyBind>().Enabled || Main["jungSteal"]["autoJ"].As <MenuBool>().Enabled))
            {
                foreach (var jungSteal in GameObjects.Jungle.Where(x => x.IsValidTarget(R.Range)))
                {
                    if ((jungSteal.UnitSkinName.StartsWith("SRU_Dragon") || jungSteal.UnitSkinName.StartsWith("SRU_Baron") ||
                         jungSteal.UnitSkinName.StartsWith("SRU_RiftHerald") || jungSteal.UnitSkinName.StartsWith("SRU_Blue") ||
                         jungSteal.UnitSkinName.StartsWith("SRU_Red")) && (jungSteal.CountAllyHeroesInRange(1000) == 0 || Main["jungSteal"]["allyJ"].As <MenuBool>().Enabled) && jungSteal.Health < jungSteal.MaxHealth && jungSteal.Distance(Player.Position) > 750)
                    {
                        if (Math.Abs(_jDmg) <= 0)
                        {
                            _jDmg = jungSteal.Health;
                        }

                        if (Game.ClockTime - _jTime > 3)
                        {
                            if (_jDmg - jungSteal.Health > 0)
                            {
                                _jDmg = jungSteal.Health;
                            }
                            _jTime = Game.ClockTime;
                        }
                        else
                        {
                            var damageS = (_jDmg - jungSteal.Health) * (Math.Abs(_jTime - Game.ClockTime) / 3);
                            if (_jDmg - jungSteal.Health > 0)
                            {
                                var timeTravel = R.Delay;
                                var timeR      = (jungSteal.Health - RDamage(jungSteal)) / (damageS / 3);
                                if (timeTravel > timeR)
                                {
                                    R.Cast(jungSteal.Position);
                                }
                            }
                            else
                            {
                                _jDmg = jungSteal.Health;
                            }
                        }
                    }
                }
            }
            if (Main["wProtect"]["enabled"].As <MenuBool>().Enabled)
            {
                AutoProtect();
            }
        }
Example #9
0
        internal virtual void OnGameUpdate()
        {
            if (Program.Player.IsDead || MenuGUI.IsChatOpen())
            {
                return;
            }
            Killsteal();
            SemiR();
            switch (Orbwalker.Implementation.Mode)
            {
            case OrbwalkingMode.None: break;

            case OrbwalkingMode.Combo:
                this.Combo();
                break;

            case OrbwalkingMode.Mixed:
                this.Harass();
                break;

            case OrbwalkingMode.Laneclear:
                this.Farming();
                break;

            case OrbwalkingMode.Lasthit:
                this.LastHit();
                break;

            case OrbwalkingMode.Freeze: break;

            case OrbwalkingMode.Custom: break;
            }
            if (ObjectManager.GetLocalPlayer().ChampionName == "Janna" ||
                ObjectManager.GetLocalPlayer().ChampionName == "Rakan" ||
                ObjectManager.GetLocalPlayer().ChampionName == "Lulu" ||
                ObjectManager.GetLocalPlayer().ChampionName == "Ivern" ||
                ObjectManager.GetLocalPlayer().ChampionName == "Karma")
            {
                bestAllies = GameObjects.AllyHeroes
                             .Where(t =>
                                    t.Distance(ObjectManager.GetLocalPlayer()) < Champion.E.Range)
                             .OrderBy(x => x.Health);
            }
            if (ObjectManager.GetLocalPlayer().ChampionName == "Lux" ||
                ObjectManager.GetLocalPlayer().ChampionName == "Sona" ||
                ObjectManager.GetLocalPlayer().ChampionName == "Taric")

            {
                bestAllies = GameObjects.AllyHeroes
                             .Where(t =>
                                    t.Distance(ObjectManager.GetLocalPlayer()) < Champion.W.Range)
                             .OrderBy(x => x.Health);
            }
            if (bestAllies != null)
            {
                foreach (var t in bestAllies)
                {
                    if (ObjectManager.GetLocalPlayer().ChampionName == "Janna" ||
                        ObjectManager.GetLocalPlayer().ChampionName == "Rakan" ||
                        ObjectManager.GetLocalPlayer().ChampionName == "Lulu" ||
                        ObjectManager.GetLocalPlayer().ChampionName == "Ivern" ||
                        ObjectManager.GetLocalPlayer().ChampionName == "Karma")
                    {
                        if (t != null && EvadeTargetManager.Menu["Brian.EvadeTargetMenu.CC"]
                            .Enabled &&
                            EvadeTargetManager.Menu["whitelist"][t.ChampionName.ToLower()]
                            .As <MenuBool>().Enabled)
                        {
                            if (t.HasBuffOfType(BuffType.Charm) || t.HasBuffOfType(BuffType.Stun) ||
                                t.HasBuffOfType(BuffType.Fear) || t.HasBuffOfType(BuffType.Snare) ||
                                t.HasBuffOfType(BuffType.Taunt) || t.HasBuffOfType(BuffType.Knockback) ||
                                t.HasBuffOfType(BuffType.Suppression))
                            {
                                E.CastOnUnit(t);
                            }
                        }
                    }
                    if (ObjectManager.GetLocalPlayer().ChampionName == "Lux" ||
                        ObjectManager.GetLocalPlayer().ChampionName == "Sona" ||
                        ObjectManager.GetLocalPlayer().ChampionName == "Taric" ||
                        ObjectManager.GetLocalPlayer().ChampionName == "Ivern" ||
                        ObjectManager.GetLocalPlayer().ChampionName == "TahmKench")

                    {
                        if (t != null && EvadeTargetManager.Menu["Brian.EvadeTargetMenu.CC"]
                            .Enabled &&
                            EvadeTargetManager.Menu["whitelist"][t.ChampionName.ToLower()]
                            .As <MenuBool>().Enabled)
                        {
                            if (t.HasBuffOfType(BuffType.Charm) || t.HasBuffOfType(BuffType.Stun) ||
                                t.HasBuffOfType(BuffType.Fear) || t.HasBuffOfType(BuffType.Snare) ||
                                t.HasBuffOfType(BuffType.Taunt) || t.HasBuffOfType(BuffType.Knockback) ||
                                t.HasBuffOfType(BuffType.Suppression))
                            {
                                W.CastOnUnit(t);
                            }
                        }
                    }
                }
                foreach (var t in bestAllies)
                {
                    if (ObjectManager.GetLocalPlayer().ChampionName == "Janna" ||
                        ObjectManager.GetLocalPlayer().ChampionName == "Rakan" ||
                        ObjectManager.GetLocalPlayer().ChampionName == "Ivern" ||
                        ObjectManager.GetLocalPlayer().ChampionName == "Lulu" ||
                        ObjectManager.GetLocalPlayer().ChampionName == "Karma")
                    {
                        if (t != null &&
                            EvadeTargetManager.Menu["whitelist"][t.ChampionName.ToLower()]
                            .As <MenuBool>().Enabled)
                        {
                            if (t.HasBuffOfType(BuffType.Poison))
                            {
                                E.CastOnUnit(t);
                            }
                        }
                    }
                    if (ObjectManager.GetLocalPlayer().ChampionName == "Lux" ||
                        ObjectManager.GetLocalPlayer().ChampionName == "Sona" ||
                        ObjectManager.GetLocalPlayer().ChampionName == "Taric")

                    {
                        if (t != null &&
                            EvadeTargetManager.Menu["whitelist"][t.ChampionName.ToLower()]
                            .As <MenuBool>().Enabled)
                        {
                            if (t.HasBuffOfType(BuffType.Poison))
                            {
                                W.CastOnUnit(t);
                            }
                        }
                    }
                }
            }
        }
Example #10
0
        private static void Game_OnUpdate()
        {
            if (Player.IsDead || MenuGUI.IsChatOpen())
            {
                return;
            }
            switch (Misc.Orbwalker.Mode)
            {
            case OrbwalkingMode.Combo:
                Combo();
                break;

            case OrbwalkingMode.Mixed:
                Harass();
                break;

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

            if (Main["combo"]["qEKey"].As <MenuKeyBind>().Enabled)
            {
                var target = GetBestEnemyHeroTargetInRange(Main["combo"]["qEMax"].As <MenuSlider>().Value);
                if (target != null)
                {
                    if (Player.Distance(target.ServerPosition) > 800 && target.IsValidTarget(Main["combo"]["qEMax"].As <MenuSlider>().Value) && Player.Mana > Player.SpellBook.GetSpell(SpellSlot.Q).Cost + Player.SpellBook.GetSpell(SpellSlot.E).Cost&& E.Ready && Q.Ready && IsEActive)
                    {
                        E.Cast(target.ServerPosition);
                        if (IsQActive)
                        {
                            Q.Cast(target.ServerPosition);
                        }
                    }
                    if (Player.Distance(target.ServerPosition) < 700 && Main["combo"]["qReles"].As <MenuBool>().Enabled&& !IsEActive)
                    {
                        E.Cast();
                    }
                    if (!IsQActive && AurelionSolQMissile != null && target.IsValidTarget(250f, false, false, AurelionSolQMissile.ServerPosition))
                    {
                        Q.Cast();
                        if (!Main["combo"]["qReles"].As <MenuBool>().Enabled&& !IsEActive)
                        {
                            E.Cast();
                        }
                    }
                }
            }
            if (!IsEActive || !IsEActive)
            {
                var target = GetBestEnemyHeroTargetInRange(Main["combo"]["qEMax"].As <MenuSlider>().Value);

                if (Player.Distance(target.ServerPosition) < 700 && Main["combo"]["qReles"].As <MenuBool>().Enabled&& !IsEActive)
                {
                    E.Cast();
                }
                if (!IsQActive && AurelionSolQMissile != null && target.IsValidTarget(250f, false, false, AurelionSolQMissile.ServerPosition))
                {
                    Q.Cast();
                    if (!Main["combo"]["qReles"].As <MenuBool>().Enabled&& !IsEActive)
                    {
                        E.Cast();
                    }
                }
            }

            if (R.Ready && Main["combo"]["rKS"].As <MenuBool>().Enabled)
            {
                foreach (var enemy in GameObjects.EnemyHeroes.Where(x => x.IsValidTarget(R.Range - 100) && !x.IsDead && x.Health < RDamage(x)))
                {
                    var pred = R.GetPrediction(enemy);
                    if (pred.HitChance >= HitChance.High && !Check(enemy, DamageType.Magical) && (!Q.Ready && !IsWActive || Player.Distance(enemy) > 750))
                    {
                        R.Cast(enemy);
                    }
                }
            }
            if (Main["harass"]["autoHarass"].As <MenuBool>().Enabled&& Misc.Orbwalker.Mode != OrbwalkingMode.Mixed)
            {
                Harass();
            }
            if (R.Ready && Main["combo"]["rKey"].As <MenuKeyBind>().Enabled)
            {
                var result = PolygonEnemy.GetLinearLocation(1300, 120);
                if (result?.EnemyHit >= Main["combo"]["rHit"].As <MenuSlider>().Value)
                {
                    R.Cast(result.CastPosition);
                }
            }

            Misc.Orbwalker.MovingEnabled    = IsEActive;
            Misc.Orbwalker.AttackingEnabled = IsEActive;
        }
Example #11
0
        private static void Game_OnUpdate()
        {
            if (Player.IsDead || MenuGUI.IsChatOpen())
            {
                return;
            }
            switch (Misc.Orbwalker.Mode)
            {
            case OrbwalkingMode.Combo:
                Combo();
                break;

            case OrbwalkingMode.Mixed:
                Harass();
                break;

            case OrbwalkingMode.Laneclear:
                LaneClear();
                JungleClear();
                break;
            }
            if (Main["wProtect"]["enabled"].As <MenuBool>().Enabled)
            {
                AutoProtect();
            }
            if (Main["combo"]["rKs"].As <MenuBool>().Enabled&& R.Ready)
            {
                var target = TargetSelector.GetTarget(R.Range - 100);
                if (target != null && target.Health <= RDamage(target) && Player.Distance(target) < 300)
                {
                    R.Cast();
                }
            }
            if (Main["harass"]["autoHarass"].As <MenuBool>().Enabled&& Misc.Orbwalker.Mode != OrbwalkingMode.Combo && Misc.Orbwalker.Mode != OrbwalkingMode.Mixed)
            {
                if (Main["harass"]["q"].As <MenuSliderBool>().Enabled&& Player.ManaPercent() >= Main["harass"]["q"].As <MenuSliderBool>().Value&& Q.Ready)
                {
                    var target = GetBestEnemyHeroTargetInRange(Main["combo"]["QMaximumRange"].As <MenuSlider>().Value);
                    if (target != null)
                    {
                        var pred = Q.GetPrediction(target);

                        if (Main["whiteList"]["qWhiteList" + target.ChampionName.ToLower()].As <MenuBool>().Enabled&&
                            target.IsValidTarget(Main["combo"]["QMaximumRange"].As <MenuSlider>().Value) &&
                            !target.HasBuff("threshQ") && Player.Distance(target.ServerPosition) > Main["combo"]["QMinimumRange"].As <MenuSlider>().Value&& !Check(target, DamageType.Magical))
                        {
                            if (!target.HasBuffOfType(BuffType.SpellImmunity) && !target.HasBuffOfType(BuffType.SpellShield) && GameObjects.EnemyMinions.Count(x => Player.Distance(x.Position) <= 200) == 0)
                            {
                                var collision = Collision.GetCollision(new List <Vector3> {
                                    target.ServerPosition
                                }, Q.GetPredictionInput(target));
                                var col = collision.Count(x => x.IsEnemy && x.IsMinion);
                                if (pred.HitChance >= HitChance.High && col == 0)
                                {
                                    Q.Cast(pred.CastPosition);
                                }
                            }
                        }
                        if (target.HasBuff("threshQ") && Main["combo"]["q2"].As <MenuBool>().Enabled&& !target.IsUnderEnemyTurret())
                        {
                            if (target.Distance(Player.ServerPosition) >= 400)
                            {
                                DelayAction.Queue(1000, () => Q.CastOnUnit(Player));
                            }
                        }
                        if (target.HasBuff("threshQ") && target.IsUnderEnemyTurret() && Main["combo"]["q2Turret"].As <MenuBool>().Enabled)
                        {
                            if (target.Distance(Player.ServerPosition) >= 400)
                            {
                                DelayAction.Queue(1000, () => Q.CastOnUnit(Player));
                            }
                        }
                        if (W.Ready)
                        {
                            var ally = GameObjects.AllyHeroes.Where(x => x.IsInRange(1700) && !x.IsDead && x.IsAlly && !x.IsMe).FirstOrDefault(x => x.Distance(Player.Position) <= 1700);
                            if (ally != null)
                            {
                                if (ally.Distance(Player.ServerPosition) <= 700)
                                {
                                    return;
                                }
                                if (target.HasBuff("threshQ"))
                                {
                                    W.Cast(ally.ServerPosition);
                                }
                            }
                        }
                    }
                }
                if (Main["harass"]["e"].As <MenuSliderBool>().Enabled&& Player.ManaPercent() >= Main["harass"]["e"].As <MenuSliderBool>().Value&& E.Ready)
                {
                    var target = GetBestEnemyHeroTargetInRange(E.Range);
                    if (target == null)
                    {
                        return;
                    }
                    switch (Main["combo"]["ePP"].As <MenuList>().Value)
                    {
                    case 0:
                        if (target.IsInRange(E.Range) && !IsQActive)
                        {
                            E.Cast(target.Position);
                        }
                        break;

                    case 1:
                        if (target.IsInRange(E.Range) && Player.Distance(target) > Main["combo"]["mPull"].As <MenuSlider>().Value&& !IsQActive)
                        {
                            E.Cast(target.Position.Extend(Player.ServerPosition, Vector3.Distance(target.Position, Player.Position) + 400));
                        }
                        break;
                    }
                }
            }

            if (Main["combo"]["qCC"].As <MenuBool>().Enabled || Main["combo"]["qDash"].As <MenuBool>().Enabled)
            {
                var target = GetBestEnemyHeroTargetInRange(Main["combo"]["QMaximumRange"].As <MenuSlider>().Value);
                if (target == null)
                {
                    return;
                }
                var pred = Q.GetPrediction(target);
                if (Main["whiteList"]["qWhiteList" + target.ChampionName.ToLower()].As <MenuBool>().Enabled&&
                    target.IsValidTarget(Main["combo"]["QMaximumRange"].As <MenuSlider>().Value) && !target.HasBuff("threshQ") &&
                    Q.Ready && Player.Distance(target.ServerPosition) > Main["combo"]["QMinimumRange"].As <MenuSlider>().Value&& !Check(target, DamageType.Magical))
                {
                    if (!target.HasBuffOfType(BuffType.SpellImmunity) && !target.HasBuffOfType(BuffType.SpellShield) && GameObjects.EnemyMinions.Count(x => Player.Distance(x.Position) <= 200) == 0)
                    {
                        var collision = Collision.GetCollision(new List <Vector3> {
                            target.ServerPosition
                        }, Q.GetPredictionInput(target));
                        var col = collision.Count(x => x.IsEnemy && x.IsMinion);
                        if (Main["combo"]["qCC"].As <MenuBool>().Enabled&& pred.HitChance == HitChance.Immobile && col == 0 && target.IsImmobile())
                        {
                            Q.Cast(pred.CastPosition);
                        }
                        if (Main["combo"]["qDash"].As <MenuBool>().Enabled&& pred.HitChance == HitChance.Dashing && col == 0)
                        {
                            Q.Cast(pred.CastPosition);
                        }
                    }
                }
                if (target.HasBuff("threshQ") && Main["combo"]["q2"].As <MenuBool>().Enabled&& !target.IsUnderEnemyTurret())
                {
                    if (target.Distance(Player.ServerPosition) >= 400)
                    {
                        DelayAction.Queue(1000, () => Q.CastOnUnit(Player));
                    }
                }
                if (target.HasBuff("threshQ") && target.IsUnderEnemyTurret() && Main["combo"]["q2Turret"].As <MenuBool>().Enabled)
                {
                    if (target.Distance(Player.ServerPosition) >= 400)
                    {
                        DelayAction.Queue(1000, () => Q.CastOnUnit(Player));
                    }
                }
            }
        }