示例#1
0
        protected override void LaneClear()
        {
            var min = Menu.Item(Menu.Name + ".lane-clear.min").GetValue <Slider>().Value;

            if (Menu.Item(Menu.Name + ".lane-clear.q").GetValue <bool>() && Q.IsReady() &&
                (ManaManager.Check("lane-clear") || Q.IsCharging))
            {
                var minions = MinionManager.GetMinions(
                    Q.ChargedMaxRange, MinionTypes.All, MinionTeam.NotAlly, MinionOrderTypes.MaxHealth);
                if (Q.IsCharging || minions.Count >= min || minions.Any(m => m.Team == GameObjectTeam.Neutral))
                {
                    if (!Q.IsCharging)
                    {
                        Q.StartCharging();
                        _lastLaneClearQStart = Game.Time;
                    }
                    if (Q.IsCharging && IsFullyCharged())
                    {
                        Casting.Farm(
                            Q, Game.Time - _lastLaneClearQStart > 3 ? 1 : (minions.Count < min ? minions.Count : min),
                            -1f, false, minions);
                    }
                }
            }

            if (Menu.Item(Menu.Name + ".lane-clear.e").GetValue <bool>() && E.IsReady() &&
                ManaManager.Check("lane-clear"))
            {
                Casting.Farm(E, min);
            }
        }
示例#2
0
 protected override void Flee()
 {
     if (Menu.Item(Menu.Name + ".flee.w").GetValue <bool>() && W.IsReady())
     {
         var near =
             GameObjects.EnemyHeroes.Where(e => W.CanCast(e))
             .OrderBy(e => e.Distance(Player.Position))
             .FirstOrDefault();
         if (near != null)
         {
             Casting.SkillShot(near, W, W.GetHitChance("combo"));
         }
     }
     if (Menu.Item(Menu.Name + ".flee.q-upgraded").GetValue <bool>() && Q.IsReady() && IsSpellUpgraded(Q))
     {
         var near =
             GameObjects.EnemyHeroes.Where(e => Q.CanCast(e))
             .OrderBy(e => e.Distance(Player.Position))
             .FirstOrDefault();
         if (near != null)
         {
             Casting.TargetSkill(near, Q);
         }
         else
         {
             var mobs = MinionManager.GetMinions(Q.Range, MinionTypes.All, MinionTeam.NotAlly);
             if (mobs.Any())
             {
                 Casting.TargetSkill(mobs.First(), Q);
             }
         }
     }
 }
示例#3
0
        protected override void LaneClear()
        {
            if (Menu.Item(Menu.Name + ".lane-clear.e").GetValue <bool>() && E.IsReady() &&
                ManaManager.Check("lane-clear-e"))
            {
                var minions = MinionManager.GetMinions(
                    MaxERange * 1.5f, MinionTypes.All, MinionTeam.NotAlly, MinionOrderTypes.MaxHealth);
                var minHits = minions.Any(m => m.Team == GameObjectTeam.Neutral)
                    ? 1
                    : Menu.Item(Menu.Name + ".lane-clear.e-min").GetValue <Slider>().Value;

                if (minions.Count >= minHits)
                {
                    ELogic(null, (minions.Concat(GameObjects.EnemyHeroes)).ToList(), HitChance.High, minHits);
                }
            }
            if (Menu.Item(Menu.Name + ".lane-clear.q").GetValue <bool>() && Q.IsReady() &&
                ManaManager.Check("lane-clear-q"))
            {
                var minion =
                    MinionManager.GetMinions(Q.Range, MinionTypes.All, MinionTeam.NotAlly, MinionOrderTypes.MaxHealth)
                    .FirstOrDefault(m => m.Health <Q.GetDamage(m) || m.Health * 2> Q.GetDamage(m));
                if (minion != null)
                {
                    Casting.TargetSkill(minion, Q);
                }
            }
        }
示例#4
0
 private void OnCorePreUpdate(EventArgs args)
 {
     try
     {
         if ((Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LastHit && ManaManager.Check("lasthit")) &&
             E.IsReady())
         {
             var ePoison = Menu.Item(Menu.Name + ".lasthit.e-poison").GetValue <bool>();
             var eHit    = Menu.Item(Menu.Name + ".lasthit.e").GetValue <bool>();
             if (eHit || ePoison)
             {
                 var m =
                     MinionManager.GetMinions(
                         Player.ServerPosition, E.Range, MinionTypes.All, MinionTeam.NotAlly)
                     .FirstOrDefault(
                         e =>
                         e.Health < E.GetDamage(e) - 5 &&
                         (ePoison && GetPoisonBuffEndTime(e) > E.ArrivalTime(e) || eHit));
                 if (m != null)
                 {
                     Casting.TargetSkill(m, E);
                 }
             }
         }
     }
     catch (Exception ex)
     {
         Global.Logger.AddItem(new LogItem(ex));
     }
 }
示例#5
0
 private bool ShouldWait()
 {
     return
         (MinionManager.GetMinions(Player.Position, float.MaxValue)
          .Any(
              minion =>
              InAutoAttackRange(minion) &&
              HealthPrediction.LaneClearHealthPrediction(
                  minion, (int)((_player.AttackDelay * 1000) * LaneClearWaitTimeMod), FarmDelay) <=
              _player.GetAutoAttackDamage(minion)));
 }
示例#6
0
        private void OnOrbwalkingAfterAttack(AttackableUnit unit, AttackableUnit target)
        {
            try
            {
                if (unit.IsMe && W.IsReady())
                {
                    var useW      = false;
                    var wMin      = 0;
                    var laneclear = false;
                    switch (Orbwalker.ActiveMode)
                    {
                    case Orbwalking.OrbwalkingMode.Combo:
                        useW = Menu.Item(Menu.Name + ".combo.w").GetValue <bool>();
                        break;

                    case Orbwalking.OrbwalkingMode.Mixed:
                        useW = Menu.Item(Menu.Name + ".harass.w").GetValue <bool>();
                        break;

                    case Orbwalking.OrbwalkingMode.LaneClear:
                        useW      = Menu.Item(Menu.Name + ".lane-clear.w").GetValue <bool>();
                        wMin      = Menu.Item(Menu.Name + ".lane-clear.w-min").GetValue <Slider>().Value;
                        laneclear = true;
                        break;
                    }
                    if (useW && (!laneclear || ManaManager.Check("lane-clear-w")))
                    {
                        var range   = W.Range + Player.BoundingRadius * 2f;
                        var targets = laneclear
                            ? MinionManager.GetMinions(
                            range + 450, MinionTypes.All, MinionTeam.NotAlly, MinionOrderTypes.MaxHealth)
                            : GameObjects.EnemyHeroes.Where(e => e.IsValidTarget(range + 450))
                                      .Cast <Obj_AI_Base>()
                                      .ToList();
                        if (targets.Count >= wMin && targets.Any(Orbwalking.InAutoAttackRange) &&
                            (wMin == 0 ||
                             targets.Any(
                                 t =>
                                 Orbwalking.InAutoAttackRange(t) &&
                                 targets.Any(t2 => t2.NetworkId != t.NetworkId && t2.Distance(t) <= 450))))
                        {
                            W.Cast();
                            Orbwalking.ResetAutoAttackTimer();
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Global.Logger.AddItem(new LogItem(ex));
            }
        }
示例#7
0
 private void OnCorePostUpdate(EventArgs args)
 {
     try
     {
         if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LaneClear ||
             Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LastHit)
         {
             if (Cards.Has(CardColor.Red))
             {
                 var range   = Player.AttackRange + Player.BoundingRadius * 1.5f;
                 var minions = MinionManager.GetMinions(range, MinionTypes.All, MinionTeam.NotAlly);
                 var pred    =
                     MinionManager.GetBestCircularFarmLocation(
                         minions.Select(m => m.Position.To2D()).ToList(), 500, range);
                 var target = minions.OrderBy(m => m.Distance(pred.Position)).FirstOrDefault();
                 if (target != null)
                 {
                     Orbwalker.ForceTarget(target);
                 }
             }
         }
         if (!Cards.ShouldWait && Cards.Status != SelectStatus.Selecting && Cards.Status != SelectStatus.Selected)
         {
             Orbwalker.ForceTarget(null);
         }
         if (Cards.Status != SelectStatus.Selected)
         {
             if (Menu.Item(Menu.Name + ".manual.blue").GetValue <KeyBind>().Active)
             {
                 Cards.Select(CardColor.Blue);
             }
             if (Menu.Item(Menu.Name + ".manual.red").GetValue <KeyBind>().Active)
             {
                 Cards.Select(CardColor.Red);
             }
             if (Menu.Item(Menu.Name + ".manual.gold").GetValue <KeyBind>().Active)
             {
                 Cards.Select(CardColor.Gold);
             }
         }
     }
     catch (Exception ex)
     {
         Global.Logger.AddItem(new LogItem(ex));
     }
 }
示例#8
0
        protected override void LaneClear()
        {
            var q    = Menu.Item(Menu.Name + ".lane-clear.q").GetValue <bool>();
            var qMin = Menu.Item(Menu.Name + ".lane-clear.q-min").GetValue <Slider>().Value;
            var w    = Menu.Item(Menu.Name + ".lane-clear.w").GetValue <bool>();

            if (ManaManager.Check("lane-clear") && q && Q.IsReady())
            {
                var minions = MinionManager.GetMinions(
                    Q.Range * 1.2f, MinionTypes.All, MinionTeam.NotAlly, MinionOrderTypes.MaxHealth);
                var m = minions.OrderBy(x => x.Distance(Player)).FirstOrDefault();
                if (m == null)
                {
                    return;
                }
                if (m.Team != GameObjectTeam.Neutral)
                {
                    minions.RemoveAll(x => x.Team == GameObjectTeam.Neutral);
                }
                else
                {
                    qMin = 1;
                }
                var best = BestQPosition(null, minions, HitChance.High);
                if (!best.Item2.Equals(Vector3.Zero) && best.Item1 >= qMin)
                {
                    Q.Cast(best.Item2);
                }
            }
            if (w && W.IsReady())
            {
                var minions = MinionManager.GetMinions(
                    W.Range * 1.2f, MinionTypes.All, MinionTeam.NotAlly, MinionOrderTypes.MaxHealth);
                if (minions.Any())
                {
                    Cards.Select(!ManaManager.Check("lane-clear-blue") ? CardColor.Blue : CardColor.Red);
                }
            }
        }
示例#9
0
            public virtual AttackableUnit GetTarget()
            {
                AttackableUnit result = null;

                if ((ActiveMode == OrbwalkingMode.Mixed || ActiveMode == OrbwalkingMode.LaneClear) &&
                    !_config.Item("PriorizeFarm").GetValue <bool>())
                {
                    var target = TargetSelector.GetTarget(-1, DamageType.Physical);
                    if (target != null)
                    {
                        return(target);
                    }
                }

                /*Killable Minion*/
                if (ActiveMode == OrbwalkingMode.LaneClear || ActiveMode == OrbwalkingMode.Mixed ||
                    ActiveMode == OrbwalkingMode.LastHit)
                {
                    var minionList =
                        MinionManager.GetMinions(Player.Position, float.MaxValue)
                        .Where(
                            minion =>
                            InAutoAttackRange(minion) &&
                            minion.Health <
                            2 *
                            (ObjectManager.Player.BaseAttackDamage + ObjectManager.Player.FlatPhysicalDamageMod))
                        .OrderByDescending(m => m.MaxHealth);

                    foreach (var minion in minionList)
                    {
                        var t = (int)(_player.AttackCastDelay * 1000) - 100 + Game.Ping / 2 +
                                1000 * (int)_player.Distance(minion) / (int)GetMyProjectileSpeed();
                        var predHealth = HealthPrediction.GetHealthPrediction(minion, t, FarmDelay);
                        if (predHealth <= 0)
                        {
                            FireOnNonKillableMinion(minion);
                        }

                        if (predHealth > 0 && predHealth <= _player.GetAutoAttackDamage(minion, true))
                        {
                            return(minion);
                        }
                    }
                }

                //Forced target
                if (_forcedTarget.IsValidTarget() && InAutoAttackRange(_forcedTarget))
                {
                    return(_forcedTarget);
                }

                /* turrets / inhibitors / nexus */
                if (ActiveMode == OrbwalkingMode.LaneClear)
                {
                    /* turrets */
                    foreach (var turret in
                             GameObjects.EnemyTurrets.Where(t => t.IsValidTarget() && InAutoAttackRange(t)))
                    {
                        return(turret);
                    }

                    /* inhibitor */
                    foreach (var turret in
                             GameObjects.EnemyInhibitors.Where(t => t.IsValidTarget() && InAutoAttackRange(t)))
                    {
                        return(turret);
                    }

                    /* nexus */
                    if (GameObjects.EnemyNexus != null && GameObjects.EnemyNexus.IsValidTarget() &&
                        InAutoAttackRange(GameObjects.EnemyNexus))
                    {
                        return(GameObjects.EnemyNexus);
                    }
                }

                /*Champions*/
                if (ActiveMode != OrbwalkingMode.LastHit)
                {
                    var target = TargetSelector.GetTarget(-1, DamageType.Physical);
                    if (target.IsValidTarget())
                    {
                        return(target);
                    }
                }

                /*Jungle minions*/
                if (ActiveMode == OrbwalkingMode.LaneClear || ActiveMode == OrbwalkingMode.Mixed)
                {
                    result =
                        MinionManager.GetMinions(Player.Position, float.MaxValue, MinionTypes.All, MinionTeam.Neutral)
                        .Where(InAutoAttackRange)
                        .MaxOrDefault(mob => mob.MaxHealth);

                    if (result != null)
                    {
                        return(result);
                    }
                }

                /*Lane Clear minions*/
                if (ActiveMode == OrbwalkingMode.LaneClear)
                {
                    if (!ShouldWait())
                    {
                        if (_prevMinion.IsValidTarget() && InAutoAttackRange(_prevMinion))
                        {
                            var predHealth = HealthPrediction.LaneClearHealthPrediction(
                                _prevMinion, (int)((_player.AttackDelay * 1000) * LaneClearWaitTimeMod), FarmDelay);
                            if (predHealth >= 2 * _player.GetAutoAttackDamage(_prevMinion) ||
                                Math.Abs(predHealth - _prevMinion.Health) < float.Epsilon)
                            {
                                return(_prevMinion);
                            }
                        }

                        result = (from minion in
                                  MinionManager.GetMinions(Player.Position, float.MaxValue).Where(InAutoAttackRange)
                                  let predHealth =
                                      HealthPrediction.LaneClearHealthPrediction(
                                          minion, (int)((_player.AttackDelay * 1000) * LaneClearWaitTimeMod), FarmDelay)
                                      where
                                      predHealth >= 2 * _player.GetAutoAttackDamage(minion) ||
                                      Math.Abs(predHealth - minion.Health) < float.Epsilon
                                      select minion).MaxOrDefault(m => m.Health);

                        if (result != null)
                        {
                            _prevMinion = (Obj_AI_Minion)result;
                        }
                    }
                }

                return(result);
            }
示例#10
0
        private void OnCorePostUpdate(EventArgs args)
        {
            try
            {
                if (Menu.Item(Menu.Name + ".ultimate.follow").GetValue <bool>())
                {
                    RFollowLogic();
                }
                if (UltimateManager.Assisted() && R.IsReady())
                {
                    if (Menu.Item(Menu.Name + ".ultimate.assisted.move-cursor").GetValue <bool>())
                    {
                        Orbwalking.MoveTo(Game.CursorPos, Orbwalker.HoldAreaRadius);
                    }
                    var target = TargetSelector.GetTarget(R);
                    if (target != null &&
                        !RLogic(
                            target, Menu.Item(Menu.Name + ".ultimate.assisted.min").GetValue <Slider>().Value,
                            Menu.Item(Menu.Name + ".combo.q").GetValue <bool>() && Q.IsReady(),
                            Menu.Item(Menu.Name + ".combo.e").GetValue <bool>() && E.IsReady()))
                    {
                        if (Menu.Item(Menu.Name + ".ultimate.assisted.duel").GetValue <bool>())
                        {
                            RLogicDuel(
                                Menu.Item(Menu.Name + ".combo.q").GetValue <bool>() && Q.IsReady(),
                                Menu.Item(Menu.Name + ".combo.e").GetValue <bool>() && E.IsReady());
                        }
                    }
                }

                if (UltimateManager.Auto() && R.IsReady())
                {
                    var target = TargetSelector.GetTarget(R);
                    if (target != null &&
                        !RLogic(
                            target, Menu.Item(Menu.Name + ".ultimate.auto.min").GetValue <Slider>().Value,
                            Menu.Item(Menu.Name + ".combo.q").GetValue <bool>() && Q.IsReady(),
                            Menu.Item(Menu.Name + ".combo.e").GetValue <bool>() && E.IsReady(), false, "auto"))
                    {
                        if (Menu.Item(Menu.Name + ".ultimate.auto.duel").GetValue <bool>())
                        {
                            RLogicDuel(
                                Menu.Item(Menu.Name + ".combo.q").GetValue <bool>() && Q.IsReady(),
                                Menu.Item(Menu.Name + ".combo.e").GetValue <bool>() && E.IsReady());
                        }
                    }
                }

                if (HeroListManager.Enabled("w-stunned") && W.IsReady())
                {
                    var target =
                        GameObjects.EnemyHeroes.FirstOrDefault(
                            t => t.IsValidTarget(W.Range) && HeroListManager.Check("w-stunned", t) && Utils.IsStunned(t));
                    if (target != null)
                    {
                        Casting.SkillShot(target, W, W.GetHitChance("combo"));
                    }
                }

                if (HeroListManager.Enabled("w-slowed") && W.IsReady())
                {
                    var target =
                        GameObjects.EnemyHeroes.FirstOrDefault(
                            t =>
                            t.IsValidTarget(W.Range) && HeroListManager.Check("w-slowed", t) &&
                            t.Buffs.Any(b => b.Type == BuffType.Slow && b.EndTime - Game.Time > 0.5f));
                    if (target != null)
                    {
                        Casting.SkillShot(target, W, W.GetHitChance("combo"));
                    }
                }

                if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LastHit ||
                    Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LaneClear)
                {
                    if (Menu.Item(Menu.Name + ".lasthit.q-unkillable").GetValue <bool>() && Q.IsReady() &&
                        ManaManager.Check("lasthit"))
                    {
                        var canAttack = Game.Time >= _lastAutoAttack + Player.AttackDelay;
                        var minions   =
                            MinionManager.GetMinions(Q.Range)
                            .Where(
                                m =>
                                (!canAttack || !Orbwalking.InAutoAttackRange(m)) && m.HealthPercent <= 50 &&
                                (_lastAfterFarmTarget == null || _lastAfterFarmTarget.NetworkId != m.NetworkId) &&
                                (_lastBeforeFarmTarget == null || _lastBeforeFarmTarget.NetworkId != m.NetworkId))
                            .ToList();
                        if (minions.Any())
                        {
                            foreach (var minion in minions)
                            {
                                var health = HealthPrediction.GetHealthPrediction(
                                    minion, (int)(Q.ArrivalTime(minion) * 1000));
                                if (health > 0 && Math.Abs(health - minion.Health) > 10 &&
                                    Q.GetDamage(minion) * 0.85f > health)
                                {
                                    if (Q.CastOnUnit(minion))
                                    {
                                        _lastQKillableTarget = minion;
                                    }
                                    break;
                                }
                            }
                        }
                    }
                }

                Orbwalking.PreventStuttering(HasQBuff());
            }
            catch (Exception ex)
            {
                Global.Logger.AddItem(new LogItem(ex));
            }
        }
示例#11
0
        protected override void LaneClear()
        {
            var q = Menu.Item(Menu.Name + ".lane-clear.q").GetValue <bool>() && Q.IsReady();
            var w = Menu.Item(Menu.Name + ".lane-clear.w").GetValue <bool>() && W.IsReady();

            if (Menu.Item(Menu.Name + ".lane-clear.e").GetValue <bool>() && E.IsReady() &&
                ManaManager.Check("lane-clear") && DelayManager.Check("e-delay", _lastECast))
            {
                var minion =
                    MinionManager.GetMinions(
                        Player.ServerPosition, E.Range, MinionTypes.All, MinionTeam.NotAlly, MinionOrderTypes.MaxHealth)
                    .Where(
                        e =>
                        GetPoisonBuffEndTime(e) > E.ArrivalTime(e) &&
                        (e.Team == GameObjectTeam.Neutral ||
                         (e.Health > E.GetDamage(e) * 2 || e.Health < E.GetDamage(e) - 5)))
                    .OrderByDescending(
                        m => m.CharData.BaseSkinName.Contains("MinionSiege", StringComparison.OrdinalIgnoreCase))
                    .FirstOrDefault();
                if (minion != null)
                {
                    _lastEEndTime = Game.Time + E.ArrivalTime(minion) + 0.1f;
                    _lastECast    = Environment.TickCount;
                    Casting.TargetSkill(minion, E);
                }
            }

            if (q || w)
            {
                var minions =
                    MinionManager.GetMinions(Player.ServerPosition, Q.Range + Q.Width)
                    .Where(e => GetPoisonBuffEndTime(e) < Q.Delay * 1.1)
                    .OrderByDescending(
                        m => m.CharData.BaseSkinName.Contains("MinionSiege", StringComparison.OrdinalIgnoreCase))
                    .ToList();
                if (minions.Any())
                {
                    if (q)
                    {
                        var prediction = Q.GetCircularFarmLocation(minions, Q.Width + 30);
                        if (prediction.MinionsHit > 1 && _lastPoisonClearDelay < Game.Time)
                        {
                            _lastPoisonClearDelay = Game.Time + Q.Delay;
                            Q.Cast(prediction.Position);
                        }
                    }
                    if (w)
                    {
                        var prediction = W.GetCircularFarmLocation(minions, W.Width + 50);
                        if (prediction.MinionsHit > 2 && _lastPoisonClearDelay < Game.Time)
                        {
                            _lastPoisonClearDelay = Game.Time + W.Delay;
                            W.Cast(prediction.Position);
                        }
                    }
                }
                else
                {
                    var creep =
                        MinionManager.GetMinions(
                            Player.ServerPosition, Q.Range + Q.Width, MinionTypes.All, MinionTeam.Neutral,
                            MinionOrderTypes.MaxHealth).FirstOrDefault(e => GetPoisonBuffEndTime(e) < Q.Delay * 1.1);
                    if (creep != null)
                    {
                        if (q)
                        {
                            Q.Cast(creep);
                        }
                        if (w)
                        {
                            W.Cast(creep);
                        }
                    }
                }
            }
        }
示例#12
0
        protected override void LaneClear()
        {
            if (!ManaManager.Check("lane-clear"))
            {
                return;
            }

            var useQ = Menu.Item(Menu.Name + ".lane-clear.q").GetValue <bool>() && Q.IsReady();
            var useE = Menu.Item(Menu.Name + ".lane-clear.e").GetValue <bool>() && E.IsReady();

            if (!useQ && !useE)
            {
                return;
            }

            var minQ1   = Menu.Item(Menu.Name + ".lane-clear.q-min-1").GetValue <Slider>().Value;
            var minQ2   = Menu.Item(Menu.Name + ".lane-clear.q-min-2").GetValue <Slider>().Value;
            var minQ3   = Menu.Item(Menu.Name + ".lane-clear.q-min-3").GetValue <Slider>().Value;
            var minE    = Menu.Item(Menu.Name + ".lane-clear.e-min").GetValue <Slider>().Value;
            var minQ    = 0;
            var minions = MinionManager.GetMinions(
                Q.Range, MinionTypes.All, MinionTeam.NotAlly, MinionOrderTypes.MaxHealth);

            if (minions.Count == 0)
            {
                return;
            }
            if (minions.Count >= 10)
            {
                minQ = minQ3;
            }
            else if (minions.Count <= 7)
            {
                minQ = minQ2;
            }
            else if (minions.Count <= 4)
            {
                minQ = minQ1;
            }
            if (useQ && minions.Count >= minQ && !Player.IsWindingUp && !Player.IsDashing())
            {
                foreach (var minion in minions.Where(x => x.Health <= Q.GetDamage(x)))
                {
                    var killcount = 0;

                    foreach (var colminion in
                             QGetCollisions(Player, Player.ServerPosition.Extend(minion.ServerPosition, Q.Range)))
                    {
                        if (colminion.Health <= Q.GetDamage(colminion))
                        {
                            killcount++;
                        }
                        else
                        {
                            break;
                        }
                    }
                    if (killcount >= minQ)
                    {
                        Q.Cast(minion.ServerPosition);
                        break;
                    }
                }
            }
            if (useE)
            {
                var killable = minions.Where(m => E.IsInRange(m) && Rend.IsKillable(m, false)).ToList();
                if (killable.Count >= minE ||
                    (killable.Count >= 1 && Menu.Item(Menu.Name + ".lane-clear.e-jungle").GetValue <bool>() &&
                     killable.Any(m => m.Team == GameObjectTeam.Neutral)))
                {
                    E.Cast();
                }
            }
        }