Esempio n. 1
0
        public static void OnUpdate()
        {
            var target = TargetSelector.GetTarget(SpellManager.WCastRange + Global.Player.AttackRange);

            if (target == null || Maths.GetEnergyPercent() < MenuConfig.Harass["Energy"].Value)
            {
                return;
            }

            if (SpellManager.W.Ready && MenuConfig.Harass["W"].Enabled)
            {
                if (ShadowManager.CanCastW1())
                {
                    SpellManager.W.Cast(target.ServerPosition);
                }
                else if (!ShadowManager.CanCastW1() && ShadowManager.CanSwitchToShadow() && MenuConfig.Harass["W2"].Enabled && Global.Player.HealthPercent() >= MenuConfig.Harass["Health"].Value && !target.IsUnderEnemyTurret())
                {
                    SpellManager.W.Cast();
                }
            }

            else if (SpellManager.Q.Ready && MenuConfig.Harass["Q"].Enabled)
            {
                SpellManager.CastQ(target);
            }

            else if (SpellManager.E.Ready && MenuConfig.Harass["E"].Enabled)
            {
                SpellManager.CastE(target);
            }
        }
Esempio n. 2
0
        public static void OnGapcloser(Obj_AI_Hero sender, GapcloserArgs args)
        {
            if (sender.IsMe || !sender.IsEnemy || args.EndPosition.Distance(Global.Player) > SpellManager.E.Range)
            {
                return;
            }

            if (SpellManager.W.Ready && MenuConfig.Misc["W"].Enabled)
            {
                var allyT = GameObjects.AllyTurrets.FirstOrDefault(x => x.IsValid);
                if (allyT != null && ShadowManager.CanCastW1())
                {
                    SpellManager.W.Cast(allyT.ServerPosition);
                }
                else if (ShadowManager.CanSwitchToShadow())
                {
                    SpellManager.W.Cast();
                }
            }

            else if (SpellManager.R.Ready)
            {
                var enemy = GameObjects.EnemyHeroes.OrderBy(x => x.Health).FirstOrDefault(x => x.IsValidTarget(SpellManager.R.Range));
                if (enemy == null)
                {
                    return;
                }

                SpellManager.R.Cast(enemy);
            }
        }
Esempio n. 3
0
        public static void OnKeyPressed()
        {
            Global.Orbwalker.Move(Game.CursorPos);

            if (ShadowManager.CanCastW1())
            {
                SpellManager.W.Cast(Game.CursorPos);
            }
            else
            {
                SpellManager.W.Cast();
            }
        }
Esempio n. 4
0
        public static void OnUpdate()
        {
            var target = TargetSelector.GetTarget(SpellManager.WCastRange + SpellManager.R.Range);

            if (target == null)
            {
                return;
            }

            if (SpellManager.R.Ready && target.IsValidTarget(SpellManager.R.Range) && !(MenuConfig.Combo["Killable"].Enabled && Dmg.Damage(target) < target.Health))
            {
                if (!MenuConfig.Combo[target.ChampionName].Enabled)
                {
                    return;
                }

                SpellManager.CastR(target);
            }

            if (SpellManager.W.Ready && MenuConfig.Combo["W"].Enabled)
            {
                if (ShadowManager.CanCastW1())
                {
                    if (!target.IsValidTarget(SpellManager.R.Range))
                    {
                        SpellManager.W.Cast(target.ServerPosition);
                    }
                    else if (MenuConfig.Combo["Extend"].Enabled)
                    {
                        foreach (var shadow in ShadowManager.Shadows)
                        {
                            SpellManager.W.Cast(target.ServerPosition.Extend(shadow.ServerPosition, -2000f));
                        }
                    }
                }
                else if (ShadowManager.CanSwitchToShadow() && ShadowManager.Shadows.FirstOrDefault().Distance(target) <= Global.Player.Distance(target) && target.Distance(Global.Player) > Global.Player.AttackRange + 65)
                {
                    SpellManager.W.Cast();
                }
            }
            else if (SpellManager.Q.Ready && MenuConfig.Combo["Q"].Enabled)
            {
                SpellManager.CastQ(target);
            }

            if (SpellManager.E.Ready && MenuConfig.Combo["E"].Enabled)
            {
                SpellManager.CastE(target);
            }
        }
Esempio n. 5
0
        public static void OnUpdate()
        {
            if (MenuConfig.LaneClear["Check"].Enabled && Global.Player.CountEnemyHeroesInRange(2000) > 0 ||
                Maths.GetEnergyPercent() < MenuConfig.LaneClear["Energy"].Value)
            {
                return;
            }

            if (_turretTarget != null && _turret != null && MenuConfig.LaneClear["TurretFarm"].Enabled)
            {
                if (_turretTarget.IsDead)
                {
                    _turret       = null;
                    _turretTarget = null;
                }
                else
                {
                    var turretDamage = _turret.GetAutoAttackDamage(_turretTarget);
                    var playerDamage = Global.Player.GetAutoAttackDamage(_turretTarget);
                    var inAaRange    = _turretTarget.Distance(Global.Player) <= Global.Player.AttackRange + 65;

                    if (!inAaRange)
                    {
                        return;
                    }

                    if (_turretTarget.Health < playerDamage * 2 + turretDamage &&
                        _turretTarget.Health > turretDamage + playerDamage && Global.Orbwalker.CanAttack())
                    {
                        Global.Orbwalker.Attack(_turretTarget);
                    }

                    else if (SpellManager.E.Ready && _turretTarget.Health <
                             Global.Player.GetSpellDamage(_turretTarget, SpellSlot.E) + playerDamage)
                    {
                        SpellManager.CastE(_turretTarget);
                    }
                    else if (SpellManager.Q.Ready && _turretTarget.Health <
                             Global.Player.GetSpellDamage(_turretTarget, SpellSlot.Q) + playerDamage)
                    {
                        SpellManager.CastQ(_turretTarget);
                    }
                }
            }
            else
            {
                var minion = GameObjects.EnemyMinions.FirstOrDefault(x => x.IsValidTarget(SpellManager.Q.Range));
                if (minion == null)
                {
                    return;
                }

                if (SpellManager.Q.Ready && MenuConfig.LaneClear["Q"].Enabled)
                {
                    SpellManager.CastQ(minion, MenuConfig.LaneClear["Q"].Value);
                }

                if (SpellManager.W.Ready && MenuConfig.LaneClear["W"].Enabled)
                {
                    if (GameObjects.EnemyMinions.Count(x => x.IsValidTarget(1300)) >= 6 && Global.Player.Level >= 12 && Maths.GetEnergyPercent() >= 70)
                    {
                        if (ShadowManager.CanCastW1())
                        {
                            SpellManager.W.Cast(minion.ServerPosition);
                        }
                        else
                        {
                            SpellManager.W.Cast();
                        }
                    }
                }

                if (SpellManager.E.Ready && MenuConfig.LaneClear["E"].Enabled)
                {
                    SpellManager.CastE(minion, MenuConfig.LaneClear["E"].Value);
                }
            }
        }