private void LastHitQ(bool auto = false)
{
if (!Q.IsReady())
{
return;
}
if (auto && player.ManaPercent < config.Item("autoQmana", true).GetValue <Slider>().Value)
{
return;
}
if (config.Item("useqLC", true).GetValue <bool>() || config.Item("useqLH", true).GetValue <bool>() || auto)
{
var minions =
MinionManager.GetMinions(Q.Range, MinionTypes.All, MinionTeam.NotAlly)
.Where(
m =>
m.IsValidTarget() && m.Health > 5 && m.Distance(player) < Q.Range &&
m.Health <
Q.GetDamage(m) * config.Item("qLHDamage", true).GetValue <Slider>().Value / 100);
var objAiBases = from minion in minions
let pred =
Q.GetCollision(
player.Position.To2D(),
new List <Vector2>()
{
player.Position.Extend(minion.Position, Q.Range).To2D()
}, 70f)
orderby pred.Count descending
select minion;
if (objAiBases.Any())
{
Obj_AI_Base target = null;
foreach (var minion in
objAiBases.Where(
minion =>
HealthPrediction.GetHealthPrediction(
minion, (int)(minion.Distance(player) / Q.Speed * 1000 + 500f)) > 0))
{
var collision =
Q.GetCollision(
player.Position.To2D(),
new List <Vector2>()
{
player.Position.Extend(minion.Position, Q.Range).To2D()
}, 70f)
.OrderBy(c => c.Distance(player))
.ToList();
if (collision.Count <= 2 || collision[0].NetworkId == minion.NetworkId ||
collision[1].NetworkId == minion.NetworkId)
{
if (collision.Count == 1)
{
Q.Cast(minion, config.Item("packets").GetValue <bool>());
}
else
{
var other = collision.FirstOrDefault(c => c.NetworkId != minion.NetworkId);
if (other != null &&
(player.GetAutoAttackDamage(other) * 2 > other.Health - Q.GetDamage(other)) &&
Q.GetDamage(other) < other.Health)
{
qMiniForWait = other;
qMiniTarget = minion;
if (Orbwalking.CanAttack() &&
other.Distance(player) < Orbwalking.GetRealAutoAttackRange(other))
{
player.IssueOrder(GameObjectOrder.AutoAttack, other);
}
}
else
{
Q.Cast(minion, config.Item("packets").GetValue <bool>());
}
}
}
}
}
}
}
private void Combo(float combodmg)
{
AIHeroClient target = DrawHelper.GetBetterTarget(1100, TargetSelector.DamageType.Magical, true);
if (target == null || target.IsInvulnerable || target.MagicImmune)
{
return;
}
if (config.Item("useItems").GetValue <bool>())
{
ItemHandler.UseItems(target, config, ComboDamage(target));
}
var ignitedmg = (float)player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite);
bool hasIgnite = player.Spellbook.CanUseSpell(player.GetSpellSlot("SummonerDot")) == SpellState.Ready;
if (config.Item("useIgnite", true).GetValue <bool>() &&
ignitedmg > HealthPrediction.GetHealthPrediction(target, 700) && hasIgnite &&
!CombatHelper.CheckCriticalBuffs(target) &&
((savedQ == null ||
(savedQ != null && target.Distance(savedQ.position) < QExplosionRange &&
getQdamage(target) > target.Health)) || useIgnite))
{
player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), target);
}
var rqCombo = R.GetDamage(target) + getQdamage(target) + (hasIgnite ? ignitedmg : 0);
if (Q.CanCast(target) && config.Item("useq", true).GetValue <bool>() && savedQ == null && SimpleQ)
{
if (Program.IsSPrediction)
{
if (Q.SPredictionCast(target, HitChance.High))
{
return;
}
}
else
{
if (Q.CastIfHitchanceEquals(target, HitChance.High))
{
return;
}
}
}
if (Q.IsReady() && config.Item("useq", true).GetValue <bool>() && savedQ != null &&
target.Distance(savedQ.position) < QExplosionRange)
{
DetonateQ();
}
if (config.Item("usee", true).GetValue <bool>())
{
CastE(target);
}
if (W.IsReady() && (!SimpleQ || !Q.IsReady()) && config.Item("usew", true).GetValue <bool>() &&
player.Distance(target) < 300 &&
target.Health > combodmg - getWdamage(target))
{
W.Cast();
}
if (R.IsReady())
{
if (R.CastIfWillHit(target, config.Item("Rmin", true).GetValue <Slider>().Value))
{
return;
}
var logic = config.Item("user", true).GetValue <bool>();
if (config.Item("rtoq", true).GetValue <bool>() && savedQ != null && !SimpleQ &&
(target.Distance(qPos) > QExplosionRange ||
(target.Health < rqCombo && target.Health > getQdamage(target))) &&
target.Distance(player) < R.Range - 100 &&
(target.Health < rqCombo || CheckRPushForAlly(target, rqCombo)) &&
target.Position.Distance(savedQ.position) < 550 + QExplosionRange / 2)
{
var cast = Prediction.GetPrediction(target, 1000f).UnitPosition.Extend(savedQ.position, -200);
if (cast.Distance(player.Position) < R.Range)
{
//Console.WriteLine("R to Q");
if (target.Health < rqCombo && target.Health > rqCombo - ignitedmg &&
player.Distance(target) < 580)
{
useIgnite = true;
}
LeagueSharp.Common.Utility.DelayAction.Add(400, () => useIgnite = false);
HandeR(target, savedQ.position, true);
return;
}
}
if (config.Item("rtoq", true).GetValue <bool>() && logic &&
(target.Health < rqCombo && target.Health > getQdamage(target)))
{
castInsec(target);
}
if (config.Item("rtoally", true).GetValue <bool>() && logic &&
target.Health - rqCombo < target.MaxHealth * 0.5f)
{
var allies =
HeroManager.Allies.Where(
a =>
!a.IsDead && !a.IsMe && a.HealthPercent > 40 && a.Distance(target) < 700 &&
a.Distance(target) > 300).OrderByDescending(a => TargetSelector.GetPriority(a));
if (allies.Any())
{
foreach (var ally in allies)
{
var cast =
Prediction.GetPrediction(target, 1000f)
.UnitPosition.Extend(Prediction.GetPrediction(ally, 400f).UnitPosition, -200);
if (cast.CountEnemiesInRange(1000) <= cast.CountAlliesInRange(1000) &&
cast.Distance(player.Position) < R.Range &&
cast.Extend(target.Position, 500).Distance(ally.Position) <
target.Distance(ally.Position))
{
//Console.WriteLine("R to Ally: " + ally.Name);
HandeR(target, Prediction.GetPrediction(ally, 400f).UnitPosition, false);
return;
}
}
}
var turret =
ObjectManager.Get <Obj_AI_Turret>()
.OrderBy(t => t.Distance(target))
.FirstOrDefault(t => t.Distance(target) < 2000 && t.IsAlly && !t.IsDead);
if (config.Item("rtoturret", true).GetValue <bool>() && turret != null)
{
var pos = target.Position.Extend(turret.Position, -200);
if (target.Distance(turret) > pos.Extend(target.Position, 500).Distance(turret.Position))
{
//nothing
}
else if ((pos.CountEnemiesInRange(1000) < pos.CountAlliesInRange(1000) &&
target.Health - rqCombo < target.MaxHealth * 0.4f) ||
(ObjectManager.Get <Obj_AI_Turret>()
.Count(t => t.Distance(pos) < 950 && t.IsAlly && t.IsValid && !t.IsDead) > 0 &&
target.Health - combodmg < target.MaxHealth * 0.5f))
{
//Console.WriteLine("R to Turret");
HandeR(target, turret.Position, false);
return;
}
}
}
if (config.Item("rtokill", true).GetValue <bool>() && config.Item("user", true).GetValue <bool>() &&
R.GetDamage(target) > target.Health && !justE && !justQ &&
(savedQ == null ||
(savedQ != null && !qPos.IsValid() && target.Distance(savedQ.position) > QExplosionRange)) &&
(target.CountAlliesInRange(700) <= 1 || player.HealthPercent < 35))
{
//Console.WriteLine("R to Kill");
var pred = R.GetPrediction(target, true);
if (pred.Hitchance >= HitChance.VeryHigh)
{
R.Cast(pred.CastPosition);
}
//R.CastIfHitchanceEquals(target, HitChance.VeryHigh);
return;
}
}
}
public static Obj_AI_Base GetPossibleTarget()
{
Obj_AI_Base tempTarget = null;
if (PUC.Menu.Item("orb_Priority").GetValue <StringList>().SelectedIndex == 1 &&
(CurrentMode == Mode.Harass || CurrentMode == Mode.LaneClear))
{
tempTarget = TargetSelector.GetAATarget();
if (tempTarget != null)
{
return(tempTarget);
}
}
if (CurrentMode == Mode.Harass || CurrentMode == Mode.Lasthit || CurrentMode == Mode.LaneClear)
{
foreach (var minion in from minion in ObjectManager.Get <Obj_AI_Minion>().Where(minion => minion.IsValidTarget(GetAutoAttackRangeto(minion)) && minion.Health > 0)
let time = (int)(Player.AttackCastDelay * 1000) + Game.Ping / 2 - 100 +
(int)(1000 * Player.Distance(minion) / (Player.ChampionName == "Thresh" ? Player.BasicAttack.MissileSpeed :(Player.IsMelee() ? float.MaxValue : Player.BasicAttack.MissileSpeed)))
let predHealth = HealthPrediction.GetHealthPrediction(minion, time, GetFarmDelay)
where minion.Team != GameObjectTeam.Neutral &&
predHealth > 0 &&
predHealth <= Player.GetAutoAttackDamage(minion, true)
select minion)
{
return(minion);
}
}
if (CurrentMode == Mode.Harass || CurrentMode == Mode.LaneClear)
{
foreach (var turret in ObjectManager.Get <Obj_AI_Turret>().Where(turret => turret.IsValidTarget(GetAutoAttackRangeto(turret))))
{
return(turret);
}
}
if (CurrentMode != Mode.Lasthit)
{
tempTarget = TargetSelector.GetAATarget();
if (tempTarget != null)
{
return(tempTarget);
}
}
float[] maxhealth;
if (CurrentMode == Mode.LaneClear || CurrentMode == Mode.Harass)
{
maxhealth = new float[] { 0 };
var maxhealth1 = maxhealth;
foreach (var minion in ObjectManager.Get <Obj_AI_Minion>().Where(minion => minion.IsValidTarget(GetAutoAttackRangeto(minion)) && minion.Team == GameObjectTeam.Neutral).Where(minion => minion.MaxHealth >= maxhealth1[0] || Math.Abs(maxhealth1[0] - float.MaxValue) < float.Epsilon))
{
tempTarget = minion;
maxhealth[0] = minion.MaxHealth;
}
if (tempTarget != null)
{
return(tempTarget);
}
}
if (CurrentMode != Mode.LaneClear || ShouldWait())
{
return(null);
}
maxhealth = new float[] { 0 };
foreach (var minion in from minion in ObjectManager.Get <Obj_AI_Minion>()
.Where(minion => minion.IsValidTarget(GetAutoAttackRangeto(minion))) let predHealth = HealthPrediction.LaneClearHealthPrediction(
minion, (int)((Player.AttackDelay * 1000) * LaneClearWaitTimeMod), GetFarmDelay) where predHealth >=
2 *
Player.GetAutoAttackDamage(minion, true) ||
Math.Abs(predHealth - minion.Health) < float.Epsilon where minion.Health >= maxhealth[0] || Math.Abs(maxhealth[0] - float.MaxValue) < float.Epsilon select minion)
{
tempTarget = minion;
maxhealth[0] = minion.MaxHealth;
}
return(tempTarget);
}
private static void LHlogic()
{
List <Obj_AI_Base> allMinions = MinionManager.GetMinions(ObjectManager.Player.ServerPosition, Q.Range);
var vminions = allMinions.Where(
minion =>
minion.IsValidTarget() && Player.Distance(minion) >
Orbwalking.GetRealAutoAttackRange(ObjectManager.Player) && Player.Distance(minion) <= Q.Range &&
HealthPrediction.GetHealthPrediction(minion, (int)((Player.Distance(minion) * 1000) / 1500) + 300 + Game.Ping / 2) <
0.75 * Player.GetSpellDamage(minion, SpellSlot.Q));
if (Config.Item("UseQfarm").GetValue <bool>() && Q.IsReady())
{
var bestminion = vminions.MaxOrDefault(x => x.MaxHealth);
if (bestminion != null)
{
Orbwalker.SetAttack(false);
Q.CastOnUnit(bestminion, false);
Orbwalker.SetAttack(true);
}
}
if (Config.Item("UseEfarm").GetValue <bool>() && E.IsReady() && !Eon)
{
var minions = ObjectManager.Get <Obj_AI_Base>().Where(m => m.IsValidTarget() && m.Team != Player.Team && Player.Distance(m) <= incrange && HealthPrediction.GetHealthPrediction(m, (int)((Player.Distance(m) * 1000) / 1500) + 300 + Game.Ping / 2) <
0.75 * Player.GetAutoAttackDamage(m));
if (minions.Any())
{
E.CastOnUnit(Player);
}
}
//TODO Better Calculations + More Logic for E activation
}
private static void Lasthit()
{
if (!Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.LastHit) || (getCheckBoxItem(performanceMenu, "motion.katarina.performance.tickmanager") && Utils.TickCount < tickValue))
{
return;
}
Obj_AI_Base[] sourroundingMinions;
int tickCount = getSliderItem(performanceMenu, "motion.katarina.performance.ticks");
tickValue = Utils.TickCount + tickCount;
if (getCheckBoxItem(lasthit, "motion.katarina.lasthit.usew") && W.IsReady())
{
sourroundingMinions = MinionManager.GetMinions(Player.Position, 390).Take(3).ToArray();
{
//Only Cast W when minion is not killable with Autoattacks
if (
sourroundingMinions.Any(
minion =>
!minion.IsDead && Orbwalker.LastTarget != minion && (qMinion == null || minion != qMinion) &&
W.GetDamage(minion) > minion.Health &&
HealthPrediction.GetHealthPrediction(minion,
(Player.CanAttack
? Game.Ping / 2
: Orbwalker.LastAutoAttack - Utils.GameTimeTickCount +
(int)Player.AttackDelay * 1000) + 200 + (getCheckBoxItem(performanceMenu, "motion.katarina.performance.tickmanager") ? tickCount - 1 : 0) + (int)Player.AttackCastDelay * 1000) <= 0))
{
W.Cast();
}
}
}
if (getCheckBoxItem(lasthit, "motion.katarina.lasthit.useq") && Q.IsReady())
{
sourroundingMinions = MinionManager.GetMinions(Player.Position, Q.Range).ToArray();
foreach (var minion in sourroundingMinions.Where(minion => !minion.IsDead && Q.GetDamage(minion) > minion.Health))
{
Q.Cast(minion);
qMinion = minion;
break;
}
}
if (getCheckBoxItem(lasthit, "motion.katarina.lasthit.usee") && E.IsReady() && (!getCheckBoxItem(lasthit, "motion.katarina.lasthit.noenemiese") || Player.GetEnemiesInRange(1000).Count == 0))
{
//Same Logic with W + not killable with W
sourroundingMinions = MinionManager.GetMinions(Player.Position, E.Range).Take(getSliderItem(performanceMenu, "motion.katarina.performance.track")).ToArray();
{
foreach (var minions in sourroundingMinions.Where(
minion =>
!minion.IsDead && Orbwalker.LastTarget != minion && (qMinion == null || minion != qMinion) &&
E.GetDamage(minion) >= minion.Health &&
(!W.IsReady() || !getCheckBoxItem(lasthit, "motion.katarina.lasthit.usew") || Player.Position.LSDistance(minion.Position) > 390)
&&
HealthPrediction.GetHealthPrediction(minion,
(Player.CanAttack
? Game.Ping / 2
: Orbwalker.LastAutoAttack - Utils.GameTimeTickCount + (int)Player.AttackDelay * 1000) +
200 + (getCheckBoxItem(performanceMenu, "motion.katarina.performance.tickmanager") ? tickCount - 1 : 0) + (int)Player.AttackCastDelay * 1000) <= 0
&&
!IsTurretPosition(Player.Position.LSExtend(minion.Position,
Player.Position.LSDistance(minion.Position) + 35))))
{
E.Cast(minions);
break;
}
}
}
}
public bool ShouldWait()
{
return(Get <Obj_AI_Minion>().Any(minion => minion.IsValidTarget() && minion.Team != GameObjectTeam.Neutral && InAutoAttackRange(minion) && MinionManager.IsMinion(minion) && HealthPrediction.LaneClearHealthPrediction(minion, (int)(player.AttackDelay * 1000 * LaneClearWaitTimeMod), FarmDelay) <= player.GetAutoAttackDamage(minion)));
}
private static AttackableUnit GetTarget(bool isCombo, bool isFarm, bool isLastHit, int targetMode)
{
AttackableUnit gtarget = null;
if (isCombo)
{
switch (targetMode)
{
case 0:
gtarget = DrawHelper.GetBetterTarget(range, TargetSelector.DamageType.Magical);
break;
case 1:
gtarget =
HeroManager.Enemies.Where(i => player.Distance(i) <= range)
.OrderBy(i => i.Health)
.FirstOrDefault();
break;
case 2:
gtarget =
HeroManager.Enemies.Where(i => player.Distance(i) <= range)
.OrderBy(i => player.Distance(i))
.FirstOrDefault();
break;
default:
break;
}
}
else
{
List <AttackableUnit> otherTarget =
MinionManager.GetMinions(1000, MinionTypes.All, MinionTeam.NotAlly)
.Where(
m =>
HealthPrediction.GetHealthPrediction(m, 2000) > Pet.GetAutoAttackDamage(m) ||
m.Health < Pet.GetAutoAttackDamage(m))
.Select(m => m as AttackableUnit)
.ToList()
.Concat(
ObjectManager.Get <Obj_AI_Turret>()
.Where(t => t.IsValidTarget() && t.Position.Distance(player.Position) < range))
.ToList();
if (isFarm)
{
gtarget =
otherTarget.OrderByDescending(m => Pet.GetAutoAttackDamage((Obj_AI_Base)m) > m.Health)
.ThenByDescending(m => m.MaxHealth)
.ThenByDescending(m => player.Distance(m))
.FirstOrDefault();
}
if (isLastHit)
{
gtarget =
otherTarget.Where(m => Pet.GetAutoAttackDamage((Obj_AI_Base)m) > m.Health)
.OrderByDescending(m => player.Distance(m))
.FirstOrDefault();
}
}
return(gtarget);
}
private static void Drawing_OnDraw(EventArgs args)
{
if (Config.Item("wRange").GetValue <bool>())
{
if (Config.Item("onlyRdy").GetValue <bool>() && W.IsReady())
{
if (Q.IsReady())
{
Render.Circle.DrawCircle(ObjectManager.Player.Position, W.Range, System.Drawing.Color.Cyan);
}
else
{
Render.Circle.DrawCircle(ObjectManager.Player.Position, W.Range, System.Drawing.Color.Cyan);
}
}
}
if (Config.Item("qRange").GetValue <bool>())
{
if (FishBoneActive)
{
Render.Circle.DrawCircle(ObjectManager.Player.Position, 590f + ObjectManager.Player.BoundingRadius, System.Drawing.Color.Orange);
}
else
{
Render.Circle.DrawCircle(ObjectManager.Player.Position, bonusRange() - 40, System.Drawing.Color.Orange);
}
}
if (Config.Item("orb").GetValue <bool>())
{
var orbT = Orbwalker.GetTarget();
if (orbT.IsValidTarget())
{
Render.Circle.DrawCircle(orbT.Position, 100, System.Drawing.Color.Pink);
}
}
if (Config.Item("noti").GetValue <bool>())
{
var t = TargetSelector.GetTarget(R.Range, TargetSelector.DamageType.Physical);
float predictedHealth = HealthPrediction.GetHealthPrediction(t, (int)(R.Delay + (Player.Distance(t.ServerPosition) / R.Speed) * 1000));
if (t.IsValidTarget() && R.IsReady())
{
var rDamage = R.GetDamage(t);
if (rDamage > predictedHealth)
{
Drawing.DrawText(Drawing.Width * 0.1f, Drawing.Height * 0.5f, System.Drawing.Color.Red, "Ult can kill: " + t.ChampionName + " have: " + t.Health + "hp");
Render.Circle.DrawCircle(t.ServerPosition, 200, System.Drawing.Color.Red);
}
if (Config.Item("semi").GetValue <bool>())
{
Render.Circle.DrawCircle(t.Position, 100, System.Drawing.Color.Red);
}
}
var tw = TargetSelector.GetTarget(W.Range, TargetSelector.DamageType.Physical);
if (tw.IsValidTarget())
{
if (Config.Item("wTarget").GetValue <bool>())
{
Render.Circle.DrawCircle(tw.ServerPosition, 100, System.Drawing.Color.Cyan);
}
var wDmg = W.GetDamage(tw);
if (wDmg > tw.Health)
{
Render.Circle.DrawCircle(ObjectManager.Player.ServerPosition, W.Range, System.Drawing.Color.Red);
Render.Circle.DrawCircle(tw.ServerPosition, 200, System.Drawing.Color.Red);
Drawing.DrawText(Drawing.Width * 0.1f, Drawing.Height * 0.4f, System.Drawing.Color.Red, "W can kill: " + t.ChampionName + " have: " + t.Health + "hp");
}
}
}
}
private void Farm()
{
var allMinionsQ = MinionManager.GetMinions(Player.ServerPosition, Q.Range, MinionTypes.All, MinionTeam.NotAlly);
var allMinionsQ2 = MinionManager.GetMinions(Player.ServerPosition, Q2.Range, MinionTypes.All, MinionTeam.NotAlly);
var allMinionsE = MinionManager.GetMinions(Player.ServerPosition, E.Range, MinionTypes.All, MinionTeam.NotAlly);
var useQ = menu.Item("UseQFarm", true).GetValue <bool>();
var useE = menu.Item("UseEFarm", true).GetValue <bool>();
var useQ3 = menu.Item("UseQ3Farm", true).GetValue <bool>();
var min = menu.Item("LaneClear_useQ_minHit", true).GetValue <Slider>().Value;
if (useQ && useE && Q.IsReady() && E.IsReady())
{
foreach (var minion in allMinionsE.Where(CanCastE))
{
var dashVec = Player.ServerPosition + Vector3.Normalize(minion.ServerPosition - Player.ServerPosition) * 475;
var count = MinionManager.GetMinions(dashVec, 300, MinionTypes.All, MinionTeam.NotAlly).Count - 1;
if (!menu.Item("E_UnderTower_Farm", true).GetValue <bool>() && dashVec.UnderTurret(true))
{
continue;
}
if (count >= min)
{
E.CastOnUnit(minion, packets());
Obj_AI_Base minion1 = minion;
Utility.DelayAction.Add(200, () => Q.Cast(minion1.ServerPosition, packets()));
}
}
}
if (useQ && Q.IsReady())
{
if (!ThirdQ())
{
var pred = Q.GetLineFarmLocation(allMinionsQ);
if (pred.MinionsHit >= min)
{
Q.Cast(pred.Position, packets());
}
}
else if (useQ3)
{
var pred = Q.GetLineFarmLocation(allMinionsQ2);
if (pred.MinionsHit >= min)
{
Q.Cast(pred.Position, packets());
}
}
}
if (useE && E.IsReady())
{
foreach (var minion in allMinionsE.Where(CanCastE))
{
var dashVec = Player.ServerPosition + Vector3.Normalize(minion.ServerPosition - Player.ServerPosition) * 475;
if (!menu.Item("E_UnderTower_Farm", true).GetValue <bool>() && dashVec.UnderTurret(true))
{
continue;
}
var predHealth = HealthPrediction.GetHealthPrediction(minion, (int)(Player.Distance(minion) * 1000 / 2000));
if (predHealth <= Player.GetSpellDamage(minion, SpellSlot.E))
{
E.CastOnUnit(minion, packets());
}
}
}
}
private static void Farm(bool laneClear)
{
if (!Config.Item("EnabledFarm").GetValue <bool>())
{
return;
}
var allMinions = MinionManager.GetMinions(ObjectManager.Player.ServerPosition, Q.Range + W.Width,
MinionTypes.All);
var rangedMinions = MinionManager.GetMinions(ObjectManager.Player.ServerPosition, Q.Range + W.Width,
MinionTypes.Ranged);
var useQi = Config.Item("UseQFarm").GetValue <StringList>().SelectedIndex;
var useWi = Config.Item("UseWFarm").GetValue <StringList>().SelectedIndex;
var useEi = Config.Item("UseWFarm").GetValue <StringList>().SelectedIndex;
var useQ = (laneClear && (useQi == 1 || useQi == 2)) || (!laneClear && (useQi == 0 || useQi == 2));
var useW = (laneClear && (useWi == 1 || useWi == 2)) || (!laneClear && (useWi == 0 || useWi == 2));
var useE = (laneClear && (useEi == 1 || useEi == 2)) || (!laneClear && (useEi == 0 || useEi == 2));
if (useQ && QIsReady)
{
if (useW)
{
var qLocation = Q.GetCircularFarmLocation(allMinions, W.Range);
var q2Location = Q.GetCircularFarmLocation(rangedMinions, W.Range);
var bestLocation = (qLocation.MinionsHit > q2Location.MinionsHit + 1) ? qLocation : q2Location;
if (bestLocation.MinionsHit > 0)
{
Q.Cast(bestLocation.Position, true);
return;
}
}
else
{
foreach (var minion in allMinions.FindAll(m => !Orbwalking.InAutoAttackRange(m)))
{
if (HealthPrediction.GetHealthPrediction(minion, Math.Max((int)(minion.ServerPosition.Distance(BallManager.BallPosition) / Q.Speed * 1000) - 100, 0)) < 50)
{
Q.Cast(minion.ServerPosition, true);
return;
}
}
}
}
if (useW && WIsReady)
{
var n = 0;
var d = 0;
foreach (var m in allMinions)
{
if (m.Distance(BallManager.BallPosition) <= W.Range)
{
n++;
if (W.GetDamage(m) > m.Health)
{
d++;
}
}
}
if (n >= 3 || d >= 2)
{
W.Cast(Player.ServerPosition, true);
return;
}
}
if (useE && EIsReady)
{
if (W.CountHits(allMinions, Player.ServerPosition) >= 3)
{
E.CastOnUnit(Player, true);
return;
}
}
}
private static void Game_OnGameUpdate(EventArgs args)
{
ManaMenager();
if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Mixed || Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LaneClear || Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LastHit)
{
Farm = true;
}
else
{
Farm = false;
}
if (E.IsReady() && ObjectManager.Player.Mana > RMANA + EMANA && Config.Item("autoE").GetValue <bool>())
{
if (Config.Item("telE").GetValue <bool>())
{
foreach (var Object in ObjectManager.Get <Obj_AI_Base>().Where(Obj => Obj.Distance(Player.ServerPosition) < E.Range && E.IsReady() && Obj.Team != Player.Team && (Obj.HasBuff("teleport_target", true) || Obj.HasBuff("Pantheon_GrandSkyfall_Jump", true))))
{
E.Cast(Object.Position, true);
}
}
foreach (var enemy in ObjectManager.Get <Obj_AI_Hero>().Where(enemy => enemy.IsValidTarget(E.Range) && E.IsReady()))
{
if (enemy.HasBuff("rocketgrab2"))
{
foreach (var ally in ObjectManager.Get <Obj_AI_Hero>())
{
if (ally.BaseSkinName == "Blitzcrank" && ObjectManager.Player.Distance(ally.Position) < E.Range)
{
E.Cast(ally, true);
}
}
}
else if (enemy.HasBuffOfType(BuffType.Stun) || enemy.HasBuffOfType(BuffType.Snare) ||
enemy.HasBuffOfType(BuffType.Charm) || enemy.HasBuffOfType(BuffType.Fear) ||
enemy.HasBuffOfType(BuffType.Taunt) || enemy.HasBuffOfType(BuffType.Suppression) ||
enemy.IsStunned || enemy.HasBuff("Recall"))
{
E.Cast(enemy, true);
}
else
{
E.CastIfHitchanceEquals(enemy, HitChance.Immobile, true);
}
}
var ta = TargetSelector.GetTarget(E.Range, TargetSelector.DamageType.Physical);
if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo && E.IsReady() && ta.IsValidTarget(E.Range) && Config.Item("comboE").GetValue <bool>() && ObjectManager.Player.Mana > RMANA + EMANA + WMANA && ta.Path.Count() < 2)
{
if (ta.HasBuffOfType(BuffType.Slow) && ta.Path.Count() < 2)
{
E.CastIfHitchanceEquals(ta, HitChance.VeryHigh, true);
}
else if (ta.Path.Count() < 2 && ta.CountEnemiesInRange(250) > 2)
{
E.CastIfHitchanceEquals(ta, HitChance.VeryHigh, true);
}
else if (ObjectManager.Player.Position.Distance(ta.ServerPosition) > ObjectManager.Player.Position.Distance(ta.Position))
{
if (ta.Position.Distance(ObjectManager.Player.ServerPosition) < ta.Position.Distance(ObjectManager.Player.Position) && ta.IsValidTarget(E.Range))
{
castE(ta);
debug("E run");
}
}
else
{
if (ta.Position.Distance(ObjectManager.Player.ServerPosition) > ta.Position.Distance(ObjectManager.Player.Position) && ta.IsValidTarget(E.Range))
{
castE(ta);
debug("E escape");
}
}
}
}
if (Q.IsReady())
{
ManaMenager();
if (Farm && Config.Item("farmQ").GetValue <bool>() && (Game.Time - lag > 0.1) && ObjectManager.Player.Mana > RMANA + WMANA + EMANA + 10 && !FishBoneActive)
{
farmQ();
lag = Game.Time;
}
var t = TargetSelector.GetTarget(bonusRange() + 60, TargetSelector.DamageType.Physical);
if (t.IsValidTarget())
{
var distance = GetRealDistance(t);
var powPowRange = GetRealPowPowRange(t);
if (!FishBoneActive && !Orbwalking.InAutoAttackRange(t))
{
if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo && (ObjectManager.Player.Mana > RMANA + WMANA + 20 || ObjectManager.Player.GetAutoAttackDamage(t) * 2 > t.Health))
{
Q.Cast();
}
else if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Mixed && Orbwalker.GetTarget() == null && ObjectManager.Player.Mana > RMANA + WMANA + EMANA + 20 && distance < bonusRange() + t.BoundingRadius + ObjectManager.Player.BoundingRadius)
{
Q.Cast();
}
else if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LaneClear && !ObjectManager.Player.UnderTurret(true) && ObjectManager.Player.Mana > RMANA + WMANA + EMANA + WMANA + 20 && distance < bonusRange())
{
Q.Cast();
}
}
}
else if (!FishBoneActive && Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo && ObjectManager.Player.Mana > RMANA + WMANA + 20 && ObjectManager.Player.CountEnemiesInRange(2000) > 0)
{
Q.Cast();
}
else if (FishBoneActive && Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo && ObjectManager.Player.Mana < RMANA + WMANA + 20)
{
Q.Cast();
}
else if (FishBoneActive && Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo && ObjectManager.Player.CountEnemiesInRange(2000) == 0)
{
Q.Cast();
}
else if (FishBoneActive && Farm)
{
Q.Cast();
}
}
if (W.IsReady() && (Game.Time - QCastTime > 0.6))
{
ManaMenager();
bool cast = false;
bool wait = false;
foreach (var target in ObjectManager.Get <Obj_AI_Hero>())
{
if (target.IsValidTarget(W.Range) &&
!target.HasBuffOfType(BuffType.PhysicalImmunity) && !target.HasBuffOfType(BuffType.SpellImmunity) && !target.HasBuffOfType(BuffType.SpellShield))
{
float predictedHealth = HealthPrediction.GetHealthPrediction(target, (int)(W.Delay + (Player.Distance(target.ServerPosition) / W.Speed) * 1000));
var Wdmg = W.GetDamage(target);
if (Wdmg > predictedHealth)
{
cast = true;
wait = true;
PredictionOutput output = R.GetPrediction(target);
Vector2 direction = output.CastPosition.To2D() - Player.Position.To2D();
direction.Normalize();
List <Obj_AI_Hero> enemies = ObjectManager.Get <Obj_AI_Hero>().Where(x => x.IsEnemy && x.IsValidTarget()).ToList();
foreach (var enemy in enemies)
{
if (enemy.SkinName == target.SkinName || !cast)
{
continue;
}
PredictionOutput prediction = R.GetPrediction(enemy);
Vector3 predictedPosition = prediction.CastPosition;
Vector3 v = output.CastPosition - Player.ServerPosition;
Vector3 w = predictedPosition - Player.ServerPosition;
double c1 = Vector3.Dot(w, v);
double c2 = Vector3.Dot(v, v);
double b = c1 / c2;
Vector3 pb = Player.ServerPosition + ((float)b * v);
float length = Vector3.Distance(predictedPosition, pb);
if (length < (W.Width + enemy.BoundingRadius) && Player.Distance(predictedPosition) < Player.Distance(target.ServerPosition))
{
cast = false;
}
}
if (!Orbwalking.InAutoAttackRange(target) && cast && target.IsValidTarget(W.Range) && ObjectManager.Player.CountEnemiesInRange(400) == 0 && target.Path.Count() < 2)
{
W.CastIfHitchanceEquals(target, HitChance.VeryHigh, true);
debug("W ks");
}
}
}
}
var t = TargetSelector.GetTarget(W.Range, TargetSelector.DamageType.Physical);
if (t.IsValidTarget() && W.IsReady() && !wait)
{
if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo && ObjectManager.Player.Mana > RMANA + WMANA + 10 && ObjectManager.Player.CountEnemiesInRange(GetRealPowPowRange(t)) == 0)
{
CastSpell(W, t, Config.Item("Hit").GetValue <Slider>().Value);
}
else if ((Farm && ObjectManager.Player.Mana > RMANA + EMANA + WMANA + WMANA + 40) && Config.Item("haras" + t.BaseSkinName).GetValue <bool>() && !ObjectManager.Player.UnderTurret(true) && ObjectManager.Player.CountEnemiesInRange(bonusRange()) == 0)
{
CastSpell(W, t, Config.Item("Hit").GetValue <Slider>().Value);
}
else if ((Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo || Farm) && ObjectManager.Player.Mana > RMANA + WMANA && ObjectManager.Player.CountEnemiesInRange(GetRealPowPowRange(t)) == 0)
{
foreach (var enemy in ObjectManager.Get <Obj_AI_Hero>().Where(enemy => enemy.IsValidTarget(W.Range)))
{
if (enemy.HasBuffOfType(BuffType.Stun) || enemy.HasBuffOfType(BuffType.Snare) ||
enemy.HasBuffOfType(BuffType.Charm) || enemy.HasBuffOfType(BuffType.Fear) ||
enemy.HasBuffOfType(BuffType.Taunt) || enemy.HasBuffOfType(BuffType.Slow) || enemy.HasBuff("Recall"))
{
W.Cast(enemy, true);
}
}
}
}
}
if (R.IsReady())
{
var t = TargetSelector.GetTarget(R.Range, TargetSelector.DamageType.Physical);
if (t.IsValidTarget() && Config.Item("useR").GetValue <KeyBind>().Active)
{
R1.Cast(t, true, true);
}
}
if (R.IsReady() && Config.Item("autoR").GetValue <bool>())
{
bool cast = false;
foreach (var target in ObjectManager.Get <Obj_AI_Hero>())
{
if (target.IsValidTarget() && (Game.Time - WCastTime > 1) && ValidUlt(target))
{
float predictedHealth = HealthPrediction.GetHealthPrediction(target, (int)(R.Delay + (Player.Distance(target.ServerPosition) / R.Speed) * 1000));
var Rdmg = R.GetDamage(target);
if (Rdmg > predictedHealth)
{
cast = true;
PredictionOutput output = R.GetPrediction(target);
Vector2 direction = output.CastPosition.To2D() - Player.Position.To2D();
direction.Normalize();
List <Obj_AI_Hero> enemies = ObjectManager.Get <Obj_AI_Hero>().Where(x => x.IsEnemy && x.IsValidTarget()).ToList();
foreach (var enemy in enemies)
{
if (enemy.SkinName == target.SkinName || !cast)
{
continue;
}
PredictionOutput prediction = R.GetPrediction(enemy);
Vector3 predictedPosition = prediction.CastPosition;
Vector3 v = output.CastPosition - Player.ServerPosition;
Vector3 w = predictedPosition - Player.ServerPosition;
double c1 = Vector3.Dot(w, v);
double c2 = Vector3.Dot(v, v);
double b = c1 / c2;
Vector3 pb = Player.ServerPosition + ((float)b * v);
float length = Vector3.Distance(predictedPosition, pb);
if (length < (R.Width + 150 + enemy.BoundingRadius / 2) && Player.Distance(predictedPosition) < Player.Distance(target.ServerPosition))
{
cast = false;
}
}
if (cast && target.IsValidTarget(R.Range) && GetRealDistance(target) > bonusRange() + 300 + target.BoundingRadius && target.CountAlliesInRange(600) == 0 && ObjectManager.Player.CountEnemiesInRange(400) == 0)
{
castR(target);
debug("R normal High");
}
else if (cast && target.IsValidTarget(R.Range) && target.CountEnemiesInRange(200) > 2 && GetRealDistance(target) > bonusRange() + 200 + target.BoundingRadius)
{
R1.Cast(target, true, true);
debug("R aoe 1");
}
else if (cast && target.HasBuff("Recall"))
{
R.Cast(target, true, true);
debug("R recall");
}
}
}
}
}
PotionMenager();
}
private void Farm()
{
if (!HasMana("LaneClear"))
{
return;
}
var useQ = menu.Item("UseQFarm", true).GetValue <bool>();
var useW = menu.Item("UseWFarm", true).GetValue <bool>();
if (useQ)
{
var allMinions = MinionManager.GetMinions(ObjectManager.Player.Position, Q.Range, MinionTypes.All, MinionTeam.NotAlly);
var minion = allMinions.FirstOrDefault(minionn => minionn.Distance(Player) <= Q.Range && HealthPrediction.LaneClearHealthPrediction(minionn, 500) > 0);
if (minion == null)
{
return;
}
Q.CastOnUnit(minion);
}
if (useW)
{
var allMinionE = MinionManager.GetMinions(Player.ServerPosition, W.Range, MinionTypes.All, MinionTeam.NotAlly);
if (allMinionE.Count > 1)
{
var pred = W.GetCircularFarmLocation(allMinionE);
W.Cast(pred.Position);
}
}
}
private void Farm()
{
if (!ManaManager.HasMana("LaneClear"))
{
return;
}
if (Menu.Item("UseQFarm", true).GetValue <bool>() && Q.IsReady())
{
var min = Menu.Item("QMinHit", true).GetValue <Slider>().Value;
var minionQ = MinionManager.GetMinions(Player.ServerPosition, Q.Range);
var pred = Q.GetCircularFarmLocation(minionQ, 120);
if (pred.MinionsHit >= min)
{
Q.Cast(pred.Position);
}
}
if (Menu.Item("UseWFarm", true).GetValue <bool>() && W.IsReady())
{
var min = Menu.Item("WMinHit", true).GetValue <Slider>().Value;
var minionW = MinionManager.GetMinions(Player.ServerPosition, W.Range);
var pred = W.GetCircularFarmLocation(minionW, 200);
if (pred.MinionsHit >= min)
{
W.Cast(pred.Position);
}
}
if (Menu.Item("UseEFarm", true).GetValue <bool>() && E.IsReady())
{
var mode = Menu.Item("EMode", true).GetValue <StringList>().SelectedIndex;
var minions = MinionManager.GetMinions(Player.ServerPosition, E.Range);
if (minions.Count == 0)
{
return;
}
switch (mode)
{
case 0:
var minion = minions.FirstOrDefault(x => PoisonDuration(x) > E.Delay);
if (minion != null)
{
E.Cast(minion);
}
break;
case 1:
foreach (var x in minions)
{
var healthPred = HealthPrediction.GetHealthPrediction(x, (int)Player.Distance(x),
Game.Ping + 200);
if (healthPred <= Player.GetSpellDamage(x, SpellSlot.E))
{
E.Cast(x);
}
}
break;
case 2:
foreach (var x in minions.Where(x => PoisonDuration(x) > E.Delay))
{
var healthPred = HealthPrediction.GetHealthPrediction(x, (int)Player.Distance(x),
Game.Ping + 200);
if (healthPred <= Player.GetSpellDamage(x, SpellSlot.E))
{
E.Cast(x);
}
}
break;
}
}
}
private void LogicQ()
{
var t = TargetSelector.GetTarget(Q.Range, TargetSelector.DamageType.Magical);
if (t.IsValidTarget() && Config.Item("Qon" + t.ChampionName).GetValue <bool>())
{
if (OktwCommon.GetKsDamage(t, Q) > t.Health)
{
Program.CastSpell(Q, t);
}
if (Program.Combo && Player.Mana > RMANA + QMANA + WMANA)
{
Program.CastSpell(Q, t);
}
if (Program.Farm && Orbwalking.CanAttack() && !Player.IsWindingUp && Config.Item("harrasQ", true).GetValue <bool>() &&
Config.Item("harras" + t.ChampionName).GetValue <bool>() && Player.ManaPercent > Config.Item("QHarassMana", true).GetValue <Slider>().Value)
{
Program.CastSpell(Q, t);
}
foreach (var enemy in Program.Enemies.Where(enemy => enemy.IsValidTarget(Q.Range) && !OktwCommon.CanMove(enemy)))
{
Program.CastSpell(Q, t);
}
}
if (Player.IsWindingUp)
{
return;
}
if (!Program.None && !Program.Combo && Player.Mana > RMANA + QMANA * 2)
{
var allMinions = MinionManager.GetMinions(Player.ServerPosition, Q.Range);
if (Config.Item("farmQout", true).GetValue <bool>())
{
foreach (var minion in allMinions.Where(minion => minion.IsValidTarget(Q.Range) && (!Orbwalker.InAutoAttackRange(minion) || (!minion.UnderTurret(true) && minion.UnderTurret()))))
{
var hpPred = HealthPrediction.GetHealthPrediction(minion, 1100);
if (hpPred < GetQDamage(minion) * 0.9 && hpPred > minion.Health - hpPred * 2)
{
Q.Cast(minion);
return;
}
}
}
if (Program.LaneClear && Config.Item("farmQ", true).GetValue <bool>() && Player.ManaPercent > Config.Item("Mana", true).GetValue <Slider>().Value)
{
foreach (var minion in allMinions.Where(minion => minion.IsValidTarget(Q.Range) && Orbwalker.InAutoAttackRange(minion)))
{
var hpPred = HealthPrediction.GetHealthPrediction(minion, 1100);
if (hpPred < GetQDamage(minion) * 0.9 && hpPred > minion.Health - hpPred * 2)
{
Q.Cast(minion);
return;
}
}
}
if (Program.LaneClear && Player.ManaPercent > Config.Item("Mana", true).GetValue <Slider>().Value&& Config.Item("farmQ", true).GetValue <bool>())
{
var farmPos = Q.GetCircularFarmLocation(allMinions, Q.Width);
if (farmPos.MinionsHit >= Config.Item("QLCminions", true).GetValue <Slider>().Value)
{
Q.Cast(farmPos.Position);
}
}
}
}
private void Game_OnUpdate(EventArgs args)
{
if (!ObjectManager.Player.IsDead)
{
if (Orbwalking.CanMove(100))
{
switch (MenuProvider.Orbwalker.ActiveMode)
{
case Orbwalking.OrbwalkingMode.Combo:
{
if (MenuProvider.Champion.Combo.GetBoolValue("Attack Minion For Chasing"))
{
if (MenuProvider.Orbwalker.GetTarget() == null)
{
if (
!HeroManager.Enemies.Any(
x => x.IsValidTarget() && Orbwalking.InAutoAttackRange(x)))
{
var minion =
MinionManager.GetMinions(Orbwalking.GetRealAutoAttackRange(null) + 65,
MinionTypes.All, MinionTeam.NotAlly)
.Where(x => x.IsValidTarget())
.OrderBy(x => x.Distance(ObjectManager.Player))
.FirstOrDefault();
if (minion != null)
{
Orbwalking.Orbwalk(minion, Game.CursorPos, 0f);
}
}
}
}
if (MenuProvider.Champion.Combo.UseQ)
{
if (_q.IsReadyPerfectly())
{
if (!ObjectManager.Player.IsDashing())
{
if (!ObjectManager.Player.Spellbook.IsAutoAttacking)
{
var target = TargetSelector.GetTargetNoCollision(_q);
if (target != null)
{
if (ObjectManager.Player.Mana - _qManaCost[_q.Level] >= 40)
{
_q.Cast(target);
}
else
{
var killableTarget =
HeroManager.Enemies.FirstOrDefault(
x =>
!Orbwalking.InAutoAttackRange(x) &&
x.IsKillableAndValidTarget(_q.GetDamage(x),
TargetSelector.DamageType.Physical, _q.Range) &&
_q.GetPrediction(x).Hitchance >= _q.MinHitChance);
if (killableTarget != null)
{
_q.Cast(killableTarget);
}
}
}
}
}
}
}
if (MenuProvider.Champion.Combo.UseE)
{
if (_e.IsReadyPerfectly())
{
foreach (var enemy in HeroManager.Enemies.Where(x =>
HealthPrediction.GetHealthPrediction(x, 250) > 0 &&
x.IsKillableAndValidTarget(_e.GetDamage(x) - 30,
TargetSelector.DamageType.Physical, _e.Range)))
{
_e.Cast();
}
}
}
break;
}
case Orbwalking.OrbwalkingMode.Mixed:
{
if (MenuProvider.Champion.Harass.UseQ)
{
if (ObjectManager.Player.IsManaPercentOkay(MenuProvider.Champion.Harass.IfMana))
{
if (!ObjectManager.Player.IsDashing())
{
if (!ObjectManager.Player.Spellbook.IsAutoAttacking)
{
if (_q.IsReadyPerfectly())
{
var target = TargetSelector.GetTargetNoCollision(_q);
if (target != null)
{
_q.Cast(target);
}
}
}
}
}
}
break;
}
case Orbwalking.OrbwalkingMode.LaneClear:
{
//Lane
if (MenuProvider.Champion.Laneclear.UseQ)
{
if (_q.IsReadyPerfectly())
{
if (!ObjectManager.Player.IsDashing())
{
if (!ObjectManager.Player.Spellbook.IsAutoAttacking)
{
if (
ObjectManager.Player.IsManaPercentOkay(
MenuProvider.Champion.Laneclear.IfMana))
{
foreach (
var killableMinion in
MinionManager.GetMinions(_q.Range)
.Where(
x =>
_q.GetPrediction(x).Hitchance >= _q.MinHitChance &&
x.IsKillableAndValidTarget(_q.GetDamage(x),
TargetSelector.DamageType.Physical, _q.Range)))
{
var killableNumber = 0;
var collisionMinions =
Collision.GetCollision(
new List <Vector3>
{
ObjectManager.Player.ServerPosition.Extend(
killableMinion.ServerPosition, _q.Range)
},
new PredictionInput
{
Unit = ObjectManager.Player,
Delay = _q.Delay,
Speed = _q.Speed,
Radius = _q.Width,
Range = _q.Range,
CollisionObjects = new[] { CollisionableObjects.Minions },
UseBoundingRadius = false
}
).OrderBy(x => x.Distance(ObjectManager.Player));
foreach (Obj_AI_Minion collisionMinion in collisionMinions)
{
if (
collisionMinion.IsKillableAndValidTarget(
ObjectManager.Player.GetSpellDamage(collisionMinion,
SpellSlot.Q), TargetSelector.DamageType.Physical,
_q.Range))
{
killableNumber++;
}
else
{
break;
}
}
if (killableNumber >=
MenuProvider.Champion.Laneclear.GetSliderValue(
"Cast Q if Killable Minion Number >=").Value)
{
if (!ObjectManager.Player.Spellbook.IsAutoAttacking)
{
_q.Cast(killableMinion.ServerPosition);
break;
}
}
}
}
}
}
}
}
if (MenuProvider.Champion.Laneclear.UseE)
{
if (_e.IsReadyPerfectly())
{
if (ObjectManager.Player.IsManaPercentOkay(MenuProvider.Champion.Laneclear.IfMana))
{
if (
MinionManager.GetMinions(_e.Range)
.Count(
x =>
HealthPrediction.GetHealthPrediction(x, 250) > 0 &&
x.IsKillableAndValidTarget(_e.GetDamage(x),
TargetSelector.DamageType.Physical)) >=
MenuProvider.Champion.Laneclear.GetSliderValue(
"Cast E if Killable Minion Number >=").Value)
{
_e.Cast();
}
}
}
}
//Jugnle
if (MenuProvider.Champion.Jungleclear.UseQ)
{
if (_q.IsReadyPerfectly())
{
if (ObjectManager.Player.IsManaPercentOkay(MenuProvider.Champion.Jungleclear.IfMana))
{
var qTarget =
MinionManager.GetMinions(_q.Range, MinionTypes.All, MinionTeam.Neutral,
MinionOrderTypes.MaxHealth)
.FirstOrDefault(
x =>
x.IsValidTarget(_q.Range) &&
_q.GetPrediction(x).Hitchance >= HitChance.High);
if (qTarget != null)
{
_q.Cast(qTarget);
}
}
}
}
if (MenuProvider.Champion.Jungleclear.UseE)
{
if (_e.IsReadyPerfectly())
{
if (ObjectManager.Player.IsManaPercentOkay(MenuProvider.Champion.Jungleclear.IfMana))
{
if (
MinionManager.GetMinions(_e.Range, MinionTypes.All, MinionTeam.Neutral,
MinionOrderTypes.MaxHealth)
.Any(
x =>
HealthPrediction.GetHealthPrediction(x, 250) > 0 &&
x.IsKillableAndValidTarget(_e.GetDamage(x),
TargetSelector.DamageType.Physical)))
{
_e.Cast();
}
}
}
}
break;
}
}
}
if (MenuProvider.Champion.Misc.GetBoolValue("Use Killsteal (With E)"))
{
if (_e.IsReadyPerfectly())
{
if (
HeroManager.Enemies.Any(
x =>
HealthPrediction.GetHealthPrediction(x, 250) > 0 &&
x.IsKillableAndValidTarget(_e.GetDamage(x) - 30, TargetSelector.DamageType.Physical,
_e.Range)))
{
_e.Cast();
}
}
}
if (MenuProvider.Champion.Misc.GetBoolValue("Use Mobsteal (With E)"))
{
if (_e.IsReadyPerfectly())
{
if (
MinionManager.GetMinions(_e.Range, MinionTypes.All, MinionTeam.Neutral,
MinionOrderTypes.MaxHealth)
.Any(
x =>
HealthPrediction.GetHealthPrediction(x, 500) > 0 &&
x.IsKillableAndValidTarget(_e.GetDamage(x), TargetSelector.DamageType.Physical)))
{
_e.Cast();
}
}
}
if (MenuProvider.Champion.Misc.GetBoolValue("Auto Steal Siege minion & Super minion (With E)"))
{
if (_e.IsReadyPerfectly())
{
if (
MinionManager.GetMinions(_e.Range)
.Any(
x =>
HealthPrediction.GetHealthPrediction(x, 250) > 0 &&
x.IsKillableAndValidTarget(_e.GetDamage(x), TargetSelector.DamageType.Physical) &&
(x.CharData.BaseSkinName.ToLower().Contains("siege") ||
x.CharData.BaseSkinName.ToLower().Contains("super"))))
{
_e.Cast();
}
}
}
if (MenuProvider.Champion.Misc.GetBoolValue("Auto Balista Combo (With R)"))
{
if (_r.IsReadyPerfectly())
{
var myBlitzcrank =
HeroManager.Allies.FirstOrDefault(
x => !x.IsDead && x.HasBuff("kalistacoopstrikeally") && x.ChampionName == "Blitzcrank");
if (myBlitzcrank != null)
{
var grabTarget =
HeroManager.Enemies.FirstOrDefault(x => !x.IsDead && x.HasBuff("rocketgrab2"));
if (grabTarget != null)
{
if (ObjectManager.Player.Distance(grabTarget) > myBlitzcrank.Distance(grabTarget))
{
_r.Cast();
}
}
}
}
}
if (MenuProvider.Champion.Misc.GetBoolValue("Auto E Harass (With E)"))
{
if (_e.IsReadyPerfectly())
{
if (
!(MenuProvider.Champion.Misc.GetBoolValue("^ Don't do this in ComboMode") &&
MenuProvider.Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo))
{
if (ObjectManager.Player.Mana - _e.ManaCost >= _e.ManaCost)
{
if (HeroManager.Enemies.Any(x => x.IsValidTarget(_e.Range) && _e.GetDamage(x) > 10))
{
if (
MinionManager.GetMinions(_e.Range, MinionTypes.All, MinionTeam.NotAlly)
.Any(
x =>
HealthPrediction.GetHealthPrediction(x, 250) > 0 &&
x.IsKillableAndValidTarget(_e.GetDamage(x),
TargetSelector.DamageType.Physical, _e.Range)))
{
_e.Cast();
}
}
}
}
}
}
if (MenuProvider.Champion.Misc.GetBoolValue("Auto W on Dragon or Baron (With W)"))
{
if (ObjectManager.Player.IsManaPercentOkay(50))
{
if (!ObjectManager.Player.IsRecalling())
{
if (ObjectManager.Player.Position.CountEnemiesInRange(1500f) <= 0)
{
if (MenuProvider.Orbwalker.GetTarget() == null)
{
if (_w.IsReadyPerfectly())
{
if (ObjectManager.Player.Distance(_baronLocation) <= _w.Range)
{
_w.Cast(_baronLocation);
}
}
if (_w.IsReadyPerfectly())
{
if (ObjectManager.Player.Distance(_dragonLocation) <= _w.Range)
{
_w.Cast(_dragonLocation);
}
}
}
}
}
}
}
if (MenuProvider.Champion.Misc.GetKeyBindValue("Cast W on Dragon").Active)
{
if (_w.IsReadyPerfectly())
{
if (ObjectManager.Player.Distance(_dragonLocation) <= _w.Range)
{
_w.Cast(_dragonLocation);
}
}
}
if (MenuProvider.Champion.Misc.GetKeyBindValue("Cast W on Baron").Active)
{
if (_w.IsReadyPerfectly())
{
if (ObjectManager.Player.Distance(_baronLocation) <= _w.Range)
{
_w.Cast(_baronLocation);
}
}
}
}
}
public static AttackableUnit GetPossibleTarget()
{
if (ForcedTarget != null)
{
if (InAutoAttackRange(ForcedTarget))
return ForcedTarget;
ForcedTarget = null;
}
AttackableUnit tempTarget = null;
if (Menu.Item("orb_Misc_Priority_Unit").GetValue<StringList>().SelectedIndex == 1 &&
(CurrentMode == Mode.Harass || CurrentMode == Mode.LaneClear))
{
tempTarget = GetBestHeroTarget();
if (tempTarget != null)
return tempTarget;
}
//last hit
if (CurrentMode == Mode.Harass || CurrentMode == Mode.Lasthit || CurrentMode == Mode.LaneClear || CurrentMode == Mode.LaneFreeze)
{
if (MyHero.ChampionName == "Azir" && Soilders.Count > 0)
{
var minions = MinionManager.GetMinions(ObjectManager.Player.ServerPosition, 800, MinionTypes.All, MinionTeam.NotAlly);
foreach (var minion in from minion in minions.Where(minion => minion.IsValidTarget() && minion.Name != "Beacon" && InSoldierAttackRange(minion))
let t = (int)(MyHero.AttackCastDelay * 1000) - 100 + Game.Ping / 2 + 1000 * (int)MyHero.Distance(minion) / (int)MyProjectileSpeed()
let predHealth = HealthPrediction.GetHealthPrediction(minion, t, FarmDelay())
where minion.Team != GameObjectTeam.Neutral && predHealth > 0 &&
predHealth <= GetAzirAaSandwarriorDamage(minion)
select minion)
return minion;
}
foreach (
var minion in
from minion in
ObjectManager.Get<Obj_AI_Minion>().Where(minion => minion.IsValidTarget() && minion.Name != "Beacon" && InAutoAttackRange(minion))
let t = (int)(MyHero.AttackCastDelay * 1000) - 100 + Game.Ping / 2 +
1000 * (int)MyHero.Distance(minion) / (int)MyProjectileSpeed()
let predHealth = HealthPrediction.GetHealthPrediction(minion, t, FarmDelay())
where minion.Team != GameObjectTeam.Neutral && predHealth > 0 &&
predHealth <= MyHero.GetAutoAttackDamage(minion, true)
select minion)
return minion;
}
if (CurrentMode != Mode.Lasthit)
{
tempTarget = GetBestHeroTarget();
if (tempTarget != null)
return tempTarget;
}
if (CurrentMode == Mode.Harass || CurrentMode == Mode.LaneClear || CurrentMode == Mode.LaneFreeze)
{
foreach (
var turret in
ObjectManager.Get<Obj_AI_Turret>().Where(turret => turret.IsValidTarget(GetAutoAttackRange(MyHero, turret))))
return turret;
}
//jungle
float[] maxhealth;
if (CurrentMode == Mode.LaneClear || CurrentMode == Mode.Harass || CurrentMode == Mode.LaneFreeze)
{
if (MyHero.ChampionName == "Azir" && Soilders.Count > 0)
{
maxhealth = new float[] { 0 };
var maxhealth1 = maxhealth;
var minions = MinionManager.GetMinions(ObjectManager.Player.ServerPosition, 800, MinionTypes.All, MinionTeam.Neutral);
foreach (
var minion in
minions
.Where(minion => InSoldierAttackRange(minion) && minion.Name != "Beacon" && minion.IsValidTarget())
.Where(minion => minion.MaxHealth >= maxhealth1[0] || Math.Abs(maxhealth1[0] - float.MaxValue) < float.Epsilon))
{
tempTarget = minion;
maxhealth[0] = minion.MaxHealth;
}
if (tempTarget != null)
return tempTarget;
}
maxhealth = new float[] { 0 };
var maxhealth2 = maxhealth;
foreach (var minion in ObjectManager.Get<Obj_AI_Minion>().Where(minion => minion.IsValidTarget(GetAutoAttackRange(MyHero, minion)) && minion.Name != "Beacon" && minion.Team == GameObjectTeam.Neutral).Where(minion => minion.MaxHealth >= maxhealth2[0] || Math.Abs(maxhealth2[0] - float.MaxValue) < float.Epsilon))
{
tempTarget = minion;
maxhealth[0] = minion.MaxHealth;
}
if (tempTarget != null)
return tempTarget;
}
//LANE CLEAR
if (CurrentMode != Mode.LaneClear || ShouldWait())
{
//ResetAutoAttackTimer();
return null;
}
if (MyHero.ChampionName == "Azir" && Soilders.Count > 0)
{
maxhealth = new float[] { 0 };
float[] maxhealth1 = maxhealth;
var minions = MinionManager.GetMinions(ObjectManager.Player.ServerPosition, 800, MinionTypes.All, MinionTeam.NotAlly);
foreach (var minion in from minion in minions
.Where(minion => minion.IsValidTarget() && minion.Name != "Beacon" && InSoldierAttackRange(minion))
let predHealth = HealthPrediction.LaneClearHealthPrediction(minion, (int)((MyHero.AttackDelay * 1000) * LaneClearWaitTimeMod), FarmDelay())
where predHealth >=
GetAzirAaSandwarriorDamage(minion) + MyHero.GetAutoAttackDamage(minion, true) ||
Math.Abs(predHealth - minion.Health) < float.Epsilon
where minion.Health >= maxhealth1[0] || Math.Abs(maxhealth1[0] - float.MaxValue) < float.Epsilon
select minion)
{
tempTarget = minion;
maxhealth[0] = minion.MaxHealth;
}
if (tempTarget != null)
return tempTarget;
}
else
{
maxhealth = new float[] { 0 };
foreach (var minion in from minion in ObjectManager.Get<Obj_AI_Minion>()
.Where(minion => minion.IsValidTarget(GetAutoAttackRange(MyHero, minion)) && minion.Name != "Beacon")
let predHealth = HealthPrediction.LaneClearHealthPrediction(minion, (int)((MyHero.AttackDelay * 1000) * LaneClearWaitTimeMod), FarmDelay())
where predHealth >=
2 * MyHero.GetAutoAttackDamage(minion, true) ||
Math.Abs(predHealth - minion.Health) < float.Epsilon
where minion.Health >= maxhealth[0] || Math.Abs(maxhealth[0] - float.MaxValue) < float.Epsilon
select minion)
{
tempTarget = minion;
maxhealth[0] = minion.MaxHealth;
}
if (tempTarget != null)
return tempTarget;
}
return null;
}
private void Game_OnUpdate(EventArgs args)
{
W.MinHitChance = MenuProvider.Champion.Misc.WSelectedHitchance;
if (!ObjectManager.Player.IsDead)
{
if (Orbwalking.CanMove(100))
{
switch (MenuProvider.Orbwalker.ActiveMode)
{
case Orbwalking.OrbwalkingMode.Combo:
{
if (MenuProvider.Champion.Combo.UseQ)
{
if (Q.isReadyPerfectly())
{
if (ObjectManager.Player.CountEnemiesInRange(2000f) > 0)
{
var Target = HeroManager.Enemies.Where(x => x.IsValidTarget(ObjectManager.Player.GetRealAutoAttackRange(x, GetQRange))).OrderByDescending(a => TargetSelector.GetPriority(a)).FirstOrDefault();
if (Target != null)
{
if (Target.CountEnemiesInRange(200) >= MenuProvider.Champion.Combo.getSliderValue("Switch to Rocket If will hit enemy Number >=").Value)
{
QSwitch(true);
}
else
{
QSwitch(!Target.IsValidTarget(ObjectManager.Player.GetRealAutoAttackRange(Target, defaultRange)));
}
}
else
{
QSwitch(true);
}
}
else
{
QSwitch(false);
}
}
}
if (MenuProvider.Champion.Combo.UseW)
{
if (ObjectManager.Player.CountEnemiesInRange(400f) == 0)
{
if (W.isReadyPerfectly())
{
var Target = TargetSelector.GetTargetNoCollision(W);
if (Target.IsValidTarget(W.Range))
{
W.Cast(Target);
}
}
}
}
if (MenuProvider.Champion.Combo.UseE)
{
if (E.isReadyPerfectly())
{
var Target = HeroManager.Enemies.Where(x => x.IsValidTarget(600) && E.GetPrediction(x).Hitchance >= E.MinHitChance && x.IsMoving).OrderBy(x => x.Distance(ObjectManager.Player)).FirstOrDefault();
if (Target != null)
{
E.Cast(Target, false, true);
}
else
{
E.CastWithExtraTrapLogic();
}
}
}
if (MenuProvider.Champion.Combo.UseR)
{
if (R.isReadyPerfectly())
{
if (WCastTime + 1060 <= Environment.TickCount)
{
var Target = HeroManager.Enemies.FirstOrDefault(x => !x.IsZombie && x.CountAlliesInRange(500) < 2 && HealthPrediction.GetHealthPrediction(x, 5000) > 0 && ObjectManager.Player.Distance(x) >= GetQRange && x.isKillableAndValidTarget(GetRDamage(x), TargetSelector.DamageType.Physical, R.Range) && R.GetPrediction(x).Hitchance >= HitChance.High);
if (Target != null)
{
var prediction = R.GetPrediction(Target);
var collision = LeagueSharp.Common.Collision.GetCollision(new System.Collections.Generic.List <SharpDX.Vector3> {
prediction.UnitPosition
}, new PredictionInput {
UseBoundingRadius = true, Unit = ObjectManager.Player, Delay = R.Delay, Speed = R.Speed, Radius = 200, CollisionObjects = new CollisionableObjects[] { CollisionableObjects.Heroes }
}).Any(x => x.NetworkId != Target.NetworkId);
if (!collision)
{
R.Cast(Target);
}
}
}
}
}
break;
}
case Orbwalking.OrbwalkingMode.Mixed:
{
if (MenuProvider.Champion.Harass.UseQ)
{
if (Q.isReadyPerfectly())
{
if (ObjectManager.Player.isManaPercentOkay(MenuProvider.Champion.Harass.IfMana))
{
if (ObjectManager.Player.CountEnemiesInRange(2000f) > 0)
{
var Target = HeroManager.Enemies.Where(x => x.IsValidTarget(ObjectManager.Player.GetRealAutoAttackRange(x, GetQRange))).OrderByDescending(a => TargetSelector.GetPriority(a)).FirstOrDefault();
QSwitch(!Target.IsValidTarget(ObjectManager.Player.GetRealAutoAttackRange(Target, defaultRange)));
}
else
{
QSwitch(false);
}
}
else
{
QSwitch(false);
}
}
}
else
{
QSwitch(false);
}
if (MenuProvider.Champion.Harass.UseW)
{
if (ObjectManager.Player.isManaPercentOkay(MenuProvider.Champion.Harass.IfMana))
{
if (ObjectManager.Player.CountEnemiesInRange(400f) == 0)
{
if (W.isReadyPerfectly())
{
var Target = TargetSelector.GetTargetNoCollision(W);
if (Target.IsValidTarget(W.Range))
{
W.Cast(Target);
}
}
}
}
}
break;
}
case Orbwalking.OrbwalkingMode.LaneClear:
{
if (MenuProvider.Champion.Laneclear.UseQ)
{
if (Q.isReadyPerfectly())
{
if (ObjectManager.Player.isManaPercentOkay(MenuProvider.Champion.Laneclear.IfMana))
{
}
else
{
QSwitch(false);
}
}
}
else
{
QSwitch(false);
}
//Jungleclear
if (MenuProvider.Champion.Jungleclear.UseW)
{
if (ObjectManager.Player.isManaPercentOkay(MenuProvider.Champion.Jungleclear.IfMana))
{
if (W.isReadyPerfectly())
{
var Target = MinionManager.GetMinions(600, MinionTypes.All, MinionTeam.Neutral, MinionOrderTypes.MaxHealth).FirstOrDefault(x => x.IsValidTarget(600) && W.GetPrediction(x).Hitchance >= W.MinHitChance);
if (Target != null)
{
W.Cast(Target);
}
}
}
}
break;
}
case Orbwalking.OrbwalkingMode.LastHit:
{
if (MenuProvider.Champion.Lasthit.UseQ)
{
if (Q.isReadyPerfectly())
{
if (ObjectManager.Player.isManaPercentOkay(MenuProvider.Champion.Lasthit.IfMana))
{
var Target = MinionManager.GetMinions(float.MaxValue).FirstOrDefault(x => x.isKillableAndValidTarget(ObjectManager.Player.GetAutoAttackDamage(x, false) + Q.GetDamage(x), TargetSelector.DamageType.Physical) && x.IsValidTarget(ObjectManager.Player.GetRealAutoAttackRange(x, GetQRange)) && !x.IsValidTarget(ObjectManager.Player.GetRealAutoAttackRange(x, defaultRange)));
if (Target != null)
{
QSwitch(true);
if (Orbwalking.InAutoAttackRange(Target))
{
MenuProvider.Orbwalker.ForceTarget(Target);
}
}
else
{
QSwitch(false);
}
}
else
{
QSwitch(false);
}
}
}
else
{
QSwitch(false);
}
break;
}
}
if (MenuProvider.Champion.Misc.getBoolValue("Auto R on Killable Target"))
{
if (R.isReadyPerfectly())
{
if (WCastTime + 1060 <= Environment.TickCount)
{
var Target = HeroManager.Enemies.FirstOrDefault(x => !x.IsZombie && x.CountAlliesInRange(500) < 2 && HealthPrediction.GetHealthPrediction(x, 5000) > 0 && ObjectManager.Player.Distance(x) >= GetQRange && x.isKillableAndValidTarget(GetRDamage(x), TargetSelector.DamageType.Physical, R.Range) && R.GetPrediction(x).Hitchance >= HitChance.High);
if (Target != null)
{
var prediction = R.GetPrediction(Target);
var collision = LeagueSharp.Common.Collision.GetCollision(new System.Collections.Generic.List <SharpDX.Vector3> {
prediction.UnitPosition
}, new PredictionInput {
Unit = ObjectManager.Player, Delay = R.Delay, Speed = R.Speed, Radius = R.Width, CollisionObjects = new CollisionableObjects[] { CollisionableObjects.Heroes }
}).Any(x => x.NetworkId != Target.NetworkId);
if (!collision)
{
R.Cast(Target);
}
}
}
}
}
if (MenuProvider.Champion.Misc.getBoolValue("Auto E on Immobile Target"))
{
if (E.isReadyPerfectly())
{
var Target = HeroManager.Enemies.FirstOrDefault(x => x.IsValidTarget(E.Range) && x.isImmobileUntil() > 0.5f);
if (Target != null)
{
E.Cast(Target, false, true);
}
}
}
if (MenuProvider.Champion.Harass.AutoHarass)
{
if (!ObjectManager.Player.IsRecalling())
{
if (MenuProvider.Champion.Harass.UseW)
{
if (ObjectManager.Player.isManaPercentOkay(MenuProvider.Champion.Harass.IfMana))
{
var Target = TargetSelector.GetTargetNoCollision(W);
if (Target != null)
{
if (ObjectManager.Player.UnderTurret(true) ? !Target.UnderTurret(true) : true)
{
W.Cast(Target);
}
}
}
}
}
}
}
}
}
public static void HandleRLogic()
{
if (Variables.spells[SpellSlot.R].IsEnabledAndReady())
{
var target = TargetSelector.GetTarget(
Variables.spells[SpellSlot.R].Range * 0.75f, TargetSelector.DamageType.Magical);
if (target.IsValidTarget() && target.Distance(ObjectManager.Player) > 400f)
{
var enemiesAround = target.GetEnemiesInRange(450f);
if (ObjectManager.Player.Distance(target) > JinxUtility.GetFishboneRange() &&
HealthPrediction.GetHealthPrediction(target, 375) > 0 &&
HealthPrediction.GetHealthPrediction(target, 375) + 5 <
Variables.spells[SpellSlot.R].GetDamage(target))
{
//Target is over the minimum distance.
//Check for overkill logics.
//We can kill target with W. Don't use R.
if ((Variables.spells[SpellSlot.W].IsEnabledAndReady() &&
Variables.spells[SpellSlot.W].GetPrediction(target).Hitchance >= HitChance.VeryHigh
? Variables.spells[SpellSlot.W].GetDamage(target)
: 0) > target.Health)
{
return;
}
Variables.spells[SpellSlot.R].CastIfHitchanceEquals(target, HitChance.VeryHigh);
}
else if (ObjectManager.Player.Distance(target) < JinxUtility.GetFishboneRange() &&
HealthPrediction.GetHealthPrediction(target, 375) > 0 &&
HealthPrediction.GetHealthPrediction(target, 375) + 5 <
Variables.spells[SpellSlot.R].GetDamage(target))
{
//Else if the target is in range and we are low health and we can kill them.
//Cast R without prodiction.
if (ObjectManager.Player.HealthPercent < 10 && target.HealthPercent > ObjectManager.Player.HealthPercent + 20)
{
Variables.spells[SpellSlot.R].Cast(target.ServerPosition);
return;
}
//We can kill the target with W (If we can hit it, using prediction) and 5 AA then return.
if (ObjectManager.Player.GetAutoAttackDamage(target) * 5 +
(Variables.spells[SpellSlot.W].IsEnabledAndReady() &&
Variables.spells[SpellSlot.W].GetPrediction(target).Hitchance >= HitChance.VeryHigh
? Variables.spells[SpellSlot.W].GetDamage(target)
: 0) >= target.Health)
{
return;
}
Variables.spells[SpellSlot.R].CastIfHitchanceEquals(target, HitChance.VeryHigh);
}
else if (
enemiesAround.Count(
m => Variables.spells[SpellSlot.R].GetDamage(m) >= target.Health * 0.25f + 5) > 1)
{
//We can do more than 25% health % damage to at least 3 enemies. Go for it lol.
Variables.spells[SpellSlot.R].CastIfHitchanceEquals(target, HitChance.High);
}
}
}
}
public virtual AttackableUnit GetTarget()
{
AttackableUnit result = null;
var mode = ActiveMode;
if ((mode == OrbwalkingMode.Mixed || mode == OrbwalkingMode.LaneClear) && !Menu.Item("PriorizeFarm").GetValue <bool>())
{
var target = TargetSelector.GetTarget(-1, TargetSelector.DamageType.Physical);
if (target != null && InAutoAttackRange(target))
{
return(target);
}
}
var attackGankPlankBarrels = Menu.Item("AttackGPBarrel").GetValue <StringList>().SelectedIndex;
if (attackGankPlankBarrels != 2 && (attackGankPlankBarrels == 0 || (mode == OrbwalkingMode.LaneClear || mode == OrbwalkingMode.Mixed || mode == OrbwalkingMode.LastHit || mode == OrbwalkingMode.Freeze)))
{
var enemyGangPlank = HeroManager.Enemies.FirstOrDefault(e => e.ChampionName.Equals("gangplank", StringComparison.InvariantCultureIgnoreCase));
if (enemyGangPlank != null)
{
var barrels = Get <Obj_AI_Minion>().Where(minion => minion.Team == GameObjectTeam.Neutral && minion.CharData.BaseSkinName == "gangplankbarrel" && minion.IsHPBarRendered && minion.IsValidTarget() && InAutoAttackRange(minion));
var objAiMinions = barrels as Obj_AI_Minion[] ?? barrels.ToArray();
foreach (var barrel in objAiMinions)
{
if (barrel.Health <= 1f)
{
return(barrel);
}
var t = (int)(player.AttackCastDelay * 1000) + Game.Ping / 2 + 1000 * (int)Math.Max(0, player.Distance(barrel) - player.BoundingRadius) / (int)GetMyProjectileSpeed();
var barrelBuff = barrel.Buffs.FirstOrDefault(b => b.Name.Equals("gangplankebarrelactive", StringComparison.InvariantCultureIgnoreCase));
if (barrelBuff != null && barrel.Health <= 2f)
{
var healthDecayRate = enemyGangPlank.Level >= 13 ? 0.5f : (enemyGangPlank.Level >= 7 ? 1f : 2f);
var nextHealthDecayTime = Game.Time < barrelBuff.StartTime + healthDecayRate ? barrelBuff.StartTime + healthDecayRate : barrelBuff.StartTime + healthDecayRate * 2;
if (nextHealthDecayTime <= Game.Time + t / 1000f)
{
return(barrel);
}
}
}
if (objAiMinions.Any())
{
return(null);
}
}
}
if (mode == OrbwalkingMode.LaneClear || mode == OrbwalkingMode.Mixed || mode == OrbwalkingMode.LastHit || mode == OrbwalkingMode.Freeze)
{
var MinionList = Get <Obj_AI_Minion>()
.Where(minion => minion.IsValidTarget() && InAutoAttackRange(minion))
.OrderByDescending(minion => minion.CharData.BaseSkinName.Contains("Siege"))
.ThenBy(minion => minion.CharData.BaseSkinName.Contains("Super"))
.ThenBy(minion => minion.Health)
.ThenByDescending(minion => minion.MaxHealth);
foreach (var minion in MinionList)
{
var t = (int)(player.AttackCastDelay * 1000) - 100 + Game.Ping / 2 + 1000 * (int)Math.Max(0, player.Distance(minion) - player.BoundingRadius) / (int)GetMyProjectileSpeed();
if (mode == OrbwalkingMode.Freeze)
{
t += 200 + Game.Ping / 2;
}
var predHealth = HealthPrediction.GetHealthPrediction(minion, t, FarmDelay);
if (minion.Team != GameObjectTeam.Neutral && ShouldAttackMinion(minion))
{
var damage = player.GetAutoAttackDamage(minion, true);
var killable = predHealth <= damage;
if (mode == OrbwalkingMode.Freeze)
{
if (minion.Health < 50 || predHealth <= 50)
{
return(minion);
}
}
else
{
if (predHealth <= 0)
{
FireOnNonKillableMinion(minion);
}
if (killable)
{
return(minion);
}
}
}
}
}
if (_forcedTarget.IsValidTarget() && InAutoAttackRange(_forcedTarget))
{
return(_forcedTarget);
}
if (mode == OrbwalkingMode.LaneClear && (!Menu.Item("FocusMinionsOverTurrets").GetValue <KeyBind>().Active || !MinionManager.GetMinions(ObjectManager.Player.Position, GetRealAutoAttackRange(ObjectManager.Player)).Any()))
{
foreach (var turret in Get <Obj_AI_Turret>().Where(t => t.IsValidTarget() && InAutoAttackRange(t)))
{
return(turret);
}
foreach (var turret in Get <Obj_BarracksDampener>().Where(t => t.IsValidTarget() && InAutoAttackRange(t)))
{
return(turret);
}
foreach (var nexus in Get <Obj_HQ>().Where(t => t.IsValidTarget() && InAutoAttackRange(t)))
{
return(nexus);
}
}
if (mode != OrbwalkingMode.LastHit)
{
if (mode != OrbwalkingMode.LaneClear || !ShouldWait())
{
var target = TargetSelector.GetTarget(-1, TargetSelector.DamageType.Physical);
if (target.IsValidTarget() && InAutoAttackRange(target))
{
return(target);
}
}
}
if (mode == OrbwalkingMode.LaneClear || mode == OrbwalkingMode.Mixed)
{
var jminions = Get <Obj_AI_Minion>().Where(mob => mob.IsValidTarget() && mob.Team == GameObjectTeam.Neutral && InAutoAttackRange(mob) && mob.CharData.BaseSkinName != "gangplankbarrel" && mob.Name != "WardCorpse");
result = Menu.Item("Smallminionsprio").GetValue <bool>() ? jminions.MinOrDefault(mob => mob.MaxHealth) : jminions.MaxOrDefault(mob => mob.MaxHealth);
if (result != null)
{
return(result);
}
}
if (mode == OrbwalkingMode.LaneClear || mode == OrbwalkingMode.Mixed || mode == OrbwalkingMode.LastHit || mode == OrbwalkingMode.Freeze)
{
var closestTower = Get <Obj_AI_Turret>().MinOrDefault(t => t.IsAlly && !t.IsDead ? player.Distance(t, true) : float.MaxValue);
if (closestTower != null && player.Distance(closestTower, true) < 1500 * 1500)
{
Obj_AI_Minion farmUnderTurretMinion = null;
Obj_AI_Minion noneKillableMinion = null;
var minions = MinionManager.GetMinions(player.Position, player.AttackRange + 200)
.Where(minion => InAutoAttackRange(minion) && closestTower.Distance(minion, true) < 900 * 900)
.OrderByDescending(minion => minion.CharData.BaseSkinName.Contains("Siege"))
.ThenBy(minion => minion.CharData.BaseSkinName.Contains("Super"))
.ThenByDescending(minion => minion.MaxHealth)
.ThenByDescending(minion => minion.Health);
if (minions.Any())
{
var turretMinion = minions.FirstOrDefault(minion => minion is Obj_AI_Minion && HealthPrediction.HasTurretAggro((Obj_AI_Minion)minion));
if (turretMinion != null)
{
var hpLeftBeforeDie = 0;
var hpLeft = 0;
var turretAttackCount = 0;
var turretStarTick = HealthPrediction.TurretAggroStartTick(turretMinion as Obj_AI_Minion);
var turretLandTick = turretStarTick + (int)(closestTower.AttackCastDelay * 1000) + 1000 * Math.Max(0, (int)(turretMinion.Distance(closestTower) - closestTower.BoundingRadius)) / (int)(closestTower.BasicAttack.MissileSpeed + 70);
for (float i = turretLandTick + 50; i < turretLandTick + 10 * closestTower.AttackDelay * 1000 + 50; i = i + closestTower.AttackDelay * 1000)
{
var time = (int)i - Utils.GameTimeTickCount + Game.Ping / 2;
var predHP = (int)HealthPrediction.LaneClearHealthPrediction(turretMinion, time > 0 ? time : 0);
if (predHP > 0)
{
hpLeft = predHP;
turretAttackCount += 1;
continue;
}
hpLeftBeforeDie = hpLeft;
hpLeft = 0;
break;
}
if (hpLeft == 0 && turretAttackCount != 0 && hpLeftBeforeDie != 0)
{
var damage = (int)player.GetAutoAttackDamage(turretMinion, true);
var hits = hpLeftBeforeDie / damage;
var timeBeforeDie = turretLandTick + (turretAttackCount + 1) * (int)(closestTower.AttackDelay * 1000) - Utils.GameTimeTickCount;
var timeUntilAttackReady = LastAATick + (int)(player.AttackDelay * 1000) > Utils.GameTimeTickCount + Game.Ping / 2 + 25 ? LastAATick + (int)(player.AttackDelay * 1000) - (Utils.GameTimeTickCount + Game.Ping / 2 + 25) : 0;
var timeToLandAttack = player.IsMelee ? player.AttackCastDelay * 1000 : player.AttackCastDelay * 1000 + 1000 * Math.Max(0, turretMinion.Distance(player) - player.BoundingRadius) / player.BasicAttack.MissileSpeed;
if (hits >= 1 && hits * player.AttackDelay * 1000 + timeUntilAttackReady + timeToLandAttack < timeBeforeDie)
{
farmUnderTurretMinion = turretMinion as Obj_AI_Minion;
}
else if (hits >= 1 && hits * player.AttackDelay * 1000 + timeUntilAttackReady + timeToLandAttack > timeBeforeDie)
{
noneKillableMinion = turretMinion as Obj_AI_Minion;
}
}
else if (hpLeft == 0 && turretAttackCount == 0 && hpLeftBeforeDie == 0)
{
noneKillableMinion = turretMinion as Obj_AI_Minion;
}
if (ShouldWaitUnderTurret(noneKillableMinion))
{
return(null);
}
if (farmUnderTurretMinion != null)
{
return(farmUnderTurretMinion);
}
foreach (var minion in minions.Where(x => x.NetworkId != turretMinion.NetworkId && x is Obj_AI_Minion && !HealthPrediction.HasMinionAggro((Obj_AI_Minion)x)))
{
var playerDamage = (int)player.GetAutoAttackDamage(minion);
var turretDamage = (int)closestTower.GetAutoAttackDamage(minion, true);
var leftHP = (int)minion.Health % turretDamage;
if (leftHP > playerDamage)
{
return(minion);
}
}
var lastminion = minions.LastOrDefault(x => x.NetworkId != turretMinion.NetworkId && x is Obj_AI_Minion && !HealthPrediction.HasMinionAggro((Obj_AI_Minion)x));
if (lastminion != null && minions.Count() >= 2)
{
if (1f / player.AttackDelay >= 1f && (int)(turretAttackCount * closestTower.AttackDelay / player.AttackDelay) * player.GetAutoAttackDamage(lastminion) > lastminion.Health)
{
return(lastminion);
}
if (minions.Count() >= 5 && 1f / player.AttackDelay >= 1.2)
{
return(lastminion);
}
}
}
else
{
if (ShouldWaitUnderTurret(noneKillableMinion))
{
return(null);
}
foreach (
var minion in
minions.Where(
x =>
x is Obj_AI_Minion &&
!HealthPrediction.HasMinionAggro((Obj_AI_Minion)x)))
{
{
var playerDamage = (int)player.GetAutoAttackDamage(minion);
var turretDamage = (int)closestTower.GetAutoAttackDamage(minion, true);
var leftHP = (int)minion.Health % turretDamage;
if (leftHP > playerDamage)
{
return(minion);
}
}
}
var lastminion =
minions.LastOrDefault(
x =>
x is Obj_AI_Minion &&
!HealthPrediction.HasMinionAggro((Obj_AI_Minion)x));
if (lastminion == null || minions.Count() < 2)
{
return(null);
}
if (minions.Count() >= 5 && 1f / player.AttackDelay >= 1.2)
{
return(lastminion);
}
}
return(null);
}
}
}
if (mode == 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 = Get <Obj_AI_Minion>()
.Where(
minion =>
minion.IsValidTarget() && InAutoAttackRange(minion) && ShouldAttackMinion(minion))
.Select(
minion =>
new
{
minion,
predHealth =
HealthPrediction.LaneClearHealthPrediction(minion,
(int)(player.AttackDelay * 1000 * LaneClearWaitTimeMod), FarmDelay)
})
.Where(
t =>
t.predHealth >= 2 * player.GetAutoAttackDamage(t.minion) ||
Math.Abs(t.predHealth - t.minion.Health) < float.Epsilon)
.Select(t => t.minion).MaxOrDefault(m => !MinionManager.IsMinion(m, true) ? float.MaxValue : m.Health);
if (result != null)
{
_prevMinion = (Obj_AI_Minion)result;
}
}
}
return(result);
}
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);
}
/// <summary>
/// Last hits jungle mobs with a spell.
/// </summary>
private static void JungleKillSteal()
{
if (!R.IsReady())
{
return;
}
var stealBlue = getCheckBoxItem(jungleKsMenu, "StealBlueBuff");
var stealRed = getCheckBoxItem(jungleKsMenu, "StealRedBuff");
var stealDragon = getCheckBoxItem(jungleKsMenu, "StealDragon");
var stealBaron = getCheckBoxItem(jungleKsMenu, "StealBaron");
var stealBuffMode = getBoxItem(jungleKsMenu, "StealBuffMode");
if (stealBaron)
{
var baron =
ObjectManager.Get <Obj_AI_Minion>().FirstOrDefault(x => x.CharData.BaseSkinName.Equals("SRU_Baron") && x.IsHPBarRendered && x.IsVisible);
if (baron != null)
{
var healthPred = HealthPrediction.GetHealthPrediction(baron, (int)(R.Delay * 1000) + Game.Ping / 2);
if (R.GetDamage(baron) >= healthPred)
{
R.Cast(baron);
}
}
}
if (stealDragon)
{
var dragon =
ObjectManager.Get <Obj_AI_Minion>().FirstOrDefault(x => x.CharData.BaseSkinName.Equals("SRU_Dragon") && x.IsHPBarRendered && x.IsVisible);
if (dragon != null)
{
var healthPred = HealthPrediction.GetHealthPrediction(dragon, (int)(R.Delay * 1000) + Game.Ping / 2);
if (R.GetDamage(dragon) >= healthPred)
{
R.Cast(dragon);
}
}
}
if (stealBlue)
{
var blueBuffs =
ObjectManager.Get <Obj_AI_Minion>().Where(x => x.CharData.BaseSkinName.Equals("SRU_Blue") && x.IsHPBarRendered && x.IsVisible).ToList();
if (blueBuffs.Any())
{
var blueBuff =
blueBuffs.Where(
x =>
R.GetDamage(x)
> HealthPrediction.GetHealthPrediction(x, (int)(R.Delay * 1000) + Game.Ping / 2))
.FirstOrDefault(
x =>
(x.CountAlliesInRange(1000) == 0 && stealBuffMode == 0) ||
(x.CountAlliesInRange(1000) > 0 && stealBuffMode == 2) || stealBuffMode == 3);
if (blueBuff != null)
{
R.Cast(blueBuff);
}
}
}
if (!stealRed)
{
return;
}
var redBuffs =
ObjectManager.Get <Obj_AI_Minion>().Where(x => x.CharData.BaseSkinName.Equals("SRU_Red") && x.IsHPBarRendered && x.IsVisible).ToList();
if (!redBuffs.Any())
{
return;
}
var redBuff =
redBuffs.Where(
x => R.GetDamage(x) > HealthPrediction.GetHealthPrediction(x, (int)(R.Delay * 1000) + Game.Ping / 2))
.FirstOrDefault(
x =>
(x.CountAlliesInRange(1000) == 0 && stealBuffMode == 0) ||
(x.CountAlliesInRange(1000) > 0 && stealBuffMode == 2) || stealBuffMode == 3);
if (redBuff != null)
{
R.Cast(redBuff);
}
}
private void Cast_Q(bool mode)
{
if (!Q.IsReady() || !_canUseSpells)
{
return;
}
if (mode)
{
var target = SimpleTs.GetTarget(Q.Range, SimpleTs.DamageType.Physical);
if (target != null)
{
if ((target.IsValidTarget(Q.Range)))
{
Q.Cast(target, UsePackets());
UsedSkill();
return;
}
}
target = SimpleTs.GetTarget(Q2.Range, SimpleTs.DamageType.Physical);
if (target == null)
{
return;
}
if ((!target.IsValidTarget(Q2.Range)) || !_canUseSpells || !Q.IsReady())
{
return;
}
var qCollision = Q2.GetPrediction(target).CollisionObjects;
foreach (var qCollisionChar in qCollision.Where(qCollisionChar => qCollisionChar.IsValidTarget(Q.Range)))
{
Q.Cast(qCollisionChar, UsePackets());
UsedSkill();
}
}
else
{
var allMinions = MinionManager.GetMinions(ObjectManager.Player.Position, Q.Range, MinionTypes.All, MinionTeam.NotAlly);
var minion = allMinions.FirstOrDefault(minionn => minionn.Distance(MyHero) <= Q.Range && HealthPrediction.LaneClearHealthPrediction(minionn, 500) > 0);
if (minion == null)
{
return;
}
_passivTimer = Environment.TickCount;
Q.CastOnUnit(minion, UsePackets());
}
}
/// <summary>
/// The method, which handles the Harass process.
/// </summary>
private static void Harass()
{
Obj_AI_Base seltarget = Utilities.targetSelector.GetSelectedTarget();
if (Utilities.MainMenu["Q"]["HarassQ"])
{
if (seltarget == null)
{
var target = Utilities.targetSelector.GetTargetNoCollision(Utilities.Q);
if (target.IsValidTarget(Utilities.Q.Range) && !target.IsDead && target.IsValid)
{
var prediction = Utilities.Q.GetPrediction(target).CastPosition;
Core.CastQ(target, prediction);
}
}
else
{
if (seltarget.IsValidTarget(Utilities.Q.Range) && !seltarget.IsDead && seltarget.IsValid)
{
var prediction = Utilities.Q.GetPrediction(seltarget, true, Utilities.Q.Range).CastPosition;
Core.CastQ(seltarget, prediction);
}
else
{
var target = Utilities.targetSelector.GetTargetNoCollision(Utilities.Q);
if (target.IsValidTarget(Utilities.Q.Range) && !target.IsDead && target.IsValid)
{
var prediction = Utilities.Q.GetPrediction(seltarget, true, Utilities.Q.Range).CastPosition;
Core.CastQ(target, prediction);
}
}
}
}
if (Utilities.MainMenu["W"]["HarassW"])
{
if (seltarget == null)
{
var target = Utilities.targetSelector.GetTargetNoCollision(Utilities.W);
if (target.IsValidTarget(Utilities.W.Range) && !target.IsDead && target.IsValid)
{
Core.CastW(target);
}
}
else
{
if (seltarget.IsValidTarget(Utilities.W.Range) && !seltarget.IsDead && seltarget.IsValid)
{
Core.CastW(seltarget);
}
else
{
var target = Utilities.targetSelector.GetTargetNoCollision(Utilities.W);
if (target.IsValidTarget(Utilities.W.Range) && !target.IsDead && target.IsValid)
{
Core.CastW(target);
}
}
}
}
if (Utilities.MainMenu["E"]["HarassE"])
{
EState(OrbwalkingMode.Combo);
}
if (!Utilities.MainMenu["Q"]["HarassQ"])
{
return;
}
// get all minions with costum equalations
var allMinions = GameObjects.EnemyMinions.Where(m => Utilities.Q.IsInRange(m));
// if minions is NOT empty or there are any minions
var objAiMinions = allMinions as Obj_AI_Minion[] ?? allMinions.ToArray();
if (!objAiMinions.Any())
{
return;
}
//var minions = allMinions.OrderBy(i => i.Health).FirstOrDefault(); // => get first one or default.
foreach (
var minion in
objAiMinions.Where(
minion =>
minion.IsValidTarget(Utilities.Q.Range) && !minion.InAutoAttackRange() ||
!minion.IsUnderAllyTurret()))
{
var hpred = HealthPrediction.GetHealthPrediction(minion, 1000);
if (minion != null && hpred < Core.GetQDamage(minion) && hpred > minion.Health - hpred * 2)
{
var prediction = Utilities.Q.GetPrediction(minion, true, Utilities.Q.Range).CastPosition;
Core.CastQ(minion, prediction, Utilities.MainMenu["Q"]["LastMana"]);
// => CastQ on it, while refering on your mana.
}
}
}
private void LastHit()
{
if (!Q.IsReady())
{
return;
}
if (!menu.Item("Q_Stun_LastHit", true).GetValue <bool>() && HasStun())
{
return;
}
foreach (var minion in MinionManager.GetMinions(Player.Position, Q.Range).Where(minion => HealthPrediction.GetHealthPrediction(minion,
(int)(Q.Delay + (minion.Distance(Player) / Q.Speed))) < Player.GetSpellDamage(minion, SpellSlot.Q) &&
HealthPrediction.GetHealthPrediction(minion, (int)(Q.Delay + (minion.Distance(Player) / Q.Speed))) > 0))
{
Q.Cast(minion);
}
}
public static Obj_AI_Base GetPossibleTarget()
{
if (ForcedTarget != null)
{
if (InAutoAttackRange(ForcedTarget))
{
return(ForcedTarget);
}
ForcedTarget = null;
}
Obj_AI_Base tempTarget = null;
if (Menu.Item("lxOrbwalker_Misc_Priority_Unit").GetValue <StringList>().SelectedIndex == 1 &&
(CurrentMode == Mode.Harass || CurrentMode == Mode.LaneClear))
{
tempTarget = GetBestHeroTarget();
if (tempTarget != null)
{
return(tempTarget);
}
}
if (CurrentMode == Mode.Harass || CurrentMode == Mode.Lasthit || CurrentMode == Mode.LaneClear || CurrentMode == Mode.LaneFreeze)
{
foreach (
var minion in
from minion in
ObjectManager.Get <Obj_AI_Minion>().Where(minion => minion.IsValidTarget() && InAutoAttackRange(minion))
let t = (int)(MyHero.AttackCastDelay * 1000) - 100 + Game.Ping / 2 +
1000 * (int)MyHero.Distance(minion) / (int)MyProjectileSpeed()
let predHealth = HealthPrediction.GetHealthPrediction(minion, t, FarmDelay())
where minion.Team != GameObjectTeam.Neutral && predHealth > 0 &&
predHealth <= MyHero.GetAutoAttackDamage(minion, true)
select minion)
{
return(minion);
}
}
if (CurrentMode == Mode.Harass || CurrentMode == Mode.LaneClear || CurrentMode == Mode.LaneFreeze)
{
foreach (
var turret in
ObjectManager.Get <Obj_AI_Turret>().Where(turret => turret.IsValidTarget(GetAutoAttackRange(MyHero, turret))))
{
return(turret);
}
}
if (CurrentMode != Mode.Lasthit)
{
tempTarget = GetBestHeroTarget();
if (tempTarget != null)
{
return(tempTarget);
}
}
float[] maxhealth;
if (CurrentMode == Mode.LaneClear || CurrentMode == Mode.Harass || CurrentMode == Mode.LaneFreeze)
{
maxhealth = new float[] { 0 };
var maxhealth1 = maxhealth;
foreach (var minion in ObjectManager.Get <Obj_AI_Minion>().Where(minion => minion.IsValidTarget(GetAutoAttackRange(MyHero, minion)) && minion.Team == GameObjectTeam.Neutral).Where(minion => minion.MaxHealth >= maxhealth1[0] || Math.Abs(maxhealth1[0] - float.MaxValue) < float.Epsilon))
{
tempTarget = minion;
maxhealth[0] = minion.MaxHealth;
}
if (tempTarget != null)
{
return(tempTarget);
}
}
if (CurrentMode != Mode.LaneClear || ShouldWait())
{
return(null);
}
maxhealth = new float[] { 0 };
foreach (var minion in from minion in ObjectManager.Get <Obj_AI_Minion>()
.Where(minion => minion.IsValidTarget(GetAutoAttackRange(MyHero, minion)))
let predHealth = HealthPrediction.LaneClearHealthPrediction(minion, (int)((MyHero.AttackDelay * 1000) * LaneClearWaitTimeMod), FarmDelay())
where predHealth >=
2 * MyHero.GetAutoAttackDamage(minion, true) ||
Math.Abs(predHealth - minion.Health) < float.Epsilon
where minion.Health >= maxhealth[0] || Math.Abs(maxhealth[0] - float.MaxValue) < float.Epsilon
select minion)
{
tempTarget = minion;
maxhealth[0] = minion.MaxHealth;
}
return(tempTarget);
}
public override void ExecuteLaneClear()
{
List <Obj_AI_Base> laneMinions;
var laneWValue = Program.laneclear["Lane.UseW"].Cast <ComboBox>().CurrentValue;
if (laneWValue != 0 && W.IsReady())
{
var totalAa =
ObjectManager.Get <Obj_AI_Minion>()
.Where(
m =>
m.LSIsValidTarget(Orbwalking.GetRealAutoAttackRange(null) + 65 + W.Range))
.Sum(mob => (int)mob.Health);
totalAa = (int)(totalAa / ObjectManager.Player.TotalAttackDamage);
if (totalAa > laneWValue * 5)
{
W.Cast();
}
}
var laneQValue = Program.laneclear["Lane.UseQ"].Cast <ComboBox>().CurrentValue;
if (laneQValue != 0 && W.IsReady())
{
if (laneQValue == 1 || laneQValue == 3)
{
var vMinions = MinionManager.GetMinions(ObjectManager.Player.Position, Q.Range);
foreach (var minions in vMinions
.Where(minions => minions.Health < ObjectManager.Player.LSGetSpellDamage(minions, SpellSlot.Q))
.Where(
m =>
m.LSIsValidTarget(Q.Range) &&
m.LSDistance(ObjectManager.Player.Position) > GetRealAARange)
)
{
var qP = Q.GetPrediction(minions);
var hit = qP.CastPosition.LSExtend(ObjectManager.Player.Position, -140);
if (qP.HitChance >= EloBuddy.SDK.Enumerations.HitChance.High)
{
Q.Cast(hit);
}
}
}
if (laneQValue == 2 || laneQValue == 3)
{
var minions = MinionManager.GetMinions(ObjectManager.Player.ServerPosition, E.Range * 1);
foreach (var n in from n in minions
let xH =
HealthPrediction.GetHealthPrediction(n,
(int)(ObjectManager.Player.AttackCastDelay * 1000), Game.Ping / 2 + 100)
where xH < 0
where n.Health < Q.GetDamage(n)
select n)
{
Q.Cast(n);
}
}
}
var laneEValue = Program.laneclear["Lane.UseE"].Cast <ComboBox>().CurrentValue;
if (laneEValue != 0 && E.IsReady())
{
laneMinions = MinionManager.GetMinions(ObjectManager.Player.ServerPosition, E.Range,
MinionTypes.All);
if (laneMinions != null)
{
var locE = E.GetLineFarmLocation(laneMinions);
if (laneMinions.Count == laneMinions.Count(m => ObjectManager.Player.LSDistance(m) < E.Range) &&
locE.MinionsHit > laneEValue && locE.Position.IsValid())
{
E.Cast(locE.Position);
}
}
}
var laneRValue = Program.laneclear["Lane.UseR"].Cast <ComboBox>().CurrentValue;
if (laneRValue != 0 && R.IsReady() && UltiBuffStacks < Program.laneclear["Lane.UseRLim"].Cast <Slider>().CurrentValue)
{
switch (laneRValue)
{
case 1:
{
var vMinions = MinionManager.GetMinions(ObjectManager.Player.Position, Q.Range);
foreach (var minions in vMinions
.Where(minions => minions.Health < R.GetDamage(minions))
.Where(
m =>
m.LSIsValidTarget(R.Range) &&
m.LSDistance(ObjectManager.Player.Position) > GetRealAARange)
)
{
R.Cast(minions);
}
break;
}
case 2:
{
laneMinions = MinionManager.GetMinions(ObjectManager.Player.ServerPosition, R.Range + R.Width + 30,
MinionTypes.Ranged);
if (laneMinions != null)
{
var locR = R.GetCircularFarmLocation(laneMinions, R.Width * 0.75f);
if (locR.MinionsHit >= laneEValue && R.IsInRange(locR.Position.To3D()))
{
R.Cast(locR.Position);
}
}
break;
}
}
}
}
private void Combo()
{
Obj_AI_Hero target = TargetSelector.GetTarget(R.Range, TargetSelector.DamageType.Magical, true);
if (target == null || target.IsInvulnerable || target.MagicImmune)
{
return;
}
if (config.Item("useItems").GetValue <bool>())
{
ItemHandler.UseItems(target, config, ComboDamage(target));
}
var data = Program.IncDamages.GetAllyData(player.NetworkId);
var ignitedmg = (float)player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite);
bool hasIgnite = player.Spellbook.CanUseSpell(player.GetSpellSlot("SummonerDot")) == SpellState.Ready;
if (config.Item("useIgnite", true).GetValue <bool>() &&
ignitedmg > HealthPrediction.GetHealthPrediction(target, 700) && hasIgnite &&
!CombatHelper.CheckCriticalBuffs(target) &&
target.Distance(player) > Orbwalking.GetRealAutoAttackRange(target) + 25 && !justQ)
{
player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), target);
}
if (Q.CanCast(target) && config.Item("useq", true).GetValue <bool>() && !player.IsWindingUp &&
!data.IncSkillShot)
{
Q.CastOnUnit(target);
}
var cmbdmg = ComboDamage(target) + ItemHandler.GetItemsDamage(target);
if (E.IsReady() && config.Item("usee", true).GetValue <bool>() && !player.IsWindingUp)
{
var enemyPred = E.GetPrediction(target);
if (!OnTrident)
{
if (config.Item("useedmg", true).GetValue <bool>() &&
data.ProjectileDamageTaken > target.GetAutoAttackDamage(player, true) + 10)
{
E.Cast(enemyPred.CastPosition);
}
if (config.Item("useehighdmg", true).GetValue <bool>() && data.DamageTaken > player.Health * 0.4f)
{
E.Cast(enemyPred.CastPosition);
}
if (config.Item("useeaa", true).GetValue <bool>() &&
data.AADamageTaken < target.GetAutoAttackDamage(player, true) + 10 &&
!SpellDatabase.AnyReadyCC(player.Position, 700, true))
{
E.Cast(enemyPred.CastPosition);
}
if (config.Item("useecq", true).GetValue <bool>() &&
cmbdmg > HeroManager.Enemies.Where(e => target.Distance(e) < 1500).Sum(e => e.Health) &&
!target.UnderTurret(true))
{
E.Cast(enemyPred.CastPosition);
}
}
else
{
if (data.DamageTaken < 10 && enemyPred.Hitchance >= HitChance.High)
{
E.Cast(enemyPred.CastPosition);
}
}
}
if (config.Item("usew", true).GetValue <bool>() && W.IsReady() && player.IsWindingUp)
{
W.Cast();
}
if (config.Item("user", true).GetValue <bool>() && R.IsReady() && player.IsWindingUp &&
cmbdmg * 1.6 + player.GetAutoAttackDamage(target, true) * 5 > target.Health &&
(target.Health > R.GetDamage(target) * 1.4f || player.HealthPercent < 40))
{
CastR(target);
}
}
public AttackableUnit GetTarget()
{
AttackableUnit result = null;
if ((ActiveMode == OrbwalkingMode.Mixed || ActiveMode == OrbwalkingMode.LaneClear) &&
!_config.Item("PriorizeFarm").GetValue <bool>())
{
var target = TargetSelector.GetTarget(-1, TargetSelector.DamageType.Physical);
if (target != null)
{
return(target);
}
}
/*Killable Minion*/
if (ActiveMode == OrbwalkingMode.LaneClear || ActiveMode == OrbwalkingMode.Mixed ||
ActiveMode == OrbwalkingMode.LastHit)
{
foreach (var minion in
ObjectHandler.Get <Obj_AI_Minion>()
.Where(
minion =>
minion.IsValidTarget() && InAutoAttackRange(minion) &&
minion.Health <
2 *
(ObjectHandler.Player.BaseAttackDamage + ObjectHandler.Player.FlatPhysicalDamageMod))
)
{
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 (minion.Team != GameObjectTeam.Neutral && MinionManager.IsMinion(minion, true))
{
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
ObjectHandler.Get <Obj_AI_Turret>().Where(t => t.IsValidTarget() && InAutoAttackRange(t)))
{
return(turret);
}
/* inhibitor */
foreach (var turret in
ObjectHandler.Get <Obj_BarracksDampener>().Where(t => t.IsValidTarget() && InAutoAttackRange(t)))
{
return(turret);
}
/* nexus */
foreach (var nexus in
ObjectHandler.Get <Obj_HQ>().Where(t => t.IsValidTarget() && InAutoAttackRange(t)))
{
return(nexus);
}
}
/*Champions*/
if (ActiveMode != OrbwalkingMode.LastHit)
{
var target = TargetSelector.GetTarget(-1, TargetSelector.DamageType.Physical);
if (target.IsValidTarget())
{
return(target);
}
}
/*Jungle minions*/
if (ActiveMode == OrbwalkingMode.LaneClear || ActiveMode == OrbwalkingMode.Mixed)
{
result =
ObjectHandler.Get <Obj_AI_Minion>()
.Where(
mob =>
mob.IsValidTarget() && InAutoAttackRange(mob) && mob.Team == GameObjectTeam.Neutral)
.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
ObjectHandler.Get <Obj_AI_Minion>()
.Where(minion => minion.IsValidTarget() && InAutoAttackRange(minion))
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);
}
public virtual AttackableUnit GetTarget()
{
AttackableUnit result = null;
if ((ActiveMode == OrbwalkingMode.Mixed || ActiveMode == OrbwalkingMode.LaneClear) &&
!_config.Item("PriorizeFarm").GetValue <bool>())
{
var target = TargetSelector.GetTarget(-1, TargetSelector.DamageType.Physical);
if (target != null && target.IsVisible && target.IsHPBarRendered && target.IsTargetable && !target.IsDead && InAutoAttackRange(target))
{
return(target);
}
}
/*Killable Minion*/
if (ActiveMode == OrbwalkingMode.LaneClear || ActiveMode == OrbwalkingMode.Mixed && _config.Item("Harass.MLH").GetValue <bool>() ||
ActiveMode == OrbwalkingMode.LastHit)
{
var MinionList =
ObjectManager.Get <Obj_AI_Minion>()
.Where(
minion =>
minion.IsValidTarget() && minion.IsVisible && minion.IsHPBarRendered && minion.IsTargetable && !minion.IsDead && InAutoAttackRange(minion))
.OrderByDescending(minion => minion.CharData.BaseSkinName.Contains("Siege"))
.ThenBy(minion => minion.CharData.BaseSkinName.Contains("Super"))
.ThenBy(minion => minion.Health)
.ThenByDescending(minion => minion.MaxHealth);
foreach (var minion in MinionList)
{
var t = (int)(Player.AttackCastDelay * 1000) - 100 +
1000 * (int)Math.Max(0, Player.Distance(minion) - Player.BoundingRadius) / int.MaxValue;
var predHealth = HealthPrediction.GetHealthPrediction(minion, t, 0);
if (minion.Team != GameObjectTeam.Neutral && (_config.Item("AttackPetsnTraps").GetValue <bool>() || MinionManager.IsMinion(minion, _config.Item("AttackWards").GetValue <bool>())))
{
if (predHealth <= 0)
{
FireOnNonKillableMinion(minion);
}
if (predHealth > 0 && predHealth <= Player.GetAutoAttackDamage(minion, true))
{
return(minion);
}
}
}
}
//Forced target
if (_forcedTarget.IsValidTarget() && _forcedTarget.IsVisible && _forcedTarget.IsHPBarRendered && _forcedTarget.IsTargetable && !_forcedTarget.IsDead && InAutoAttackRange(_forcedTarget))
{
return(_forcedTarget);
}
/* turrets / inhibitors / nexus */
if (ActiveMode == OrbwalkingMode.LaneClear)
{
/* turrets */
foreach (var turret in
ObjectManager.Get <Obj_AI_Turret>().Where(t => t.IsValidTarget() && InAutoAttackRange(t)))
{
return(turret);
}
/* inhibitor */
foreach (var turret in
ObjectManager.Get <Obj_BarracksDampener>().Where(t => t.IsValidTarget() && InAutoAttackRange(t)))
{
return(turret);
}
/* nexus */
foreach (var nexus in
ObjectManager.Get <Obj_HQ>().Where(t => t.IsValidTarget() && InAutoAttackRange(t)))
{
return(nexus);
}
}
/*Champions*/
if (ActiveMode != OrbwalkingMode.LastHit)
{
var target = TargetSelector.GetTarget(-1, TargetSelector.DamageType.Physical);
if (target.IsValidTarget() && target.IsVisible && target.IsHPBarRendered && target.IsTargetable && !target.IsDead && InAutoAttackRange(target))
{
return(target);
}
}
/*Jungle minions*/
if (ActiveMode == OrbwalkingMode.LaneClear || ActiveMode == OrbwalkingMode.Mixed)
{
var jminions =
ObjectManager.Get <Obj_AI_Minion>()
.Where(
mob =>
mob.IsValidTarget() && mob.Team == GameObjectTeam.Neutral && InAutoAttackRange(mob) &&
mob.CharData.BaseSkinName != "gangplankbarrel");
result = _config.Item("Smallminionsprio").GetValue <bool>() ? jminions.MinOrDefault(mob => mob.MaxHealth) : jminions.MaxOrDefault(mob => mob.MaxHealth);
if (result != null)
{
return(result);
}
}
/*Lane Clear minions*/
if (ActiveMode == OrbwalkingMode.LaneClear)
{
if (!ShouldWait())
{
if (_prevMinion.IsValidTarget() && _prevMinion.IsVisible && _prevMinion.IsHPBarRendered && _prevMinion.IsTargetable && !_prevMinion.IsDead && InAutoAttackRange(_prevMinion))
{
var predHealth = HealthPrediction.LaneClearHealthPrediction(
_prevMinion, (int)((Player.AttackDelay * 1000) * LaneClearWaitTimeMod), 0);
if (predHealth >= 2 * Player.GetAutoAttackDamage(_prevMinion) ||
Math.Abs(predHealth - _prevMinion.Health) < float.Epsilon)
{
return(_prevMinion);
}
}
result = (from minion in
ObjectManager.Get <Obj_AI_Minion>()
.Where(minion => minion.IsValidTarget() && minion.IsVisible && minion.IsHPBarRendered && minion.IsTargetable && !minion.IsDead && InAutoAttackRange(minion) &&
(_config.Item("AttackWards").GetValue <bool>() || !MinionManager.IsWard(minion.CharData.BaseSkinName.ToLower())) &&
(_config.Item("AttackPetsnTraps").GetValue <bool>() && minion.CharData.BaseSkinName != "jarvanivstandard" || MinionManager.IsMinion(minion, _config.Item("AttackWards").GetValue <bool>())) &&
minion.CharData.BaseSkinName != "gangplankbarrel")
let predHealth =
HealthPrediction.LaneClearHealthPrediction(
minion, (int)((Player.AttackDelay * 1000) * LaneClearWaitTimeMod), 0)
where
predHealth >= 2 * Player.GetAutoAttackDamage(minion) ||
Math.Abs(predHealth - minion.Health) < float.Epsilon
select minion).MaxOrDefault(m => !MinionManager.IsMinion(m, true) ? float.MaxValue : m.Health);
if (result != null)
{
_prevMinion = (Obj_AI_Minion)result;
}
}
}
return(result);
}
private static void Farm(bool laneClear)
{
if (!Orbwalking.CanMove(40))
{
return;
}
var allMinions = MinionManager.GetMinions(Player.ServerPosition, Q.Range);
var useQi = Config.Item("UseQFarm").GetValue <StringList>().SelectedIndex;
var useWi = Config.Item("UseWFarm").GetValue <StringList>().SelectedIndex;
var useEi = Config.Item("UseEFarm").GetValue <StringList>().SelectedIndex;
var useQ = (laneClear && (useQi == 1 || useQi == 2)) || (!laneClear && (useQi == 0 || useQi == 2));
var useW = (laneClear && (useWi == 1 || useWi == 2)) || (!laneClear && (useWi == 0 || useWi == 2));
var useE = (laneClear && (useEi == 1 || useEi == 2)) || (!laneClear && (useEi == 0 || useEi == 2));
if (useQ && Q.IsReady())
{
foreach (var minion in allMinions)
{
if (minion.IsValidTarget() &&
HealthPrediction.GetHealthPrediction(minion,
(int)(Player.Distance(minion) * 1000 / 1400)) <
Player.GetSpellDamage(minion, SpellSlot.Q))
{
Q.CastOnUnit(minion);
return;
}
}
}
else if (useW && W.IsReady())
{
foreach (var minion in allMinions)
{
if (minion.IsValidTarget(W.Range) &&
minion.Health < Player.GetSpellDamage(minion, SpellSlot.Q))
{
W.CastOnUnit(minion);
return;
}
}
}
else if (useE && E.IsReady())
{
foreach (var minion in allMinions)
{
if (minion.IsValidTarget(E.Range) &&
HealthPrediction.GetHealthPrediction(minion,
(int)(Player.Distance(minion) * 1000 / 1000)) <
Player.GetSpellDamage(minion, SpellSlot.Q) - 10)
{
E.CastOnUnit(minion);
return;
}
}
}
if (laneClear)
{
foreach (var minion in allMinions)
{
if (useQ)
{
Q.CastOnUnit(minion);
}
if (useW)
{
W.CastOnUnit(minion);
}
if (useE)
{
E.CastOnUnit(minion);
}
}
}
}
