internal override void Execute()
{
if (Settings.UseE && !Config.Auto.AutoE.KillEnemyHeros && E.IsReady() && GameObjects.EnemyHeroes.Any(x => x.IsKillableWithE(true)))
{
E.Cast();
}
if (Settings.AttackMinion && Variables.Orbwalker.CanAttack && !GameObjects.EnemyHeroes.Any(x => x.InAutoAttackRange()))
{
var units = new List <Obj_AI_Minion>();
units.AddRange(GameObjects.EnemyMinions);
units.AddRange(GameObjects.Jungle);
var bestUnit = units.Where(x => x.IsValidTarget() && x.InAutoAttackRange()).OrderByDescending(x => x.Distance(GameObjects.Player)).FirstOrDefault();
if (bestUnit != null)
{
Variables.Orbwalker.Attack(bestUnit);
}
}
if (!Variables.Orbwalker.CanMove)
{
return;
}
if (Q.IsReady() && Settings.KeepManaForE ? GameObjects.Player.Mana - Q.Instance.SData.Mana >= 30 : true)
{
var caststate = CastStates.NotCasted;
if (Settings.UseQ)
{
caststate = Q.CastOnBestTarget();
}
if (Settings.UseQPierce && caststate == CastStates.NotCasted)
{
var target = Variables.TargetSelector.GetTarget(Q);
if (target != null)
{
var prediction = Movement.GetPrediction(new PredictionInput
{
Unit = target, Delay = Q.Delay, Radius = Q.Width, Speed = Q.Speed, Range = Q.Range
});
if (prediction.Hitchance >= HitChance.High)
{
var collision = Collision.GetCollision(new List <Vector3>
{
prediction.UnitPosition
}, SpellManager.QCollisionInput);
collision.Remove(GameObjects.Player);
collision.Remove(target);
if (collision.All(x => x.IsKillableWithQ()))
{
Q.Cast(prediction.CastPosition);
}
}
}
}
}
}
internal override void Execute()
{
if (!Variables.Orbwalker.CanMove())
{
return;
}
if (Q.IsReady() && GameObjects.Player.ManaPercent > Settings.Mana)
{
var caststate = CastStates.NotCasted;
if (Settings.UseQ)
{
caststate = Q.CastOnBestTarget();
}
if (Settings.UseQPierce && caststate == CastStates.NotCasted)
{
var target = Variables.TargetSelector.GetTarget(Q);
if (target != null)
{
var prediction = Movement.GetPrediction(new PredictionInput
{
Unit = target,
Delay = Q.Delay,
Radius = Q.Width,
Speed = Q.Speed,
Range = Q.Range
});
if (prediction.Hitchance >= HitChance.High)
{
var collision = Collision.GetCollision(new List <Vector3>
{
prediction.UnitPosition
}, SpellManager.QCollisionInput);
collision.Remove(GameObjects.Player);
collision.Remove(target);
if (collision.All(x => x.IsKillableWithQ()))
{
Q.Cast(prediction.CastPosition);
}
}
}
}
}
}
internal static List <Obj_AI_Base> GetCollision(
this PredictionOutput pred,
CollisionableObjects collisionable = CollisionableObjects.Minions)
{
var col = Collision.GetCollision(
new List <Vector3> {
pred.UnitPosition, pred.Input.Unit.Position
},
new PredictionInput
{
Delay = pred.Input.Delay, Radius = pred.Input.Radius, Speed = pred.Input.Speed,
Range = pred.Input.Range, Type = pred.Input.Type, CollisionObjects = collisionable,
From = pred.Input.From
});
col.RemoveAll(i => i.Compare(pred.Input.Unit));
return(col);
}
public static List <Obj_AI_Base> GetCollision(this Spell spell, Obj_AI_Base target, List <Vector3> to, CollisionableObjects collisionable = CollisionableObjects.Minions)
{
var col = Collision.GetCollision(
to,
new PredictionInput
{
Delay = spell.Delay,
Radius = spell.Width,
Speed = spell.Speed,
From = spell.From,
Range = spell.Range,
Type = spell.Type,
CollisionObjects = collisionable
});
col.RemoveAll(i => i.Compare(target));
return(col);
}
/// <summary>
/// Returns Calculated Prediction based off given data values.
/// </summary>
/// <param name="input">
/// <see cref="PredictionInput" /> input
/// </param>
/// <param name="ft">Add Delay</param>
/// <param name="checkCollision">Check Collision</param>
/// <returns>
/// <see cref="PredictionOutput" /> output
/// </returns>
internal static PredictionOutput GetPrediction(PredictionInput input, bool ft, bool checkCollision)
{
if (!input.Unit.LSIsValidTarget(float.MaxValue, false))
{
return(new PredictionOutput());
}
if (ft)
{
// Increase the delay due to the latency and server tick:
input.Delay += Game.Ping / 2000f + 0.06f;
if (input.AoE)
{
return(Cluster.GetAoEPrediction(input));
}
}
// Target too far away.
if (Math.Abs(input.Range - float.MaxValue) > float.Epsilon &&
input.Unit.LSDistanceSquared(input.RangeCheckFrom) > Math.Pow(input.Range * 1.5, 2))
{
return(new PredictionOutput {
Input = input
});
}
PredictionOutput result = null;
// Unit is dashing.
if (input.Unit.IsDashing())
{
result = GetDashingPrediction(input);
}
else
{
// Unit is immobile.
var remainingImmobileT = UnitIsImmobileUntil(input.Unit);
if (remainingImmobileT >= 0d)
{
result = GetImmobilePrediction(input, remainingImmobileT);
}
}
// Normal prediction
if (result == null)
{
result = GetStandardPrediction(input);
}
// Check if the unit position is in range
if (Math.Abs(input.Range - float.MaxValue) > float.Epsilon)
{
if (result.Hitchance >= HitChance.High &&
input.RangeCheckFrom.LSDistanceSquared(input.Unit.Position)
> Math.Pow(input.Range + input.RealRadius * 3 / 4, 2))
{
result.Hitchance = HitChance.Medium;
}
if (input.RangeCheckFrom.LSDistanceSquared(result.UnitPosition)
> Math.Pow(input.Range + (input.Type == SkillshotType.SkillshotCircle ? input.RealRadius : 0), 2))
{
result.Hitchance = HitChance.OutOfRange;
}
if (input.RangeCheckFrom.LSDistanceSquared(result.CastPosition) > Math.Pow(input.Range, 2) &&
result.Hitchance != HitChance.OutOfRange)
{
result.CastPosition = input.RangeCheckFrom
+ input.Range
* (result.UnitPosition - input.RangeCheckFrom).ToVector2()
.LSNormalized()
.ToVector3();
}
}
// Check for collision
if (checkCollision && input.Collision && Math.Abs(input.Speed - float.MaxValue) > float.Epsilon)
{
var positions = new List <Vector3> {
result.UnitPosition, input.Unit.Position
};
result.CollisionObjects = Collision.GetCollision(positions, input);
result.CollisionObjects.RemoveAll(x => x.Compare(input.Unit));
if (result.CollisionObjects.Count > 0)
{
result.Hitchance = HitChance.Collision;
}
}
// Calc hitchance again
if (result.Hitchance == HitChance.High)
{
result.Hitchance = GetHitChance(input);
}
return(result);
}
/// <summary>
/// Returns Calculated Prediction based off given data values.
/// </summary>
/// <param name="input">
/// <see cref="PredictionInput" /> input
/// </param>
/// <param name="ft">Add Delay</param>
/// <param name="checkCollision">Check Collision</param>
/// <returns>
/// <see cref="PredictionOutput" /> output
/// </returns>
internal static PredictionOutput GetPrediction(PredictionInput input, bool ft, bool checkCollision)
{
if (!input.Unit.IsValidTarget(float.MaxValue, false))
{
return(new PredictionOutput());
}
if (ft)
{
input.Delay += Game.Ping / 2000f + 0.05f;
if (input.AoE)
{
return(Cluster.GetAoEPrediction(input));
}
}
// Target too far away.
if (Math.Abs(input.Range - float.MaxValue) > float.Epsilon &&
input.Unit.DistanceSquared(input.RangeCheckFrom) > Math.Pow(input.Range * 1.5, 2))
{
return(new PredictionOutput {
Input = input
});
}
PredictionOutput result = null;
// Unit is dashing.
if (input.Unit.IsDashing())
{
result = GetDashingPrediction(input);
}
else
{
// Unit is immobile.
var remainingImmobileT = UnitIsImmobileUntil(input.Unit);
if (remainingImmobileT >= 0d)
{
result = GetImmobilePrediction(input, remainingImmobileT);
}
}
// Normal prediction
if (result == null)
{
result = GetStandardPrediction(input);
}
if (!((Player.Instance).Distance(input.Unit, true) < input.Range * input.Range))
{
result.Hitchance = HitChance.OutOfRange;
}
// Check for collision
if (checkCollision && input.Collision && Math.Abs(input.Speed - float.MaxValue) > float.Epsilon)
{
var positions = new List <Vector3> {
result.UnitPosition, input.Unit.Position
};
result.CollisionObjects = Collision.GetCollision(positions, input);
result.CollisionObjects.RemoveAll(x => x.Compare(input.Unit));
if (result.CollisionObjects.Count > 0)
{
result.Hitchance = HitChance.Collision;
}
}
// Calc hitchance again
if (result.Hitchance == HitChance.High)
{
result.Hitchance = GetHitChance(input);
}
return(result);
}
