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);
}
private static void GameObject_OnCreate(GameObject sender, EventArgs args)
{
var missile = sender as MissileClient;
if (missile == null) return;
var missileInfo =
SpellDatabase.GetSpellInfoList(missile.SpellCaster).FirstOrDefault(s => s.RealSlot == missile.Slot);
if (missileInfo == null) return;
switch (missileInfo.Type)
{
case SpellType.Self:
break;
case SpellType.Circle:
var polCircle = new Geometry.Polygon.Circle(missile.Position, missileInfo.Radius);
Missiles.Add(missile, polCircle);
break;
case SpellType.Line:
var polLine = new Geometry.Polygon.Rectangle(missile.StartPosition,
missile.StartPosition.Extend(missile.EndPosition, missileInfo.Range).To3D(), 5);
Missiles.Add(missile, polLine);
break;
case SpellType.Cone:
var polCone = new Geometry.Polygon.Sector(missile.StartPosition, missile.EndPosition, missileInfo.Radius, missileInfo.Range, 80);
Missiles.Add(missile, polCone);
break;
case SpellType.Ring:
break;
case SpellType.Arc:
break;
case SpellType.MissileLine:
var polMissileLine = new Geometry.Polygon.Rectangle(missile.StartPosition,
missile.StartPosition.Extend(missile.EndPosition, missileInfo.Range).To3D(), 5);
Missiles.Add(missile, polMissileLine);
break;
case SpellType.MissileAoe:
var polMissileAoe = new Geometry.Polygon.Rectangle(missile.StartPosition,
missile.StartPosition.Extend(missile.EndPosition, missileInfo.Range).To3D(), 5);
Missiles.Add(missile, polMissileAoe);
break;
}
var polygons = new List<Geometry.Polygon>();
polygons.AddRange(Missiles.Values);
Joined = polygons.JoinPolygons();
}
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);
}
}
}
static void AutoUseQ()
{
if (Q.IsReady() && Getkeybindvalue(Auto, "AutoQ") && Player.ManaPercent > Getslidervalue(Auto, "MinMana"))
{
var extarget = TargetSelector.GetTarget(Q1.Range, DamageType.Physical);
var Minions = EntityManager.MinionsAndMonsters.GetLaneMinions(EntityManager.UnitTeam.Enemy,
Player.Position, Q.Range);
if(Minions == null || extarget == null || extarget.IsValidTarget()) return;
foreach (var Minion in Minions)
{
var QHit = new Geometry.Polygon.Rectangle(Player.Position, Player.Position.Extend(Minion.Position, Q1.Range), Q1.Width);
var QPred = Q1.GetPrediction(extarget);
if (!QHit.IsOutside(QPred.UnitPosition.To2D()) && QPred.HitChance >= HitChance.AveragePoint)
{
Q.Cast(Minion);
break;
}
}
}
}
//---------------------------------------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;
}
//------------------------------------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;
}
private static void OnObjAiBaseProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
try
{
var enemy = sender as Obj_AI_Hero;
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 UpdateTask()
{
if (EvadePlus.Program.Evade == null) return;
EvadePlus.Program.Evade.CacheSkillshots();
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 EvadePlus.Program.Evade.SkillshotDetector.ActiveSkillshots.Where(a => (a is LinearMissileSkillshot) && EvadeMenu.IsSkillshotW(a)))
{
if (WallPolygon.IsInside(activeSkillshot.GetPosition()))
{
activeSkillshot.IsValid = false;
}
}
}
EvadePlus.Program.Evade.CacheSkillshots();
if (EvadePlus.Program.Evade.IsHeroInDanger(Player.Instance))
{
if (Settings.UseW && SpellManager.W.IsReady())
{
foreach (var activeSkillshot in EvadePlus.Program.Evade.SkillshotDetector.ActiveSkillshots.Where(a => a is LinearMissileSkillshot && EvadeMenu.IsSkillshotW(a)))
{
if (activeSkillshot.ToPolygon().IsInside(Player.Instance))
{
Player.CastSpell(SpellSlot.W, activeSkillshot.GetPosition());
WDelay = Environment.TickCount + 500;
return;
}
}
}
if (WDelay > Environment.TickCount) return;
if (Settings.UseE && SpellManager.E.IsReady())
{
foreach (
var source in
EntityManager.MinionsAndMonsters.EnemyMinions.Where(
a => a.Team != Player.Instance.Team && a.Distance(Player.Instance) < 475 && a.CanE()))
{
if(source.GetAfterEPos().Tower()) continue;
if (EvadePlus.Program.Evade.IsPointSafe(source.GetAfterEPos().To2D()))
{
int count = 0;
for (int i = 0; i < 10; i += 47)
{
if (!EvadePlus.Program.Evade.IsPointSafe(Player.Instance.Position.Extend(source.GetAfterEPos(), 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.CanE()))
{
if (source.GetAfterEPos().Tower()) continue;
if (EvadePlus.Program.Evade.IsPointSafe(source.GetAfterEPos().To2D()))
{
int count = 0;
for (int i = 0; i < 10; i += 47)
{
if (!EvadePlus.Program.Evade.IsPointSafe(Player.Instance.Position.Extend(source.GetAfterEPos(), i)))
{
count ++;
}
}
if (count > 3) continue;
Player.CastSpell(SpellSlot.E, source);
break;
}
}
}
}
}
public static Vector2 GetCollisionPoint(this Skillshot skillshot)
{
var collisions = new List<DetectedCollision>();
var from = skillshot.GetMissilePosition(0);
skillshot.ForceDisabled = false;
foreach (var cObject in skillshot.SpellData.CollisionObjects)
{
switch (cObject)
{
case CollisionObjectTypes.Minion:
collisions.AddRange(
from minion in
EntityManager.MinionsAndMonsters.GetLaneMinions(skillshot.Unit.Team == ObjectManager.Player.Team ? EntityManager.UnitTeam.Enemy : EntityManager.UnitTeam.Ally,
@from.To3D(),
1200)
let pred =
FastPrediction(
@from,
minion,
Math.Max(
0,
skillshot.SpellData.Delay - (Extensions.GameTimeTickCount - skillshot.StartTick)),
skillshot.SpellData.MissileSpeed)
let pos = pred.PredictedPos
let w =
skillshot.SpellData.RawRadius + (!pred.IsMoving ? minion.BoundingRadius - 15 : 0)
- pos.Distance(@from, skillshot.End, true)
where w > 0
select
new DetectedCollision
{
Position =
pos.ProjectOn(skillshot.End, skillshot.Start).LinePoint
+ skillshot.Direction * 30,
Unit = minion,
Type = CollisionObjectTypes.Minion,
Distance = pos.Distance(@from),
Diff = w
});
break;
case CollisionObjectTypes.Champion:
collisions.AddRange(
from hero in EntityManager.Heroes.Allies.Where(i => i.IsValidTarget(1200, false) && !i.IsMe)
let pred =
FastPrediction(
@from,
hero,
Math.Max(
0,
skillshot.SpellData.Delay - (Extensions.GameTimeTickCount - skillshot.StartTick)),
skillshot.SpellData.MissileSpeed)
let pos = pred.PredictedPos
let w = skillshot.SpellData.RawRadius + 30 - pos.Distance(@from, skillshot.End, true)
where w > 0
select
new DetectedCollision
{
Position =
pos.ProjectOn(skillshot.End, skillshot.Start).LinePoint
+ skillshot.Direction * 30,
Unit = hero,
Type = CollisionObjectTypes.Minion,
Distance = pos.Distance(@from),
Diff = w
});
break;
case CollisionObjectTypes.YasuoWall:
if (
!EntityManager.Heroes.Allies.Any(
i => i.IsValidTarget(float.MaxValue, false) && i.ChampionName == "Yasuo"))
{
break;
}
var wall =
ObjectManager.Get<GameObject>()
.FirstOrDefault(
i =>
i.IsValid && Regex.IsMatch(i.Name, "_w_windwall.\\.troy", RegexOptions.IgnoreCase));
if (wall == null)
{
break;
}
var wallWidth = 300 + 50 * Convert.ToInt32(wall.Name.Substring(wall.Name.Length - 6, 1));
var wallDirection = (wall.Position.To2D() - wallCastedPos).Normalized().Perpendicular();
var wallStart = wall.Position.To2D() + wallWidth / 2f * wallDirection;
var wallEnd = wallStart - wallWidth * wallDirection;
var wallPolygon = new Geometry.Polygon.Rectangle(wallStart, wallEnd, 75);
var intersections = new List<Vector2>();
for (var i = 0; i < wallPolygon.Points.Count; i++)
{
var inter =
wallPolygon.Points[i].Intersection(
wallPolygon.Points[i != wallPolygon.Points.Count - 1 ? i + 1 : 0],
from,
skillshot.End);
if (inter.Intersects)
{
intersections.Add(inter.Point);
}
}
if (intersections.Count > 0)
{
var intersection = intersections.OrderBy(i => i.Distance(@from)).ToList()[0];
var collisionT = Extensions.GameTimeTickCount
+ Math.Max(
0,
skillshot.SpellData.Delay
- (Extensions.GameTimeTickCount - skillshot.StartTick)) + 100
+ (1000 * intersection.Distance(from)) / skillshot.SpellData.MissileSpeed;
if (collisionT - wallCastT < 4000)
{
if (skillshot.SpellData.Type != SkillShotType.SkillshotMissileLine)
{
skillshot.ForceDisabled = true;
}
return intersection;
}
}
break;
}
}
return collisions.Count > 0 ? collisions.OrderBy(i => i.Distance).ToList()[0].Position : new Vector2();
}
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
});
}
}
}
}
private static void UpdatePolygons()
{
foreach (var missile in Missiles)
{
var missileInfo =
SpellDatabase.GetSpellInfoList(missile.Key.SpellCaster)
.FirstOrDefault(s => s.RealSlot == missile.Key.Slot);
if (missileInfo == null) return;
switch (missileInfo.Type)
{
case SpellType.Self:
break;
case SpellType.Circle:
var polCircle = new Geometry.Polygon.Circle(missile.Key.Position, missileInfo.Radius);
Missiles[missile.Key] = polCircle;
break;
case SpellType.Line:
var polLine = new Geometry.Polygon.Rectangle(missile.Key.StartPosition,
missile.Key.StartPosition.Extend(missile.Key.EndPosition, missileInfo.Range).To3D(), 5);
Missiles[missile.Key] = polLine;
break;
case SpellType.Cone:
var polCone = new Geometry.Polygon.Sector(missile.Key.StartPosition, missile.Key.EndPosition, missileInfo.Radius, missileInfo.Range, 80);
Missiles[missile.Key] = polCone;
break;
case SpellType.Ring:
break;
case SpellType.Arc:
break;
case SpellType.MissileLine:
var polMissileLine = new Geometry.Polygon.Rectangle(missile.Key.StartPosition,
missile.Key.StartPosition.Extend(missile.Key.EndPosition, missileInfo.Range).To3D(), 5);
Missiles[missile.Key] = polMissileLine;
break;
case SpellType.MissileAoe:
var polMissileAoe = new Geometry.Polygon.Rectangle(missile.Key.StartPosition,
missile.Key.StartPosition.Extend(missile.Key.EndPosition, missileInfo.Range).To3D(), 5);
Missiles[missile.Key] = polMissileAoe;
break;
}
}
var polygons = new List<Geometry.Polygon>();
polygons.AddRange(Missiles.Values);
Joined = polygons.JoinPolygons();
}
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
});
}
}
}
}
internal static bool HasCollison(Obj_AI_Base target)
{
var Rectangle = new Geometry.Polygon.Rectangle(Player.Instance.ServerPosition, target.Home(), SpellBase.Width);
return(EntityManager.Heroes.Enemies.Count(e => Rectangle.IsInside(e) && e.IsValidTarget()) > SpellBase.AllowedCollisionCount);
}
protected override async Task <bool> Killsteal()
{
if (await base.Killsteal())
{
return(true);
}
if (MyHero.IsSilenced())
{
return(false);
}
var flare = MyHero.Spellbook.SpellE;
if (flare.IsKillstealAbilityEnabled() && flare.CanBeCasted())
{
var damage = (float)flare.GetDamage(flare.Level - 1);
damage *= GetSpellAmp();
var enemy =
ObjectManager.GetEntitiesParallel <Hero>()
.FirstOrDefault(
x =>
x.IsAlive && x.Team != MyHero.Team && flare.CanBeCasted(x) &&
x.Distance2D(MyHero) < 5000 && !x.IsIllusion &&
x.Health < damage * (1 - x.MagicResistance()) && !x.CantBeAttacked() &&
!x.CantBeKilled());
if (enemy != null)
{
var speed = flare.GetAbilityData("speed");
var time = enemy.Distance2D(MyHero) / speed * 1000.0f;
var predictedPos = Prediction.Prediction.PredictPosition(enemy, (int)time);
Log.Debug($"use flare killsteal");
flare.UseAbility(predictedPos);
await Await.Delay(GetAbilityDelay(enemy, flare));
return(true);
}
}
if (Target != null)
{
return(false);
}
var ult = MyHero.Spellbook.SpellR;
if (ult.IsKillstealAbilityEnabled() && MyHero.HasItem(ClassId.CDOTA_Item_UltimateScepter) && ult.CanBeCasted())
{
var damage = ult.GetAbilityData("damage");
damage *= GetSpellAmp();
var enemies =
ObjectManager.GetEntitiesParallel <Hero>()
.Where(
x =>
x.IsAlive && x.Team != MyHero.Team && ult.CanBeCasted(x) && ult.CanHit(x) &&
!x.IsIllusion &&
x.Health < damage * (1 - x.MagicResistance()) && !x.CantBeAttacked() &&
!x.CantBeKilled());
var speed = ult.GetAbilityData("speed");
var radius = ult.GetAbilityData("latch_radius") * 2;
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)
{
continue;
}
var rec = new Geometry.Polygon.Rectangle(MyHero.NetworkPosition, predictedPos, radius);
// test for enemies in range
var isUnitBlocking = ObjectManager.GetEntitiesParallel <Unit>()
.Any(
x =>
x.IsValid && x != enemy && x.IsAlive && x != MyHero &&
x.IsSpawned && x.IsRealUnit() &&
x.Distance2D(enemy) >= radius &&
rec.IsInside(x.NetworkPosition));
if (!isUnitBlocking)
{
Log.Debug($"use ult for killsteal");
ult.UseAbility(predictedPos);
await Await.Delay(GetAbilityDelay(enemy, ult));
return(true);
}
}
}
return(false);
}
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 async Task ExecuteComboAsync(Unit target, CancellationToken tk = new CancellationToken())
{
var ult = MyHero.Spellbook.SpellR;
if (!MyHero.IsSilenced() && ult.IsAbilityEnabled() && ult.CanBeCasted(target) && ult.CanHit(target))
{
var speed = ult.GetAbilityData("speed");
var radius = ult.GetAbilityData("latch_radius") * 2;
var time = target.Distance2D(MyHero) / speed * 1000.0f;
var predictedPos = Prediction.Prediction.PredictPosition(target, (int)time, true);
if (predictedPos != Vector3.Zero)
{
var rec = new Geometry.Polygon.Rectangle(MyHero.NetworkPosition, predictedPos, radius);
// test for enemies in range
var isUnitBlocking = ObjectManager.GetEntitiesParallel <Unit>()
.Any(
x =>
x.IsValid && x != target && x.IsAlive && x != MyHero &&
x.IsSpawned && x.IsRealUnit() &&
x.Distance2D(target) >= radius &&
rec.IsInside(x.NetworkPosition));
if (!isUnitBlocking)
{
Log.Debug($"use ult");
ult.UseAbility(predictedPos);
await Await.Delay(GetAbilityDelay(target, ult), tk);
}
else if (ShouldCircleHook)
{
//MyHero.Hold();
var dir = (Game.MousePosition - target.NetworkPosition).Normalized();
var distance = (target.NetworkPosition - MyHero.NetworkPosition).Length();
var targetPos = target.NetworkPosition + dir * distance;
MyHero.Move(Prediction.Prediction.PredictMyRoute(MyHero, 500, targetPos).Last());
return;
}
}
}
await UseItems(target, tk);
// make him disabled
if (await DisableEnemy(target, tk) == DisabledState.UsedAbilityToDisable)
{
Log.Debug($"disabled!");
// return;
}
// check if we are near the enemy
if (!await MoveOrBlinkToEnemy(target, tk))
{
Log.Debug($"return because of blink");
return;
}
if (!MyHero.IsSilenced())
{
var cogs = MyHero.Spellbook.SpellW;
if (cogs.IsAbilityEnabled() && cogs.CanBeCasted())
{
var radius = cogs.GetAbilityData("cogs_radius");
if (target.Distance2D(MyHero) <= radius)
{
Log.Debug($"use cogs");
cogs.UseAbility();
await Await.Delay((int)(cogs.FindCastPoint() * 1000.0 + 125 + Game.Ping), tk);
var bladeMail = MyHero.GetItemById(ItemId.item_blade_mail);
if (bladeMail != null && bladeMail.CanBeCasted())
{
Log.Debug($"using blademail");
bladeMail.UseAbility();
await Await.Delay(ItemDelay, tk);
}
}
}
var q = MyHero.Spellbook.SpellQ;
if (q.IsAbilityEnabled() && q.CanBeCasted(target))
{
Log.Debug($"use Q");
q.UseAbility();
await Await.Delay((int)(q.FindCastPoint() * 1000.0 + Game.Ping), tk);
}
var flare = MyHero.Spellbook.SpellQ;
if (flare.IsAbilityEnabled() && flare.CanBeCasted(target))
{
var speed = flare.GetAbilityData("speed");
var time = target.Distance2D(MyHero) / speed * 1000.0f;
var predictedPos = Prediction.Prediction.PredictPosition(target, (int)time);
Log.Debug($"use flare");
flare.UseAbility(predictedPos);
await Await.Delay(GetAbilityDelay(target, flare), tk);
}
}
await HasNoLinkens(target, tk);
if (ZaioMenu.ShouldUseOrbwalker)
{
Orbwalk();
}
}
public void OnUpdate()
{
if (SpellData.CollisionObjects.Length > 0 && SpellData.CollisionObjects != null &&
Utils.GameTimeTickCount - _lastCollisionCalc > 50)
{
_lastCollisionCalc = Utils.GameTimeTickCount;
_collisionEnd = Collision.GetCollisionPoint(this);
}
if (SpellData.Type == SkillShotType.SkillshotMissileLine)
{
Rectangle = new Geometry.Polygon.Rectangle(GetMissilePosition(0), CollisionEnd, SpellData.Radius);
UpdatePolygon();
}
if (SpellData.MissileFollowsUnit)
{
if (Unit.IsVisible)
{
End = Unit.ServerPosition.To2D();
Direction = (End - Start).Normalized();
UpdatePolygon();
}
}
if (SpellData.SpellName == "TaricE")
{
Start = Unit.ServerPosition.To2D();
End = Start + Direction * SpellData.Range;
Rectangle = new Geometry.Polygon.Rectangle(Start, End, SpellData.Radius);
UpdatePolygon();
}
if (SpellData.SpellName == "SionR")
{
if (_helperTick == 0)
{
_helperTick = StartTick;
}
SpellData.MissileSpeed = (int)Unit.MoveSpeed;
if (Unit.IsValidTarget(float.MaxValue, false))
{
if (!Unit.HasBuff("SionR") && Utils.GameTimeTickCount - _helperTick > 600)
{
StartTick = 0;
}
else
{
StartTick = Utils.GameTimeTickCount - SpellData.Delay;
Start = Unit.ServerPosition.To2D();
End = Unit.ServerPosition.To2D() + 1000 * Unit.Direction.To2D().Perpendicular();
Direction = (End - Start).Normalized();
UpdatePolygon();
}
}
else
{
StartTick = 0;
}
}
if (SpellData.FollowCaster)
{
Circle.Center = Unit.ServerPosition.To2D();
UpdatePolygon();
}
}
/// <summary>
/// Ranged Champions Logic.
/// </summary>
public static bool RangedLogic()
{
var NearestEnemy = ObjectsManager.NearestEnemy;
// TeamFighting Logic.
if (NearestEnemy != null && Brain.TeamFightActive && MyHero.Instance.PredictHealthPercent() > 15 &&
!(ModesManager.CurrentMode == ModesManager.Modes.Flee || ModesManager.CurrentMode == ModesManager.Modes.None))
{
var pos = NearestEnemy.KitePos(Detector.LastAlliesTeamFightPos);
if (MyHero.Instance.SafePath(pos))
{
Program.Moveto = "KiteNearestEnemy";
Position = pos;
return(true);
}
}
// Tower Defence
if (ObjectsManager.FarthestAllyTurret != null && Player.Instance.PredictHealthPercent() >= 20)
{
if (ObjectsManager.FarthestAllyTurret.CountEnemyHeros((int)ObjectsManager.FarthestAllyTurret.GetAutoAttackRange(MyHero.Instance) + 50) > 0)
{
var enemy = EntityManager.Heroes.Enemies.OrderBy(o => o.Distance(ObjectsManager.AllySpawn)).FirstOrDefault(e => e.IsKillable() && e.IsUnderEnemyturret() &&
(e.TeamTotal() >= e.TeamTotal(true) || e.CountAllyHeros(SafeValue) > 1 || e.CountEnemyHeros(SafeValue) < 2));
if (enemy != null)
{
Program.Moveto = "DefendingTower";
Position = enemy.KitePos(ObjectsManager.AllySpawn);
return(true);
}
}
}
// Inhb defend
var AllyInhb = ObjectsManager.AllyInhb;
if (AllyInhb != null && AllyInhb.IsValidTarget() && AllyInhb.CountEnemyHeroesInRangeWithPrediction(SafeValue) > 0 && AllyInhb.Position.TeamTotal() > AllyInhb.Position.TeamTotal(true))
{
var enemy = EntityManager.Heroes.Enemies.OrderBy(o => o.Distance(ObjectsManager.AllySpawn)).FirstOrDefault(e => e.IsKillable() && e.IsInRange(AllyInhb, SafeValue) &&
(e.TeamTotal() >= e.TeamTotal(true) || e.CountAllyHeros(SafeValue) > 1 || e.CountEnemyHeros(SafeValue) < 2));
if (enemy != null)
{
Program.Moveto = "DefendingInhbitor";
Position = enemy.KitePos(ObjectsManager.AllySpawn);
return(true);
}
}
var EnemyObject = ObjectsManager.NearestEnemyObject;
// if Can AttackObject then start attacking THE DAMN OBJECT FFS.
if (EnemyObject != null && Player.Instance.PredictHealthPercent() > 20 && ModesManager.AttackObject &&
(EnemyObject.Position.TeamTotal() > EnemyObject.Position.TeamTotal(true) || EnemyObject.CountEnemyHeros(SafeValue + 100) < 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.KitePos(extendto);
var rect = new Geometry.Polygon.Rectangle(Player.Instance.ServerPosition, ObjectsManager.NearestEnemyObject.Position, 400);
var Enemy = EntityManager.Heroes.Enemies.Any(a => a != null && a.IsValid && a.TeamTotal(true) > a.TeamTotal() && !a.IsDead && new Geometry.Polygon.Circle(a.PredictPosition(), a.GetAutoAttackRange(Player.Instance)).Points.Any(p => rect.IsInside(p)));
if (!Enemy)
{
if (ObjectsManager.EnemyTurret != null)
{
var TurretCircle = new Geometry.Polygon.Circle(ObjectsManager.EnemyTurret.ServerPosition, ObjectsManager.EnemyTurret.GetAutoAttackRange(Player.Instance));
if (ObjectsManager.NearestEnemyObject is Obj_AI_Turret)
{
if (SafeToDive)
{
Program.Moveto = "NearestEnemyObject";
Position = extendtopos;
return(true);
}
}
if (!TurretCircle.Points.Any(p => rect.IsInside(p)))
{
Program.Moveto = "NearestEnemyObject2";
Position = extendtopos;
return(true);
}
}
else
{
Program.Moveto = "NearestEnemyObject3";
Position = extendtopos;
return(true);
}
}
}
// if NearestEnemyMinion exsists moves to NearestEnemyMinion.
var NearestEnemyMinion = ObjectsManager.NearestEnemyMinion;
if (NearestEnemyMinion != null && MyHero.Instance.SafePath(NearestEnemyMinion) && NearestEnemyMinion.CountEnemyMinionsInRangeWithPrediction(SafeValue) > 1 && ObjectsManager.AllySpawn != null && Player.Instance.PredictHealthPercent() > 20)
{
Program.Moveto = "NearestEnemyMinion";
Position = NearestEnemyMinion.PredictPosition().Extend(ObjectsManager.AllySpawn.Position.Random(), KiteDistance(NearestEnemyMinion)).To3D();
return(true);
}
// if SafestAllyToFollow2 exsists moves to SafestAllyToFollow2.
if (ObjectsManager.SafestAllyToFollow2 != null)
{
Program.Moveto = "SafestAllyToFollow2";
Position = ObjectsManager.SafestAllyToFollow2.PredictPosition().Extend(ObjectsManager.AllySpawn, 100).Random();
return(true);
}
// if Minion not exsist picks other to follow.
if (ObjectsManager.AllyMinion != null)
{
Program.Moveto = "AllyMinion";
Position = ObjectsManager.AllyMinion.PredictPosition().Extend(ObjectsManager.AllySpawn, 100).Random();
return(true);
}
// if SecondTurret exsists moves to SecondTurret.
if (ObjectsManager.SecondTurret != null)
{
Program.Moveto = "SecondTurret";
Position = ObjectsManager.SecondTurret.ServerPosition.Extend(ObjectsManager.AllySpawn, 425).To3D().Random();
return(true);
}
// if SafeAllyTurret exsists moves to SafeAllyTurret.
if (ObjectsManager.SafeAllyTurret != null)
{
Program.Moveto = "SafeAllyTurret";
Position = ObjectsManager.SafeAllyTurret.ServerPosition.Extend(ObjectsManager.AllySpawn, 425).To3D().Random();
return(true);
}
// if ClosesetAllyTurret exsists moves to ClosesetAllyTurret.
if (ObjectsManager.ClosesetAllyTurret != null)
{
Program.Moveto = "ClosesetAllyTurret";
Position = ObjectsManager.ClosesetAllyTurret.ServerPosition.Extend(ObjectsManager.AllySpawn, 425).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 async Task ExecuteComboAsync(Unit target, CancellationToken tk = new CancellationToken())
{
if (MyHero.IsChanneling() || MyHero.HasModifier("modifier_pudge_dismember"))
{
if (_rotAbility.IsAbilityEnabled() && !MyHero.IsSilenced() && _rotAbility.CanBeCasted(target) && !_rotAbility.IsToggled &&
_rotAbility.CanHit(target))
{
_rotAbility.ToggleAbility();
await Await.Delay(100, tk);
}
return;
}
if (_hasHookModifier || target.HasModifier("modifier_pudge_meat_hook"))
{
if (!MyHero.IsSilenced() && _rotAbility.IsAbilityEnabled() && _rotAbility.CanBeCasted() && !_rotAbility.IsToggled)
{
_rotAbility.ToggleAbility();
await Await.Delay(ItemDelay, tk);
}
if (_ultAbility.IsAbilityEnabled() && await HasNoLinkens(target, tk) && _ultAbility.CanBeCasted(target))
{
if (!MyHero.IsSilenced() && _ultAbility.CanHit(target))
{
_ultAbility.UseAbility(target);
await Await.Delay(GetAbilityDelay(target, _ultAbility) + 250, tk);
}
else if (ShouldStopOnHook)
{
MyHero.Hold();
}
}
return;
}
if (!MyHero.IsSilenced())
{
if (_rotAbility.IsAbilityEnabled() && _rotAbility.CanBeCasted(target) && !_rotAbility.IsToggled && _rotAbility.CanHit(target))
{
_rotAbility.ToggleAbility();
await Await.Delay(100, tk);
}
if (_ultAbility.IsAbilityEnabled() && _ultAbility.CanBeCasted(target) && _ultAbility.CanHit(target) && await HasNoLinkens(target, tk))
{
if (_ultAbility.CanHit(target))
{
_ultAbility.UseAbility(target);
await Await.Delay(GetAbilityDelay(target, _ultAbility) + 250, tk);
return;
}
}
if (_hookAbility.IsAbilityEnabled() && _hookAbility.CanBeCasted(target) && _hookAbility.CanHit(target))
{
var speed = _hookAbility.GetAbilityData("hook_speed");
var radius = _hookAbility.GetAbilityData("hook_width") * 2;
var time = target.Distance2D(MyHero) / speed * 1000.0f;
var predictedPos = Prediction.Prediction.PredictPosition(target, (int)time, true);
if (predictedPos != Vector3.Zero)
{
var rec = new Geometry.Polygon.Rectangle(MyHero.NetworkPosition, predictedPos, radius);
// test for enemies in range
var isUnitBlocking = ObjectManager.GetEntitiesParallel <Unit>()
.Any(
x =>
x.IsValid && x != target && x.IsAlive && x != MyHero &&
x.IsSpawned && x.IsRealUnit() && !x.IsIllusion &&
x.Distance2D(target) >= radius &&
rec.IsInside(x.NetworkPosition));
if (!isUnitBlocking)
{
Log.Debug($"using hook");
_hookAbility.UseAbility(predictedPos);
await Await.Delay(GetAbilityDelay(predictedPos, _hookAbility), tk);
return;
}
if (ShouldCircleHook)
{
//MyHero.Hold();
var dir = (Game.MousePosition - target.NetworkPosition).Normalized();
var distance = (target.NetworkPosition - MyHero.NetworkPosition).Length();
var targetPos = target.NetworkPosition + dir * distance;
MyHero.Move(Prediction.Prediction.PredictMyRoute(MyHero, 500, targetPos).Last());
return;
}
}
}
}
await UseItems(target, tk);
// make him disabled
if (await DisableEnemy(target, tk) == DisabledState.UsedAbilityToDisable)
{
Log.Debug($"disabled!");
// return;
}
// check if we are near the enemy
if (!await MoveOrBlinkToEnemy(target, tk))
{
Log.Debug($"return because of blink");
return;
}
if (ZaioMenu.ShouldUseOrbwalker)
{
Orbwalk();
}
}
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);
}
}
}
static void OnLoadingComplete(EventArgs args)
{
if (Player.Instance.ChampionName != ChampName)
return;
SkinID = Player.Instance.SkinId;
Config.Initialize();
ModeManager.Initialize();
ItemManager.Initialize();
SpellManager.Initialize();
RRectangle = new Geometry.Polygon.Rectangle(Player.Instance.Position, Player.Instance.Position, 300);
//Notification.DrawNotification(new NotificationModel(Game.Time, 5f, 2f, Player.Instance.ChampionName + " Loaded.", Color.Green));
UpdateChecker.CheckForUpdates();
Player.SetSkinId(Config.Misc.SkinID);
Drawing.OnDraw += OnDraw;
Game.OnUpdate += OnUpdate;
Obj_AI_Base.OnProcessSpellCast += OnProcessSpellCast;
Obj_AI_Base.OnBasicAttack += OnBasicAttack;
}
public static Vector2 GetCollision(SpellInstance spell)
{
var result = new List <Vector2>();
var curPos = spell.GetMissilePosition(0);
spell.ForceDisabled = false;
foreach (var type in spell.Data.CollisionObjects)
{
switch (type)
{
case CollisionableObjects.Minions:
result.AddRange(
from minion in
ObjectManager.Get <Obj_AI_Minion>()
.Where(
i =>
i.IsValidTarget(1200, false, curPos.To3D()) &&
(i.IsJungle() || (i.IsAlly && (i.IsMinion() || i.IsPet()))))
let pred =
FastPrediction(
curPos,
minion,
Math.Max(0, spell.Data.Delay - (Utils.GameTimeTickCount - spell.StartTick)),
spell.Data.MissileSpeed)
let pos = pred.Position
where
spell.Data.RawRadius + (!pred.IsMoving ? minion.BoundingRadius - 15 : 0)
- pos.Distance(curPos, spell.End, true) > 0
select pos.ProjectOn(spell.End, spell.Start).LinePoint + spell.Direction * 30);
break;
case CollisionableObjects.Heroes:
result.AddRange(
from hero in HeroManager.Allies.Where(i => !i.IsMe && i.IsValidTarget(1200, false))
let pos =
FastPrediction(
curPos,
hero,
Math.Max(0, spell.Data.Delay - (Utils.GameTimeTickCount - spell.StartTick)),
spell.Data.MissileSpeed).Position
where spell.Data.RawRadius + 30 - pos.Distance(curPos, spell.End, true) > 0
select pos.ProjectOn(spell.End, spell.Start).LinePoint + spell.Direction * 30);
break;
case CollisionableObjects.YasuoWall:
if (!haveYasuo || spell.Data.MissileSpeed == 0)
{
continue;
}
var wall =
ObjectManager.Get <Obj_GeneralParticleEmitter>()
.FirstOrDefault(
i => i.IsValid && new Regex("Yasuo_.+_W_windwall.\\.troy").IsMatch(i.Name));
if (wall == null)
{
continue;
}
var wallWidth = 300 + 50 * Convert.ToInt32(wall.Name.Substring(wall.Name.Length - 6, 1));
var wallDirection = (wall.Position.To2D() - yasuoWallPos).Normalized().Perpendicular();
var wallStart = wall.Position.To2D() + wallWidth / 2f * wallDirection;
var wallEnd = wallStart - wallWidth * wallDirection;
var wallPolygon = new Geometry.Polygon.Rectangle(wallStart, wallEnd, 75);
var intersects = wallPolygon.GetIntersectPointsLine(curPos, spell.End);
if (intersects.Count > 0)
{
var intersect = intersects.OrderBy(i => i.Distance(curPos)).First();
var time = Utils.GameTimeTickCount
+ Math.Max(0, spell.Data.Delay - (Utils.GameTimeTickCount - spell.StartTick))
+ 100 + intersect.Distance(curPos) / spell.Data.MissileSpeed * 1000;
if (time - yasuoWallTick < 4000)
{
if (spell.Type != SpellType.MissileLine)
{
spell.ForceDisabled = true;
}
return(intersect);
}
}
break;
}
}
return(result.Count > 0 ? result.OrderBy(i => i.Distance(curPos)).First() : Vector2.Zero);
}
public RectangleContainer(Geometry.Polygon.Rectangle rect, int hitCount)
{
Rectangle = rect;
HitCount = hitCount;
CastPosition = rect.End.To3D();
}
private static void OnEnemyGapcloser(ActiveGapcloser args)
{
try
{
if (args.Sender.IsEnemy)
{
if (args.Sender.ChampionName.Equals("Pantheon", StringComparison.OrdinalIgnoreCase))
{
return;
}
var endPos = args.End;
if (args.Sender.ChampionName.Equals("Fizz", StringComparison.OrdinalIgnoreCase))
{
endPos = args.Start.Extend(endPos, 550f);
}
else if (args.Sender.ChampionName.Equals("Yasuo", StringComparison.OrdinalIgnoreCase))
{
endPos = args.Start.Extend(endPos, 475f);
}
else if (args.Sender.ChampionName.Equals("Poppy", StringComparison.OrdinalIgnoreCase))
{
endPos = args.Start.Extend(endPos, 475f);
}
var spell = args.Sender.GetSpell(args.Slot);
if (args.Sender.ChampionName.Equals("Gragas", StringComparison.OrdinalIgnoreCase) &&
args.Slot == SpellSlot.E ||
args.Sender.ChampionName.Equals("Sejuani", StringComparison.OrdinalIgnoreCase) &&
args.Slot == SpellSlot.Q)
{
if (spell != null)
{
var colObjects =
GameObjects.AllyHeroes.Select(a => a as Obj_AI_Base)
.Concat(
GameObjects.AllyMinions.Where(m => m.Distance(args.Sender) <= 2000).ToList());
var rect = new Geometry.Polygon.Rectangle(
args.Start, endPos, spell.SData.LineWidth + args.Sender.BoundingRadius);
var collision =
colObjects.FirstOrDefault(
col =>
new Geometry.Polygon.Circle(col.ServerPosition, col.BoundingRadius).Points.Any(
p => rect.IsInside(p)));
if (collision != null)
{
endPos = collision.ServerPosition.Extend(
args.Sender.ServerPosition, args.Sender.BoundingRadius + collision.BoundingRadius);
if (collision is Obj_AI_Minion && endPos.Distance(args.Start) <= 100)
{
return;
}
}
}
}
var endTime = Game.Time;
if (spell != null)
{
var time = args.Start.Distance(endPos) /
Math.Max(spell.SData.MissileSpeed, args.Sender.MoveSpeed * 1.25f);
if (time <= 3)
{
endTime += time;
}
}
Check(false, args.Sender, args.Start, endPos, endTime, args.SkillType == GapcloserType.Targeted);
}
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
}
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);
}
}
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);
}
//------------------------------------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 Vector3 GetBestLinearPredictionPos(this Spell.Skillshot self, List<Obj_AI_Base> enemies, Vector3 sourcePosition, out int enemiesHit)
{
enemiesHit = 0;
enemies = enemies.Where(a => a.MeetsCriteria() && a.IsInRange(sourcePosition, self.Range)).ToList();
Vector3 castPosition = Vector3.Zero;
//if there is nothing that meets the criteria
if (enemies.Count() == 0)
return castPosition;
List<Tuple<Geometry.Polygon.Rectangle, Vector3>> rectPositions = new List<Tuple<Geometry.Polygon.Rectangle, Vector3>>();
Vector3 extendingPosition = sourcePosition + new Vector3(0, self.Range, 0);
//checks every 15 degrees
for (int i = 0; i < 24; i++)
{
Vector3 endPosition = extendingPosition.To2D().RotateAroundPoint(sourcePosition.To2D(), (float)((i * 15) * Math.PI / 180)).To3D((int)sourcePosition.Z);
Geometry.Polygon.Rectangle rect = new Geometry.Polygon.Rectangle(sourcePosition, endPosition, self.Width);
rectPositions.Add(Tuple.Create(rect, endPosition));
}
Tuple<Geometry.Polygon.Rectangle, Vector3> bestPos = null;
if (self.AllowedCollisionCount == 1)
{
bestPos = rectPositions.Where(a =>
enemies.Where(enemy => a.Item1.IsInside(enemy)).OrderBy(enemy => enemy.Distance(sourcePosition)).FirstOrDefault() != null
).FirstOrDefault();
if (bestPos != null)
enemiesHit = 1;
}
else
{
bestPos = rectPositions.OrderByDescending(a =>
enemies.Where(enemy => a.Item1.IsInside(enemy)).Count()
).FirstOrDefault();
if (bestPos != null)
enemiesHit = enemies.Where(enemy => bestPos.Item1.IsInside(enemy)).Count();
}
if (bestPos != null)
return sourcePosition.Extend(bestPos.Item2, self.Range / 2).To3D((int)sourcePosition.Z);
else
return Vector3.Zero;
}
private static void OnDoCastDelayedLC(GameObjectProcessSpellCastEventArgs args)
{
AAPassive = false;
if (args.Target is Obj_AI_Minion && args.Target.IsValid)
{
if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.LaneClear) && Player.ManaPercent >= Getslidervalue(Laneclear, "LMinMana"))
{
var Minions =
EntityManager.MinionsAndMonsters.Get(EntityManager.MinionsAndMonsters.EntityType.Both,
EntityManager.UnitTeam.Enemy, Player.Position, Player.GetAutoAttackRange())
.OrderByDescending(i => i.Health).ToList();
if (Minions[0].IsValid && Minions.Count != 0)
{
if (!Getkeybindvalue(Laneclear, "LT")) return;
if (E.IsReady() && !AAPassive && Getcheckboxvalue(Laneclear, "LE")) EloBuddy.Player.CastSpell(SpellSlot.E, Player.Position.Extend(Game.CursorPos, 70));
if (Q.IsReady() && (!E.IsReady() || (E.IsReady() && !Getcheckboxvalue(Laneclear, "LE"))) && Getslidervalue(Laneclear, "LQ") != 0 && !AAPassive)
{
var QMinions = EntityManager.MinionsAndMonsters.GetLaneMinions(
EntityManager.UnitTeam.Enemy, Player.Position, Q.Range);
var exminions = EntityManager.MinionsAndMonsters.GetLaneMinions(
EntityManager.UnitTeam.Enemy, Player.Position, Q1.Range);
foreach (var Minion in QMinions)
{
var QHit = new Geometry.Polygon.Rectangle(Player.Position,Player.Position.Extend(Minion.Position, Q1.Range),Q1.Width);
if (exminions.Count(x => !QHit.IsOutside(x.Position.To2D())) >= Getslidervalue(Laneclear, "LQ"))
{
Q.Cast(Minion);
break;
}
}
}
if ((!E.IsReady() || (E.IsReady() && !Getcheckboxvalue(Laneclear, "LE"))) && (!Q.IsReady() || (Q.IsReady() && Getslidervalue(Laneclear, "LQ") == 0)) && Getcheckboxvalue(Laneclear, "LW") && W.IsReady() && !AAPassive) W.Cast(Minions[0].Position);
}
}
}
}
public static Vector3 GetPos()
{
var AARange = Player.Instance.GetAutoAttackRange(Nearest);
var TargetPosition = new Vector2();
if (Nearest != null)
{
TargetPosition = Config.EPath.CurrentValue ? Prediction.Position.PredictUnitPosition(Nearest, 200) : Nearest.Position.To2D();
}
var Location = new Vector3();
if (Config.EQ.CurrentValue && Player.Instance.CountEnemiesInRange(Spells.Q2.Range + Spells.E.Range) > Config.EQHit.CurrentValue)
{
var Champs = EntityManager.Heroes.Enemies.Where(x => !x.IsDead && x.IsValid && x.Distance(Player.Instance) <= Spells.E.Range + Spells.Q2.Range).ToArray();
if (Champs != null)
{
Prediction.Position.PredictionData data = new Prediction.Position.PredictionData(Prediction.Position.PredictionData.PredictionType.Linear, (int)Spells.Q2.Range, Spells.Q2.Width, 0, 450, int.MaxValue, int.MaxValue, Player.Instance.Position);
var preds = Prediction.Position.GetPredictionAoe(Champs, data).OrderByDescending(x => x.CastPosition.Distance(Player.Instance)).ToArray();
if (preds.Count() >= Config.EQHit.CurrentValue)
{
for (var i = 1; i <= preds.Count(); i++)
{
var Rectangle = new Geometry.Polygon.Rectangle(preds[0].CastPosition, preds[i].CastPosition, 75f);
var count = preds.Count(x => Rectangle.IsInside(x.CastPosition));
if (count >= Config.EQHit.CurrentValue)
{
var Position = preds[0].CastPosition.Extend(preds[i].CastPosition, Spells.Q.Range).To3DWorld();
if (Spells.E.IsInRange(Position))
{
Location = Position;
break;
}
}
}
}
}
}
else
{
switch (Get_Style_Of_E)
{
case 1:
{
var Range = Config.ERange.CurrentValue;
var Path = Intersection_Of_2Circle(Player.Instance.Position.To2D(), Spells.E.Range, TargetPosition, AARange - Range);
if (Path.Count() > 0)
{
if (Path.Count(x => IsNotDangerPosition(x)) == 2)
{
Location = Path.OrderByDescending(x => Get_Rate_Position(x)).OrderBy(x => x.Distance(Game.CursorPos)).FirstOrDefault().To3DWorld();
}
else if (Path.Count(x => IsNotDangerPosition(x)) == 0)
{
var Position = Path.OrderByDescending(x => Get_Rate_Position(x)).OrderBy(x => x.Distance(Game.CursorPos)).FirstOrDefault().To3DWorld();
var target = TargetSelector.GetTarget(EntityManager.Heroes.Enemies.Where(t => t != null &&
!t.IsDead &&
t.IsValidTarget() &&
Position.IsInRange(t, Player.Instance.GetAutoAttackRange(t)) &&
t.Health <= Damages.EDamage(t) &&
!t.Unkillable()), DamageType.Physical);
if (target != null)
{
Location = Position;
}
else if (Config.ECorrect.CurrentValue)
{
var Loc = Path.OrderBy(x => x.Distance(Game.CursorPos)).FirstOrDefault().To3DWorld();
Location = CorrectToBetter(Loc);
}
else
{
Location = Vector3.Zero;
}
}
else
{
Location = Path.OrderBy(x => Get_Rate_Position(x)).FirstOrDefault(x => IsNotDangerPosition(x)).To3DWorld();
}
}
else
{
if (Player.Instance.Distance(TargetPosition) >= AARange + Spells.E.Range)
{
Location = Vector3.Zero;
}
if (Player.Instance.Distance(TargetPosition) <= AARange - Spells.E.Range && Config.EKite.CurrentValue)
{
Location = Nearest.Position.Extend(Player.Instance, Nearest.Distance(Player.Instance) + Spells.E.Range).To3DWorld();
}
}
}
break;
case 2:
{
if (Nearest.Distance(Player.Instance) <= AARange + Spells.E.Range)
{
Location = Player.Instance.ServerPosition.Extend(Game.CursorPos, Spells.E.Range).To3DWorld();
}
}
break;
case 3:
{
if (Nearest.Distance(Player.Instance) <= AARange + Spells.E.Range)
{
if (Nearest.Distance(Player.Instance) <= AARange - Spells.E.Range && Config.EKite.CurrentValue)
{
Location = Nearest.Position.Extend(Player.Instance, Nearest.Distance(Player.Instance) + Spells.E.Range).To3DWorld();
}
else
{
var Pos = Player.Instance.ServerPosition.Extend(Game.CursorPos, Spells.E.Range).To3DWorld();
var GrassObject = ObjectManager.Get <GameObject>().Where(x => Spells.E.IsInRange(x.Position) && x.Type.ToString() == "GrassObject").OrderBy(x => x.Distance(Nearest)).FirstOrDefault();
var target = TargetSelector.GetTarget(EntityManager.Heroes.Enemies.Where(t => t != null &&
!t.IsDead &&
t.IsValidTarget() &&
Pos.IsInRange(t, Player.Instance.GetAutoAttackRange(t)) &&
t.Health <= Damages.EDamage(t) &&
!t.Unkillable()), DamageType.Physical);
if (IsNotDangerPosition(Pos) || target != null)
{
Location = Pos;
}
else if (Config.ECorrect.CurrentValue)
{
if (GrassObject != null && Config.EGrass.CurrentValue)
{
Location = GrassObject.Position;
}
else
{
Location = CorrectToBetter(Pos);
}
}
}
}
}
break;
case 4:
{
Location = Player.Instance.ServerPosition.Extend(Game.CursorPos, Spells.E.Range).To3DWorld();
}
break;
}
}
return(Location);
}
public static List <Obj_AI_Base> GetEnemiesHitInSectorAndRectangle(this Geometry.Polygon.Sector sector, Geometry.Polygon.Rectangle rect, List <Obj_AI_Base> enemies, int delay)
{
return(enemies.Where(a => a.MeetsCriteria() && rect.IsInside(a.Position(delay))).ToList());
}
public static Vector2 GetCollisionPoint(this LinearSkillshot skillshot)
{
if (!skillshot.OwnSpellData.MinionCollision || skillshot.Missile == null)
{
return(Vector2.Zero);
}
var collisions = new List <Vector2>();
var currentSpellPos = skillshot.GetPosition().To2D();
var spellEndPos = skillshot.EndPosition;
var rect = new Geometry.Polygon.Rectangle(currentSpellPos, spellEndPos.To2D(), skillshot.OwnSpellData.Radius * 2);
if (EvadeMenu.CollisionMenu["minion"].Cast <CheckBox>().CurrentValue)
{
bool useProj = EvadeMenu.CollisionMenu["useProj"].Cast <CheckBox>().CurrentValue;
foreach (var minion in
EntityManager.MinionsAndMonsters.AlliedMinions.Where(x => !x.IsDead && x.IsValid && x.Health >= 200 &&
x.Distance(skillshot.StartPosition) < skillshot.OwnSpellData.Range))
{
if (rect.IsInside(minion) && !useProj)
{
collisions.Add(minion.Position.To2D());
}
else if (useProj)
{
var proj = minion.Position.To2D()
.ProjectOn(skillshot.StartPosition.To2D(), skillshot.EndPosition.To2D());
if (proj.IsOnSegment && proj.SegmentPoint.Distance(minion) <= skillshot.OwnSpellData.Radius)
{
collisions.Add(proj.SegmentPoint);
}
}
}
}
if (EvadeMenu.CollisionMenu["yasuoWall"].Cast <CheckBox>().CurrentValue&& skillshot.Missile != null)
{
GameObject wall = null;
foreach (var gameObject in ObjectManager.Get <GameObject>().
Where(gameObject => 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() - WindWallStartPosition).Normalized().Perpendicular();
var wallStart = wall.Position.To2D() + wallWidth / 2f * wallDirection;
var wallEnd = wallStart - wallWidth * wallDirection;
var wallPolygon = new Geometry.Polygon.Rectangle(wallStart, wallEnd, 75);
var intersections = wallPolygon.GetIntersectionPointsWithLineSegment(skillshot.GetPosition().To2D(),
skillshot.EndPosition.To2D());
if (intersections.Length > 0)
{
float wallDisappearTime = WallCastTick + 250 + 3750 - Environment.TickCount;
collisions.AddRange(intersections.Where(intersec =>
intersec.Distance(currentSpellPos) / skillshot.OwnSpellData.MissileSpeed * 1000 <
wallDisappearTime).ToList());
}
}
}
var result = collisions.Count > 0 ? collisions.
OrderBy(c => c.Distance(currentSpellPos)).ToList().First() : Vector2.Zero;
return(result);
}
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>
/// + minion hitbox
/// </summary>
public static Vector2[] GetCollisionPoints(this AsheW skillshot)
{
var collisions = new List <Vector2>();
if (Environment.TickCount - LastMinionPosArrayTick < 1000)
{
collisions.AddRange(LastMinionPosArray);
}
Vector2[] edges = skillshot.GetEdgePoints();
Vector2 rightEdge = edges[0];
Vector2 leftEdge = edges[1];
var triangle = new Geometry.Polygon();
triangle.Points.AddRange(new List <Vector2> {
skillshot.RealStartPosition.To2D(), rightEdge, leftEdge
});
if (EvadeMenu.CollisionMenu["minion"].Cast <CheckBox>().CurrentValue)
{
foreach (var minion in
EntityManager.MinionsAndMonsters.AlliedMinions.Where(x => !x.IsDead && x.IsValid && x.Health >= 100 &&
x.Distance(skillshot.RealStartPosition) < skillshot.OwnSpellData.Range))
{
if (GetHitboxCirclePoints(minion).Any(x => triangle.IsInside(x)))
{
LastMinionPosArray.Add(minion.Position.To2D());
LastMinionPosArrayTick = Environment.TickCount;
collisions.Add(minion.Position.To2D());
}
}
}
if (EvadeMenu.CollisionMenu["yasuoWall"].Cast <CheckBox>().CurrentValue&& skillshot.Missile != null)
{
GameObject wall = null;
foreach (var gameObject in ObjectManager.Get <GameObject>().
Where(gameObject => 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() - WindWallStartPosition).Normalized().Perpendicular();
var wallStart = wall.Position.To2D() + wallWidth / 2f * wallDirection;
var wallEnd = wallStart - wallWidth * wallDirection;
var wallPolygon = new Geometry.Polygon.Rectangle(wallStart, wallEnd, 75).GetDetailedPolygon();
collisions.AddRange(wallPolygon.Points.Where(wallPoint => triangle.IsInside(wallPoint)));
}
}
return(collisions.ToArray());
}
protected override async Task <bool> Killsteal()
{
if (await base.Killsteal())
{
return(true);
}
if (MyHero.IsSilenced())
{
return(false);
}
if (Target != null || MyHero.IsChanneling())
{
return(false);
}
if (_hookAbility.IsKillstealAbilityEnabled() && _hookAbility.CanBeCasted())
{
var damage = MyHero.HasItem(ClassId.CDOTA_Item_UltimateScepter)
? _hookAbility.GetAbilityData("damage_scepter")
: _hookAbility.GetDamage(_hookAbility.Level - 1);
damage *= GetSpellAmp();
var enemies =
ObjectManager.GetEntitiesParallel <Hero>()
.Where(
x =>
x.IsAlive && x.Team != MyHero.Team && _hookAbility.CanBeCasted(x) &&
_hookAbility.CanHit(x) && !x.IsIllusion &&
x.Health < damage && !x.CantBeAttacked() &&
!x.CantBeKilled());
var speed = _hookAbility.GetAbilityData("hook_speed");
var radius = _hookAbility.GetAbilityData("hook_width") * 2;
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)
{
continue;
}
var rec = new Geometry.Polygon.Rectangle(MyHero.NetworkPosition, predictedPos, radius);
// test for enemies in range
var isUnitBlocking = ObjectManager.GetEntitiesParallel <Unit>()
.Any(
x =>
x.IsValid && x != enemy && x.IsAlive && x != MyHero &&
x.IsSpawned && x.IsRealUnit() &&
x.Distance2D(enemy) >= radius &&
rec.IsInside(x.NetworkPosition));
if (!isUnitBlocking)
{
Log.Debug($"use hook for killsteal");
_hookAbility.UseAbility(predictedPos);
await Await.Delay(GetAbilityDelay(predictedPos, _hookAbility));
return(true);
}
}
}
return(false);
}
public Geometry.Polygon PredictedPolygon(float afterTime, float extraWidth = 0)
{
var extraAngle = Math.Max(1, Math.Max(1, extraWidth) / 4);
extraWidth += this.Width;
Geometry.Polygon polygon = null;
switch (this.Data.type)
{
case Type.LineMissile:
polygon = new Geometry.Polygon.Rectangle(this.CalculatedPosition(afterTime), this.CollideEndPosition, extraWidth);
break;
case Type.CircleMissile:
polygon = new Geometry.Polygon.Circle(this.Data.IsMoving ? this.CalculatedPosition(afterTime) : this.CollideEndPosition, extraWidth);
break;
case Type.Cone:
polygon = new Geometry.Polygon.Sector(this.CurrentPosition, this.CollideEndPosition, (float)((this.Angle + extraAngle) * Math.PI / 180), this.Range);
break;
case Type.Arc:
polygon = new CustomGeometry.Arc(this.Start, this.CollideEndPosition, (int)extraWidth).ToSDKPolygon();
break;
case Type.Ring:
polygon = new CustomGeometry.Ring(this.CollideEndPosition, extraWidth, this.RingRadius).ToSDKPolygon();
break;
}
if (polygon != null && (this.ExplodeEnd || this.CollideExplode))
{
var newpolygon = polygon;
var pos = this.CurrentPosition;
var collidepoint = this.CollideExplode ? this.CorrectCollidePoint.GetValueOrDefault() : this.CollideEndPosition;
switch (this.Data.Explodetype)
{
case Type.CircleMissile:
this.ExplodePolygon = new Geometry.Polygon.Circle(collidepoint, this.ExplodeWidth);
break;
case Type.LineMissile:
var st = collidepoint - (collidepoint - pos).Normalized().Perpendicular() * (this.ExplodeWidth);
var en = collidepoint + (collidepoint - pos).Normalized().Perpendicular() * (this.ExplodeWidth);
this.ExplodePolygon = new Geometry.Polygon.Rectangle(st, en, this.ExplodeWidth / 2);
break;
case Type.Cone:
var st2 = collidepoint - Direction * (this.ExplodeWidth * 0.25f);
var en2 = collidepoint + Direction * (this.ExplodeWidth * 3);
this.ExplodePolygon = new Geometry.Polygon.Sector(st2, en2, (float)(this.Angle * Math.PI / 180), this.ExplodeWidth);
break;
}
var poly = Geometry.ClipPolygons(new[] { newpolygon, this.ExplodePolygon });
var vectors = new List <IntPoint>();
foreach (var p in poly)
{
vectors.AddRange(p.ToPolygon().ToClipperPath());
}
polygon = vectors.ToPolygon();
}
return(polygon);
}
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;
}
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);
}
}
}
}
}
}
/// <summary>
/// Melee Champions Logic.
/// </summary>
public static bool MeleeLogic()
{
var AllySpawn = ObjectsManager.AllySpawn;
// if there is a TeamFight follow NearestEnemy.
var NearestEnemy = ObjectsManager.NearestEnemy;
if (Brain.TeamFightActive && Player.Instance.PredictHealthPercent() > 20 && !(ModesManager.CurrentMode == ModesManager.Modes.None || ModesManager.CurrentMode == ModesManager.Modes.Flee) &&
NearestEnemy != null && NearestEnemy.TeamTotal() >= NearestEnemy.TeamTotal(true) &&
NearestEnemy.CountAllyHeros(SafeValue) > 1)
{
// if there is a TeamFight move from NearestEnemy to nearestally.
if (ObjectsManager.SafestAllyToFollow != null)
{
var pos = NearestEnemy.KitePos(ObjectsManager.SafestAllyToFollow);
if (Player.Instance.SafePath(pos))
{
Program.Moveto = "NearestEnemyToNearestAlly";
Position = pos;
return(true);
}
}
// if there is a TeamFight move from NearestEnemy to AllySpawn.
if (AllySpawn != null)
{
var pos = NearestEnemy.KitePos(AllySpawn);
if (Player.Instance.SafePath(pos))
{
Program.Moveto = "NearestEnemyToAllySpawn";
Position = pos;
return(true);
}
}
}
// Tower Defence
var FarthestAllyTurret = ObjectsManager.FarthestAllyTurret;
if (Player.Instance.IsUnderHisturret() && FarthestAllyTurret != null && Player.Instance.PredictHealthPercent() >= 20 &&
!(ModesManager.CurrentMode == ModesManager.Modes.None || ModesManager.CurrentMode == ModesManager.Modes.Flee))
{
if (FarthestAllyTurret.CountEnemyHeros((int)FarthestAllyTurret.GetAutoAttackRange(Player.Instance) + 50) > 0)
{
var enemy = EntityManager.Heroes.Enemies.OrderBy(o => o.Distance(AllySpawn)).FirstOrDefault(e => e.IsKillable(3000) &&
e.TeamTotal() >= e.TeamTotal(true) && (e.CountAllyHeros(SafeValue) > 1 || e.CountEnemyHeros(SafeValue) < 2) && e.UnderEnemyTurret());
if (enemy != null && enemy.UnderEnemyTurret())
{
Program.Moveto = "EnemyUnderTurret";
Position = enemy.KitePos(AllySpawn);
return(true);
}
}
}
var NearestEnemyObject = ObjectsManager.NearestEnemyObject;
// if Can AttackObject then start attacking THE DAMN OBJECT FFS.
if (NearestEnemyObject != null && Player.Instance.PredictHealthPercent() > 20 && ModesManager.AttackObject &&
(NearestEnemyObject.Position.TeamTotal() > NearestEnemyObject.Position.TeamTotal(true) ||
NearestEnemyObject.CountEnemyHeros(SafeValue + 100) == 0))
{
var extendto = new Vector3();
if (AllySpawn != null)
{
extendto = AllySpawn.Position;
}
if (ObjectsManager.NearestMinion != null)
{
extendto = ObjectsManager.NearestMinion.Position;
}
if (ObjectsManager.NearestAlly != null)
{
extendto = ObjectsManager.NearestAlly.Position;
}
var extendtopos = NearestEnemyObject.KitePos(extendto);
var rect = new Geometry.Polygon.Rectangle(Player.Instance.ServerPosition, NearestEnemyObject.Position, 400);
var Enemy = EntityManager.Heroes.Enemies.Any(a => a != null && a.IsValid && a.TeamTotal(true) > a.TeamTotal() && !a.IsDead && new Geometry.Polygon.Circle(a.PredictPosition(), a.GetAutoAttackRange(Player.Instance)).Points.Any(p => rect.IsInside(p)));
if (!Enemy)
{
if (ObjectsManager.EnemyTurret != null)
{
var TurretCircle = new Geometry.Polygon.Circle(ObjectsManager.EnemyTurret.ServerPosition, ObjectsManager.EnemyTurret.GetAutoAttackRange(Player.Instance));
if (NearestEnemyObject.IsTurret())
{
if (SafeToDive)
{
Program.Moveto = "NearestEnemyObject";
Position = extendtopos;
return(true);
}
}
if (!TurretCircle.Points.Any(p => rect.IsInside(p)))
{
Program.Moveto = "NearestEnemyObject2";
Position = extendtopos;
return(true);
}
}
else
{
Program.Moveto = "NearestEnemyObject3";
Position = extendtopos;
return(true);
}
}
}
// if NearestEnemyMinion exsists moves to NearestEnemyMinion.
if (ObjectsManager.NearestEnemyMinion != null && AllySpawn != null && ModesManager.LaneClear && Player.Instance.PredictHealthPercent() > 25)
{
Program.Moveto = "NearestEnemyMinion";
Position = ObjectsManager.NearestEnemyMinion.PredictPosition().Extend(AllySpawn.Position.Random(), KiteDistance(ObjectsManager.NearestEnemyMinion)).To3D();
return(true);
}
// if SafestAllyToFollow not exsist picks other to follow.
if (ObjectsManager.SafestAllyToFollow != null)
{
// if SafestAllyToFollow exsist follow BestAllyToFollow.
Program.Moveto = "SafestAllyToFollow";
Position = ObjectsManager.SafestAllyToFollow.PredictPosition().Random();
return(true);
}
// if Minion exsists moves to Minion.
if (ObjectsManager.AllyMinion != null)
{
Program.Moveto = "AllyMinion";
Position = ObjectsManager.AllyMinion.PredictPosition().Random();
return(true);
}
// if FarthestAllyToFollow exsists moves to FarthestAllyToFollow.
if (ObjectsManager.FarthestAllyToFollow != null)
{
Program.Moveto = "FarthestAllyToFollow";
Position = ObjectsManager.FarthestAllyToFollow.PredictPosition().Random();
return(true);
}
// if SecondTurret exsists moves to SecondTurret.
if (ObjectsManager.SecondTurret != null)
{
Program.Moveto = "SecondTurret";
Position = ObjectsManager.SecondTurret.PredictPosition().Extend(AllySpawn, 400).To3D().Random();
return(true);
}
// if SafeAllyTurret exsists moves to SafeAllyTurret.
if (ObjectsManager.SafeAllyTurret != null)
{
Program.Moveto = "SafeAllyTurret";
Position = ObjectsManager.SafeAllyTurret.ServerPosition.Extend(AllySpawn, 400).To3D().Random();
return(true);
}
// if ClosesetAllyTurret exsists moves to ClosesetAllyTurret.
if (ObjectsManager.ClosesetAllyTurret != null)
{
Program.Moveto = "ClosesetAllyTurret";
Position = ObjectsManager.ClosesetAllyTurret.ServerPosition.Extend(AllySpawn, 400).To3D().Random();
return(true);
}
// Well if it ends up like this then best thing is to let it end.
if (AllySpawn != null)
{
Program.Moveto = "AllySpawn3";
Position = AllySpawn.Position.Random();
return(true);
}
return(false);
}
private static void GameOnOnGameLoad(EventArgs args)
{
if (Player.ChampionName != "Fizz")
{
return;
}
CreateMenu();
RRectangle = new Geometry.Polygon.Rectangle(Player.Position, Player.Position, R.Width);
Game.OnUpdate += GameOnOnUpdate;
Obj_AI_Base.OnProcessSpellCast += ObjAiBaseOnOnProcessSpellCast;
Drawing.OnDraw += DrawingOnOnDraw;
Chat.Print("<font color=\"#7CFC00\"><b>Fizz-Farofakids(original script made by:ChewyMoon)</b></font> Loaded");
}
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);
}
}
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;
}
}
}
}
}
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(ClassId.CDOTA_Item_UltimateScepter)
? "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();
}
}
public static void Combo()
{
#region R combos
var unit =
HeroManager.Enemies.Where(
x => x.Distance(Player) < 500 && !x.IsDead && x.IsValidTarget(500) && x.Health < R.GetDamage(x) + 50)
.OrderBy(x => x.Distance(Player))
.FirstOrDefault();
if (unit != null)
{
foreach (var targets in
HeroManager.Enemies.Where(
x =>
!x.IsDead && x.IsValidTarget() && x.IsVisible && x.Distance(unit) < 1000 &&
x.Distance(unit) > 300 && x.NetworkId != unit.NetworkId && x.Health < R.GetDamage(x)))
{
var prediction = Prediction.GetPrediction(targets, 0.1f);
var pos = prediction.UnitPosition.Extend(unit.ServerPosition,
prediction.UnitPosition.Distance(unit.ServerPosition) + 250);
RCombo = pos;
var slot = WardSorter.Wards();
if (unit.Distance(Player) > 500)
{
RCombo = null;
}
if (W.IsReady() && R.IsReady() && Player.ServerPosition.Distance(unit.ServerPosition) < 500 &&
slot != null)
{
WardJump.WardJumped(pos, false, true);
}
}
if (Player.IsDead)
{
UltPoly = null;
UltPolyExpectedPos = null;
return;
}
UltPoly = new Geometry.Polygon.Rectangle(Player.ServerPosition,
Player.ServerPosition.Extend(unit.Position, 1100), unit.BoundingRadius + 30);
var counts =
HeroManager.Enemies.Where(
x => x.Distance(Player) < 1100 && x.IsValidTarget(1100) && x.Health < R.GetDamage(x))
.Count(h => h.NetworkId != unit.NetworkId && UltPoly.IsInside(h.ServerPosition));
if (counts >= 1 && R.IsReady() && Created && R.IsReady())
{
R.Cast(unit);
}
}
#endregion
#region Regular combo
var target = TargetSelector.GetTarget(Q.Range, TargetSelector.DamageType.Physical);
if (!target.IsValidTarget())
{
return;
}
var useq = GetBool("useq", typeof(bool));
var usee = GetBool("usee", typeof(bool));
var user = GetBool("user", typeof(bool));
var usew = GetBool("wardjumpcombo", typeof(bool));
var smite = GetBool("usessmite", typeof(bool));
if (GetStringValue("hydrati") == 0 || GetStringValue("hydrati") == 2)
{
if (target.IsValidTarget(400) && (ItemReady(Tiamat) || ItemReady(Hydra)) &&
(HasItem(Tiamat) || HasItem(Hydra)))
{
SelfCast(HasItem(Hydra) ? Hydra : Tiamat);
}
}
if (GetBool("youm", typeof(bool)) && HasItem(Youm) && ItemReady(Youm) &&
target.Distance(Player) < Q.Range - 300)
{
SelfCast(Youm);
}
if (GetBool("omen", typeof(bool)) && HasItem(Omen) && ItemReady(Omen) &&
Player.CountAlliesInRange(400) >= GetValue("minrand"))
{
SelfCast(Omen);
}
if (usew)
{
if (Environment.TickCount - Lastqc > 300 && Environment.TickCount - Laste > 300 &&
Environment.TickCount - Lastwcombo > 300)
{
if (W.IsReady() && target.Distance(Player) <= Player.AttackRange && W1())
{
W.Cast(Player);
Lastwcombo = Environment.TickCount;
}
if (W.IsReady() && target.Distance(Player) <= Player.AttackRange && W2() && !HasPassive())
{
W.Cast();
}
}
}
if (useq)
{
if (Environment.TickCount - Lastqc > 300 && Environment.TickCount - Laste > 300 &&
Environment.TickCount - Lastwcombo > 300)
{
var qpred = Q.GetPrediction(target);
if (Q.IsReady() && Q1())
{
OnUpdate.CastSpell(Q, target);
Lastqc = Environment.TickCount;
}
if (Q2() && Q.IsReady() && GetBool("useq2", typeof(bool)))
{
LeagueSharp.Common.Utility.DelayAction.Add(GetValue("secondqdelay"), () => Q.Cast());
Lastqc = Environment.TickCount;
}
}
}
if (usee)
{
if (target.Distance(Player) <= E.Range && E1())
{
E.Cast();
Laste = Environment.TickCount;
}
if ((Player.Distance(target) >
Player.AttackRange + Player.BoundingRadius + target.BoundingRadius + 100 ||
Environment.TickCount - Laste > 2300) && E2())
{
E.Cast();
Laste = Environment.TickCount;
}
}
if (user && target.IsValidTarget(R.Range) && R.IsReady())
{
if (Q.GetDamage(target) + 70 < target.Health)
{
// Chat.Print("firstcheck");
if (target.Health > Player.GetAutoAttackDamage(target) + 30)
{
// Chat.Print("secondCheck");
if (Q.IsReady() &&
target.Health <=
R.GetDamage(target) + GetQDamage(target) + Player.GetAutoAttackDamage(target) &&
Q.IsReady() && target.Health > GetQDamage(target))
{
R.Cast(target);
}
if (target.Health <= R.GetDamage(target) + Q.GetDamage(target) && Q.IsReady() &&
Player.Mana > 30)
{
R.Cast(target);
}
}
}
}
if (Smite.IsReady() && target.Distance(Player) < 500 && smite && target.Health < ActiveModes.Smite.GetFuckingSmiteDamage())
{
Player.Spellbook.CastSpell(Smite, target);
}
var poss = Player.ServerPosition.Extend(target.ServerPosition, 600);
if (!GetBool("wardjumpcombo1", typeof(bool)))
{
return;
}
if (!E.IsReady() || !W.IsReady() || !(target.Distance(Player) > E.Range) || !LastQ(target))
{
return;
}
if (!Q.IsReady() && Environment.TickCount - Q.LastCastAttemptT > 1000)
{
WardManager.WardJump.WardJumped(poss, true, true);
}
#endregion
}
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);
}
}
/// <summary>
/// returns the distance to the closest edge point of the multi kick rectangle
/// </summary>
/// <returns></returns>
float GetEdgeValue(Geometry.Polygon.Rectangle multiKickRect, Vector2 position)
{
return(multiKickRect.GetDetailedPolygon().Points.OrderBy(x => x.Distance(position)).First().Distance(position));
}
private static bool GoThroughWall(Vector2 pos1, Vector2 pos2)
{
if (Wall == null)
{
return false;
}
var wallWidth = 300 + 50 * Convert.ToInt32(Wall.Name.Substring(Wall.Name.Length - 6, 1));
var wallDirection = (Wall.Position.To2D() - wallCastedPos).Normalized().Perpendicular();
var wallStart = Wall.Position.To2D() + wallWidth / 2f * wallDirection;
var wallEnd = wallStart - wallWidth * wallDirection;
var wallPolygon = new Geometry.Polygon.Rectangle(wallStart, wallEnd, 75);
var intersections = new List<Vector2>();
for (var i = 0; i < wallPolygon.Points.Count; i++)
{
var inter =
wallPolygon.Points[i].Intersection(
wallPolygon.Points[i != wallPolygon.Points.Count - 1 ? i + 1 : 0],
pos1,
pos2);
if (inter.Intersects)
{
intersections.Add(inter.Point);
}
}
return intersections.Any();
}
public static Vector2 GetCollisionPoint(this Skillshot skillshot)
{
var collisions = new List <DetectedCollision>();
var from = skillshot.GetMissilePosition(0);
skillshot.ForceDisabled = false;
foreach (var cObject in skillshot.SpellData.CollisionObjects)
{
switch (cObject)
{
case CollisionObjectTypes.Minion:
collisions.AddRange(
from minion in
EntityManager.MinionsAndMonsters.GetLaneMinions(skillshot.Unit.Team == ObjectManager.Player.Team ? EntityManager.UnitTeam.Enemy : EntityManager.UnitTeam.Ally,
@from.To3D(),
1200)
let pred =
FastPrediction(
@from,
minion,
Math.Max(
0,
skillshot.SpellData.Delay - (Utils.GameTimeTickCount - skillshot.StartTick)),
skillshot.SpellData.MissileSpeed)
let pos = pred.PredictedPos
let w =
skillshot.SpellData.RawRadius + (!pred.IsMoving ? minion.BoundingRadius - 15 : 0)
- pos.Distance(@from, skillshot.End, true)
where w > 0
select
new DetectedCollision
{
Position =
pos.ProjectOn(skillshot.End, skillshot.Start).LinePoint
+ skillshot.Direction * 30,
Unit = minion,
Type = CollisionObjectTypes.Minion,
Distance = pos.Distance(@from),
Diff = w
});
break;
case CollisionObjectTypes.Champion:
collisions.AddRange(
from hero in EntityManager.Heroes.Allies.Where(i => i.IsValidTarget(1200, false) && !i.IsMe)
let pred =
FastPrediction(
@from,
hero,
Math.Max(
0,
skillshot.SpellData.Delay - (Utils.GameTimeTickCount - skillshot.StartTick)),
skillshot.SpellData.MissileSpeed)
let pos = pred.PredictedPos
let w = skillshot.SpellData.RawRadius + 30 - pos.Distance(@from, skillshot.End, true)
where w > 0
select
new DetectedCollision
{
Position =
pos.ProjectOn(skillshot.End, skillshot.Start).LinePoint
+ skillshot.Direction * 30,
Unit = hero,
Type = CollisionObjectTypes.Minion,
Distance = pos.Distance(@from),
Diff = w
});
break;
case CollisionObjectTypes.YasuoWall:
if (
!EntityManager.Heroes.Allies.Any(
i => i.IsValidTarget(float.MaxValue, false) && i.ChampionName == "Yasuo"))
{
break;
}
var wall =
ObjectManager.Get <GameObject>()
.FirstOrDefault(
i =>
i.IsValid && Regex.IsMatch(i.Name, "_w_windwall.\\.troy", RegexOptions.IgnoreCase));
if (wall == null)
{
break;
}
var wallWidth = 300 + 50 * Convert.ToInt32(wall.Name.Substring(wall.Name.Length - 6, 1));
var wallDirection = (wall.Position.To2D() - wallCastedPos).Normalized().Perpendicular();
var wallStart = wall.Position.To2D() + wallWidth / 2f * wallDirection;
var wallEnd = wallStart - wallWidth * wallDirection;
var wallPolygon = new Geometry.Polygon.Rectangle(wallStart, wallEnd, 75);
var intersections = new List <Vector2>();
for (var i = 0; i < wallPolygon.Points.Count; i++)
{
var inter =
wallPolygon.Points[i].Intersection(
wallPolygon.Points[i != wallPolygon.Points.Count - 1 ? i + 1 : 0],
from,
skillshot.End);
if (inter.Intersects)
{
intersections.Add(inter.Point);
}
}
if (intersections.Count > 0)
{
var intersection = intersections.OrderBy(i => i.Distance(@from)).ToList()[0];
var collisionT = Utils.GameTimeTickCount
+ Math.Max(
0,
skillshot.SpellData.Delay
- (Utils.GameTimeTickCount - skillshot.StartTick)) + 100
+ (1000 * intersection.Distance(from)) / skillshot.SpellData.MissileSpeed;
if (collisionT - wallCastT < 4000)
{
if (skillshot.SpellData.Type != SkillShotType.SkillshotMissileLine)
{
skillshot.ForceDisabled = true;
}
return(intersection);
}
}
break;
}
}
return(collisions.Count > 0 ? collisions.OrderBy(i => i.Distance).ToList()[0].Position : new Vector2());
}
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 OnGameUpdate(EventArgs args)
{
try
{
if (Player.IsDead)
{
return;
}
var QTarget = TargetSelector.GetTarget(_Q.Range, TargetSelector.DamageType.Magical);
var WTarget = TargetSelector.GetTarget(_W.Range, TargetSelector.DamageType.Magical);
var RTarget = TargetSelector.GetTarget(_R.Range, TargetSelector.DamageType.Magical);
// Flee
if (_MainMenu.Item("Nami_Flee").GetValue <KeyBind>().Active)
{
MovingPlayer(Game.CursorPos);
if (_E.IsReady())
{
_E.CastOnUnit(Player, true);
}
if (_Q.IsReady() && QTarget != null && _Q.GetPrediction(QTarget).Hitchance >= HitChance.Low)
{
_Q.CastIfHitchanceEquals(QTarget, _Q.GetPrediction(QTarget).Hitchance, true);
}
}
// Auto W Heal
if (_MainMenu.Item("Nami_HealWMinEnable").GetValue <bool>())
{
var Ally = HeroManager.Allies.FirstOrDefault(f => f.Position.Distance(Player.Position) <= _W.Range && !f.IsDead &&
f.HealthPercent <= _MainMenu.Item("Nami_HealWMin").GetValue <Slider>().Value &&
!f.InFountain(Utility.FountainType.OwnFountain));
if (Ally != null && !Ally.IsRecalling())
{
_W.CastOnUnit(Ally, true);
}
}
//KillSteal
if (_MainMenu.Item("Nami_KUse_W").GetValue <bool>())
{
if (_W.IsReady() && WTarget != null)
{
if (WTarget.Health < _W.GetDamage(WTarget))
{
_W.CastOnUnit(WTarget, true);
}
}
}
if (_MainMenu.Item("Nami_KUse_Q").GetValue <bool>())
{
if (_Q.IsReady() && QTarget != null)
{
if (QTarget.Health < _Q.GetDamage(QTarget))
{
if (_Q.GetPrediction(QTarget).Hitchance >= HitChance.Medium)
{
_Q.CastIfHitchanceEquals(QTarget, HitChance.Medium, true);
}
}
}
}
//Auto R
if (_MainMenu.Item("Nami_CUse_MinR1").GetValue <bool>() && _R.IsReady())
{
var Enemy = HeroManager.Enemies.OrderBy(f => f.Distance(Player.Position));
if (Enemy != null)
{
foreach (var item in Enemy)
{
if (item.Position.Distance(Player.Position) < _R.Range && !item.IsDead)
{
var RRange = new Geometry.Polygon.Rectangle(Player.Position, Player.Position.Extend(item.Position, +1200), 250);
var Count = HeroManager.Enemies.Where(f => f.Distance(Player.Position) <= 1500).Count(f => RRange.IsInside(f.Position));
if (Count >= _MainMenu.Item("Nami_CUse_MinR").GetValue <Slider>().Value)
{
_R.Cast(item.Position, true);
return;
}
}
}
}
}
// Combo
if (_MainMenu.Item("CKey").GetValue <KeyBind>().Active)
{
if (_MainMenu.Item("Nami_CUse_Q").GetValue <bool>())
{
if (QTarget != null)
{
if (_Q.IsReady())
{
if (_Q.GetPrediction(QTarget).Hitchance >= HitChance.Medium)
{
_Q.CastIfHitchanceEquals(QTarget, _Q.GetPrediction(QTarget).Hitchance, true);
return;
}
}
}
}
if (_MainMenu.Item("Nami_CUse_W").GetValue <bool>() && _W.IsReady())
{
// W to Ally
foreach (var item in HeroManager.Allies.OrderByDescending(f => f.Health))
{
if (item.Position.Distance(Player.Position) <= _W.Range)
{
if ((HeroManager.Enemies.FirstOrDefault(f => f.Position.Distance(item.Position) <= _W.Range - 50) != null))
{
_W.CastOnUnit(item, true);
return;
}
}
}
if (WTarget != null && WTarget.Position.Distance(Player.Position) <= _W.Range)
{
_W.CastOnUnit(WTarget, true);
}
}
if (_MainMenu.Item("Nami_CUse_R").GetValue <bool>() && _R.IsReady() && RTarget != null)
{
if (RTarget.Distance(Player.Position) <= 1300)
{
if (_R.GetPrediction(RTarget).Hitchance >= HitChance.Medium)
{
_R.CastIfHitchanceEquals(RTarget, _R.GetPrediction(RTarget).Hitchance);
}
}
}
}
// Harass
if ((_MainMenu.Item("HKey").GetValue <KeyBind>().Active || _MainMenu.Item("Nami_Auto_HEnable").GetValue <bool>()) &&
_MainMenu.Item("Nami_HMana").GetValue <Slider>().Value < Player.ManaPercent)
{
if (_MainMenu.Item("Nami_HUse_Q").GetValue <bool>())
{
if (QTarget != null)
{
if (_Q.IsReady())
{
if (_Q.GetPrediction(QTarget).Hitchance >= HitChance.Medium)
{
_Q.CastIfHitchanceEquals(QTarget, _Q.GetPrediction(QTarget).Hitchance, true);
return;
}
}
}
}
if (_MainMenu.Item("Nami_HUse_W").GetValue <bool>() && _W.IsReady())
{
// W to Ally
foreach (var item in HeroManager.Allies.OrderByDescending(f => f.Health))
{
if (item.Position.Distance(Player.Position) <= _W.Range && !item.IsDead)
{
if ((HeroManager.Enemies.FirstOrDefault(f => f.Position.Distance(item.Position) <= _W.Range - 50 && !f.IsDead) != null) && !item.Name.ToLower().Contains("name"))
{
_W.CastOnUnit(item, true);
return;
}
}
}
if (WTarget != null && WTarget.Position.Distance(Player.Position) <= _W.Range && WTarget.IsChampion())
{
_W.CastOnUnit(WTarget, true);
}
}
}
}
catch (Exception)
{
if (NowTime() > ErrorTime)
{
Game.PrintChat(ChampName + " in FreshBooster isn't Load. Error Code 06");
ErrorTime = TickCount(10000);
}
}
}
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;
}
public static void CastBestLine(bool forceUlt, Spell spell, Spell spell2, int midPointRange, Menu menu, float extraPrerange = 1, bool wallCheck = true)
{
if (!spell.IsReady())
{
return;
}
int maxHit = 0;
Vector3 start = Vector3.Zero;
Vector3 end = Vector3.Zero;
//loop one
foreach (var target in ObjectManager.Get <Obj_AI_Hero>().Where(x => x.IsValidTarget(spell.Range)))
{
//loop 2
var target1 = target;
var target2 = target;
foreach (var enemy in ObjectManager.Get <Obj_AI_Hero>().Where(x => x.IsValidTarget(spell.Range + spell2.Range) && x.NetworkId != target1.NetworkId &&
x.Distance(target1.Position) < spell2.Range - 100).OrderByDescending(x => x.Distance(target2.Position)))
{
int hit = 2;
var targetPred = Prediction.GetPrediction(target, spell.Delay);
var enemyPred = Prediction.GetPrediction(enemy, spell.Delay);
var midpoint = (enemyPred.CastPosition + targetPred.CastPosition) / 2;
var startpos = midpoint + Vector3.Normalize(enemyPred.CastPosition - targetPred.CastPosition) * midPointRange;
var endPos = midpoint - Vector3.Normalize(enemyPred.CastPosition - targetPred.CastPosition) * midPointRange;
Geometry.Polygon.Rectangle rec1 = new Geometry.Polygon.Rectangle(startpos, endPos, spell.Width);
if (!rec1.Points.Exists(Util.IsWall) && Player.CountEnemiesInRange(spell.Range + spell2.Range) > 2)
{
//loop 3
var target3 = target;
var enemy1 = enemy;
foreach (var enemy2 in ObjectManager.Get <Obj_AI_Hero>().Where(x => x.IsValidTarget(spell.Range + spell2.Range) && x.NetworkId != target3.NetworkId && x.NetworkId != enemy1.NetworkId && x.Distance(target3.Position) < 1000))
{
var enemy2Pred = Prediction.GetPrediction(enemy2, spell.Delay);
Object[] obj = Util.VectorPointProjectionOnLineSegment(startpos.To2D(), endPos.To2D(), enemy2Pred.CastPosition.To2D());
var isOnseg = (bool)obj[2];
var pointLine = (Vector2)obj[1];
if (pointLine.Distance(enemy2Pred.CastPosition.To2D()) < spell.Width && isOnseg)
{
hit++;
}
}
}
if (hit > maxHit && hit > 1 && !rec1.Points.Exists(Util.IsWall))
{
maxHit = hit;
start = startpos;
end = endPos;
}
}
}
if (start != Vector3.Zero && end != Vector3.Zero && spell.IsReady())
{
spell2.UpdateSourcePosition(start, start);
if (forceUlt)
{
CastLineSpell(start, end);
}
if (menu.Item("ComboActive", true).GetValue <KeyBind>().Active&& maxHit >= menu.Item("Line_If_Enemy_Count_Combo", true).GetValue <Slider>().Value)
{
CastLineSpell(start, end);
}
if (maxHit >= menu.Item("Line_If_Enemy_Count", true).GetValue <Slider>().Value)
{
CastLineSpell(start, end);
}
}
//check if only one target
if (forceUlt)
{
CastSingleLine(spell, spell2, wallCheck, extraPrerange);
}
}
private static void Game_OnUpdate(EventArgs args)
{
if (myHero.IsDead) return;
if (start.IsValid() && end.IsValid())
{
rectangle = new Geometry.Polygon.Rectangle(start, end, Lib.Q.Width);
rectangle.Draw(Color.Red, 2);
}
else
rectangle = null;
if (Config.StunTarget)
Modes.Stun.Execute();
if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo))
Modes.Combo.Execute();
if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.LaneClear))
Modes.Laneclear.Execute();
if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Flee))
Modes.Flee.Execute();
if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Harass))
Modes.Harass.Execute();
if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.JungleClear))
Modes.Jungleclear.Execute();
Modes.Misc.Execute();
}
public static void DrawBestLine(Spell spell, Spell spell2, int midPointRange, float extraPrerange = 1, bool wallCheck = true)
{
//---------------------------------MEC----------------------------
int maxHit = 0;
Vector3 start = Vector3.Zero;
Vector3 end = Vector3.Zero;
//loop one
foreach (var target in ObjectManager.Get <Obj_AI_Hero>().Where(x => x.IsValidTarget(spell.Range)))
{
//loop 2
var target1 = target;
var target2 = target;
foreach (var enemy in ObjectManager.Get <Obj_AI_Hero>().Where(x => x.IsValidTarget(spell.Range + spell2.Range) && x.NetworkId != target1.NetworkId &&
x.Distance(target1.Position) < spell2.Range - 100).OrderByDescending(x => x.Distance(target2.Position)))
{
int hit = 2;
var targetPred = Prediction.GetPrediction(target, spell.Delay);
var enemyPred = Prediction.GetPrediction(enemy, spell.Delay);
var midpoint = (enemyPred.CastPosition + targetPred.CastPosition) / 2;
var startpos = midpoint + Vector3.Normalize(enemyPred.CastPosition - targetPred.CastPosition) * midPointRange;
var endPos = midpoint - Vector3.Normalize(enemyPred.CastPosition - targetPred.CastPosition) * midPointRange;
Geometry.Polygon.Rectangle rec1 = new Geometry.Polygon.Rectangle(startpos, endPos, spell.Width);
if (!rec1.Points.Exists(Util.IsWall) && Player.CountEnemiesInRange(spell.Range + spell2.Range) > 2)
{
//loop 3
var target3 = target;
var enemy1 = enemy;
foreach (var enemy2 in ObjectManager.Get <Obj_AI_Hero>().Where(x => x.IsValidTarget(spell.Range + spell2.Range) && x.NetworkId != target3.NetworkId && x.NetworkId != enemy1.NetworkId && x.Distance(target3.Position) < spell2.Range))
{
var enemy2Pred = Prediction.GetPrediction(enemy2, spell.Delay);
Object[] obj = Util.VectorPointProjectionOnLineSegment(startpos.To2D(), endPos.To2D(), enemy2Pred.CastPosition.To2D());
var isOnseg = (bool)obj[2];
var pointLine = (Vector2)obj[1];
if (pointLine.Distance(enemy2Pred.CastPosition.To2D()) < spell.Width && isOnseg)
{
hit++;
}
}
}
if (hit > maxHit && hit > 1 && !rec1.Points.Exists(Util.IsWall))
{
maxHit = hit;
start = startpos;
end = endPos;
}
}
}
if (maxHit >= 2)
{
Vector2 wts = Drawing.WorldToScreen(Player.Position);
Drawing.DrawText(wts[0], wts[1], Color.Wheat, "Hit: " + maxHit);
Geometry.Polygon.Rectangle rec1 = new Geometry.Polygon.Rectangle(start, end, spell.Width);
rec1.Draw(Color.Blue, 4);
}
else
{
//-------------------------------Single---------------------------
var target = TargetSelector.GetTarget(spell.Range + spell2.Range, TargetSelector.DamageType.Magical);
if (target == null)
{
return;
}
var vector1 = Player.ServerPosition + Vector3.Normalize(target.ServerPosition - Player.ServerPosition) * (spell.Range * extraPrerange);
var pred = Prediction.GetPrediction(target, spell.Delay);
Geometry.Polygon.Rectangle rec1 = new Geometry.Polygon.Rectangle(vector1, vector1.Extend(pred.CastPosition, spell2.Range), spell.Width);
if (Player.Distance(target) < spell.Range)
{
vector1 = pred.CastPosition.Extend(target.ServerPosition, spell2.Range * .3f);
Geometry.Polygon.Rectangle rec2 = new Geometry.Polygon.Rectangle(vector1, vector1.Extend(pred.CastPosition, spell2.Range), spell.Width);
if ((!rec2.Points.Exists(Util.IsWall) || !wallCheck) && pred.Hitchance >= HitChance.Medium && target.IsMoving)
{
Vector2 wts = Drawing.WorldToScreen(Player.Position);
Drawing.DrawText(wts[0], wts[1], Color.Wheat, "Hit: " + 1);
rec2.Draw(Color.Blue, 4);
}
}
else if (!rec1.Points.Exists(Util.IsWall) || !wallCheck)
{
//wall check
if (pred.Hitchance >= HitChance.High)
{
Vector2 wts = Drawing.WorldToScreen(Player.Position);
Drawing.DrawText(wts[0], wts[1], Color.Wheat, "Hit: " + 1);
rec1.Draw(Color.Blue, 4);
}
}
}
}
private static void AIHeroClient_OnProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
if ((args.Slot == SpellSlot.Q || args.Slot == SpellSlot.W || args.Slot == SpellSlot.E ||
args.Slot == SpellSlot.R) && sender.IsEnemy && _e.IsReady())
{
if (args.SData.TargettingType == SpellDataTargetType.Unit ||
args.SData.TargettingType == SpellDataTargetType.SelfAndUnit ||
args.SData.TargettingType == SpellDataTargetType.Self)
{
if ((args.Target.NetworkId == Player.Instance.NetworkId && args.Time < 1.5 ||
args.End.Distance(Player.Instance.ServerPosition) <= Player.Instance.BoundingRadius*3) &&
MainMenu.Misc[args.SData.Name].Cast<CheckBox>().CurrentValue)
{
_e.Cast();
}
}
else if (args.SData.TargettingType == SpellDataTargetType.LocationAoe)
{
var castvector =
new Geometry.Polygon.Circle(args.End, args.SData.CastRadius).IsInside(
Player.Instance.ServerPosition);
if (castvector && MainMenu.Misc[args.SData.Name].Cast<CheckBox>().CurrentValue)
{
_e.Cast();
}
}
else if (args.SData.TargettingType == SpellDataTargetType.Cone)
{
var castvector =
new Geometry.Polygon.Arc(args.Start, args.End, args.SData.CastConeAngle, args.SData.CastRange)
.IsInside(Player.Instance.ServerPosition);
if (castvector && MainMenu.Misc[args.SData.Name].Cast<CheckBox>().CurrentValue)
{
_e.Cast();
}
}
else if (args.SData.TargettingType == SpellDataTargetType.SelfAoe)
{
var castvector =
new Geometry.Polygon.Circle(sender.ServerPosition, args.SData.CastRadius).IsInside(
Player.Instance.ServerPosition);
if (castvector && MainMenu.Misc[args.SData.Name].Cast<CheckBox>().CurrentValue)
{
_e.Cast();
}
}
else
{
var castvector =
new Geometry.Polygon.Rectangle(args.Start, args.End, args.SData.LineWidth).IsInside(
Player.Instance.ServerPosition);
if (castvector && MainMenu.Misc[args.SData.Name].Cast<CheckBox>().CurrentValue)
{
_e.Cast();
}
}
}
}
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));
}
private static void Harass()
{
if (Player.ManaPercent < Getslidervalue(HarassMenu, "HMinMana")) return;
if (Q.IsReady() && Getcheckboxvalue(HarassMenu, "HEXQ"))
{
var target = TargetSelector.GetTarget(Q1.Range, DamageType.Physical);
var Minions = EntityManager.MinionsAndMonsters.GetLaneMinions(EntityManager.UnitTeam.Enemy,
Player.Position, Q.Range);
if (target == null || !target.IsValidTarget(Q1.Range) || Minions == null) return;
foreach (var Minion in Minions)
{
var QHit = new Geometry.Polygon.Rectangle(Player.Position, Player.Position.Extend(Minion.Position, Q1.Range),Q1.Width);
var QPred = Q1.GetPrediction(target);
if (!QHit.IsOutside(QPred.UnitPosition.To2D()) && QPred.HitChance == HitChance.AveragePoint)
{
Q.Cast(Minion);
break;
}
}
}
}
private static void OnTick(EventArgs args)
{
if (doubleClickReset <= Environment.TickCount && clickCount != 0)
{
doubleClickReset = float.MaxValue;
clickCount = 0;
}
if (passiveTimer <= Environment.TickCount)
{
PassiveStacks = 0;
}
if (myHero.IsDead || MenuGUI.IsChatOpen || myHero.IsRecalling())
{
return;
}
if (TargetSelector.GetTarget(Q.Range, DamageType.Physical) == null)
{
insecComboStep = InsecComboStepSelect.None;
}
if (starCombo)
{
WardCombo();
}
if (ElLeeSinIgniteKS)
{
var newTarget = TargetSelector.GetTarget(600, DamageType.True);
if (newTarget != null && ignite != null && ignite.IsReady() && ObjectManager.Player.GetSummonerSpellDamage(newTarget, DamageLibrary.SummonerSpells.Ignite) > newTarget.Health)
{
ignite.Cast(newTarget);
}
}
if (InsecEnabled)
{
if (insecOrbwalk)
{
Orbwalk(Game.CursorPos);
}
var newTarget = TargetSelector.GetTarget(Q.Range, DamageType.Physical);
if (newTarget != null && R.IsReady())
{
InsecCombo(newTarget);
}
}
else
{
isNullInsecPos = true;
}
if (!Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo))
{
insecComboStep = InsecComboStepSelect.None;
}
if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Combo))
{
Combo();
}
else if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.LaneClear) || Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.JungleClear))
{
AllClear();
JungleClear();
}
else if (Orbwalker.ActiveModesFlags.HasFlag(Orbwalker.ActiveModes.Harass))
{
Harass();
}
if (ElLeeSinWardjump)
{
Orbwalk(Game.CursorPos);
WardjumpToMouse();
}
if (ElLeeSinInsecUseInstaFlash)
{
Orbwalk(Game.CursorPos);
var target = TargetSelector.GetTarget(flashSlot.Range - 25, DamageType.Physical);
if (target == null)
{
return;
}
if (!R.IsReady() && !flashSlot.IsReady())
{
castR = false;
return;
}
if (GetInsecPos(target).Distance(myHero.Position) < 425 && ElLeeSinInsecUseInstaFlash && flashSlot.IsReady() && R.IsReady())
{
flashSlot.Cast(GetInsecPos(target));
castR = true;
return;
}
if (R.IsReady() && !target.IsZombie && R.IsInRange(target) && castR)
{
R.Cast(target);
castR = false;
}
}
if (ElLeeSinComboNew)
{
float leeSinRKickDistance = 700;
float leeSinRKickWidth = 100;
var minREnemies = ElLeeSinComboRCount;
foreach (var enemy in EntityManager.Heroes.Enemies)
{
var startPos = enemy.ServerPosition;
var endPos = myHero.ServerPosition.Extend(startPos, myHero.Distance(enemy) + leeSinRKickDistance);
var rectangle = new Geometry.Polygon.Rectangle(startPos, endPos, leeSinRKickWidth);
if (EntityManager.Heroes.Enemies.Count(x => rectangle.IsInside(x)) >= minREnemies)
{
R.Cast(enemy);
}
}
}
}
public static int EnemiesHitInRectangle(this Geometry.Polygon.Rectangle rect, List <Obj_AI_Base> enemies, int delay)
{
return(enemies.Where(a => a.MeetsCriteria() && rect.IsInside(a.Position(delay))).Count());
}
//---------------------------------------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;
}
