private void OnInterruptableTarget(Obj_AI_Hero target, Interrupter2.InterruptableTargetEventArgs args)
{
if (E.CanCast(target) && config.Item("useEint", true).GetValue<bool>())
{
if (E.CastIfHitchanceEquals(target, HitChance.High, config.Item("packets").GetValue<bool>()))
{
return;
}
}
if (R.CanCast(target) && config.Item("useRint", true).GetValue<bool>())
{
if (savedQ != null && !SimpleQ && !target.IsMoving && target.Distance(qPos) > QExplosionRange &&
target.Distance(player) < R.Range - 100 &&
target.Position.Distance(savedQ.position) < 550 + QExplosionRange / 2 &&
!target.HasBuffOfType(BuffType.Knockback))
{
var cast = Prediction.GetPrediction(target, 1000f).UnitPosition.Extend(savedQ.position, -100);
R.Cast(cast);
}
else if (target.Distance(player) < R.Range - 100)
{
if (player.CountEnemiesInRange(2000) <= player.CountAlliesInRange(2000))
{
var cast = target.Position.Extend(player.Position, -100);
R.Cast(cast);
}
else
{
var cast = target.Position.Extend(player.Position, 100);
R.Cast(cast);
}
}
}
}
public override void Execute(Obj_AI_Hero target)
{
if (target == null)
target = TargetSelector.GetTarget(1200, TargetSelector.DamageType.Magical);
if (target == null) return;
var dmgPerBounce = ObjectManager.Player.GetSpellDamage(target, Slot) + BrandCombo.GetPassiveDamage(target);
if (dmgPerBounce > target.Health && target.Distance(ObjectManager.Player) > 750)
{
TryBridgeUlt(target);
// Console.WriteLine("ayy lmao bridge bois");
}
if (dmgPerBounce > target.Health && !Provider.ShouldBeDead(target) && ObjectManager.Player.GetAutoAttackDamage(target, true) < target.Health && ((_otherSkills.All(skill => skill.Instance.State != SpellState.Ready && skill.Instance.State != SpellState.Surpressed /*&& !skill.IsSafeCasting(1)*/) /*|| target.Distance(ObjectManager.Player) > 650*/) || ObjectManager.Player.GetSpellDamage(target, SpellSlot.Q) + dmgPerBounce + ObjectManager.Player.GetAutoAttackDamage(target) > target.Health && !target.HasBuff("brandablaze") && target.Distance(ObjectManager.Player) < 750))
{
if (ObjectManager.Player.HealthPercent - target.HealthPercent < OverkillPercent || !AntiOverkill || IgnoreAntiOverkillOnFlee && target.Distance(ObjectManager.Player) > ObjectManager.Player.AttackRange)
{
Cast(target);
}
else if (ObjectManager.Player.HealthPercent < target.HealthPercent && IgniteManager.CanBeUsed() && IgniteManager.GetDamage() + dmgPerBounce > target.Health)
{
if (target.Distance(ObjectManager.Player) < 600)
IgniteManager.UseIgnite(target);
Cast(target);
}
}
// if (target.Distance(ObjectManager.Player) > 750) return;
var inBounce = new bool[HeroManager.Enemies.Count];
var canBounce = BounceCheck(target, inBounce);
if (canBounce)
{
var inBounceEnemies = HeroManager.Enemies.Where(enemy => inBounce[HeroManager.Enemies.IndexOf(enemy)]).ToArray();
var distance = target.Distance(ObjectManager.Player);
var bounceCount = inBounce.Count(item => item);
if (bounceCount <= 1) return;
//Console.WriteLine("bounce r " + bounceCount);
if ((inBounceEnemies.Any(enemy => (dmgPerBounce > enemy.Health && MaxDamage > enemy.Health)) && (bounceCount == 2 || RiskyUlt)))
{
TryUlt(target, inBounceEnemies, distance);
}
else if (bounceCount == 2 && dmgPerBounce * 3 > target.Health && MaxDamage > target.Health && distance < 750 && RiskyUlt)
{
Cast(target);
}
else if (dmgPerBounce * 2 > target.Health && MaxDamage > target.Health)
{
TryUlt(target, inBounceEnemies, distance);
}
else if (UltNonKillable && MinBounceTargets <= bounceCount)
{
TryUlt(target, inBounceEnemies, distance, false);
}
}
}
public ChampionInfo(Obj_AI_Hero hero, bool ally)
{
index++;
int textoffset = index * 50;
_hero = hero;
Render.Text text = new Render.Text(
new Vector2(), _hero.ChampionName, 20,
ally
? new Color { R = 205, G = 255, B = 205, A = 255 }
: new Color { R = 255, G = 205, B = 205, A = 255 })
{
PositionUpdate =
() =>
Drawing.WorldToScreen(
ObjectManager.Player.Position.Extend(_hero.Position, 300 + textoffset)),
VisibleCondition = delegate
{
float dist = _hero.Distance(ObjectManager.Player.Position);
return Program.Instance().ShowChampionNames && !_hero.IsDead &&
Game.ClockTime - _lineStart < Program.Instance().LineDuration &&
(!_hero.IsVisible || !Render.OnScreen(Drawing.WorldToScreen(_hero.Position))) &&
dist < Program.Instance().Radius && dist > 300 + textoffset;
},
Centered = true,
OutLined = true,
};
text.Add(1);
_line = new Render.Line(
new Vector2(), new Vector2(), 5,
ally ? new Color { R = 0, G = 255, B = 0, A = 125 } : new Color { R = 255, G = 0, B = 0, A = 125 })
{
StartPositionUpdate = () => Drawing.WorldToScreen(ObjectManager.Player.Position),
EndPositionUpdate = () => Drawing.WorldToScreen(_hero.Position),
VisibleCondition =
delegate
{
return !_hero.IsDead && Game.ClockTime - _lineStart < Program.Instance().LineDuration &&
_hero.Distance(ObjectManager.Player.Position) < (Program.Instance().Radius + 1000);
}
};
_line.Add(0);
Render.Line minimapLine = new Render.Line(
new Vector2(), new Vector2(), 2,
ally ? new Color { R = 0, G = 255, B = 0, A = 255 } : new Color { R = 255, G = 0, B = 0, A = 255 })
{
StartPositionUpdate = () => Drawing.WorldToMinimap(ObjectManager.Player.Position),
EndPositionUpdate = () => Drawing.WorldToMinimap(_hero.Position),
VisibleCondition =
delegate
{
return Program.Instance().DrawMinimapLines && !_hero.IsDead && Game.ClockTime - _lineStart < Program.Instance().LineDuration;
}
};
minimapLine.Add(0);
Game.OnUpdate += Game_OnGameUpdate;
OnEnterRange += ChampionInfo_OnEnterRange;
}
public override void Cast(Obj_AI_Hero target, bool force = false, HitChance minChance = HitChance.Low)
{
if (target == null) return;
if (ObjectManager.Player.HasBuff("ekkoattackbuff") && target.Distance(ObjectManager.Player) < 500)
{
ObjectManager.Player.IssueOrder(GameObjectOrder.AutoAttack, target);
}
if (HasBeenSafeCast() || target.Distance(ObjectManager.Player) < ObjectManager.Player.AttackRange + ObjectManager.Player.BoundingRadius + target.BoundingRadius) return;
SafeCast(() => Spell.Cast(target.Position));
}
public static Obj_AI_Base QMinion(Obj_AI_Hero t)
{
var m = MinionManager.GetMinions(ObjectManager.Player.ServerPosition, Q.Range, MinionTypes.All,
MinionTeam.NotAlly, MinionOrderTypes.None);
return (from vM
in m.Where(vM => vM.IsValidTarget(Q.Range))
let endPoint = vM.ServerPosition.To2D().Extend(ObjectManager.Player.ServerPosition.To2D(), -Q2.Range).To3D()
where
vM.Distance(t) <= t.Distance(ObjectManager.Player) &&
Intersection(ObjectManager.Player.ServerPosition.To2D(), endPoint.To2D(), t.ServerPosition.To2D(), t.BoundingRadius + vM.BoundingRadius)
//Intersection(ObjectManager.Player.ServerPosition.To2D(), endPoint.To2D(), t.ServerPosition.To2D(), t.BoundingRadius + Q.Width/4)
select vM).FirstOrDefault();
//get
//{
// var vTarget = TargetSelector.GetTarget(Q2.Range, TargetSelector.DamageType.Physical);
// var vMinions = MinionManager.GetMinions(
// ObjectManager.Player.ServerPosition, Q.Range, MinionTypes.All, MinionTeam.NotAlly,
// MinionOrderTypes.None);
// return (from vMinion in vMinions.Where(vMinion => vMinion.IsValidTarget(Q.Range))
// let endPoint =
// vMinion.ServerPosition.To2D()
// .Extend(ObjectManager.Player.ServerPosition.To2D(), -Q2.Range)
// .To3D()
// where
// vMinion.Distance(vTarget) <= vTarget.Distance(ObjectManager.Player) &&
// Intersection(ObjectManager.Player.ServerPosition.To2D(), endPoint.To2D(),
// vTarget.ServerPosition.To2D(), vTarget.BoundingRadius + vMinion.BoundingRadius)
// select vMinion).FirstOrDefault();
//}
}
public static void doCombo(Obj_AI_Hero target)
{
igniteIfKIllable(target);
if (!target.IsValidTarget())
return;
if (!W.IsReady() && !E.IsReady() && R.IsReady() && Rdata.Name == "TalonShadowAssault" && (target.Health > getAAdmg(target) || targetInRange(target, 125f))
&& target.Health<(getRdmg(target)*2 + getTargetBleedDmg(target)))
{
PredictionOutput po = R.GetPrediction(target);
if (po.Hitchance >= HitChance.Medium)
{
R.Cast();
posRCast = Player.ServerPosition;
}
}
if (Rdata.Name == "TalonShadowAssault")
{
if (target.Health<= getRdmg(target) && target.Distance(posRCast) < R.Range)
R.Cast();
}
if (E.IsReady() && targetInRange(target, E.Range))
{
E.Cast(target);
}
if (W.IsReady() && !E.IsReady() && targetInRange(target, W.Range) && !targetInRange(target, 100) && !Player.IsChanneling
&& (!targetInRange(target,250) || targetHasCut(target)))
{
W.Cast(target);
}
castItemsFull(target);
}
public float GetComboDamage(Obj_AI_Hero target)
{
if (target == null) return 0;
float comboDmg = 0;
var aaDmg = (float)ObjectManager.Player.GetAutoAttackDamage(target, true);
if (qSpell.Spell.IsReady())
{
comboDmg += qSpell.GetDamage(target) + aaDmg;
}
if (wSpell.Spell.IsReady())
{
comboDmg += wSpell.Spell.GetDamage(target) + aaDmg;
}
if (eSpell.Spell.IsReady())
{
comboDmg += aaDmg;
}
if (target.Distance(ObjectManager.Player) >= 900 && rSpell.Spell.IsReady())
{
comboDmg += rSpell.GetDamage(target);
}
return comboDmg;
}
void CastE(Obj_AI_Hero target)
{
if (target != null)
{
if (SpellSlot.E.IsReady() && isHealthy)
{
if (DashCount >= 1 && GetDashPos(target).IsCloser(target) && target.IsDashable() &&
(GetBool("Combo.ETower") || GetKeyBind("Misc.TowerDive") || !GetDashPos(target).PointUnderEnemyTurret()))
{
Spells[E].CastOnUnit(target);
return;
}
if (DashCount == 0)
{
var dist = Yasuo.Distance(target);
var bestminion =
ObjectManager.Get<Obj_AI_Base>()
.Where(
x =>
x.IsDashable()
&& target.Distance(GetDashPos(x)) < dist &&
(GetBool("Combo.ETower") || GetKeyBind("Misc.TowerDive") || !GetDashPos(x).PointUnderEnemyTurret()))
.OrderBy(x => Vector2.Distance(GetDashPos(x), target.ServerPosition.To2D()))
.FirstOrDefault();
if (bestminion != null)
{
Spells[E].CastOnUnit(bestminion);
}
else
{
var minion =
ObjectManager.Get<Obj_AI_Base>()
.Where(x => x.IsDashable() && (GetBool("Combo.ETower") || GetKeyBind("Misc.TowerDive") || !GetDashPos(x).PointUnderEnemyTurret()))
.OrderBy(x => GetDashPos(x).Distance(target)).FirstOrDefault();
if (minion != null && GetDashPos(minion).IsCloser(target))
{
Spells[E].CastOnUnit(minion);
}
}
}
else
{
var minion =
ObjectManager.Get<Obj_AI_Base>()
.Where(x => x.IsDashable() && (GetBool("Combo.ETower") || GetKeyBind("Misc.TowerDive") || !GetDashPos(x).PointUnderEnemyTurret()))
.OrderBy(x => GetDashPos(x).Distance(target)).FirstOrDefault();
if (minion != null && GetDashPos(minion).IsCloser(target))
{
Spells[E].CastOnUnit(minion);
}
}
}
}
}
public void Update(Obj_AI_Hero target)
{
if ((target.HealthPercent >= _minEnemyHealth || ObjectManager.Player.HealthPercent < 20) && ObjectManager.Player.HealthPercent <= _maxPlayerHealth && target.Distance(ObjectManager.Player) < 550)
{
Use(target);
}
}
public static void WardJumpFlashInsec(Obj_AI_Hero enemy)
{
if (Config.Item("insec.whitelist." + enemy.ChampionName).GetValue<bool>() && HybridCommon.Utility.GetPriority(enemy.ChampionName) > 2)
{
if (ObjectManager.Player.Distance(enemy.Position) > Spells[Q].Range &&
ObjectManager.Player.Distance(enemy.Position) < Spells[Q].Range + 600 && WardJump.WardCastable)
{
WardJump.HikiJump(Spells[W], Helper.WardJumpToEnemy(enemy, 600));
}
if (enemy.Distance(LeeSin.Position) < Spells[Q].Range && Spells[Q].GetPrediction(enemy).Hitchance > HitChance.High)
{
Spells[Q].Cast(enemy);
}
if (Helper.QTwo(Spells[Q]) && Spells[Q2].IsReady())
{
Spells[Q2].Cast();
}
if (Flashable && LeeSin.Distance(Helper.InsecPositions()) < FlashRange)
{
Utility.DelayAction.Add(Helper.SliderCheck("flash.insec.flash.delay"),
() => LeeSin.Spellbook.CastSpell(FlashSlot, Helper.InsecPositions()));
}
if (LeeSin.Spellbook.CanUseSpell(FlashSlot) == SpellState.Cooldown && !Spells[Q].IsReady() &&
LeeSin.Distance(enemy.Position) < Spells[R].Range)
{
Spells[R].Cast(enemy);
}
}
}
public override void Interruptable(ComboProvider combo, Obj_AI_Hero sender, ComboProvider.InterruptableSpell interruptableSpell, float endTime)
{
if (endTime - Game.Time > Math.Max(sender.Distance(ObjectManager.Player) - Orbwalking.GetRealAutoAttackRange(sender), 0)/ObjectManager.Player.MoveSpeed + 0.5f)
{
SafeCast();
Orbwalking.Orbwalk(sender, sender.Position);
}
}
public override void Interruptable(ComboProvider combo, Obj_AI_Hero sender, ComboProvider.InterruptableSpell interruptableSpell, float endTime)
{
var distance = sender.Distance(ObjectManager.Player);
if (sender.HasBuff("brandablaze") || Provider.IsMarked(sender) || !_brandQ.CouldHit(sender) || !InterruptW) return;
if (Cast(sender) == CastStates.SuccessfullyCasted)
Provider.SetMarked(sender); //Todo: risky, keep an eye on this. If the W misses u r f****d
}
private void Interrupter2_OnInterruptableTarget(Obj_AI_Hero sender,
Interrupter2.InterruptableTargetEventArgs args)
{
if (R.IsReady() && config.Item("Interrupt", true).GetValue<bool>() && sender.Distance(player) < R.Range)
{
CastR();
}
}
//Credits to metaphorce
public static void UseSmite(Obj_AI_Hero target)
{
var usesmite = Config.Item("UseS").GetValue<bool>();
var itemscheck = SmiteBlue.Any(i => Items.HasItem(i)) || SmiteRed.Any(i => Items.HasItem(i));
if (itemscheck && usesmite &&
ObjectManager.Player.Spellbook.CanUseSpell(_smiteSlot) == SpellState.Ready &&
target.Distance(player.Position) < _smite.Range)
{
ObjectManager.Player.Spellbook.CastSpell(_smiteSlot, target);
}
}
private static void IgniteOnTarget(Obj_AI_Hero t)
{
var range = 550f;
var use = menu.Item("Spells.Ignite").GetValue<bool>();
if (use && Program.Player.Spellbook.CanUseSpell(IgniteSlot) == SpellState.Ready &&
t.Distance(Program.Player.Position) < range &&
Program.Player.GetSummonerSpellDamage(t, Damage.SummonerSpell.Ignite) > t.Health)
{
Program.Player.Spellbook.CastSpell(IgniteSlot, t);
}
}
public static void Insec(Obj_AI_Hero target)
{
Rpos = Player.Position.To2D().Extend(target.Position.To2D(), Player.Distance(target) + 250);
if (Rpos.Distance(Player.Position) <= R.Range)
{
if (Player.Distance(Rpos.Extend(target.Position.To2D(), 700 - target.Distance(Rpos))) < E.Range && !IsWall(Rpos.To3D()) && target.IsFacing(Player))
{
R.Cast(Rpos);
}
}
}
public static Vector3 GetInsecPos(Obj_AI_Hero target)
{
try
{
if (ClicksecEnabled && Misc.GetMenuItem("clickInsec"))
{
InsecLinePos = Drawing.WorldToScreen(InsecClickPos);
return V2E(InsecClickPos, target.Position, target.Distance(InsecClickPos) + 230).To3D();
}
if (isNullInsecPos)
{
isNullInsecPos = false;
insecPos = ObjectManager.Player.Position;
}
if ((GetAllyHeroes(target, 1500).Count > 0) && Misc.GetMenuItem("ElLeeSin.Insec.Ally"))
{
var insecPosition = InterceptionPoint(GetAllyInsec(GetAllyHeroes(target, 2000)));
InsecLinePos = Drawing.WorldToScreen(insecPosition);
return V2E(insecPosition, target.Position, target.Distance(insecPosition) + 230).To3D();
}
if (Misc.GetMenuItem("ElLeeSin.Insec.Tower"))
{
var tower =
ObjectManager.Get<Obj_AI_Turret>()
.Where(
t =>
t.IsVisible && t.Health > 0 && t.Distance(target) - 725 < 1100 && t.Distance(ObjectManager.Player) < 3000
&& t.IsAlly && !t.IsDead)
.MinOrDefault(t => t.Distance(target));
if (tower != null)
{
InsecLinePos = Drawing.WorldToScreen(tower.Position);
return V2E(tower.Position, target.Position, target.Distance(tower.Position) + 230).To3D();
}
}
if (Misc.GetMenuItem("ElLeeSin.Insec.Original.Pos"))
{
InsecLinePos = Drawing.WorldToScreen(insecPos);
return V2E(insecPos, target.Position, target.Distance(insecPos) + 230).To3D();
}
return new Vector3();
}
catch (Exception e)
{
Console.WriteLine("An error occurred: '{0}'", e);
}
return new Vector3();
}
private void Interrupter2_OnInterruptableTarget(Obj_AI_Hero sender, Interrupter2.InterruptableTargetEventArgs args)
{
if (!Config.Item("OPTI", true).GetValue<bool>())
return;
if (R.IsReady() && sender.Distance(BallPos) < R.Range)
{
R.Cast();
Program.debug("interupt");
}
else if (Q.IsReady() && Player.Mana > RMANA + QMANA && sender.IsValidTarget(Q.Range))
Q.Cast(sender.ServerPosition);
}
public static void JumpKs(Obj_AI_Hero target)
{
foreach (Obj_AI_Minion ward in ObjectManager.Get<Obj_AI_Minion>().Where(ward =>
E.IsReady() && Q.IsReady() && ward.Name.ToLower().Contains("ward") &&
ward.Distance(target.ServerPosition) < Q.Range && ward.Distance(Player.Position) < E.Range))
{
E.Cast(ward);
return;
}
foreach (Obj_AI_Hero hero in ObjectManager.Get<Obj_AI_Hero>().Where(hero =>
E.IsReady() && Q.IsReady() && hero.Distance(target.ServerPosition) < Q.Range &&
hero.Distance(Player.Position) < E.Range && hero.IsValidTarget(E.Range)))
{
E.Cast(hero);
return;
}
foreach (Obj_AI_Minion minion in ObjectManager.Get<Obj_AI_Minion>().Where(minion =>
E.IsReady() && Q.IsReady() && minion.Distance(target.ServerPosition) < Q.Range &&
minion.Distance(Player.Position) < E.Range && minion.IsValidTarget(E.Range)))
{
E.Cast(minion);
return;
}
if (Player.Distance(target.Position) < Q.Range)
{
Q.Cast(target);
return;
}
if (E.IsReady() && Q.IsReady())
{
Vector3 position = Player.ServerPosition +
Vector3.Normalize(target.ServerPosition - Player.ServerPosition) * 590;
if (target.Distance(position) < Q.Range)
{
InventorySlot invSlot = FindBestWardItem();
if (invSlot == null) return;
Player.Spellbook.CastSpell(invSlot.SpellSlot, position);
LastWardPos = position;
LastPlaced = Utils.TickCount;
}
}
if (Player.Distance(target.Position) < Q.Range)
{
Q.Cast(target);
}
}
public static bool IsValidTarget(Obj_AI_Hero target)
{
if (!IsWhitelisted(target))
return false;
var targetPosition = Geometry.PositionAfter(target.GetWaypoints(), 300, (int)target.MoveSpeed);
if (target.Distance(ObjectManager.Player.ServerPosition) < 650f && IsCondemnable(ObjectManager.Player.ServerPosition.To2D(), targetPosition, target.BoundingRadius))
{
if (target.Path.Length == 0)
{
var outRadius = (0.3f * target.MoveSpeed) / (float)Math.Cos(2 * Math.PI / 12);
int count = 0;
for (int i = 1; i <= 12; i++)
{
var angle = i * 2 * Math.PI / 12;
float x = target.Position.X + outRadius * (float)Math.Cos(angle);
float y = target.Position.Y + outRadius * (float)Math.Sin(angle);
if (IsCondemnable(ObjectManager.Player.ServerPosition.To2D(), new Vector2(x, y), target.BoundingRadius))
count++;
}
return count >= 4;
}
else
return true;
}
else
{
if (TumbleCondemn && s_Champion.Spells[Champion.Q].IsReady())
{
var outRadius = 300 / (float)Math.Cos(2 * Math.PI / 12);
for (int i = 1; i <= 12; i++)
{
var angle = i * 2 * Math.PI / 12;
float x = ObjectManager.Player.Position.X + outRadius * (float)Math.Cos(angle);
float y = ObjectManager.Player.Position.Y + outRadius * (float)Math.Sin(angle);
targetPosition = Geometry.PositionAfter(target.GetWaypoints(), 300, (int)target.MoveSpeed);
if (targetPosition.Distance(new Vector2(x, y)) < 550f && IsCondemnable(new Vector2(x, y), targetPosition, target.BoundingRadius, 300f))
{
s_Champion.Spells[Champion.Q].Cast(new Vector2(x, y));
return false;
}
}
return false;
}
}
return false;
}
internal static bool CanR(Obj_AI_Hero unit)
{
if (Me.HealthPercent <= 35 && unit.Distance(Me.ServerPosition) <= Me.AttackRange + 65)
{
return true;
}
if (unit.IsZombie || TargetSelector.IsInvulnerable(unit, TargetSelector.DamageType.Physical))
{
return false;
}
if (unit.CountAlliesInRange(400) >= 2 &&
Me.GetAutoAttackDamage(unit, true) * 6 >= unit.Health)
{
return false;
}
if (Orbwalking.InAutoAttackRange(unit) &&
Me.GetAutoAttackDamage(unit, true) * 3 >= unit.Health)
{
return false;
}
if (Buckshot.IsReady() && unit.Distance(Me.ServerPosition) <= Buckshot.Range &&
Buckshot.GetDamage(unit) >= unit.Health)
{
return false;
}
if (Quickdraw.IsReady() && unit.Distance(Me.ServerPosition) <= Quickdraw.Range + 25 &&
Me.GetAutoAttackDamage(unit, true) * 3 >= unit.Health)
{
return false;
}
return true;
}
private void Interrupter2_OnInterruptableTarget(Obj_AI_Hero sender,
Interrupter2.InterruptableTargetEventArgs args)
{
var dist = sender.Distance(player) < 750;
if (E.IsReady() && config.Item("Interrupt", true).GetValue<bool>() && dist && CanStun(sender))
{
E.Cast(config.Item("packets").GetValue<bool>());
}
if (stance == Stance.Bear && dist && CanStun(sender))
{
orbwalker.ForceTarget(sender);
player.IssueOrder(GameObjectOrder.AttackTo, sender);
}
}
public static double CalcDamage(Obj_AI_Hero enemy)
{
double damage = 0;
if (enemy.GetBuffCount("EkkoStacks") == 2)
damage += 10 + 10 * Player.Level + 0.7 * Player.TotalMagicalDamage;
if (SpellManager.Q.IsReady())
damage += 45 + SpellManager.Q.Level * 15 + Player.TotalMagicalDamage * 0.1;
if (SpellManager.E.IsReady() || Player.HasBuff("ekkoeattackbuff"))
damage += 20 + SpellManager.E.Level * 30 + Player.TotalMagicalDamage() * 0.2;
if (EkkoUlt != null)
if (enemy.Distance(EkkoUlt.Position) <= SpellManager.R.Range)
damage += Rdamage();
return Player.CalcDamage(enemy, Damage.DamageType.Magical, damage);
}
public void AutoInterrupter(Obj_AI_Hero sender, Interrupter2.InterruptableTargetEventArgs args)
{
if (!DelayHandler.CheckInterrption()) return;
DelayHandler.UseInterrption();
// Game.PrintChat($"{sender.ChampionName}");
if (!SMenu.Item(MenuItemBase + "Boolean.AntiGapClose.Use.On." + sender.ChampionName).GetValue<bool>()) return;
if (!Champion.GetSpellR.IsReady()) return;
if (sender.Distance(Champion.Player) > Champion.GetSpellR.Range) return;
Logger.WriteLog($"Interrupt Cast R on : {sender}");
Champion.GetSpellR.Cast(sender);
}
// Ward position, flash position, position to be in when you have to cast r, if a parameter is not applicable eg flash pos without having flash than this param will be set to new Vector3(nullptr)
// Func will return null when no position is found
public static Tuple<Vector3, Vector3, Vector3> GetWardFlashPositions(bool canUseWard, bool canUseFlash, Obj_AI_Hero player, byte minHitRequirement, List<Obj_AI_Hero> enemies)
{
float maxTravelDistance = GetMaxTravelDistance(canUseWard, canUseFlash);
Vector3 destination = SelectBest(GetPositions(player, maxTravelDistance, minHitRequirement, enemies),player);
if (destination == new Vector3(null))
{
return null;
}
bool useWard, useFlash;
if (maxTravelDistance == 187.5f)
{
useWard = false;
useFlash = false;
}
else
{
if (player.Distance(destination) <= 600f)
{
useWard = true;
useFlash = false;
}
else
{
useWard = true;
useFlash = true;
}
}
Vector3 wardPos = new Vector3(null), flashPos = new Vector3(null);
if (useWard && useFlash)
{
wardPos = MoveVector(player.ServerPosition, destination, 600f);
flashPos = destination;
}
if (useWard && !useFlash)
{
wardPos = destination;
}
return new Tuple<Vector3, Vector3, Vector3>(wardPos, flashPos, destination);
}
//private static void OnProcessCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
//{
// if (args.Slot == SpellSlot.Q)
// {
// Game.PrintChat(args.SData.DelayCastOffsetPercent.ToString());
// }
//}
//private static void OnCreate(GameObject sender, EventArgs args)
//{
// var sen = (MissileClient) sender;
// if (sen == null) return;
// Game.PrintChat(sen.SData.LineMissileTimePulseBetweenCollisionSpellHits.ToString());
//}
private static void OnInterrupt(Obj_AI_Hero sender, Interrupter2.InterruptableTargetEventArgs args)
{
if (!GetBool("autoeint", typeof(bool))) return;
if (sender.IsMe || sender.IsAlly) return;
if (sender.Distance(Player) < Em.Range)
{
if (!Ismelee())
{
R.Cast();
}
if (Ismelee())
{
Em.Cast(sender);
}
}
}
public static Vector3 GetDashPosition(Spell spell, Obj_AI_Hero target, float safetyDistance)
{
var distance = target.Distance(ObjectManager.Player);
var dashPoints = new Geometry.Polygon.Circle(ObjectManager.Player.Position, spell.Range).Points;
if (distance < safetyDistance)
{
dashPoints.AddRange(
new Geometry.Polygon.Circle(ObjectManager.Player.Position, safetyDistance - distance).Points);
}
dashPoints = dashPoints.Where(p => !p.IsWall()).OrderBy(p => p.Distance(Game.CursorPos)).ToList();
foreach (var point in dashPoints)
{
var allies =
GameObjects.AllyHeroes.Where(
hero => !hero.IsDead && hero.Distance(point.To3D()) < ObjectManager.Player.AttackRange).ToList();
var enemies =
GameObjects.EnemyHeroes.Where(
hero => hero.IsValidTarget(ObjectManager.Player.AttackRange, true, point.To3D())).ToList();
var lowEnemies = enemies.Where(hero => hero.HealthPercent <= 15).ToList();
if (!point.To3D().IsUnderTurret(false))
{
if (enemies.Count == 1 &&
(!target.IsMelee ||
(target.HealthPercent <= ObjectManager.Player.HealthPercent - 25 ||
target.Position.Distance(point.To3D()) >= safetyDistance)) ||
allies.Count >
enemies.Count -
(ObjectManager.Player.HealthPercent >= (10 * lowEnemies.Count) ? lowEnemies.Count : 0))
{
return point.To3D();
}
}
else
{
if (enemies.Count == 1 && lowEnemies.Any(t => t.NetworkId.Equals(target.NetworkId)))
{
return point.To3D();
}
}
}
return Vector3.Zero;
}
public override void Execute(Obj_AI_Hero target)
{
var distance = target.Distance(ObjectManager.Player); //Todo: make him use fireminions even in range, just for showoff and potential AOE. Check if hes on fire too though
if (distance < 950 && distance > 650 && UseMinions)
{
var fireMinion = MinionManager.GetMinions(650, MinionTypes.All, MinionTeam.NotAlly, MinionOrderTypes.None).Where(minion => minion.HasBuff("brandablaze") && minion.Distance(target) < 300).MinOrDefault(minion => minion.Distance(target));
if (fireMinion != null)
{
if (Cast(fireMinion) == CastStates.SuccessfullyCasted && !target.HasSpellShield())
Provider.SetMarked(target);
}
}
if (distance < 650)
{
if (Cast(target) == CastStates.SuccessfullyCasted && !target.HasSpellShield())
Provider.SetMarked(target);
}
}
public static void doCombo(Obj_AI_Hero target)
{
try
{
if (target == null || !target.IsValid)
return;
if (LXOrbwalker.ForcedTarget != null && LXOrbwalker.ForcedTarget is Obj_AI_Hero)
target = (Obj_AI_Hero)LXOrbwalker.ForcedTarget;
useItems(target);
if(target.Distance(player)>750 && !player.IsDashing() && LucianSharp.Config.Item("useQ").GetValue<bool>())
useQonTarg(target,QhitChance.medium);
//if(W.IsReady())
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
internal static bool IsValidTarget(Obj_AI_Hero target,
float range,
DamageType damageType,
bool ignoreShields = true,
Vector3 from = default(Vector3))
{
try
{
return target.IsValidTarget() &&
target.Distance(
(from.Equals(default(Vector3)) ? ObjectManager.Player.ServerPosition : from), true) <
Math.Pow((range <= 0 ? Orbwalking.GetRealAutoAttackRange(target) : range), 2) &&
!Invulnerable.Check(target, damageType, ignoreShields);
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
return false;
}
private static void Game_OnGameUpdate(EventArgs args)
{
ManaMenager();
if (Orbwalker.ActiveMode.ToString() == "Mixed" || Orbwalker.ActiveMode.ToString() == "LaneClear" || Orbwalker.ActiveMode.ToString() == "LastHit")
{
Farm = true;
}
else
{
Farm = false;
}
if (W.IsReady())
{
var t = TargetSelector.GetTarget(W.Range, TargetSelector.DamageType.Magical);
if (t.IsValidTarget())
{
if (W.GetDamage(t) > t.Health)
{
W.Cast(t, true, true);
OverKill = Game.Time;
return;
}
else if (Orbwalker.ActiveMode.ToString() == "Combo" && ObjectManager.Player.Mana > RMANA + QMANA + EMANA + WMANA)
{
W.Cast(t, true, true);
}
else if (Orbwalker.ActiveMode.ToString() == "Combo" && ObjectManager.Player.Mana > RMANA + WMANA + QMANA + 5 &&
GetRealDistance(t) > GetRealRange(t))
{
W.Cast(t, true, true);
}
else if (Orbwalker.ActiveMode.ToString() == "Combo" && ObjectManager.Player.Mana > RMANA + QMANA + WMANA &&
ObjectManager.Player.CountEnemiesInRange(300) > 0)
{
W.Cast(t, true, true);
}
else if (Orbwalker.ActiveMode.ToString() == "Combo" && ObjectManager.Player.Mana > RMANA + WMANA + EMANA &&
ObjectManager.Player.Health < ObjectManager.Player.MaxHealth * 0.4)
{
W.Cast(t, true, true);
}
else if ((Orbwalker.ActiveMode.ToString() == "Combo" || Farm) && ObjectManager.Player.Mana > RMANA + QMANA + WMANA)
{
foreach (var enemy in ObjectManager.Get <Obj_AI_Hero>().Where(enemy => enemy.IsValidTarget(Q.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, true);
}
}
}
}
}
if (E.IsReady() && Config.Item("autoE").GetValue <bool>())
{
ManaMenager();
var t = TargetSelector.GetTarget(E.Range + Q.Range - 100f, TargetSelector.DamageType.Physical);
var t2 = TargetSelector.GetTarget(900f, TargetSelector.DamageType.Physical);
if (Orbwalker.ActiveMode.ToString() == "Combo" && ObjectManager.Player.Health > ObjectManager.Player.MaxHealth * 0.4 && !ObjectManager.Player.UnderTurret(true))
{
if (t.IsValidTarget() &&
Q.IsReady() &&
ObjectManager.Player.Mana > RMANA + EMANA &&
Q.GetDamage(t) > t.Health &&
GetRealDistance(t) > GetRealRange(t) &&
t.CountEnemiesInRange(800) < 3)
{
E.Cast(Game.CursorPos, true);
return;
}
else if (t2.IsValidTarget() &&
ObjectManager.Player.Mana > QMANA + RMANA &&
ObjectManager.Player.GetAutoAttackDamage(t2) * 2 > t2.Health &&
GetRealDistance(t2) > GetRealRange(t2) &&
t2.CountEnemiesInRange(800) < 3)
{
E.Cast(Game.CursorPos, true);
return;
}
else if (t.IsValidTarget() &&
Q.IsReady() && R.IsReady() &&
ObjectManager.Player.Mana > RMANA + EMANA + RMANA &&
Q.GetDamage(t) + R.GetDamage(t) > t.Health &&
R.GetDamage(t) < t.Health &&
GetRealDistance(t) > GetRealRange(t) &&
t.CountEnemiesInRange(800) < 3)
{
E.Cast(Game.CursorPos, true);
return;
}
}
}
if (Q.IsReady())
{
ManaMenager();
var t = TargetSelector.GetTarget(Q1.Range, TargetSelector.DamageType.Physical);
if (t.IsValidTarget())
{
if (Q.GetDamage(t) > t.Health)
{
Q1.Cast(t, true);
OverKill = Game.Time;
return;
}
if (R.GetDamage(t) + Q.GetDamage(t) > t.Health && R.IsReady() && ObjectManager.Player.Mana > RMANA + QMANA)
{
Q1.Cast(t, true);
}
else if (Orbwalker.ActiveMode.ToString() == "Combo" && ObjectManager.Player.Mana > RMANA + QMANA + EMANA)
{
Q.Cast(t, true, true);
}
else if ((Farm && ObjectManager.Player.Mana > RMANA + EMANA + WMANA + QMANA + QMANA) && Orbwalker.GetTarget() == null)
{
if (ObjectManager.Player.Mana > ObjectManager.Player.MaxMana * 0.9)
{
Q.Cast(t, true, true);
}
else if (t.Path.Count() > 1)
{
Q.Cast(t, true, true);
}
}
else if ((Orbwalker.ActiveMode.ToString() == "Combo" || Farm) && ObjectManager.Player.Mana > RMANA + QMANA)
{
foreach (var enemy in ObjectManager.Get <Obj_AI_Hero>().Where(enemy => enemy.IsValidTarget(Q.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"))
{
Q1.CastIfHitchanceEquals(enemy, HitChance.High, true);
}
}
}
}
}
if (R.IsReady() && Config.Item("autoR").GetValue <bool>() && (Game.Time - OverKill > 0.5))
{
bool cast = false;
foreach (var target in ObjectManager.Get <Obj_AI_Hero>().Where(target => target.IsValidTarget(R1.Range)))
{
if (target.IsValidTarget() &&
R.GetDamage(target) > target.Health &&
!target.HasBuffOfType(BuffType.PhysicalImmunity) &&
!target.HasBuffOfType(BuffType.SpellImmunity) &&
!target.HasBuffOfType(BuffType.SpellShield))
{
float predictedHealth = HealthPrediction.GetHealthPrediction(target, (int)(R.Delay + (Player.Distance(target.ServerPosition) / R.Speed) * 1000));
var Rdmg = R.GetDamage(target);
var collisionTarget = target;
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 < (200 + enemy.BoundingRadius) && Player.Distance(predictedPosition) < Player.Distance(target.ServerPosition))
{
cast = false;
collisionTarget = enemy;
}
}
if (cast &&
target.IsValidTarget() &&
Rdmg > predictedHealth &&
target.IsValidTarget(R.Range) &&
((GetRealDistance(target) > GetRealRange(target) && target.CountAlliesInRange(300) == 0) || ObjectManager.Player.Health < ObjectManager.Player.MaxHealth * 0.5))
{
R.Cast(target, true);
}
else if (cast &&
Rdmg * 0.6 > predictedHealth &&
target.CountAlliesInRange(300) == 0 &&
target.IsValidTarget(R1.Range) &&
((GetRealDistance(target) > GetRealRange(target) && target.CountAlliesInRange(300) == 0) || ObjectManager.Player.Health < ObjectManager.Player.MaxHealth * 0.5))
{
R1.CastIfHitchanceEquals(target, HitChance.High, true);
}
else if (!cast && Rdmg * 0.6 > predictedHealth &&
target.CountAlliesInRange(300) == 0 &&
target.IsValidTarget(GetRealDistance(collisionTarget) + 700) &&
((GetRealDistance(target) > GetRealRange(target) && target.CountAlliesInRange(300) == 0) || ObjectManager.Player.Health < ObjectManager.Player.MaxHealth * 0.5))
{
R1.CastIfHitchanceEquals(target, HitChance.High, true);
}
}
}
}
PotionMenager();
}
public virtual AttackableUnit GetTarget()
{
AttackableUnit result = null;
if ((ActiveMode == OrbwalkingMode.Mixed || ActiveMode == OrbwalkingMode.LaneClear) &&
!_config.Item("PriorizeFarm").GetValue <bool>())
{
var target = TargetSelector.GetTarget(-1);
if (target != null)
{
return(target);
}
}
/*Killable Minion*/
if (ActiveMode == OrbwalkingMode.LaneClear || ActiveMode == OrbwalkingMode.Mixed ||
ActiveMode == OrbwalkingMode.LastHit)
{
var MinionList =
ObjectManager.Get <Obj_AI_Minion>()
.Where(
minion =>
minion.IsValidTarget() && InAutoAttackRange(minion) &&
minion.Health <
2 *
(ObjectManager.Player.BaseAttackDamage + ObjectManager.Player.FlatPhysicalDamageMod));
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 (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
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);
if (target.IsValidTarget())
{
if (target.IsMelee && Items.HasItem((int)ItemId.Thornmail, target) && target.HealthPercent > Player.HealthPercent && Player.HealthPercent < 20)
{
return
(MinionManager.GetMinions(Player.ServerPosition, Orbwalking.GetRealAutoAttackRange(null))
.OrderBy(m => m.Armor)
.FirstOrDefault() ?? target);
}
else
{
return(target);
}
}
}
if (ActiveMode == OrbwalkingMode.Combo && Items.HasItem((int)ItemId.The_Bloodthirster, Player))
{
var minion =
MinionManager.GetMinions(Player.ServerPosition, GetRealAutoAttackRange(null))
.OrderBy(m => m.Armor).FirstOrDefault();
if (Player.CountEnemiesInRange(600) == 0 && Player.HealthPercent < 60 && minion != null)
{
return(minion);
}
}
/*Jungle minions*/
if (ActiveMode == OrbwalkingMode.LaneClear || ActiveMode == OrbwalkingMode.Mixed)
{
result =
ObjectManager.Get <Obj_AI_Minion>()
.Where(
mob =>
mob.IsValidTarget() && mob.Team == GameObjectTeam.Neutral && InAutoAttackRange(mob) && mob.CharData.BaseSkinName != "gangplankbarrel")
.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
ObjectManager.Get <Obj_AI_Minion>()
.Where(minion => minion.IsValidTarget() && InAutoAttackRange(minion) && minion.CharData.BaseSkinName != "gangplankbarrel")
let predHealth =
HealthPrediction.LaneClearHealthPrediction(
minion, (int)((Player.AttackDelay * 1000) * LaneClearWaitTimeMod), FarmDelay)
where
predHealth >= 2 * Player.GetAutoAttackDamage(minion) ||
Math.Abs(predHealth - minion.Health) < float.Epsilon
select minion).MaxOrDefault(m => m.Health);
if (result != null)
{
_prevMinion = (Obj_AI_Minion)result;
}
}
}
return(result);
}
private static void CastItems(Obj_AI_Hero enemy)
{
if (myHero.Distance(enemy) <= 480)
{
if (Items.HasItem(3144) && Items.CanUseItem(3144))
{
Items.UseItem(3144, enemy);
}
if (Items.HasItem(3153) && Items.CanUseItem(3153))
{
Items.UseItem(3153, enemy);
}
}
if (myHero.Distance(enemy) <= 400)
{
if (Items.HasItem(3146) && Items.CanUseItem(3146))
{
Items.UseItem(3146, enemy);
}
}
if (myHero.Distance(enemy) <= 300)
{
if (Items.HasItem(3184) && Items.CanUseItem(3184))
{
Items.UseItem(3184, enemy);
}
if (Items.HasItem(3143) && Items.CanUseItem(3143))
{
Items.UseItem(3143, enemy);
}
if (Items.HasItem(3074) && Items.CanUseItem(3074))
{
Items.UseItem(3074, enemy);
}
if (Items.HasItem(3131) && Items.CanUseItem(3131))
{
Items.UseItem(3131, enemy);
}
if (Items.HasItem(3077) && Items.CanUseItem(3077))
{
Items.UseItem(3077, enemy);
}
if (Items.HasItem(3142) && Items.CanUseItem(3142))
{
Items.UseItem(3142, enemy);
}
}
if (myHero.Distance(enemy) <= 1000)
{
if (Items.HasItem(3023) && Items.CanUseItem(3023))
{
Items.UseItem(3023, enemy);
}
}
}
/// <summary>
/// Returns true if hero is in shop range.
/// </summary>
/// <returns></returns>
public static bool InShop(this Obj_AI_Hero hero)
{
return(hero.IsVisible &&
ObjectManager.Get <Obj_Shop>()
.Any(s => s.Team == hero.Team && hero.Distance(s.Position, true) < 1562500)); // 1250²
}
private static void Game_OnGameUpdate(EventArgs args)
{
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) && !enemy.HasBuff("rocketgrab2") && E.IsReady()))
{
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 (ObjectManager.Player.IsMoving && ta.IsValidTarget(E.Range) && E.GetPrediction(ta).CastPosition.Distance(ta.Position) > 200 && (int)E.GetPrediction(ta).Hitchance == 5 && Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo && E.IsReady() && Config.Item("comboE").GetValue <bool>() && ObjectManager.Player.Mana > RMANA + EMANA + WMANA && ta.Path.Count() == 1)
{
if (ta.HasBuffOfType(BuffType.Slow))
{
E.CastIfHitchanceEquals(ta, HitChance.VeryHigh, true);
}
else if (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))
{
CastSpell(E, ta, Config.Item("Hit").GetValue <Slider>().Value);
debug("E run");
}
}
else
{
if (ta.Position.Distance(ObjectManager.Player.ServerPosition) > ta.Position.Distance(ObjectManager.Player.Position))
{
CastSpell(E, ta, Config.Item("Hit").GetValue <Slider>().Value);
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))
{
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() && !wait)
{
if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo && ObjectManager.Player.Mana > RMANA + WMANA + 10 && ObjectManager.Player.CountEnemiesInRange(GetRealPowPowRange(t)) == 0)
{
if (Config.Item("humanzier").GetValue <bool>())
{
Utility.DelayAction.Add(500, () => CastSpell(W, t, Config.Item("Hit").GetValue <Slider>().Value));
}
else
{
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)
{
if (Config.Item("humanzier").GetValue <bool>())
{
Utility.DelayAction.Add(500, () => CastSpell(W, t, Config.Item("Hit").GetValue <Slider>().Value));
}
else
{
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())
{
if (Config.Item("useR").GetValue <KeyBind>().Active)
{
var t = TargetSelector.GetTarget(R.Range, TargetSelector.DamageType.Physical);
if (t.IsValidTarget())
{
R1.Cast(t, true, true);
}
}
if (Config.Item("Rjungle").GetValue <bool>())
{
KsJungle();
}
}
if (R.IsReady() && Config.Item("autoR").GetValue <bool>())
{
bool cast = false;
foreach (var target in ObjectManager.Get <Obj_AI_Hero>())
{
if (target.IsValidTarget(R.Range) && (Game.Time - WCastTime > 0.8) && 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 && 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.CountEnemiesInRange(200) > 2 && GetRealDistance(target) > bonusRange() + 200 + target.BoundingRadius)
{
R1.Cast(target, true, true);
debug("R aoe 1");
}
}
}
}
}
PotionMenager();
}
private static void QManager(String mode)
{
if (!Q.IsReady())
{
return;
}
var aaRange = GetMinigunRange(null) + GetFishboneRange() + 25f;
var target = TargetSelector.GetTarget(aaRange, TargetSelector.DamageType.Physical);
var jinxBaseRange = GetMinigunRange(target);
if (!target.IsValidTarget(aaRange + GetFishboneRange() + 25f))
{
return;
}
switch (Menu.Item("QMode").GetValue <StringList>().SelectedIndex)
{
//AOE Mode
case 0:
if (IsFishBone() && GetPerValue(true) <= GetSliderValue("QMana" + mode))
{
Q.Cast();
return;
}
if (target.CountEnemysInRange(150) > 1)
{
if (!IsFishBone())
{
Q.Cast();
}
}
else
{
if (IsFishBone())
{
Q.Cast();
}
}
break;
//Range Mode
case 1:
if (IsFishBone())
{
//Switching to Minigun
if (Player.Distance(target) < jinxBaseRange ||
GetPerValue(true) <= GetSliderValue("QMana" + mode))
{
Q.Cast();
}
}
else
{
//Switching to rockets
if (Player.Distance(target) > jinxBaseRange &&
GetPerValue(true) >= GetSliderValue("QMana" + mode))
{
Q.Cast();
}
}
break;
//Both
case 2:
if (IsFishBone())
{
//Switching to Minigun
if (Player.Distance(target) < jinxBaseRange ||
GetPerValue(true) <= GetSliderValue("QMana" + mode))
{
Q.Cast();
}
}
else
{
//Switching to rockets
if (Player.Distance(target) > jinxBaseRange &&
GetPerValue(true) >= GetSliderValue("QMana" + mode) ||
target.CountEnemysInRange(150) > 1)
{
Q.Cast();
}
}
break;
}
}
private static void OnProcessSpellCast(Obj_AI_Base vTarget, GameObjectProcessSpellCastEventArgs args)
{
var stopUlties = Config.Item("StopUlties").GetValue <KeyBind>().Active;
var forceInterrupt = Config.Item("ForceInterruptUlties").GetValue <KeyBind>().Active;
if (!stopUlties || forceInterrupt)
{
return;
}
String[] interruptSpells =
{
"AbsoluteZero", "AlZaharNetherGrasp", "CaitlynAceintheHole", "Crowstorm",
"DrainChannel", "FallenOne", "GalioIdolOfDurand", "InfiniteDuress","KatarinaR","MissFortuneBulletTime",
"Teleport", "Pantheon_GrandSkyfall_Jump", "ShenStandUnited", "UrgotSwap2"
};
foreach (string interruptSpellName in interruptSpells)
{
if (vTarget.Team != vPlayer.Team && args.SData.Name == interruptSpellName)
{
if (vPlayer.Health < vTarget.Health)
{
if (forceInterrupt || vPlayer.Distance(vTarget) >= E.Range ||
vPlayer.Distance(vTarget) <= Q.Range + E.Range)
{
var vMinions = MinionManager.GetMinions(
vPlayer.ServerPosition, Q.Range, MinionTypes.All, MinionTeam.NotAlly);
foreach (var vMinion in vMinions)
{
if (vMinion.Distance(vTarget) <= E.Range || vMinion.Distance(vPlayer) <= Q.Range)
{
Q.CastOnUnit(vMinion);
if (vPlayer.Distance(vTarget) <= E.Range)
{
E.CastOnUnit(vTarget);
}
}
}
}
else if (vPlayer.Distance(vTarget) <= E.Range && E.IsReady())
{
E.CastOnUnit(vTarget);
}
}
}
}
/*
* if (stopUlties)
* {
* foreach (string interruptSpellName in interruptSpells)
* {
* if (vTarget.Team != vPlayer.Team && args.SData.Name == interruptSpellName)
* {
* if (vPlayer.Distance(vTarget) <= E.Range && E.IsReady() && isStunPossible(vTarget))
* E.CastOnUnit(vTarget);
* }
* }
* }
*/
}
private void Misc_Insec()
{
Obj_AI_Hero target = null;
if (SimpleTs.GetSelectedTarget() != null)
{
target = SimpleTs.GetSelectedTarget();
}
if (target == null || !target.IsEnemy || target.Type != GameObjectType.obj_AI_Hero)
{
return;
}
if (soilderCount() > 0)
{
if ((Q.IsReady() || QSpell.State == SpellState.Surpressed) && E.IsReady())
{
var slaves = (from obj in ObjectManager.Get <Obj_AI_Base>()
where obj.Name == "AzirSoldier" && obj.IsAlly && target.Distance(obj.ServerPosition) < 2000
select obj).ToList();
foreach (var slave in slaves.Where(slave => MyHero.Distance(target) < 800))
{
Q.UpdateSourcePosition(slave.ServerPosition, slave.ServerPosition);
var qPred = Q.GetPrediction(target);
var vec = target.ServerPosition - MyHero.ServerPosition;
var castBehind = qPred.CastPosition + Vector3.Normalize(vec) * 75;
_rVec = qPred.CastPosition - Vector3.Normalize(vec) * 300;
if (!Q.IsReady() || (!E.IsReady() && ESpell.State != SpellState.Surpressed) || !R.IsReady() ||
qPred.Hitchance < Get_Q_Hitchance())
{
continue;
}
Q.Cast(castBehind, UsePackets());
E.Cast(slave.ServerPosition, UsePackets());
E.LastCastAttemptT = Environment.TickCount;
}
}
if (!R.IsReady())
{
return;
}
if (MyHero.Distance(target) < 200 && Environment.TickCount - E.LastCastAttemptT > Game.Ping + 150)
{
R.Cast(_rVec);
}
}
else if (W.IsReady())
{
var wVec = MyHero.ServerPosition + Vector3.Normalize(target.ServerPosition - MyHero.ServerPosition) * 450;
Q.UpdateSourcePosition(wVec, wVec);
var qPred = Q.GetPrediction(target);
if ((Q.IsReady() || QSpell.State == SpellState.Surpressed) && (E.IsReady() || ESpell.State == SpellState.Surpressed) &&
R.IsReady() && MyHero.Distance(target) < 800 && qPred.Hitchance >= HitChance.High)
{
var vec = target.ServerPosition - MyHero.ServerPosition;
var castBehind = qPred.CastPosition + Vector3.Normalize(vec) * 75;
_rVec = MyHero.Position;
W.Cast(wVec);
_qExtend.Cast(castBehind, UsePackets());
E.Cast(getNearestSoilderToEnemy(target).ServerPosition, UsePackets());
}
if (!R.IsReady())
{
return;
}
if (MyHero.Distance(target) < 200 && Environment.TickCount - E.LastCastAttemptT > Game.Ping + 150)
{
R.Cast(_rVec);
}
}
}
private static void Drawing_OnDraw(EventArgs args)
{
if (Config.Item("DrawDisable").GetValue <bool>())
{
return;
}
foreach (var spell in SpellList.Where(spell => spell != Q && spell != W))
{
var menuItem = Config.Item("Draw" + spell.Slot).GetValue <Circle>();
if (menuItem.Active && spell.Level > 0)
{
Render.Circle.DrawCircle(Player.Position, spell.Range, menuItem.Color);
}
}
var drawSlaveRange = Config.Item("DrawSlaveRange").GetValue <Circle>();
if (MordekaiserHaveSlave)
{
MordekaiserHaveSlave2();
if (drawSlaveRange.Active)
{
Render.Circle.DrawCircle(Player.Position, SlaveActivationRange, drawSlaveRange.Color);
}
if (!Config.Item("DrawSlavePos").GetValue <Circle>().Active)
{
return;
}
var drawSlavePos = Config.Item("DrawSlavePos").GetValue <Circle>();
var xMinion =
ObjectManager.Get <Obj_AI_Minion>()
.Where(
minion => Player.Distance(minion) < SlaveActivationRange && Player.IsAlly && !Player.IsDead);
var xEnemy = ObjectManager.Get <Obj_AI_Hero>().Where(enemy => enemy.IsEnemy);
var xList = from xM in xMinion
join xE in xEnemy on new { pEquals1 = xM.BaseSkinName }
equals new { pEquals1 = xE.BaseSkinName }
select new { xM.Position, xM.Name, xM.NetworkId, xM.BaseSkinName };
foreach (var xL in xList)
{
// Game.PrintChat(xL.BaseSkinName);
Render.Circle.DrawCircle(xL.Position, 70f, Color.White);
Render.Circle.DrawCircle(xL.Position, 75f, drawSlavePos.Color);
Render.Circle.DrawCircle(xL.Position, 80f, Color.White);
}
}
}
private void Combo(Obj_AI_Hero target)
{
if (target == null)
{
return;
}
var cmbdmg = ComboDamage(target) + ItemHandler.GetItemsDamage(target);
if (config.Item("useItems").GetValue <bool>())
{
ItemHandler.UseItems(target, config, cmbdmg);
}
if (!config.Item("Rdamage").GetValue <bool>())
{
cmbdmg += R.GetDamage(target) * 15;
}
var bonusDmg = Environment.Hero.GetAdOverTime(player, target, 5);
if ((config.Item("user").GetValue <bool>() && player.Distance(target) < player.AttackRange + 50 &&
cmbdmg + bonusDmg > target.Health && target.Health > bonusDmg + 200 && player.HealthPercent < 50) ||
(config.Item("usertf").GetValue <Slider>().Value <= player.CountEnemiesInRange(600) &&
player.HealthPercent < 80))
{
R.Cast();
}
var ignitedmg = (float)player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite);
bool hasIgnite = player.Spellbook.CanUseSpell(player.GetSpellSlot("SummonerDot")) == SpellState.Ready;
if (config.Item("useIgnite").GetValue <bool>() && ignitedmg > target.Health && hasIgnite &&
!E.CanCast(target))
{
player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), target);
}
if (config.Item("usew").GetValue <bool>() && W.CanCast(target))
{
if (((config.Item("keepManaForR").GetValue <bool>() && R.IsReady()) || !R.IsReady()) &&
player.Mana > R.Instance.ManaCost + W.Instance.ManaCost)
{
W.Cast(target);
}
}
if (((config.Item("keepManaForR").GetValue <bool>() && R.IsReady()) || !R.IsReady()) &&
(player.Mana > R.Instance.ManaCost + E.Instance.ManaCost ||
(E.IsReady() && E.GetDamage(target) > target.Health)))
{
if (config.Item("usee").GetValue <bool>() && E.IsReady() &&
((config.Item("useeslow").GetValue <bool>() && NasusW(target)) ||
!config.Item("useeslow").GetValue <bool>()))
{
var ePred = E.GetPrediction(target);
if (E.Range > ePred.CastPosition.Distance(player.Position) &&
target.Distance(ePred.CastPosition) < 400)
{
E.Cast(ePred.CastPosition);
}
else
{
if (ePred.CastPosition.Distance(player.Position) < 925 &&
target.Distance(ePred.CastPosition) < 400)
{
E.Cast(
player.Position.Extend(target.Position, E.Range));
}
}
}
}
}
private static void OnGameUpdate(EventArgs args)
{
try
{
if (Player.IsDead)
{
return;
}
var QTarget = TargetSelector.GetTarget(_Q.Range, TargetSelector.DamageType.Magical);
var WTarget = TargetSelector.GetTarget(_W.Range, TargetSelector.DamageType.Magical);
var ETarget = TargetSelector.GetTarget(_E.Range, TargetSelector.DamageType.Magical);
var RTarget = TargetSelector.GetTarget(_E.Range, TargetSelector.DamageType.Magical);
var KTarget = ObjectManager.Get <Obj_AI_Hero>().OrderBy(x => x.Health).FirstOrDefault(x => x.IsEnemy && Player.Distance(x) < 900);
//KillSteal
if (KTarget != null && !KTarget.IsDead && KTarget.IsEnemy && KTarget.Health > 0)
{
if (MainMenu._MainMenu.Item("KseQ").GetValue <bool>() && _Q.IsReady() && KTarget.Health < _Q.GetDamage(KTarget) && KTarget.Distance(Player) <= _Q.Range)
{
_Q.CastIfHitchanceEquals(KTarget, Hitchance("CUseQ_Hit"), true);
return;
}
if (MainMenu._MainMenu.Item("KseR").GetValue <bool>() && _R.IsReady() && KTarget.Health < _R.GetDamage(KTarget) && KTarget.Distance(Player) <= _R.Range)
{
_R.Cast(KTarget, true);
return;
}
if (MainMenu._MainMenu.Item("KseW").GetValue <bool>() && _W.IsReady() && !KTarget.CanMove && KTarget.Health < _W.GetDamage(KTarget) && KTarget.Distance(Player) <= _W.Range)
{
_W.CastIfHitchanceEquals(KTarget, HitChance.VeryHigh, true);
return;
}
}
//Combo
if (MainMenu._MainMenu.Item("CKey").GetValue <KeyBind>().Active)
{
if (MainMenu._MainMenu.Item("CUseE").GetValue <bool>() && ETarget != null && _E.IsReady())
{
SpellUseE(ETarget);
}
if (MainMenu._MainMenu.Item("CUseW").GetValue <bool>() && WTarget != null && _W.IsReady())
{
_W.CastIfHitchanceEquals(WTarget, HitChance.VeryHigh, true);
return;
}
if (MainMenu._MainMenu.Item("CUseQ").GetValue <bool>() && QTarget != null && _Q.IsReady())
{
_Q.CastIfHitchanceEquals(QTarget, Hitchance("CUseQ_Hit"), true);
return;
}
if (MainMenu._MainMenu.Item("CUseR").GetValue <bool>() && RTarget != null && _R.IsReady() && !MainMenu._MainMenu.Item("CUseR_Select").GetValue <bool>())
{
_R.Cast(RTarget, true);
return;
}
}
//Harass
if ((MainMenu._MainMenu.Item("HKey").GetValue <KeyBind>().Active || MainMenu._MainMenu.Item("AutoHUseQ").GetValue <KeyBind>().Active) &&
MainMenu._MainMenu.Item("HManarate").GetValue <Slider>().Value < Player.ManaPercent)
{
if (MainMenu._MainMenu.Item("HUseE").GetValue <bool>() && ETarget != null && _E.IsReady() && !ETarget.CanMove)
{
SpellUseE(ETarget);
}
if (MainMenu._MainMenu.Item("HUseW").GetValue <bool>() && WTarget != null && _W.IsReady() && !WTarget.CanMove)
{
_W.CastIfHitchanceEquals(WTarget, HitChance.VeryHigh, true);
return;
}
if (MainMenu._MainMenu.Item("HUseQ").GetValue <bool>() && QTarget != null && _Q.IsReady())
{
_Q.CastIfHitchanceEquals(QTarget, Hitchance("CUseQ_Hit"), true);
return;
}
if (MainMenu._MainMenu.Item("HUseR").GetValue <bool>() && RTarget != null && _R.IsReady())
{
_R.Cast(RTarget, true);
return;
}
}
//LaneClear
if (MainMenu._MainMenu.Item("LKey").GetValue <KeyBind>().Active&& MainMenu._MainMenu.Item("LManarate").GetValue <Slider>().Value < Player.ManaPercent)
{
var MinionTarget = MinionManager.GetMinions(900, MinionTypes.All, MinionTeam.Enemy, MinionOrderTypes.Health);
foreach (var item in MinionTarget)
{
if (MainMenu._MainMenu.Item("LUseQ").GetValue <bool>())
{
if (MainMenu._MainMenu.Item("LUseQSet").GetValue <bool>() && item.Health < _Q.GetDamage(item))
{
_Q.CastIfHitchanceEquals(item, HitChance.Low, true);
return;
}
if (!MainMenu._MainMenu.Item("LUseQSet").GetValue <bool>())
{
_Q.CastIfHitchanceEquals(item, HitChance.Low, true);
return;
}
}
}
}
//JungleClear
if (MainMenu._MainMenu.Item("JKey").GetValue <KeyBind>().Active&& MainMenu._MainMenu.Item("JManarate").GetValue <Slider>().Value < Player.ManaPercent)
{
var MinionTarget = MinionManager.GetMinions(900, MinionTypes.All, MinionTeam.Neutral, MinionOrderTypes.Health);
foreach (var item in MinionTarget)
{
if (MainMenu._MainMenu.Item("JUseQ").GetValue <bool>())
{
if (MainMenu._MainMenu.Item("JUseQSet").GetValue <bool>() && item.Health < _Q.GetDamage(item))
{
_Q.CastIfHitchanceEquals(item, HitChance.Low, true);
return;
}
if (!MainMenu._MainMenu.Item("JUseQSet").GetValue <bool>())
{
_Q.CastIfHitchanceEquals(item, HitChance.Low, true);
return;
}
}
}
}
}
catch (Exception e)
{
//Console.Write(e);
//Game.PrintChat("FreshVeigar is not working. plz send message by KorFresh (Code 4)");
}
}
private static void AutoHeal()
{
if (Player.Mana == 5 && Player.HealthPercent <= AutoHP && W.IsReady())
{
W.Cast();
}
var target = TargetSelector.GetTarget(W.Range, TargetSelector.DamageType.Magical);
if (Player.Mana == 4 && Player.HealthPercent <= AutoHP && W.IsReady() && Player.Distance(target.ServerPosition) <= W.Range)
{
W.Cast();
}
}
private static void UseSpells(bool useQ, bool useW, bool useE, bool useR, string Source)
{
var range = W.IsReady() ? W.Range : Q.Range;
var focusSelected = menu.Item("selected").GetValue <bool>();
Obj_AI_Hero target = SimpleTs.GetTarget(range, SimpleTs.DamageType.Magical);
if (SimpleTs.GetSelectedTarget() != null)
{
if (focusSelected && SimpleTs.GetSelectedTarget().Distance(Player.ServerPosition) < range)
{
target = SimpleTs.GetSelectedTarget();
}
}
bool hasmana = manaCheck();
float dmg = GetComboDamage(target);
int IgniteMode = menu.Item("igniteMode").GetValue <StringList>().SelectedIndex;
var minManaHarass = menu.Item("minMana").GetValue <Slider>().Value;
Obj_AI_Hero eTar = SimpleTs.GetTarget(E.Range, SimpleTs.DamageType.Magical);
if (Source == "Harass" && getManaPercentage() < minManaHarass)
{
return;
}
if (target == null)
{
return;
}
//W
if (useW && W.IsReady() && Player.Distance(target) <= W.Range && shouldW(target) &&
W.GetPrediction(target).Hitchance >= HitChance.High)
{
W.Cast(target, packets());
}
//Q
if (useQ && Q.IsReady())
{
var qPred = Q.GetPrediction(target);
if (qPred.Hitchance >= getHit(Source))
{
Q.Cast(qPred.CastPosition);
}
}
//E
if (useE && E.IsReady() && Player.Distance(eTar) < E.Range && eSpell.ToggleState == 1 && hasManaForE(Source))
{
E.Cast(packets());
}
//Ignite
if (menu.Item("ignite").GetValue <bool>() && IgniteSlot != SpellSlot.Unknown &&
Player.SummonerSpellbook.CanUseSpell(IgniteSlot) == SpellState.Ready && Source == "Combo" && hasmana)
{
if (IgniteMode == 0 && dmg > target.Health)
{
Player.SummonerSpellbook.CastSpell(IgniteSlot, target);
}
}
}
public static void doCombo(Obj_AI_Hero target)
{
castOmen(target);
if (!isHammer)
{
if (castEonQ != null)
{
castEonSpell(target);
}
//DO QE combo first
if (E1.IsReady() && Q1.IsReady() && gotManaFor(true, false, true))
{
castQEPred(target);
}
else if (Q1.IsReady() && gotManaFor(true))
{
castQPred(target);
}
else if (W1.IsReady() && gotManaFor(false, true) && targetInRange(getClosestEnem(), 650f))
{
W1.Cast();
sumItems.cast(SummonerItems.ItemIds.Ghostblade);
}//and wont die wih 1 AA
else if (!Q1.IsReady() && !W1.IsReady() && R1.IsReady() && hammerWillKill(target) && hamQCDRem == 0 && hamECDRem == 0)// will need to add check if other form skills ready
{
R1.Cast();
}
}
else
{
if (!Q2.IsReady() && R2.IsReady() && Player.Distance(getClosestEnem()) > 350)
{
sumItems.cast(SummonerItems.ItemIds.Ghostblade);
R2.Cast();
}
if (Q2.IsReady() && gotManaFor(true) && targetInRange(target, Q2.Range) && Player.Distance(target) > 300)
{
sumItems.cast(SummonerItems.ItemIds.Ghostblade);
Q2.Cast(target);
}
if (E2.IsReady() && gotManaFor(false, false, true) && targetInRange(target, E2.Range) && shouldIKnockDatMadaFaka(target))
{
E2.Cast(target);
}
if (W2.IsReady() && gotManaFor(false, true) && targetInRange(target, W2.Range))
{
W2.Cast();
}
}
}
static void GravesOnCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
if (sender.IsEnemy && sender.Type == Me.Type && mainMenu.Item("usewl3").GetValue <bool>())
{
if (sender.Distance(Me.ServerPosition) <= Smokescreen.Range)
{
if ((args.SData.CastFrame / 30) > 500)
{
Smokescreen.Cast(sender.ServerPosition);
}
}
}
if (!sender.IsMe)
{
return;
}
switch (args.SData.Name)
{
case "GravesMove":
LastE = Utils.GameTimeTickCount;
break;
case "GravesClusterShot":
if (mainMenu.Item("combokey").GetValue <KeyBind>().Active)
{
if (rtarget.IsValidTarget(Quickdraw.Range + 450) && Quickdraw.IsReady())
{
Utility.DelayAction.Add(Game.Ping + 250, () =>
{
CastE(rtarget);
});
}
}
break;
case "GravesSmokeGrenade":
if (mainMenu.Item("fleekey").GetValue <KeyBind>().Active)
{
if (rtarget.IsValidTarget(Quickdraw.Range + 450) && Quickdraw.IsReady())
{
Utility.DelayAction.Add(Game.Ping + 250, () =>
{
Quickdraw.Cast(Game.CursorPos);
});
}
}
if (mainMenu.Item("combokey").GetValue <KeyBind>().Active)
{
if (rtarget.IsValidTarget(Quickdraw.Range + 450) && Quickdraw.IsReady())
{
Utility.DelayAction.Add(Game.Ping + 250, () =>
{
CastE(rtarget);
});
}
}
break;
case "GravesChargeShot":
LastR = Utils.GameTimeTickCount;
if (mainMenu.Item("combokey").GetValue <KeyBind>().Active)
{
if (rtarget.Distance(Me.ServerPosition) <= Chargeshot.Range)
{
Utility.DelayAction.Add(Game.Ping + 250, () =>
{
if (rtarget.Distance(Me.ServerPosition) > Quickdraw.Range - 55f &&
rtarget.CountEnemiesInRange(Me.AttackRange) <= 2)
{
Quickdraw.Cast(rtarget.ServerPosition);
}
else
{
CastE(rtarget);
}
});
}
}
break;
}
}
static void AntiPink(Vector3 position)
{
float pd = player.Distance(position);
foreach (var item in player.InventoryItems)
{
switch (item.Name)
{
case "TrinketSweeperLvl1":
if (pd < 800)
{
item.UseItem(V2E(player.Position, position, 400).To3D());
}
break;
case "TrinketSweeperLvl2":
if (pd < 1200)
{
item.UseItem(V2E(player.Position, position, 600).To3D());
}
break;
case "TrinketSweeperLvl3":
if (pd < 1200)
{
item.UseItem(V2E(player.Position, position, 600).To3D());
}
break;
}
}
}
private static void UseCombo()
{
if (Target == null)
{
return;
}
bool AllSkills = false;
if (ComboDmg(Target) >= Target.Health && Target.Distance(Player) <= 950)
{
AllSkills = true;
}
if (GetBool("UseItems") && AllSkills && GetDistanceSqr(Player, Target) <= 750 * 750 && NotYasuoWall(Target))
{
if (Items.CanUseItem(3128))
{
Items.UseItem(3128, Target);
}
if (Items.CanUseItem(3188))
{
Items.UseItem(3188, Target);
}
}
if (GetBool("UseQ") && Q.IsReady() && GetDistanceSqr(Player, Target) <= Q.Range * Q.Range && NotYasuoWall(Target))
{
Q.CastIfHitchanceEquals(Target, HitC, GetBool("UsePacket"));
if (Target.IsValidTarget(550) && Target.HasBuff("luxilluminatingfraulein"))
{
Player.IssueOrder(GameObjectOrder.AttackUnit, Target);
}
}
if (GetBool("UseW") && W.IsReady() && IsFacing(Player, Target) && Player.Distance(Target) <= 550)
{
W.Cast(Target, GetBool("UsePacket"));
}
if (GetBool("UseE") && E.IsReady() && GetDistanceSqr(Player, Target) <= E.Range * E.Range && NotYasuoWall(Target) && !IsInvul(Target))
{
if (GetBool("UseQE"))
{
if (Target.HasBuff("LuxLightBindingMis"))
{
E.Cast(Target, GetBool("UsePacket"));
CastE2();
}
}
else
{
E.CastIfHitchanceEquals(Target, HitC, GetBool("UsePacket"));
CastE2();
}
if (Target.IsValidTarget(550) && Target.HasBuff("luxilluminatingfraulein"))
{
Player.IssueOrder(GameObjectOrder.AttackUnit, Target);
}
}
if (GetBool("UseR") && R.IsReady() && (R.IsKillable(Target) || AllSkills) && NotYasuoWall(Target) && !IsInvul(Target))
{
if (Target.Health <= Damage.GetAutoAttackDamage(Player, Target, true) && Player.Distance(Target) < 550)
{
Player.IssueOrder(GameObjectOrder.AttackUnit, Target);
}
else
{
if (Target.HasBuffOfType(BuffType.Slow) || Target.HasBuffOfType(BuffType.Stun) ||
Target.HasBuffOfType(BuffType.Snare) || Target.HasBuffOfType(BuffType.Taunt))
{
R.Cast(Target, GetBool("UsePacket"));
}
else
{
R.CastIfHitchanceEquals(Target, HitChance.VeryHigh, GetBool("UsePacket"));
}
}
}
if (GetBool("UseIgnite") && (IgniteKillable(Target) || AllSkills) && CanIgnite())
{
if (Player.Distance(Target) <= 600)
{
if (Target.Health <= Damage.GetAutoAttackDamage(Player, Target, true) && Player.Distance(Target) < 550)
{
Player.IssueOrder(GameObjectOrder.AttackUnit, Target);
}
else
{
Player.Spellbook.CastSpell(IgniteSlot, Target);
}
}
}
}
static void InsecCombo(Obj_AI_Hero target)
{
if (target != null && target.IsVisible)
{
if (_player.Distance(getInsecPos(target)) < 200)
{
R.CastOnUnit(target, true);
InsecComboStep = InsecComboStepSelect.PRESSR;
}
else if (InsecComboStep == InsecComboStepSelect.NONE &&
getInsecPos(target).Distance(_player.Position) < 600)
{
InsecComboStep = InsecComboStepSelect.WGAPCLOSE;
}
else if (InsecComboStep == InsecComboStepSelect.NONE && target.Distance(_player) < Q.Range)
{
InsecComboStep = InsecComboStepSelect.QGAPCLOSE;
}
switch (InsecComboStep)
{
case InsecComboStepSelect.QGAPCLOSE:
if (!(target.HasBuff("BlindMonkQOne", true) || target.HasBuff("blindmonkqonechaos", true)) &&
Q.Instance.Name == "BlindMonkQOne")
{
CastQ1(target);
}
else if ((target.HasBuff("BlindMonkQOne", true) || target.HasBuff("blindmonkqonechaos", true)))
{
Q.Cast();
InsecComboStep = InsecComboStepSelect.WGAPCLOSE;
}
break;
case InsecComboStepSelect.WGAPCLOSE:
if (W.IsReady() && W.Instance.Name == "BlindMonkWOne" &&
(paramBool("waitForQBuff")
? !(target.HasBuff("BlindMonkQOne", true) || target.HasBuff("blindmonkqonechaos", true))
: true))
{
WardJump(getInsecPos(target), false, false, true);
wardJumped = true;
}
else if (_player.SummonerSpellbook.CanUseSpell(flashSlot) == SpellState.Ready &&
paramBool("flashInsec") && !wardJumped && _player.Distance(insecPos) < 400 ||
_player.SummonerSpellbook.CanUseSpell(flashSlot) == SpellState.Ready &&
paramBool("flashInsec") && !wardJumped && _player.Distance(insecPos) < 400 &&
Items.GetWardSlot() == null)
{
_player.SummonerSpellbook.CastSpell(flashSlot, getInsecPos(target));
Utility.DelayAction.Add(50, () => R.CastOnUnit(target, true));
}
break;
case InsecComboStepSelect.PRESSR:
R.CastOnUnit(target, true);
break;
}
}
}
static void Obj_AI_Hero_OnAggro(Obj_AI_Base sender, GameObjectAggroEventArgs args)
{
if (!IreliaMenu.Config.Item("misc.stunundertower").GetValue <bool>())
{
return;
}
if (!Spells.E.IsReady())
{
return;
}
if (!sender.Name.Contains("Turret"))
{
return;
}
foreach (
var enemy in
HeroManager.Enemies.Where(
enemy => enemy.NetworkId == args.NetworkId && Player.HealthPercent <= enemy.HealthPercent))
{
if (Player.Distance(enemy) <= Spells.E.Range)
{
Spells.E.CastOnUnit(enemy);
}
else if (Player.Distance(enemy) <= Spells.Q.Range && Spells.Q.IsReady())
{
var qminion = MinionManager
.GetMinions(Spells.Q.Range + 350, MinionTypes.All, MinionTeam.NotAlly)
.Where(
m =>
m.Distance(Player) <= Spells.Q.Range &&
m.Health <= QDamage(m) + ExtraWDamage(m) + SheenDamage(m) - 30 && m.IsValidTarget())
.OrderBy(m => m.Distance(enemy.Position) <= Spells.Q.Range + 350)
.FirstOrDefault();
if (qminion != null && qminion.Distance(enemy) <= Spells.E.Range)
{
var qtraveltime = Player.Distance(qminion) / Spells.Q.Speed + Spells.Q.Delay;
var enemy1 = enemy;
Spells.Q.CastOnUnit(qminion);
Utility.DelayAction.Add((int)qtraveltime, () => Spells.E.CastOnUnit(enemy1));
}
}
}
}
private static void Game_OnGameUpdate(EventArgs args)
{
_maintarget = TargetSelector.GetTarget(1100, TargetSelector.DamageType.Physical);
CheckDamage(_maintarget);
Kappa();
_orbwalker.SetAttack(_canattack);
_orbwalker.SetMovement(_canmove);
_astime = 1 / (0.318 * Me.AttackSpeedMod);
_truerange = Me.AttackRange + Me.Distance(Me.BBox.Minimum) + 1;
_ulton = Me.GetSpell(SpellSlot.R).Name != "RivenFengShuiEngine";
_hashydra = Items.HasItem(3077) || Items.HasItem(3074);
_canhydra = !_isattacking && (Items.CanUseItem(3077) || Items.CanUseItem(3074));
_qt = (_qtRem - Game.Time > 0) ? (_qtRem - Game.Time) : 0;
if (_maintarget.IsValidTarget(1000))
{
_movePos = _maintarget.ServerPosition +
Vector3.Normalize(Me.Position - _maintarget.ServerPosition) *
(Me.Distance(_maintarget.ServerPosition) + 51);
}
else
{
_movePos = Game.CursorPos;
}
if (_config.Item("fleemode").GetValue <KeyBind>().Active)
{
if (_candash && _e.IsReady())
{
_e.Cast(Game.CursorPos);
}
if (!_e.IsReady() && Environment.TickCount - _lastcleave >= 300 && Environment.TickCount - _lastdash >= 200)
{
_q.Cast(Game.CursorPos);
}
if (_canmove)
{
Me.IssueOrder(GameObjectOrder.MoveTo, Game.CursorPos);
}
}
foreach (var b in Me.Buffs)
{
if (b.Name == "RivenTriCleave")
{
_cleavecount = b.Count;
}
if (b.Name == "rivenpassiveaaboost")
{
_runiccount = b.Count;
}
}
if (Me.HasBuff("RivenTriCleave", true) && Environment.TickCount - _lastcleave >= 3600)
{
if (_config.Item("keepq").GetValue <bool>() && !Me.IsRecalling())
{
_q.Cast(Game.CursorPos);
}
}
if (!Me.HasBuff("rivenpassiveaaboost", true))
{
Utility.DelayAction.Add(1000, () => _runiccount = 1);
}
if (!Me.HasBuff("RivenTriCleave", true))
{
Utility.DelayAction.Add(1000, () => _cleavecount = 0);
}
if (_config.Item("reckless").GetValue <KeyBind>().Active)
{
var wTarget = ObjectManager.Get <Obj_AI_Hero>()
.Where(huro => huro.IsValidTarget(_w.Range));
if (wTarget.Count() >= _config.Item("autow").GetValue <Slider>().Value)
{
if (_cankiburst && _w.IsReady())
{
_w.Cast();
}
}
}
var obj = (_orbwalker.GetTarget() != null ? (Obj_AI_Base)_orbwalker.GetTarget() : _maintarget) ?? Me;
var time = (int)(Me.AttackCastDelay * 1000) - 100 + Game.Ping / 2 +
1000 * (int)Me.Distance(obj.ServerPosition) / (int)Me.BasicAttack.MissileSpeed;
if (_orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo)
{
NormalCombo(_maintarget);
}
if (_orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.LaneClear)
{
LaneClear();
JungleClear();
}
if (!_canwindslash && !_isattacking && _ulton && _r.IsReady())
{
_canwindslash = true;
}
if (!_candash && !(_iscleaving || _isattacking || _iskibursting) && _e.IsReady())
{
_candash = true;
}
if (!_cankiburst && !(_iscleaving || _isattacking || _isdashing) && _w.IsReady())
{
_cankiburst = true;
}
if (!_canmove && !(_isattacking || _iscleaving || _iskibursting || _isdashing) &&
Environment.TickCount - _lastattack >= time)
{
_canmove = true;
}
if (!_canattack && !(_iscleaving || _isdashing || _iskibursting) &&
Environment.TickCount - _lastattack >= time + 166)
{
_canattack = true;
}
var time2 = (int)((_astime * 100) - 10 - (Me.Level * 8 / 2) + Game.Ping / 2);
if (_isattacking && Environment.TickCount - _lastattack >= time2)
{
_isattacking = false;
_canmove = true;
if (_config.Item("usecomboq").GetValue <bool>())
{
_cancleave = true;
}
if (_config.Item("usecomboe").GetValue <bool>())
{
_candash = true;
}
if (_config.Item("usecombow").GetValue <bool>())
{
_cankiburst = true;
}
if (_config.Item("usews").GetValue <bool>())
{
_canwindslash = true;
}
}
if (_iscleaving && Environment.TickCount - _lastcleave >= 273)
{
_iscleaving = false;
_canmove = true;
_canattack = true;
}
if (_iskibursting && Environment.TickCount - _lastkiburst >= 148)
{
_iskibursting = false;
_canattack = true;
_canmove = true;
}
if (_isdashing && Environment.TickCount - _lastdash >= 200)
{
_isdashing = false;
_canmove = true;
}
}
private static void Game_OnGameUpdate(EventArgs args)
{
ManaMenager();
if (Orbwalker.ActiveMode.ToString() == "Mixed" || Orbwalker.ActiveMode.ToString() == "LaneClear" || Orbwalker.ActiveMode.ToString() == "LastHit")
{
Farm = true;
}
else
{
Farm = false;
}
if (E.IsReady() && ObjectManager.Player.Mana > RMANA + EMANA)
{
foreach (var enemy in ObjectManager.Get <Obj_AI_Hero>().Where(enemy => enemy.IsValidTarget(E.Range) && E.IsReady()))
{
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 if (enemy.HasBuffOfType(BuffType.Slow) && enemy.Path.Count() > 1)
{
E.CastIfHitchanceEquals(enemy, HitChance.VeryHigh, true);
}
else if (enemy.Path.Count() > 1 && enemy.CountEnemiesInRange(300) > 2)
{
E.CastIfHitchanceEquals(enemy, HitChance.VeryHigh, true);
}
else
{
E.CastIfHitchanceEquals(enemy, HitChance.Immobile, true);
}
}
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)))
{
E.Cast(Object.Position, true);
}
var ta = TargetSelector.GetTarget(E.Range, TargetSelector.DamageType.Physical);
if (Orbwalker.ActiveMode.ToString() == "Combo" && ta.IsValidTarget(E.Range) && ta.Path.Count() == 1 && Config.Item("autoE").GetValue <bool>() && ObjectManager.Player.Mana > RMANA + EMANA + WMANA)
{
if (ObjectManager.Player.Position.Distance(ta.ServerPosition) > ObjectManager.Player.Position.Distance(ta.Position))
{
if (ta.Position.Distance(Game.CursorPos) < ta.Position.Distance(ObjectManager.Player.Position) && ta.IsValidTarget(E.Range - 300))
{
E.CastIfHitchanceEquals(ta, HitChance.VeryHigh, true);
}
}
else
if (ta.Position.Distance(Game.CursorPos) > ta.Position.Distance(ObjectManager.Player.Position) && ta.IsValidTarget(E.Range - 100))
{
E.CastIfHitchanceEquals(ta, HitChance.VeryHigh, true);
}
}
}
if (Q.IsReady())
{
ManaMenager();
if (Farm)
{
if (ObjectManager.Player.Mana > RMANA + WMANA + EMANA + 10 && !FishBoneActive)
{
farmQ();
}
}
var t = TargetSelector.GetTarget(bonusRange() + 50, TargetSelector.DamageType.Physical);
if (t.IsValidTarget())
{
var distance = GetRealDistance(t);
var powPowRange = GetRealPowPowRange(t);
if (!FishBoneActive && !Orbwalking.InAutoAttackRange(t))
{
if (Orbwalker.ActiveMode.ToString() == "Combo" && (ObjectManager.Player.Mana > RMANA + WMANA + 20 || ObjectManager.Player.GetAutoAttackDamage(t) * 2 > t.Health))
{
Q.Cast();
}
else if (Farm && haras() && !ObjectManager.Player.UnderTurret(true) && ObjectManager.Player.Mana > RMANA + WMANA + EMANA + WMANA + 20 && distance < bonusRange() + t.BoundingRadius)
{
Q.Cast();
}
}
}
else if (!FishBoneActive && (Orbwalker.ActiveMode.ToString() == "Combo") && ObjectManager.Player.Mana > RMANA + WMANA + 20)
{
Q.Cast();
}
else if (FishBoneActive && (Orbwalker.ActiveMode.ToString() == "Combo") && ObjectManager.Player.Mana < RMANA + WMANA + 20)
{
Q.Cast();
}
else if (FishBoneActive && Farm)
{
Q.Cast();
}
}
if (W.IsReady())
{
ManaMenager();
var t = TargetSelector.GetTarget(W.Range, TargetSelector.DamageType.Physical);
if (t.IsValidTarget())
{
var wDmg = W.GetDamage(t);
if (!Orbwalking.InAutoAttackRange(t) && wDmg + ObjectManager.Player.GetAutoAttackDamage(t) > t.Health)
{
W.Cast(t, true);
}
else if (t.Path.Count() == 1 && Orbwalker.ActiveMode.ToString() == "Combo" && ObjectManager.Player.Mana > RMANA + WMANA + 10 && ObjectManager.Player.CountEnemiesInRange(GetRealPowPowRange(t)) == 0)
{
W.CastIfHitchanceEquals(t, HitChance.VeryHigh, true);
}
else if ((Farm && ObjectManager.Player.Mana > RMANA + EMANA + WMANA + WMANA + 20) && !ObjectManager.Player.UnderTurret(true) && ObjectManager.Player.CountEnemiesInRange(bonusRange()) == 0 && haras())
{
if (ObjectManager.Player.Mana > ObjectManager.Player.MaxMana * 0.8)
{
W.CastIfHitchanceEquals(t, HitChance.High, true);
}
else if (t.Path.Count() == 1)
{
W.CastIfHitchanceEquals(t, HitChance.VeryHigh, true);
}
}
else if ((Orbwalker.ActiveMode.ToString() == "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.CastIfHitchanceEquals(t, HitChance.High, true);
}
}
}
}
}
if (R.IsReady() && Config.Item("autoR").GetValue <bool>())
{
bool cast = false;
foreach (var target in ObjectManager.Get <Obj_AI_Hero>().Where(target => target.IsValidTarget(R.Range)))
{
if (target.IsValidTarget() && (Game.Time - WCastTime > 1) &&
!target.HasBuffOfType(BuffType.PhysicalImmunity) && !target.HasBuffOfType(BuffType.SpellImmunity) && !target.HasBuffOfType(BuffType.SpellShield))
{
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 + 100 + enemy.BoundingRadius / 2) && Player.Distance(predictedPosition) < Player.Distance(target.ServerPosition))
{
cast = false;
}
}
if (cast && target.IsValidTarget() && GetRealDistance(target) > bonusRange() + 150 + target.BoundingRadius && target.CountAlliesInRange(500) == 0 && ObjectManager.Player.CountEnemiesInRange(400) == 0)
{
if (Config.Item("hitchanceR").GetValue <bool>() && target.Path.Count() == 1)
{
R.CastIfHitchanceEquals(target, HitChance.VeryHigh, true);
}
else
{
R.Cast(target, true);
}
}
else if (target.IsValidTarget() && target.CountEnemiesInRange(200) > 2 && ObjectManager.Player.CountEnemiesInRange(400) == 0)
{
R1.Cast(target, true, true);
}
}
}
}
}
PotionMenager();
}
private void ProtectorOnSkillshotProtection(Obj_AI_Hero target, List <Skillshot> skillshots)
{
try
{
if (!ConfigValue <bool>("Misc.Shield.Skill"))
{
return;
}
// get most dangerous skillshot
var max = skillshots.First();
foreach (var spell in skillshots)
{
if (spell.Unit.GetSpellDamage(target, spell.SpellData.SpellName) >
max.Unit.GetSpellDamage(target, max.SpellData.SpellName) &&
spell.SpellData.Type != SkillShotType.SkillshotCircle &&
spell.SpellData.Type != SkillShotType.SkillshotRing)
{
max = spell;
}
}
// too fast
if (max.SpellData.MissileSpeed > 2000 || max.SpellData.MissileSpeed == 0)
{
return;
}
// dont block Circle skillshots
if (max.SpellData.Type != SkillShotType.SkillshotCircle &&
max.SpellData.Type != SkillShotType.SkillshotRing)
{
return;
}
if (target.IsMe && E.IsReady())
{
CastShield(max.Start.To3D());
}
if (!target.IsMe && W.IsReady() && W.IsInRange(target) && (IsShieldActive || E.IsReady()))
{
var jumpTime = (Player.Distance(target) * 1000 / W.Instance.SData.MissileSpeed) +
(W.Instance.SData.SpellCastTime * 1000);
var missileTime = target.Distance(max.MissilePosition) * 1000 / max.SpellData.MissileSpeed;
if (jumpTime > missileTime)
{
Console.WriteLine("Abort Jump - Missile too Fast: {0} {1}", jumpTime, missileTime);
return;
}
W.CastOnUnit(target, UsePackets);
Utility.DelayAction.Add((int)jumpTime, () => CastShield(max.Start.To3D()));
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
private static bool DeadByRMark(Obj_AI_Hero target)
{
return(deathMark != null && target.Distance(deathMark) < target.BoundingRadius * 1.5);
}
private static void Interrupter2_OnInterruptableTarget(Obj_AI_Hero sender, Interrupter2.InterruptableTargetEventArgs args)
{
if (MainMenu._MainMenu.Item("Interrupt").GetValue <bool>() && sender.IsEnemy && _E.IsReady() && sender.Distance(Player) < 1150)
{
var EPosition = sender.ServerPosition.Extend(Player.Position, 400);
_E.Cast(EPosition, true);
return;
}
}
static int GetEnemiesNearHero(Obj_AI_Hero hero, float range)
{
return(HeroManager.Enemies.Where(x => x.IsEnemy && !x.IsDead && x.IsValidTarget() && hero.Distance(x.ServerPosition) < range).Count());
}
private static void OnProcessSpell(Obj_AI_Base unit, GameObjectProcessSpellCastEventArgs castedSpell)
{
if (unit.Type != GameObjectType.obj_AI_Hero)
{
return;
}
if (unit.IsEnemy)
{
if (_config.Item("rdodge").GetValue <bool>() && _r.IsReady() && UltStage == UltCastStage.First &&
_config.Item("ds" + unit.SkinName).GetValue <bool>())
{
if (DangerDB.DangerousList.Any(spell => spell.Contains(castedSpell.SData.Name)) &&
(unit.Distance(_player.ServerPosition) < 650f || _player.Distance(castedSpell.End) <= 250f))
{
if (castedSpell.SData.Name == "SyndraR")
{
clockon = Environment.TickCount + 150;
countdanger = countdanger + 1;
}
else
{
_r.Cast(unit);
}
}
}
}
if (unit.IsMe && castedSpell.SData.Name == "zedult")
{
ticktock = Environment.TickCount + 200;
}
}
public static void UseItems(Obj_AI_Hero target, Menu config, float comboDmg = 0f, bool cleanseSpell = false)
{
if (config.Item("hyd").GetValue <bool>() && player.BaseSkinName != "Renekton")
{
castHydra(target);
}
if (config.Item("hyd").GetValue <bool>())
{
hydraTarget = target;
useHydra = true;
}
else
{
useHydra = false;
}
if (config.Item("ran").GetValue <bool>() && Items.HasItem(randuins.Id) && Items.CanUseItem(randuins.Id))
{
if (target != null && player.Distance(target) < randuins.Range &&
player.CountEnemiesInRange(randuins.Range) >= config.Item("ranmin").GetValue <Slider>().Value)
{
Items.UseItem(randuins.Id);
}
}
if (config.Item("odin").GetValue <bool>() && target != null && Items.HasItem(odins.Id) &&
Items.CanUseItem(odins.Id))
{
var odinDmg = Damage.GetItemDamage(player, target, Damage.DamageItems.OdingVeils);
if (config.Item("odinonlyks").GetValue <bool>())
{
if (odinDmg > target.Health)
{
odins.Cast(target);
}
}
else if (player.CountEnemiesInRange(odins.Range) >= config.Item("odinmin").GetValue <Slider>().Value ||
(Math.Max(comboDmg, odinDmg) > target.Health && player.HealthPercent < 30 &&
player.Distance(target) < odins.Range && !CombatHelper.CheckCriticalBuffs(target)))
{
odins.Cast();
}
}
if (target != null && config.Item("bil").GetValue <bool>() && Items.HasItem(bilgewater.Id) &&
Items.CanUseItem(bilgewater.Id))
{
var bilDmg = Damage.GetItemDamage(player, target, Damage.DamageItems.Bilgewater);
if (config.Item("bilonlyks").GetValue <bool>())
{
if (bilDmg > target.Health)
{
bilgewater.Cast(target);
}
}
else if ((player.Distance(target) > config.Item("bilminr").GetValue <Slider>().Value&&
IsHeRunAway(target) && (target.Health / target.MaxHealth * 100f) < 40 &&
target.Distance(player) > player.AttackRange) ||
(Math.Max(comboDmg, bilDmg) > target.Health && (player.Health / player.MaxHealth * 100f) < 50) ||
IsURF)
{
bilgewater.Cast(target);
}
}
if (target != null && config.Item("botr").GetValue <bool>() && Items.HasItem(botrk.Id) &&
Items.CanUseItem(botrk.Id))
{
var botrDmg = Damage.GetItemDamage(player, target, Damage.DamageItems.Botrk);
if (config.Item("botronlyks").GetValue <bool>())
{
if (botrDmg > target.Health)
{
botrk.Cast(target);
}
}
else if ((player.Distance(target) > config.Item("botrminr").GetValue <Slider>().Value&&
(player.Health / player.MaxHealth * 100f) <
config.Item("botrmyhealth").GetValue <Slider>().Value&&
(target.Health / target.MaxHealth * 100f) <
config.Item("botrenemyhealth").GetValue <Slider>().Value) ||
(IsHeRunAway(target) && (target.Health / target.MaxHealth * 100f) < 40 &&
target.Distance(player) > player.AttackRange) ||
(Math.Max(comboDmg, botrDmg) > target.Health && (player.Health / player.MaxHealth * 100f) < 50) ||
IsURF)
{
botrk.Cast(target);
}
}
if (target != null && config.Item("hex").GetValue <bool>() && Items.HasItem(hexgun.Id) &&
Items.CanUseItem(hexgun.Id))
{
var hexDmg = Damage.GetItemDamage(player, target, Damage.DamageItems.Hexgun);
if (config.Item("hexonlyks").GetValue <bool>())
{
if (hexDmg > target.Health)
{
hexgun.Cast(target);
}
}
else if ((player.Distance(target) > config.Item("hexminr").GetValue <Slider>().Value&&
IsHeRunAway(target) && (target.Health / target.MaxHealth * 100f) < 40 &&
target.Distance(player) > player.AttackRange) ||
(Math.Max(comboDmg, hexDmg) > target.Health && (player.Health / player.MaxHealth * 100f) < 50) ||
IsURF)
{
hexgun.Cast(target);
}
}
/*
* if (config.Item("Muramana").GetValue<bool>() &&
* ((!MuramanaEnabled && config.Item("MuramanaMinmana").GetValue<Slider>().Value < player.ManaPercent) ||
* (MuramanaEnabled && config.Item("MuramanaMinmana").GetValue<Slider>().Value > player.ManaPercent)))
* {
* if (Muramana.IsOwned() && Muramana.IsReady())
* {
* Muramana.Cast();
* }
* if (Muramana2.IsOwned() && Muramana2.IsReady())
* {
* Muramana2.Cast();
* }
* }
* MuramanaTime = System.Environment.TickCount;
*/
if (config.Item("you").GetValue <bool>() && Items.HasItem(youmuu.Id) && Items.CanUseItem(youmuu.Id) &&
target != null && player.Distance(target) < player.AttackRange + 50 && target.HealthPercent < 65)
{
youmuu.Cast();
}
if (Items.HasItem(frost.Id) && Items.CanUseItem(frost.Id) && target != null &&
config.Item("frost").GetValue <bool>())
{
if ((config.Item("frostmin").GetValue <Slider>().Value <= player.CountEnemiesInRange(2000) ||
target.HealthPercent < 40) &&
(target.HealthPercent < 40 && config.Item("frostlow").GetValue <bool>() ||
!config.Item("frostlow").GetValue <bool>()))
{
frost.Cast(target);
}
}
if (config.Item("Zhonya").GetValue <bool>())
{
if (((config.Item("Zhonyadmg").GetValue <Slider>().Value / 100f * player.Health <=
Program.IncDamages.GetAllyData(player.NetworkId).DamageTaken ||
Program.IncDamages.GetAllyData(player.NetworkId).DamageTaken > player.Health) ||
(Danger() && player.HealthPercent < 30)) && player.IsValidTarget(10, false))
{
if (Items.HasItem(Zhonya.Id) && Items.CanUseItem(Zhonya.Id))
{
Zhonya.Cast();
return;
}
if (Items.HasItem(Wooglet.Id) && Items.CanUseItem(Wooglet.Id))
{
Wooglet.Cast();
return;
}
}
}
if (config.Item("Seraph").GetValue <bool>())
{
if (((config.Item("SeraphdmgHP").GetValue <Slider>().Value / 100f * player.Health <=
Program.IncDamages.GetAllyData(player.NetworkId).DamageTaken ||
Program.IncDamages.GetAllyData(player.NetworkId).DamageTaken > player.Health) ||
(config.Item("SeraphdmgSh").GetValue <Slider>().Value / 100f * (150 + player.Mana * 0.2f) <=
Program.IncDamages.GetAllyData(player.NetworkId).DamageTaken)) || Danger())
{
if (Items.HasItem(Seraph.Id) && Items.CanUseItem(Seraph.Id))
{
Seraph.Cast();
}
if (Items.HasItem(SeraphDom.Id) && Items.CanUseItem(SeraphDom.Id))
{
SeraphDom.Cast();
}
}
}
if (Items.HasItem(solari.Id) && Items.CanUseItem(solari.Id) && config.Item("solari").GetValue <bool>())
{
if ((config.Item("solariminally").GetValue <Slider>().Value <= player.CountAlliesInRange(solari.Range) &&
config.Item("solariminenemy").GetValue <Slider>().Value <= player.CountEnemiesInRange(solari.Range)) ||
ObjectManager.Get <Obj_AI_Hero>()
.FirstOrDefault(
h => h.IsAlly && !h.IsDead && solari.IsInRange(h) && CombatHelper.CheckCriticalBuffs(h)) !=
null ||
(Program.IncDamages.IncomingDamagesAlly.Any(
a => a.Hero.HealthPercent < 50 && (a.DamageTaken > 150 || a.DamageTaken > a.Hero.Health))))
{
solari.Cast();
}
}
if (Items.HasItem(mountain.Id) && Items.CanUseItem(mountain.Id) && config.Item("mountain").GetValue <bool>())
{
if (config.Item("castonme").GetValue <bool>() &&
((player.Health / player.MaxHealth * 100f) < config.Item("mountainmin").GetValue <Slider>().Value ||
Program.IncDamages.GetAllyData(player.NetworkId).DamageTaken > player.Health) &&
(player.CountEnemiesInRange(700f) > 0 || CombatHelper.CheckCriticalBuffs(player)))
{
mountain.Cast(player);
return;
}
var targ =
ObjectManager.Get <Obj_AI_Hero>()
.Where(
h =>
h.IsAlly && !h.IsMe && !h.IsDead && player.Distance(h) < mountain.Range &&
config.Item("mountainpriority" + h.ChampionName).GetValue <Slider>().Value > 0 &&
((h.Health / h.MaxHealth * 100f) < config.Item("mountainmin").GetValue <Slider>().Value ||
Program.IncDamages.GetAllyData(h.NetworkId).DamageTaken > h.Health));
if (targ != null)
{
var finaltarg =
targ.OrderByDescending(
t => config.Item("mountainpriority" + t.ChampionName).GetValue <Slider>().Value)
.ThenBy(t => t.Health)
.FirstOrDefault();
if (finaltarg != null &&
(finaltarg.CountEnemiesInRange(700f) > 0 || finaltarg.UnderTurret(true) ||
CombatHelper.CheckCriticalBuffs(finaltarg)))
{
mountain.Cast(finaltarg);
}
}
}
if (config.Item("protoBelt").GetValue <bool>() && target != null && player.Distance(target) < 750)
{
if (config.Item("protoBeltEHealth").GetValue <Slider>().Value > target.HealthPercent &&
(player.Distance(target) > 150 ||
player.Distance(target) > Orbwalking.GetRealAutoAttackRange(target)))
{
if (Items.HasItem(ProtoBelt.Id) && Items.CanUseItem(ProtoBelt.Id))
{
var pred = Prediction.GetPrediction(
target, 0.25f, 100, 2000,
new[]
{
CollisionableObjects.Heroes, CollisionableObjects.Minions, CollisionableObjects.Walls,
CollisionableObjects.YasuoWall
});
if (pred.Hitchance >= HitChance.High)
{
ProtoBelt.Cast(pred.CastPosition);
}
}
}
}
if (config.Item("glp").GetValue <bool>() && target != null && player.Distance(target) < 650)
{
if (config.Item("glpEHealth").GetValue <Slider>().Value > target.HealthPercent)
{
if (Items.HasItem(GLP.Id) && Items.CanUseItem(GLP.Id))
{
var pred = Prediction.GetPrediction(
target, 0.25f, 100, 1500,
new[] { CollisionableObjects.Heroes, CollisionableObjects.YasuoWall });
if (pred.Hitchance >= HitChance.High)
{
GLP.Cast(pred.CastPosition);
}
}
}
}
if (config.Item("QSSEnabled").GetValue <bool>())
{
UseCleanse(config, cleanseSpell);
}
}
public static Obj_AI_Base GetPossibleTarget()
{
if (ForcedTarget != null)
{
if (InAutoAttackRange(ForcedTarget))
{
return(ForcedTarget);
}
ForcedTarget = null;
}
Obj_AI_Base 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);
}
}
if (CurrentMode == Mode.Harass || CurrentMode == Mode.Lasthit || CurrentMode == Mode.LaneClear || CurrentMode == Mode.LaneFreeze)
{
if (MyHero.ChampionName == "Azir")
{
foreach (
var minion in
from minion in
ObjectManager.Get <Obj_AI_Minion>().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(-125))
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);
}
}
float[] maxhealth;
if (CurrentMode == Mode.LaneClear || CurrentMode == Mode.Harass || CurrentMode == Mode.LaneFreeze)
{
if (MyHero.ChampionName == "Azir")
{
maxhealth = new float[] { 0 };
var maxhealth1 = maxhealth;
foreach (
var minion in
ObjectManager.Get <Obj_AI_Minion>()
.Where(minion => InSoldierAttackRange(minion) && minion.Name != "Beacon" && minion.IsValidTarget() && 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);
}
}
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);
}
}
if (CurrentMode != Mode.LaneClear || ShouldWait())
{
//ResetAutoAttackTimer();
return(null);
}
if (MyHero.ChampionName == "Azir")
{
maxhealth = new float[] { 0 };
float[] maxhealth1 = maxhealth;
foreach (var minion in from minion in ObjectManager.Get <Obj_AI_Minion>()
.Where(minion => minion.IsValidTarget() && minion.Name != "Beacon" && InSoldierAttackRange(minion))
let predHealth = HealthPrediction.LaneClearHealthPrediction(minion, (int)((MyHero.AttackDelay * 1000) * LaneClearWaitTimeMod), FarmDelay(-125))
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);
}
}
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);
}
public static void UseComboItems(Obj_AI_Hero target, bool killSteal = false)
{
if (_menu == null || !_menu.Item(_menu.Name + ".enabled").GetValue <bool>())
{
return;
}
try
{
var distance = target == null ? 0 : target.Distance(ObjectManager.Player.Position, true);
if (distance >= Math.Pow(MaxRange, 2))
{
return;
}
foreach (var item in
Items.Where(
i =>
((i.Flags & _itemFlags) != 0) &&
_menu.Item(_menu.Name + "." + i.Name + ".combo").GetValue <bool>() && i.Item.IsOwned() &&
i.Item.IsReady() && distance <= Math.Pow(i.Range, 2) &&
(killSteal ||
ObjectManager.Player.CountEnemiesInRange(i.Range) >=
_menu.Item(_menu.Name + "." + i.Name + ".min-enemies-range").GetValue <Slider>().Value&&
ObjectManager.Player.HealthPercent <=
_menu.Item(_menu.Name + "." + i.Name + ".player-health-below").GetValue <Slider>().Value&&
ObjectManager.Player.HealthPercent >=
_menu.Item(_menu.Name + "." + i.Name + ".player-health-above").GetValue <Slider>().Value&&
(target == null ||
target.HealthPercent <=
_menu.Item(_menu.Name + "." + i.Name + ".target-health-below").GetValue <Slider>().Value&&
target.HealthPercent >=
_menu.Item(_menu.Name + "." + i.Name + ".target-health-above").GetValue <Slider>().Value)))
)
{
switch (item.CastType)
{
case CastType.Target:
item.Item.Cast(target);
break;
case CastType.Self:
item.Item.Cast(ObjectManager.Player);
break;
case CastType.None:
item.Item.Cast();
break;
case CastType.Position:
var prediction = Prediction.GetPrediction(target, item.Delay, item.Radius, item.Speed);
if (prediction.Hitchance >= HitChance.Medium)
{
item.Item.Cast(prediction.CastPosition);
}
break;
}
}
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
}
static void RapeTime()
{
Obj_AI_Hero possibleVictim = SimpleTs.GetTarget(R.Range * 2 + Orbwalking.GetRealAutoAttackRange(player), SimpleTs.DamageType.Magical);
try
{
if (rektmate.IsDead || Game.Time - assignTime > 1.5)
{
//Console.WriteLine("Unassign - " + rektmate.ChampionName + " dead: " + rektmate.IsDead + "\n\n");
rektmate = default(Obj_AI_Hero);
}
}
catch (Exception ex) { }
try
{
if (rektmate == default(Obj_AI_Hero) && IsRapeble(possibleVictim) > possibleVictim.Health)
{
rektmate = possibleVictim;
assignTime = Game.Time;
//Console.WriteLine("Assign - " + rektmate.ChampionName + " time: " + assignTime+"\n\n");
}
}
catch (Exception ex) { }
if (rektmate != default(Obj_AI_Hero))
{
//!(menu.SubMenu("misc").Item("TowerDive").GetValue<Slider>().Value < player.Health/player.MaxHealth && Utility.UnderTurret(rektmate, true)) &&
if (player.Distance(rektmate) < R.Range * 2 + Orbwalking.GetRealAutoAttackRange(player) && player.Distance(rektmate) > Q.Range)
{
CastR(rektmate.Position);
}
else if (player.Distance(rektmate) < Q.Range)
{
RaperinoCasterino(rektmate);
}
else
{
rektmate = default(Obj_AI_Hero); //Target is out of range. Unassign.
}
}
else
{
orbwalker.SetAttack(!Q.IsReady() && !E.IsReady());
if (menu.SubMenu("combo").Item("useQ").GetValue <bool>())
{
CastQ(true);
}
if (menu.SubMenu("combo").Item("useE").GetValue <bool>())
{
CastE(true);
}
if (menu.SubMenu("combo").Item("useW").GetValue <bool>())
{
CastW();
}
if (menu.SubMenu("combo").Item("useR").GetValue <bool>())
{
Obj_AI_Hero target = SimpleTs.GetTarget(R.Range, SimpleTs.DamageType.Magical);
if ((target.IsValidTarget(R.Range) && target.Distance(player) > Orbwalking.GetRealAutoAttackRange(player)) || R.IsKillable(target))
{
R.Cast(target, packetCast);
}
}
}
}
