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);
}
}
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);
}
}
}
}
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);
}
}
}
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));
}
}
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)));
}
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));
}
}
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));
}
}
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);
}
}
}
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);
}
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));
}
}
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);
}
}
}
}
}
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();
}
}
}