// AIHeroClient enemy;
public static void Orbwalking_AfterAttack(AttackableUnit unit, AttackableUnit target)
{
if (!unit.IsMe)
{
return;
}
if (Program.orbwalker.ActiveMode.ToString() == "LaneClear" &&
100 * (Program.Player.Mana / Program.Player.MaxMana) > Program.qmenu.Item("Junglemana").GetValue <Slider>().CurrentValue)
{
var mob =
MinionManager.GetMinions(
Program.Player.ServerPosition,
Program.E.Range,
MinionTypes.All,
MinionTeam.Neutral,
MinionOrderTypes.MaxHealth).FirstOrDefault();
var Minions = MinionManager.GetMinions(
Program.Player.Position.Extend(Game.CursorPosition, Program.Q.Range),
Program.Player.AttackRange,
MinionTypes.All);
var useQ = Program.qmenu.Item("UseQJ").GetValue <bool>();
int countMinions = 0;
foreach (var minions in
Minions.Where(
minion =>
minion.Health < Program.Player.GetAutoAttackDamage(minion) ||
minion.Health < Program.Q.GetDamage(minion) + Program.Player.GetAutoAttackDamage(minion) || minion.Health < Program.Q.GetDamage(minion)))
{
countMinions++;
}
if (countMinions >= 2 && useQ && Program.Q.IsReady() && Minions != null)
{
Program.Q.Cast(Program.Player.Position.Extend(Game.CursorPosition, Program.Q.Range / 2));
}
if (useQ && Program.Q.IsReady() && Orbwalker.InAutoAttackRange(mob) && mob != null)
{
Program.Q.Cast(Game.CursorPosition);
}
}
if (!(target is AIHeroClient))
{
return;
}
Program.tar = (AIHeroClient)target;
if (Program.menu.Item("aaqaa").GetValue <KeyBind>().Active)
{
if (Program.Q.IsReady())
{
Program.Q.Cast(Game.CursorPosition);
Game.SendEmote(Emote.Dance);
}
Orbwalker.Orbwalk(TargetSelector.GetTarget(625, TargetSelector.DamageType.Physical), Game.CursorPosition);
}
// Condemn.FlashE();
if (Program.menu.Item("zzrot").GetValue <KeyBind>().Active)
{
Misc.zzRotCondemn.RotE();
}
if (Program.emenu.Item("UseEaa").GetValue <KeyBind>().Active)
{
Program.E.Cast((Obj_AI_Base)target);
}
//QLogic
if ((Program.qmenu.Item("UseQC").GetValue <bool>() && Program.orbwalker.ActiveMode == Orbwalker.OrbwalkingMode.Combo) || (Program.orbwalker.ActiveMode == Orbwalker.OrbwalkingMode.Harass && Program.qmenu.Item("hq").GetValue <bool>()))
{
var value = Program.qmenu.Item("QMode").GetValue <StringList>().DefaultValue;
var FastQ = Program.qmenu.Item("FastQ").GetValue <bool>();
var htarget = TargetSelector.GetTarget(Program.E.Range, TargetSelector.DamageType.Physical);
if (value == 0)
{
QLogic.Gosu.Run();
}
if (value == 1)
{
Program.Q.Cast(QLogic.Lords.SideQ(ObjectManager.Player.Position.To2D(), target.Position.To2D(), 65).To3D());
}
if (value == 2)
{
Program.Q.Cast(Game.CursorPosition);
}
if (value == 3)
{
if (ObjectManager.Player.Position.Extend(Game.CursorPosition, 700).CountEnemiesInRange(700) <= 1)
{
Program.Q.Cast(Game.CursorPosition);
}
}
if (value == 4)
{
Program.Q.Cast(QLogic.Lords.SafeQ(ObjectManager.Player.Position.To2D(), target.Position.To2D(), 65).To3D());
}
if (value == 5)
{
Program.Q.Cast(QLogic.Lords.AggresiveQ(ObjectManager.Player.Position.To2D(), target.Position.To2D(), 65).To3D());
}
if (value == 6)
{
QLogic.Bursts.Burst();
}
if (value == 7)
{
QLogic.Hiki.SafePositionQ(htarget);
}
if (value == 8)
{
}
}
}
private void LogicQ()
{
var t = TargetSelector.GetTarget(Q3.Range, TargetSelector.DamageType.Magical);
if (t.IsValidTarget())
{
if (Program.Combo && Player.Mana > RMANA + QMANA + EMANA)
{
CastQ(t);
}
else if (Program.Harass && Config.Item("harassQ", true).GetValue <bool>() && Config.Item("Harass" + t.ChampionName).GetValue <bool>() && Player.ManaPercent > Config.Item("QHarassMana", true).GetValue <Slider>().Value&& OktwCommon.CanHarras())
{
CastQ(t);
}
else if (OktwCommon.GetKsDamage(t, Q1) > t.Health)
{
CastQ(t);
}
else if (Player.Mana > RMANA + QMANA)
{
foreach (var enemy in HeroManager.Enemies.Where(enemy => enemy.IsValidTarget(Q3.Range) && !OktwCommon.CanMove(enemy)))
{
CastQ(t);
}
}
}
if (Player.IsWindingUp)
{
return;
}
if (!Program.None && !Program.Combo)
{
var allMinions = Cache.GetMinions(Player.ServerPosition, Q1.Range);
if (Config.Item("farmQout", true).GetValue <bool>() && Player.Mana > RMANA + QMANA + EMANA + WMANA)
{
foreach (var minion in allMinions.Where(minion => minion.IsValidTarget(Q1.Range) && (!Orbwalker.InAutoAttackRange(minion) || (!minion.UnderTurret(true) && minion.UnderTurret()))))
{
var hpPred = SebbyLib.HealthPrediction.GetHealthPrediction(minion, 600);
if (hpPred < Q1.GetDamage(minion) && hpPred > minion.Health - hpPred * 2)
{
Q1.Cast(minion);
return;
}
}
}
if (FarmSpells && Config.Item("farmQ", true).GetValue <bool>())
{
var farmPos = Q1.GetCircularFarmLocation(allMinions, Q1.Width);
if (farmPos.MinionsHit >= FarmMinions)
{
Q1.Cast(farmPos.Position);
}
}
}
}
private void LogicFarm()
{
if (!Program.Harass)
{
return;
}
var allMinions = Cache.GetMinions(Player.ServerPosition, Q.Range);
if (Config.Item("farmQout", true).GetValue <bool>() && Player.Mana > RMANA + QMANA + WMANA + EMANA)
{
foreach (var minion in allMinions.Where(minion => minion.IsValidTarget(Q.Range) && !Orbwalker.InAutoAttackRange(minion) && minion.Health <Q.GetDamage(minion) && minion.Health> minion.FlatPhysicalDamageMod))
{
Q.Cast(minion);
}
}
if (!Program.LaneClear || Player.Mana < RMANA + QMANA)
{
return;
}
var mobs = Cache.GetMinions(Player.ServerPosition, 800, MinionTeam.Neutral);
if (mobs.Count > 0)
{
var mob = mobs[0];
if (Q.IsReady())
{
Q.Cast(mob.Position);
}
if (W.IsReady() && BallPos.Distance(mob.Position) < W.Width)
{
W.Cast();
}
else if (E.IsReady())
{
E.CastOnUnit(best);
}
return;
}
if ((FarmSpells || (Player.UnderTurret(false) && !Player.UnderTurret(true))))
{
var Qfarm = Q.GetCircularFarmLocation(allMinions, 100);
var QWfarm = Q.GetCircularFarmLocation(allMinions, W.Width);
if (Qfarm.MinionsHit + QWfarm.MinionsHit == 0)
{
return;
}
if (Config.Item("farmQ", true).GetValue <bool>())
{
if (Qfarm.MinionsHit >= FarmMinions && !W.IsReady() && Q.IsReady())
{
Q.Cast(Qfarm.Position);
}
else if (QWfarm.MinionsHit > 2 && Q.IsReady())
{
Q.Cast(QWfarm.Position);
}
}
foreach (var minion in allMinions)
{
if (W.IsReady() && minion.Distance(BallPos) < W.Range && minion.Health < W.GetDamage(minion) && Config.Item("farmW", true).GetValue <bool>())
{
W.Cast();
}
if (!W.IsReady() && E.IsReady() && minion.Distance(BallPos) < E.Width && Config.Item("farmE", true).GetValue <bool>())
{
E.CastOnUnit(Player);
}
}
}
}
private void Cast_Q(bool combo, int mode = 0)
{
if (!Q.IsReady())
{
return;
}
if (combo)
{
var target = TargetSelector.GetTarget(Q.Range, TargetSelector.DamageType.Magical);
if (!target.IsValidTarget(Q.Range))
{
return;
}
if (target.HasBuff("AkaliMota"))
{
return;
}
if (CheckMark(Q.Range) != null)
{
target = CheckMark(Q.Range);
}
if (mode == 0)
{
Q.Cast(target);
}
else if (mode == 1)
{
if (!target.HasBuff("AkaliMota"))
{
Q.Cast(target);
}
}
}
else
{
if (MinionManager.GetMinions(Player.Position, Q.Range).Any(minion => minion.HasBuff("AkaliMota") && Orbwalker.InAutoAttackRange(minion)))
{
return;
}
foreach (var minion in MinionManager.GetMinions(Player.Position, Q.Range).Where(minion => HealthPrediction.GetHealthPrediction(minion,
(int)(E.Delay + (minion.Distance(Player.Position) / E.Speed)) * 1000) <
Player.GetSpellDamage(minion, SpellSlot.Q) &&
HealthPrediction.GetHealthPrediction(minion,
(int)(E.Delay + (minion.Distance(Player.Position) / E.Speed)) * 1000) > 0 &&
Orbwalker.InAutoAttackRange(minion)))
{
Q.Cast(minion);
}
foreach (var minion in MinionManager.GetMinions(Player.Position, Q.Range).Where(minion => HealthPrediction.GetHealthPrediction(minion,
(int)(Q.Delay + (minion.Distance(Player.Position) / Q.Speed))) <
Player.GetSpellDamage(minion, SpellSlot.Q)))
{
Q.Cast(minion);
}
foreach (var minion in MinionManager.GetMinions(Player.ServerPosition, Q.Range, MinionTypes.All, MinionTeam.Neutral, MinionOrderTypes.MaxHealth).Where(minion => Player.Distance(minion.Position) <= Q.Range))
{
Q.Cast(minion);
}
}
}
private static void DoCombo()
{
var target = TargetSelector.GetTarget(R.Range, TargetSelector.DamageType.Magical);
if (!target.IsValidTarget())
{
return;
}
if (Menu.Item("UseREGapclose").IsActive() && CanKillWithUltCombo(target) && Q.IsReady() && W.IsReady() &&
E.IsReady() && R.IsReady() && (Player.Distance(target) < Q.Range + E.Range * 2))
{
CastRSmart(target);
E.Cast(Player.ServerPosition.Extend(target.ServerPosition, E.Range - 1));
E.Cast(Player.ServerPosition.Extend(target.ServerPosition, E.Range - 1));
W.Cast();
Q.Cast(target);
}
else
{
if (R.IsEnabledAndReady())
{
if (Player.GetSpellDamage(target, SpellSlot.R) > target.Health)
{
CastRSmart(target);
}
if (DamageToUnit(target) > target.Health)
{
CastRSmart(target);
}
if ((Q.IsReady() || E.IsReady()))
{
CastRSmart(target);
}
if (Orbwalker.InAutoAttackRange(target))
{
CastRSmart(target);
}
}
// Use W Before Q
if (W.IsEnabledAndReady() && Menu.Item("UseWWhen").GetValue <StringList>().SelectedIndex == 0 &&
(Q.IsReady() || Orbwalker.InAutoAttackRange(target)))
{
W.Cast();
}
if (Q.IsEnabledAndReady())
{
Q.Cast(target);
}
if (E.IsEnabledAndReady())
{
E.Cast(target);
}
}
}
public void farmQ()
{
if (Program.LaneClear)
{
var mobs = Cache.GetMinions(Player.ServerPosition, 800, MinionTeam.Neutral);
if (mobs.Count > 0)
{
var mob = mobs[0];
Q.Cast(mob, true);
return;
}
}
if (!MainMenu.Item("farmQ", true).GetValue <bool>())
{
return;
}
var minions = Cache.GetMinions(Player.ServerPosition, Q.Range);
int orbTarget = 0;
if (Orbwalker.GetTarget() != null)
{
orbTarget = Orbwalker.GetTarget().NetworkId;
}
foreach (var minion in minions.Where(minion => orbTarget != minion.NetworkId && !Orbwalker.InAutoAttackRange(minion) && minion.Health < Q.GetDamage(minion)))
{
if (Q.Cast(minion) == Spell.CastStates.SuccessfullyCasted)
{
return;
}
}
if (MainMenu.Item("LC", true).GetValue <bool>() && Program.LaneClear && !Orbwalking.CanAttack() && FarmSpells)
{
var LCP = MainMenu.Item("LCP", true).GetValue <bool>();
foreach (var minion in minions.Where(minion => Orbwalker.InAutoAttackRange(minion) && orbTarget != minion.NetworkId))
{
var hpPred = HealthPrediction.GetHealthPrediction(minion, 300);
var dmgMinion = minion.GetAutoAttackDamage(minion);
var qDmg = Q.GetDamage(minion);
if (hpPred < qDmg)
{
if (hpPred > dmgMinion)
{
if (Q.Cast(minion) == Spell.CastStates.SuccessfullyCasted)
{
return;
}
}
}
else if (LCP)
{
if (hpPred > dmgMinion + qDmg)
{
if (Q.Cast(minion) == Spell.CastStates.SuccessfullyCasted)
{
return;
}
}
}
}
}
}
public void LaneClear()
{
if (GetValue <bool>("UseEQL"))
{
if (ECasting && ETar != null && ETar.IsValidTarget() && Q1.IsReady())
{
Q1.Cast(ETar);
}
}
var vMinions = MinionManager.GetMinions(Player.Position, 950);
if (GetValue <StringList>("ELmode").SelectedIndex == 1 && E.IsReady())
{
var min =
vMinions.Where(
minion =>
minion.IsValidTarget(E.Range) && IsDashable(minion) && !GetDashingEnd(minion).To3D().UnderTurret(true) &&
minion.Health < GetSweepingBladeDamage(minion)).OrderBy(tar => tar.Health).FirstOrDefault();
if (min != null)
{
if (E.CastOnUnit(min))
{
vMinions.Remove(min);
}
}
}
if (Q1.IsReady() && GetValue <bool>("UseQL") && !ETar.IsValidTarget() && !Player.IsDashing() && !ECast && !ECasting)
{
foreach (var minions in vMinions.Where(minions => minions.IsValidTarget(HasWhirlwind() ? Q2.Range : 475) && minions.Health < Player.GetSpellDamage(minions, SpellSlot.Q) && (AttackNow || !Orbwalker.InAutoAttackRange(minions))).OrderBy(tar => tar.Health))
{
if (ETar != null && ETar.NetworkId == minions.NetworkId)
{
if (ETar.IsValidTarget() && GetSweepingBladeDamage(minions) < minions.Health)
{
if (!HasWhirlwind())
{
Q1.Cast(minions);
}
else
{
Q2.Cast(minions, false, true);
}
}
}
else
{
if (!HasWhirlwind())
{
Q1.Cast(minions);
}
else
{
Q2.Cast(minions, false, true);
}
}
}
}
}
public override void Game_OnGameUpdate(EventArgs args)
{
if (LaneClearActive)
{
var vMinions = MinionManager.GetMinions(Player.Position, Orbwalking.GetRealAutoAttackRange(null));
foreach (var minions in
vMinions.Where(
minions => minions.HasBuff("QuinnW") && (minions.Health <(Player.GetAutoAttackDamage(minions) + PassiveMarkDamage(minions)) || minions.Health> (Player.GetAutoAttackDamage(minions) + PassiveMarkDamage(minions)) + (20 + Player.Level * 2))))
{
Orbwalker.ForceTarget(minions);
}
}
if (!ComboActive)
{
Orbwalker.SetAttack(true);
Orbwalker.SetMovement(true);
return;
}
var useQ = GetValue <bool>("UseQ" + (ComboActive ? "C" : "H"));
var useE = GetValue <bool>("UseE" + (ComboActive ? "C" : "H"));
var useR = GetValue <bool>("UseR");
var useET = GetValue <bool>("UseET" + (ComboActive ? "C" : "H"));
var manE = GetValue <KeyBind>("ManualE").Active;
if (Player.IsMelee())
{
if (IsValorMode())
{
if (useR)
{
var vTarget = TargetSelector.GetTarget(R.Range, TargetSelector.DamageType.Physical);
if (vTarget != null)
{
CalculateValorDamage();
if (vTarget.Health >= ValorMinDamage && vTarget.Health <= ValorMaxDamage)
{
R.Cast();
}
}
}
if (Q.IsReady() && useQ)
{
var t = TargetSelector.GetTarget(275, TargetSelector.DamageType.Physical);
if (t != null && (AttackReadiness > 0.2 && AttackReadiness < 0.75))
{
Q.Cast();
}
}
}
var targetLoc = Game.CursorPos;
YTarget = (TargetSelector.GetSelectedTarget() != null &&
TargetSelector.GetSelectedTarget().Distance(Game.CursorPos) <= GetValue <Slider>("Cirsize").Value)
? TargetSelector.GetSelectedTarget()
: TargetSelector.GetTarget(
GetValue <Slider>("Cirsize").Value, TargetSelector.DamageType.Physical, true, null, Game.CursorPos);
Orbwalker.ForceTarget(YTarget);
Orbwalker.SetMovement(false);
if (YTarget.IsValidTarget())
{
Orbwalker.SetAttack(
Orbwalker.GetTarget().IsValidTarget() && Orbwalker.GetTarget().NetworkId == YTarget.NetworkId);
if (Orbwalking.CanMove(50))
{
if (!Orbwalker.InAutoAttackRange(YTarget))
{
var pLoc = Prediction.GetPrediction(YTarget, 0.1f, 175, 600).UnitPosition;
MoveTo(pLoc, Orbwalking.GetRealAutoAttackRange(YTarget) / 2);
}
else
{
MoveByTarget(YTarget);
}
}
if (E.IsReady() && (useE || manE) && Player.Distance3D(YTarget) > 350)
{
E.CastOnUnit(YTarget);
}
}
else
{
MoveTo(targetLoc, 100);
Orbwalker.SetAttack(false);
}
}
else
{
Orbwalker.SetAttack(true);
Orbwalker.SetMovement(true);
var targ =
HeroManager.Enemies.Where(enemy => enemy.IsValidTarget() && Orbwalking.InAutoAttackRange(enemy) && enemy.HasBuff("QuinnW")).OrderBy(PhysHealth)
.FirstOrDefault();
Orbwalker.ForceTarget(targ);
if (E.IsReady() && (useE || manE))
{
var vTarget = Orbwalker.GetTarget() as Obj_AI_Hero ?? TargetSelector.GetTarget(E.Range, TargetSelector.DamageType.Physical);
if (vTarget != null && !IsHePantheon(vTarget) &&
(Player.Distance3D(vTarget) > Orbwalking.GetRealAutoAttackRange(vTarget) ||
(AttackReadiness > 0.2 && AttackReadiness < 0.75)))
{
if (!useET)
{
E.CastOnUnit(vTarget);
}
else if (!vTarget.UnderTurret())
{
E.CastOnUnit(vTarget);
}
}
}
if (Q.IsReady() && useQ)
{
var t =
HeroManager.Enemies.Where(enemy => enemy.IsValidTarget(Q.Range) && (GetValue <StringList>("Blind" + enemy.ChampionName).SelectedIndex == 1 ||
enemy.HealthPercent <= GetValue <Slider>("BlindD").Value || !BlindTargetNear(enemy))).OrderBy(PhysHealth)
.FirstOrDefault();
if (t != null &&
(Player.Distance3D(t) > Orbwalking.GetRealAutoAttackRange(t) ||
(AttackReadiness > 0.2 && AttackReadiness < 0.75)))
{
Q.Collision = false;
var chance = Q.GetPrediction(t).Hitchance;
if (chance >= HitChance.VeryHigh)
{
Q.Collision = true;
CastSpellAoEShot(Q, t, 100);
}
}
}
Drawing.DrawText(
Drawing.WorldToScreen(Player.Position)[0] + 50,
Drawing.WorldToScreen(Player.Position)[1] - 20, Color.Yellow, "lol");
}
}
private void Combo()
{
var target = TargetSelector.GetTarget(E.Range, TargetSelector.DamageType.Physical);
if (CheckTarget(target, E.Range))
{
if (Menu.Item("ComboW", true).GetValue <bool>() && W.IsReady() && !Me.HasBuff("dravenfurybuff"))
{
if (Menu.Item("ComboWLogic", true).GetValue <bool>())
{
if (target.DistanceToPlayer() >= 600)
{
W.Cast();
}
else
{
if (target.Health <
(AxeCount > 0 ? Q.GetDamage(target) * 5 : Me.GetAutoAttackDamage(target) * 5))
{
W.Cast();
}
}
}
else
{
W.Cast();
}
}
if (Menu.Item("ComboE", true).GetValue <bool>() && E.IsReady())
{
if (!Orbwalker.InAutoAttackRange(target) ||
target.Health < (AxeCount > 0 ? Q.GetDamage(target) * 3 : Me.GetAutoAttackDamage(target) * 3) ||
Me.HealthPercent < 40)
{
E.CastTo(target);
}
}
if (Menu.Item("ComboR", true).GetValue <bool>() && R.IsReady())
{
if (Menu.Item("ComboRSolo", true).GetValue <bool>())
{
if ((target.Health <
R.GetDamage(target) +
(AxeCount > 0 ? Q.GetDamage(target) * 2 : Me.GetAutoAttackDamage(target) * 2) +
(E.IsReady() ? E.GetDamage(target) : 0)) &&
target.Health > (AxeCount > 0 ? Q.GetDamage(target) * 3 : Me.GetAutoAttackDamage(target) * 3) &&
(Me.CountEnemiesInRange(1000) == 1 ||
(Me.CountEnemiesInRange(1000) == 2 && Me.HealthPercent >= 60)))
{
var rPred = R.GetPrediction(target);
if (rPred.Hitchance >= HitChance.VeryHigh)
{
R.Cast(rPred.CastPosition);
}
}
}
if (Menu.Item("ComboRTeam", true).GetValue <bool>())
{
if (Me.CountAlliesInRange(1000) <= 3 && Me.CountEnemiesInRange(1000) <= 3)
{
var rPred = R.GetPrediction(target);
if (rPred.AoeTargetsHitCount >= 3)
{
R.Cast(rPred.CastPosition);
}
else if (rPred.AoeTargetsHitCount >= 2)
{
R.Cast(rPred.CastPosition);
}
}
else if (Me.CountAlliesInRange(1000) <= 2 && Me.CountEnemiesInRange(1000) <= 4)
{
var rPred = R.GetPrediction(target);
if (rPred.AoeTargetsHitCount >= 3)
{
R.Cast(rPred.CastPosition);
}
}
}
}
}
}
public override void Game_OnGameUpdate(EventArgs args)
{
/*if (champ != null)
* Drawing.DrawText(
* Drawing.WorldToScreen(champ.Position)[0] + 50,
* Drawing.WorldToScreen(champ.Position)[1] - 20, Color.Yellow, "" + textl);*/
EvadeDetectedSkillshots.RemoveAll(skillshot => !skillshot.IsActive());
Evader();
if (Player.IsDashing() && ECast)
{
ECasting = true;
ECast = false;
}
if (GetValue <bool>("UseRC"))
{
AutoUlt();
}
var dashList =
ObjectManager.Get <Obj_AI_Base>()
.Where(o => o.IsValidTarget(E.Range) && IsDashable(o) &&
(o.Type == GameObjectType.obj_AI_Hero || o.Type == GameObjectType.obj_AI_Minion)).ToList();
if (GetValue <bool>("UseQC") && (GetValue <KeyBind>("UseQHT").Active || ComboActive) && !GetValue <KeyBind>("Flee").Active)
{
if (YTarget.IsValidTarget(HasWhirlwind() ? Q2.Range : Q1.Range))
{
if (HasWhirlwind() || YTarget.HasBuff("YasuoDashWrapper") || Orbwalker.InAutoAttackRange(YTarget))
{
AutoQ(YTarget);
}
}
else
{
AutoQ(
HasWhirlwind()
? TargetSelector.GetTarget(Q2.Range, TargetSelector.DamageType.Physical)
: TargetSelector.GetTarget(Q1.Range, TargetSelector.DamageType.Physical));
}
}
var targetLoc = Game.CursorPos;
if (GetValue <KeyBind>("Flee").Active)
{
CanMove = true;
MoveTo(targetLoc, 100);
DashToLoc(targetLoc, dashList, true);
}
if (LaneClearActive)
{
if (GetValue <StringList>("ELmode").SelectedIndex == 2)
{
DashToLoc(targetLoc, dashList, true);
}
LaneClear();
}
if (ComboActive)
{
if (ECasting && ETar != null && ETar.IsValidTarget() && Q1.IsReady() && !HasWhirlwind())
{
Q1.Cast(ETar);
}
YTarget = (TargetSelector.GetSelectedTarget().IsValidTarget() &&
TargetSelector.GetSelectedTarget().Distance(Game.CursorPos) <=
GetValue <Slider>("Cirsize").Value)
? TargetSelector.GetSelectedTarget()
: TargetSelector.GetTarget(
GetValue <Slider>("Cirsize").Value, TargetSelector.DamageType.Physical, true, null,
Game.CursorPos);
Orbwalker.ForceTarget(YTarget);
Orbwalker.SetMovement(false);
if (YTarget != null && YTarget.IsValidTarget())
{
if (Orbwalker.GetTarget().IsValidTarget())
{
Orbwalker.SetAttack(Orbwalker.GetTarget().NetworkId == YTarget.NetworkId);
}
if (Orbwalking.CanMove(50))
{
if (!Orbwalker.InAutoAttackRange(YTarget))
{
DashToLoc(Prediction.GetPrediction(YTarget, 0.4f).UnitPosition, dashList, false);
var pLoc = Prediction.GetPrediction(YTarget, 0.1f, 175, 600).UnitPosition;
MoveTo(pLoc, Orbwalking.GetRealAutoAttackRange(YTarget) / 2);
}
else if (AttackReadiness > 0.3)
{
MoveByTarget(YTarget);
}
}
}
else
{
CanMove = true;
Orbwalker.SetAttack(false);
MoveTo(targetLoc, 100);
DashToLoc(targetLoc, dashList, false);
}
}
else
{
CanMove = true;
Orbwalker.SetAttack(true);
Orbwalker.SetMovement(true);
}
if (!Player.IsDashing() && ECasting && E.Instance.CooldownExpires - Game.Time > 0)
{
ECasting = false;
ETar = null;
}
}
public static AttackableUnit GetTarget()
{
AttackableUnit result = null;
if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.None)
{
return(null);
}
/*Killable Minion*/
if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LaneClear || Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Mixed ||
Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LastHit)
{
foreach (var minion in
ObjectManager.Get <Obj_AI_Minion>()
.Where(
minion =>
minion.IsValidTarget() && Orbwalker.InAutoAttackRange(minion) &&
minion.Health <
2 *
(RealAutoAttack(minion)))
)
{
var t = (int)(Player.AttackCastDelay * 1000) - 100 + Game.Ping / 2 +
1000 * (int)Player.Distance(minion) / (int)Orbwalking.GetMyProjectileSpeed();
var predHealth = HealthPrediction.GetHealthPrediction(minion, t, Program.Config.Item("FarmDelay").GetValue <Slider>().Value);
if (minion.Team != GameObjectTeam.Neutral && MinionManager.IsMinion(minion, true))
{
if (predHealth > 0 && predHealth <= RealAutoAttack(minion))
{
return(minion);
}
}
}
}
/* turrets / inhibitors / nexus */
if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LaneClear)
{
/* turrets */
foreach (var turret in
ObjectManager.Get <Obj_AI_Turret>().Where(t => t.IsValidTarget() && Orbwalker.InAutoAttackRange(t)))
{
return(turret);
}
/* inhibitor */
foreach (var turret in
ObjectManager.Get <Obj_BarracksDampener>().Where(t => t.IsValidTarget() && Orbwalker.InAutoAttackRange(t)))
{
return(turret);
}
/* nexus */
foreach (var nexus in
ObjectManager.Get <Obj_HQ>().Where(t => t.IsValidTarget() && Orbwalker.InAutoAttackRange(t)))
{
return(nexus);
}
}
/*Champions*/
if (Orbwalker.ActiveMode != Orbwalking.OrbwalkingMode.LastHit)
{
var target = TargetSelector.GetTarget(-1, TargetSelector.DamageType.Physical);
if (target.IsValidTarget())
{
return(target);
}
}
/*Jungle minions*/
if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LaneClear || Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Mixed)
{
result =
ObjectManager.Get <Obj_AI_Minion>()
.Where(
mob =>
mob.IsValidTarget() && Orbwalker.InAutoAttackRange(mob) && mob.Team == GameObjectTeam.Neutral)
.MaxOrDefault(mob => mob.MaxHealth);
if (result != null)
{
return(result);
}
}
/*Lane Clear minions*/
if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LaneClear)
{
if (!ShouldWait())
{
if (_prevMinion.IsValidTarget() && Orbwalker.InAutoAttackRange(_prevMinion))
{
var predHealth = HealthPrediction.LaneClearHealthPrediction(
_prevMinion, (int)((Player.AttackDelay * 1000) * 2f), Program.Config.Item("FarmDelay").GetValue <Slider>().Value);
if (predHealth >= 2 * RealAutoAttack(_prevMinion) ||
Math.Abs(predHealth - _prevMinion.Health) < float.Epsilon)
{
return(_prevMinion);
}
}
result = (from minion in
ObjectManager.Get <Obj_AI_Minion>()
.Where(minion => minion.IsValidTarget() && Orbwalker.InAutoAttackRange(minion))
let predHealth =
HealthPrediction.LaneClearHealthPrediction(
minion, (int)((Player.AttackDelay * 1000) * 2f), Program.Config.Item("FarmDelay").GetValue <Slider>().Value)
where
predHealth >= 2 * RealAutoAttack(minion) ||
Math.Abs(predHealth - minion.Health) < float.Epsilon
select minion).MaxOrDefault(m => m.Health);
if (result != null)
{
_prevMinion = (Obj_AI_Minion)result;
}
}
}
return(null);
}
private static void Combo()
{
var target = TargetSelector.GetTarget(Q.Range, TargetSelector.DamageType.Physical);
if (target.IsValidTarget(Q.Range))
{
if (ComboOption.GetBool("ComboAttack") && target.DistanceToPlayer() > Me.AttackRange + Me.BoundingRadius)
{
var minion =
MinionManager.GetMinions(Me.Position, Me.AttackRange + Me.BoundingRadius, MinionTypes.All,
MinionTeam.NotAlly)
.Where(Orbwalker.InAutoAttackRange)
.OrderBy(x => x.DistanceToPlayer())
.FirstOrDefault();
if (minion != null && !minion.IsDead)
{
Orbwalker.Orbwalk(minion, Game.CursorPosition);
}
}
if (ComboOption.UseQ && Q.IsReady() && target.IsValidTarget(Q.Range) &&
!Orbwalker.InAutoAttackRange(target))
{
if (ComboOption.GetBool("ComboMana"))
{
if (Me.Mana > Q.ManaCost + E.ManaCost)
{
var qPred = Q.GetPrediction(target);
if (qPred.Hitchance >= HitChance.VeryHigh)
{
Q.Cast(qPred.CastPosition, true);
}
}
}
else
{
var qPred = Q.GetPrediction(target);
if (qPred.Hitchance >= HitChance.VeryHigh)
{
Q.Cast(qPred.CastPosition, true);
}
}
}
if (ComboOption.UseW && W.IsReady() && Utils.TickCount - LastCastTickW > 2000)
{
if (NavMesh.IsGrass(target.ServerPosition) && !target.IsVisible)
{
if (ComboOption.GetBool("ComboMana"))
{
if (Me.Mana > Q.ManaCost + E.ManaCost * 2 + W.ManaCost + R.ManaCost)
{
W.Cast(target.ServerPosition, true);
}
}
else
{
W.Cast(target.ServerPosition, true);
}
}
}
if (ComboOption.UseE && E.IsReady() && target.IsValidTarget(E.Range) &&
target.HasBuff("kalistaexpungemarker") && Utils.TickCount - lastETime >= 500)
{
if (target.Health < GetRealEDamage(target))
{
E.Cast(true);
}
if (ComboOption.GetBool("ComboEUse") &&
target.DistanceToPlayer() > Orbwalker.GetRealAutoAttackRange(Me) + 100)
{
var EKillMinion = MinionManager.GetMinions(Me.Position, E.Range, MinionTypes.All,
MinionTeam.NotAlly)
.FirstOrDefault(x => x.HasBuff("kalistaexpungemarker") &&
x.DistanceToPlayer() <= E.Range && x.Health < GetRealEDamage(x));
if (EKillMinion != null && EKillMinion.DistanceToPlayer() <= E.Range &&
target.IsValidTarget(E.Range))
{
E.Cast(true);
}
}
}
}
}
private void KillSteal()
{
if (R.Instance.Name == "JhinRShot")
{
return;
}
if (Menu.Item("KillStealQ", true).GetValue <bool>() && Q.IsReady())
{
foreach (
var target in
HeroManager.Enemies.Where(
x => x.IsValidTarget(Q.Range) && x.Health < Me.GetSpellDamage(x, SpellSlot.Q)))
{
if (CheckTarget(target, Q.Range))
{
Q.CastOnUnit(target, true);
}
}
}
if (Menu.Item("KillStealW", true).GetValue <bool>() && W.IsReady())
{
foreach (
var target in
HeroManager.Enemies.Where(
x => x.IsValidTarget(W.Range) && x.Health < Me.GetSpellDamage(x, SpellSlot.W)))
{
if (CheckTarget(target, W.Range))
{
if (target.Health < Me.GetSpellDamage(target, SpellSlot.Q) && Q.IsReady() &&
target.IsValidTarget(Q.Range))
{
return;
}
if (Menu.Item("KillStealWInAttackRange", true).GetValue <bool>() && Orbwalker.InAutoAttackRange(target))
{
W.CastTo(target);
return;
}
if (Orbwalker.InAutoAttackRange(target) && target.Health <= Me.GetAutoAttackDamage(target, true))
{
return;
}
W.CastTo(target);
return;
}
}
}
}
public void farmQ()
{
if (Program.LaneClear)
{
var mobs = Cache.GetMinions(Player.ServerPosition, 800, MinionTeam.Neutral);
if (mobs.Count > 0)
{
var mob = mobs[0];
Q.Cast(mob.Position);
}
}
if (!Orbwalking.CanMove(50) || (Orbwalker.ShouldWait() && Orbwalking.CanAttack()))
{
return;
}
var minions = Cache.GetMinions(Player.ServerPosition, Q.Range);
int orbTarget = 0;
if (Orbwalker.GetTarget() != null)
{
orbTarget = Orbwalker.GetTarget().NetworkId;
}
if (MainMenu.Item("FQ", true).GetValue <bool>())
{
foreach (var minion in minions.Where(minion => minion.IsValidTarget() && orbTarget != minion.NetworkId && !Orbwalker.InAutoAttackRange(minion)))
{
int delay = (int)((minion.Distance(Player) / Q.Speed + Q.Delay) * 1000);
var hpPred = HealthPrediction.GetHealthPrediction(minion, delay);
if (hpPred > 0 && hpPred < Q.GetDamage(minion))
{
if (Q.Cast(minion) == Spell.CastStates.SuccessfullyCasted)
{
return;
}
}
}
}
if (MainMenu.Item("farmQ", true).GetValue <bool>() && !Orbwalking.CanAttack() && FarmSpells)
{
var LCP = MainMenu.Item("LCP", true).GetValue <bool>();
var PT = Game.Time - GetPassiveTime() > -1.5 || !E.IsReady();
foreach (var minion in minions.Where(minion => Orbwalker.InAutoAttackRange(minion)))
{
int delay = (int)((minion.Distance(Player) / Q.Speed + Q.Delay) * 1000);
var hpPred = HealthPrediction.GetHealthPrediction(minion, delay);
if (hpPred < 20)
{
continue;
}
var qDmg = Q.GetDamage(minion);
if (hpPred < qDmg && orbTarget != minion.NetworkId)
{
if (Q.Cast(minion) == Spell.CastStates.SuccessfullyCasted)
{
return;
}
}
else if (PT || LCP)
{
if (minion.HealthPercent > 80)
{
if (Q.Cast(minion) == Spell.CastStates.SuccessfullyCasted)
{
return;
}
}
}
}
}
}
private void LogicQ()
{
var t = TargetSelector.GetTarget(Q.Range, TargetSelector.DamageType.Magical);
if (t.IsValidTarget() && MainMenu.Item("Qon" + t.ChampionName).GetValue <bool>())
{
if (Program.Combo && Player.Mana > RMANA + QMANA + WMANA)
{
Program.CastSpell(Q, t);
}
else if (Program.Harass && OktwCommon.CanHarras() && MainMenu.Item("harassQ", true).GetValue <bool>() &&
MainMenu.Item("Harass" + t.ChampionName).GetValue <bool>() && Player.ManaPercent > MainMenu.Item("QHarassMana", true).GetValue <Slider>().Value)
{
Program.CastSpell(Q, t);
}
else if (OktwCommon.GetKsDamage(t, Q) > t.Health)
{
Program.CastSpell(Q, t);
}
foreach (var enemy in HeroManager.Enemies.Where(enemy => enemy.IsValidTarget(Q.Range) && !OktwCommon.CanMove(enemy)))
{
Program.CastSpell(Q, t);
}
}
if (!OktwCommon.CanHarras())
{
return;
}
if (!Program.None && !Program.Combo && Player.Mana > RMANA + QMANA * 2)
{
var allMinions = Cache.GetMinions(Player.ServerPosition, Q.Range);
if (MainMenu.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 (MainMenu.Item("farmQ", true).GetValue <bool>() && FarmSpells)
{
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;
}
}
var farmPos = Q.GetCircularFarmLocation(allMinions, Q.Width);
if (farmPos.MinionsHit >= MainMenu.Item("QLCminions", true).GetValue <Slider>().Value)
{
Q.Cast(farmPos.Position);
}
}
}
}
private static void OnUpdate(EventArgs args)
{
if (Config.Item("TsAa").GetValue <StringList>().SelectedIndex == 2 || !SebbyLib.Orbwalking.CanAttack() || !Program.Combo)
{
return;
}
var orbT = Orbwalker.GetTarget() as Obj_AI_Hero;
if (orbT != null)
{
var bestTarget = orbT;
if (Config.Item("TsAa").GetValue <StringList>().SelectedIndex == 0)
{
foreach (var enemy in HeroManager.Enemies.Where(enemy => orbT.NetworkId != enemy.NetworkId && enemy.IsValidTarget() && Orbwalker.InAutoAttackRange(enemy)))
{
if (enemy.Health / Player.GetAutoAttackDamage(enemy) < bestTarget.Health / Player.GetAutoAttackDamage(bestTarget))
{
bestTarget = enemy;
}
}
}
else
{
foreach (var enemy in HeroManager.Enemies.Where(enemy => orbT.NetworkId != enemy.NetworkId && enemy.IsValidTarget() && Orbwalker.InAutoAttackRange(enemy)))
{
if (enemy.Health / Player.GetAutoAttackDamage(enemy) < 3)
{
bestTarget = enemy;
break;
}
if (Config.Item("TsAaPriority" + enemy.ChampionName).GetValue <Slider>().Value > Config.Item("TsAaPriority" + bestTarget.ChampionName).GetValue <Slider>().Value)
{
bestTarget = enemy;
}
}
}
if (bestTarget.NetworkId != orbT.NetworkId)
{
Program.debug("force " + bestTarget.ChampionName);
Orbwalker.ForceTarget(bestTarget);
}
}
}
private static void Combo()
{
var target = TargetSelector.GetSelectedTarget() ?? myOrbwalker.GetTarget() as AIHeroClient;
if (ComboOption.UseE && E.IsReady() && !Q.IsCharging)
{
if (target == null || !target.IsValidTarget())
{
target = TargetSelector.GetTarget(E.Range, TargetSelector.DamageType.Physical);
}
if (target.IsValidTarget(E.Range) && GetBuffCount(target) >= ComboOption.GetSlider("ComboPassive") || W.Level == 0 || target.Health < E.GetDamage(target) + GetWDmg(target) || !Orbwalker.InAutoAttackRange(target))
{
SpellManager.PredCast(E, target, true);
return;
}
}
if (ComboOption.UseQ && Q.IsReady())
{
if (target == null || !target.IsValidTarget())
{
target = TargetSelector.GetTarget(1600f, TargetSelector.DamageType.Physical);
}
if (target.IsValidTarget(1600f))
{
if (Q.IsCharging)
{
if (target.IsValidTarget(Q.ChargedMaxRange))
{
SpellManager.PredCast(Q, target);
return;
}
}
else
{
if (GetBuffCount(target) >= ComboOption.GetSlider("ComboPassive") || W.Level == 0 || target.Health < Q.GetDamage(target) + GetWDmg(target))
{
if (target.IsValidTarget(Q.Range))
{
SpellManager.PredCast(Q, target);
}
else
{
Q.StartCharging();
}
return;
}
}
}
else
{
foreach (var t in ObjectManager.Heroes.Enemies.Where(x => !x.IsDead && !x.IsZombie && x.IsValidTarget(1600f)))
{
if (Q.IsCharging)
{
if (t.IsValidTarget(Q.ChargedMaxRange))
{
SpellManager.PredCast(Q, target);
return;
}
}
else
{
if (GetBuffCount(t) >= ComboOption.GetSlider("ComboPassive") || W.Level == 0 || t.Health < Q.GetDamage(t) + GetWDmg(t))
{
if (t.IsValidTarget(Q.Range))
{
SpellManager.PredCast(Q, t);
}
else
{
Q.StartCharging();
}
return;
}
}
}
}
}
if (ComboOption.UseR && R.IsReady())
{
if (target == null || !target.IsValidTarget())
{
target = TargetSelector.GetTarget(R.Range, TargetSelector.DamageType.Physical);
}
if (target.IsValidTarget(R.Range) && ComboOption.GetBool("ComboRSolo") && Me.CountEnemiesInRange(1000) <= 2)
{
if (target.Health + target.HPRegenRate * 2 <
R.GetDamage(target) + W.GetDamage(target) + (E.IsReady() ? E.GetDamage(target) : 0) +
(Q.IsReady() ? Q.GetDamage(target) : 0) + Me.GetAutoAttackDamage(target) * 3)
{
SpellManager.PredCast(R, target);
return;
}
}
var rPred = R.GetPrediction(target, true);
if (rPred.AoeTargetsHitCount >= ComboOption.GetSlider("ComboRCount") ||
Me.CountEnemiesInRange(R.Range) >= ComboOption.GetSlider("ComboRCount"))
{
SpellManager.PredCast(R, target);
}
}
}
