public static void AutoUlti()
{
// Hoes code below
if (GetBool("wardinsec", typeof(KeyBind))) return;
var target =
HeroManager.Enemies.Where(x => x.Distance(Player) < R.Range && !x.IsDead && x.IsValidTarget(R.Range))
.OrderBy(x => x.Distance(Player)).FirstOrDefault();
if (target == null || Player.IsDead)
{
UltPoly = null;
_ultPolyExpectedPos = null;
return;
}
UltPoly = new Geometry.Polygon.Rectangle(Player.ServerPosition,
Player.ServerPosition.Extend(target.Position, 1100),
target.BoundingRadius + 10);
var counts =
HeroManager.Enemies.Where(x => x.Distance(Player) < 1100 && x.IsValidTarget(1100))
.Count(h => h.NetworkId != target.NetworkId && UltPoly.IsInside(h.ServerPosition));
if (counts >= GetValue("autoron") && R.IsReady())
{
R.Cast(target);
}
}
/// <summary>
/// Gets the predicted health of a unit.
/// </summary>
/// <param name="target">Target</param>
/// <param name="time">Time in miliseconds</param>
/// <returns>Predicted Health.</returns>
public static float GetPredictedHealth(Obj_AI_Base target, float time)
{
var health = target.Health;
foreach (var missile in Missiles)
{
var missileArriveTime = 1000 * missile.Position.Distance(target.ServerPosition) / missile.SData.MissileSpeed;
var missileRectangle = new Geometry.Polygon.Rectangle(missile.StartPosition, missile.EndPosition, missile.SData.LineWidth);
if (missileRectangle.IsInside(target) && missileArriveTime >= time)
{
health -= (float) missile.SpellCaster.GetSpellDamage(target, missile.SData.Name);
}
}
return health;
}
public static void Drawing_OnDraw(EventArgs args)
{
try
{
if (Player.IsDead) return;
if (Program.EndPos != null)
{
var Range = new Geometry.Polygon.Rectangle(Program.StartPos, Program.EndPos, 150);
Range.Draw(Color.Red);
}
}
catch (Exception e)
{
Console.Write(e);
Game.PrintChat("FreshTahmKench is not working. plz send message by KorFresh (Code 5)");
}
}
public bool QMinionExtend(Obj_AI_Base minion)
{
var target = HeroManager.Enemies.FirstOrDefault(x => x.IsValidTarget(Spell.Range));
if (minion == null || target == null)
{
return false;
}
var prediction = Spell.GetPrediction(target);
if (prediction.Hitchance < HitChance.Medium)
{
return false;
}
var hit = new Geometry.Polygon.Rectangle(ObjectManager.Player.Position, ObjectManager.Player.Position.Extend(minion.Position, Spell.Range), Spell.Width);
return !hit.IsOutside(QPred(target).To2D());
}
private static void DrawingOnOnDraw(EventArgs args)
{
if (!Menu.Item("DrawSpell").IsActive())
{
return;
}
var rectangle = new Geometry.Polygon.Rectangle(new Vector3(), new Vector3(), 0);
foreach (var missile in ObjectManager.Get<Obj_SpellMissile>().Where(x => x.SpellCaster.IsMe /*&& CastedSpellsNames.Any(y => y == x.SData.Name)*/))
{
var missilePosition = missile.Position.To2D();
var unitPosition = missile.StartPosition.To2D();
var endPos = missile.EndPosition.To2D();
//Calculate the real end Point:
var direction = (endPos - unitPosition).Normalized();
if (unitPosition.Distance(endPos) > missile.SData.CastRange)
{
endPos = unitPosition + direction * missile.SData.CastRange;
}
rectangle.Start = unitPosition;
rectangle.End = endPos;
rectangle.Width = missile.SData.LineWidth;
rectangle.UpdatePolygon();
rectangle.Draw(Color.LightYellow);
// Draw Line
var start = missilePosition + missile.SData.LineWidth * rectangle.Direction.Perpendicular();
var end = missilePosition - missile.SData.LineWidth * rectangle.Direction.Perpendicular();
Drawing.DrawLine(Drawing.WorldToScreen(start.To3D()), Drawing.WorldToScreen(end.To3D()), 3, Color.Chartreuse);
}
}
/// <summary>
/// TODO The extended q.
/// </summary>
/// <param name="mode">
/// TODO The mode.
/// </param>
private static void ExtendedQ(Mode mode)
{
if (
!MenuHelper.IsMenuEnabled(
"com.idzlucian." + MenuHelper.GetFullNameFromMode(mode).ToLowerInvariant() + ".useextendedq")
|| ObjectManager.Player.ManaPercent
< MenuHelper.GetSliderValue(
"com.idzlucian.manamanager.qmana" + MenuHelper.GetStringFromMode(mode).ToLowerInvariant()))
{
return;
}
var target = TargetSelector.GetTarget(Spells[SpellSlot.Q].Range, TargetSelector.DamageType.Physical);
var targetExtended = TargetSelector.GetTarget(qExtended.Range, TargetSelector.DamageType.Physical);
if (target.IsValidTarget(Spells[SpellSlot.Q].Range) || !targetExtended.IsValidTarget(qExtended.Range)
|| (HasPassive() && Orbwalking.InAutoAttackRange(target)))
{
return;
}
var targetPrediction = qExtended.GetPrediction(targetExtended).UnitPosition.To2D();
var minions = MinionManager.GetMinions(
player.ServerPosition,
Spells[SpellSlot.Q].Range,
MinionTypes.All,
MinionTeam.NotAlly);
if (!minions.Any() || !targetExtended.IsMoving)
{
return;
}
if (MenuHelper.IsMenuEnabled("com.idzlucian.misc.noextq." + targetExtended.ChampionName.ToLowerInvariant()) && mode == Mode.Harass)
{
return;
}
// Credits xSalice
foreach (var minion in minions)
{
var polygon = new Geometry.Polygon.Rectangle(
player.ServerPosition,
player.ServerPosition.Extend(minion.ServerPosition, qExtended.Range),
qExtended.Width);
if (polygon.IsInside(targetPrediction)
&& Spells[SpellSlot.Q].Cast(minion) == Spell.CastStates.SuccessfullyCasted)
{
Spells[SpellSlot.Q].LastCastAttemptT = Environment.TickCount;
}
}
}
private static void LineFarm(Spell spell, List<Obj_AI_Base> minions, int min, float overrideWidth = -1f)
{
var spellWidth = overrideWidth > 0 ? overrideWidth : spell.Width;
var totalHits = 0;
var castPos = Vector3.Zero;
var positions = (from minion in minions
let pred = spell.GetPrediction(minion)
where pred.Hitchance >= HitChance.Medium
select new Tuple<Obj_AI_Base, Vector3>(minion, pred.UnitPosition)).ToList();
if (positions.Any())
{
foreach (var position in positions)
{
var rect = new Geometry.Polygon.Rectangle(
ObjectManager.Player.Position, ObjectManager.Player.Position.Extend(position.Item2, spell.Range),
spellWidth);
var count =
positions.Select(
position2 =>
new Geometry.Polygon.Circle(position2.Item2, position2.Item1.BoundingRadius * 0.9f))
.Count(circle => circle.Points.Any(p => rect.IsInside(p)));
if (count > totalHits)
{
totalHits = count;
castPos = position.Item2;
}
if (totalHits == minions.Count)
{
break;
}
}
if (!castPos.Equals(Vector3.Zero) && totalHits >= min)
{
spell.Cast(castPos);
}
}
}
private bool ELogic(Obj_AI_Hero mainTarget, List<Obj_AI_Base> targets, HitChance hitChance, int minHits)
{
try
{
var input = new PredictionInput
{
Range = ELength,
Delay = E.Delay,
Radius = E.Width,
Speed = E.Speed,
Type = E.Type
};
var input2 = new PredictionInput
{
Range = E.Range + ELength,
Delay = E.Delay,
Radius = E.Width,
Speed = E.Speed,
Type = E.Type
};
var startPos = Vector3.Zero;
var endPos = Vector3.Zero;
var hits = 0;
targets = targets.Where(t => t.IsValidTarget(E.Range + ELength + E.Width * 1.1f)).ToList();
var targetCount = targets.Count;
foreach (var target in targets)
{
bool containsTarget;
var lTarget = target;
if (target.Distance(Player.Position) <= E.Range)
{
containsTarget = mainTarget == null || lTarget.NetworkId == mainTarget.NetworkId;
var cCastPos = target.Position;
foreach (var t in targets.Where(t => t.NetworkId != lTarget.NetworkId))
{
var count = 1;
var cTarget = t;
input.Unit = t;
input.From = cCastPos;
input.RangeCheckFrom = cCastPos;
var pred = Prediction.GetPrediction(input);
if (pred.Hitchance >= (hitChance - 1))
{
count++;
if (!containsTarget)
{
containsTarget = t.NetworkId == mainTarget.NetworkId;
}
var rect = new Geometry.Polygon.Rectangle(
cCastPos.To2D(), cCastPos.Extend(pred.CastPosition, ELength).To2D(), E.Width);
foreach (var c in
targets.Where(
c => c.NetworkId != cTarget.NetworkId && c.NetworkId != lTarget.NetworkId))
{
input.Unit = c;
var cPredPos = c.Type == GameObjectType.obj_AI_Minion
? c.Position
: Prediction.GetPrediction(input).UnitPosition;
if (
new Geometry.Polygon.Circle(
cPredPos,
(c.Type == GameObjectType.obj_AI_Minion && c.IsMoving
? (c.BoundingRadius / 2f)
: (c.BoundingRadius) * 0.9f)).Points.Any(p => rect.IsInside(p)))
{
count++;
if (!containsTarget && c.NetworkId == mainTarget.NetworkId)
{
containsTarget = true;
}
}
}
if (count > hits && containsTarget)
{
hits = count;
startPos = cCastPos;
endPos = cCastPos.Extend(pred.CastPosition, ELength);
if (hits == targetCount)
{
break;
}
}
}
}
if (endPos.Equals(Vector3.Zero) && containsTarget)
{
startPos = target.IsFacing(Player) && IsSpellUpgraded(E)
? Player.Position.Extend(cCastPos, Player.Distance(cCastPos) - (ELength / 10f))
: cCastPos;
endPos = Player.Position.Extend(cCastPos, ELength);
hits = 1;
}
}
else
{
input2.Unit = lTarget;
var castPos = Prediction.GetPrediction(input2).CastPosition;
var sCastPos = Player.Position.Extend(castPos, E.Range);
var extDist = ELength / 4f;
var circle =
new Geometry.Polygon.Circle(Player.Position, sCastPos.Distance(Player.Position), 45).Points
.Where(p => p.Distance(sCastPos) < extDist).OrderBy(p => p.Distance(lTarget));
foreach (var point in circle)
{
input2.From = point.To3D();
input2.RangeCheckFrom = point.To3D();
input2.Range = ELength;
var pred2 = Prediction.GetPrediction(input2);
if (pred2.Hitchance >= hitChance)
{
containsTarget = mainTarget == null || lTarget.NetworkId == mainTarget.NetworkId;
var count = 1;
var rect = new Geometry.Polygon.Rectangle(
point, point.To3D().Extend(pred2.CastPosition, ELength).To2D(), E.Width);
foreach (var c in targets.Where(t => t.NetworkId != lTarget.NetworkId))
{
input2.Unit = c;
var cPredPos = c.Type == GameObjectType.obj_AI_Minion
? c.Position
: Prediction.GetPrediction(input2).UnitPosition;
if (
new Geometry.Polygon.Circle(
cPredPos,
(c.Type == GameObjectType.obj_AI_Minion && c.IsMoving
? (c.BoundingRadius / 2f)
: (c.BoundingRadius) * 0.9f)).Points.Any(p => rect.IsInside(p)))
{
count++;
if (!containsTarget && c.NetworkId == mainTarget.NetworkId)
{
containsTarget = true;
}
}
}
if (count > hits && containsTarget ||
count == hits && containsTarget && mainTarget != null &&
point.Distance(mainTarget.Position) < startPos.Distance(mainTarget.Position))
{
hits = count;
startPos = point.To3D();
endPos = startPos.Extend(pred2.CastPosition, ELength);
if (hits == targetCount)
{
break;
}
}
}
}
}
if (hits == targetCount)
{
break;
}
}
if (hits >= minHits && !startPos.Equals(Vector3.Zero) && !endPos.Equals(Vector3.Zero))
{
if (startPos.Distance(Player.Position) > E.Range)
{
startPos = Player.Position.Extend(startPos, E.Range);
}
if (startPos.Distance(endPos) > ELength)
{
endPos = startPos.Extend(endPos, ELength);
}
E.Cast(startPos, endPos);
return true;
}
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
return false;
}
private bool ELogicHero(Obj_AI_Hero mainTarget, HitChance hitChance)
{
try
{
if (mainTarget == null)
{
return false;
}
var input = new PredictionInput
{
Range = ELength,
Delay = E.Delay,
Radius = E.Width,
Speed = E.Speed,
Type = E.Type,
UseBoundingRadius = true
};
var input2 = new PredictionInput
{
Range = E.Range + ELength,
Delay = E.Delay,
Radius = E.Width,
Speed = E.Speed,
Type = E.Type,
UseBoundingRadius = true
};
var startPosition = Vector3.Zero;
var endPosition = Vector3.Zero;
var targets =
GameObjects.EnemyHeroes.Where(t => t.IsValidTarget((E.Range + ELength + E.Width) * 1.25f)).ToList();
if (mainTarget.ServerPosition.Distance(Player.ServerPosition) <= E.Range)
{
var castPosition = mainTarget.ServerPosition;
var maxAdditionalHits = 0;
foreach (var target in targets.Where(t => t.NetworkId != mainTarget.NetworkId))
{
var lTarget = target;
var additionalHits = 0;
input.Unit = lTarget;
input.From = castPosition;
input.RangeCheckFrom = castPosition;
var pred = Prediction.GetPrediction(input);
if (pred.Hitchance >= HitChance.High)
{
additionalHits++;
var rect = new Geometry.Polygon.Rectangle(
castPosition, castPosition.Extend(pred.CastPosition, ELength), E.Width);
foreach (var target2 in
targets.Where(
t => t.NetworkId != mainTarget.NetworkId && t.NetworkId != lTarget.NetworkId))
{
input.Unit = target2;
var pred2 = Prediction.GetPrediction(input);
if (!pred2.UnitPosition.Equals(Vector3.Zero) &&
new Geometry.Polygon.Circle(pred2.UnitPosition, target2.BoundingRadius * 0.9f)
.Points.Any(p => rect.IsInside(p)))
{
additionalHits++;
}
}
}
if (additionalHits > maxAdditionalHits)
{
maxAdditionalHits = additionalHits;
endPosition = pred.CastPosition;
}
}
startPosition = castPosition;
if (endPosition.Equals(Vector3.Zero))
{
if (startPosition.Distance(Player.ServerPosition) > E.Range)
{
startPosition = Player.ServerPosition.Extend(startPosition, E.Range);
}
if (mainTarget.Path.Length > 0)
{
var newPos = mainTarget.Path[0];
if (mainTarget.Path.Length > 1 &&
newPos.Distance(mainTarget.ServerPosition) <= mainTarget.BoundingRadius * 4f)
{
var nnPos = newPos.Extend(
mainTarget.Path[1],
Math.Min(mainTarget.BoundingRadius * 1.5f, newPos.Distance(mainTarget.Path[1])));
if (startPosition.To2D().AngleBetween(nnPos.To2D()) < 30)
{
newPos = nnPos;
}
}
endPosition = startPosition.Extend(newPos, ELength);
}
else if (mainTarget.IsFacing(Player))
{
endPosition = startPosition.Extend(Player.ServerPosition, ELength);
}
else
{
endPosition = Player.ServerPosition.Extend(
startPosition, startPosition.Distance(Player.ServerPosition) + ELength);
}
}
}
else
{
var totalHits = 0;
input2.Unit = mainTarget;
var pred = Prediction.GetPrediction(input2);
if (!pred.UnitPosition.Equals(Vector3.Zero) && !pred.CastPosition.Equals(Vector3.Zero))
{
var ranges =
new[] { E.Range }.Concat(
targets.Where(
t =>
t.ServerPosition.Distance(Player.ServerPosition) < E.Range &&
t.ServerPosition.Distance(mainTarget.ServerPosition) < ELength * 1.25f)
.Select(t => t.ServerPosition.Distance(Player.ServerPosition)));
var maxDistance = (ELength + E.Width + mainTarget.BoundingRadius) * 1.1f;
foreach (var range in ranges)
{
var circle =
new Geometry.Polygon.Circle(Player.ServerPosition, Math.Min(E.Range, range), 50).Points
.Where(p => p.Distance(pred.UnitPosition) <= maxDistance)
.Select(p => p.To3D())
.OrderBy(p => p.Distance(pred.CastPosition));
foreach (var point in circle)
{
var hits = 0;
input.From = point;
input.RangeCheckFrom = point;
input.Unit = mainTarget;
var pred2 = Prediction.GetPrediction(input);
if (pred2.Hitchance >= hitChance)
{
hits++;
var rect = new Geometry.Polygon.Rectangle(
point, point.Extend(pred2.CastPosition, ELength), E.Width);
foreach (var target in targets.Where(t => t.NetworkId != mainTarget.NetworkId))
{
input.Unit = target;
var pred3 = Prediction.GetPrediction(input);
if (!pred3.UnitPosition.Equals(Vector3.Zero) &&
new Geometry.Polygon.Circle(
pred3.UnitPosition, target.BoundingRadius * 0.9f).Points.Any(
p => rect.IsInside(p)))
{
hits++;
}
}
if (hits > totalHits ||
hits > 0 && hits == totalHits &&
point.Distance(mainTarget.ServerPosition) <
startPosition.Distance(mainTarget.ServerPosition))
{
totalHits = hits;
startPosition = point;
endPosition = point.Extend(pred2.CastPosition, ELength);
}
if (totalHits == targets.Count)
{
break;
}
}
}
if (totalHits == targets.Count)
{
break;
}
}
}
}
if (!startPosition.Equals(Vector3.Zero) && !endPosition.Equals(Vector3.Zero))
{
if (startPosition.Distance(Player.ServerPosition) > E.Range)
{
startPosition = Player.ServerPosition.Extend(startPosition, E.Range);
}
if (endPosition.Distance(startPosition) > ELength)
{
endPosition = startPosition.Extend(endPosition, ELength);
}
E.Cast(startPosition, endPosition);
return true;
}
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
return false;
}
public static Result Line(Spell spell,
Obj_AI_Hero target,
HitChance hitChance,
bool boundingRadius = true,
bool maxRange = true)
{
try
{
if (spell == null || target == null)
{
return new Result(Vector3.Zero, new List<Obj_AI_Hero>());
}
var range = (spell.IsChargedSpell && maxRange ? spell.ChargedMaxRange : spell.Range) +
(spell.Width * 0.9f) +
(boundingRadius ? target.BoundingRadius * BoundingRadiusMultiplicator : 0);
var positions = (from t in GameObjects.EnemyHeroes
where t.IsValidTarget(range, true, spell.RangeCheckFrom)
let prediction = spell.GetPrediction(t)
where prediction.Hitchance >= hitChance
select new Position(t, prediction.UnitPosition)).ToList();
if (positions.Any())
{
var hits = new List<Obj_AI_Hero>();
var pred = spell.GetPrediction(target);
if (pred.Hitchance >= hitChance)
{
hits.Add(target);
var rect = new Geometry.Polygon.Rectangle(
spell.From, spell.From.Extend(pred.CastPosition, range), spell.Width);
if (boundingRadius)
{
hits.AddRange(
from point in positions.Where(p => p.Hero.NetworkId != target.NetworkId)
let circle =
new Geometry.Polygon.Circle(
point.UnitPosition, point.Hero.BoundingRadius * BoundingRadiusMultiplicator)
where circle.Points.Any(p => rect.IsInside(p))
select point.Hero);
}
else
{
hits.AddRange(
from position in positions
where rect.IsInside(position.UnitPosition)
select position.Hero);
}
return new Result(pred.CastPosition, hits);
}
}
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
return new Result(Vector3.Zero, new List<Obj_AI_Hero>());
}
private static void LineFarm(Spell spell, List<Obj_AI_Base> minions, int min, float overrideWidth = -1f)
{
var spellWidth = overrideWidth > 0 ? overrideWidth : spell.Width;
var totalHits = 0;
var castPos = Vector3.Zero;
foreach (var minion in minions)
{
var lMinion = minion;
var pred = spell.GetPrediction(minion);
if (pred.Hitchance < HitChance.Medium)
{
continue;
}
var rect = new Geometry.Polygon.Rectangle(
ObjectManager.Player.Position.To2D(),
ObjectManager.Player.Position.Extend(pred.CastPosition, spell.Range).To2D(), spellWidth);
var count = 1 + (from minion2 in minions.Where(m => m.NetworkId != lMinion.NetworkId)
let pred2 = spell.GetPrediction(minion2)
where pred2.Hitchance >= HitChance.Medium
where
new Geometry.Polygon.Circle(pred2.UnitPosition, minion2.BoundingRadius * 0.8f).Points.Any(
p => rect.IsInside(p))
select 1).Sum();
if (count > totalHits)
{
totalHits = count;
castPos = pred.CastPosition;
}
if (totalHits == minions.Count)
{
break;
}
if (!castPos.Equals(Vector3.Zero) && totalHits >= min)
{
spell.Cast(castPos);
}
}
}
public static Vector2 GetCollisionPoint(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
Helper.GetMinions(
@from.To3D(), 1200, MinionTypes.All,
skillshot.Unit.Team == ObjectManager.Player.Team
? MinionTeam.NotAlly
: MinionTeam.NotAllyForEnemy)
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.Champions:
collisions.AddRange(
from hero in HeroManager.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 (
!HeroManager.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 subWallWidth = wallWidth / 2;
var wallStart = wall.Position.To2D() + subWallWidth * 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();
}
private void Game_OnUpdate(EventArgs args)
{
if (!ObjectManager.Player.IsDead)
if (Orbwalking.CanMove(100))
{
switch (MenuProvider.Orbwalker.ActiveMode)
{
case Orbwalking.OrbwalkingMode.Combo:
{
if (MenuProvider.Champion.Combo.UseQ)
if (_q.IsReadyPerfectly())
if (!ObjectManager.Player.IsDashing())
if (_hasPassive == false)
{
var target = TargetSelector.GetTarget(_q.Range, _q.DamageType);
if (target != null)
_q.CastOnUnit(target);
else
{
var extendedTarget = TargetSelector.GetTarget(_qExtended.Range,
_q.DamageType);
if (extendedTarget != null)
{
var minions =
MinionManager.GetMinions(ObjectManager.Player.ServerPosition,
_q.Range, MinionTypes.All, MinionTeam.NotAlly);
foreach (var minion in minions)
{
var box =
new Geometry.Polygon.Rectangle(
ObjectManager.Player.ServerPosition,
ObjectManager.Player.ServerPosition.Extend(
minion.ServerPosition, _qExtended.Range),
_qExtended.Width);
var prediction = _qExtended.GetPrediction(extendedTarget);
if (box.IsInside(prediction.UnitPosition))
if (prediction.Hitchance >= _q.MinHitChance)
{
_q.CastOnUnit(minion);
break;
}
}
}
}
}
else
{
var killableTarget =
HeroManager.Enemies.FirstOrDefault(
x =>
x.IsKillableAndValidTarget(_q.GetDamage(x),
TargetSelector.DamageType.Physical, _q.Range));
if (killableTarget != null)
_q.CastOnUnit(killableTarget);
}
if (MenuProvider.Champion.Combo.UseW)
if (_w.IsReadyPerfectly())
if (!ObjectManager.Player.IsDashing())
if (_hasPassive == false)
{
if (HeroManager.Enemies.Any(x => Orbwalking.InAutoAttackRange(x)))
{
var target = TargetSelector.GetTarget(_w.Range, _w.DamageType);
if (target != null)
_wNoCollision.Cast(target, false, true);
}
else
{
var target = TargetSelector.GetTargetNoCollision(_w);
if (target != null)
_w.Cast(target);
}
}
else
{
var killableTarget =
HeroManager.Enemies.FirstOrDefault(
x =>
x.IsKillableAndValidTarget(_w.GetDamage(x),
TargetSelector.DamageType.Physical, _w.Range) &&
_w.GetPrediction(x).Hitchance >= HitChance.High);
if (killableTarget != null)
_w.Cast(killableTarget);
}
break;
}
case Orbwalking.OrbwalkingMode.Mixed:
{
if (MenuProvider.Champion.Harass.UseQ)
if (_hasPassive == false)
if (_q.IsReadyPerfectly())
if (!ObjectManager.Player.IsDashing())
if (
ObjectManager.Player.IsManaPercentOkay(
MenuProvider.Champion.Harass.IfMana))
{
var target = TargetSelector.GetTarget(_q.Range, _q.DamageType);
if (target != null)
_q.CastOnUnit(target);
else
{
var extendedTarget = TargetSelector.GetTarget(_qExtended.Range,
_q.DamageType);
if (extendedTarget != null)
{
var minions =
MinionManager.GetMinions(
ObjectManager.Player.ServerPosition, _q.Range,
MinionTypes.All, MinionTeam.NotAlly);
foreach (var minion in minions)
{
var box =
new Geometry.Polygon.Rectangle(
ObjectManager.Player.ServerPosition,
ObjectManager.Player.ServerPosition.Extend(
minion.ServerPosition, _qExtended.Range),
_qExtended.Width);
var prediction = _qExtended.GetPrediction(extendedTarget);
if (box.IsInside(prediction.UnitPosition))
if (prediction.Hitchance >= _q.MinHitChance)
{
_q.CastOnUnit(minion);
break;
}
}
}
}
}
if (MenuProvider.Champion.Harass.UseW)
if (_w.IsReadyPerfectly())
if (!ObjectManager.Player.IsDashing())
if (ObjectManager.Player.IsManaPercentOkay(MenuProvider.Champion.Harass.IfMana))
if (_hasPassive == false)
{
if (HeroManager.Enemies.Any(x => Orbwalking.InAutoAttackRange(x)))
{
var target = TargetSelector.GetTarget(_w.Range, _w.DamageType);
if (target != null)
_wNoCollision.Cast(target, false, true);
}
else
{
var target = TargetSelector.GetTargetNoCollision(_w);
if (target != null)
_w.Cast(target);
}
}
else
{
var killableTarget =
HeroManager.Enemies.FirstOrDefault(
x =>
x.IsKillableAndValidTarget(_w.GetDamage(x),
TargetSelector.DamageType.Physical, _w.Range) &&
_w.GetPrediction(x).Hitchance >= HitChance.High);
if (killableTarget != null)
_w.Cast(killableTarget);
}
break;
}
case Orbwalking.OrbwalkingMode.LaneClear:
{
//Laneclear
if (MenuProvider.Champion.Laneclear.UseQ)
if (_hasPassive == false)
if (ObjectManager.Player.IsManaPercentOkay(MenuProvider.Champion.Laneclear.IfMana))
if (_q.IsReadyPerfectly())
if (!ObjectManager.Player.IsDashing())
{
var minions =
MinionManager.GetMinions(ObjectManager.Player.ServerPosition,
_q.Range);
foreach (var minion in minions)
{
var box =
new Geometry.Polygon.Rectangle(
ObjectManager.Player.ServerPosition,
ObjectManager.Player.ServerPosition.Extend(
minion.ServerPosition, _qExtended.Range),
_qExtended.Width);
if (minions.Count(x => box.IsInside(x.ServerPosition)) >= 3)
{
_q.CastOnUnit(minion);
break;
}
}
}
//Jungleclear
if (MenuProvider.Champion.Jungleclear.UseQ)
if (_hasPassive == false)
if (ObjectManager.Player.IsManaPercentOkay(MenuProvider.Champion.Jungleclear.IfMana))
if (_q.IsReadyPerfectly())
if (!ObjectManager.Player.IsDashing())
{
var target =
MinionManager.GetMinions(_q.Range, MinionTypes.All,
MinionTeam.Neutral, MinionOrderTypes.MaxHealth)
.FirstOrDefault(x => x.IsValidTarget(_q.Range));
if (target != null)
_q.CastOnUnit(target);
}
if (MenuProvider.Champion.Jungleclear.UseW)
if (_hasPassive == false)
if (ObjectManager.Player.IsManaPercentOkay(MenuProvider.Champion.Jungleclear.IfMana))
if (_w.IsReadyPerfectly())
if (!ObjectManager.Player.IsDashing())
{
var target =
MinionManager.GetMinions(_w.Range, MinionTypes.All,
MinionTeam.Neutral, MinionOrderTypes.MaxHealth)
.FirstOrDefault(x => x.IsValidTarget(_w.Range));
if (target != null)
_w.Cast(target);
}
break;
}
}
if (MenuProvider.Champion.Harass.AutoHarass)
if (MenuProvider.Orbwalker.ActiveMode != Orbwalking.OrbwalkingMode.Combo &&
MenuProvider.Orbwalker.ActiveMode != Orbwalking.OrbwalkingMode.Mixed)
if (!ObjectManager.Player.IsRecalling())
if (ObjectManager.Player.IsManaPercentOkay(MenuProvider.Champion.Harass.IfMana))
if (MenuProvider.Champion.Harass.UseQ)
{
var extendedTarget = TargetSelector.GetTarget(_qExtended.Range, _q.DamageType);
if (extendedTarget != null)
if (ObjectManager.Player.UnderTurret(true)
? !extendedTarget.UnderTurret(true)
: true)
{
var minions =
MinionManager.GetMinions(ObjectManager.Player.ServerPosition,
_q.Range, MinionTypes.All, MinionTeam.NotAlly);
foreach (var minion in minions)
{
var box =
new Geometry.Polygon.Rectangle(
ObjectManager.Player.ServerPosition,
ObjectManager.Player.ServerPosition.Extend(
minion.ServerPosition, _qExtended.Range),
_qExtended.Width);
var prediction = _qExtended.GetPrediction(extendedTarget);
if (box.IsInside(prediction.UnitPosition))
if (prediction.Hitchance >= _q.MinHitChance)
{
_q.CastOnUnit(minion);
break;
}
}
}
}
}
}
private static void OnProcessSpell(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
try
{
if (!sender.IsMe && sender.IsEnemy)
{
if (_MainMenu.Item("TahmKench_MyTeamMinEnable").GetValue<bool>() && sender.IsEnemy && _W.IsReady())
{
var SkillRange = new Geometry.Polygon.Rectangle(args.Start, args.End, sender.BoundingRadius + 30);
var Target = HeroManager.Allies.FirstOrDefault(f => f.Distance(Player.Position) <= _W.Range
&& !f.IsZombie && !f.IsDead && SkillRange.IsInside(f.Position)
&& _MainMenu.Item("TahmKench_MyTeamMin").GetValue<Slider>().Value >= f.HealthPercent);
if (Target != null)
{
_W.CastOnUnit(Target, true);
return;
}
if (args.Target != null)
{
var target = HeroManager.Allies.FirstOrDefault(f => f.Position.Distance(Player.Position) <= _W.Range
&& !f.IsZombie && !f.IsDead && f.HealthPercent <= _MainMenu.Item("TahmKench_MyTeamMin").GetValue<Slider>().Value);
if (target != null)
{
_W.CastOnUnit(target, true);
return;
}
}
}
if (_MainMenu.Item("TahmKench_AutoEUse").GetValue<bool>() && sender.IsEnemy && _E.IsReady() && Player.HealthPercent <= _MainMenu.Item("TahmKench_MinE").GetValue<Slider>().Value)
{
var target = new Geometry.Polygon.Rectangle(args.Start, args.End, sender.BoundingRadius + 30);
if (target != null)
{
_E.Cast(true);
return;
}
if (args.Target != null)
{
var TargetMe = HeroManager.Allies.FirstOrDefault(f => f.Position.Distance(Player.Position) <= 10);
if (TargetMe == Player)
{
_E.Cast(true);
return;
}
}
}
}
}
catch (Exception)
{
if (NowTime() > ErrorTime)
{
Game.PrintChat(ChampName + " in FreshBooster isn't Load. Error Code 08");
ErrorTime = TickCount(10000);
}
}
}
private static void AutoKick()
{
if (MainMenu._MainMenu.Item("AutoKick").GetValue<Slider>().Value == 0 || MainMenu._MainMenu.Item("InsecKick").GetValue<KeyBind>().Active) return;
var target =
HeroManager.Enemies.Where(x => x.Distance(Player) < 375 && !x.IsDead && x.IsValidTarget(375))
.OrderBy(x => x.Distance(Player)).FirstOrDefault();
if (target == null) return;
var ultPoly = new Geometry.Polygon.Rectangle(Player.ServerPosition,
Player.ServerPosition.Extend(target.Position, 1100),
target.BoundingRadius + 10);
var count =
HeroManager.Enemies.Where(x => x.Distance(Player) < 1100 && x.IsValidTarget(1100))
.Count(h => h.NetworkId != target.NetworkId && ultPoly.IsInside(h.ServerPosition));
if (count >= MainMenu._MainMenu.Item("AutoKick").GetValue<Slider>().Value && _R.IsReady())
{
_R.Cast(target);
}
}
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 subWallWidth = wallWidth / 2;
var wallStart = Wall.Position.To2D() + subWallWidth * 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();
}
private static void OnProcessSpell(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
try
{
if (!(sender is Obj_AI_Hero) || Player.IsRecalling())
return;
// Auto W
if (_MainMenu.Item("Braum_AutoW").GetValue<bool>() && _W.IsReady())
{
if (!(sender is Obj_AI_Hero) || !sender.IsEnemy)
return;
if (args.Target != null)
if (args.SData.Name.ToLower().Contains("attack") && args.Target.Position.Distance(Player.Position) < _W.Range)
if (args.Target.IsAlly && args.Target is Obj_AI_Hero)
{
if (args.Target.IsMe && Player.HealthPercent < 20)
{
_W.CastOnUnit((Obj_AI_Base)args.Target, true);
}
else
{
_W.CastOnUnit((Obj_AI_Base)args.Target, true);
}
}
}
// Auto E
if (_MainMenu.Item("Braum_AutoE").GetValue<bool>() && _E.IsReady())
{
if (!(sender is Obj_AI_Hero) || !sender.IsEnemy || !Orbwalking.CanAttack())
return;
var enemyskill = new Geometry.Polygon.Rectangle(args.Start, args.End, args.SData.BounceRadius + 20);
var myteam = HeroManager.Allies.Where(f => f.Distance(Player.Position) < 200);
var count = myteam.Count(f => enemyskill.IsInside(f.Position));
if (args.Target != null && args.Target.Position.Distance(Player.Position) < 200)
{
if (args.Target.Name == Player.Name && Player.HealthPercent < 20)
{
_E.Cast(sender.Position, true);
}
else if (args.Target.Position.Distance(Player.Position) < 200 && args.Target is Obj_AI_Hero)
{
if (_W.IsReady() && args.Target.Position.Distance(Player.Position) < _W.Range)
_W.CastOnUnit((Obj_AI_Base)args.Target, true);
_E.Cast(sender.Position, true);
}
}
else if (args.Target == null)
{
if (Player.HealthPercent < 20 && count == 1)
{
_E.Cast(sender.Position, true);
}
else if (count >= 2)
{
_E.Cast(sender.Position, true);
}
}
}
}
catch (Exception)
{
if (NowTime() > ErrorTime)
{
Game.PrintChat(ChampName + " in FreshBooster isn't Load. Error Code 08");
ErrorTime = TickCount(10000);
}
}
}
private void Game_OnUpdate(EventArgs args)
{
if (UnderClocking.NeedtoUnderClocking())
return;
if (!ObjectManager.Player.IsDead)
if (Orbwalking.CanMove(100))
{
switch (MenuProvider.Orbwalker.ActiveMode)
{
case Orbwalking.OrbwalkingMode.Combo:
{
if (MenuProvider.Champion.Combo.UseQ)
if (Q.isReadyPerfectly())
if (!ObjectManager.Player.IsDashing())
if (HasPassive == false)
{
var Target = TargetSelector.GetTarget(Q.Range, Q.DamageType);
if (Target != null)
Q.CastOnUnit(Target);
else
{
var ExtendedTarget = TargetSelector.GetTarget(QExtended.Range, Q.DamageType);
if (ExtendedTarget != null)
{
var Minions = MinionManager.GetMinions(ObjectManager.Player.ServerPosition, Q.Range, MinionTypes.All, MinionTeam.NotAlly);
foreach (var Minion in Minions)
{
var BOX = new Geometry.Polygon.Rectangle(ObjectManager.Player.ServerPosition, ObjectManager.Player.ServerPosition.Extend(Minion.ServerPosition, QExtended.Range), QExtended.Width);
if (BOX.IsInside(QExtended.GetPrediction(ExtendedTarget).UnitPosition))
{
Q.CastOnUnit(Minion);
break;
}
}
}
}
}
else
{
var killableTarget = HeroManager.Enemies.FirstOrDefault(x => x.isKillableAndValidTarget(Q.GetDamage(x), TargetSelector.DamageType.Physical, Q.Range));
if (killableTarget != null)
Q.CastOnUnit(killableTarget);
}
if (MenuProvider.Champion.Combo.UseW)
if (W.isReadyPerfectly())
if (!ObjectManager.Player.IsDashing())
if (HasPassive == false)
{
if (HeroManager.Enemies.Any(x => Orbwalking.InAutoAttackRange(x)))
WNoCollision.CastOnBestTarget();
else
{
var Target = TargetSelector.GetTargetNoCollision(W);
if (Target != null)
W.Cast(Target);
}
}
else
{
var killableTarget = HeroManager.Enemies.FirstOrDefault(x => x.isKillableAndValidTarget(W.GetDamage(x), TargetSelector.DamageType.Physical, W.Range) && W.GetPrediction(x).Hitchance >= HitChance.High);
if (killableTarget != null)
W.Cast(killableTarget);
}
break;
}
case Orbwalking.OrbwalkingMode.Mixed:
{
if (MenuProvider.Champion.Harass.UseQ)
if (HasPassive == false)
if (Q.isReadyPerfectly())
if (!ObjectManager.Player.IsDashing())
if (ObjectManager.Player.isManaPercentOkay(MenuProvider.Champion.Harass.IfMana))
{
var Target = TargetSelector.GetTarget(Q.Range, Q.DamageType);
if (Target != null)
Q.CastOnUnit(Target);
else
{
var ExtendedTarget = TargetSelector.GetTarget(QExtended.Range, Q.DamageType);
if (ExtendedTarget != null)
{
var Minions = MinionManager.GetMinions(ObjectManager.Player.ServerPosition, Q.Range, MinionTypes.All, MinionTeam.NotAlly);
foreach (var Minion in Minions)
{
var BOX = new Geometry.Polygon.Rectangle(ObjectManager.Player.ServerPosition, ObjectManager.Player.ServerPosition.Extend(Minion.ServerPosition, QExtended.Range), QExtended.Width);
if (BOX.IsInside(QExtended.GetPrediction(ExtendedTarget).UnitPosition))
{
Q.CastOnUnit(Minion);
break;
}
}
}
}
}
if (MenuProvider.Champion.Harass.UseW)
if (W.isReadyPerfectly())
if (!ObjectManager.Player.IsDashing())
if (ObjectManager.Player.isManaPercentOkay(MenuProvider.Champion.Harass.IfMana))
if (HasPassive == false)
{
if (HeroManager.Enemies.Any(x => Orbwalking.InAutoAttackRange(x)))
WNoCollision.CastOnBestTarget();
else
{
var Target = TargetSelector.GetTargetNoCollision(W);
if (Target != null)
W.Cast(Target);
}
}
else
{
var killableTarget = HeroManager.Enemies.FirstOrDefault(x => x.isKillableAndValidTarget(W.GetDamage(x), TargetSelector.DamageType.Physical, W.Range) && W.GetPrediction(x).Hitchance >= HitChance.High);
if (killableTarget != null)
W.Cast(killableTarget);
}
break;
}
case Orbwalking.OrbwalkingMode.LaneClear:
{
//Laneclear
if (MenuProvider.Champion.Laneclear.UseQ)
if (HasPassive == false)
if (ObjectManager.Player.isManaPercentOkay(MenuProvider.Champion.Laneclear.IfMana))
if (Q.isReadyPerfectly())
if (!ObjectManager.Player.IsDashing())
{
var Minions = MinionManager.GetMinions(ObjectManager.Player.ServerPosition, Q.Range);
foreach (var Minion in Minions)
{
var BOX = new Geometry.Polygon.Rectangle(ObjectManager.Player.ServerPosition, ObjectManager.Player.ServerPosition.Extend(Minion.ServerPosition, QExtended.Range), QExtended.Width);
if (Minions.Count(x => BOX.IsInside(x.ServerPosition)) >= 3)
{
Q.CastOnUnit(Minion);
break;
}
}
}
//Jungleclear
if (MenuProvider.Champion.Jungleclear.UseQ)
if (HasPassive == false)
if (ObjectManager.Player.isManaPercentOkay(MenuProvider.Champion.Jungleclear.IfMana))
if (Q.isReadyPerfectly())
if (!ObjectManager.Player.IsDashing())
{
var Target = MinionManager.GetMinions(Q.Range, MinionTypes.All, MinionTeam.Neutral, MinionOrderTypes.MaxHealth).FirstOrDefault(x => x.IsValidTarget(Q.Range));
if (Target != null)
Q.CastOnUnit(Target);
}
if (MenuProvider.Champion.Jungleclear.UseW)
if (HasPassive == false)
if (ObjectManager.Player.isManaPercentOkay(MenuProvider.Champion.Jungleclear.IfMana))
if (W.isReadyPerfectly())
if (!ObjectManager.Player.IsDashing())
{
var Target = MinionManager.GetMinions(W.Range, MinionTypes.All, MinionTeam.Neutral, MinionOrderTypes.MaxHealth).FirstOrDefault(x => x.IsValidTarget(W.Range));
if (Target != null)
W.Cast(Target);
}
break;
}
}
}
}
private void Drawing_OnDraw(EventArgs args)
{
if (!EE["Enabled"].Cast<CheckBox>().CurrentValue)
{
return;
}
if (EE["VayneE"] != null)
{
foreach (var e in HeroManager.Enemies.Where(e => e.ChampionName.ToLower() == "vayne" && e.LSDistance(Program.Player.Position) < 900))
{
for (var i = 1; i < 8; i++)
{
var championBehind = ObjectManager.Player.Position
+ Vector3.Normalize(e.ServerPosition - ObjectManager.Player.Position)
* (-i * 50);
if (EE["drawline"].Cast<CheckBox>().CurrentValue)
{
Drawing.DrawCircle(championBehind, 35f, championBehind.LSIsWall() ? System.Drawing.Color.Red : System.Drawing.Color.Gray);
}
}
}
}
foreach (var e in HeroManager.Enemies.Where(e => e.LSIsValidTarget(2000)))
{
foreach (var eList in this.EarlyList)
{
if (eList.ChampionName == e.ChampionName)
{
if (EE[eList.ChampionName + eList.SpellName].Cast<CheckBox>().CurrentValue)
{
var xminions = 0;
if (e.LSIsValidTarget(eList.Range))
{
for (var i = 1;
i < e.Position.LSDistance(ObjectManager.Player.Position) / eList.Width;
i++)
{
var championBehind = ObjectManager.Player.Position
+ Vector3.Normalize(
e.ServerPosition - ObjectManager.Player.Position)
* (i * eList.Width);
var list = eList;
var allies = HeroManager.Allies.Where(a => a.LSDistance(ObjectManager.Player.Position) < list.Range);
var minions = MinionManager.GetMinions(ObjectManager.Player.Position, eList.Range,MinionTypes.All, MinionTeam.Ally);
var mobs = MinionManager.GetMinions(ObjectManager.Player.Position,eList.Range,MinionTypes.All,MinionTeam.Neutral);
xminions += minions.Count(m => m.LSDistance(championBehind) < eList.Width)
+ allies.Count(a => a.LSDistance(championBehind) < eList.Width)
+ mobs.Count(m => m.LSDistance(championBehind) < eList.Width);
}
if (xminions == 0)
{
if (EE["drawline"].Cast<CheckBox>().CurrentValue)
{
var rec = new Geometry.Polygon.Rectangle(ObjectManager.Player.Position, e.Position, eList.Width - 10);
rec.Draw(eList.Color, 2);
}
if (EE["drawtext"].Cast<CheckBox>().CurrentValue)
{
Vector3[] x = new[] { ObjectManager.Player.Position, e.Position };
var aX =
Drawing.WorldToScreen(
new Vector3(
Helper.CenterOfVectors(x).X,
Helper.CenterOfVectors(x).Y,
Helper.CenterOfVectors(x).Z));
Drawing.DrawText(aX.X - 15, aX.Y - 15, eList.Color, eList.ChampionName + eList.SpellName);
}
}
}
}
}
}
}
}
private static void AutoUlt()
{
var target =
HeroManager.Enemies.Where(x => x.Distance(Player) < R.Range && !x.IsDead && x.IsValidTarget(R.Range))
.OrderBy(x => x.Distance(Player)).FirstOrDefault();
if (target == null || Player.IsDead)
{
ultPoly = null;
ultPolyExpectedPos = null;
return;
}
ultPoly = new Geometry.Polygon.Rectangle(Player.ServerPosition,
Player.ServerPosition.Extend(target.Position, 1100),
target.BoundingRadius + 10);
var counts =
HeroManager.Enemies.Where(x => x.Distance(Player) < 1100 && x.IsValidTarget(1100))
.Count(h => h.NetworkId != target.NetworkId && ultPoly.IsInside(h.ServerPosition));
if (counts >= GetValue("autoron") && R.IsReady())
{
R.Cast(target);
}
}
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);
//Game.PrintChat("local 1");
}
}
//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 && !f.IsDead) != null))
{
_W.CastOnUnit(item, true);
//Game.PrintChat("local 2");
return;
}
}
if (WTarget != null && WTarget.Position.Distance(Player.Position) <= _W.Range)
{
_W.CastOnUnit(WTarget, true);
//Game.PrintChat("local 3");
}
}
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);
//Game.PrintChat("local 4");
return;
}
}
if (WTarget != null && WTarget.Position.Distance(Player.Position) <= _W.Range && WTarget.IsChampion())
{
_W.CastOnUnit(WTarget, true);
//Game.PrintChat("local 5");
}
}
}
}
catch (Exception)
{
if (NowTime() > ErrorTime)
{
Game.PrintChat(ChampName + " in FreshBooster isn't Load. Error Code 06");
ErrorTime = TickCount(10000);
}
}
}
private Tuple<int, List<Obj_AI_Hero>, Vector3> GetRHits(Obj_AI_Hero target)
{
var hits = new List<Obj_AI_Hero>();
var castPos = Vector3.Zero;
try
{
var pred = R.GetPrediction(target);
if (pred.Hitchance >= R.GetHitChance("combo"))
{
castPos = pred.CastPosition;
hits.Add(target);
var pos = Player.Position.Extend(castPos, Math.Min(Player.Distance(pred.UnitPosition), R.Range));
var pos2 = Player.Position.Extend(pos, Player.Distance(pos) + R2.Range);
var input = new PredictionInput
{
Range = R2.Range,
Delay = Player.Position.Distance(pred.UnitPosition) / R.Speed + 0.1f,
From = pos,
RangeCheckFrom = pos,
Radius = R2.Width,
Type = SkillshotType.SkillshotLine,
Speed = R2.Speed
};
var rect = new Geometry.Polygon.Rectangle(pos, pos2, R2.Width);
foreach (var enemy in
GameObjects.EnemyHeroes.Where(e => e.IsValidTarget() && e.NetworkId != target.NetworkId))
{
input.Unit = enemy;
var pred2 = Prediction.GetPrediction(input);
if (!pred2.UnitPosition.Equals(Vector3.Zero))
{
if (
new Geometry.Polygon.Circle(enemy.Position, enemy.BoundingRadius).Points.Any(
p => rect.IsInside(p)))
{
hits.Add(enemy);
}
}
}
}
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
return new Tuple<int, List<Obj_AI_Hero>, Vector3>(hits.Count, hits, castPos);
}
private void ELogicFarm(List<Obj_AI_Base> targets, HitChance hitChance, int minHits)
{
try
{
var input = new PredictionInput
{
Range = ELength,
Delay = E.Delay,
Radius = E.Width,
Speed = E.Speed,
Type = E.Type
};
var input2 = new PredictionInput
{
Range = E.Range + ELength,
Delay = E.Delay,
Radius = E.Width,
Speed = E.Speed,
Type = E.Type
};
var startPos = Vector3.Zero;
var endPos = Vector3.Zero;
var hits = 0;
targets = targets.Where(t => t.IsValidTarget((E.Range + ELength + E.Width) * 1.1f)).ToList();
var targetCount = targets.Count;
foreach (var target in targets)
{
var lTarget = target;
if (target.ServerPosition.Distance(Player.ServerPosition) <= E.Range)
{
var cCastPos = target.ServerPosition;
foreach (var t in targets.Where(t => t.NetworkId != lTarget.NetworkId))
{
var count = 1;
input.Unit = t;
input.From = cCastPos;
input.RangeCheckFrom = cCastPos;
var pred = Prediction.GetPrediction(input);
var rect = new Geometry.Polygon.Rectangle(
cCastPos.To2D(), cCastPos.Extend(pred.CastPosition, ELength).To2D(), E.Width);
foreach (var c in targets.Where(c => c.NetworkId != lTarget.NetworkId))
{
input.Unit = c;
var cPredPos = c.Position;
if (
new Geometry.Polygon.Circle(
cPredPos, (c.IsMoving ? (c.BoundingRadius / 2f) : (c.BoundingRadius) * 0.9f))
.Points.Any(p => rect.IsInside(p)))
{
count++;
}
}
if (pred.Hitchance >= (hitChance - 1))
{
count++;
if (count > hits)
{
hits = count;
startPos = cCastPos;
endPos = cCastPos.Extend(pred.CastPosition, ELength);
if (hits == targetCount)
{
break;
}
}
}
}
if (endPos.Equals(Vector3.Zero))
{
startPos = cCastPos;
if (IsSpellUpgraded(E))
{
if (target.Path.Length > 0)
{
var newPos = target.Path[0];
if (target.Path.Length > 1 && newPos.Distance(target.ServerPosition) <= 150)
{
newPos = newPos.Extend(target.Path[1], 50);
}
startPos = target.ServerPosition.Extend(newPos, -(lTarget.BoundingRadius * 0.85f));
}
else if (target.IsFacing(Player))
{
startPos = target.ServerPosition.Extend(
Player.ServerPosition, -(lTarget.BoundingRadius * 0.85f));
}
else
{
startPos = cCastPos;
}
}
if (startPos.Distance(Player.ServerPosition) > E.Range)
{
startPos = Player.ServerPosition.Extend(startPos, E.Range);
}
if (target.Path.Length > 0)
{
endPos = startPos.Extend(target.Path[0], ELength);
}
else if (target.IsFacing(Player))
{
endPos = startPos.Extend(Player.ServerPosition, ELength);
}
else
{
endPos = Player.ServerPosition.Extend(
startPos, startPos.Distance(Player.ServerPosition) + ELength);
}
hits = 1;
}
}
else
{
input2.Unit = lTarget;
var castPos = Prediction.GetPrediction(input2).CastPosition;
if (castPos.Equals(Vector3.Zero))
{
continue;
}
var circle =
new Geometry.Polygon.Circle(
Player.ServerPosition, Math.Min(E.Range, castPos.Distance(Player.ServerPosition)), 45)
.Points.Where(p => p.Distance(castPos) < ELength * 1.5f)
.Select(p => p.To3D())
.OrderBy(p => p.Distance(lTarget.ServerPosition));
foreach (var point in circle)
{
input2.From = point;
input2.RangeCheckFrom = point;
input2.Range = ELength;
var pred2 = Prediction.GetPrediction(input2);
if (pred2.Hitchance >= hitChance)
{
var count = 1;
var rect = new Geometry.Polygon.Rectangle(
point, point.Extend(pred2.CastPosition, ELength), E.Width);
foreach (var c in targets.Where(t => t.NetworkId != lTarget.NetworkId))
{
input2.Unit = c;
var cPredPos = c.Position;
if (
new Geometry.Polygon.Circle(
cPredPos, (c.IsMoving ? (c.BoundingRadius / 2f) : (c.BoundingRadius) * 0.9f))
.Points.Any(p => rect.IsInside(p)))
{
count++;
}
}
if (count > hits)
{
hits = count;
startPos = point;
endPos = startPos.Extend(pred2.CastPosition, ELength);
if (hits == targetCount)
{
break;
}
}
}
}
}
if (hits == targetCount)
{
break;
}
}
if (hits >= minHits && !startPos.Equals(Vector3.Zero) && !endPos.Equals(Vector3.Zero))
{
if (startPos.Distance(Player.ServerPosition) > E.Range)
{
startPos = Player.ServerPosition.Extend(startPos, E.Range);
}
if (endPos.Distance(startPos) > ELength)
{
endPos = startPos.Extend(endPos, ELength);
}
E.Cast(startPos, endPos);
}
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
}
private static void OnSpells(EventArgs args)
{
if (Player.IsDead) return;
if (ultPoly != null && GetBool("rpolygon", typeof(bool)))
{
ultPoly.Draw(Color.Red);
}
if (RCombo != null && GetBool("rpolygon", typeof(bool))) Render.Circle.DrawCircle((Vector3) RCombo, 100, Color.Red, 5, true);
if (GetBool("counthitr", typeof (bool)))
{
var getresults = Mathematics.GetPositions(Player, 1125, (byte) 3, HeroManager.Enemies);
if (getresults.Count > 1)
{
var Getposition = Mathematics.SelectBest(getresults, Player);
Render.Circle.DrawCircle(Getposition, 100, Color.Red, 3, true);
}
}
Render.Circle.DrawCircle(Player.Position, 1125, Color.DarkViolet);
if (!GetBool("spellsdraw", typeof (bool))) return;
if (!GetBool("ovdrawings", typeof (bool))) return;
if (GetBool("qrange", typeof (bool)) && Q.Level > 0)
{
var color = Q.IsReady() ? Color.DodgerBlue : Color.Red;
Render.Circle.DrawCircle(Player.Position, Q.Range, color);
}
if (GetBool("wrange", typeof (bool)) && W.Level > 0)
{
var colorw = W.IsReady() ? Color.BlueViolet : Color.Red;
Render.Circle.DrawCircle(Player.Position, W.Range, colorw);
}
if (GetBool("erange", typeof (bool)) && E.Level > 0)
{
var colore = E.IsReady() ? Color.Plum : Color.Red;
Render.Circle.DrawCircle(Player.Position, E.Range, colore);
}
if (GetBool("rrange", typeof (bool)) && R.Level > 0)
{
var colorr = R.IsReady() ? Color.LawnGreen : Color.Red;
Render.Circle.DrawCircle(Player.Position, R.Range, colorr);
}
var target =
HeroManager.Enemies.Where(x => x.Distance(Player) < R.Range && !x.IsDead && x.IsValidTarget(R.Range))
.OrderBy(x => x.Distance(Player)).FirstOrDefault();
if (target == null || Player.IsDead)
{
ultPoly = null;
ultPolyExpectedPos = null;
return;
}
ultPoly = new Geometry.Polygon.Rectangle(Player.ServerPosition,
Player.ServerPosition.Extend(target.Position, 1100),
target.BoundingRadius + 20);
if (GetBool("counthitr", typeof (bool)))
{
var counts =
HeroManager.Enemies.Where(x => x.Distance(Player) < 1200 && x.IsValidTarget(1200))
.Count(h => h.NetworkId != target.NetworkId && ultPoly.IsInside(h.ServerPosition));
Drawing.DrawText(Drawing.WorldToScreen(Player.Position).X, Drawing.WorldToScreen(Player.Position).Y,
Color.Magenta, "Ult Will Hit " + counts);
}
}
private static Paths WPPolygon(Obj_AI_Hero Hero)
{
List<Vector2Time> HeroPath = Hero.GetWaypointsWithTime();
Vector2 myPath;
Paths WPPaths = new Paths();
for (var i = 0; i < HeroPath.Count() - 1; i++)
{
if (HeroPath.ElementAt<Vector2Time>(i + 1).Time <= 0.6f)
{
Geometry.Polygon.Rectangle WPRectangle = new Geometry.Polygon.Rectangle(HeroPath.ElementAt<Vector2Time>(i).Position, HeroPath.ElementAt<Vector2Time>(i + 1).Position, Hero.BoundingRadius);
Geometry.Polygon.Circle Box = new Geometry.Polygon.Circle(HeroPath.ElementAt<Vector2Time>(i).Position, Hero.BoundingRadius);
WPPaths.Add(Box.ToClipperPath());
WPPaths.Add(WPRectangle.ToClipperPath());
}
else
{
myPath = PositionAfter(Hero, 0.6f, Hero.MoveSpeed);
Geometry.Polygon.Rectangle WPRectangle = new Geometry.Polygon.Rectangle(HeroPath.ElementAt<Vector2Time>(i).Position, myPath, Hero.BoundingRadius);
Geometry.Polygon.Circle Box = new Geometry.Polygon.Circle(myPath, Hero.BoundingRadius);
WPPaths.Add(Box.ToClipperPath());
WPPaths.Add(WPRectangle.ToClipperPath());
break;
}
}
Geometry.Polygon.Circle WPFirstBox = new Geometry.Polygon.Circle(HeroPath.First<Vector2Time>().Position, Hero.BoundingRadius);
WPPaths.Add(WPFirstBox.ToClipperPath());
return WPPaths;
}
private static void AutoUlt()
{
// Hoes code below
if (GetBool("wardinsec", typeof (KeyBind))) return;
var target =
HeroManager.Enemies.Where(x => x.Distance(Player) < R.Range && !x.IsDead && x.IsValidTarget(R.Range))
.OrderBy(x => x.Distance(Player)).FirstOrDefault();
if (target == null || Player.IsDead)
{
ultPoly = null;
ultPolyExpectedPos = null;
return;
}
ultPoly = new Geometry.Polygon.Rectangle(Player.ServerPosition,
Player.ServerPosition.Extend(target.Position, 1100),
target.BoundingRadius + 10);
var counts =
HeroManager.Enemies.Where(x => x.Distance(Player) < 1100 && x.IsValidTarget(1100))
.Count(h => h.NetworkId != target.NetworkId && ultPoly.IsInside(h.ServerPosition));
if (counts >= GetValue("autoron") && R.IsReady())
{
R.Cast(target);
}
//// HyunMi code here
//var enemies = Playerpos.GetEnemiesInRange(2800);
//byte minEnemHitConstraint = (byte)Config.Item("xeminhit").GetValue<Slider>().Value;
//if (enemies.Count < minEnemHitConstraint) return;
//bool xeallowFlash = Config.Item("xeflash").GetValue<bool>();
//bool allowWard = Config.Item("xeward").GetValue<bool>();
//bool canUseWard = false, canUseFlash = false;
//if (FlashSlot.IsReady() && FlashSlot != SpellSlot.Unknown && xeallowFlash)
//{
// canUseFlash = true;
//}
////TODO: check if player has a ward and w is ready if so canUseWard == true only if AllowWard = true
}
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() - ObjectManager.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 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 = Items.GetWardSlot();
if (unit.Distance(Player) > 500)
{
RCombo = null;
}
if (W.IsReady() && R.IsReady() && Player.ServerPosition.Distance(unit.ServerPosition) < 500
&& slot != null)
{
if (!_processw &&
Player.GetSpell(SpellSlot.W).Name == "BlindMonkWOne")
{
Player.Spellbook.CastSpell(slot.SpellSlot, pos);
_lastwarr = Environment.TickCount;
}
if (Player.GetSpell(SpellSlot.W).Name == "blindmonkwtwo")
{
_lastwards = Environment.TickCount;
}
}
}
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 &&
Player.Spellbook.GetSpell(SpellSlot.W).Name == "BlindMonkWOne")
{
W.Cast(Player);
lastwcombo = Environment.TickCount;
}
if (W.IsReady() && target.Distance(Player) <= Player.AttackRange &&
Player.Spellbook.GetSpell(SpellSlot.W).Name == "blindmonkwtwo" && !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() &&
!qpred.CollisionObjects.Any() && Player.Spellbook.GetSpell(SpellSlot.Q).Name == "BlindMonkQOne" &&
(qpred.Hitchance >= HitChance.Medium || qpred.Hitchance == HitChance.Immobile ||
qpred.Hitchance == HitChance.Dashing))
{
Q.Cast(qpred.CastPosition);
_lastqc = Environment.TickCount;
}
if (Player.Spellbook.GetSpell(SpellSlot.Q).Name == "blindmonkqtwo" && Q.IsReady() &&
GetBool("useq2", typeof (bool)))
{
Utility.DelayAction.Add(GetValue("secondqdelay"), () => Q.Cast());
_lastqc = Environment.TickCount;
}
}
}
if (usee)
{
if (Environment.TickCount - _lastqc > 300 && Environment.TickCount - _laste > 300 &&
Environment.TickCount - lastwcombo > 300)
{
if (target.Distance(Player) <= E.Range &&
Player.GetSpell(SpellSlot.E).Name == "BlindMonkEOne")
{
E.Cast();
_laste = Environment.TickCount;
}
if ((Player.Distance(target) >
Player.AttackRange + Player.BoundingRadius + target.BoundingRadius + 100 ||
Environment.TickCount - _laste > 2700) && Player.GetSpell(SpellSlot.E).Name == "blindmonketwo")
{
E.Cast();
_laste = Environment.TickCount;
}
}
}
if (user && target.IsValidTarget(R.Range) && R.IsReady())
{
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)
{
Player.Spellbook.CastSpell(Smite, target);
}
#endregion
}
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.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));
}
}
/// <summary>
/// Goes ham on a target using a minion for collision, and finishing the target with an extended Q
/// </summary>
/// <param name="target">
/// The target.
/// </param>
private static void DashKillsteal(Obj_AI_Hero target)
{
var dashSpeed = Spells[SpellSlot.E].Range / (700 + player.MoveSpeed);
var targetPrediction = GetPredictionWithDelay(target, dashSpeed).To2D();
var minions = MinionManager.GetMinions(player.Position, 1000)
.Where(min => min.Distance(targetPrediction, true) < 900 * 900)
.OrderByDescending(min => min.Distance(targetPrediction, true));
foreach (Obj_AI_Base minion in minions)
{
var minionPrediction = Prediction.GetPrediction(minion, dashSpeed);
var inter = MathHelper.GetCicleLineInteraction(
minionPrediction.UnitPosition.To2D(),
targetPrediction,
player.Position.To2D(),
Spells[SpellSlot.E].Range);
var best = inter.GetBestInter(target);
if (Math.Abs(best.X) < 1)
{
return;
}
if (PositionHelper.IsSafePosition(best.To3D()))
{
Spells[SpellSlot.E].Cast(best);
}
var polygon = new Geometry.Polygon.Rectangle(
player.ServerPosition,
player.ServerPosition.Extend(minion.ServerPosition, qExtended.Range),
qExtended.Width);
if (polygon.IsInside(targetPrediction)
&& Spells[SpellSlot.Q].Cast(minion) == Spell.CastStates.SuccessfullyCasted)
{
Spells[SpellSlot.Q].LastCastAttemptT = Environment.TickCount;
}
}
}
