public static bool SpellPrediction(Spell spell, Obj_AI_Hero target,bool collisionable)
{
//
var dist = ObjectManager.Player.Distance(target.Position);
var pos1 = LeagueSharp.Common.Prediction.GetPrediction(target, dist / spell.Speed).UnitPosition-40;
var dister = target.Position.Extend(target.GetWaypoints()[1].To3D(), target.GetWaypoints()[1].To3D().Distance(target.Position) + 50);
// var pos1 = LeagueSharp.Common.Prediction.GetPrediction(target, dist / spell.Speed).UnitPosition - 40;
var wts = Drawing.WorldToScreen(target.Position);
var wtsx = target.GetWaypoints()[1];
Drawing.DrawLine(wts[0], wts[1], wtsx[0], wtsx[1], 2f, System.Drawing.Color.Red);
var e = pos1.Distance(target.GetWaypoints()[1].To3D());
pos1.Extend(target.GetWaypoints()[1].To3D(), -e);
Render.Circle.DrawCircle(dister, 10, System.Drawing.Color.GreenYellow, 2);
Render.Circle.DrawCircle(pos1, 10, System.Drawing.Color.BlueViolet, 2);
//
var point = PointsAroundTheTarget(target.Position, target.BoundingRadius + 50).FirstOrDefault(t => t.IsWall());
if (point.X != 0 && point.Y != 0 && point.Z != 0)
{
if (MinionCollideLine(ObjectManager.Player.Position, ExtendWallpos(target, point), spell,collisionable)) return false;
Render.Circle.DrawCircle(ExtendWallpos(target, point), 10, System.Drawing.Color.Brown, 2);
spell.Cast(ExtendWallpos(target, point));
return true;
}
else
{
var range = spell.Range;
if (target.Position.Distance(ObjectManager.Player.Position) < target.GetWaypoints()[1].Distance(ObjectManager.Player.Position))
{
range -= 100;
}
if (!spell.IsInRange(target, range)) return false;
/*if (target.IsFacing(ObjectManager.Player) && target.Position.Distance(ObjectManager.Player.Position) > target.GetWaypoints()[1].Distance(ObjectManager.Player.Position))
{
if (MinionCollideLine(ObjectManager.Player.Position, target.Position, spell,collisionable)) return false;
{
Game.PrintChat("Casteando por inface");
spell.Cast(target.Position);
return true;
}
}*/
// code of dashes
if (target.IsDashing())
{
float timeforArrive=(target.Position.Distance(target.GetDashInfo().EndPos.To3D()))/target.GetDashInfo().Speed;
float grabtime =( ObjectManager.Player.Position.Distance(target.GetDashInfo().EndPos.To3D())
/ spell.Speed)+spell.Delay;
if (timeforArrive<grabtime)
{
spell.Cast(target.GetDashInfo().EndPos);
return true;
}
}
/* if (target.IsImmovable) // check for cc guys
{
if (MinionCollideLine(ObjectManager.Player.Position, target.Position, spell,collisionable)) return false;
spell.Cast(target.Position);
return true;
}*/
// if(target.IsChannelingImportantSpell())
if (target.IsWindingUp && !target.IsMelee())
{
if (MinionCollideLine(ObjectManager.Player.Position, target.Position, spell,collisionable)) return false;
spell.Cast(target.Position);
return true;
}
if (target.Position.Distance(ObjectManager.Player.Position) <= 300)
{
CastToDirection( target, spell,collisionable);
}
else
{
var oldPos = target.GetWaypoints()[0].To3D();
var h = false;
Utility.DelayAction.Add(Game.Ping + 1000, () => h = Next(target, oldPos, spell,collisionable));
return h;
}
}
return false;
}
public static bool IsCondemnable(this Obj_AI_Hero hero)
{
if (!hero.IsValidTarget(550f) || hero.HasBuffOfType(BuffType.SpellShield) ||
hero.HasBuffOfType(BuffType.SpellImmunity) || hero.IsDashing())
{
return(false);
}
//values for pred calc pP = player position; p = enemy position; pD = push distance
var pP = Heroes.Player.ServerPosition;
var p = hero.ServerPosition;
var pD = Program.ComboMenu.Item("EPushDist").GetValue <Slider>().Value;
var mode = Program.ComboMenu.Item("EMode").GetValue <StringList>().SelectedValue;
if (mode == "PRADASMART" && (p.Extend(pP, -pD).IsCollisionable() || p.Extend(pP, -pD / 2f).IsCollisionable() ||
p.Extend(pP, -pD / 3f).IsCollisionable()))
{
if (!hero.CanMove ||
(hero.IsWindingUp))
{
return(true);
}
var enemiesCount = ObjectManager.Player.CountEnemiesInRange(1200);
if (enemiesCount > 1 && enemiesCount <= 3)
{
var prediction = Program.E.GetPrediction(hero);
for (var i = 15; i < pD; i += 75)
{
var posFlags = NavMesh.GetCollisionFlags(
prediction.UnitPosition.To2D()
.Extend(
pP.To2D(),
-i)
.To3D());
if (posFlags.HasFlag(CollisionFlags.Wall) || posFlags.HasFlag(CollisionFlags.Building))
{
return(true);
}
}
return(false);
}
else
{
var hitchance = Program.ComboMenu.Item("EHitchance").GetValue <Slider>().Value;
var angle = 0.20 * hitchance;
const float travelDistance = 0.5f;
var alpha = new Vector2((float)(p.X + travelDistance * Math.Cos(Math.PI / 180 * angle)),
(float)(p.X + travelDistance * Math.Sin(Math.PI / 180 * angle)));
var beta = new Vector2((float)(p.X - travelDistance * Math.Cos(Math.PI / 180 * angle)),
(float)(p.X - travelDistance * Math.Sin(Math.PI / 180 * angle)));
for (var i = 15; i < pD; i += 100)
{
if (pP.To2D().Extend(alpha,
i)
.To3D().IsCollisionable() && pP.To2D().Extend(beta, i).To3D().IsCollisionable())
{
return(true);
}
}
return(false);
}
}
if (mode == "PRADAPERFECT" &&
(p.Extend(pP, -pD).IsCollisionable() || p.Extend(pP, -pD / 2f).IsCollisionable() ||
p.Extend(pP, -pD / 3f).IsCollisionable()))
{
if (!hero.CanMove ||
(hero.IsWindingUp))
{
return(true);
}
var hitchance = Program.ComboMenu.Item("EHitchance").GetValue <Slider>().Value;
var angle = 0.20 * hitchance;
const float travelDistance = 0.5f;
var alpha = new Vector2((float)(p.X + travelDistance * Math.Cos(Math.PI / 180 * angle)),
(float)(p.X + travelDistance * Math.Sin(Math.PI / 180 * angle)));
var beta = new Vector2((float)(p.X - travelDistance * Math.Cos(Math.PI / 180 * angle)),
(float)(p.X - travelDistance * Math.Sin(Math.PI / 180 * angle)));
for (var i = 15; i < pD; i += 100)
{
if (pP.To2D().Extend(alpha,
i)
.To3D().IsCollisionable() && pP.To2D().Extend(beta, i).To3D().IsCollisionable())
{
return(true);
}
}
return(false);
}
if (mode == "OLDPRADA")
{
if (!hero.CanMove ||
(hero.IsWindingUp))
{
return(true);
}
var hitchance = Program.ComboMenu.Item("EHitchance").GetValue <Slider>().Value;
var angle = 0.20 * hitchance;
const float travelDistance = 0.5f;
var alpha = new Vector2((float)(p.X + travelDistance * Math.Cos(Math.PI / 180 * angle)),
(float)(p.X + travelDistance * Math.Sin(Math.PI / 180 * angle)));
var beta = new Vector2((float)(p.X - travelDistance * Math.Cos(Math.PI / 180 * angle)),
(float)(p.X - travelDistance * Math.Sin(Math.PI / 180 * angle)));
for (var i = 15; i < pD; i += 100)
{
if (pP.To2D().Extend(alpha,
i)
.To3D().IsCollisionable() || pP.To2D().Extend(beta, i).To3D().IsCollisionable())
{
return(true);
}
}
return(false);
}
if (mode == "MARKSMAN")
{
var prediction = Program.E.GetPrediction(hero);
return(NavMesh.GetCollisionFlags(
prediction.UnitPosition.To2D()
.Extend(
pP.To2D(),
-pD)
.To3D()).HasFlag(CollisionFlags.Wall) ||
NavMesh.GetCollisionFlags(
prediction.UnitPosition.To2D()
.Extend(
pP.To2D(),
-pD / 2f)
.To3D()).HasFlag(CollisionFlags.Wall));
}
if (mode == "SHARPSHOOTER")
{
var prediction = Program.E.GetPrediction(hero);
for (var i = 15; i < pD; i += 100)
{
var posCF = NavMesh.GetCollisionFlags(
prediction.UnitPosition.To2D()
.Extend(
pP.To2D(),
-i)
.To3D());
if (posCF.HasFlag(CollisionFlags.Wall) || posCF.HasFlag(CollisionFlags.Building))
{
return(true);
}
}
return(false);
}
if (mode == "GOSU")
{
var prediction = Program.E.GetPrediction(hero);
for (var i = 15; i < pD; i += 75)
{
var posCF = NavMesh.GetCollisionFlags(
prediction.UnitPosition.To2D()
.Extend(
pP.To2D(),
-i)
.To3D());
if (posCF.HasFlag(CollisionFlags.Wall) || posCF.HasFlag(CollisionFlags.Building))
{
return(true);
}
}
return(false);
}
if (mode == "VHR")
{
var prediction = Program.E.GetPrediction(hero);
for (var i = 15; i < pD; i += (int)hero.BoundingRadius) //:frosty:
{
var posCF = NavMesh.GetCollisionFlags(
prediction.UnitPosition.To2D()
.Extend(
pP.To2D(),
-i)
.To3D());
if (posCF.HasFlag(CollisionFlags.Wall) || posCF.HasFlag(CollisionFlags.Building))
{
return(true);
}
}
return(false);
}
if (mode == "PRADALEGACY")
{
var prediction = Program.E.GetPrediction(hero);
for (var i = 15; i < pD; i += 75)
{
var posCF = NavMesh.GetCollisionFlags(
prediction.UnitPosition.To2D()
.Extend(
pP.To2D(),
-i)
.To3D());
if (posCF.HasFlag(CollisionFlags.Wall) || posCF.HasFlag(CollisionFlags.Building))
{
return(true);
}
}
return(false);
}
if (mode == "FASTEST" && (p.Extend(pP, -pD).IsCollisionable() || p.Extend(pP, -pD / 2f).IsCollisionable() ||
p.Extend(pP, -pD / 3f).IsCollisionable()))
{
return(true);
}
return(false);
}
internal static void OnCombo()
{
bool useQ = boolLinks["comboUseQ"].Value;
bool useE = boolLinks["comboUseE"].Value;
Obj_AI_Hero target;
if (useQ && Q.IsReady())
{
target = SimpleTs.GetTarget(Q.Range, SimpleTs.DamageType.Physical);
}
else
{
target = SimpleTs.GetTarget(E.Range * 1.2f, SimpleTs.DamageType.Physical);
}
if (target == null)
{
return;
}
// Item usage
if (boolLinks["comboUseItems"].Value)
{
if (boolLinks["itemsBotrk"].Value)
{
bool foundCutlass = Items.HasItem(3144);
bool foundBotrk = Items.HasItem(3153);
if (foundCutlass || foundBotrk)
{
if (foundCutlass || player.Health + player.GetItemDamage(target, Damage.DamageItems.Botrk) < player.MaxHealth)
{
Items.UseItem(foundCutlass ? 3144 : 3153, target);
}
}
}
}
// Spell usage
if (useQ && Q.IsReady() && !player.IsDashing())
{
Q.Cast(target);
}
if (useE && (E.IsReady() || E.Instance.State == SpellState.Surpressed))
{
// Target is not in range but has E stacks on
if (player.Distance(target, true) > Math.Pow(Orbwalking.GetRealAutoAttackRange(player), 2) && target.HasRendBuff())
{
// Get minions around
var minions = ObjectManager.Get <Obj_AI_Minion>().Where(m => m.IsValidTarget(Orbwalking.GetRealAutoAttackRange(player)));
// Check if a minion can die with the current E stacks
if (minions.Any(m => m.IsRendKillable()))
{
E.Cast(true);
}
else
{
// Check if a minion can die with one AA and E. Also, the AA minion has be be behind the player direction for a further leap
var minion = GetDashObjects(minions).FirstOrDefault(m => m.Health > player.GetAutoAttackDamage(m) && m.Health < player.GetAutoAttackDamage(m) + GetRendDamage(m, 1));
if (minion != null)
{
menu.Orbwalker.ForceTarget(minion);
}
}
}
// Target is in range and has at least the set amount of E stacks on
if (E.InRange(target.ServerPosition) && (target.IsRendKillable() || target.HasRendBuff() && target.GetRendBuff().Count >= sliderLinks["comboNumE"].Value.Value))
{
var buff = target.GetRendBuff();
// Check if the target would die from E
if (target.IsRendKillable())
{
E.Cast(true);
}
// If the target is still in range or the buff is active for longer than 0.25 seconds, if not, cast it
else if (GetRendDamage(target, buff.Count + 2) < target.Health && target.ServerPosition.Distance(player.Position, true) > Math.Pow(E.Range * 0.8, 2) || buff.EndTime - Game.Time <= 0.25)
{
E.Cast(true);
}
}
}
}
/// <summary>
/// Do the combo sequence
/// </summary>
private static void OnCombo()
{
Obj_AI_Hero target = GetEnemy(1500f);
if (Menu.Item("useEGap").GetValue <bool>() && _spells[Spells.E].IsReady())
{
Obj_AI_Base dashObject = GetBestDashObject(target);
Vector3 positionAfterE = V3E(_player.ServerPosition, dashObject.ServerPosition, 475);
if (_player.Distance(dashObject) <= _spells[Spells.E].Range &&
_player.Distance(target) > _spells[Spells.Q].Range)
{
if (Menu.Item("safetyCheck").GetValue <bool>() && positionAfterE.UnderTurret(true))
{
return;
}
_spells[Spells.E].CastOnUnit(dashObject);
}
}
if (Menu.Item("useQC").GetValue <bool>() && Menu.Item("useEC").GetValue <bool>() &&
_spells[Spells.Q].IsReady() && _spells[Spells.E].IsReady() && _spells[Spells.E].IsInRange(target) &&
V3E(_player.ServerPosition, target.ServerPosition, _spells[Spells.E].Range).To2D().Distance(target) <=
315)
{
if (Menu.Item("safetyCheck").GetValue <bool>() &&
V3E(_player.ServerPosition, target.ServerPosition, _spells[Spells.E].Range).UnderTurret(true))
{
return;
}
_spells[Spells.E].CastOnUnit(target);
Utility.DelayAction.Add(target.GetDistanceCastTime(_spells[Spells.E]), () => _spells[Spells.Q].Cast());
}
//Q Casting
if (Menu.Item("useQC").GetValue <bool>() && _spells[Spells.Q].IsReady() && target != null)
{
if (!_player.IsDashing())
{
PredictionOutput prediction = _spells[Spells.Q].GetPrediction(target);
if (prediction.Hitchance >= HitChance.Medium)
{
_spells[Spells.Q].Cast(prediction.CastPosition);
}
}
}
//Normal E cast
if (Menu.Item("useEC").GetValue <bool>() && _spells[Spells.E].IsReady() &&
_spells[Spells.E].IsInRange(target) && _player.CanDash(target))
{
if (target != null &&
V3E(_player.ServerPosition, target.ServerPosition, _spells[Spells.E].Range).UnderTurret(true))
{
return;
}
_spells[Spells.E].CastOnUnit(target);
}
if (Menu.Item("useRC").GetValue <bool>() && _spells[Spells.R].IsReady() &&
_spells[Spells.R].IsInRange(target))
{
var enemiesKnockedUp =
ObjectManager.Get <Obj_AI_Hero>()
.Where(x => x.IsValidTarget(_spells[Spells.R].Range) && x.HasBuffOfType(BuffType.Knockup));
if (enemiesKnockedUp.Count() >= Menu.Item("rCount").GetValue <Slider>().Value)
{
_spells[Spells.R].Cast();
}
else
{
if (Menu.Item("delayUltimate").GetValue <bool>() && target.IsAirborne())
{
Utility.DelayAction.Add(
(int)(AirborneTimeLeft(target) * 1000 - 200), () => _spells[Spells.R].Cast());
}
}
}
}
/// <summary>
/// Gets Predicted position for arc
/// </summary>
/// <param name="target">Target for spell</param>
/// <param name="s">Spell to cast</param>
/// <param name="avgt">Average reaction time (in ms)</param>
/// <param name="movt">Passed time from last movement change (in ms)</param>
/// <param name="hc">Predicted HitChance</param>
/// <param name="rangeCheckFrom">Position where spell will be casted from</param>
/// <returns>Predicted position and HitChance out value</returns>
public static Vector2 GetArcPrediction(Obj_AI_Hero target, Spell s, List <Vector2> path, float avgt, float movt, out HitChance hc, Vector3 rangeCheckFrom)
{
if (!blInitialized)
{
throw new InvalidOperationException("Prediction is not initalized");
}
if (target.MovImmobileTime() > 200 || target.AvgMovChangeTime() == 0 || Utility.IsImmobileTarget(target)) //if target is not moving, easy to hit
{
hc = HitChance.Immobile;
return(target.ServerPosition.To2D());
}
if (target.IsDashing())
{
return(GetDashingPrediction(target, s, out hc, rangeCheckFrom));
}
float targetDistance = rangeCheckFrom.Distance(target.ServerPosition);
float flyTime = 0f;
if (s.Speed != 0)
{
Vector2 Vt = (path[path.Count - 1] - path[0]).Normalized() * target.MoveSpeed;
Vector2 Vs = (target.ServerPosition.To2D() - rangeCheckFrom.To2D()).Normalized() * s.Speed;
Vector2 Vr = Vs - Vt;
flyTime = targetDistance / Vr.Length();
if (path.Count > 5)
{
flyTime = targetDistance / s.Speed;
}
}
float t = flyTime + s.Delay + Game.Ping / 1000f;
float distance = t * target.MoveSpeed;
hc = GetHitChance(t * 1000f, avgt, movt);
#region arc collision test
for (int i = 1; i < path.Count; i++)
{
Vector2 senderPos = ObjectManager.Player.ServerPosition.To2D();
Vector2 testPos = path[i];
float multp = (testPos.Distance(senderPos) / 875.0f);
var dianaArc = new ShineCommon.Maths.Geometry.Polygon(
ClipperWrapper.DefineArc(senderPos - new Vector2(875 / 2f, 20), testPos, (float)Math.PI * multp, 410, 200 * multp),
ClipperWrapper.DefineArc(senderPos - new Vector2(875 / 2f, 20), testPos, (float)Math.PI * multp, 410, 320 * multp));
if (!ClipperWrapper.IsOutside(dianaArc, target.ServerPosition.To2D()))
{
hc = HitChance.VeryHigh;
return(testPos);
}
}
#endregion
for (int i = 0; i < path.Count - 1; i++)
{
float d = path[i + 1].Distance(path[i]);
if (distance == d)
{
return(path[i + 1]);
}
else if (distance < d)
{
return(path[i] + distance * (path[i + 1] - path[i]).Normalized());
}
else
{
distance -= d;
}
}
hc = HitChance.Impossible;
return(path[path.Count - 1]);
}
private void Combo()
{
Obj_AI_Hero target = DrawHelper.GetBetterTarget(GetTargetRange(), TargetSelector.DamageType.Physical);
if (target == null)
{
return;
}
var data = Program.IncDamages.GetAllyData(player.NetworkId);
if (config.Item("usew", true).GetValue <bool>() && W.IsReady() && data.AnyCC)
{
W.Cast();
}
var eTarget = DrawHelper.GetBetterTarget(E.Range, TargetSelector.DamageType.Physical);
var cmbdmg = ComboDamage(target) + ItemHandler.GetItemsDamage(target);
if (config.Item("useItems").GetValue <bool>())
{
ItemHandler.UseItems(target, config, cmbdmg);
}
var dist = player.Distance(target);
if (lastR > 4000f)
{
lastR = 0f;
}
if (config.Item("useq", true).GetValue <bool>() && Q.CanCast(target) &&
dist < config.Item("useqMaxRange", true).GetValue <Slider>().Value&& !player.IsDashing())
{
if (dist < 550)
{
Q.CastIfHitchanceEquals(target, HitChance.Medium);
}
else
{
Q.CastIfHitchanceEquals(target, HitChance.High);
}
}
if (config.Item("usee", true).GetValue <bool>() && E.CanCast(eTarget) &&
dist < config.Item("useeMaxRange", true).GetValue <Slider>().Value)
{
E.Cast(eTarget);
}
if (config.Item("user", true).GetValue <bool>() && R.IsReady())
{
R.Range = rRanges[R.Level - 1];
}
if (config.Item("user", true).GetValue <bool>() && lastR.Equals(0) && !target.UnderTurret(true) &&
R.CanCast(target) &&
((qTrailOnMe && eBuff(target) && target.MoveSpeed > player.MoveSpeed && dist > 360 &&
target.HealthPercent < 60) ||
(dist < rRanges[R.Level - 1] && dist > 900 &&
target.CountAlliesInRange(2000) >= target.CountEnemiesInRange(2000) &&
cmbdmg + Environment.Hero.GetAdOverTime(player, target, 5) > target.Health &&
(target.Health > Q.GetDamage(target) || !Q.IsReady())) ||
(player.HealthPercent < 40 && target.HealthPercent < 40 && target.CountAlliesInRange(1000) == 1 &&
target.CountEnemiesInRange(1000) == 1)))
{
R.Cast(target);
lastR = System.Environment.TickCount;
}
if (config.Item("user", true).GetValue <bool>() && !lastR.Equals(0) && R.CanCast(target) &&
((cmbdmg * 1.6 + Environment.Hero.GetAdOverTime(player, target, 5) > target.Health ||
R.GetDamage(target) > target.Health ||
(qTrailOnMe && eBuff(target) && target.MoveSpeed > player.MoveSpeed && dist > 360 &&
target.HealthPercent < 60))))
{
var time = System.Environment.TickCount - lastR;
if (time > 3500f || player.Distance(target) > E.Range || cmbdmg > target.Health ||
(player.HealthPercent < 40 && target.HealthPercent < 40))
{
R.Cast(target);
lastR = 0f;
}
}
var ignitedmg = (float)player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite);
bool hasIgnite = player.Spellbook.CanUseSpell(player.GetSpellSlot("SummonerDot")) == SpellState.Ready;
if (config.Item("useIgnite").GetValue <bool>() && ignitedmg > target.Health && hasIgnite &&
!E.CanCast(target))
{
player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), target);
}
}
/// <summary>
/// Gets Predicted position while target is dashing
/// </summary>
private static Vector2 GetDashingPrediction(Obj_AI_Hero target, Spell s, out HitChance hc, Vector3 rangeCheckFrom)
{
if (target.IsDashing())
{
var dashInfo = target.GetDashInfo();
float dashPassedDistance = (Utils.TickCount - dashInfo.StartTick) / 1000f * dashInfo.Speed;
Vector2 currentDashPos = dashInfo.StartPos + (dashInfo.EndPos - dashInfo.StartPos).Normalized() * dashPassedDistance;
float targetDistance = rangeCheckFrom.To2D().Distance(currentDashPos);
float flyTime = 0f;
if (s.Speed != 0) //skillshot with a missile
{
Vector2 Vt = (dashInfo.Path[dashInfo.Path.Count - 1] - dashInfo.Path[0]).Normalized() * dashInfo.Speed;
Vector2 Vs = (target.ServerPosition.To2D() - rangeCheckFrom.To2D()).Normalized() * s.Speed;
Vector2 Vr = Vs - Vt;
flyTime = targetDistance / Vr.Length();
}
int dashLeftTime = dashInfo.EndTick - Utils.TickCount;
float t = flyTime + s.Delay + Game.Ping / 1000f;
if (dashLeftTime >= t * 1000f)
{
float distance = t * dashInfo.Speed;
hc = HitChance.Dashing;
for (int i = 0; i < dashInfo.Path.Count - 1; i++)
{
float d = dashInfo.Path[i + 1].Distance(dashInfo.Path[i]);
if (distance == d)
return dashInfo.Path[i + 1];
else if (distance < d)
return dashInfo.Path[i] + distance * (dashInfo.Path[i + 1] - dashInfo.Path[i]).Normalized();
else distance -= d;
}
}
}
hc = HitChance.Impossible;
return rangeCheckFrom.To2D();
}
public static void OnCombo(bool afterAttack = false, Obj_AI_Base afterAttackTarget = null)
{
// Item usage
if (afterAttack && afterAttackTarget is Obj_AI_Hero && Config.BoolLinks["comboUseItems"].Value)
{
ItemManager.UseBotrk(afterAttackTarget as Obj_AI_Hero);
ItemManager.UseYoumuu(afterAttackTarget);
}
// Validate spell usage
if (!Q.IsEnabled(Mode.COMBO) && !E.IsEnabled(Mode.COMBO))
{
return;
}
var target = TargetSelector.GetTarget(Q.IsEnabledAndReady(Mode.COMBO) ? Q.Range : (E.Range * 1.2f), TargetSelector.DamageType.Physical);
if (target != null)
{
// Q usage
if (Q.IsEnabledAndReady(Mode.COMBO) && !player.IsDashing())
{
Q.Cast(target);
}
// E usage
if (E.IsEnabled(Mode.COMBO) && (E.Instance.State == SpellState.Ready || E.Instance.State == SpellState.Surpressed) && target.HasRendBuff())
{
// Target is not in range but has E stacks on
if (player.Distance(target, true) > Math.Pow(Orbwalking.GetRealAutoAttackRange(target), 2))
{
// Get minions around
var minions = ObjectManager.Get <Obj_AI_Minion>().FindAll(m => m.IsValidTarget(Orbwalking.GetRealAutoAttackRange(m)));
// Check if a minion can die with the current E stacks
if (minions.Any(m => m.IsRendKillable()))
{
E.Cast(true);
}
else
{
// Check if a minion can die with one AA and E. Also, the AA minion has be be behind the player direction for a further leap
var minion = VectorHelper.GetDashObjects(minions).Find(m => m.Health > player.GetAutoAttackDamage(m) && m.Health < player.GetAutoAttackDamage(m) + Damages.GetRendDamage(m, 1));
if (minion != null)
{
Config.Menu.Orbwalker.ForceTarget(minion);
}
}
}
// Target is in range and has at least the set amount of E stacks on
else if (E.IsInRange(target) &&
(target.IsRendKillable() || target.GetRendBuff().Count >= Config.SliderLinks["comboNumE"].Value.Value))
{
// Check if the target would die from E
if (target.IsRendKillable())
{
E.Cast(true);
}
else
{
// Check if target is about to leave our E range or the buff is about to run out
if (target.ServerPosition.Distance(player.ServerPosition, true) > Math.Pow(E.Range * 0.8, 2) ||
target.GetRendBuff().EndTime - Game.Time < 0.3)
{
E.Cast(true);
}
}
}
}
}
}
/// <summary>
/// Gets Predicted position for arc
/// </summary>
/// <param name="target">Target for spell</param>
/// <param name="s">Spell to cast</param>
/// <param name="avgt">Average reaction time (in ms)</param>
/// <param name="movt">Passed time from last movement change (in ms)</param>
/// <param name="hc">Predicted HitChance</param>
/// <param name="rangeCheckFrom">Position where spell will be casted from</param>
/// <returns>Predicted position and HitChance out value</returns>
public static Vector2 GetArcPrediction(Obj_AI_Hero target, Spell s, List<Vector2> path, float avgt, float movt, out HitChance hc, Vector3 rangeCheckFrom)
{
if (!blInitialized)
throw new InvalidOperationException("Prediction is not initalized");
if (target.MovImmobileTime() > 200 || target.AvgMovChangeTime() == 0 || Utility.IsImmobileTarget(target)) //if target is not moving, easy to hit
{
hc = HitChance.Immobile;
return target.ServerPosition.To2D();
}
if (target.IsDashing())
return GetDashingPrediction(target, s, out hc, rangeCheckFrom);
float targetDistance = rangeCheckFrom.Distance(target.ServerPosition);
float flyTime = 0f;
if (s.Speed != 0)
{
Vector2 Vt = (path[path.Count - 1] - path[0]).Normalized() * target.MoveSpeed;
Vector2 Vs = (target.ServerPosition.To2D() - rangeCheckFrom.To2D()).Normalized() * s.Speed;
Vector2 Vr = Vs - Vt;
flyTime = targetDistance / Vr.Length();
if (path.Count > 5)
flyTime = targetDistance / s.Speed;
}
float t = flyTime + s.Delay + Game.Ping / 1000f;
float distance = t * target.MoveSpeed;
hc = GetHitChance(t * 1000f, avgt, movt);
#region arc collision test
for (int i = 1; i < path.Count; i++)
{
Vector2 senderPos = ObjectManager.Player.ServerPosition.To2D();
Vector2 testPos = path[i];
float multp = (testPos.Distance(senderPos) / 875.0f);
var dianaArc = new ShineCommon.Maths.Geometry.Polygon(
ClipperWrapper.DefineArc(senderPos - new Vector2(875 / 2f, 20), testPos, (float)Math.PI * multp, 410, 200 * multp),
ClipperWrapper.DefineArc(senderPos - new Vector2(875 / 2f, 20), testPos, (float)Math.PI * multp, 410, 320 * multp));
if (!ClipperWrapper.IsOutside(dianaArc, target.ServerPosition.To2D()))
{
hc = HitChance.VeryHigh;
return testPos;
}
}
#endregion
for (int i = 0; i < path.Count - 1; i++)
{
float d = path[i + 1].Distance(path[i]);
if (distance == d)
return path[i + 1];
else if (distance < d)
return path[i] + distance * (path[i + 1] - path[i]).Normalized();
else distance -= d;
}
hc = HitChance.Impossible;
return path[path.Count - 1];
}
/// <summary>
/// Gets Predicted position
/// </summary>
/// <param name="target">Target for spell</param>
/// <param name="s">Spell to cast</param>
/// <param name="path">Waypoint of target</param>
/// <param name="avgt">Average reaction time (in ms)</param>
/// <param name="movt">Passed time from last movement change (in ms)</param>
/// <param name="hc">Predicted HitChance</param>
/// <param name="rangeCheckFrom">Position where spell will be casted from</param>
/// <returns>Predicted position and HitChance out value</returns>
public static Vector2 GetPrediction(Obj_AI_Hero target, Spell s, List<Vector2> path, float avgt, float movt, out HitChance hc, Vector3 rangeCheckFrom)
{
if (!blInitialized)
throw new InvalidOperationException("Prediction is not initalized");
if (target.MovImmobileTime() > 200 || target.AvgMovChangeTime() == 0 || Utility.IsImmobileTarget(target)) //if target is not moving, easy to hit
{
hc = HitChance.Immobile;
return target.ServerPosition.To2D() + target.Direction.To2D().Perpendicular() * s.Width / 2;
}
if (target.IsDashing())
return GetDashingPrediction(target, s, out hc, rangeCheckFrom);
float targetDistance = rangeCheckFrom.Distance(target.ServerPosition);
float flyTime = 0f;
if (s.Speed != 0) //skillshot with a missile
{
Vector2 Vt = (path[path.Count - 1] - path[0]).Normalized() * target.MoveSpeed;
Vector2 Vs = (target.ServerPosition.To2D() - rangeCheckFrom.To2D()).Normalized() * s.Speed;
Vector2 Vr = Vs - Vt;
flyTime = targetDistance / Vr.Length();
if (path.Count > 5) //complicated movement
flyTime = targetDistance / s.Speed;
}
float t = flyTime + s.Delay + Game.Ping / 1000f;
float distance = t * target.MoveSpeed;
//can be improved by checking area of circle
if (s.Type == SkillshotType.SkillshotCircle) //haven't tested yet.
distance -= s.Width / 2;
hc = GetHitChance(t * 1000f, avgt, movt);
for (int i = 0; i < path.Count - 1; i++)
{
float d = path[i + 1].Distance(path[i]);
if (distance == d)
return path[i + 1];
else if (distance < d)
return path[i] + distance * (path[i + 1] - path[i]).Normalized();
else distance -= d;
}
hc = HitChance.Impossible;
return path[path.Count - 1];
}
private static void OrbwalkerBestPosition(Obj_AI_Hero target)
{
if (target == null || !target.IsValid || target.IsDead || target.IsZombie || target.IsDashing())
{
Orbwalker.SetOrbwalkingPoint(Vector3.Zero);
return;
}
var BestPosition = Vector3.Zero;
float Wrange = IsWActive ? W.Range - 20 : 350;
var points = CirclePoints(target.Position, Wrange);
foreach (var point in points.Where(p => !p.IsWall()))
{
if (BestPosition == Vector3.Zero || Game.CursorPos.Distance(point) < Game.CursorPos.Distance(BestPosition))
{
BestPosition = point;
}
}
if (BestPosition == Vector3.Zero)
{
Orbwalker.SetOrbwalkingPoint(Vector3.Zero);
}
else
{
Orbwalker.SetOrbwalkingPoint(BestPosition);
}
}
private void Combo()
{
Obj_AI_Hero target = TargetSelector.GetTarget(E.Range * 2, TargetSelector.DamageType.Physical);
if (target == null)
{
return;
}
if (config.Item("selected").GetValue <bool>())
{
target = CombatHelper.SetTarget(target, TargetSelector.GetSelectedTarget());
orbwalker.ForceTarget(target);
}
if (config.Item("useItems").GetValue <bool>())
{
ItemHandler.UseItems(target, config, ComboDamage(target));
}
bool hasIgnite = player.Spellbook.CanUseSpell(player.GetSpellSlot("SummonerDot")) == SpellState.Ready;
var FuryQ = Damage.GetSpellDamage(player, target, SpellSlot.Q) * 0.5;
var FuryW = Damage.GetSpellDamage(player, target, SpellSlot.W) * 0.5;
var eDmg = Damage.GetSpellDamage(player, target, SpellSlot.E);
var combodamage = ComboDamage(target);
if (config.Item("useIgnite").GetValue <bool>() && hasIgnite &&
player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite) > target.Health)
{
player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), target);
}
if (player.Distance(target) > E.Range && E.IsReady() && (W.IsReady() || Q.IsReady()) && lastE.Equals(0) &&
config.Item("usee").GetValue <bool>())
{
var closeGapTarget =
ObjectManager.Get <Obj_AI_Base>()
.FirstOrDefault(
i =>
i.IsEnemy && player.Distance(i) < E.Range && !i.IsDead &&
i.Distance(target.ServerPosition) < E.Range);
if (closeGapTarget != null)
{
if ((canBeOpWIthQ(closeGapTarget.Position) || fury) && !rene)
{
if (E.CanCast(closeGapTarget))
{
E.Cast(closeGapTarget.Position, config.Item("packets").GetValue <bool>());
lastE = System.Environment.TickCount;
return;
}
}
}
}
if (config.Item("useq").GetValue <bool>() && Q.CanCast(target) && !renw && !player.IsDashing() &&
(!W.IsReady() ||
((W.IsReady() && !fury) || (player.Health < target.Health) ||
Environment.Minion.countMinionsInrange(player.Position, Q.Range) + player.CountEnemiesInRange(Q.Range) >
3 && fury)))
{
Q.Cast(config.Item("packets").GetValue <bool>());
}
var distance = player.Distance(target.Position);
if (config.Item("usee").GetValue <bool>() && lastE.Equals(0) && E.CanCast(target) &&
(eDmg > target.Health ||
(((W.IsReady() && canBeOpWIthQ(target.Position) && !rene) ||
(distance > target.Distance(player.Position.Extend(target.Position, E.Range)) - distance)))))
{
E.Cast(target.Position, config.Item("packets").GetValue <bool>());
lastE = System.Environment.TickCount;
return;
}
if (config.Item("usee").GetValue <bool>() && !lastE.Equals(0) &&
(eDmg + player.GetAutoAttackDamage(target) > target.Health ||
(((W.IsReady() && canBeOpWIthQ(target.Position) && !rene) ||
(distance < target.Distance(player.Position.Extend(target.Position, E.Range)) - distance) ||
player.Distance(target) > E.Range - 100))))
{
var time = System.Environment.TickCount - lastE;
if (time > 3600f || combodamage > target.Health || (player.Distance(target) > E.Range - 100))
{
E.Cast(target.Position, config.Item("packets").GetValue <bool>());
lastE = 0;
}
}
if ((player.Health * 100 / player.MaxHealth) <= config.Item("user").GetValue <Slider>().Value ||
config.Item("userindanger").GetValue <Slider>().Value < player.CountEnemiesInRange(R.Range))
{
R.Cast(config.Item("packets").GetValue <bool>());
}
}
/// <summary>
/// Gets Predicted position
/// </summary>
/// <param name="target">Target for spell</param>
/// <param name="s">Spell to cast</param>
/// <param name="path">Waypoint of target</param>
/// <param name="avgt">Average reaction time (in ms)</param>
/// <param name="movt">Passed time from last movement change (in ms)</param>
/// <param name="hc">Predicted HitChance</param>
/// <param name="rangeCheckFrom">Position where spell will be casted from</param>
/// <returns>Predicted position and HitChance out value</returns>
public static Vector2 GetPrediction(Obj_AI_Hero target, Spell s, List <Vector2> path, float avgt, float movt, out HitChance hc, Vector3 rangeCheckFrom)
{
if (!blInitialized)
{
throw new InvalidOperationException("Prediction is not initalized");
}
if (target.MovImmobileTime() > 200 || target.AvgMovChangeTime() == 0 || Utility.IsImmobileTarget(target)) //if target is not moving, easy to hit
{
hc = HitChance.Immobile;
return(target.ServerPosition.To2D() + target.Direction.To2D().Perpendicular() * s.Width / 2);
}
if (target.IsDashing())
{
return(GetDashingPrediction(target, s, out hc, rangeCheckFrom));
}
float targetDistance = rangeCheckFrom.Distance(target.ServerPosition);
float flyTime = 0f;
if (s.Speed != 0) //skillshot with a missile
{
Vector2 Vt = (path[path.Count - 1] - path[0]).Normalized() * target.MoveSpeed;
Vector2 Vs = (target.ServerPosition.To2D() - rangeCheckFrom.To2D()).Normalized() * s.Speed;
Vector2 Vr = Vs - Vt;
flyTime = targetDistance / Vr.Length();
if (path.Count > 5) //complicated movement
{
flyTime = targetDistance / s.Speed;
}
}
float t = flyTime + s.Delay + Game.Ping / 1000f;
float distance = t * target.MoveSpeed;
//can be improved by checking area of circle
if (s.Type == SkillshotType.SkillshotCircle) //haven't tested yet.
{
distance -= s.Width / 2;
}
hc = GetHitChance(t * 1000f, avgt, movt);
for (int i = 0; i < path.Count - 1; i++)
{
float d = path[i + 1].Distance(path[i]);
if (distance == d)
{
return(path[i + 1]);
}
else if (distance < d)
{
return(path[i] + distance * (path[i + 1] - path[i]).Normalized());
}
else
{
distance -= d;
}
}
hc = HitChance.Impossible;
return(path[path.Count - 1]);
}
private void Game_OnGameUpdate(EventArgs args)
{
orbwalker.SetMovement(true);
Obj_AI_Hero target = TargetSelector.GetTarget(Q.Range, TargetSelector.DamageType.Magical);
switch (orbwalker.ActiveMode)
{
case Orbwalking.OrbwalkingMode.Combo:
Combo();
break;
case Orbwalking.OrbwalkingMode.Mixed:
Harass();
break;
case Orbwalking.OrbwalkingMode.LaneClear:
Clear();
break;
case Orbwalking.OrbwalkingMode.LastHit:
LastHit();
break;
default:
break;
}
if (target == null)
{
return;
}
if (player.HasBuff("KennenShurikenStorm") &&
config.Item("Minhelath", true).GetValue <Slider>().Value > player.Health / player.MaxHealth * 100)
{
if (Items.HasItem(ItemHandler.Wooglet.Id) && Items.CanUseItem(ItemHandler.Wooglet.Id))
{
ItemHandler.Wooglet.Cast();
}
if (Items.HasItem(ItemHandler.Zhonya.Id) && Items.CanUseItem(ItemHandler.Zhonya.Id))
{
ItemHandler.Zhonya.Cast();
}
}
if (config.Item("autoq", true).GetValue <bool>())
{
if (Q.CanCast(target) && !target.IsDashing() &&
(MarkOfStorm(target) > 1 || (MarkOfStorm(target) > 0 && player.Distance(target) < W.Range)))
{
Q.Cast(target, config.Item("packets").GetValue <bool>());
}
}
if (config.Item("autow", true).GetValue <bool>() && W.IsReady() && MarkOfStorm(target) > 1)
{
if (player.Distance(target) < W.Range)
{
W.Cast(config.Item("packets").GetValue <bool>());
}
}
if (config.Item("KenAutoQ", true).GetValue <KeyBind>().Active&& Q.IsReady() &&
config.Item("KenminmanaaQ", true).GetValue <Slider>().Value < player.ManaPercent &&
orbwalker.ActiveMode != Orbwalking.OrbwalkingMode.Combo && Orbwalking.CanMove(100))
{
if (target != null && Q.CanCast(target) && target.IsValidTarget())
{
Q.CastIfHitchanceEquals(
target, CombatHelper.GetHitChance(config.Item("qHit", true).GetValue <Slider>().Value),
config.Item("packets").GetValue <bool>());
}
}
}
private static void Combo()
{
var useQ = _config.Item("UseQC").GetValue <bool>();
var useW = _config.Item("UseWC").GetValue <bool>();
if (useQ && !HavePassivee && !_player.IsDashing())
{
var t = TargetSelector.GetTarget(_q1.Range, TargetSelector.DamageType.Physical);
if (t.IsValidTarget(_q1.Range) && _q.IsReady() && !t.HasBuffOfType(BuffType.Invulnerability))
{
ExtendedQ();
}
else if (t.IsValidTarget(_q.Range) && _q.IsReady() && !t.HasBuffOfType(BuffType.Invulnerability))
{
CastQ();
}
}
if (useW && _w.IsReady() && !HavePassivee && !_player.IsDashing() && !_q.IsReady())
{
var t = TargetSelector.GetTarget(_w.Range, TargetSelector.DamageType.Magical);
var predW = _w.GetPrediction(t);
if (t.IsValidTarget(_w.Range) && predW.Hitchance >= HitChance.Medium && predW.CollisionObjects.Count == 0)
{
_w.Cast(t, false, true);
}
else if (t.IsValidTarget(_w2.Range) && predW.Hitchance >= HitChance.Medium)
{
_w2.Cast(t, false, true);
}
}
var useE = _config.Item("UseEC").GetValue <bool>();
if (Orbwalker.ActiveMode != Orbwalking.OrbwalkingMode.Combo)
{
return;
}
if (useE && _e.IsReady() &&
!_player.HasBuff("LucianR") && !HavePassivee)
{
var ta = TargetSelector.GetTarget(_q1.Range, TargetSelector.DamageType.Physical);
if (ta == null)
{
return;
}
if (ObjectManager.Player.Position.Extend(Game.CursorPos, 700).CountEnemiesInRange(700) <= 1)
{
if (!ta.UnderTurret() && ta.IsValidTarget(_q.Range) && !Orbwalking.InAutoAttackRange(ta))
{
_e.Cast(ObjectManager.Player.Position.Extend(Game.CursorPos, 450));
}
else if (ta.UnderTurret() && _e.IsReady() && ta.IsValidTarget(_q.Range + _e.Range))
{
if (_q.ManaCost + _e.ManaCost < _player.Mana && ta.Health < _q.GetDamage(ta))
{
_e.Cast(ObjectManager.Player.Position.Extend(Game.CursorPos, 450));
CastQ();
}
else if (ta.Health < _player.GetAutoAttackDamage(ta, true) * 2 && ta.IsValidTarget())
{
_e.Cast(ObjectManager.Player.Position.Extend(Game.CursorPos, 450));
}
}
}
}
UseItemes();
}
private void OnGapcloser(Obj_AI_Hero target, GapcloserArgs Args)
{
if (target != null && Args.EndPosition.Distance(Player) < Q.Range && Q.Ready && !target.IsDashing() &&
target.IsValidTarget(Q.Range))
{
Q.Cast(Args.EndPosition);
}
}
public static bool IsCondemnableVHRPlugin(this Obj_AI_Hero hero)
{
if (!hero.IsValidTarget(550f) || hero.HasBuffOfType(BuffType.SpellShield) ||
hero.HasBuffOfType(BuffType.SpellImmunity) || hero.IsDashing())
{
return(false);
}
//values for pred calc pP = player position; p = enemy position; pD = push distance
var pP = Heroes.Player.ServerPosition;
var p = hero.ServerPosition;
var pD = PRADAHijacker.HijackedMenu.Item("EPushDist").GetValue <Slider>().Value;
if ((p.Extend(pP, -pD).IsCollisionable() || p.Extend(pP, -pD / 2f).IsCollisionable() ||
p.Extend(pP, -pD / 3f).IsCollisionable()))
{
if (!hero.CanMove ||
(hero.IsWindingUp))
{
return(true);
}
var enemiesCount = ObjectManager.Player.CountEnemiesInRange(1200);
if (enemiesCount > 1 && enemiesCount <= 3)
{
var prediction = Program.E.GetPrediction(hero);
for (var i = 15; i < pD; i += 75)
{
var posFlags = NavMesh.GetCollisionFlags(
prediction.UnitPosition.To2D()
.Extend(
pP.To2D(),
-i)
.To3D());
if (posFlags.HasFlag(CollisionFlags.Wall) || posFlags.HasFlag(CollisionFlags.Building))
{
return(true);
}
}
return(false);
}
else
{
var hitchance = PRADAHijacker.HijackedMenu.Item("EHitchance").GetValue <Slider>().Value;
var angle = 0.20 * hitchance;
const float travelDistance = 0.5f;
var alpha = new Vector2((float)(p.X + travelDistance * Math.Cos(Math.PI / 180 * angle)),
(float)(p.X + travelDistance * Math.Sin(Math.PI / 180 * angle)));
var beta = new Vector2((float)(p.X - travelDistance * Math.Cos(Math.PI / 180 * angle)),
(float)(p.X - travelDistance * Math.Sin(Math.PI / 180 * angle)));
for (var i = 15; i < pD; i += 100)
{
if (pP.To2D().Extend(alpha,
i)
.To3D().IsCollisionable() && pP.To2D().Extend(beta, i).To3D().IsCollisionable())
{
return(true);
}
}
return(false);
}
}
return(false);
}
/// <summary>
/// Combo Function
/// </summary>
// ReSharper disable once FunctionComplexityOverflow
private void Combo()
{
var packets = menu.GetValue <bool>(YasuoMenu.MiscPacketsName); // => Packets
var target = TargetSelector.GetTarget(1200f, TargetSelector.DamageType.Physical); // => Target
var useE = menu.GetValue <bool>(YasuoMenu.ComboEName); // => Use E
// => E Function
if (useE && YasuoSpells.E.IsReady())
{
var eMode = menu.GetValue <StringList>(YasuoMenu.ComboGapcloserModeName).SelectedIndex;
// => Gapcloser Mode
var efMode = menu.GetValue <bool>(YasuoMenu.ComboGapcloserFModeName); // => Gapcloser Follow Mode
// => Mouse mode
if (eMode == 0)
{
var dashData = player.GetDashData(Game.CursorPos);
if (dashData != null && dashData.Value.ObjAiBase.IsValidTarget())
{
if (Environment.TickCount - _sweepingBladeDelay > 300)
{
if (dashData.Value.Vector3.Distance(Game.CursorPos) <
Yasuo.Player.Distance(Game.CursorPos) - 100 &&
dashData.Value.Vector3.Distance(Game.CursorPos) <
Yasuo.Menu.GetValue <Slider>(YasuoMenu.ComboERangeName).Value)
{
YasuoSpells.E.Cast(dashData.Value.ObjAiBase, packets);
DashingEnd = player.GetDashingEnd(dashData.Value.ObjAiBase);
_sweepingBladeDelay = LastSweepingBladeTick = Environment.TickCount;
}
}
}
}
else
{
// => Target mode
if (!target.IsValidTarget())
{
return;
}
if (player.Distance(target.ServerPosition) < player.GetAutoAttackRange() && efMode ||
player.Distance(target.ServerPosition) > player.GetAutoAttackRange())
{
var dashData = player.GetDashData(target.ServerPosition, target);
if (dashData != null && dashData.Value.ObjAiBase.IsValidTarget())
{
if (Environment.TickCount - _sweepingBladeDelay > 300)
{
if (dashData.Value.Vector3.Distance(target.ServerPosition) <
Yasuo.Player.Distance(target.ServerPosition) - 100 &&
dashData.Value.Vector3.Distance(target.ServerPosition) <
Yasuo.Menu.GetValue <Slider>(YasuoMenu.ComboERangeName).Value)
{
YasuoSpells.E.Cast(dashData.Value.ObjAiBase, packets);
DashingEnd = player.GetDashingEnd(dashData.Value.ObjAiBase);
_sweepingBladeDelay = LastSweepingBladeTick = Environment.TickCount;
}
}
}
}
}
}
if (!target.IsValidTarget())
{
return;
}
var useQ = menu.GetValue <bool>(YasuoMenu.ComboQName); // => Use Q
var use3Q = menu.GetValue <bool>(YasuoMenu.Combo3QName); // => Use 3rd Q
var useR = menu.GetValue <bool>(YasuoMenu.ComboRName); // => Use R
// => Q Function
if (useQ && !player.HasWhirlwind() && YasuoSpells.Q.QStage0.IsReady())
{
// => Dashing
if (player.IsDashing())
{
// => Prediction Distance
if (player.Distance(target.ServerPosition) < YasuoSpells.Q.DashingRange - 50f &&
DashingEnd.Distance(target.ServerPosition) < YasuoSpells.Q.DashingRange - 50f)
{
YasuoSpells.Q.QStage0.Cast(packets);
}
}
else if (Environment.TickCount - LastSweepingBladeTick > 420)
{
// => Not dashing
var targetPosition =
Prediction.GetPrediction(target, YasuoSpells.Q.QStage0.Delay, 0f, target.MoveSpeed).UnitPosition;
// => Prediction
var castPosition =
Prediction.GetPrediction(target, YasuoSpells.Q.QStage0.Delay, 0f, YasuoSpells.Q.QStage0.Speed)
.CastPosition; // => Prediction
// => Prediction Distance
if (player.Distance(targetPosition) < YasuoSpells.Q.QStage0.Range)
{
YasuoSpells.Q.QStage0.Cast(castPosition, packets);
}
}
}
// => 3Q Function
if (use3Q && player.HasWhirlwind() && YasuoSpells.Q.QStage1.IsReady())
{
// => Dashing
if (player.IsDashing())
{
// => Prediction Distance
if (player.Distance(target.ServerPosition) < YasuoSpells.Q.DashingRange - 50f &&
DashingEnd.Distance(target.ServerPosition) < YasuoSpells.Q.DashingRange - 50f)
{
YasuoSpells.Q.QStage1.Cast(packets);
}
}
else if (Environment.TickCount - LastSweepingBladeTick > 420)
{
// => Prediction
var castPosition =
Prediction.GetPrediction(target, YasuoSpells.Q.QStage1.Delay, 0f, YasuoSpells.Q.QStage1.Speed)
.CastPosition; // => Prediction
// => Prediction Distance
if (player.Distance(target.ServerPosition) < YasuoSpells.Q.QStage1.Range)
{
YasuoSpells.Q.QStage1.Cast(castPosition, packets);
}
}
}
// => R Function
if (useR && YasuoSpells.R.IsReady())
{
var rMode = menu.GetValue <StringList>(YasuoMenu.ComboRModeName).SelectedIndex; // => R Mode
var rMPercent = menu.GetValue <Slider>(YasuoMenu.ComboRPercentName).Value; // => R Min Enemies Health %
var rSPercent = menu.GetValue <Slider>(YasuoMenu.ComboRPercent2Name).Value; // => R Min Enemy Health %
var rSelfKnockup = menu.GetValue <bool>(YasuoMenu.ComboRSelfName); // => R only self knockedup enemies
var rMin = menu.GetValue <Slider>(YasuoMenu.ComboRMinName).Value; // => R Min Enemies to use
var rKnockupTime = menu.GetValue <Slider>(YasuoMenu.ComboRAirTimeName).Value; // => R Min. Airtime
var usedR = false;
if (rMode == 0 || rMode == 2)
{
var targets =
ObjectManager.Get <Obj_AI_Hero>().FindAll(t => t.IsValidTarget() && t.IsKnockedup(rSelfKnockup));
if (targets.Count() >= rMin)
{
var totalPercent = targets.Sum(t => t.Health / t.MaxHealth * 100) / targets.Count();
if (totalPercent <= rMPercent)
{
var lowestAirtime = targets.OrderBy(t => Game.Time - t.KnockupTimeLeft()).FirstOrDefault();
var formula = (float)rKnockupTime / 100;
if (lowestAirtime != null && lowestAirtime.KnockupTimeLeft() <= formula)
{
YasuoSpells.R.Cast(packets);
usedR = true;
}
}
}
}
if ((rMode == 1 || rMode == 2) && !usedR)
{
if (target.IsKnockedup(rSelfKnockup))
{
var totalPercent = target.Health / target.MaxHealth * 100;
if (totalPercent <= rSPercent)
{
var formula = (float)rKnockupTime / 1000;
if (target.KnockupTimeLeft() <= formula)
{
YasuoSpells.R.Cast(packets);
}
}
}
}
}
// => Items
if (YasuoSpells.Tiamat.GetItem().IsOwned() && menu.GetValue <bool>(YasuoMenu.ComboItemsTiamatName))
{
// => Tiamat
var item = YasuoSpells.Tiamat.GetItem();
var range = YasuoSpells.Tiamat.Range;
if (item.IsReady())
{
if (player.Distance(target) < range)
{
item.Cast();
}
}
}
else if (YasuoSpells.RavenousHydra.GetItem().IsOwned() && menu.GetValue <bool>(YasuoMenu.ComboItemsHydraName))
{
// => Hydra
var item = YasuoSpells.RavenousHydra.GetItem();
var range = YasuoSpells.RavenousHydra.Range;
if (item.IsReady())
{
if (player.Distance(target) < range)
{
item.Cast();
}
}
}
if (YasuoSpells.BilgewaterCutlass.GetItem().IsOwned() &&
menu.GetValue <bool>(YasuoMenu.ComboItemsBilgewaterName))
{
// => Bilgewater
var item = YasuoSpells.BilgewaterCutlass.GetItem();
var range = YasuoSpells.BilgewaterCutlass.Range;
if (item.IsReady())
{
if (player.Distance(target) < range)
{
item.Cast(target);
}
}
}
else if (YasuoSpells.BladeoftheRuinedKing.GetItem().IsOwned() &&
menu.GetValue <bool>(YasuoMenu.ComboItemsBotRkName))
{
// => BotRK
var item = YasuoSpells.BladeoftheRuinedKing.GetItem();
var range = YasuoSpells.BladeoftheRuinedKing.Range;
if (item.IsReady())
{
if (player.Distance(target) < range)
{
item.Cast(target);
}
}
}
}
private static void HandleQ(Obj_AI_Hero comboTarget)
{
var QPrediction = spells[SpellSlot.Q].GetPrediction(comboTarget);
if (QPrediction.Hitchance >= HitChance.High)
{
if (spells[SpellSlot.Q].GetDamage(comboTarget) > comboTarget.Health + 15 && GetItemValue <bool>("dz191.bard.combo.qks"))
{
spells[SpellSlot.Q].Cast(QPrediction.CastPosition);
return;
}
var QPushDistance = GetItemValue <Slider>("dz191.bard.misc.distance").Value;
var QAccuracy = GetItemValue <Slider>("dz191.bard.misc.accuracy").Value;
var PlayerPosition = ObjectManager.Player.ServerPosition;
var BeamStartPositions = new List <Vector3>()
{
QPrediction.CastPosition,
QPrediction.UnitPosition,
comboTarget.ServerPosition,
comboTarget.Position
};
if (comboTarget.IsDashing())
{
BeamStartPositions.Add(comboTarget.GetDashInfo().EndPos.To3D());
}
var PositionsList = new List <Vector3>();
var CollisionPositions = new List <Vector3>();
foreach (var position in BeamStartPositions)
{
var collisionableObjects = spells[SpellSlot.Q].GetCollision(position.To2D(),
new List <Vector2>()
{
position.Extend(PlayerPosition, -QPushDistance).To2D()
});
if (collisionableObjects.Any())
{
if (collisionableObjects.Any(h => h is Obj_AI_Hero) &&
(collisionableObjects.All(h => h.IsValidTarget())))
{
spells[SpellSlot.Q].Cast(QPrediction.CastPosition);
break;
}
for (var i = 0; i < QPushDistance; i += (int)comboTarget.BoundingRadius)
{
CollisionPositions.Add(position.Extend(PlayerPosition, -i));
}
}
for (var i = 0; i < QPushDistance; i += (int)comboTarget.BoundingRadius)
{
PositionsList.Add(position.Extend(PlayerPosition, -i));
}
}
if (PositionsList.Any())
{
//We don't want to divide by 0 Kappa
var WallNumber = PositionsList.Count(p => p.IsWall()) * 1.3f;
var CollisionPositionCount = CollisionPositions.Count;
var Percent = (WallNumber + CollisionPositionCount) / PositionsList.Count;
var AccuracyEx = QAccuracy / 100f;
if (Percent >= AccuracyEx)
{
spells[SpellSlot.Q].Cast(QPrediction.CastPosition);
}
}
}
else if (QPrediction.Hitchance == HitChance.Collision)
{
var QCollision = QPrediction.CollisionObjects;
if (QCollision.Count == 1)
{
spells[SpellSlot.Q].Cast(QPrediction.CastPosition);
}
}
}
private bool IsCondemnable(Obj_AI_Hero hero)
{
if (!hero.IsValidTarget(550f) || hero.HasBuffOfType(BuffType.SpellShield) ||
hero.HasBuffOfType(BuffType.SpellImmunity) || hero.IsDashing()) return false;
//values for pred calc pP = player position; p = enemy position; pD = push distance
var pP = ObjectManager.Player.ServerPosition;
var p = hero.ServerPosition;
var pD = EPushDistanceSlider.Value;
var mode = EModeStringList.SelectedValue;
if (mode == "PRADASMART" && (IsCollisionable(p.Extend(pP, -pD)) || IsCollisionable(p.Extend(pP, -pD / 2f)) ||
IsCollisionable(p.Extend(pP, -pD / 3f))))
{
if (!hero.CanMove ||
(hero.IsWindingUp))
return true;
var enemiesCount = ObjectManager.Player.CountEnemyHeroesInRange(1200);
if (enemiesCount > 1 && enemiesCount <= 3)
{
var prediction = E.GetPrediction(hero);
for (var i = 15; i < pD; i += 75)
{
if (i > pD)
{
var lastPosFlags = NavMesh.GetCollisionFlags(
prediction.UnitPosition.ToVector2()
.Extend(
pP.ToVector2(),
-pD)
.ToVector3());
if (lastPosFlags.HasFlag(CollisionFlags.Wall) || lastPosFlags.HasFlag(CollisionFlags.Building))
{
return true;
}
return false;
}
var posFlags = NavMesh.GetCollisionFlags(
prediction.UnitPosition.ToVector2()
.Extend(
pP.ToVector2(),
-i)
.ToVector3());
if (posFlags.HasFlag(CollisionFlags.Wall) || posFlags.HasFlag(CollisionFlags.Building))
{
return true;
}
}
return false;
}
else
{
var hitchance = EHitchanceSlider.Value;
var angle = 0.20 * hitchance;
const float travelDistance = 0.5f;
var alpha = new Vector2((float)(p.X + travelDistance * Math.Cos(Math.PI / 180 * angle)),
(float)(p.X + travelDistance * Math.Sin(Math.PI / 180 * angle)));
var beta = new Vector2((float)(p.X - travelDistance * Math.Cos(Math.PI / 180 * angle)),
(float)(p.X - travelDistance * Math.Sin(Math.PI / 180 * angle)));
for (var i = 15; i < pD; i += 100)
{
if (i > pD) return false;
if (IsCollisionable(pP.ToVector2().Extend(alpha,
i)
.ToVector3()) && IsCollisionable(pP.ToVector2().Extend(beta, i).ToVector3())) return true;
}
return false;
}
}
if (mode == "PRADAPERFECT" &&
(IsCollisionable(p.Extend(pP, -pD)) || IsCollisionable(p.Extend(pP, -pD / 2f)) ||
IsCollisionable(p.Extend(pP, -pD / 3f))))
{
if (!hero.CanMove ||
(hero.IsWindingUp))
return true;
var hitchance = EHitchanceSlider.Value;
var angle = 0.20 * hitchance;
const float travelDistance = 0.5f;
var alpha = new Vector2((float)(p.X + travelDistance * Math.Cos(Math.PI / 180 * angle)),
(float)(p.X + travelDistance * Math.Sin(Math.PI / 180 * angle)));
var beta = new Vector2((float)(p.X - travelDistance * Math.Cos(Math.PI / 180 * angle)),
(float)(p.X - travelDistance * Math.Sin(Math.PI / 180 * angle)));
for (var i = 15; i < pD; i += 100)
{
if (i > pD)
{
return IsCollisionable(alpha.Extend(pP.ToVector2(),
-pD)
.ToVector3()) && IsCollisionable(beta.Extend(pP.ToVector2(), -pD).ToVector3());
}
if (IsCollisionable(alpha.Extend(pP.ToVector2(),
-i)
.ToVector3()) && IsCollisionable(beta.Extend(pP.ToVector2(), -i).ToVector3())) return true;
}
return false;
}
if (mode == "OLDPRADA")
{
if (!hero.CanMove ||
(hero.IsWindingUp))
return true;
var hitchance = EHitchanceSlider.Value;
var angle = 0.20 * hitchance;
const float travelDistance = 0.5f;
var alpha = new Vector2((float)(p.X + travelDistance * Math.Cos(Math.PI / 180 * angle)),
(float)(p.X + travelDistance * Math.Sin(Math.PI / 180 * angle)));
var beta = new Vector2((float)(p.X - travelDistance * Math.Cos(Math.PI / 180 * angle)),
(float)(p.X - travelDistance * Math.Sin(Math.PI / 180 * angle)));
for (var i = 15; i < pD; i += 100)
{
if (IsCollisionable(pP.ToVector2().Extend(alpha,
i)
.ToVector3()) || IsCollisionable(pP.ToVector2().Extend(beta, i).ToVector3())) return true;
}
return false;
}
if (mode == "MARKSMAN")
{
var prediction = E.GetPrediction(hero);
return NavMesh.GetCollisionFlags(
prediction.UnitPosition.ToVector2()
.Extend(
pP.ToVector2(),
-pD)
.ToVector3()).HasFlag(CollisionFlags.Wall) ||
NavMesh.GetCollisionFlags(
prediction.UnitPosition.ToVector2()
.Extend(
pP.ToVector2(),
-pD / 2f)
.ToVector3()).HasFlag(CollisionFlags.Wall);
}
if (mode == "SHARPSHOOTER")
{
var prediction = E.GetPrediction(hero);
for (var i = 15; i < pD; i += 100)
{
if (i > pD) return false;
var posCF = NavMesh.GetCollisionFlags(
prediction.UnitPosition.ToVector2()
.Extend(
pP.ToVector2(),
-i)
.ToVector3());
if (posCF.HasFlag(CollisionFlags.Wall) || posCF.HasFlag(CollisionFlags.Building))
{
return true;
}
}
return false;
}
if (mode == "GOSU")
{
var prediction = E.GetPrediction(hero);
for (var i = 15; i < pD; i += 75)
{
var posCF = NavMesh.GetCollisionFlags(
prediction.UnitPosition.ToVector2()
.Extend(
pP.ToVector2(),
-i)
.ToVector3());
if (posCF.HasFlag(CollisionFlags.Wall) || posCF.HasFlag(CollisionFlags.Building))
{
return true;
}
}
return false;
}
if (mode == "VHR")
{
var prediction = E.GetPrediction(hero);
for (var i = 15; i < pD; i += (int)hero.BoundingRadius) //:frosty:
{
var posCF = NavMesh.GetCollisionFlags(
prediction.UnitPosition.ToVector2()
.Extend(
pP.ToVector2(),
-i)
.ToVector3());
if (posCF.HasFlag(CollisionFlags.Wall) || posCF.HasFlag(CollisionFlags.Building))
{
return true;
}
}
return false;
}
if (mode == "PRADALEGACY")
{
var prediction = E.GetPrediction(hero);
for (var i = 15; i < pD; i += 75)
{
var posCF = NavMesh.GetCollisionFlags(
prediction.UnitPosition.ToVector2()
.Extend(
pP.ToVector2(),
-i)
.ToVector3());
if (posCF.HasFlag(CollisionFlags.Wall) || posCF.HasFlag(CollisionFlags.Building))
{
return true;
}
}
return false;
}
if (mode == "FASTEST" &&
(IsCollisionable(p.Extend(pP, -pD)) || IsCollisionable(p.Extend(pP, -pD / 2f)) ||
IsCollisionable(p.Extend(pP, -pD / 3f))))
{
return true;
}
return false;
}
private void Combo()
{
Obj_AI_Hero target = getTarget();
if (target == null)
{
return;
}
if (config.Item("useItems").GetValue <bool>())
{
ItemHandler.UseItems(target, config, ComboDamage(target));
}
if (config.Item("usee", true).GetValue <bool>() && player.HasBuff("KennenLightningRush") &&
player.Health > target.Health && !target.UnderTurret(true) && target.Distance(Game.CursorPos) < 250f)
{
orbwalker.SetMovement(false);
player.IssueOrder(GameObjectOrder.MoveTo, target);
}
bool hasIgnite = player.Spellbook.CanUseSpell(player.GetSpellSlot("SummonerDot")) == SpellState.Ready;
var combodamage = ComboDamage(target);
var ignitedmg = (float)player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite);
if (config.Item("useIgnite").GetValue <bool>() && ignitedmg > target.Health && hasIgnite &&
!Q.CanCast(target) && !W.IsReady())
{
player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), target);
}
if (config.Item("useq", true).GetValue <bool>() && Q.CanCast(target) && Orbwalking.CanMove(100) &&
!target.IsDashing())
{
if (Program.IsSPrediction)
{
Q.SPredictionCast(target, HitChance.High);
}
else
{
Q.CastIfHitchanceEquals(target, HitChance.High);
}
}
if (config.Item("usew", true).GetValue <bool>() && W.IsReady())
{
if (player.HasBuff("KennenShurikenStorm"))
{
if (HeroManager.Enemies.Count(e => e.Distance(player) < R.Range && MarkOfStorm(e) > 0) ==
player.CountEnemiesInRange(R.Range))
{
W.Cast();
}
}
else if (W.Range > player.Distance(target) && MarkOfStorm(target) > 0)
{
W.Cast();
}
}
if (config.Item("usee", true).GetValue <bool>() && !target.UnderTurret(true) && E.IsReady() &&
(player.Distance(target) < 80 ||
(!player.HasBuff("KennenLightningRush") && !Q.CanCast(target) &&
config.Item("useemin", true).GetValue <Slider>().Value < player.Health / player.MaxHealth * 100 &&
MarkOfStorm(target) > 0 &&
CombatHelper.IsPossibleToReachHim(target, 1f, new float[5] {
2f, 2f, 2f, 2f, 2f
}[Q.Level - 1]))))
{
E.Cast();
}
if (R.IsReady() && !player.HasBuffOfType(BuffType.Snare) &&
(config.Item("user", true).GetValue <Slider>().Value <=
player.CountEnemiesInRange(config.Item("userrange", true).GetValue <Slider>().Value) ||
(config.Item("usertarget", true).GetValue <bool>() &&
player.CountEnemiesInRange(config.Item("userrange", true).GetValue <Slider>().Value) == 1 &&
combodamage + player.GetAutoAttackDamage(target) * 3 > target.Health && !Q.CanCast(target) &&
player.Distance(target) < config.Item("userrange", true).GetValue <Slider>().Value)) ||
(config.Item("userLow", true).GetValue <Slider>().Value <=
HeroManager.Enemies.Count(
e =>
e.IsValidTarget(config.Item("userrange", true).GetValue <Slider>().Value) &&
e.HealthPercent < 75)))
{
R.Cast();
}
}
public static bool SpellPrediction(Spell spell, Obj_AI_Hero target, bool collisionable)
{
//
var dist = ObjectManager.Player.Distance(target.Position);
var pos1 = LeagueSharp.Common.Prediction.GetPrediction(target, dist / spell.Speed).UnitPosition - 40;
var dister = target.Position.Extend(target.GetWaypoints()[1].To3D(), target.GetWaypoints()[1].To3D().Distance(target.Position) + 50);
// var pos1 = LeagueSharp.Common.Prediction.GetPrediction(target, dist / spell.Speed).UnitPosition - 40;
var wts = Drawing.WorldToScreen(target.Position);
var wtsx = target.GetWaypoints()[1];
Drawing.DrawLine(wts[0], wts[1], wtsx[0], wtsx[1], 2f, System.Drawing.Color.Red);
var e = pos1.Distance(target.GetWaypoints()[1].To3D());
pos1.Extend(target.GetWaypoints()[1].To3D(), -e);
Render.Circle.DrawCircle(dister, 10, System.Drawing.Color.GreenYellow, 2);
Render.Circle.DrawCircle(pos1, 10, System.Drawing.Color.BlueViolet, 2);
//
var point = PointsAroundTheTarget(target.Position, target.BoundingRadius + 50).FirstOrDefault(t => t.IsWall());
if (point.X != 0 && point.Y != 0 && point.Z != 0)
{
if (MinionCollideLine(ObjectManager.Player.Position, ExtendWallpos(target, point), spell, collisionable))
{
return(false);
}
Render.Circle.DrawCircle(ExtendWallpos(target, point), 10, System.Drawing.Color.Brown, 2);
spell.Cast(ExtendWallpos(target, point));
return(true);
}
else
{
var range = spell.Range;
if (target.Position.Distance(ObjectManager.Player.Position) < target.GetWaypoints()[1].Distance(ObjectManager.Player.Position))
{
range -= 100;
}
if (!spell.IsInRange(target, range))
{
return(false);
}
/*if (target.IsFacing(ObjectManager.Player) && target.Position.Distance(ObjectManager.Player.Position) > target.GetWaypoints()[1].Distance(ObjectManager.Player.Position))
* {
* if (MinionCollideLine(ObjectManager.Player.Position, target.Position, spell,collisionable)) return false;
*
* {
* Game.PrintChat("Casteando por inface");
* spell.Cast(target.Position);
*
* return true;
* }
*
* }*/
// code of dashes
if (target.IsDashing())
{
float timeforArrive = (target.Position.Distance(target.GetDashInfo().EndPos.To3D())) / target.GetDashInfo().Speed;
float grabtime = (ObjectManager.Player.Position.Distance(target.GetDashInfo().EndPos.To3D())
/ spell.Speed) + spell.Delay;
if (timeforArrive < grabtime)
{
spell.Cast(target.GetDashInfo().EndPos);
return(true);
}
}
/* if (target.IsImmovable) // check for cc guys
* {
* if (MinionCollideLine(ObjectManager.Player.Position, target.Position, spell,collisionable)) return false;
* spell.Cast(target.Position);
* return true;
* }*/
// if(target.IsChannelingImportantSpell())
if (target.IsWindingUp && !target.IsMelee())
{
if (MinionCollideLine(ObjectManager.Player.Position, target.Position, spell, collisionable))
{
return(false);
}
spell.Cast(target.Position);
return(true);
}
if (target.Position.Distance(ObjectManager.Player.Position) <= 300)
{
CastToDirection(target, spell, collisionable);
}
else
{
var oldPos = target.GetWaypoints()[0].To3D();
var h = false;
Utility.DelayAction.Add(Game.Ping + 1000, () => h = Next(target, oldPos, spell, collisionable));
return(h);
}
}
return(false);
}
private void Game_OnGameUpdate(EventArgs args)
{
orbwalker.SetMovement(true);
if (player.HasBuff("KennenLightningRush"))
{
orbwalker.SetAttack(false);
}
else
{
orbwalker.SetAttack(true);
}
if (FpsBalancer.CheckCounter())
{
return;
}
Obj_AI_Hero target = getTarget();
switch (orbwalker.ActiveMode)
{
case Orbwalking.OrbwalkingMode.Combo:
Combo();
break;
case Orbwalking.OrbwalkingMode.Mixed:
Harass();
break;
case Orbwalking.OrbwalkingMode.LaneClear:
Clear();
break;
case Orbwalking.OrbwalkingMode.LastHit:
LastHit();
break;
default:
break;
}
if (target == null)
{
return;
}
var data = Program.IncDamages.GetAllyData(player.NetworkId);
if (data != null && player.HasBuff("KennenShurikenStorm") &&
(config.Item("Minhelath", true).GetValue <Slider>().Value > player.Health / player.MaxHealth * 100 ||
(data.IsAboutToDie && config.Item("Minhelath", true).GetValue <Slider>().Value > 0)))
{
if (Items.HasItem(ItemHandler.Wooglet.Id) && Items.CanUseItem(ItemHandler.Wooglet.Id))
{
ItemHandler.Wooglet.Cast();
}
if (Items.HasItem(ItemHandler.Zhonya.Id) && Items.CanUseItem(ItemHandler.Zhonya.Id))
{
ItemHandler.Zhonya.Cast();
}
}
if (config.Item("autoq", true).GetValue <bool>())
{
if (Q.CanCast(target) && !target.IsDashing() &&
(MarkOfStorm(target) > 1 || (MarkOfStorm(target) > 0 && player.Distance(target) < W.Range)))
{
Q.Cast(target);
}
}
if (config.Item("autow", true).GetValue <bool>() && W.IsReady() && MarkOfStorm(target) > 1 &&
!player.HasBuff("KennenShurikenStorm"))
{
if (player.Distance(target) < W.Range)
{
W.Cast();
}
}
if (config.Item("KenAutoQ", true).GetValue <KeyBind>().Active&& Q.IsReady() &&
config.Item("KenminmanaaQ", true).GetValue <Slider>().Value < player.ManaPercent &&
orbwalker.ActiveMode != Orbwalking.OrbwalkingMode.Combo && Orbwalking.CanMove(100) &&
!player.UnderTurret(true))
{
if (target != null && Q.CanCast(target) && target.IsValidTarget())
{
Q.CastIfHitchanceEquals(
target, CombatHelper.GetHitChance(config.Item("qHit", true).GetValue <Slider>().Value));
}
}
}
static void Drawing_OnDraw(EventArgs args)
{
if (!Menu.Item("switch").GetValue<Boolean>())
return;
Target = TargetSelector.GetSelectedTarget() != null ? TargetSelector.GetSelectedTarget() : Player;
var buffs = string.Empty;
foreach (var buff in Target.Buffs)
{
buffs += "\n" + buff.Name + "[Count: " + buff.Count + "/Duration: " + (buff.EndTime - Game.ClockTime).ToString("0.00") +"],";
}
var Mobs = MinionManager.GetMinions(1500, MinionTypes.All, MinionTeam.NotAlly, MinionOrderTypes.MaxHealth);
var MobsList = string.Empty;
foreach (var Mob in Mobs)
{
MobsList += "\n" + Mob.Name + "[Skinname: " + Mob.SkinName + "/HP: " + Mob.Health + " / " + Mob.MaxHealth + "(" + Mob.HealthPercent.ToString("0.0") + "%)],";
}
Render.Circle.DrawCircle(Player.Position, 1500, Color.Red, 10);
Text.text =
//"Name: " + Target.Name + NewLine +
"ChampionName: " + Target.ChampionName + NewLine +
"SkinName: " + Target.SkinName + NewLine +
//"Gold: " + Target.Gold + NewLine +
//"Level: " + Target.Level + NewLine +
"TotalAttackDamage: " + Utility.TotalAttackDamage(Target) + NewLine +
"TotalMagicalDamage: " + Utility.TotalMagicalDamage(Target) + NewLine +
"Armor: " + Target.Armor + NewLine +
"Health: " + Target.Health + " / " + Target.MaxHealth + " (" + Target.HealthPercent.ToString("0.0") + "%)" + NewLine +
"Mana: " + Target.Mana + " / " + Target.MaxMana + " (" + Target.HealthPercent.ToString("0.0") + "%)" + NewLine +
"HPRegenRate: " + Target.HPRegenRate + NewLine +
"PARRegenRate: " + Target.PARRegenRate + NewLine +
"Experience: " + Target.Experience + NewLine +
"Position: " + Target.Position + NewLine +
"ServerPosition: " + Target.ServerPosition + NewLine +
"Team: " + Target.Team + NewLine +
"NetworkId: " + Target.NetworkId + NewLine +
"MoveSpeed: " + Target.MoveSpeed + NewLine +
"AttackRange: " + Target.AttackRange + NewLine +
"RealAutoAttackRange: " + Orbwalking.GetRealAutoAttackRange(Target) + NewLine +
//"DeathDuration: " + Target.DeathDuration + NewLine +
"BoundingRadius: " + Target.BoundingRadius + NewLine +
NewLine +
"Buffs: " + buffs + NewLine +
NewLine +
"IsDead: " + Target.IsDead + NewLine +
"IsImmovable: " + Target.IsImmovable + NewLine +
"IsInvulnerable: " + Target.IsInvulnerable + NewLine +
"IsMoving: " + Target.IsMoving + NewLine +
"IsPacified: " + Target.IsPacified + NewLine +
"IsTargetable: " + Target.IsTargetable + NewLine +
"IsWindingUp: " + Target.IsWindingUp + NewLine +
"IsZombie: " + Target.IsZombie + NewLine +
"IsRecalling: " + Target.IsRecalling() + NewLine +
"IsStunned: " + Target.IsStunned + NewLine +
"IsRooted: " + Target.IsRooted + NewLine +
"IsMelee: " + Target.IsMelee() + NewLine +
"IsDashing: " + Target.IsDashing() + NewLine +
"IsAlly: " + Target.IsAlly + NewLine +
"IsCanMove: " + Orbwalking.CanMove(1) + NewLine +
"UnderTurret: " + Target.UnderTurret() + NewLine +
NewLine +
"Mobs: " + MobsList + NewLine +
NewLine +
"Game_CursorPos: " + Game.CursorPos + NewLine +
"Game_ClockTime: " + Game.ClockTime + NewLine +
"Game_Time: " + Game.Time + NewLine +
"Game_Type: " + Game.Type + NewLine +
"Game_Version: " + Game.Version + NewLine +
"Game_Region: " + Game.Region + NewLine +
"Game_IP: " + Game.IP + NewLine +
"Game_Port: " + Game.Port + NewLine +
"Game_Ping: " + Game.Ping + NewLine +
"Game_Mode: " + Game.Mode + NewLine +
"Game_MapId: " + Game.MapId + NewLine +
"Game_MapName: " + Utility.Map.GetMap().Name
;
Text.OnEndScene();
}
private static void Combo()
{
if (Q.IsReady() && Config.Item("qCombo").GetValue <bool>())
{
foreach (var enemy in HeroManager.Enemies.Where(hero => hero.IsValidTarget(Q.Range)))
{
float dZ = Player.Position.Distance(enemy.Position);
if (hCannon())
{
if (dZ <= 600)
{
Q.Cast();
}
}
else
{
if (dZ > 600)
{
Q.Cast();
}
}
}
}
if (W.IsReady() && Config.Item("wCombo").GetValue <bool>())
{
foreach (var enemyW in HeroManager.Enemies.Where(hero => hero.IsValidTarget(W.Range)))
{
if (W.GetPrediction(enemyW).Hitchance >= HitChance.Medium && !Player.IsWindingUp && !Player.IsDashing())
{
W.Cast(enemyW);
}
}
}
if (E.IsReady() && Config.Item("eCombo").GetValue <bool>())
{
foreach (var enemyE in HeroManager.Enemies.Where(hero => hero.IsValidTarget(E.Range)))
{
if (!CanMove(enemyE))
{
E.Cast(enemyE.Position, true);
}
}
}
if (R.IsReady() && Config.Item("rCombo").GetValue <bool>())
{
var rDistance = Config.Item("maxR").GetValue <Slider>().Value;
foreach (var enemyR in HeroManager.Enemies.Where(hero => CollisionCheckerino(Player, hero, R.Width) && hero.IsValidTarget(rDistance)))
{
if (!enemyR.IsZombie && enemyR.Health < R.GetDamage(enemyR))
{
R.Cast(enemyR);
}
}
}
}
private void CastR()
{
if (!R.IsReady())
{
return;
}
var target = TargetSelector.GetTarget(R.Range, TargetSelector.DamageType.Magical);
if (!target.IsValidTarget(R.Range))
{
return;
}
var minDelay = MenuService.SliderLinks["Misc_r_min_delay"].Value.Value;
var maxDelay = MenuService.SliderLinks["Misc_r_max_delay"].Value.Value;
var dashDelay = MenuService.SliderLinks["Misc_r_dash"].Value.Value;
if (_rTarget == null)
{
_rTarget = target;
}
else if (_rTarget.NetworkId != target.NetworkId)
{
var time = _rTarget.Distance(target);
if (time > 3000)
{
time = 3000;
}
_rTargetChangedWaitTime = Utils.TickCount + (int)time;
_rTarget = target;
}
if ((Player.LastCastedSpellName().ToLower() == "summonerflash" && Player.LastCastedSpellT() > Utils.TickCount - 100) || _rTarget.IsDashing())
{
_dashWaitTime = Utils.TickCount + dashDelay;
}
if (Utils.TickCount >= _rTargetChangedWaitTime &&
Utils.TickCount >= _dashWaitTime &&
Utils.TickCount >= Player.LastCastedSpellT() + minDelay)
{
if (R.GetPrediction(_rTarget).Hitchance >= HitChance.VeryHigh)
{
R.Cast(_rTarget, IsPacketCastEnabled);
}
if (R.GetPrediction(_rTarget).Hitchance >= HitChance.High && Utils.TickCount >= Player.LastCastedSpellT() + maxDelay)
{
R.Cast(_rTarget, IsPacketCastEnabled);
}
}
}
public static bool IsCondemnable(this Obj_AI_Hero hero)
{
if (!hero.IsValidTarget(550f) || hero.HasBuffOfType(BuffType.SpellShield) ||
hero.HasBuffOfType(BuffType.SpellImmunity) || hero.IsDashing())
{
return(false);
}
//values for pred calc pP = player position; p = enemy position; pD = push distance
var pP = Heroes.Player.ServerPosition;
var p = hero.ServerPosition;
var pD = Program.ComboMenu.Item("EPushDist").GetValue <Slider>().Value;
var mode = Program.ComboMenu.Item("EMode").GetValue <StringList>().SelectedValue;
if (mode == "PRADA" &&
(p.Extend(pP, -pD).IsCollisionable() || p.Extend(pP, -pD / 2f).IsCollisionable() ||
p.Extend(pP, -pD / 3f).IsCollisionable()))
{
if (!hero.CanMove ||
(hero.IsWindingUp && Program.ComboMenu.Item("EHitchance").GetValue <Slider>().Value < 100))
{
return(true);
}
if (Program.ComboMenu.Item("EHitchance").GetValue <Slider>().Value <= 85)
{
var prediction = Program.E.GetPrediction(hero);
for (var i = 15; i < pD; i += 75)
{
var posCF = NavMesh.GetCollisionFlags(
prediction.UnitPosition.To2D()
.Extend(
pP.To2D(),
-i)
.To3D());
if (posCF.HasFlag(CollisionFlags.Wall) || posCF.HasFlag(CollisionFlags.Building))
{
return(true);
}
}
return(false);
}
var eT = 0.063 + Game.Ping / 2000f + 0.06;
eT += (double)Program.ComboMenu.Item("EHitchance").GetValue <Slider>().Value *4 / 1000;
var d = hero.MoveSpeed * eT;
var pList = new List <Vector3>();
pList.Add(hero.ServerPosition);
for (var i = 0; i <= 360; i += 60)
{
var v3 = new Vector2((int)(p.X + d * Math.Cos(i)), (int)(p.Y - d * Math.Sin(i))).To3D();
pList.Add(v3.Extend(pP, -pD));
}
return(pList.All(el => el.IsCollisionable()));
}
if (mode == "MARKSMAN")
{
var prediction = Program.E.GetPrediction(hero);
return(NavMesh.GetCollisionFlags(
prediction.UnitPosition.To2D()
.Extend(
pP.To2D(),
-pD)
.To3D()).HasFlag(CollisionFlags.Wall) ||
NavMesh.GetCollisionFlags(
prediction.UnitPosition.To2D()
.Extend(
pP.To2D(),
-pD / 2f)
.To3D()).HasFlag(CollisionFlags.Wall));
}
if (mode == "GOSU")
{
var prediction = Program.E.GetPrediction(hero);
for (var i = 15; i < pD; i += 100)
{
var posCF = NavMesh.GetCollisionFlags(
prediction.UnitPosition.To2D()
.Extend(
pP.To2D(),
-i)
.To3D());
if (posCF.HasFlag(CollisionFlags.Wall) || posCF.HasFlag(CollisionFlags.Building))
{
return(true);
}
}
return(false);
}
if (mode == "SHARPSHOOTER")
{
var prediction = Program.E.GetPrediction(hero);
for (var i = 15; i < pD; i += 75)
{
var posCF = NavMesh.GetCollisionFlags(
prediction.UnitPosition.To2D()
.Extend(
pP.To2D(),
-i)
.To3D());
if (posCF.HasFlag(CollisionFlags.Wall) || posCF.HasFlag(CollisionFlags.Building))
{
return(true);
}
}
return(false);
}
if (mode == "VHREWORK")
{
var prediction = Program.E.GetPrediction(hero);
for (var i = 15; i < pD; i += (int)hero.BoundingRadius) //:frosty:
{
var posCF = NavMesh.GetCollisionFlags(
prediction.UnitPosition.To2D()
.Extend(
pP.To2D(),
-i)
.To3D());
if (posCF.HasFlag(CollisionFlags.Wall) || posCF.HasFlag(CollisionFlags.Building))
{
return(true);
}
}
return(false);
}
return(false);
}
private static void OrbwalkerBestPosition(Obj_AI_Hero target)
{
if (target == null || !target.IsValid || target.IsDead || target.IsZombie || target.IsDashing())
{
Orbwalker.SetOrbwalkingPoint(Vector3.Zero);
return;
}
var BestPosition = Vector3.Zero;
float Wrange = IsWActive ? W.Range - 20 : 350;
var points = CirclePoints(target.Position, Wrange);
foreach (var point in points.Where(p => !p.IsWall()))
{
if (BestPosition == Vector3.Zero || Game.CursorPos.Distance(point) < Game.CursorPos.Distance(BestPosition))
{
BestPosition = point;
}
}
if (BestPosition == Vector3.Zero)
{
Orbwalker.SetOrbwalkingPoint(Vector3.Zero);
}
else
{
Orbwalker.SetOrbwalkingPoint(BestPosition);
}
}
bool IsCondemnable(Obj_AI_Hero hero)
{
if (!hero.IsValidTarget(550f) || hero.HasBuffOfType(BuffType.SpellShield) ||
hero.HasBuffOfType(BuffType.SpellImmunity) || hero.IsDashing()) return false;
var pP = Heroes.Player.ServerPosition;
var pD = 425;
var prediction = E.GetPrediction(hero);
for (var i = 15; i < pD; i += 100)
{
var posCF = NavMesh.GetCollisionFlags(
prediction.UnitPosition.To2D()
.Extend(
pP.To2D(),
-i)
.To3D());
if (posCF.HasFlag(CollisionFlags.Wall) || posCF.HasFlag(CollisionFlags.Building))
{
return true;
}
}
return false;
}
private void Combo()
{
Obj_AI_Hero target = TargetSelector.GetTarget(Q.Range, TargetSelector.DamageType.Magical);
if (target == null)
{
return;
}
if (config.Item("selected", true).GetValue <bool>())
{
target = CombatHelper.SetTarget(target, TargetSelector.GetSelectedTarget());
orbwalker.ForceTarget(target);
}
if (config.Item("useItems").GetValue <bool>())
{
ItemHandler.UseItems(target, config, ComboDamage(target));
}
if (player.HasBuff("KennenLightningRush") && player.Health > target.Health && target.UnderTurret(true))
{
orbwalker.SetMovement(false);
player.IssueOrder(GameObjectOrder.MoveTo, target);
}
bool hasIgnite = player.Spellbook.CanUseSpell(player.GetSpellSlot("SummonerDot")) == SpellState.Ready;
var combodamage = ComboDamage(target);
var ignitedmg = (float)player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite);
if (config.Item("useIgnite").GetValue <bool>() && ignitedmg > target.Health && hasIgnite &&
!Q.CanCast(target) && !W.IsReady())
{
player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), target);
}
if (config.Item("useq", true).GetValue <bool>() && Q.CanCast(target) && Orbwalking.CanMove(100) &&
!target.IsDashing())
{
Q.CastIfHitchanceEquals(target, HitChance.High, config.Item("packets").GetValue <bool>());
}
if (config.Item("usew", true).GetValue <bool>() && W.IsReady() && W.Range > player.Distance(target) &&
MarkOfStorm(target) > 0)
{
W.Cast(config.Item("packets").GetValue <bool>());
}
if (config.Item("usee", true).GetValue <bool>() && !target.UnderTurret(true) && E.IsReady() &&
(player.Distance(target) < 80 ||
(!player.HasBuff("KennenLightningRush") && !Q.CanCast(target) &&
config.Item("useemin", true).GetValue <Slider>().Value < player.Health / player.MaxHealth * 100 &&
MarkOfStorm(target) > 0 &&
CombatHelper.IsPossibleToReachHim(target, 1f, new float[5] {
2f, 2f, 2f, 2f, 2f
}[Q.Level - 1]))))
{
E.Cast(config.Item("packets").GetValue <bool>());
}
if (R.IsReady() && !player.HasBuffOfType(BuffType.Snare) &&
(config.Item("user", true).GetValue <Slider>().Value <=
player.CountEnemiesInRange(config.Item("userrange", true).GetValue <Slider>().Value) ||
(config.Item("usertarget", true).GetValue <bool>() &&
combodamage + player.GetAutoAttackDamage(target) * 3 > target.Health && !Q.CanCast(target) &&
player.Distance(target) < config.Item("userrange", true).GetValue <Slider>().Value)))
{
R.Cast(config.Item("packets").GetValue <bool>());
}
}
static void Drawing_OnDraw(EventArgs args)
{
if (!Menu.Item("switch").GetValue <Boolean>())
{
return;
}
Target = Hud.SelectedUnit != null ? Hud.SelectedUnit as Obj_AI_Hero : Player;
var buffs = string.Empty;
foreach (var buff in Target.Buffs)
{
buffs += "\n" + buff.Name + "[Count: " + buff.Count + "/Duration: " + (buff.EndTime - Game.ClockTime).ToString("0.00") + "],";
}
var Mobs = MinionManager.GetMinions(1500, MinionTypes.All, MinionTeam.NotAlly, MinionOrderTypes.MaxHealth);
var MobsList = string.Empty;
foreach (var Mob in Mobs)
{
MobsList += "\n" + Mob.Name + "[BaseSkin: " + Mob.CharData.BaseSkinName + "/HP: " + Mob.Health + " / " + Mob.MaxHealth + "(" + Mob.HealthPercent.ToString("0.0") + "%)],";
}
Render.Circle.DrawCircle(Player.Position, 1500, Color.Red, 10);
Text.text =
//"Name: " + Target.Name + NewLine +
"ChampionName: " + Target.ChampionName + NewLine +
"SkinName: " + Target.SkinName + NewLine +
//"Gold: " + Target.Gold + NewLine +
//"Level: " + Target.Level + NewLine +
"TotalAttackDamage: " + Utility.TotalAttackDamage(Target) + NewLine +
"TotalMagicalDamage: " + Utility.TotalMagicalDamage(Target) + NewLine +
"Armor: " + Target.Armor + NewLine +
"Health: " + Target.Health + " / " + Target.MaxHealth + " (" + Target.HealthPercent.ToString("0.0") + "%)" + NewLine +
"Mana: " + Target.Mana + " / " + Target.MaxMana + " (" + Target.HealthPercent.ToString("0.0") + "%)" + NewLine +
"HPRegenRate: " + Target.HPRegenRate + NewLine +
"PARRegenRate: " + Target.PARRegenRate + NewLine +
"Experience: " + Target.Experience + NewLine +
"Position: " + Target.Position + NewLine +
"ServerPosition: " + Target.ServerPosition + NewLine +
"Team: " + Target.Team + NewLine +
"NetworkId: " + Target.NetworkId + NewLine +
"MoveSpeed: " + Target.MoveSpeed + NewLine +
"AttackRange: " + Target.AttackRange + NewLine +
"RealAutoAttackRange: " + Orbwalking.GetRealAutoAttackRange(Target) + NewLine +
//"DeathDuration: " + Target.DeathDuration + NewLine +
"BoundingRadius: " + Target.BoundingRadius + NewLine +
NewLine +
"Buffs: " + buffs + NewLine +
NewLine +
"IsDead: " + Target.IsDead + NewLine +
"IsImmovable: " + Target.IsImmovable + NewLine +
"IsInvulnerable: " + Target.IsInvulnerable + NewLine +
"IsMoving: " + Target.IsMoving + NewLine +
"IsPacified: " + Target.IsPacified + NewLine +
"IsTargetable: " + Target.IsTargetable + NewLine +
"IsWindingUp: " + Target.IsWindingUp + NewLine +
"IsZombie: " + Target.IsZombie + NewLine +
"IsRecalling: " + Target.IsRecalling() + NewLine +
"IsStunned: " + Target.IsStunned + NewLine +
"IsRooted: " + Target.IsRooted + NewLine +
"IsMelee: " + Target.IsMelee() + NewLine +
"IsDashing: " + Target.IsDashing() + NewLine +
"IsAlly: " + Target.IsAlly + NewLine +
"IsCanMove: " + Orbwalking.CanMove(1) + NewLine +
"UnderTurret: " + Target.UnderTurret() + NewLine +
NewLine +
"Mobs: " + MobsList + NewLine +
NewLine +
"Game_CursorPos: " + Game.CursorPos + NewLine +
"Game_ClockTime: " + Game.ClockTime + NewLine +
"Game_Time: " + Game.Time + NewLine +
"Game_Type: " + Game.Type + NewLine +
"Game_Version: " + Game.Version + NewLine +
"Game_Region: " + Game.Region + NewLine +
"Game_IP: " + Game.IP + NewLine +
"Game_Port: " + Game.Port + NewLine +
"Game_Ping: " + Game.Ping + NewLine +
"Game_Mode: " + Game.Mode + NewLine +
"Game_MapId: " + Game.MapId + NewLine +
"Game_MapName: " + Utility.Map.GetMap().Name
;
Text.OnEndScene();
}
private void Game_OnGameUpdate(EventArgs args)
{
if (Environment.TickCount < lastTick + tick)
{
return;
}
lastTick = Environment.TickCount;
SkinManager.Update();
Update();
if ((Menu.Item("Recall_block").GetValue <bool>() && Player.HasBuff("Recall")) || Player.IsWindingUp || Player.IsDashing())
{
return;
}
BushManager.Update(Orbwalker);
bool minionBlock = false;
foreach (Obj_AI_Minion minion in MinionManager.GetMinions(Player.Position, Player.AttackRange, MinionTypes.All, MinionTeam.Enemy, MinionOrderTypes.None))
{
if (HealthPrediction.GetHealthPrediction(minion, 3000) <= Damage.GetAutoAttackDamage(Player, minion, false))
{
minionBlock = true;
}
}
switch (Orbwalker.ActiveMode)
{
case Orbwalking.OrbwalkingMode.Combo:
Combo();
break;
case Orbwalking.OrbwalkingMode.Mixed:
if (!minionBlock)
{
Harass();
}
break;
default:
if (!minionBlock)
{
Auto();
}
break;
}
}
private void OnGapcloser(Obj_AI_Hero target, Cassiopeia_By_Kornis.RGap.GapcloserArgs Args)
{
if (target != null && Args.EndPosition.Distance(Player) < R.Range - 100 && R.Ready && !target.IsDashing() && target.IsValidTarget(R.Range))
{
R.Cast(Args.EndPosition);
}
}
public void HandleQ(Obj_AI_Hero comboTarget)
{
var QPrediction = Variables.Spells[SpellSlot.Q].GetPrediction(comboTarget);
if (QPrediction.Hitchance >= HitChance.High)
{
var QPushDistance = 250;
var QAccuracy = 20;
var PlayerPosition = ObjectManager.Player.ServerPosition;
var BeamStartPositions = new List<Vector3>()
{
QPrediction.CastPosition,
QPrediction.UnitPosition,
comboTarget.ServerPosition,
comboTarget.Position
};
if (comboTarget.IsDashing())
{
BeamStartPositions.Add(comboTarget.GetDashInfo().EndPos.To3D());
}
var PositionsList = new List<Vector3>();
var CollisionPositions = new List<Vector3>();
foreach (var position in BeamStartPositions)
{
var collisionableObjects = Variables.Spells[SpellSlot.Q].GetCollision(position.To2D(),
new List<Vector2>() { position.Extend(PlayerPosition, -QPushDistance).To2D() });
if (collisionableObjects.Any())
{
if (collisionableObjects.Any(h => h is Obj_AI_Hero) &&
(collisionableObjects.All(h => h.IsValidTarget())))
{
Variables.Spells[SpellSlot.Q].Cast(QPrediction.CastPosition);
break;
}
for (var i = 0; i < QPushDistance; i += (int)comboTarget.BoundingRadius)
{
CollisionPositions.Add(position.Extend(PlayerPosition, -i));
}
}
for (var i = 0; i < QPushDistance; i += (int)comboTarget.BoundingRadius)
{
PositionsList.Add(position.Extend(PlayerPosition, -i));
}
}
if (PositionsList.Any())
{
//We don't want to divide by 0 Kappa
var WallNumber = PositionsList.Count(p => p.IsWall()) * 1.3f;
var CollisionPositionCount = CollisionPositions.Count;
var Percent = (WallNumber + CollisionPositionCount) / PositionsList.Count;
var AccuracyEx = QAccuracy / 100f;
if (Percent >= AccuracyEx)
{
Variables.Spells[SpellSlot.Q].Cast(QPrediction.CastPosition);
}
}
}
else if (QPrediction.Hitchance == HitChance.Collision)
{
var QCollision = QPrediction.CollisionObjects;
if (QCollision.Count == 1)
{
Variables.Spells[SpellSlot.Q].Cast(QPrediction.CastPosition);
}
}
}
private void CastR()
{
Obj_AI_Hero target = TargetSelector.GetTarget(R.Range, TargetSelector.DamageType.Magical);
if (target == null || !target.IsValidTarget(R.Range))
{
return;
}
if (RTarget == null)
{
RTarget = target;
}
else if (RTarget.NetworkId != target.NetworkId)
{
if (RTime == 0)
{
RTime = Environment.TickCount;
}
int time = Environment.TickCount - RTime;
float distance = RTarget.Distance(target);
if (time > distance / 2.5)
{
time = 0;
RTarget = target;
}
}
if (Environment.TickCount >= RWaitTime)
{
if ((Player.LastCastedSpellName() == "summonerflash" && Player.LastCastedSpellT() > Environment.TickCount - 100) || RTarget.IsDashing())
{
RWaitTime = Environment.TickCount + SliderLinks["misc_r_dash"].Value.Value;
}
if (Player.LastCastedSpellT() < Environment.TickCount - SliderLinks["misc_r_min_delay"].Value.Value)
{
if (Player.LastCastedSpellT() < Environment.TickCount - SliderLinks["misc_r_max_delay"].Value.Value)
{
Spells.CastSkillshot(R, RTarget, HitChance.High);
}
else
{
Spells.CastSkillshot(R, RTarget);
}
}
}
}
public static void doFlyToMouse(Vector3 pos)
{
/* E use if soli dist targ < 250
* or soli dist targ < play dist targ and soli dist play > 650
*
* if palyer time to soli < soli tiem to targ
*/
var closest = getClosestSolider(pos);
var dist = Player.Distance(pos, true);
if ((closest == null || (closest.Distance(pos, true) > dist)) && W.IsReady() &&
Qdata.CooldownExpires < Game.Time && E.IsReady(200))
{
summonSolider(pos);
Player.IssueOrder(GameObjectOrder.MoveTo, Game.CursorPos);
return;
}
if (closest == null)
{
return;
}
var timeToSoli = Player.Distance(closest) / E.Speed + E.Delay;
var soliTimeToTarg = closest.Distance(pos) / Q.Speed + Q.Delay;
// if (soliTimeToTarg < timeToSoli && E.IsReady())
// E.CastOnUnit(closest);
// if (Q.IsReady() && soliTimeToTarg > timeToSoli)
// Q.Cast(pos);
//return;
var soliToTarg = closest.Distance(pos);
var playToTarg = Player.Distance(pos);
var playToSoli = Player.Distance(closest);
if (soliToTarg + 250 < playToTarg)
{
if (E.IsReady())
{
E.CastOnUnit(closest);
}
}
else
{
if (Q.IsReady())
{
Q.Cast(pos);
}
}
if (Player.IsDashing() && playToSoli < 400)
{
if (Q.IsReady())
{
Q.Cast(pos);
}
}
else if (soliToTarg >= playToTarg)
{
if (Q.IsReady())
{
Q.Cast(pos);
}
}
return;
if ((closest.Distance(pos, true) > dist - 150 * 150))
{
if (E.IsReady())
{
E.CastOnUnit(closest);
}
}
else
{
if (E.IsReady() && Q.IsReady(150))
{
E.CastOnUnit(closest);
}
if (Player.IsDashing() && Q.IsReady())
{
Q.Cast(pos);
}
}
}
private void OnGapcloser(Obj_AI_Hero target, EGap.GapcloserArgs Args)
{
if (target != null && Args.EndPosition.Distance(Player) <= 800 && E.Ready && target.IsDashing() && target.IsValidTarget(E.Range))
{
E.Cast();
}
}
private void Combo()
{
Obj_AI_Hero target = TargetSelector.GetTarget(E.Range * 2, TargetSelector.DamageType.Physical);
if (target == null)
{
return;
}
if (config.Item("useItems").GetValue <bool>())
{
ItemHandler.UseItems(target, config, ComboDamage(target));
}
bool hasIgnite = player.Spellbook.CanUseSpell(player.GetSpellSlot("SummonerDot")) == SpellState.Ready;
var FuryQ = Damage.GetSpellDamage(player, target, SpellSlot.Q) * 0.5;
var FuryW = Damage.GetSpellDamage(player, target, SpellSlot.W) * 0.5;
var eDmg = Damage.GetSpellDamage(player, target, SpellSlot.E);
var combodamage = ComboDamage(target);
if (config.Item("useIgnite").GetValue <bool>() && hasIgnite &&
player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite) > target.Health)
{
player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), target);
}
if (player.Distance(target) > E.Range && E.IsReady() && (W.IsReady() || Q.IsReady()) && lastE.Equals(0) &&
config.Item("usee", true).GetValue <bool>())
{
var closeGapTarget =
MinionManager.GetMinions(E.Range, MinionTypes.All, MinionTeam.NotAlly)
.Where(i => i.Distance(target.ServerPosition) < Q.Range - 40)
.OrderByDescending(i => Environment.Minion.countMinionsInrange(i.Position, Q.Range))
.FirstOrDefault();
if (closeGapTarget != null)
{
if ((canBeOpWIthQ(closeGapTarget.Position) || fury) && !rene)
{
if (E.CanCast(closeGapTarget))
{
E.Cast(closeGapTarget.Position, config.Item("packets").GetValue <bool>());
lastE = System.Environment.TickCount;
return;
}
}
}
}
if (config.Item("useq", true).GetValue <bool>() && Q.CanCast(target) && !renw && !player.IsDashing() &&
checkFuryMode(SpellSlot.Q, target) &&
(!W.IsReady() ||
((W.IsReady() && !fury) || (player.Health < target.Health) ||
(Environment.Minion.countMinionsInrange(player.Position, Q.Range) +
player.CountEnemiesInRange(Q.Range) > 3 && fury))))
{
Q.Cast(config.Item("packets").GetValue <bool>());
}
var distance = player.Distance(target.Position);
if (config.Item("usee", true).GetValue <bool>() && lastE.Equals(0) && E.CanCast(target) &&
(eDmg > target.Health ||
(((W.IsReady() && canBeOpWIthQ(target.Position) && !rene) ||
(distance > target.Distance(player.Position.Extend(target.Position, E.Range)) - distance)))))
{
E.Cast(target.Position, config.Item("packets").GetValue <bool>());
lastE = System.Environment.TickCount;
return;
}
if (config.Item("usee", true).GetValue <bool>() && checkFuryMode(SpellSlot.E, target) && !lastE.Equals(0) &&
(eDmg + player.GetAutoAttackDamage(target) > target.Health ||
(((W.IsReady() && canBeOpWIthQ(target.Position) && !rene) ||
(distance < target.Distance(player.Position.Extend(target.Position, E.Range)) - distance) ||
player.Distance(target) > E.Range - 100))))
{
var time = System.Environment.TickCount - lastE;
if (time > 3600f || combodamage > target.Health || (player.Distance(target) > E.Range - 100))
{
E.Cast(target.Position, config.Item("packets").GetValue <bool>());
lastE = 0;
}
}
var data = Program.IncDamages.GetAllyData(player.NetworkId);
if (((player.Health * 100 / player.MaxHealth) <= config.Item("user", true).GetValue <Slider>().Value&&
data.DamageTaken > 30) ||
config.Item("userindanger", true).GetValue <Slider>().Value < player.CountEnemiesInRange(R.Range))
{
R.Cast(config.Item("packets").GetValue <bool>());
}
}
private static void FlashR()
{
var target = TargetSelector.GetTarget(R.Range, TargetSelector.DamageType.Physical);
if (_cfg.Item("moveRFQQ").IsActive() && _cfg.Item("ActiveFR").GetValue <KeyBind>().Active)
{
_player.IssueOrder(GameObjectOrder.MoveTo, Game.CursorPos);
}
if (target.Distance(_player) <= R.Range && R.IsReady() && ObjectManager.Player.GetSpellSlot("SummonerFlash").IsReady() && !_player.IsDashing())
{
var targetQ = TargetSelector.GetTarget(R.Range, TargetSelector.DamageType.Physical);
if (target.IsValidTarget())
{
R.CastOnUnit(target);
Utility.DelayAction.Add(100, () => ObjectManager.Player.Spellbook.CastSpell(ObjectManager.Player.GetSpellSlot("SummonerFlash"), Game.CursorPos));
}
if (_cfg.Item("UseQ1RFQQ").IsActive())
{
Utility.DelayAction.Add(500, () => Q.Cast(targetQ.ServerPosition));
}
if (_cfg.Item("UseQ2RFQQ").IsActive())
{
Utility.DelayAction.Add(500, () => Q.Cast());
}
}
}
