public static RectangleContainer GetBestQRectangle(float qRange = 900f)
{
List<Vector2> predPos = (
from enemy in EntityManager.Heroes.Enemies.Where(x => x.IsValid && x.Distance(me) <= 2000)
select Prediction.Position.PredictUnitPosition(enemy, 750)).ToList();
int HighestHitCount = 0;
Geometry.Polygon.Rectangle bestRectangle = null;
for (int i = 0; i < 360; ++i)
{
Geometry.Polygon.Rectangle rect = new Geometry.Polygon.Rectangle(me.Position,
PointOnCircle(qRange, i), jannaQRadius);
var hitCount = predPos.Count(x => rect.IsInside(x));
if (hitCount > HighestHitCount)
{
HighestHitCount = hitCount;
bestRectangle = rect;
}
}
return new RectangleContainer(bestRectangle, HighestHitCount);
}
public static void CastQ()
{
var target = EntityManager.Heroes.Enemies.FirstOrDefault(x => x.IsValidTarget(Q.Range));
var ghost = ObjectManager.Get<Obj_AI_Minion>().FirstOrDefault(x => x.IsValidTarget(Q.Range) && x.HasBuff("illaoiespirit"));
if (target != null)
{
var ePred = E.GetPrediction(target);
//var saveMana = Player.Mana > Helpers.Rmana + Helpers.Wmana + Helpers.Qmana;
if ((Init.ComboMenu["useEQ"].Cast<CheckBox>().CurrentValue && ePred.HitChance >= HitChance.Medium && E.IsReady()) || !Q.IsReady()) return;
}
if (target != null && ghost != null)
{
var predPos = Prediction.Position.PredictLinearMissile(target, Q.Range, Q.Width, Q.CastDelay, Q.Speed, int.MaxValue, null, true);
var p = new Geometry.Polygon.Rectangle((Vector2) Player.ServerPosition,
Player.ServerPosition.Extend(ghost.ServerPosition, Q.Range), Q.Width);
if (p.IsInside(predPos.CastPosition))
{
Q.Cast(predPos.CastPosition);
}
}
if (target == null || !target.IsValidTarget(Q.Range) && ghost != null)
{
if (ghost != null && Player.Distance(ghost.ServerPosition) <= Q.Range)
Q.Cast(ghost);
}
if (target == null || ghost != null) return;
{
var predPos = Prediction.Position.PredictLinearMissile(target, Q.Range - target.BoundingRadius, Q.Width,
Q.CastDelay, Q.Speed, int.MaxValue, null, true);
if ((target.Health < Player.GetSpellDamage(target, SpellSlot.Q) && predPos.HitChance >= HitChance.Medium) || // Cast on target
(predPos.HitChance >= HitChance.High))
{
Q.Cast(predPos.CastPosition);
}
if ((!target.CanMove && !target.IsDashing())) // Cast on target
{
Q.Cast(target.ServerPosition);
}
}
}
private static void LineFarm(Spell spell, List <Obj_AI_Base> minions, int min, float overrideWidth = -1f)
{
var spellWidth = overrideWidth > 0 ? overrideWidth : spell.Width;
var totalHits = 0;
var castPos = Vector3.Zero;
var positions = (from minion in minions
let pred = spell.GetPrediction(minion)
where pred.Hitchance >= HitChance.Medium
select new Tuple <Obj_AI_Base, Vector3>(minion, pred.UnitPosition)).ToList();
if (positions.Any())
{
foreach (var position in positions)
{
var rect = new Geometry.Polygon.Rectangle(
ObjectManager.Player.Position, ObjectManager.Player.Position.Extend(position.Item2, spell.Range),
spellWidth);
var count =
positions.Select(
position2 =>
new Geometry.Polygon.Circle(position2.Item2, position2.Item1.BoundingRadius * 0.9f))
.Count(circle => circle.Points.Any(p => rect.IsInside(p)));
if (count > totalHits)
{
totalHits = count;
castPos = position.Item2;
}
if (totalHits == minions.Count)
{
break;
}
}
if (!castPos.Equals(Vector3.Zero) && totalHits >= min)
{
spell.Cast(castPos);
}
}
}
public static void KnockUpKill()
{
if (ObjectManager.Player.IsDashing())
{
return;
}
foreach (var enemy in HeroManager.Enemies.Where(e => e.IsValidTarget(1300f)))
{
var startPos = enemy.ServerPosition;
var endPos = ObjectManager.Player.ServerPosition.Extend(
startPos,
ObjectManager.Player.Distance(enemy) + LeeSinRKickDistance);
var rectangle = new Geometry.Polygon.Rectangle(startPos, endPos, LeeSinRKickWidth);
if (
HeroManager.Enemies.Where(x => rectangle.IsInside(x) && !x.IsDead)
.Any(i => spells[Spells.R].IsKillable(i)) && spells[Spells.R].CastOnUnit(enemy))
{
break;
}
}
}
public static void KnockUp()
{
if (ObjectManager.Player.IsDashing())
{
return;
}
var minREnemies = MyMenu.Menu.Item("ElLeeSin.Combo.R.Count").GetValue <Slider>().Value;
foreach (var enemy in HeroManager.Enemies.Where(e => e.IsValidTarget(1300f)))
{
var startPos = enemy.ServerPosition;
var endPos = ObjectManager.Player.ServerPosition.Extend(
startPos,
ObjectManager.Player.Distance(enemy) + LeeSinRKickDistance);
var rectangle = new Geometry.Polygon.Rectangle(startPos, endPos, LeeSinRKickWidth);
if (HeroManager.Enemies.Count(x => rectangle.IsInside(x)) >= minREnemies)
{
spells[Spells.R].Cast(enemy);
}
}
}
public static void QExtend(this PredictionResult PredictionResult)
{
var Rectangle = new Geometry.Polygon.Rectangle(PredictionResult.UnitPosition, Player.Instance.Position, Spells.Q2.Width);
var Collision = PredictionResult.CollisionObjects.OrderBy(x => x.Distance(Rectangle.Start) + x.Distance(Rectangle.End));
var QTarget = new Obj_AI_Base();
if (Collision != null)
{
foreach (var obj in Collision)
{
var Hitbox = new Geometry.Polygon.Rectangle(Player.Instance.Position.To2D(), Player.Instance.Position.Extend(obj.Position, Spells.Q2.Range), 75f);
if (Hitbox.IsInside(PredictionResult.CastPosition) && Spells.Q.IsInRange(obj))
{
QTarget = obj;
break;
}
}
}
if (QTarget != null || QTarget != new Obj_AI_Base())
{
Spells.Q.Cast(QTarget);
}
}
internal static Obj_AI_Minion SelectBall(Obj_AI_Base target)
{
if (target == null)
{
return(null);
}
Obj_AI_Minion theball = null;
var CastPosition = Syndra.Q.GetPrediction(target).CastPosition;
foreach (var ball in BallsList.Where(b => b != null && Syndra.E.IsInRange(b)))
{
var source = Player.Instance.PredictPosition();
var start = ball.ServerPosition.Extend(source, 100).To3D();
var end = source.Extend(ball.ServerPosition, Syndra.Eball.Range).To3D();
var rect = new Geometry.Polygon.Rectangle(start, end, Syndra.Eball.Width);
if (rect.IsInside(CastPosition))
{
theball = ball;
}
}
return(theball);
}
protected static void CastE(Obj_AI_Base Target = null)
{
Orbwalker.ForcedTarget = null;
var target = Target ?? E2.GetTarget();
if (target == null)
{
return;
}
if (!player.HasBuff("ViE") && CanCastE)
{
E.Cast();
}
var prediction = Prediction.Position.PredictLinearMissile(target, 600, 60, (int)player.AttackDelay, 3500, int.MaxValue, null, true);
var Rectangle = new Geometry.Polygon.Rectangle(prediction.UnitPosition, Player.Instance.Position, Q.Width);
var Collision = prediction.CollisionObjects.Where(x => x.IsValidTarget() && x.IsEnemy).OrderBy(x => x.Distance(Rectangle.Start) + x.Distance(Rectangle.End));
var collisiontarget = new Obj_AI_Base();
if (Collision != null)
{
foreach (var obj in Collision)
{
collisiontarget = null;
var Hitbox = new Geometry.Polygon.Rectangle(Player.Instance.Position.To2D(), Player.Instance.Position.Extend(obj.Position, 600), 120f);
if (Hitbox.IsInside(prediction.CastPosition) && Q.IsInRange(obj))
{
collisiontarget = obj;
break;
}
}
}
if (collisiontarget != null && collisiontarget != new Obj_AI_Base())
{
Orbwalker.ForcedTarget = collisiontarget;
}
}
private static int GetDravenDamage(Obj_AI_Base target)
{
int level = Player.Instance.Spellbook.GetSpell(SpellSlot.R).Level;
var base_damage = Player.Instance.CalculateDamageOnUnit(target, DamageType.Physical,
(new float[] { 0, 175, 275, 375 }[level] +
((Player.Instance.TotalAttackDamage - Player.Instance.BaseAttackDamage) * 1.1f)));
var total_damage = base_damage;
var polygon = new Geometry.Polygon.Rectangle(Player.Instance.Position, target.Position, 150);
foreach (var e in EloBuddy.SDK.EntityManager.Heroes.Enemies.Where(h => !h.IsDead))
{
if (polygon.IsInside(e))
{
total_damage *= .92f;
}
}
if (base_damage * .4f > total_damage)
{
return((int)(base_damage * .4f));
}
return((int)total_damage);
}
private static void OnProcessSpell(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
try
{
if (!sender.IsMe && sender.IsEnemy)
{
if (_MainMenu.Item("TahmKench_MyTeamMinEnable").GetValue <bool>() && sender.IsEnemy && _W.IsReady())
{
var SkillRange = new Geometry.Polygon.Rectangle(args.Start, args.End, sender.BoundingRadius + 30);
var Target = HeroManager.Allies.FirstOrDefault(f => f.Distance(Player.Position) <= _W.Range &&
!f.IsZombie && !f.IsDead && SkillRange.IsInside(f.Position) &&
_MainMenu.Item("TahmKench_MyTeamMin").GetValue <Slider>().Value >= f.HealthPercent);
if (Target != null)
{
_W.CastOnUnit(Target, true);
return;
}
if (args.Target != null)
{
var target = HeroManager.Allies.FirstOrDefault(f => f.Position.Distance(Player.Position) <= _W.Range &&
!f.IsZombie && !f.IsDead && f.HealthPercent <= _MainMenu.Item("TahmKench_MyTeamMin").GetValue <Slider>().Value);
if (target != null)
{
_W.CastOnUnit(target, true);
return;
}
}
}
if (_MainMenu.Item("TahmKench_AutoEUse").GetValue <bool>() && sender.IsEnemy && _E.IsReady() && Player.HealthPercent <= _MainMenu.Item("TahmKench_MinE").GetValue <Slider>().Value)
{
var target = new Geometry.Polygon.Rectangle(args.Start, args.End, sender.BoundingRadius + 30);
if (target != null)
{
_E.Cast(true);
return;
}
if (args.Target != null)
{
var TargetMe = HeroManager.Allies.FirstOrDefault(f => f.Position.Distance(Player.Position) <= 10);
if (TargetMe == Player)
{
_E.Cast(true);
return;
}
}
}
}
}
catch (Exception)
{
if (NowTime() > ErrorTime)
{
Chat.Print(ChampName + " in FreshBooster isn't Load. Error Code 08");
ErrorTime = TickCount(10000);
}
}
}
private void Game_OnUpdate(EventArgs args)
{
if (!ObjectManager.Player.IsDead)
{
if (Orbwalking.CanMove(100))
{
switch (MenuProvider.Orbwalker.ActiveMode)
{
case Orbwalking.OrbwalkingMode.Combo:
{
if (MenuProvider.Champion.Combo.UseQ)
{
if (_q.IsReadyPerfectly())
{
if (!ObjectManager.Player.IsDashing())
{
if (_hasPassive == false)
{
var target = TargetSelector.GetTarget(_q.Range, _q.DamageType);
if (target != null)
{
_q.CastOnUnit(target);
}
else
{
var extendedTarget = TargetSelector.GetTarget(_qExtended.Range,
_q.DamageType);
if (extendedTarget != null)
{
var minions =
MinionManager.GetMinions(ObjectManager.Player.ServerPosition,
_q.Range, MinionTypes.All, MinionTeam.NotAlly);
foreach (var minion in minions)
{
var box =
new Geometry.Polygon.Rectangle(
ObjectManager.Player.ServerPosition,
ObjectManager.Player.ServerPosition.Extend(
minion.ServerPosition, _qExtended.Range),
_qExtended.Width);
var prediction = _qExtended.GetPrediction(extendedTarget);
if (box.IsInside(prediction.UnitPosition))
{
if (prediction.Hitchance >= _q.MinHitChance)
{
_q.CastOnUnit(minion);
break;
}
}
}
}
}
}
else
{
var killableTarget =
HeroManager.Enemies.FirstOrDefault(
x =>
x.IsKillableAndValidTarget(_q.GetDamage(x),
TargetSelector.DamageType.Physical, _q.Range));
if (killableTarget != null)
{
_q.CastOnUnit(killableTarget);
}
}
}
}
}
if (MenuProvider.Champion.Combo.UseW)
{
if (_w.IsReadyPerfectly())
{
if (!ObjectManager.Player.IsDashing())
{
if (_hasPassive == false)
{
if (HeroManager.Enemies.Any(x => Orbwalking.InAutoAttackRange(x)))
{
var target = TargetSelector.GetTarget(_w.Range, _w.DamageType);
if (target != null)
{
_wNoCollision.Cast(target, false, true);
}
}
else
{
var target = TargetSelector.GetTargetNoCollision(_w);
if (target != null)
{
_w.Cast(target);
}
}
}
else
{
var killableTarget =
HeroManager.Enemies.FirstOrDefault(
x =>
x.IsKillableAndValidTarget(_w.GetDamage(x),
TargetSelector.DamageType.Physical, _w.Range) &&
_w.GetPrediction(x).Hitchance >= HitChance.High);
if (killableTarget != null)
{
_w.Cast(killableTarget);
}
}
}
}
}
break;
}
case Orbwalking.OrbwalkingMode.Mixed:
{
if (MenuProvider.Champion.Harass.UseQ)
{
if (_hasPassive == false)
{
if (_q.IsReadyPerfectly())
{
if (!ObjectManager.Player.IsDashing())
{
if (
ObjectManager.Player.IsManaPercentOkay(
MenuProvider.Champion.Harass.IfMana))
{
var target = TargetSelector.GetTarget(_q.Range, _q.DamageType);
if (target != null)
{
_q.CastOnUnit(target);
}
else
{
var extendedTarget = TargetSelector.GetTarget(_qExtended.Range,
_q.DamageType);
if (extendedTarget != null)
{
var minions =
MinionManager.GetMinions(
ObjectManager.Player.ServerPosition, _q.Range,
MinionTypes.All, MinionTeam.NotAlly);
foreach (var minion in minions)
{
var box =
new Geometry.Polygon.Rectangle(
ObjectManager.Player.ServerPosition,
ObjectManager.Player.ServerPosition.Extend(
minion.ServerPosition, _qExtended.Range),
_qExtended.Width);
var prediction = _qExtended.GetPrediction(extendedTarget);
if (box.IsInside(prediction.UnitPosition))
{
if (prediction.Hitchance >= _q.MinHitChance)
{
_q.CastOnUnit(minion);
break;
}
}
}
}
}
}
}
}
}
}
if (MenuProvider.Champion.Harass.UseW)
{
if (_w.IsReadyPerfectly())
{
if (!ObjectManager.Player.IsDashing())
{
if (ObjectManager.Player.IsManaPercentOkay(MenuProvider.Champion.Harass.IfMana))
{
if (_hasPassive == false)
{
if (HeroManager.Enemies.Any(x => Orbwalking.InAutoAttackRange(x)))
{
var target = TargetSelector.GetTarget(_w.Range, _w.DamageType);
if (target != null)
{
_wNoCollision.Cast(target, false, true);
}
}
else
{
var target = TargetSelector.GetTargetNoCollision(_w);
if (target != null)
{
_w.Cast(target);
}
}
}
else
{
var killableTarget =
HeroManager.Enemies.FirstOrDefault(
x =>
x.IsKillableAndValidTarget(_w.GetDamage(x),
TargetSelector.DamageType.Physical, _w.Range) &&
_w.GetPrediction(x).Hitchance >= HitChance.High);
if (killableTarget != null)
{
_w.Cast(killableTarget);
}
}
}
}
}
}
break;
}
case Orbwalking.OrbwalkingMode.LaneClear:
{
//Laneclear
if (MenuProvider.Champion.Laneclear.UseQ)
{
if (_hasPassive == false)
{
if (ObjectManager.Player.IsManaPercentOkay(MenuProvider.Champion.Laneclear.IfMana))
{
if (_q.IsReadyPerfectly())
{
if (!ObjectManager.Player.IsDashing())
{
var minions =
MinionManager.GetMinions(ObjectManager.Player.ServerPosition,
_q.Range);
foreach (var minion in minions)
{
var box =
new Geometry.Polygon.Rectangle(
ObjectManager.Player.ServerPosition,
ObjectManager.Player.ServerPosition.Extend(
minion.ServerPosition, _qExtended.Range),
_qExtended.Width);
if (minions.Count(x => box.IsInside(x.ServerPosition)) >= 3)
{
_q.CastOnUnit(minion);
break;
}
}
}
}
}
}
}
//Jungleclear
if (MenuProvider.Champion.Jungleclear.UseQ)
{
if (_hasPassive == false)
{
if (ObjectManager.Player.IsManaPercentOkay(MenuProvider.Champion.Jungleclear.IfMana))
{
if (_q.IsReadyPerfectly())
{
if (!ObjectManager.Player.IsDashing())
{
var target =
MinionManager.GetMinions(_q.Range, MinionTypes.All,
MinionTeam.Neutral, MinionOrderTypes.MaxHealth)
.FirstOrDefault(x => x.IsValidTarget(_q.Range));
if (target != null)
{
_q.CastOnUnit(target);
}
}
}
}
}
}
if (MenuProvider.Champion.Jungleclear.UseW)
{
if (_hasPassive == false)
{
if (ObjectManager.Player.IsManaPercentOkay(MenuProvider.Champion.Jungleclear.IfMana))
{
if (_w.IsReadyPerfectly())
{
if (!ObjectManager.Player.IsDashing())
{
var target =
MinionManager.GetMinions(_w.Range, MinionTypes.All,
MinionTeam.Neutral, MinionOrderTypes.MaxHealth)
.FirstOrDefault(x => x.IsValidTarget(_w.Range));
if (target != null)
{
_w.Cast(target);
}
}
}
}
}
}
break;
}
}
if (MenuProvider.Champion.Harass.AutoHarass)
{
if (MenuProvider.Orbwalker.ActiveMode != Orbwalking.OrbwalkingMode.Combo &&
MenuProvider.Orbwalker.ActiveMode != Orbwalking.OrbwalkingMode.Mixed)
{
if (!ObjectManager.Player.IsRecalling())
{
if (ObjectManager.Player.IsManaPercentOkay(MenuProvider.Champion.Harass.IfMana))
{
if (MenuProvider.Champion.Harass.UseQ)
{
var extendedTarget = TargetSelector.GetTarget(_qExtended.Range, _q.DamageType);
if (extendedTarget != null)
{
if (ObjectManager.Player.UnderTurret(true)
? !extendedTarget.UnderTurret(true)
: true)
{
var minions =
MinionManager.GetMinions(ObjectManager.Player.ServerPosition,
_q.Range, MinionTypes.All, MinionTeam.NotAlly);
foreach (var minion in minions)
{
var box =
new Geometry.Polygon.Rectangle(
ObjectManager.Player.ServerPosition,
ObjectManager.Player.ServerPosition.Extend(
minion.ServerPosition, _qExtended.Range),
_qExtended.Width);
var prediction = _qExtended.GetPrediction(extendedTarget);
if (box.IsInside(prediction.UnitPosition))
{
if (prediction.Hitchance >= _q.MinHitChance)
{
_q.CastOnUnit(minion);
break;
}
}
}
}
}
}
}
}
}
}
}
}
}
//------------------------------------AIHeroClient_OnProcessSpellCast-------------------------------------
static void AIHeroClient_OnProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
if (sender.IsEnemy)
{
if (Q.IsReady() && args.SData.Name.ToLower() == "summonerflash" && args.End.Distance(Player) <= Q.Range && Menu["AutoQFlash"].Cast<CheckBox>().CurrentValue)
{
//Chat.Print("{0} detected, Q on args.End", args.SData.Name);
var rectangle = new Geometry.Polygon.Rectangle(Player.Position, args.End, Q.Width+20);
if ( !EntityManager.MinionsAndMonsters.EnemyMinions.Any( it => rectangle.IsInside(it) ) ) Q.Cast(args.End);
return;
}
if (E.IsReady() && EMenu["UseShield?"].Cast<CheckBox>().CurrentValue && MenuSpells.Any(it => it == args.SData.Name))
{
if (EMenu[args.SData.Name].Cast<CheckBox>().CurrentValue)
{
List<AIHeroClient> Allies = new List<AIHeroClient>();
//Division
if (args.Target != null)
{
if (args.Target.IsAlly || args.Target.IsMe)
{
var target = EntityManager.Heroes.Allies.FirstOrDefault(it => it.NetworkId == args.Target.NetworkId);
//Chat.Print(args.Target.Name);
if (target != null)
{
int delay = (int)((sender.Distance(target) / ((args.SData.MissileMaxSpeed + args.SData.MissileMinSpeed) / 2)) * 1000 + args.SData.SpellCastTime - 300 - Game.Ping);
Core.DelayAction(() => E.Cast(target), delay);
//Chat.Print("Targetted detection");
}
return;
}
}
//Division
var rectangle = new Geometry.Polygon.Rectangle(args.Start, args.End, args.SData.LineWidth);
foreach (var ally in EntityManager.Heroes.Allies)
{
if (rectangle.IsInside(ally)) { Allies.Add(ally); continue; }
foreach (var point in rectangle.Points)
{
if (ally.Distance(point) <= 90)
{
Allies.Add(ally);
}
}
}
if (Allies.Any())
{
//Chat.Print("Rectangle Detection");
PriorityCast(sender, args, Allies, rectangle);
return;
}
//Division
var circle = new Geometry.Polygon.Circle(args.End, args.SData.CastRadius);
foreach (var ally in EntityManager.Heroes.Allies)
{
if (circle.IsInside(ally)) { Allies.Add(ally); continue; }
foreach (var point in circle.Points)
{
if (ally.Distance(point) <= 90)
{
Allies.Add(ally);
}
}
}
if (Allies.Any())
{
//Chat.Print("Circle Detection");
PriorityCast(sender, args, Allies, circle);
return;
}
}
}
}
return;
}
private static void Obj_AI_Base_OnProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
if (Player.Instance.IsDead || !Settings.UseSeraph || !Program.Seraph.IsOwned() || !Program.Seraph.IsReady())
{
return;
}
if (sender.IsMe)
{
return;
}
var heroSender = sender as AIHeroClient;
var target = args.Target as AIHeroClient;
if (heroSender != null && target != null && target.IsMe)
{
IncomingDamages.Add(new IncomingDamageArgs
{
Sender = heroSender,
Target = target,
Tick = (int)Game.Time * 1000,
Damage = heroSender.GetSpellDamage(target, args.Slot),
IsTargetted = true
});
}
if (heroSender != null && target == null)
{
if (args.SData.TargettingType == SpellDataTargetType.LocationAoe)
{
{
var polygon = new Geometry.Polygon.Circle(args.End, args.SData.CastRadius);
var polygon2 = new Geometry.Polygon.Circle(args.End, args.SData.CastRadiusSecondary);
if (polygon.IsInside(Player.Instance) || polygon2.IsInside(Player.Instance))
{
IncomingDamages.Add(new IncomingDamageArgs
{
Sender = heroSender,
Target = Player.Instance,
IsSkillShot = true,
Damage =
heroSender.GetSpellDamage(Player.Instance,
heroSender.GetSpellSlotFromName(args.SData.Name)),
Tick = (int)Game.Time * 1000,
IsTargetted = false,
IsTurretShot = false
});
}
}
}
else if (args.SData.TargettingType == SpellDataTargetType.Location ||
args.SData.TargettingType == SpellDataTargetType.Location2 ||
args.SData.TargettingType == SpellDataTargetType.Location3 ||
args.SData.TargettingType == SpellDataTargetType.LocationVector ||
args.SData.TargettingType == SpellDataTargetType.LocationVector ||
args.SData.TargettingType == SpellDataTargetType.LocationVector)
{
var range = SpellDatabase.GetSpellInfoList(heroSender).FirstOrDefault();
var polygon = new Geometry.Polygon.Rectangle(args.Start.To2D(),
args.Start.Extend(args.End, range?.Range ?? 1), args.SData.LineWidth);
if (polygon.IsInside(Player.Instance))
{
IncomingDamages.Add(new IncomingDamageArgs
{
Sender = heroSender,
Target = Player.Instance,
IsSkillShot = true,
Tick = (int)Game.Time * 1000,
Damage =
heroSender.GetSpellDamage(Player.Instance,
heroSender.GetSpellSlotFromName(args.SData.Name)),
IsTargetted = false,
IsTurretShot = false
});
}
}
}
}
public static void Execute()
{
var laneMinions =
EntityManager.MinionsAndMonsters.GetLaneMinions(EntityManager.UnitTeam.Enemy, Player.Instance.Position, 1000).ToList();
if (!laneMinions.Any() || !CanILaneClear())
{
return;
}
if (!Q.IsReady() || !Settings.LaneClear.UseQInLaneClear ||
(Player.Instance.ManaPercent < Settings.LaneClear.MinManaQ) || Player.Instance.IsUnderTurret())
{
return;
}
var qMinions = laneMinions.Where(x => x.IsValidTarget(Q.Range) && !Player.Instance.Position.IsWallBetween(x.Position)).ToList();
if (!qMinions.Any())
{
return;
}
var last = 0;
Obj_AI_Minion lastMinion = null;
foreach (var minion in qMinions)
{
var area = new Geometry.Polygon.Rectangle(Player.Instance.Position,
Player.Instance.Position.Extend(minion, Q.Range).To3D(), Q.Width);
var count = qMinions.Count(
x => new Geometry.Polygon.Circle(x.Position, x.BoundingRadius).Points.Any(k =>
area.IsInside(k)));
if (count <= last)
{
continue;
}
last = count;
lastMinion = minion;
}
if (last <= 0 || lastMinion == null)
{
return;
}
if (last >= Settings.LaneClear.MinMinionsHitQ && lastMinion.IsValidTarget(Q.Range))
{
Q.Cast(lastMinion);
}
}
private static void GameObject_OnCreate(GameObject sender, EventArgs args)
{
var missile = sender as MissileClient;
var caster = missile?.SpellCaster as AIHeroClient;
if (caster == null || missile == null || !caster.IsMe || !missile.IsValid)
{
return;
}
if (Database.SkillShotSpells.SkillShotsSpellsList.Any(s => caster != null && (s.hero == caster.Hero && s.MissileName.ToLower() == missile.SData.Name.ToLower())))
{
var spell = Database.SkillShotSpells.SkillShotsSpellsList.FirstOrDefault(s => caster != null && (s.hero == caster.Hero && s.MissileName.ToLower() == missile.SData.Name.ToLower()));
if (DetectedSpells.All(s => !spell.MissileName.Equals(s.spell.MissileName, StringComparison.CurrentCultureIgnoreCase) && caster.NetworkId != s.Caster.NetworkId))
{
var endpos = missile.StartPosition.Extend(missile.EndPosition, spell.Range).To3D();
if (spell.type == Database.SkillShotSpells.Type.LineMissile || spell.type == Database.SkillShotSpells.Type.CircleMissile)
{
var rect = new Geometry.Polygon.Rectangle(missile.StartPosition, endpos, spell.Width);
var collide =
ObjectManager.Get <Obj_AI_Base>()
.OrderBy(m => m.Distance(sender))
.FirstOrDefault(
s =>
s.Team != sender.Team &&
(((s.IsMinion || s.IsMonster || s is Obj_AI_Minion) && !s.IsWard() && spell.Collisions.Contains(Database.SkillShotSpells.Collision.Minions)) ||
s is AIHeroClient && spell.Collisions.Contains(Database.SkillShotSpells.Collision.Heros)) && rect.IsInside(s) && s.IsValidTarget());
if (collide != null)
{
endpos = collide.ServerPosition;
}
}
if (spell.type == Database.SkillShotSpells.Type.Cone)
{
var sector = new Geometry.Polygon.Sector(missile.StartPosition, endpos, spell.Angle, spell.Range);
var collide =
ObjectManager.Get <Obj_AI_Base>()
.OrderBy(m => m.Distance(sender))
.FirstOrDefault(
s =>
s.Team != sender.Team &&
(((s.IsMinion || s.IsMonster || s is Obj_AI_Minion) && !s.IsWard() && spell.Collisions.Contains(Database.SkillShotSpells.Collision.Minions)) ||
s is AIHeroClient && spell.Collisions.Contains(Database.SkillShotSpells.Collision.Heros)) && sector.IsInside(s) && s.IsValidTarget());
if (collide != null)
{
endpos = collide.ServerPosition;
}
}
//Chat.Print("OnCreate " + missile.SData.Name);
DetectedSpells.Add(
new ActiveSpells
{
spell = spell, Start = missile.StartPosition, End = missile.EndPosition, Width = spell.Width,
EndTime = (endpos.Distance(missile.StartPosition) / spell.Speed) + (spell.CastDelay / 1000) + Game.Time, Missile = missile, Caster = caster,
ArriveTime = (missile.StartPosition.Distance(Player.Instance) / spell.Speed) - (spell.CastDelay / 1000)
});
}
}
}
/// <summary>
/// Ranged Champions Logic.
/// </summary>
public static bool RangedLogic()
{
// TeamFighting Logic.
if (Core.GameTickCount - LastTeamFight < 1000 && Player.Instance.HealthPercent > 25 && !ModesManager.Flee && ObjectsManager.NearestEnemy != null && TeamTotal(ObjectsManager.NearestEnemy.PredictPosition()) >= TeamTotal(ObjectsManager.NearestEnemy.PredictPosition(), true) &&
(ObjectsManager.NearestEnemy.PredictPosition().UnderEnemyTurret() && SafeToDive || !ObjectsManager.NearestEnemy.PredictPosition().UnderEnemyTurret()))
{
// if there is a TeamFight move from NearestEnemy to nearestally.
if (ObjectsManager.SafestAllyToFollow2 != null)
{
Program.Moveto = "NearestEnemyToNearestAlly";
Position = ObjectsManager.NearestEnemy.PredictPosition().Extend(ObjectsManager.SafestAllyToFollow2.PredictPosition(), KiteDistance(ObjectsManager.NearestEnemy)).To3D();
return(true);
}
// if there is a TeamFight move from NearestEnemy to AllySpawn.
if (ObjectsManager.AllySpawn != null)
{
Program.Moveto = "NearestEnemyToAllySpawn";
Position = ObjectsManager.NearestEnemy.PredictPosition().Extend(ObjectsManager.AllySpawn.Position, KiteDistance(ObjectsManager.NearestEnemy)).To3D();
return(true);
}
}
// Tower Defence
if (Player.Instance.IsUnderHisturret() && ObjectsManager.FarthestAllyTurret != null && Player.Instance.HealthPercent >= 20)
{
if (ObjectsManager.FarthestAllyTurret.CountEnemiesInRange(ObjectsManager.FarthestAllyTurret.GetAutoAttackRange() + 50) > 0)
{
var enemy = EntityManager.Heroes.Enemies.OrderBy(o => o.Distance(ObjectsManager.FarthestAllyTurret)).FirstOrDefault(e => e.IsKillable(3000));
if (enemy != null && enemy.UnderEnemyTurret() && TeamTotal(enemy.PredictPosition()) >= TeamTotal(enemy.PredictPosition(), true))
{
Program.Moveto = "EnemyUnderTurret";
Position = enemy.PredictPosition().Extend(ObjectsManager.AllySpawn, KiteDistance(enemy)).To3D();
return(true);
}
}
}
// if Can AttackObject then start attacking THE DAMN OBJECT FFS.
if (ObjectsManager.NearestEnemyObject != null && Player.Instance.HealthPercent > 20 &&
(TeamTotal(ObjectsManager.NearestEnemyObject.Position) > TeamTotal(ObjectsManager.NearestEnemyObject.Position, true) || ObjectsManager.NearestEnemyObject.CountEnemiesInRange(1250) < 1))
{
var extendto = new Vector3();
if (ObjectsManager.AllySpawn != null)
{
extendto = ObjectsManager.AllySpawn.Position;
}
if (ObjectsManager.NearestMinion != null)
{
extendto = ObjectsManager.NearestMinion.Position;
}
if (ObjectsManager.NearestAlly != null)
{
extendto = ObjectsManager.NearestAlly.Position;
}
var extendtopos = ObjectsManager.NearestEnemyObject.Position.Extend(extendto, KiteDistance(ObjectsManager.NearestEnemyObject)).To3D();
var rect = new Geometry.Polygon.Rectangle(Player.Instance.ServerPosition, ObjectsManager.NearestEnemyObject.Position, 500);
var Enemy = EntityManager.Heroes.Enemies.Any(a => a != null && a.IsValidTarget() && new Geometry.Polygon.Circle(a.PredictPosition(), a.GetAutoAttackRange()).Points.Any(p => rect.IsInside(p)));
if (!Enemy)
{
if (ObjectsManager.EnemyTurret != null)
{
var TurretCircle = new Geometry.Polygon.Circle(ObjectsManager.EnemyTurret.ServerPosition, ObjectsManager.EnemyTurret.GetAutoAttackRange());
if (!TurretCircle.Points.Any(p => rect.IsInside(p)))
{
if (ObjectsManager.NearestEnemyObject is Obj_AI_Turret)
{
if (SafeToDive)
{
Program.Moveto = "NearestEnemyObject";
Position = extendtopos;
return(true);
}
}
else
{
Program.Moveto = "NearestEnemyObject2";
Position = extendtopos;
return(true);
}
}
}
else
{
Program.Moveto = "NearestEnemyObject3";
Position = extendtopos;
return(true);
}
}
}
// if SafestAllyToFollow2 exsists moves to SafestAllyToFollow2.
if (ObjectsManager.SafestAllyToFollow2 != null)
{
Program.Moveto = "SafestAllyToFollow2";
Position = ObjectsManager.SafestAllyToFollow2.PredictPosition().Random();
return(true);
}
// if Minion not exsist picks other to follow.
if (ObjectsManager.Minion != null)
{
Program.Moveto = "Minion";
Position = ObjectsManager.Minion.PredictPosition().Random();
return(true);
}
// if SecondTurret exsists moves to SecondTurret.
if (ObjectsManager.SecondTurret != null)
{
Program.Moveto = "SecondTurret";
Position = ObjectsManager.SecondTurret.ServerPosition.Extend(ObjectsManager.AllySpawn, 400).To3D().Random();
return(true);
}
// if SafeAllyTurret exsists moves to SafeAllyTurret.
if (ObjectsManager.SafeAllyTurret != null)
{
Program.Moveto = "SafeAllyTurret";
Position = ObjectsManager.SafeAllyTurret.ServerPosition.Extend(ObjectsManager.AllySpawn, 400).To3D().Random();
return(true);
}
// if ClosesetAllyTurret exsists moves to ClosesetAllyTurret.
if (ObjectsManager.ClosesetAllyTurret != null)
{
Program.Moveto = "ClosesetAllyTurret";
Position = ObjectsManager.ClosesetAllyTurret.ServerPosition.Extend(ObjectsManager.AllySpawn, 400).To3D().Random();
return(true);
}
// Well if it ends up like this then best thing is to let it end.
if (ObjectsManager.AllySpawn != null)
{
Program.Moveto = "AllySpawn3";
Position = ObjectsManager.AllySpawn.Position.Random();
return(true);
}
return(false);
}
public override void Combo()
{
var mode = ComboMenu.combobox("mode");
AIHeroClient target;
if (Qtarget() != null && Qtarget() is AIHeroClient && ComboMenu.checkbox("Q2"))
{
target = Qtarget() as AIHeroClient;
}
else if (Q.IsReady() && W.IsReady() && (ComboMenu.checkbox("WQ1") || ComboMenu.checkbox("WQ2")) && (ComboMenu.combobox("Wmode").Equals(0) || ComboMenu.combobox("Wmode").Equals(1)))
{
target = TargetSelector.GetTarget(Q.Range + 200, DamageType.Physical);
}
else if (Q.IsReady() && ComboMenu.checkbox("Q1"))
{
target = TargetSelector.GetTarget(Q.Range, DamageType.Physical);
}
else if (W.IsReady() && (TargetSelector.GetTarget(W.Range, DamageType.Physical) != null && WardJump.IsReady(TargetSelector.GetTarget(W.Range, DamageType.Physical).ServerPosition, true))
&& ComboMenu.combobox("Wmode") == 0 || ComboMenu.combobox("Wmode") == 1)
{
target = TargetSelector.GetTarget(W.Range, DamageType.Physical);
}
else if (E.IsReady() && ComboMenu.checkbox("E1"))
{
target = TargetSelector.GetTarget(E.Range, DamageType.Magical);
}
else if (R.IsReady())
{
target = TargetSelector.GetTarget(R.Range, DamageType.Physical);
}
else
{
target = TargetSelector.GetTarget(user.GetAutoAttackRange(), DamageType.Physical);
}
if (target == null)
{
return;
}
if (Qtarget() != null && Qtarget() is AIHeroClient)
{
var qtarget = Qtarget() as AIHeroClient;
if (Qtarget().NetworkId.Equals(target.NetworkId) && Q.GetDamage(qtarget) >= qtarget.PredHP(Q.CastDelay))
{
SpellsManager.Q(qtarget, false, true);
}
if (ComboMenu.checkbox("WQ2") && qtarget.IsKillable(1500) && !qtarget.IsKillable(1300) && WardJump.IsReady(user.ServerPosition.Extend(qtarget, 600).To3D(), true))
{
Chat.Print("leesin debug: WQ2");
WardJump.Jump(user.ServerPosition.Extend(qtarget, 600).To3D(), false, true);
Q2.Cast();
}
}
if (R.IsReady())
{
foreach (var enemy in EntityManager.Heroes.Enemies.Where(e => e.IsKillable(R.Range)))
{
var rec = new Geometry.Polygon.Rectangle(user.ServerPosition, user.ServerPosition.Extend(enemy.ServerPosition, 700).To3D(), target.BoundingRadius * 2);
if (EntityManager.Heroes.Enemies.Count(e => e.IsKillable() && rec.IsInside(e.PredPos(100))) >= ComboMenu.slider("Raoe"))
{
Chat.Print("leesin debug: Raoe");
R.Cast(enemy);
}
}
}
if (mode.Equals(0))
{
if (!target.IsKillable(Q.Range - 100) && target.IsKillable(Q.Range + 300) && ComboMenu.checkbox("WQ1")
&& WardJump.IsReady(user.ServerPosition.Extend(target.ServerPosition, 600).To3D()) && Q.IsReady())
{
Chat.Print("leesin debug: W Q");
WardJump.Jump(user.ServerPosition.Extend(target.ServerPosition, 600).To3D(), false, true);
return;
}
if (!target.IsKillable(user.GetAutoAttackRange() + 35) && Qtarget() != null && Qtarget() is AIHeroClient && Qtarget().NetworkId.Equals(target.NetworkId))
{
Chat.Print("leesin debug: Q gap");
if (ComboMenu.checkbox("Q2") && Q.IsReady())
{
Q2.Cast();
return;
}
}
if (Passive <= ComboMenu.slider("Passive") || SpellsManager.lastspelltimer > 2500)
{
if (E.IsReady() && target.IsKillable(E.Range))
{
Chat.Print("leesin debug: Ecombo");
SpellsManager.E(target, ComboMenu.checkbox("E1"), ComboMenu.checkbox("E2"));
return;
}
if (Q.IsReady() && target.IsKillable(Q.Range))
{
Chat.Print("leesin debug: Q combo");
if (Qtarget() != null && Qtarget() is AIHeroClient)
{
SpellsManager.Q(target, false, ComboMenu.checkbox("Q2"));
return;
}
SpellsManager.Q(target, ComboMenu.checkbox("Q1"));
return;
}
if (W.IsReady())
{
if (ComboMenu.combobox("Wmode").Equals(0) || ComboMenu.combobox("Wmode").Equals(1))
{
if (target.IsKillable(W.Range) && WardJump.IsReady(target.PredPos(200).To3D()) && !target.IsKillable(user.GetAutoAttackRange() + 35) && !target.IsKillable(E.Range)
&& !target.PredPos(200).IsInRange(user, user.GetAutoAttackRange() + 15))
{
Chat.Print("leesin debug: W WardJump");
WardJump.Jump(target.PredPos(200).Extend(user, -200).To3D(), false, true);
return;
}
}
if (ComboMenu.combobox("Wmode").Equals(2) || ComboMenu.combobox("Wmode").Equals(0))
{
if (target.IsKillable(user.GetAutoAttackRange()))
{
Chat.Print("leesin debug: W shield");
SpellsManager.W(user, true, true);
return;
}
}
}
}
if (R.IsReady())
{
if (R.GetDamage(target) >= target.TotalShieldHealth() && ComboMenu.checkbox("Rkill"))
{
Chat.Print("leesin debug: Rkill");
R.Cast(target);
return;
}
}
}
if (mode.Equals(1))
{
if (Core.GameTickCount - SpellsManager.LastR < 1500 && Core.GameTickCount - SpellsManager.LastR > 350)
{
Chat.Print("leesin debug: Q2 Star");
SpellsManager.Q(target, true, true);
return;
}
if (R.IsReady() && (WardJump.IsReady(target.ServerPosition) || target.IsKillable(R.Range)))
{
if (!target.IsKillable(R.Range) && (Q.IsReady() || Qtarget() == target))
{
if (WardJump.IsReady(target.ServerPosition, true) && target.IsKillable(W.Range) && ComboMenu.checkbox("Wj"))
{
Chat.Print("leesin debug: Wardjump Star");
WardJump.Jump(target.ServerPosition, false, true);
}
}
else
{
if (Qtarget() == null && Q.IsReady() && SpellsManager.Q1 && target.IsKillable(Q.Range))
{
Chat.Print("leesin debug: Q1 Star");
SpellsManager.Q(target, true);
}
else
{
if (ComboMenu.checkbox("bubba") && user.CountEnemeis(1000) > 1 && (Flash != null && Flash.IsReady() || WardJump.IsReady(target.ServerPosition, true)))
{
Chat.Print("leesin debug: Bubba Star");
BubbaKush.DoBubba(target);
}
else
{
if (target.IsKillable(R.Range) && Qtarget() != null && Qtarget().NetworkId.Equals(target.NetworkId))
{
Chat.Print("leesin debug: R Star");
R.Cast(target);
}
}
}
}
}
else
{
if (!target.IsKillable(Q.Range - 50) && target.IsKillable(Q.Range + 300) && ComboMenu.checkbox("WQ1")
&& WardJump.IsReady(user.ServerPosition.Extend(target.ServerPosition, 600).To3D(), true) && Q.IsReady() && ComboMenu.checkbox("Wj"))
{
Chat.Print("leesin debug: W Q");
WardJump.Jump(user.ServerPosition.Extend(target.ServerPosition, 600).To3D(), false, true);
return;
}
if (!target.IsKillable(user.GetAutoAttackRange() + 20) && Qtarget() != null && Qtarget() is AIHeroClient && Qtarget().NetworkId.Equals(target.NetworkId))
{
if (Q.IsReady() && !SpellsManager.Q1)
{
Chat.Print("leesin debug: Q gap");
Q2.Cast();
return;
}
}
if (Passive <= ComboMenu.slider("Passive") || SpellsManager.lastspelltimer > 2500)
{
if (E.IsReady() && target.IsKillable(E.Range + 15))
{
SpellsManager.E(target, true, true);
return;
}
if (Q.IsReady())
{
if (Qtarget() != null && Qtarget() is AIHeroClient)
{
SpellsManager.Q(target, false, true);
return;
}
SpellsManager.Q(target, true);
return;
}
if (W.IsReady())
{
if (ComboMenu.combobox("Wmode").Equals(0) || ComboMenu.combobox("Wmode").Equals(1))
{
if (ComboMenu.checkbox("Wj") && !target.IsKillable(user.GetAutoAttackRange() + 35) && target.IsKillable(W.Range)
&& !(Q.IsReady() && Q.GetPrediction(target).HitChance >= HitChance.Low))
{
Chat.Print("leesin debug: W WardJump");
WardJump.Jump(target.PredPos(200).Extend(user, -200).To3D(), false, true);
return;
}
}
if (ComboMenu.combobox("Wmode").Equals(2) || ComboMenu.combobox("Wmode").Equals(0))
{
if (target.IsKillable(user.GetAutoAttackRange()))
{
Chat.Print("leesin debug: W shield");
SpellsManager.W(user, true, true);
return;
}
}
}
if (R.IsReady() && target.IsKillable(R.Range))
{
if (R.GetDamage(target) >= target.TotalShieldHealth() && ComboMenu.checkbox("Rkill"))
{
Chat.Print("leesin debug: Rkill");
R.Cast(target);
}
}
}
}
}
}
private static void Game_OnGameUpdate(EventArgs args)
{
try
{
if (doubleClickReset <= Environment.TickCount && clickCount != 0)
{
doubleClickReset = float.MaxValue;
clickCount = 0;
}
if (clickCount >= 2)
{
resetTime = Environment.TickCount + 3000;
ClicksecEnabled = true;
InsecClickPos = Game.CursorPos;
clickCount = 0;
}
if (passiveTimer <= Environment.TickCount)
{
PassiveStacks = 0;
}
if (resetTime <= Environment.TickCount && !getKeyBindItem(InitMenu.insecMenu, "InsecEnabled")
&& ClicksecEnabled)
{
ClicksecEnabled = false;
}
if (q2Timer <= Environment.TickCount)
{
q2Done = false;
}
if (Player.IsDead || Player.LSIsRecalling())
{
return;
}
if ((getCheckBoxItem(InitMenu.insecMenu, "insecMode")
? TargetSelector.SelectedTarget
: TargetSelector.GetTarget(spells[Spells.Q].Range, DamageType.Physical)) == null)
{
insecComboStep = InsecComboStepSelect.None;
}
if (getKeyBindItem(InitMenu.comboMenu, "starCombo"))
{
WardCombo();
}
if (getCheckBoxItem(InitMenu.miscMenu, "ElLeeSin.Ignite.KS"))
{
var newTarget = TargetSelector.GetTarget(600f, DamageType.True);
if (newTarget != null && igniteSlot != SpellSlot.Unknown
&& Player.Spellbook.CanUseSpell(igniteSlot) == SpellState.Ready
&& ObjectManager.Player.GetSummonerSpellDamage(newTarget, Damage.SummonerSpell.Ignite)
> newTarget.Health)
{
Player.Spellbook.CastSpell(igniteSlot, newTarget);
}
}
if (getKeyBindItem(InitMenu.insecMenu, "InsecEnabled") && spells[Spells.R].IsReady())
{
if (getCheckBoxItem(InitMenu.insecMenu, "insecOrbwalk"))
{
Orbwalk(Game.CursorPos);
}
var newTarget = getCheckBoxItem(InitMenu.insecMenu, "insecMode")
? TargetSelector.SelectedTarget
: TargetSelector.GetTarget(
spells[Spells.Q].Range,
DamageType.Physical);
if (newTarget != null)
{
InsecCombo(newTarget);
}
}
else
{
isNullInsecPos = true;
wardJumped = false;
}
if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo))
{
insecComboStep = InsecComboStepSelect.None;
}
if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo))
{
Combo();
}
if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.LaneClear) ||
Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.JungleClear))
{
AllClear();
JungleClear();
}
if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Harass))
{
Harass();
}
if (getKeyBindItem(InitMenu.wardjumpMenu, "ElLeeSin.Wardjump"))
{
WardjumpToMouse();
}
if (getKeyBindItem(InitMenu.insecMenu, "ElLeeSin.Insec.UseInstaFlash"))
{
var target = TargetSelector.GetTarget(spells[Spells.R].Range, DamageType.Physical);
if (target == null)
{
return;
}
if (spells[Spells.R].IsReady() && !target.IsZombie
&& Player.Spellbook.CanUseSpell(flashSlot) == SpellState.Ready
&& target.LSIsValidTarget(spells[Spells.R].Range))
{
spells[Spells.R].CastOnUnit(target);
}
}
if (getCheckBoxItem(InitMenu.kickMenu, "ElLeeSin.Combo.New"))
{
float leeSinRKickDistance = 700;
float leeSinRKickWidth = 100;
var minREnemies = getSliderItem(InitMenu.kickMenu, "ElLeeSin.Combo.R.Count");
foreach (var enemy in HeroManager.Enemies)
{
var startPos = enemy.ServerPosition;
var endPos = Player.ServerPosition.ELExtend(
startPos,
Player.ELDistance(enemy) + leeSinRKickDistance);
var rectangle = new Geometry.Polygon.Rectangle(startPos, endPos, leeSinRKickWidth);
if (HeroManager.Enemies.Count(x => rectangle.IsInside(x)) >= minREnemies)
{
spells[Spells.R].Cast(enemy);
}
}
}
}
catch (Exception e)
{
Console.WriteLine("An error occurred: '{0}'", e);
}
}
private static void Obj_AI_Base_OnProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
if (Player.Instance.IsDead || !Settings.UseSeraph || !Program.Seraph.IsOwned() || !Program.Seraph.IsReady())
return;
if (sender.IsMe)
return;
var heroSender = sender as AIHeroClient;
var target = args.Target as AIHeroClient;
if (heroSender != null && target != null && target.IsMe)
{
IncomingDamages.Add(new IncomingDamageArgs
{
Sender = heroSender,
Target = target,
Tick = (int)Game.Time * 1000,
Damage = heroSender.GetSpellDamage(target, args.Slot),
IsTargetted = true
});
}
if (heroSender != null && target == null)
{
if (args.SData.TargettingType == SpellDataTargetType.LocationAoe)
{
{
var polygon = new Geometry.Polygon.Circle(args.End, args.SData.CastRadius);
var polygon2 = new Geometry.Polygon.Circle(args.End, args.SData.CastRadiusSecondary);
if (polygon.IsInside(Player.Instance) || polygon2.IsInside(Player.Instance))
{
IncomingDamages.Add(new IncomingDamageArgs
{
Sender = heroSender,
Target = Player.Instance,
IsSkillShot = true,
Damage =
heroSender.GetSpellDamage(Player.Instance,
heroSender.GetSpellSlotFromName(args.SData.Name)),
Tick = (int) Game.Time*1000,
IsTargetted = false,
IsTurretShot = false
});
}
}
}
else if (args.SData.TargettingType == SpellDataTargetType.Location ||
args.SData.TargettingType == SpellDataTargetType.Location2 ||
args.SData.TargettingType == SpellDataTargetType.Location3 ||
args.SData.TargettingType == SpellDataTargetType.LocationVector ||
args.SData.TargettingType == SpellDataTargetType.LocationVector ||
args.SData.TargettingType == SpellDataTargetType.LocationVector)
{
var range = SpellDatabase.GetSpellInfoList(heroSender).FirstOrDefault();
var polygon = new Geometry.Polygon.Rectangle(args.Start.To2D(),
args.Start.Extend(args.End, range?.Range ?? 1), args.SData.LineWidth);
if (polygon.IsInside(Player.Instance))
{
IncomingDamages.Add(new IncomingDamageArgs
{
Sender = heroSender,
Target = Player.Instance,
IsSkillShot = true,
Tick = (int) Game.Time*1000,
Damage =
heroSender.GetSpellDamage(Player.Instance,
heroSender.GetSpellSlotFromName(args.SData.Name)),
IsTargetted = false,
IsTurretShot = false
});
}
}
}
}
//---------------------------------------WhyInsec()-------------------------------------------------------
static void WhyInsec(Obj_AI_Base target, Vector3 cursorpos)
{
//Back distance = 300
//Why I did that
if (!WhyIDidThatAddonInsec && Orbwalker.ValidAzirSoldiers.Any(it => it.Distance(target) >= E.Width + target.BoundingRadius && it.Distance(target) <= (R.Width/2) - 50))
{
if (!WhyIDidThatAddonInsec)
WhyIDidThatAddonInsec = true;
Core.DelayAction(() => WhyIDidThatAddonInsec = false, 3000);
if (E.IsReady())
{
InsecSoldier = Orbwalker.ValidAzirSoldiers.Where(it => it.Distance(target) <= (R.Width / 2) - 50).OrderByDescending(it => it.Distance(target)).First();
var targetpos = Prediction.Position.PredictUnitPosition(target, 500).To3D();
var rectangle = new Geometry.Polygon.Rectangle(Player.Position, InsecSoldier.Position, E.Width + target.BoundingRadius);
if (!rectangle.IsInside(targetpos) && InsecSoldier.Distance(target) <= (R.Width / 2) - 50)
{
var EDelay = (int)((((Player.Distance(InsecSoldier) - 100) / 8) * 5));
if (E.Cast(CorrectRange(InsecSoldier.Position, E.Range)))
{
//Delayed insec
Core.DelayAction(delegate
{
if (Player.Spellbook.CastSpell(SpellSlot.Q, CursorCorrectRange(Q.Range)))
{
LastQTime = Game.Time;
}
else WhyIDidThatAddonInsec = false;
}, EDelay);
}
else WhyIDidThatAddonInsec = false;
}
else { WhyIDidThatAddonInsec = false; }
}
else WhyIDidThatAddonInsec = false;
}
return;
}
public static int CountEnemiesInLine(this Obj_AI_Base obj, Vector3 endpos, float width, float range)
{
var line = new Geometry.Polygon.Rectangle(obj.Position, endpos, width);
var enemies = EntityManager.Heroes.Enemies.Where(x => line.IsInside(x) && x.IsValidTarget() && x.IsInRange(obj, range)).Count();
return enemies;
}
private static void QCast(Obj_AI_Base target, bool transfer = false, int HitCount = -1)
{
/*
* var pred = Prediction.Position.GetPrediction(
* new Prediction.Manager.PredictionInput
* {
* Range = Q.Range, Delay = Q.CastDelay, Radius = Q.Radius, Target = target, Type = SkillShotType.Linear, From = user.ServerPosition, Speed = Q.Speed,
* CollisionTypes = new HashSet<CollisionType> { CollisionType.AiHeroClient, CollisionType.ObjAiMinion, CollisionType.YasuoWall }, RangeCheckFrom = user.ServerPosition
* });*/
var collidelist = new List <Obj_AI_Base>();
collidelist.Clear();
var pred = Q.GetPrediction(target);
var CastPos = pred.CastPosition;
var rect = new Geometry.Polygon.Rectangle(user.ServerPosition, CastPos, Q.Width);
if (pred.HitChance < HitChance.Medium)
{
return;
}
collidelist.AddRange(EntityManager.MinionsAndMonsters.EnemyMinions.Where(m => new Geometry.Polygon.Circle(m.ServerPosition, m.BoundingRadius).Points.Any(p => rect.IsInside(p)) && !m.IsDead && m.IsValidTarget()));
if (HitCount == -1)
{
collidelist.AddRange(EntityManager.MinionsAndMonsters.GetJungleMonsters().Where(m => new Geometry.Polygon.Circle(m.ServerPosition, m.BoundingRadius).Points.Any(p => rect.IsInside(p)) && !m.IsDead && m.IsValidTarget()));
collidelist.AddRange(EntityManager.Heroes.Enemies.Where(m => new Geometry.Polygon.Circle(m.ServerPosition, m.BoundingRadius).Points.Any(p => rect.IsInside(p)) && m.NetworkId != target.NetworkId && !m.IsDead && m.IsValidTarget()));
//Chat.Print(collidelist.Count(o => Q.WillKill(o)) - collidelist.Count);
if (collidelist.Count(o => Q.WillKill(o)) - collidelist.Count == 0)
{
if (transfer)
{
if (collidelist.Any(o => EKill(o, target)))
{
Q.Cast(CastPos);
}
}
else
{
Q.Cast(CastPos);
}
}
}
else
{
if (collidelist.Count(o => Q.WillKill(o)) >= HitCount)
{
Q.Cast(CastPos);
}
}
}
public static bool WillStun(this PredictionResult pred)
{
var EndPoint = Player.Instance.Position.Extend(pred.CastPosition, Spells.Q.Range).To3D();
var Rectangle = new Geometry.Polygon.Rectangle(Player.Instance.Position, EndPoint, Spells.Q.Width);
var Count = ObjectManager.Get <Obj_AI_Base>().Where(x => x.IsValidTarget() && Rectangle.IsInside(x)).Count();
if (pred.CollisionObjects.Any())
{
return(true);
}
if (Count >= 2)
{
return(true);
}
var Distance = Spells.Q.Range - Player.Instance.Distance(pred.UnitPosition);
float checkDistance = Distance / 50f;
for (int i = 0; i <= 50; i++)
{
Vector3 finalPosition = Player.Instance.Position.Extend(pred.UnitPosition, Player.Instance.Distance(pred.UnitPosition) + i * checkDistance).To3DWorld();
if (finalPosition.IsWall() || finalPosition.IsBuilding())
{
return(true);
}
}
return(false);
}
public static void DoBubba(AIHeroClient target = null, bool draw = false)
{
if (target == null)
{
target = new AIHeroClient();
switch (RMenu.combobox("list"))
{
case 0:
target = Qtarget() != null
? EntityManager.Heroes.Enemies.OrderBy(e => e.Distance(user)).FirstOrDefault(e => e.PredHP(250) > R.GetDamage(e) && Qtarget().IsInRange(e.PredPos(250), 450))
: EntityManager.Heroes.Enemies.OrderBy(e => e.PredPos(250).Distance(user))
.FirstOrDefault(e => e.PredHP(250) > R.GetDamage(e) && WardJump.IsReady(e.ServerPosition) ? e.IsKillable(W.Range) : e.IsKillable(R.Range));
break;
case 1:
target = Qtarget() != null
? EntityManager.Heroes.Enemies.OrderBy(e => e.Distance(user)).FirstOrDefault(e => e.PredHP(250) > R.GetDamage(e) && Qtarget().IsInRange(e.PredPos(250), 450))
: EntityManager.Heroes.Enemies.OrderBy(e => e.PredPos(250).Distance(user))
.FirstOrDefault(e => e.PredHP(250) > R.GetDamage(e) && WardJump.IsReady(e.ServerPosition) ? e.IsKillable(W.Range) : e.IsKillable(R.Range));
break;
case 2:
target = Qtarget() != null
? EntityManager.Heroes.Enemies.OrderBy(e => e.MaxHealth).FirstOrDefault(e => e.PredHP(250) > R.GetDamage(e) && Qtarget().IsInRange(e.PredPos(250), 450))
: EntityManager.Heroes.Enemies.OrderBy(e => e.MaxHealth)
.FirstOrDefault(e => e.PredHP(250) > R.GetDamage(e) && WardJump.IsReady(e.ServerPosition) ? e.IsKillable(W.Range) : e.IsKillable(R.Range));
break;
}
}
if (target == null)
{
if (!draw)
{
Orbwalker.OrbwalkTo(Game.CursorPos);
}
return;
}
var enemy = EntityManager.Heroes.Enemies.OrderBy(e => e.Health).FirstOrDefault(e => e.IsKillable() && !e.NetworkId.Equals(target.NetworkId) && e.IsInRange(target, 750));
if (enemy == null)
{
if (!draw)
{
Orbwalker.OrbwalkTo(Game.CursorPos);
}
return;
}
Pos = target.PredPos(250).Extend(enemy.PredPos(300), -275).To3D();
var rec = new Geometry.Polygon.Rectangle(target.PredPos(200), target.PredPos(200).Extend(enemy.PredPos(250), 750), target.BoundingRadius * 2);
if (draw)
{
Circle.Draw(Color.White, 100, Pos);
rec.Draw(System.Drawing.Color.White, 2);
return;
}
if (!R.IsReady())
{
Orbwalker.OrbwalkTo(Game.CursorPos);
return;
}
if (target.IsKillable(R.Range) || user.IsInRange(Pos, 125))
{
if (Flash != null && Flash.IsReady() && !WardJump.IsReady(Pos))
{
Chat.Print("leesin debug: RFlash");
R.Cast(target);
Rflash = Core.GameTickCount;
}
if (user.IsInRange(Pos, 100))
{
Chat.Print("leesin debug: RInRange");
R.Cast(target);
}
foreach (var ene in EntityManager.Heroes.Enemies.Where(e => e.IsKillable(R.Range)))
{
if (ene != null)
{
var rect = new Geometry.Polygon.Rectangle(user.ServerPosition, user.ServerPosition.Extend(ene.PredPos(200), ene.BoundingRadius * 2).To3D(), 200);
if (EntityManager.Heroes.Enemies.Count(e => rect.IsInside(e)) > 1)
{
Chat.Print("leesin debug: Rfix");
R.Cast(ene);
}
}
}
if (SpellsManager.Wtimer < 1500)
{
Chat.Print("leesin debug: RpW");
R.Cast(target);
}
}
else
{
Orbwalker.OrbwalkTo(Game.CursorPos);
}
if (Qtarget() != null && Qtarget().IsInRange(target, 300) && !target.IsKillable(R.Range) && !W.IsInRange(Pos) && (WardJump.IsReady(Pos) || Flash != null && Flash.IsReady())
&& !user.IsInRange(Pos, 125))
{
Chat.Print("leesin debug: qcast");
Q2.Cast();
}
else
{
Orbwalker.OrbwalkTo(Game.CursorPos);
}
if (WardJump.IsReady(Pos) && target.IsKillable(600))
{
if (!(target.IsKillable(R.Range) && Flash != null && Flash.IsReady()))
{
Chat.Print("leesin debug: WardJump");
WardJump.Jump(Pos, true);
}
}
else
{
Orbwalker.OrbwalkTo(Game.CursorPos);
}
var RF = user.ServerPosition.Extend(target.ServerPosition, 600).To3D();
if (WardJump.IsReady(target.ServerPosition) && target.IsInRange(RF, R.Range - 100))
{
if (!target.IsKillable(R.Range) && Flash != null && Flash.IsReady())
{
Chat.Print("leesin debug: WardJump R Flash");
WardJump.Jump(RF, true);
}
}
else
{
Orbwalker.OrbwalkTo(Game.CursorPos);
}
}
private static void CastQ()
{
if (!Q.IsReady())
{
return;
}
var target = TargetSelector.GetTarget(Q.Range, DamageType.Physical);
if (target == null)
{
return;
}
if (target.IsValidTarget(Q.Range))
{
var predq = Q.GetPrediction(target);
Q.Cast(predq.CastPosition);
}
var target2 = TargetSelector.GetTarget(Q2.Range, DamageType.Physical);
if (target2 == null)
{
return;
}
var pred = Q2.GetPrediction(target2);
var collisions = EntityManager.MinionsAndMonsters.EnemyMinions.Where(it => it.IsValidTarget(Q.Range)).ToList();
if (!collisions.Any())
{
return;
}
foreach (var minion in collisions)
{
var poly = new Geometry.Polygon.Rectangle(
(Vector2)Player.ServerPosition,
Player.ServerPosition.Extend(minion.ServerPosition, Q2.Range),
Q2.Width);
if (poly.IsInside(pred.UnitPosition))
{
Q.Cast(minion.Position);
}
}
}
public static void UpdateTask()
{
Program.Evade.CacheSkillshots();
GameObject wall = null;
foreach (var gameObject in ObjectManager.Get<GameObject>())
{
if (gameObject.IsValid &&
System.Text.RegularExpressions.Regex.IsMatch(
gameObject.Name, "_w_windwall.\\.troy",
System.Text.RegularExpressions.RegexOptions.IgnoreCase))
{
wall = gameObject;
}
}
if (wall != null)
{
var level = wall.Name.Substring(wall.Name.Length - 6, 1);
var wallWidth = (300 + 50*Convert.ToInt32(level));
var wallDirection = (wall.Position.To2D() - YasuoWallCastedPos).Normalized().Perpendicular();
var wallStart = wall.Position.To2D() + wallWidth/2*wallDirection;
var wallEnd = wallStart - wallWidth*wallDirection;
var wallPolygon = new Geometry.Polygon.Rectangle(wallStart, wallEnd, 75);
foreach (var activeSkillshot in EvadePlus.Program.Evade.SkillshotDetector.ActiveSkillshots.Where(a => (a is LinearMissileSkillshot) && EvadeMenu.IsSkillshotW(a)))
{
if (wallPolygon.IsInside(activeSkillshot.GetPosition()))
{
activeSkillshot.IsValid = false;
}
}
}
if (Program.Evade.IsHeroInDanger(Player.Instance))
{
if (Player.GetSpell(SpellSlot.W).State == SpellState.Ready)
{
foreach (var activeSkillshot in EvadePlus.Program.Evade.SkillshotDetector.ActiveSkillshots.Where(a => a is LinearMissileSkillshot && EvadePlus.EvadeMenu.IsSkillshotW(a)))
{
if (activeSkillshot.ToPolygon().IsInside(Player.Instance))
{
Player.CastSpell(SpellSlot.W, activeSkillshot.GetPosition());
return;
}
}
}
if (Player.GetSpell(SpellSlot.E).State == SpellState.Ready)
{
foreach (
var source in
EntityManager.MinionsAndMonsters.EnemyMinions.Where(
a => a.Team != Player.Instance.Team && a.Distance(Player.Instance) < 475 && a.CanDash()))
{
if(source.GetDashPos().IsUnderTower()) continue;
if (EvadePlus.Program.Evade.IsPointSafe(source.GetDashPos().To2D()))
{
int count = 0;
for (int i = 0; i < 10; i += 47)
{
if(!EvadePlus.Program.Evade.IsPointSafe(Player.Instance.Position.Extend(source.GetDashPos(), i)))
{
count ++;
}
}
if (count > 3) continue;
Player.CastSpell(SpellSlot.E, source);
break;
}
}
foreach (
var source in
EntityManager.Heroes.Enemies.Where(
a => a.IsEnemy && a.Distance(Player.Instance) < 475 && a.CanDash()))
{
if (source.GetDashPos().IsUnderTower()) continue;
if (EvadePlus.Program.Evade.IsPointSafe(source.GetDashPos().To2D()))
{
int count = 0;
for (int i = 0; i < 10; i += 47)
{
if(!EvadePlus.Program.Evade.IsPointSafe(Player.Instance.Position.Extend(source.GetDashPos(), i)))
{
count ++;
}
}
if (count > 3) continue;
Player.CastSpell(SpellSlot.E, source);
break;
}
}
}
}
}
/// <summary>
/// Casts AoE spell with selected hitchance.
/// </summary>
private static bool CastLineAoE(this Spell.SpellBase spell, Obj_AI_Base target, HitChance hitChance, int hits = 2)
{
var skillshot = spell as Spell.Skillshot;
if (target != null && skillshot != null && skillshot.IsReady() && target.IsKillable(skillshot.Range))
{
var pred = spell.GetPrediction(target);
var rect = new Geometry.Polygon.Rectangle(Player.Instance.ServerPosition, Player.Instance.ServerPosition.Extend(pred.CastPosition, skillshot.Range).To3D(), skillshot.Width);
if (EntityManager.Heroes.Enemies.Count(e => e != null && e.IsKillable(skillshot.Range) && skillshot.GetPrediction(e).HitChance >= hitChance && rect.IsInside(skillshot.GetPrediction(e).CastPosition)) >= hits)
{
return(skillshot.Cast(pred.CastPosition));
}
}
return(false);
}
public override void Execute()
{
var target = Program.CurrentTarget;
if (target == null || target.HasUndyingBuff())
return;
if (Config.MiscMenu.UseIgnite && Program.Ignite != null &&
Program.Ignite.IsReady() && Program.Ignite.IsInRange(Program.CurrentTarget))
{
var damage = 50 + (20*Player.Instance.Level);
if (!Program.CurrentTarget.CanMove &&
Program.CurrentTarget.GetComboDamage() + damage >= Program.CurrentTarget.Health)
{
Program.Ignite.Cast(Program.CurrentTarget);
}
}
if (Settings.UseQ && Q.IsReady() && target.IsInRange(Player.Instance, Q.Range))
{
var prediction = Q.GetPrediction(target);
if (prediction.HitChancePercent >= 70)
{
Q.Cast(prediction.CastPosition);
}
}
if (Settings.UseW && W.IsReady() && Player.Instance.IsInRange(target, W.Range-50))
{
W.Cast();
}
if (Settings.UseE && E.IsReady())
{
var prediction = E.GetPrediction(target);
if (prediction.HitChancePercent >= 98 && (target.IsInRange(Player.Instance, 800)|| !target.CanMove))
{
E.Cast(prediction.CastPosition);
}
if (prediction.HitChancePercent >= 80 && target.IsInRange(Player.Instance, 800) && NavMesh.IsWallOfGrass(Player.Instance.Position, 0))
{
E.Cast(prediction.CastPosition);
}
}
if (R.IsReady())
{
if (Settings.UseRAfterPlayer && !Player.HasBuff("AhriTumble"))
return;
var rtarget = TargetSelector.GetTarget(E.Range + R.Range, DamageType.Magical);
if (rtarget == null)
return;
if (rtarget.IsUnderHisturret() && Settings.UseRToDive)
{
if (rtarget.GetComboDamage() >= rtarget.Health*1.20f &&
Player.Instance.CountEnemiesInRange(1200) <= 1)
{
R.Cast(rtarget.Distance(Player.Instance) > 600
? Player.Instance.Position.Extend(rtarget, 399).To3D()
: Player.Instance.Position.Extend(Game.CursorPos, 399).To3D());
}
}
else
{
if (rtarget.GetComboDamage() >= rtarget.Health &&
Player.Instance.CountEnemiesInRange(1200) <= 1)
{
R.Cast(rtarget.Distance(Player.Instance) > 600
? Player.Instance.Position.Extend(rtarget, 399).To3D()
: Player.Instance.Position.Extend(Game.CursorPos, 399).To3D());
}
}
if (Program.QReturnMissile != null && Player.HasBuff("AhriTumble") && Player.GetBuff("AhriTumble").Count <= 2)
{
for (var i = -360; i < 360; i += 100)
{
var qReturnMissile = Program.QReturnMissile;
var qpolygon = new Geometry.Polygon.Rectangle(Player.Instance.Position,
qReturnMissile.StartPosition, 100);
if (qpolygon.IsInside(rtarget))
break;
var q =
Player.Instance.Position.Extend(qReturnMissile, i)
.RotateAroundPoint(qReturnMissile.Position.To2D(), i);
var polygonsahead = new Geometry.Polygon.Rectangle(Player.Instance.Position.Extend(q, i),
Player.Instance.Position.Extend(q, qReturnMissile.Distance(Player.Instance)), 100);
var polygonsbehind = new Geometry.Polygon.Rectangle(Player.Instance.Position.Extend(q, i),
Player.Instance.Position.Extend(q, -qReturnMissile.Distance(Player.Instance)), 100);
if (polygonsahead.IsInside(rtarget) || polygonsbehind.IsInside(rtarget))
{
var prediction = Prediction.Position.PredictLinearMissile(rtarget, SpellManager.Q.Range, 100,
250, 1500, int.MaxValue,
Player.Instance.Position.Extend(q, i).To3D());
if (prediction.HitChance == HitChance.High)
R.Cast(prediction.CastPosition);
}
}
}
}
}
private static void Game_OnUpdate(EventArgs args)
{
switch (Program.insecmode)
{
case 0:
var hero = HeroManager.Allies.Where(x => !x.IsMe && !x.IsDead)
.OrderByDescending(x => x.Distance(Player.Position)).LastOrDefault();
if (hero != null)
InsecPoint = hero.Position;
break;
case 1:
var turret = GameObjects.AllyTurrets.OrderByDescending(x => x.Distance(Player.Position)).LastOrDefault();
if (turret != null)
InsecPoint = turret.Position;
break;
case 2:
InsecPoint = Game.CursorPos;
break;
case 3:
InsecPoint = LastLeftClick;
break;
}
if (!Program.insec)
return;
if (OrbwalkCommands.CanMove())
{
OrbwalkCommands.MoveTo(Game.CursorPos);
}
if (!InsecPoint.IsValid())
return;
var target = TargetSelector.GetSelectedTarget();
if (!target.IsValidTarget() || target.IsZombie)
return;
if (!Program._r2.IsReady())
return;
//case 1
Vector2 start1 = Player.Position.To2D().Extend(InsecPoint.To2D(), -300);
Vector2 end1 = start1.Extend(Player.Position.To2D(), 750);
float width1 = Program._r.Level == 3 ? 125 * 6 / 2 :
Program._r.Level == 2 ? 125 * 5 / 2 :
125 * 4 / 2;
var Rect1 = new Geometry.Polygon.Rectangle(start1, end1, width1 - 100);
var Predicted1 = Prediction.GetPrediction(target, Game.Ping / 1000f + 0.25f).UnitPosition;
if (Rect1.IsInside(target.Position) && Rect1.IsInside(Predicted1))
{
Program._r2.Cast(InsecPoint);
return;
}
if (Environment.TickCount - LastJump < 1500)
return;
if (!Program._e.IsReady())
return;
//case 2
var sold2 = Soldiers.soldier
.Where(x => Player.Distance(x.Position) <= 1100)
.OrderBy(x => x.Position.Distance(target.Position)).FirstOrDefault();
if (sold2 != null)
{
if (!Program._q2.IsReady())
{
var time = Player.Position.Distance(sold2.Position) / 1700f;
var predicted2 = Prediction.GetPrediction(target, time).UnitPosition;
Vector2 start2 = sold2.Position.To2D().Extend(InsecPoint.To2D(), -300);
Vector2 end2 = start2.Extend(InsecPoint.To2D(), 750);
float width2 = Program._r.Level == 3 ? 125 * 6 / 2 :
Program._r.Level == 2 ? 125 * 5 / 2 :
125 * 4 / 2;
var Rect2 = new Geometry.Polygon.Rectangle(start2, end2, width2 - 100);
if (Rect2.IsInside(target.Position) && Rect2.IsInside(predicted2))
{
Program._e.Cast(sold2.Position);
LastJump = Environment.TickCount;
return;
}
}
if (Program._q2.IsReady() && target.Distance(sold2.Position) <= 875 - 100)
{
var time = (Player.Distance(sold2.Position) + sold2.Position.Distance(target.Position)) / 1700f;
var predicted2 = Prediction.GetPrediction(target, time).UnitPosition;
Vector2 start2 = target.Position.To2D().Extend(InsecPoint.To2D(), -300);
Vector2 end2 = start2.Extend(InsecPoint.To2D(), 750);
float width2 = Program._r.Level == 3 ? 125 * 6 / 2 :
Program._r.Level == 2 ? 125 * 5 / 2 :
125 * 4 / 2;
var Rect2 = new Geometry.Polygon.Rectangle(start2, end2, width2 - 100);
if (Rect2.IsInside(target.Position) && Rect2.IsInside(predicted2))
{
var timetime = sold2.Position.Distance(Player.Position) * 1000 / 1700;
Program._e.Cast(sold2.Position);
LeagueSharp.Common.Utility.DelayAction.Add((int)timetime - 150 - Program.EQdelay, () => Program._q2.Cast(target.Position));
LastJump = Environment.TickCount;
return;
}
}
}
if(Program._w.IsReady())
{
var posWs = GeoAndExten.GetWsPosition(target.Position.To2D()).Where(x => x != null);
foreach (var posW in posWs)
{
if (!Program._q2.IsReady())
{
var time = Player.Position.To2D().Distance((Vector2)posW) / 1700f + 0.3f;
var predicted2 = Prediction.GetPrediction(target, time).UnitPosition;
Vector2 start2 = ((Vector2)posW).Extend(InsecPoint.To2D(), -300);
Vector2 end2 = start2.Extend(InsecPoint.To2D(), 750);
float width2 = Program._r.Level == 3 ? 125 * 6 / 2 :
Program._r.Level == 2 ? 125 * 5 / 2 :
125 * 4 / 2;
var Rect2 = new Geometry.Polygon.Rectangle(start2, end2, width2 - 100);
if (Rect2.IsInside(target.Position) && Rect2.IsInside(predicted2))
{
var timetime = ((Vector2)posW).Distance(Player.Position) * 1000 / 1700;
Program._w.Cast(Player.Position.To2D().Extend((Vector2)posW, Program._w.Range));
LeagueSharp.Common.Utility.DelayAction.Add(0, () => Program._e.Cast((Vector2)posW));
LeagueSharp.Common.Utility.DelayAction.Add((int)timetime + 300 - 150 - Program.EQdelay, () => Program._q2.Cast(target.Position));
LastJump = Environment.TickCount;
return;
}
}
if (Program._q2.IsReady() && target.Distance((Vector2)posW) <= 875 - 100)
{
var time = (Player.Distance((Vector2)posW) + ((Vector2)posW).Distance(target.Position)) / 1700f + 0.3f;
var predicted2 = Prediction.GetPrediction(target, time).UnitPosition;
Vector2 start2 = target.Position.To2D().Extend(InsecPoint.To2D(), -300);
Vector2 end2 = start2.Extend(InsecPoint.To2D(), 750);
float width2 = Program._r.Level == 3 ? 125 * 6 / 2 :
Program._r.Level == 2 ? 125 * 5 / 2 :
125 * 4 / 2;
var Rect2 = new Geometry.Polygon.Rectangle(start2, end2, width2 - 100);
if (Rect2.IsInside(target.Position) && Rect2.IsInside(predicted2))
{
var timetime = ((Vector2)posW).Distance(Player.Position) * 1000 / 1700;
Program._w.Cast(Player.Position.To2D().Extend((Vector2)posW, Program._w.Range));
LeagueSharp.Common.Utility.DelayAction.Add(0, () => Program._e.Cast((Vector2)posW));
LeagueSharp.Common.Utility.DelayAction.Add((int)timetime + 300 - 150 - Program.EQdelay, () => Program._q2.Cast(target.Position));
LastJump = Environment.TickCount;
return;
}
}
}
}
}
public override void Dash_OnDash(Obj_AI_Base sender, Dash.DashEventArgs e)
{
if (!Q.IsReady() || !(sender.BaseSkinName == "Yasuo" && Player.Distance(e.EndPos) <= 200) || !sender.IsEnemy || Player.Distance(e.EndPos) > Q.Range || !misc.IsActive("autoqondash")) return;
var rectangle = new Geometry.Polygon.Rectangle(Player.Position, e.EndPos, Q.Width);
if (!EntityManager.MinionsAndMonsters.EnemyMinions.Any(it => !it.IsDead && it.IsValidTarget() && rectangle.IsInside(it)) || !(EntityManager.Heroes.Enemies.Count(enemy => !enemy.IsDead && enemy.IsValidTarget() && rectangle.IsInside(enemy)) > 0))
{
Q.Cast(e.EndPos);
}
}
public static void UpdateTask()
{
if (Program.Evade == null)
{
return;
}
if (_resetWall - Environment.TickCount > 3400 && Wall != null)
{
var level = Player.GetSpell(SpellSlot.W).Level;
var wallWidth = (300 + 50 * level);
var wallDirection = (Wall.Position.To2D() - YasuoWallCastedPos).Normalized().Perpendicular();
var wallStart = Wall.Position.To2D() + wallWidth / 2 * wallDirection;
var wallEnd = wallStart - wallWidth * wallDirection;
WallPolygon = new Geometry.Polygon.Rectangle(wallStart, wallEnd, 75);
}
if (_resetWall < Environment.TickCount)
{
Wall = null;
WallPolygon = null;
}
if (Wall != null && YasuoWallCastedPos.IsValid() && WallPolygon != null)
{
foreach (var activeSkillshot in Program.Evade.SkillshotDetector.ActiveSkillshots.Where(EvadeMenu.IsSkillshotW))
{
if (WallPolygon.IsInside(activeSkillshot.GetPosition()))
{
activeSkillshot.IsValid = false;
}
}
}
Program.Evade.CacheSkillshots();
if (Program.Evade.IsHeroInDanger(Player.Instance))
{
if (Yasuo.FleeMenu["Evade.W"].Cast <CheckBox>().CurrentValue&& Player.GetSpell(SpellSlot.W).State == SpellState.Ready)
{
foreach (var activeSkillshot in Program.Evade.SkillshotDetector.ActiveSkillshots.Where(a => EvadeMenu.IsSkillshotW(a) && Environment.TickCount - a.TimeDetected >= Yasuo.FleeMenu["Evade.WDelay"].Cast <Slider>().CurrentValue))
{
if (activeSkillshot.ToPolygon().IsInside(Player.Instance))
{
Player.CastSpell(SpellSlot.W, activeSkillshot.GetPosition());
WDelay = Environment.TickCount + 500;
return;
}
}
}
if (WDelay > Environment.TickCount)
{
return;
}
var poly = Program.Evade.CustomPoly();
if (Yasuo.FleeMenu["Evade.E"].Cast <CheckBox>().CurrentValue&& Player.GetSpell(SpellSlot.E).State == SpellState.Ready)
{
foreach (
var source in
EntityManager.MinionsAndMonsters.EnemyMinions.Where(
a => a.Team != Player.Instance.Team && a.Distance(Player.Instance) < 475 && a.CanDash()))
{
if (source.GetDashPos().IsUnderTower())
{
continue;
}
if (Program.Evade.IsPointSafe(poly, source.GetDashPos().To2D()))
{
int count = 0;
for (int i = 0; i < 10; i += 47)
{
if (!Program.Evade.IsPointSafe(poly, Player.Instance.Position.Extend(source.GetDashPos(), i)))
{
count++;
}
}
if (count > 3)
{
continue;
}
Player.CastSpell(SpellSlot.E, source);
break;
}
}
foreach (
var source in
EntityManager.Heroes.Enemies.Where(
a => a.IsEnemy && a.Distance(Player.Instance) < 475 && a.CanDash()))
{
if (source.GetDashPos().IsUnderTower())
{
continue;
}
if (Program.Evade.IsPointSafe(poly, source.GetDashPos().To2D()))
{
int count = 0;
for (int i = 0; i < 10; i += 47)
{
if (!Program.Evade.IsPointSafe(poly, Player.Instance.Position.Extend(source.GetDashPos(), i)))
{
count++;
}
}
if (count > 3)
{
continue;
}
Player.CastSpell(SpellSlot.E, source);
break;
}
}
}
}
}
public override void AIHeroClient_OnProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
if (Player.IsDead || !sender.IsEnemy || !(sender is AIHeroClient)) return;
if (Q.IsReady() && args.SData.Name.ToLower() == "summonerflash" && args.End.Distance(Player) <= Q.Range && MenuManager.Menus[HERO_MENU]["Misc"].Keys.Last().IsActive("autoqonflash"))
{
//Chat.Print("{0} detected, Q on args.End", args.SData.Name);
var rectangle = new Geometry.Polygon.Rectangle(Player.Position, args.End, Q.Width + 10);
if (!EntityManager.MinionsAndMonsters.EnemyMinions.Any(it => rectangle.IsInside(it))) Q.Cast(args.End);
return;
}
if (E.IsReady() && EMenu["UseShield?"].Cast<CheckBox>().CurrentValue && MenuSpells.Any(it => it == args.SData.Name))
{
if (EMenu[args.SData.Name].Cast<CheckBox>().CurrentValue)
{
List<AIHeroClient> Allies = new List<AIHeroClient>();
//Division
if (args.Target != null)
{
if (args.Target.IsAlly || args.Target.IsMe)
{
var target = EntityManager.Heroes.Allies.FirstOrDefault(it => it.NetworkId == args.Target.NetworkId);
//Chat.Print(args.Target.Name);
if (target != null) E.Cast(target);
return;
}
}
//Division
var rectangle = new Geometry.Polygon.Rectangle(args.Start, args.End, args.SData.LineWidth);
foreach (var ally in EntityManager.Heroes.Allies)
{
if (rectangle.IsInside(ally)) { Allies.Add(ally); continue; }
foreach (var point in rectangle.Points)
{
if (ally.Distance(point) <= 90)
{
Allies.Add(ally);
}
}
}
if (Allies.Any())
{
//Chat.Print("Rectangle Detection");
PriorityCast(sender, args, Allies, rectangle);
return;
}
//Division
var circle = new Geometry.Polygon.Circle(args.End, args.SData.CastRadius);
foreach (var ally in EntityManager.Heroes.Allies)
{
if (circle.IsInside(ally)) { Allies.Add(ally); continue; }
foreach (var point in circle.Points)
{
if (ally.Distance(point) <= 90)
{
Allies.Add(ally);
}
}
}
if (Allies.Any())
{
//Chat.Print("Circle Detection");
PriorityCast(sender, args, Allies, circle);
return;
}
}
}
return;
}
/// <summary>
/// Picking best Position to move to.
/// </summary>
public static void BestPosition()
{
if (EnableTeleport && ObjectsManager.ClosestAlly != null)
{
Program.Moveto = "Teleporting";
Teleport.Cast();
}
// If player is Zombie moves follow nearest Enemy.
if (Player.Instance.IsZombie())
{
var ZombieTarget = TargetSelector.GetTarget(1000, DamageType.True);
if (ZombieTarget != null)
{
Program.Moveto = "ZombieTarget";
Position = ZombieTarget.PredictPosition();
return;
}
if (ObjectsManager.NearestEnemy != null)
{
Program.Moveto = "NearestEnemy";
Position = ObjectsManager.NearestEnemy.PredictPosition();
return;
}
if (ObjectsManager.NearestEnemyMinion != null)
{
Program.Moveto = "NearestEnemyMinion";
Position = ObjectsManager.NearestEnemyMinion.PredictPosition();
return;
}
}
// Feeding Poros
if (ObjectsManager.ClosesetPoro != null)
{
var porosnax = new Item(2052);
if (porosnax != null && porosnax.IsOwned(Player.Instance) && porosnax.IsReady())
{
porosnax.Cast(ObjectsManager.ClosesetPoro);
Logger.Send("Feeding ClosesetPoro");
}
}
// Hunting Bard chimes kappa.
if (PickBardChimes && ObjectsManager.BardChime != null)
{
Program.Moveto = "BardChime";
Position = ObjectsManager.BardChime.Position.Random();
return;
}
// Moves to HealthRelic if the bot needs heal.
if ((Player.Instance.PredictHealthPercent() <= HealthRelicHP || (Player.Instance.ManaPercent <= HealthRelicMP && !Player.Instance.IsNoManaHero())) && ObjectsManager.HealthRelic != null &&
((DontStealHR && !EntityManager.Heroes.Allies
.Any(a => Player.Instance.PredictHealth() > a.PredictHealth() && a.Path.LastOrDefault().IsInRange(ObjectsManager.HealthRelic, ObjectsManager.HealthRelic.BoundingRadius + a.BoundingRadius) &&
!a.IsMe && a.IsValidTarget())) || !DontStealHR))
{
var formana = Player.Instance.ManaPercent < HealthRelicMP && !Player.Instance.IsNoManaHero();
var rect = new Geometry.Polygon.Rectangle(Player.Instance.ServerPosition, ObjectsManager.HealthRelic.Position, 375);
if (ObjectsManager.EnemyTurret != null)
{
var Circle = new Geometry.Polygon.Circle(ObjectsManager.EnemyTurret.ServerPosition, ObjectsManager.EnemyTurret.GetAutoAttackRange());
if ((!Circle.Points.Any(p => rect.IsInside(p)) || Circle.Points.Any(p => rect.IsInside(p)) && SafeToDive) && !EntityManager.Heroes.Enemies.Any(e => rect.IsInside(e.PredictPosition()) && e.IsValid && !e.IsDead))
{
if (ObjectsManager.HealthRelic.Name.Contains("Bard"))
{
if (!formana)
{
Program.Moveto = "BardShrine";
Position = ObjectsManager.HealthRelic.Position;
return;
}
}
else
{
Program.Moveto = "HealthRelic";
Position = ObjectsManager.HealthRelic.Position;
return;
}
}
}
else
{
if (!EntityManager.Heroes.Enemies.Any(e => rect.IsInside(e.PredictPosition()) && e.IsValid && !e.IsDead))
{
if (ObjectsManager.HealthRelic.Name.Contains("Bard"))
{
if (!formana)
{
Program.Moveto = "BardShrine2";
Position = ObjectsManager.HealthRelic.Position;
return;
}
}
else
{
Program.Moveto = "HealthRelic2";
Position = ObjectsManager.HealthRelic.Position;
return;
}
}
}
}
// Pick Thresh Lantern
if (ObjectsManager.ThreshLantern != null)
{
if (Player.Instance.Distance(ObjectsManager.ThreshLantern) > 300)
{
Program.Moveto = "ThreshLantern";
Position = ObjectsManager.ThreshLantern.Position.Random();
}
else
{
Program.Moveto = "ThreshLantern";
Player.UseObject(ObjectsManager.ThreshLantern);
}
return;
}
if (PickDravenAxe && ObjectsManager.DravenAxe != null)
{
Program.Moveto = "DravenAxe";
Position = ObjectsManager.DravenAxe.Position;
return;
}
if (PickZacBlops && ObjectsManager.ZacBlop != null)
{
Program.Moveto = "ZacBlop";
Position = ObjectsManager.ZacBlop.Position;
return;
}
/* fix core pls not working :pepe:
* if (PickCorkiBomb && ObjectsManager.CorkiBomb != null)
* {
* Program.Moveto = "CorkiBomb";
* if (Player.Instance.IsInRange(ObjectsManager.CorkiBomb, 300))
* {
* Program.Moveto = "UsingCorkiBomb";
* Player.UseObject(ObjectsManager.CorkiBomb);
* }
* Position = ObjectsManager.CorkiBomb.Position;
* return;
* }*/
// Moves to the Farthest Ally if the bot has Autsim
if (Brain.Alone() && ObjectsManager.FarthestAllyToFollow != null && Player.Instance.Distance(ObjectsManager.AllySpawn) <= 3000)
{
Program.Moveto = "FarthestAllyToFollow";
Position = ObjectsManager.FarthestAllyToFollow.PredictPosition().Random();
return;
}
// Stays Under tower if the bot health under 10%.
if ((ModesManager.CurrentMode == ModesManager.Modes.Flee || (Player.Instance.PredictHealthPercent() < 10 && Player.Instance.CountAllyHeros(SafeValue + 2000) < 3)) &&
EntityManager.Heroes.Enemies.Count(e => e.IsValid && !e.IsDead && e.IsInRange(Player.Instance, SafeValue + 200)) > 0)
{
if (ObjectsManager.SafeAllyTurret != null)
{
Program.Moveto = "SafeAllyTurretFlee";
Position = ObjectsManager.SafeAllyTurret.PredictPosition().Random().Extend(ObjectsManager.AllySpawn.Position.Random(), 400).To3D();
return;
}
if (ObjectsManager.AllySpawn != null)
{
Program.Moveto = "AllySpawnFlee";
Position = ObjectsManager.AllySpawn.Position.Random();
return;
}
}
// Moves to AllySpawn if the bot is diving and it's not safe to dive.
if (((Player.Instance.UnderEnemyTurret() && !SafeToDive) || Core.GameTickCount - Brain.LastTurretAttack < 2000) && ObjectsManager.AllySpawn != null)
{
Program.Moveto = "AllySpawn2";
Position = ObjectsManager.AllySpawn.Position.Random();
return;
}
if (Player.Instance.GetAutoAttackRange() < 425)
{
MeleeLogic();
}
else
{
RangedLogic();
}
}
public override async Task ExecuteComboAsync(Unit target, CancellationToken tk = new CancellationToken())
{
await HasNoLinkens(target, tk);
if (!MyHero.IsSilenced())
{
var eulsModifier = target.FindModifier("modifier_eul_cyclone");
if (_stunAbility.IsAbilityEnabled() && (_stunAbility.CanBeCasted(target) || eulsModifier != null && _stunAbility.CanBeCasted()) &&
_stunAbility.CanHit(target))
{
var stunCastpoint = _stunAbility.FindCastPoint();
var delay = _stunAbility.GetAbilityData("path_delay");
if (eulsModifier != null)
{
Log.Debug($"has euls {eulsModifier.RemainingTime}");
if (eulsModifier.RemainingTime < stunCastpoint + delay)
{
Log.Debug($"using stun on cycloned target");
_stunAbility.UseAbility(target.NetworkPosition);
await Await.Delay(GetAbilityDelay(target, _stunAbility), tk);
}
}
else
{
var disabled = 0.0f;
if (target.IsRooted(out disabled) || target.IsStunned(out disabled))
{
var time = disabled - stunCastpoint - delay;
if (time >= 0)
{
Log.Debug($"using stun on disabled target {time}");
_stunAbility.UseAbility(target.NetworkPosition);
await Await.Delay(GetAbilityDelay(target, _stunAbility), tk);
}
else
{
var predictedPos = Prediction.Prediction.PredictPosition(target, (int)time * -1000);
Log.Debug($"using stun on disabled target {time} with predicted pos {predictedPos}");
_stunAbility.UseAbility(predictedPos);
await Await.Delay(GetAbilityDelay(target, _stunAbility), tk);
}
}
else
{
var euls = MyHero.GetItemById(ItemId.item_cyclone);
if (euls != null && euls.CanBeCasted(target))
{
if (euls.CanHit(target))
{
Log.Debug($"using euls to disable enemy before stun");
euls.UseAbility(target);
await Await.Delay(125, tk);
return;
}
// check if we are near the enemy
if (!await MoveOrBlinkToEnemy(target, tk, minimumRange: 250, maximumRange: euls.GetCastRange()))
{
Log.Debug($"return because of blink");
return;
}
}
var predictedPos = Prediction.Prediction.PredictPosition(target,
(int)((stunCastpoint + delay) * 1000));
Log.Debug($"using stun on target with predicted pos {predictedPos}");
_stunAbility.UseAbility(predictedPos);
await Await.Delay(GetAbilityDelay(target, _stunAbility), tk);
}
}
}
}
await UseItems(target, tk);
// make him disabled
if (await DisableEnemy(target, tk) == DisabledState.UsedAbilityToDisable)
{
Log.Debug($"disabled!");
// return;
}
if (!MyHero.IsSilenced())
{
if (_ultAbility.IsAbilityEnabled() && _ultAbility.CanBeCasted(target) && _ultAbility.CanHit(target))
{
if (target.IsStunned() || target.IsRooted())
{
Log.Debug($"using ult because target is stunned");
_ultAbility.UseAbility(target.NetworkPosition);
await Await.Delay(GetAbilityDelay(target, _ultAbility) + 250, tk);
}
else
{
var predictedPos = Prediction.Prediction.PredictPosition(target,
(int)(_ultAbility.FindCastPoint() * 1000.0));
var radius = _ultAbility.GetAbilityData("path_radius");
var dir = predictedPos - MyHero.NetworkPosition;
dir.Normalize();
dir *=
_ultAbility.GetAbilityData(MyHero.HasItem(ItemId.item_ultimate_scepter)
? "cast_range_scepter"
: "cast_range");
var rec = new Geometry.Polygon.Rectangle(MyHero.NetworkPosition, MyHero.NetworkPosition + dir,
radius);
var hasMoreEnemies =
ObjectManager.GetEntitiesParallel <Hero>()
.Any(
x =>
x.IsValid && x != target && x.IsAlive && !x.IsMagicImmune() &&
x.Team != MyHero.Team && rec.IsInside(x.NetworkPosition));
if (hasMoreEnemies)
{
Log.Debug($"using ult because more enemies");
_ultAbility.UseAbility(predictedPos);
await Await.Delay(GetAbilityDelay(target, _ultAbility) + 250, tk);
}
}
}
if (_dualAbility.IsAbilityEnabled() && _dualAbility.CanBeCasted(target) && _dualAbility.CanHit(target))
{
Log.Debug($"using Q");
_dualAbility.UseAbility(target.NetworkPosition);
await Await.Delay(GetAbilityDelay(target, _dualAbility), tk);
}
if (_orbAbility.IsAbilityEnabled() && _orbAbility.CanBeCasted(target) && _orbAbility.CanHit(target))
{
Log.Debug($"using orb");
_orbAbility.UseAbility(target);
await Await.Delay(GetAbilityDelay(target, _orbAbility), tk);
}
}
// check if we are near the enemy
if (!await MoveOrBlinkToEnemy(target, tk))
{
Log.Debug($"return because of blink");
return;
}
if (ZaioMenu.ShouldUseOrbwalker)
{
Orbwalk();
}
}
protected override async Task <bool> Killsteal()
{
if (await base.Killsteal())
{
return(true);
}
if (MyHero.IsSilenced() || MyHero.IsChanneling() || Target != null)
{
return(false);
}
if (_powerShotAbility.IsKillstealAbilityEnabled() && _powerShotAbility.CanBeCasted())
{
var damage = (float)_powerShotAbility.GetDamage(_powerShotAbility.Level - 1);
damage *= GetSpellAmp();
var speed = _powerShotAbility.GetAbilityData("arrow_speed");
var range = _powerShotAbility.GetAbilityData("arrow_range");
var width = _powerShotAbility.GetAbilityData("arrow_width");
var damageReduction = _powerShotAbility.GetAbilityData("damage_reduction"); // 0.2
var enemies =
ObjectManager.GetEntitiesParallel <Hero>()
.Where(
x =>
x.IsAlive && x.Team != MyHero.Team && !x.IsIllusion &&
_powerShotAbility.CanBeCasted(x) &&
_powerShotAbility.CanHit(x) && !x.IsMagicImmune() &&
x.Health < damage * (1 - x.MagicResistance()) && !x.CantBeAttacked() &&
!x.CantBeKilled());
foreach (var enemy in enemies)
{
var time = enemy.Distance2D(MyHero) / speed * 1000.0f;
var predictedPos = Prediction.Prediction.PredictPosition(enemy, (int)time, true);
if (predictedPos == Vector3.Zero || MyHero.Distance2D(predictedPos) >= range)
{
continue;
}
// check for reduction
var rec = new Geometry.Polygon.Rectangle(MyHero.NetworkPosition, predictedPos, width);
// test for enemies in range
var unitsHit = ObjectManager.GetEntitiesParallel <Unit>()
.Count(
x =>
x.IsValid && x != enemy && x.IsAlive && !(x is Building) && x != MyHero && x.Team != MyHero.Team &&
x.IsSpawned && x.IsRealUnit() &&
rec.IsInside(x.NetworkPosition));
var newDamage = damage * (unitsHit > 0 ? Math.Pow(1 - damageReduction, unitsHit) : 1.0f);
if (enemy.Health >= newDamage * (1 - enemy.MagicResistance()))
{
Log.Debug($"not using powershot killsteal because too many units hit before ({unitsHit}) - {newDamage * (1 - enemy.MagicResistance())}");
continue;
}
var powerShotProp = GetPowerShotProp(enemy);
if (powerShotProp > 1.0f)
{
Log.Debug($"powershot prop too high {powerShotProp}");
}
else
{
time += (1000.0f * powerShotProp);
predictedPos = Prediction.Prediction.PredictPosition(enemy, (int)time, true);
Log.Debug(
$"use killsteal powershot because enough damage {enemy.Health} <= {damage * (1 - enemy.MagicResistance())} prop {powerShotProp}");
_powerShotAbility.UseAbility(predictedPos);
await Await.Delay(GetAbilityDelay(enemy, _powerShotAbility) + (int)time);
MyHero.Stop();
return(true);
}
}
}
return(false);
}
private static void OnObjAiBaseProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
try
{
var enemy = sender as AIHeroClient;
if (enemy == null || !enemy.IsEnemy)
{
return;
}
var gSpell =
GapcloserSpells.FirstOrDefault(
spell => spell.Name.Equals(args.SData.Name, StringComparison.OrdinalIgnoreCase));
if (!gSpell.Equals(default(GapcloserSpell)))
{
var startPosition = args.Start;
var endPosition = args.End;
var cSpell = enemy.GetSpell(gSpell.Slot);
if (gSpell.IsTargeted && args.Target != null)
{
endPosition = args.Target.Position;
}
if (gSpell.IsUnitDash)
{
endPosition = startPosition.Extend(endPosition, gSpell.DashDistance);
}
if (gSpell.Collision)
{
if (cSpell != null)
{
var colObjects =
GameObjects.AllyHeroes.Select(a => a as Obj_AI_Base)
.Concat(GameObjects.AllyMinions.Where(m => m.Distance(enemy) <= 2000))
.OrderBy(c => c.Distance(enemy))
.ToList();
var rect = new Geometry.Polygon.Rectangle(
startPosition, endPosition, cSpell.SData.LineWidth + enemy.BoundingRadius);
var collision =
colObjects.FirstOrDefault(
col =>
new Geometry.Polygon.Circle(col.ServerPosition, col.BoundingRadius).Points.Any(
p => rect.IsInside(p)));
if (collision != null)
{
endPosition = collision.ServerPosition.Extend(
startPosition, collision.BoundingRadius + enemy.BoundingRadius);
if (collision is Obj_AI_Minion && endPosition.Distance(startPosition) <= 100 &&
!GameObjects.AllyHeroes.Any(a => a.Distance(endPosition) <= 150))
{
return;
}
}
}
}
var endTime = Game.Time;
if (cSpell != null)
{
var time = startPosition.Distance(endPosition) /
Math.Max(cSpell.SData.MissileSpeed, enemy.MoveSpeed * 1.25f);
if (time <= 3)
{
endTime += time;
}
}
Check(false, enemy, startPosition, endPosition, endTime, gSpell.IsTargeted);
}
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
}
public static void Execute()
{
var jungleMinions = EntityManager.MinionsAndMonsters.GetJungleMonsters(Player.Instance.Position, 600).ToList();
if (!jungleMinions.Any())
{
return;
}
if (E.IsReady() && Settings.LaneClear.UseEInJungleClear &&
Player.Instance.ManaPercent >= Settings.LaneClear.MinManaE && GetAmmoCount < 2)
{
string[] allowedMonsters =
{
"SRU_Gromp", "SRU_Blue", "SRU_Red", "SRU_Razorbeak", "SRU_Krug", "SRU_Murkwolf", "Sru_Crab",
"SRU_Crab",
"SRU_RiftHerald", "SRU_Dragon_Fire", "SRU_Dragon_Earth", "SRU_Dragon_Air", "SRU_Dragon_Elder",
"SRU_Dragon_Water", "SRU_Baron"
};
if (jungleMinions.Count > 1 || jungleMinions.Any(minion => allowedMonsters.Contains(minion.BaseSkinName) && minion.Health > Player.Instance.GetAutoAttackDamage(minion) * 2))
{
E.Cast(Game.CursorPos.Distance(Player.Instance) > E.Range
? Player.Instance.Position.Extend(Game.CursorPos, 420).To3D()
: Game.CursorPos);
}
}
if (!Q.IsReady() || !Settings.LaneClear.UseQInJungleClear || (Player.Instance.ManaPercent < Settings.LaneClear.MinManaQ))
{
return;
}
var qMinions = jungleMinions.Where(x => x.IsValidTarget(Q.Range) && !Player.Instance.Position.IsWallBetween(x.Position)).ToList();
if (!qMinions.Any())
{
return;
}
var last = 0;
Obj_AI_Minion lastMinion = null;
foreach (var minion in qMinions)
{
var area = new Geometry.Polygon.Rectangle(Player.Instance.Position,
Player.Instance.Position.Extend(minion, Q.Range).To3D(), Q.Width);
var count = qMinions.Count(
x => new Geometry.Polygon.Circle(x.Position, x.BoundingRadius).Points.Any(k =>
area.IsInside(k)));
if (count <= last)
{
continue;
}
last = count;
lastMinion = minion;
}
if (last <= 0 || lastMinion == null)
{
return;
}
if (lastMinion.IsValidTarget(Q.Range))
{
Q.Cast(lastMinion);
}
}
//---------------------------------------WhyInsec()----------------------------------------------------
void WhyInsec(Obj_AI_Base target)
{
//Back distance = 300
//Why I did that
EloBuddy.Player.IssueOrder(GameObjectOrder.MoveTo, target);
var targetpos = Prediction.Position.PredictUnitPosition(target, 500).To3D();
if (!WhyIDidThatAddonInsec && Orbwalker.ValidAzirSoldiers.Any(it => it.Distance(target) >= E.Width + target.BoundingRadius && it.Distance(target) <= (R.Width / 2) - 20))
{
WhyIDidThatAddonInsec = true;
Core.DelayAction(() => WhyIDidThatAddonInsec = false, 3000);
if (E.IsReady())
{
InsecSoldier = Orbwalker.ValidAzirSoldiers.Where(it => it.Distance(target) <= (R.Width / 2) - 20).OrderByDescending(it => it.Distance(target)).First();
var rectangle = new Geometry.Polygon.Rectangle(Player.Position, InsecSoldier.Position, E.Width + target.BoundingRadius);
if (!rectangle.IsInside(targetpos) && InsecSoldier.Distance(target) <= (R.Width / 2) - 50)
{
var EDelay = (int)((((Player.Distance(InsecSoldier) - 100) / 8) * 5));
if (E.Cast(Vectors.CorrectSpellRange(InsecSoldier.Position, E.Range)))
{
//Delayed insec
Core.DelayAction(delegate
{
if (Player.Spellbook.CastSpell(SpellSlot.Q, Vectors.CorrectSpellRange(Game.CursorPos, Q.Range)))
{
LastQTime = Game.Time;
}
else WhyIDidThatAddonInsec = false;
}, EDelay);
}
else WhyIDidThatAddonInsec = false;
}
else { WhyIDidThatAddonInsec = false; }
}
else WhyIDidThatAddonInsec = false;
}
else if (!WhyIDidThatAddonInsec && W.IsReady() && E.IsReady() && Q.IsReady() && W.IsInRange(target))
{
var rectangle = new Geometry.Polygon.Rectangle(Player.Position, targetpos, 2 * (target.BoundingRadius + E.Width + 20));
//rectangle.Draw(System.Drawing.Color.Yellow);
var circle = new Geometry.Polygon.Circle(targetpos, (R.Width - 20)/2);
//circle.Draw(System.Drawing.Color.Red);
var point = circle.Points.Where(it => !NavMesh.GetCollisionFlags(it).HasFlag(CollisionFlags.Wall) && W.IsInRange(it.To3D()) && !rectangle.IsInside(it)).OrderByDescending(it => it.Distance(Player)).FirstOrDefault();
if (point != null && W.Cast(point.To3D()))
{
WhyIDidThatAddonInsec = true;
Core.DelayAction(() => WhyIDidThatAddonInsec = false, 3000);
Core.DelayAction(delegate
{
InsecSoldier = Orbwalker.ValidAzirSoldiers.Where(it => it.Distance(target) <= (R.Width / 2) - 20).OrderByDescending(it => it.Distance(target)).First();
var EDelay = (int)((((Player.Distance(InsecSoldier) - 100) / 8) * 5));
if (E.Cast(Vectors.CorrectSpellRange(InsecSoldier.Position, E.Range)))
{
//Delayed insec
Core.DelayAction(delegate
{
if (Player.Spellbook.CastSpell(SpellSlot.Q, Vectors.CorrectSpellRange(Game.CursorPos, Q.Range)))
{
LastQTime = Game.Time;
}
else WhyIDidThatAddonInsec = false;
}, EDelay);
}
else WhyIDidThatAddonInsec = false;
}, 350);
}
}
return;
}
private Tuple <int, Vector3> BestQPosition(Obj_AI_Base target, List <Obj_AI_Base> targets, HitChance hitChance)
{
var castPos = Vector3.Zero;
var totalHits = 0;
try
{
var enemies = targets.Where(e => e.IsValidTarget(Q.Range * 1.5f)).ToList();
var enemyPositions = new List <Tuple <Obj_AI_Base, Vector3> >();
var circle = new Geometry.Polygon.Circle(Player.Position, Player.BoundingRadius, 30).Points;
foreach (var h in enemies)
{
var ePred = Q.GetPrediction(h);
if (ePred.Hitchance >= hitChance)
{
circle.Add(Player.Position.Extend(ePred.UnitPosition, Player.BoundingRadius).To2D());
enemyPositions.Add(new Tuple <Obj_AI_Base, Vector3>(h, ePred.UnitPosition));
}
}
var targetPos = target == null ? Vector3.Zero : target.Position;
if (target == null)
{
var possibilities =
ListExtensions.ProduceEnumeration(enemyPositions).Where(p => p.Count > 0).ToList();
var count = 0;
foreach (var possibility in possibilities)
{
var mec = MEC.GetMec(possibility.Select(p => p.Item2.To2D()).ToList());
if (mec.Radius < Q.Width && possibility.Count > count)
{
count = possibility.Count;
targetPos = mec.Center.To3D();
}
}
}
if (targetPos.Equals(Vector3.Zero))
{
return(new Tuple <int, Vector3>(totalHits, castPos));
}
circle = circle.OrderBy(c => c.Distance(targetPos)).ToList();
if (!enemyPositions.Any())
{
return(new Tuple <int, Vector3>(totalHits, castPos));
}
foreach (var point in circle)
{
var hits = 0;
var containsTarget = false;
var direction = Q.Range * (point.To3D() - Player.Position).Normalized().To2D();
var rect1 = new Geometry.Polygon.Rectangle(
Player.Position, Player.Position.Extend(Player.Position + direction.To3D(), Q.Range), Q.Width);
var rect2 = new Geometry.Polygon.Rectangle(
Player.Position,
Player.Position.Extend(Player.Position + direction.Rotated(QAngle).To3D(), Q.Range), Q.Width);
var rect3 = new Geometry.Polygon.Rectangle(
Player.Position,
Player.Position.Extend(Player.Position + direction.Rotated(-QAngle).To3D(), Q.Range), Q.Width);
foreach (var enemy in enemyPositions)
{
var bounding = new Geometry.Polygon.Circle(enemy.Item2, enemy.Item1.BoundingRadius * 0.85f);
if (bounding.Points.Any(p => rect1.IsInside(p) || rect2.IsInside(p) || rect3.IsInside(p)))
{
hits++;
if (target != null && enemy.Item1.NetworkId.Equals(target.NetworkId))
{
containsTarget = true;
}
}
}
if ((containsTarget || target == null) && hits > totalHits)
{
totalHits = hits;
castPos = Player.Position.Extend(point.To3D(), Q.Range);
if (totalHits >= enemies.Count)
{
break;
}
}
}
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
return(new Tuple <int, Vector3>(totalHits, castPos));
}
public static bool PathUnderEnemyTurret(this Obj_AI_Base target, Vector3 point)
{
var betterpath = new Geometry.Polygon.Rectangle(target.ServerPosition, point, 600);
var pathinsideenemyturret = EntityManager.Turrets.Enemies.Any(t => t.IsValid && !t.IsDead && !t.IsSafe() && betterpath.IsInside(t));
return(pathinsideenemyturret);
}
/// <summary>
/// Picking best Position to move to.
/// </summary>
public static void BestPosition()
{
if (ObjectsManager.ClosestAlly != null && ObjectsManager.ClosestAlly.Distance(Player.Instance) > 2500)
{
Teleport.Cast();
}
if (TeamFight)
{
LastTeamFight = Core.GameTickCount;
}
// If player is Zombie moves follow nearest Enemy.
if (Player.Instance.IsZombie())
{
if (ObjectsManager.NearestEnemy != null)
{
Program.Moveto = "NearestEnemy";
Position = ObjectsManager.NearestEnemy.PredictPosition();
return;
}
if (ObjectsManager.NearestEnemyMinion != null)
{
Program.Moveto = "NearestEnemyMinion";
Position = ObjectsManager.NearestEnemyMinion.PredictPosition();
return;
}
}
// Hunting Bard chimes kappa.
if (Player.Instance.Hero == Champion.Bard && ObjectsManager.BardChime != null && ObjectsManager.BardChime.Distance(Player.Instance) <= 600)
{
Program.Moveto = "BardChime";
Position = ObjectsManager.BardChime.Position.Random();
return;
}
// Moves to HealthRelic if the bot needs heal.
if ((Player.Instance.HealthPercent <= HealthRelicHP || (Player.Instance.ManaPercent <= HealthRelicMP && !Player.Instance.IsNoManaHero())) && ObjectsManager.HealthRelic != null &&
((DontStealHR && !EntityManager.Heroes.Allies.Any(a => Player.Instance.Health > a.Health && a.Path.LastOrDefault().IsInRange(ObjectsManager.HealthRelic, ObjectsManager.HealthRelic.BoundingRadius + a.BoundingRadius) && !a.IsMe && a.IsValidTarget() && !a.IsDead)) || !DontStealHR))
{
var formana = Player.Instance.ManaPercent < HealthRelicMP && !Player.Instance.IsNoManaHero();
var rect = new Geometry.Polygon.Rectangle(Player.Instance.ServerPosition, ObjectsManager.HealthRelic.Position, 375);
if (ObjectsManager.EnemyTurret != null)
{
var Circle = new Geometry.Polygon.Circle(ObjectsManager.EnemyTurret.ServerPosition, ObjectsManager.EnemyTurret.GetAutoAttackRange());
if ((!Circle.Points.Any(p => rect.IsInside(p)) || Circle.Points.Any(p => rect.IsInside(p)) && SafeToDive) && !EntityManager.Heroes.Enemies.Any(e => rect.IsInside(e.PredictPosition()) && e.IsValidTarget() && !e.IsDead))
{
if (ObjectsManager.HealthRelic.Name.Contains("Bard"))
{
if (!formana)
{
Program.Moveto = "BardShrine";
Position = ObjectsManager.HealthRelic.Position;
return;
}
}
else
{
Program.Moveto = "HealthRelic";
Position = ObjectsManager.HealthRelic.Position;
return;
}
}
}
else
{
if (!EntityManager.Heroes.Enemies.Any(e => rect.IsInside(e.PredictPosition()) && e.IsValidTarget() && !e.IsDead))
{
if (ObjectsManager.HealthRelic.Name.Contains("Bard"))
{
if (!formana)
{
Program.Moveto = "BardShrine2";
Position = ObjectsManager.HealthRelic.Position;
return;
}
}
else
{
Program.Moveto = "HealthRelic2";
Position = ObjectsManager.HealthRelic.Position;
return;
}
}
}
}
// Pick Thresh Lantern
if (Player.Instance.HealthPercent <= 50 && ObjectsManager.ThreshLantern != null && ObjectsManager.ThreshLantern.Distance(Player.Instance) <= 800)
{
if (Player.Instance.Distance(ObjectsManager.ThreshLantern) > 300)
{
Program.Moveto = "ThreshLantern";
Position = ObjectsManager.ThreshLantern.Position.Random();
}
else
{
Player.UseObject(ObjectsManager.ThreshLantern);
}
return;
}
if (ObjectsManager.DravenAxe != null)
{
Program.Moveto = "DravenAxe";
Position = ObjectsManager.DravenAxe.Position;
return;
}
// Moves to the Farthest Ally if the bot has Autsim
if (Brain.Alone() && ObjectsManager.FarthestAllyToFollow != null && Player.Instance.Distance(ObjectsManager.AllySpawn) <= 3000)
{
Program.Moveto = "FarthestAllyToFollow";
Position = ObjectsManager.FarthestAllyToFollow.PredictPosition().Random();
return;
}
// Stays Under tower if the bot health under 10%.
if ((ModesManager.Flee || (Player.Instance.HealthPercent < 10 && Player.Instance.CountAlliesInRange(3000) < 3)) && EntityManager.Heroes.Enemies.Count(e => !e.IsDead && e.IsValidTarget(SafeValue + 200)) > 0)
{
if (ObjectsManager.SafeAllyTurret != null)
{
Program.Moveto = "SafeAllyTurret";
Position = ObjectsManager.SafeAllyTurret.PredictPosition().Random().Extend(ObjectsManager.AllySpawn.Position.Random(), 400).To3D();
return;
}
if (ObjectsManager.AllySpawn != null)
{
Program.Moveto = "AllySpawn";
Position = ObjectsManager.AllySpawn.Position.Random();
return;
}
}
// Moves to AllySpawn if the bot is diving and it's not safe to dive.
if (((Player.Instance.UnderEnemyTurret() && !SafeToDive) || Core.GameTickCount - Brain.LastTurretAttack < 2000) && ObjectsManager.AllySpawn != null)
{
Program.Moveto = "AllySpawn2";
Position = ObjectsManager.AllySpawn.Position.Random();
return;
}
if (Player.Instance.IsMelee)
{
MeleeLogic();
}
else
{
RangedLogic();
}
}
public static bool SafePath(this Obj_AI_Base target, Vector3 point)
{
var betterpath = new Geometry.Polygon.Rectangle(target.ServerPosition, point, 400);
var moreallies = EntityManager.Heroes.Allies.Count(a => a.IsValidTarget() && betterpath.IsInside(a)) >= EntityManager.Heroes.Enemies.Count(a => a.IsValidTarget() && betterpath.IsInside(a));
return(moreallies && !PathUnderEnemyTurret(target, point) && point.IsSafe());
}
private static void OnProcessSpell(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
try
{
if (!(sender is AIHeroClient) || Player.IsRecalling())
{
return;
}
// Auto W
if (_MainMenu.Item("Braum_AutoW").GetValue <bool>() && _W.IsReady())
{
if (!(sender is AIHeroClient) || !sender.IsEnemy)
{
return;
}
if (args.Target != null)
{
if (args.SData.Name.ToLower().Contains("attack") && args.Target.Position.Distance(Player.Position) < _W.Range)
{
if (args.Target.IsAlly && args.Target is AIHeroClient)
{
if (args.Target.IsMe && Player.HealthPercent < 20)
{
_W.CastOnUnit((Obj_AI_Base)args.Target, true);
}
else
{
_W.CastOnUnit((Obj_AI_Base)args.Target, true);
}
}
}
}
}
// Auto E
if (_MainMenu.Item("Braum_AutoE").GetValue <bool>() && _E.IsReady())
{
if (!(sender is AIHeroClient) || !sender.IsEnemy || !Orbwalking.CanAttack())
{
return;
}
var enemyskill = new Geometry.Polygon.Rectangle(args.Start, args.End, args.SData.BounceRadius + 20);
var myteam = HeroManager.Allies.Where(f => f.Distance(Player.Position) < 200);
var count = myteam.Count(f => enemyskill.IsInside(f.Position));
if (args.Target != null && args.Target.Position.Distance(Player.Position) < 200)
{
if (args.Target.Name == Player.Name && Player.HealthPercent < 20)
{
_E.Cast(sender.Position, true);
}
else if (args.Target.Position.Distance(Player.Position) < 200 && args.Target is AIHeroClient)
{
if (_W.IsReady() && args.Target.Position.Distance(Player.Position) < _W.Range)
{
_W.CastOnUnit((Obj_AI_Base)args.Target, true);
}
_E.Cast(sender.Position, true);
}
}
else if (args.Target == null)
{
if (Player.HealthPercent < 20 && count == 1)
{
_E.Cast(sender.Position, true);
}
else if (count >= 2)
{
_E.Cast(sender.Position, true);
}
}
}
}
catch (Exception)
{
if (NowTime() > ErrorTime)
{
Chat.Print(ChampName + " in FreshBooster isn't Load. Error Code 08");
ErrorTime = TickCount(10000);
}
}
}
//------------------------------------CastE(Obj_AI_Base target)----------------------------------------
static void CastE(Obj_AI_Base target)
{
foreach (var soldier in Orbwalker.ValidAzirSoldiers)
{
var rectangle = new Geometry.Polygon.Rectangle(Player.Position, soldier.Position, 90);
if (rectangle.IsInside(target))
{
if (E.Cast(target)) return;
}
}
return;
}
//------------------------------------AIHeroClient_OnProcessSpellCast-------------------------------------
static void AIHeroClient_OnProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
if (sender.IsEnemy)
{
if (Q.IsReady() && args.SData.Name.ToLower() == "summonerflash" && args.End.Distance(Player) <= Q.Range && Menu["AutoQFlash"].Cast <CheckBox>().CurrentValue)
{
//Chat.Print("{0} detected, Q on args.End", args.SData.Name);
var rectangle = new Geometry.Polygon.Rectangle(Player.Position, args.End, Q.Width + 20);
if (!EntityManager.MinionsAndMonsters.EnemyMinions.Any(it => rectangle.IsInside(it)))
{
Q.Cast(args.End);
}
return;
}
if (E.IsReady() && EMenu["UseShield?"].Cast <CheckBox>().CurrentValue&& MenuSpells.Any(it => it == args.SData.Name))
{
if (EMenu[args.SData.Name].Cast <CheckBox>().CurrentValue)
{
List <AIHeroClient> Allies = new List <AIHeroClient>();
//Division
if (args.Target != null)
{
if (args.Target.IsAlly || args.Target.IsMe)
{
var target = EntityManager.Heroes.Allies.FirstOrDefault(it => it.NetworkId == args.Target.NetworkId);
//Chat.Print(args.Target.Name);
if (target != null)
{
int delay = (int)((sender.Distance(target) / ((args.SData.MissileMaxSpeed + args.SData.MissileMinSpeed) / 2)) * 1000 + args.SData.SpellCastTime - 300 - Game.Ping);
Core.DelayAction(() => E.Cast(target), delay);
//Chat.Print("Targetted detection");
}
return;
}
}
//Division
var rectangle = new Geometry.Polygon.Rectangle(args.Start, args.End, args.SData.LineWidth);
foreach (var ally in EntityManager.Heroes.Allies)
{
if (rectangle.IsInside(ally))
{
Allies.Add(ally); continue;
}
foreach (var point in rectangle.Points)
{
if (ally.Distance(point) <= 90)
{
Allies.Add(ally);
}
}
}
if (Allies.Any())
{
//Chat.Print("Rectangle Detection");
PriorityCast(sender, args, Allies, rectangle);
return;
}
//Division
var circle = new Geometry.Polygon.Circle(args.End, args.SData.CastRadius);
foreach (var ally in EntityManager.Heroes.Allies)
{
if (circle.IsInside(ally))
{
Allies.Add(ally); continue;
}
foreach (var point in circle.Points)
{
if (ally.Distance(point) <= 90)
{
Allies.Add(ally);
}
}
}
if (Allies.Any())
{
//Chat.Print("Circle Detection");
PriorityCast(sender, args, Allies, circle);
return;
}
}
}
}
return;
}
public static void Execute()
{
if (DravenRMissile != null && Player.Instance.Spellbook.GetSpell(SpellSlot.R).Name.ToLowerInvariant() == "dravenrdoublecast" && R.IsReady())
{
var pos = Player.Instance.Position.Extend(DravenRMissile.Position,
DravenRMissile.Distance(Player.Instance));
var rectangle = new Geometry.Polygon.Rectangle(Player.Instance.Position.To2D(), pos, 160);
var entitiesInside =
EntityManager.Heroes.Enemies.Where(x => x.IsValid() && rectangle.IsInside(x)).ToList();
if (entitiesInside.Count == 0)
{
return;
}
var cloesestEnemy = entitiesInside.OrderBy(x => x.Distance(DravenRMissile.Position)).First();
if (cloesestEnemy.TotalHealthWithShields() < Player.Instance.GetSpellDamage(cloesestEnemy, SpellSlot.R))
{
var posAfter = Prediction.Position.PredictUnitPosition(cloesestEnemy, 1000 + (int)(cloesestEnemy.Distance(DravenRMissile.Position) / 1900) * 1000); // r return delay
if (rectangle.IsInside(posAfter))
{
R.Cast();
Misc.PrintDebugMessage("hehe xd");
}
}
}
if (E.IsReady() && Settings.Combo.UseE && Player.Instance.Mana - 70 > 145)
{
var target = TargetSelector.GetTarget(E.Range, DamageType.Physical);
if (target != null)
{
var ePrediction = E.GetPrediction(target);
if (ePrediction.HitChance == HitChance.High)
{
E.Cast(ePrediction.CastPosition);
return;
}
}
}
if (!R.IsReady() || !Settings.Combo.UseR)
{
return;
}
if (Player.Instance.CountEnemiesInRange(900) == 1)
{
var target = TargetSelector.GetTarget(900, DamageType.Physical);
if (target != null && Player.Instance.HealthPercent > target.HealthPercent && !target.HasUndyingBuffA() &&
target.TotalHealthWithShields() <
Player.Instance.GetSpellDamage(target, SpellSlot.R) +
Player.Instance.GetAutoAttackDamage(target, true) * 3 && target.TotalHealthWithShields() > Player.Instance.GetAutoAttackDamage(target, true) * 3)
{
var rPrediction = R.GetPrediction(target);
if (rPrediction.HitChance == HitChance.High)
{
R.Cast(rPrediction.CastPosition);
return;
}
}
}
if (Player.Instance.CountEnemiesInRange(1500) > Player.Instance.CountAlliesInRange(1500))
{
return;
}
foreach (var rPrediction in EntityManager.Heroes.Enemies.Where(unit => unit.IsValidTarget(3000)).Select(enemy => Prediction.Manager.GetPrediction(new Prediction.Manager.PredictionInput
{
CollisionTypes = new HashSet <CollisionType> {
Prediction.Manager.PredictionSelected == "ICPrediction" ? CollisionType.AiHeroClient : CollisionType.ObjAiMinion
},
Delay = .5f,
From = Player.Instance.Position,
Range = 3000,
Radius = 160,
RangeCheckFrom = Player.Instance.Position,
Speed = 2000,
Target = enemy,
Type = SkillShotType.Linear
})).Where(rPrediction => rPrediction.RealHitChancePercent >= 60).Where(rPrediction => rPrediction.GetCollisionObjects <AIHeroClient>().Length >= 2))
{
R.Cast(rPrediction.CastPosition);
return;
}
}
