public static Vector2 GetFirstNonWallPos(Vector2 startPos, Vector2 endPos)
{
int distance = 0;
for (int i = 0; i < Program.CondemnMenu["pushDistance"].Cast<Slider>().CurrentValue; i += 20)
{
var cell = startPos.Extend(endPos, endPos.Distance(startPos) + i).ToNavMeshCell().CollFlags;
if (cell.HasFlag(CollisionFlags.Wall) || cell.HasFlag(CollisionFlags.Building))
{
distance = i - 20;
}
}
return startPos.Extend(endPos, distance + endPos.Distance(startPos));
}
public static Vector2 GetFirstNonWallPos(Vector2 startPos, Vector2 endPos)
{
int distance = 0;
for (int i = 0; i < Manager.MenuManager.CondemnPushDistance; i += 20)
{
var cell = startPos.Extend(endPos, endPos.Distance(startPos) + i);
if (NavMesh.GetCollisionFlags(cell).HasFlag(CollisionFlags.Wall) ||
NavMesh.GetCollisionFlags(cell).HasFlag(CollisionFlags.Building))
{
distance = i - 20;
}
}
return startPos.Extend(endPos, distance + endPos.Distance(startPos));
}
public static Vector3 GetCondemnPosition(this Vector3 position)
{
var pointList = new List<Vector3>();
pointList.Add(Vector3.Zero);
for (var j = 485; j >= 50; j -= 100)
{
var offset = (int)(2 * Math.PI * j / 100);
for (var i = 0; i <= offset; i++)
{
var angle = i * Math.PI * 2 / offset;
var point =
new Vector2(
(float)(position.X + j * Math.Cos(angle)),
(float)(position.Y - j * Math.Sin(angle))).To3D();
var cP = point.Extend(position, point.Distance(position) + 50);
if (point.IsWall() && cP.Distance(point) < 425 && !cP.UnderTurret(true) && cP.Distance(position) > 325 && cP.Distance(position) < 545 &&
(cP.CountEnemiesInRange(425) <= cP.CountAlliesInRange(325)))
{
pointList.Add(cP);
}
}
}
return pointList.OrderByDescending(p=>p.Distance(position)).FirstOrDefault();
}
public static void Insec(Obj_AI_Hero target)
{
Rpos = Player.Position.To2D().Extend(target.Position.To2D(), Player.Distance(target) + 250);
if (Rpos.Distance(Player.Position) <= R.Range)
{
if (Player.Distance(Rpos.Extend(target.Position.To2D(), 700 - target.Distance(Rpos))) < E.Range && !IsWall(Rpos.To3D()) && target.IsFacing(Player))
{
R.Cast(Rpos);
}
}
}
public static bool InMiddileWall(Vector2 firstwall, Vector2 lastwall)
{
var midwall = new Vector2((firstwall.X + lastwall.X) / 2, (firstwall.Y + lastwall.Y) / 2);
var point = midwall.Extend(Game.CursorPos.To2D(), 50);
for (int i = 0; i <= 350; i = i + 10)
{
var testpoint = point.BadaoRotateAround(midwall, i);
var flags = NavMesh.GetCollisionFlags(testpoint.X, testpoint.Y);
if (!flags.HasFlag(CollisionFlags.Wall) && !flags.HasFlag(CollisionFlags.Building))
{
return false;
}
}
return true;
}
public static bool IsCondemable(this AIHeroClient unit, Vector2 pos = new Vector2())
{
if (unit.HasBuffOfType(BuffType.SpellImmunity) || unit.HasBuffOfType(BuffType.SpellShield) || LastCheck + 50 > Environment.TickCount || _Player.IsDashing()) return false;
Program.CorrectPoints = new List<Vector2>();
Program.Points = new List<Vector2>();
if (!pos.IsValid()) pos = ObjectManager.Player.Position.To2D();
int wallCount = 0;
int pushDistance = Program.CondemnMenu["pushDistance"].Cast<Slider>().CurrentValue;
for (int i = 0; i < pushDistance; i += 20)
{
var unitPos = Prediction.Position.PredictUnitPosition(unit, 250);
var cell = pos.Extend(unitPos, unitPos.Distance(pos) + i);
if (cell.ToNavMeshCell().CollFlags.HasFlag(CollisionFlags.Wall))
{
Program.CorrectPoints.Add(cell);
wallCount++;
}
else
{
Program.Points.Add(cell);
}
}
if (CheckCount >= 2 && wallCount > 2)
{
CheckCount = 0;
LastCheck = Environment.TickCount;
return true;
}
if (wallCount > 2)
{
CheckCount++;
}
else
{
CheckCount = 0;
}
LastCheck = Environment.TickCount;
return false;
}
public static bool willColide(Skillshot ss, Vector2 from, float speed, Vector2 direction, float radius)
{
Vector2 ssVel = ss.Direction.Normalized() * ss.SpellData.MissileSpeed;
Vector2 dashVel = direction * speed;
Vector2 a = ssVel - dashVel;
Vector2 realFrom = from.Extend(direction, ss.SpellData.Delay + speed);
if (!ss.IsAboutToHit((int)((dashVel.Length() / 475) * 1000) + Game.Ping + 100, ObjectManager.Player))
return false;
if (ss.IsAboutToHit(1000, ObjectManager.Player) && interCir(ss.MissilePosition, ss.MissilePosition.Extend(ss.MissilePosition + a, ss.SpellData.Range + 50), from,
radius))
return true;
return false;
}
public static bool CanStun(AIHeroClient unit, Vector2 pos)
{
if (unit.HasBuffOfType(BuffType.SpellImmunity) || unit.HasBuffOfType(BuffType.SpellShield) || Player.Instance.IsDashing()) return false;
var prediction = Prediction.Position.PredictUnitPosition(unit, 400);
var predictionsList = new List<Vector3>
{
unit.ServerPosition,
unit.Position,
prediction.To3D(),
};
var wallsFound = 0;
foreach (var position in predictionsList)
{
for (var i = 0; i < 300; i += (int) unit.BoundingRadius)
{
var cPos = pos.Extend(position, pos.Distance(position) + i).To3D();
if (cPos.IsWall())
{
wallsFound++;
break;
}
}
}
if ((wallsFound / predictionsList.Count) >= Settings.MiscSettings.StunPercent / 100f)
{
return true;
}
return false;
}
private bool IsWallStunable(Vector2 from, Vector2 to)
{
float count = from.Distance(to);
for (uint i = 0; i <= count; i += 25)
{
Vector2 pos = from.Extend(ObjectManager.Player.ServerPosition.To2D(), -i);
var colFlags = NavMesh.GetCollisionFlags(pos.X, pos.Y);
if (colFlags.HasFlag(CollisionFlags.Wall) || colFlags.HasFlag(CollisionFlags.Building))
return true;
}
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 == "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 bool IsCondemnable(EloBuddy.AIHeroClient hero)
{
if (!hero.LSIsValidTarget(550f) || hero.HasBuffOfType(EloBuddy.BuffType.SpellShield) ||
hero.HasBuffOfType(EloBuddy.BuffType.SpellImmunity) || hero.IsDashing()) return false;
//values for pred calc pP = player position; p = enemy position; pD = push distance
var pP = EloBuddy.ObjectManager.Player.ServerPosition;
var p = hero.ServerPosition;
var pD = EPushDistanceSlider;
var mode = EModeStringList;
if (mode == 1 && (IsCollisionable(p.LSExtend(pP, -pD)) || IsCollisionable(p.LSExtend(pP, -pD / 2f)) ||
IsCollisionable(p.LSExtend(pP, -pD / 3f))))
{
if (!hero.CanMove)
return true;
var enemiesCount = EloBuddy.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 = EloBuddy.NavMesh.GetCollisionFlags(
prediction.UnitPosition.ToVector2()
.Extend(
pP.ToVector2(),
-pD)
.ToVector3());
if (lastPosFlags.HasFlag(EloBuddy.CollisionFlags.Wall) || lastPosFlags.HasFlag(EloBuddy.CollisionFlags.Building))
{
return true;
}
return false;
}
var posFlags = EloBuddy.NavMesh.GetCollisionFlags(
prediction.UnitPosition.ToVector2()
.Extend(
pP.ToVector2(),
-i)
.ToVector3());
if (posFlags.HasFlag(EloBuddy.CollisionFlags.Wall) || posFlags.HasFlag(EloBuddy.CollisionFlags.Building))
{
return true;
}
}
return false;
}
else
{
var hitchance = EHitchanceSlider;
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 == 2 &&
(IsCollisionable(p.LSExtend(pP, -pD)) || IsCollisionable(p.LSExtend(pP, -pD / 2f)) ||
IsCollisionable(p.LSExtend(pP, -pD / 3f))))
{
if (!hero.CanMove ||
(hero.Spellbook.IsAutoAttacking))
return true;
var hitchance = EHitchanceSlider;
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 == 9)
{
if (!hero.CanMove ||
(hero.Spellbook.IsAutoAttacking))
return true;
var hitchance = EHitchanceSlider;
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 == 3)
{
var prediction = E.GetPrediction(hero);
return EloBuddy.NavMesh.GetCollisionFlags(
prediction.UnitPosition.ToVector2()
.Extend(
pP.ToVector2(),
-pD)
.ToVector3()).HasFlag(EloBuddy.CollisionFlags.Wall) ||
EloBuddy.NavMesh.GetCollisionFlags(
prediction.UnitPosition.ToVector2()
.Extend(
pP.ToVector2(),
-pD / 2f)
.ToVector3()).HasFlag(EloBuddy.CollisionFlags.Wall);
}
if (mode == 4)
{
var prediction = E.GetPrediction(hero);
for (var i = 15; i < pD; i += 100)
{
if (i > pD) return false;
var posCF = EloBuddy.NavMesh.GetCollisionFlags(
prediction.UnitPosition.ToVector2()
.Extend(
pP.ToVector2(),
-i)
.ToVector3());
if (posCF.HasFlag(EloBuddy.CollisionFlags.Wall) || posCF.HasFlag(EloBuddy.CollisionFlags.Building))
{
return true;
}
}
return false;
}
if (mode == 5)
{
var prediction = E.GetPrediction(hero);
for (var i = 15; i < pD; i += 75)
{
var posCF = EloBuddy.NavMesh.GetCollisionFlags(
prediction.UnitPosition.ToVector2()
.Extend(
pP.ToVector2(),
-i)
.ToVector3());
if (posCF.HasFlag(EloBuddy.CollisionFlags.Wall) || posCF.HasFlag(EloBuddy.CollisionFlags.Building))
{
return true;
}
}
return false;
}
if (mode == 6)
{
var prediction = E.GetPrediction(hero);
for (var i = 15; i < pD; i += (int)hero.BoundingRadius) //:frosty:
{
var posCF = EloBuddy.NavMesh.GetCollisionFlags(
prediction.UnitPosition.ToVector2()
.Extend(
pP.ToVector2(),
-i)
.ToVector3());
if (posCF.HasFlag(EloBuddy.CollisionFlags.Wall) || posCF.HasFlag(EloBuddy.CollisionFlags.Building))
{
return true;
}
}
return false;
}
if (mode == 7)
{
var prediction = E.GetPrediction(hero);
for (var i = 15; i < pD; i += 75)
{
var posCF = EloBuddy.NavMesh.GetCollisionFlags(
prediction.UnitPosition.ToVector2()
.Extend(
pP.ToVector2(),
-i)
.ToVector3());
if (posCF.HasFlag(EloBuddy.CollisionFlags.Wall) || posCF.HasFlag(EloBuddy.CollisionFlags.Building))
{
return true;
}
}
return false;
}
if (mode == 8 &&
(IsCollisionable(p.LSExtend(pP, -pD)) || IsCollisionable(p.LSExtend(pP, -pD / 2f)) ||
IsCollisionable(p.LSExtend(pP, -pD / 3f))))
{
return true;
}
return false;
}
private static Vector2 getEndOfMissilePosition(Vector2 basePosition, Vector2 endPosition, int dividend, out Obj_AI_Base enemyHit, Obj_AI_Base ignoreCollisionWithThisUnit = null)
{
List<Obj_AI_Base> enemiesHitByQ = new List<Obj_AI_Base>();
foreach (Obj_AI_Base enemy in EntityManager.Enemies.Where(a=>!a.IsDead && a.Distance(vel) <= Q.Range * 2))
if ((ignoreCollisionWithThisUnit == null || enemy.Name != ignoreCollisionWithThisUnit.Name) && Prediction.Position.Collision.LinearMissileCollision(enemy, basePosition, endPosition, Q.Speed, Q.Width, Q.CastDelay))
enemiesHitByQ.Add(enemy);
if (enemiesHitByQ.Count == 0)
{
enemyHit = null;
return basePosition.Extend(endPosition, (Q.Range / numQDivideTimes) * dividend);
}
else
{
enemyHit = enemiesHitByQ.OrderByDescending(a => a.Distance(basePosition)).FirstOrDefault();
return endPosition;//basePosition.Extend(endPosition, enemiesHitByQ.OrderByDescending(a => a.Distance(basePosition)).FirstOrDefault().Distance(basePosition));
}
}
private static Queue<Vector2> GeneratePath(Vector2 start, Vector2 end)
{
//return PathGenerator.GeneratePath(start.ToWorldPoint().To2D(), end.ToWorldPoint().To2D());
var d = start.Distance(end);
var path = new Queue<Vector2>();
if (d < 75)
{
path.Enqueue(end);
return path;
}
var increment = (int) d / 30; //(2 * d / FPS)
var count = 0;
for (var i = 0; i < d; i += increment)
{
if (i > d)
{
break;
}
var point = start.Extend(end, i);
if (count++ % 10 == 0)
{
point.Randomize(10, 50);
if (count % 6 == 0)
{
point.Randomize(50, 100);
}
}
path.Enqueue(point);
}
path.Enqueue(end);
return path;
}
private static void TryToEvade(List<Skillshot> HitBy, Vector2 to)
{
var dangerLevel = 0;
foreach (var skillshot in HitBy)
{
dangerLevel = Math.Max(dangerLevel, skillshot.GetValue<Slider>("DangerLevel").Value);
}
foreach (var evadeSpell in EvadeSpellDatabase.Spells)
{
if (evadeSpell.Enabled && evadeSpell.DangerLevel <= dangerLevel)
{
//SpellShields
if (evadeSpell.IsSpellShield &&
ObjectManager.Player.Spellbook.CanUseSpell(evadeSpell.Slot) == SpellState.Ready)
{
if (IsAboutToHit(ObjectManager.Player, evadeSpell.Delay))
{
ObjectManager.Player.Spellbook.CastSpell(evadeSpell.Slot, ObjectManager.Player);
}
//Let the user move freely inside the skillshot.
NoSolutionFound = true;
return;
}
//Walking
if (evadeSpell.Name == "Walking")
{
var points = Evader.GetEvadePoints();
if (points.Count > 0)
{
EvadePoint = to.Closest(points);
var nEvadePoint = EvadePoint.Extend(PlayerPosition, -100);
if (
Program.IsSafePath(
ObjectManager.Player.GetPath(nEvadePoint.To3D()).To2DList(),
Config.EvadingSecondTimeOffset, (int) ObjectManager.Player.MoveSpeed, 100).IsSafe)
{
EvadePoint = nEvadePoint;
}
Evading = true;
return;
}
}
if (evadeSpell.IsReady())
{
//MovementSpeed Buff
if (evadeSpell.IsMovementSpeedBuff)
{
var points = Evader.GetEvadePoints((int) evadeSpell.MoveSpeedTotalAmount());
if (points.Count > 0)
{
EvadePoint = to.Closest(points);
Evading = true;
if (evadeSpell.IsSummonerSpell)
{
ObjectManager.Player.Spellbook.CastSpell(
evadeSpell.Slot, ObjectManager.Player);
}
else
{
ObjectManager.Player.Spellbook.CastSpell(evadeSpell.Slot, ObjectManager.Player);
}
return;
}
}
//Dashes
if (evadeSpell.IsDash)
{
//Targetted dashes
if (evadeSpell.IsTargetted) //Lesinga W.
{
var targets = Evader.GetEvadeTargets(
evadeSpell.ValidTargets, evadeSpell.Speed, evadeSpell.Delay, evadeSpell.MaxRange,
false, false);
if (targets.Count > 0)
{
var closestTarget = Utils.Closest(targets, to);
EvadePoint = closestTarget.ServerPosition.To2D();
Evading = true;
if (evadeSpell.IsSummonerSpell)
{
ObjectManager.Player.Spellbook.CastSpell(evadeSpell.Slot, closestTarget);
}
else
{
ObjectManager.Player.Spellbook.CastSpell(evadeSpell.Slot, closestTarget);
}
return;
}
if (Utils.TickCount - LastWardJumpAttempt < 250)
{
//Let the user move freely inside the skillshot.
NoSolutionFound = true;
return;
}
if (evadeSpell.IsTargetted &&
evadeSpell.ValidTargets.Contains(SpellValidTargets.AllyWards) &&
Config.Menu.Item("WardJump" + evadeSpell.Name).GetValue<bool>())
{
var wardSlot = Items.GetWardSlot();
if (wardSlot != null)
{
var points = Evader.GetEvadePoints(evadeSpell.Speed, evadeSpell.Delay, false);
// Remove the points out of range
points.RemoveAll(
item => item.Distance(ObjectManager.Player.ServerPosition) > 600);
if (points.Count > 0)
{
//Dont dash just to the edge:
for (var i = 0; i < points.Count; i++)
{
var k =
(int)
(600 -
PlayerPosition.Distance(points[i]));
k = k - new Random(Utils.TickCount).Next(k);
var extended = points[i] +
k *
(points[i] - PlayerPosition)
.Normalized();
if (IsSafe(extended).IsSafe)
{
points[i] = extended;
}
}
var ePoint = to.Closest(points);
ObjectManager.Player.Spellbook.CastSpell(wardSlot.SpellSlot, ePoint.To3D());
LastWardJumpAttempt = Utils.TickCount;
//Let the user move freely inside the skillshot.
NoSolutionFound = true;
return;
}
}
}
}
//Skillshot type dashes.
else
{
var points = Evader.GetEvadePoints(evadeSpell.Speed, evadeSpell.Delay, false);
// Remove the points out of range
points.RemoveAll(
item => item.Distance(ObjectManager.Player.ServerPosition) > evadeSpell.MaxRange);
//If the spell has a fixed range (Vaynes Q), calculate the real dashing location. TODO: take into account walls in the future.
if (evadeSpell.FixedRange)
{
for (var i = 0; i < points.Count; i++)
{
points[i] = PlayerPosition
.Extend(points[i], evadeSpell.MaxRange);
}
for (var i = points.Count - 1; i > 0; i--)
{
if (!IsSafe(points[i]).IsSafe)
{
points.RemoveAt(i);
}
}
}
else
{
for (var i = 0; i < points.Count; i++)
{
var k =
(int)
(evadeSpell.MaxRange -
PlayerPosition.Distance(points[i]));
k -= Math.Max(RandomN.Next(k) - 100, 0);
var extended = points[i] +
k *
(points[i] - PlayerPosition)
.Normalized();
if (IsSafe(extended).IsSafe)
{
points[i] = extended;
}
}
}
if (points.Count > 0)
{
EvadePoint = to.Closest(points);
Evading = true;
if (!evadeSpell.Invert)
{
if (evadeSpell.RequiresPreMove)
{
ObjectManager.Player.SendMovePacket(EvadePoint);
var theSpell = evadeSpell;
Utility.DelayAction.Add(
Game.Ping / 2 + 100,
delegate
{
ObjectManager.Player.Spellbook.CastSpell(
theSpell.Slot, EvadePoint.To3D());
});
}
else
{
ObjectManager.Player.Spellbook.CastSpell(evadeSpell.Slot, EvadePoint.To3D());
}
}
else
{
var castPoint = PlayerPosition -
(EvadePoint - PlayerPosition);
ObjectManager.Player.Spellbook.CastSpell(evadeSpell.Slot, castPoint.To3D());
}
return;
}
}
}
//Blinks
if (evadeSpell.IsBlink)
{
//Targetted blinks
if (evadeSpell.IsTargetted)
{
var targets = Evader.GetEvadeTargets(
evadeSpell.ValidTargets, int.MaxValue, evadeSpell.Delay, evadeSpell.MaxRange, true,
false);
if (targets.Count > 0)
{
if (IsAboutToHit(ObjectManager.Player, evadeSpell.Delay))
{
var closestTarget = Utils.Closest(targets, to);
EvadePoint = closestTarget.ServerPosition.To2D();
Evading = true;
if (evadeSpell.IsSummonerSpell)
{
ObjectManager.Player.Spellbook.CastSpell(
evadeSpell.Slot, closestTarget);
}
else
{
ObjectManager.Player.Spellbook.CastSpell(evadeSpell.Slot, closestTarget);
}
}
//Let the user move freely inside the skillshot.
NoSolutionFound = true;
return;
}
if (Utils.TickCount - LastWardJumpAttempt < 250)
{
//Let the user move freely inside the skillshot.
NoSolutionFound = true;
return;
}
if (evadeSpell.IsTargetted &&
evadeSpell.ValidTargets.Contains(SpellValidTargets.AllyWards) &&
Config.Menu.Item("WardJump" + evadeSpell.Name).GetValue<bool>())
{
var wardSlot = Items.GetWardSlot();
if (wardSlot != null)
{
var points = Evader.GetEvadePoints(int.MaxValue, evadeSpell.Delay, true);
// Remove the points out of range
points.RemoveAll(
item => item.Distance(ObjectManager.Player.ServerPosition) > 600);
if (points.Count > 0)
{
//Dont blink just to the edge:
for (var i = 0; i < points.Count; i++)
{
var k =
(int)
(600 -
PlayerPosition.Distance(points[i]));
k = k - new Random(Utils.TickCount).Next(k);
var extended = points[i] +
k *
(points[i] - PlayerPosition)
.Normalized();
if (IsSafe(extended).IsSafe)
{
points[i] = extended;
}
}
var ePoint = to.Closest(points);
ObjectManager.Player.Spellbook.CastSpell(wardSlot.SpellSlot, ePoint.To3D());
LastWardJumpAttempt = Utils.TickCount;
//Let the user move freely inside the skillshot.
NoSolutionFound = true;
return;
}
}
}
}
//Skillshot type blinks.
else
{
var points = Evader.GetEvadePoints(int.MaxValue, evadeSpell.Delay, true);
// Remove the points out of range
points.RemoveAll(
item => item.Distance(ObjectManager.Player.ServerPosition) > evadeSpell.MaxRange);
//Dont blink just to the edge:
for (var i = 0; i < points.Count; i++)
{
var k =
(int)
(evadeSpell.MaxRange -
PlayerPosition.Distance(points[i]));
k = k - new Random(Utils.TickCount).Next(k);
var extended = points[i] +
k *
(points[i] - PlayerPosition).Normalized();
if (IsSafe(extended).IsSafe)
{
points[i] = extended;
}
}
if (points.Count > 0)
{
if (IsAboutToHit(ObjectManager.Player, evadeSpell.Delay))
{
EvadePoint = to.Closest(points);
Evading = true;
if (evadeSpell.IsSummonerSpell)
{
ObjectManager.Player.Spellbook.CastSpell(
evadeSpell.Slot, EvadePoint.To3D());
}
else
{
ObjectManager.Player.Spellbook.CastSpell(evadeSpell.Slot, EvadePoint.To3D());
}
}
//Let the user move freely inside the skillshot.
NoSolutionFound = true;
return;
}
}
}
//Invulnerabilities, like Fizz's E
if (evadeSpell.IsInvulnerability)
{
if (evadeSpell.IsTargetted)
{
var targets = Evader.GetEvadeTargets(
evadeSpell.ValidTargets, int.MaxValue, 0, evadeSpell.MaxRange, true, false, true);
if (targets.Count > 0)
{
if (IsAboutToHit(ObjectManager.Player, evadeSpell.Delay))
{
var closestTarget = Utils.Closest(targets, to);
EvadePoint = closestTarget.ServerPosition.To2D();
Evading = true;
ObjectManager.Player.Spellbook.CastSpell(evadeSpell.Slot, closestTarget);
}
//Let the user move freely inside the skillshot.
NoSolutionFound = true;
return;
}
}
else
{
if (IsAboutToHit(ObjectManager.Player, evadeSpell.Delay))
{
if (evadeSpell.SelfCast)
{
ObjectManager.Player.Spellbook.CastSpell(evadeSpell.Slot);
}
else
{
ObjectManager.Player.Spellbook.CastSpell(
evadeSpell.Slot, ObjectManager.Player.ServerPosition);
}
}
}
//Let the user move freely inside the skillshot.
NoSolutionFound = true;
return;
}
}
//Zhonyas
if (evadeSpell.Name == "Zhonyas" && (Items.CanUseItem("ZhonyasHourglass")))
{
if (IsAboutToHit(ObjectManager.Player, 100))
{
Items.UseItem("ZhonyasHourglass");
}
//Let the user move freely inside the skillshot.
NoSolutionFound = true;
return;
}
//Shields
if (evadeSpell.IsShield &&
ObjectManager.Player.Spellbook.CanUseSpell(evadeSpell.Slot) == SpellState.Ready)
{
if (IsAboutToHit(ObjectManager.Player, evadeSpell.Delay))
{
ObjectManager.Player.Spellbook.CastSpell(evadeSpell.Slot, ObjectManager.Player);
}
//Let the user move freely inside the skillshot.
NoSolutionFound = true;
return;
}
}
}
NoSolutionFound = true;
}
private static void InsecCombo(Vector2 pos)
{
var vTarget = SimpleTs.GetTarget(Q.Range, SimpleTs.DamageType.Magical);
if (!(vTarget.Distance(pos) <= 700)) return;
var newpos = pos.Extend(vTarget.Position.To2D(), 700);
Q.Cast(newpos, true);
E.Cast(newpos, true);
}
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;
}
public EvadeResult(EvadePlus evade, Vector2 evadePoint, Vector2 anchorPoint, int totalTimeAvailable,
int timeAvailable,
bool enoughTime)
{
Evade = evade;
PlayerPos = Player.Instance.Position.To2D();
Time = Environment.TickCount;
EvadePoint = evadePoint.Extend(PlayerPos, -70); //adjust evade range;
AnchorPoint = anchorPoint;
TotalTimeAvailable = totalTimeAvailable;
TimeAvailable = timeAvailable;
EnoughTime = enoughTime;
// fix evade pos
//if (evadePoint.IsInLineSegment(PlayerPos, anchorPoint, 40))
//{
// EvadePoint = anchorPoint;
//}
// extra evade range
if (Evade.ExtraEvadeRange > 0)
{
var newPoint = EvadePoint.Extend(PlayerPos,
-(Evade.RandomizeExtraEvadeRange
? Utils.Random.Next(Evade.ExtraEvadeRange/3, Evade.ExtraEvadeRange)
: Evade.ExtraEvadeRange));
if (Evade.IsPointSafe(newPoint))
{
EvadePoint = newPoint;
}
}
}
private static Vector2 getEndOfMissilePosition(Vector2 basePosition, Vector2 endPosition, Obj_AI_Base target, out Obj_AI_Base enemyHit)
{
if (Prediction.Position.Collision.LinearMissileCollision(target, basePosition, endPosition, Q.Speed, Q.Width, Q.CastDelay))
{
enemyHit = target;
return endPosition;
}
else
{
enemyHit = null;
return basePosition.Extend(endPosition, Q.Range);
}
}
/// <summary>
/// Gets collided units & flags
/// </summary>
/// <param name="from">Start position</param>
/// <param name="to">End position</param>
/// <param name="width">Rectangle scale</param>
/// <param name="delay">Spell delay</param>
/// <param name="missileSpeed">Spell missile speed</param>
/// <returns>Collision result as <see cref="Collision.Result"/></returns>
public static Result GetCollisions(Vector2 from, Vector2 to, float range, float width, float delay, float missileSpeed = 0, bool isArc = false)
{
List<Obj_AI_Base> collidedUnits = new List<Obj_AI_Base>();
var spellHitBox = ClipperWrapper.MakePaths(ClipperWrapper.DefineRectangle(from, to.Extend(from, -width), width));
if (isArc)
{
spellHitBox = ClipperWrapper.MakePaths(new SPrediction.Geometry.Polygon(
ClipperWrapper.DefineArc(from - new Vector2(900 / 2f, 20), to, (float)Math.PI * (to.Distance(from) / 900), 410, 200 * (to.Distance(from) / 900)),
ClipperWrapper.DefineArc(from - new Vector2(900 / 2f, 20), to, (float)Math.PI * (to.Distance(from) / 900), 410, 320 * (to.Distance(from) / 900))));
}
Flags _colFlags = Flags.None;
var collidedMinions = MinionManager.GetMinions(range + 100, MinionTypes.All, MinionTeam.NotAlly, MinionOrderTypes.None).AsParallel().Where(p => ClipperWrapper.IsIntersects(ClipperWrapper.MakePaths(ClipperWrapper.DefineCircle(Prediction.GetFastUnitPosition(p, delay, missileSpeed), p.BoundingRadius + 15)), spellHitBox));
var collidedEnemies = HeroManager.Enemies.AsParallel().Where(p => ClipperWrapper.IsIntersects(ClipperWrapper.MakePaths(ClipperWrapper.DefineCircle(Prediction.GetFastUnitPosition(p, delay, missileSpeed), p.BoundingRadius)), spellHitBox));
var collidedAllies = HeroManager.Allies.AsParallel().Where(p => ClipperWrapper.IsIntersects(ClipperWrapper.MakePaths(ClipperWrapper.DefineCircle(Prediction.GetFastUnitPosition(p, delay, missileSpeed), p.BoundingRadius)), spellHitBox));
if (collidedMinions != null && collidedMinions.Count() != 0)
{
collidedUnits.AddRange(collidedMinions);
_colFlags |= Flags.Minions;
}
if (collidedEnemies != null && collidedEnemies.Count() != 0)
{
collidedUnits.AddRange(collidedEnemies);
_colFlags |= Flags.EnemyChampions;
}
if (collidedAllies != null && collidedAllies.Count() != 0)
{
collidedUnits.AddRange(collidedAllies);
_colFlags |= Flags.AllyChampions;
}
if (CheckWallCollision(from, to))
_colFlags |= Flags.Wall;
if (CheckYasuoWallCollision(from, to, width))
_colFlags |= Flags.YasuoWall;
return new Result(collidedUnits, _colFlags);
}
public EvadeResult(EvadePlus evade, Vector2 evadePoint, Vector2 anchorPoint, int totalTimeAvailable,
int timeAvailable,
bool enoughTime)
{
Evade = evade;
PlayerPos = Player.Instance.Position.To2D();
Time = Environment.TickCount;
EvadePoint = evadePoint.Extend(PlayerPos, -40);
AnchorPoint = anchorPoint;
TotalTimeAvailable = totalTimeAvailable;
TimeAvailable = timeAvailable;
EnoughTime = enoughTime;
if (Evade.ExtraEvadeRange > 0)
{
var newPoint = EvadePoint.Extend(PlayerPos,
-(Evade.RandomizeExtraEvadeRange
? Utils.Random.Next(Evade.ExtraEvadeRange/3, Evade.ExtraEvadeRange)
: Evade.ExtraEvadeRange));
if (Evade.IsPointSafe(newPoint))
{
EvadePoint = newPoint;
}
}
}
public static void BubbKushGo(Obj_AI_Hero target)
{
int posChecked = 0;
int maxPosToCheck = 50;
int posRadius = 50;
int radiusIndex = 0;
var bubba = new Bubba();
var bubbaList = new List<Bubba>();
while (posChecked < maxPosToCheck)
{
radiusIndex++;
var curRadius = radiusIndex * (2 * posRadius);
var curCurcleChecks = (int)Math.Ceiling((2 * Math.PI * curRadius) / (2 * (double)posRadius));
for (var i = 1; i < curCurcleChecks; i++)
{
posChecked++;
var cRadians = (0x2 * Math.PI / (curCurcleChecks - 1)) * i;
var startPos = new Vector2((float)Math.Floor(target.Position.X + curRadius *
Math.Cos(cRadians)), (float)Math.Floor(target.Position.Y + curRadius * Math.Sin(cRadians)));
var endPos = startPos.Extend(target.Position.To2D(), 1000f);
var targetProj = target.Position.To2D().ProjectOn(startPos, endPos);
foreach (var hero in HeroManager.Enemies.Where(x => x.IsValidTarget()))
{
if (hero.NetworkId != target.NetworkId && hero.Distance(targetProj.SegmentPoint) <= 1000)
{
Vector2 mPos = Prediction.GetPrediction(hero, 250 + Game.Ping / 2).UnitPosition.To2D();
Geometry.ProjectionInfo mProj = mPos.ProjectOn(startPos, endPos);
if (mProj.IsOnSegment && mProj.SegmentPoint.Distance(hero.Position) <= hero.BoundingRadius + 100)
{
if (bubba.HeroesOnSegment.Contains(hero) == false)
{
bubba.HeroToKick = hero;
bubba.TargetHero = target;
bubba.KickPos = hero.Position.To2D().Extend(startPos, -(hero.BoundingRadius + 35));
bubba.HeroesOnSegment.Add(hero);
}
}
}
}
bubbaList.Add(bubba);
BubbaFat =
bubbaList.Where(x => x.HeroesOnSegment.Count > 0)
.OrderByDescending(x => x.HeroesOnSegment.Count)
.ThenByDescending(x => x.HeroToKick.MaxHealth).FirstOrDefault();
if (BubbaFat != null)
{
if (!LeeSin.spells[LeeSin.Spells.R].IsReady())
{
return;
}
if (BubbaFat.KickPos.To3D().IsValid()
&& BubbaFat.KickPos.Distance(ObjectManager.Player) < LeeSin.spells[LeeSin.Spells.W].Range
&& Wardmanager.FindBestWardItem() != null
&& Misc.IsWOne)
{
Wardmanager.WardJump(BubbaFat.KickPos.To3D(), false, true, true);
LeeSin.spells[LeeSin.Spells.R].CastOnUnit(BubbaFat.HeroToKick);
}
if (MyMenu.Menu.Item("bubbaflash").IsActive() && Wardmanager.FindBestWardItem() == null && BubbaFat.KickPos.To3D().IsValid()
&& BubbaFat.KickPos.Distance(ObjectManager.Player) < 425)
{
if (ObjectManager.Player.Spellbook.CanUseSpell(LeeSin.flashSlot) == SpellState.Ready && Wardmanager.LastWard + 1000 < Environment.TickCount)
{
ObjectManager.Player.Spellbook.CastSpell(LeeSin.flashSlot, BubbaFat.KickPos.To3D());
LeeSin.spells[LeeSin.Spells.R].CastOnUnit(BubbaFat.HeroToKick);
}
}
}
}
}
}
public static List<Vector2> GetRadiusPoints(Vector2 targetpredictedpos, Vector2 passivepredictedposition)
{
List<Vector2> RadiusPoints = new List<Vector2>();
for (int i = 50; i <= 300; i = i + 25)
{
var x = targetpredictedpos.Extend(passivepredictedposition, i);
for (int j = -45; j <= 45; j = j + 5)
{
RadiusPoints.Add(x.RotateAround(targetpredictedpos, j * (float)(Math.PI / 180)));
}
}
return RadiusPoints;
}
public static List<Vector2> ExtendDist(Vector2 origin, Vector2 currWallPos, float dist)
{
//getting OPs
List<Vector2> resultVecs = new List<Vector2>();
for (float i = 1; i <= dist; i += .05f)
{
if (!LeagueSharp.Common.Utility.IsWall(origin.Extend(currWallPos, i)))
resultVecs.Add(origin.Extend(currWallPos, i));
}
return resultVecs;
}
/// <summary>
/// Checks wall collisions
/// </summary>
/// <param name="from">Start position</param>
/// <param name="to">End position</param>
/// <returns>true if collision found</returns>
public static bool CheckWallCollision(Vector2 from, Vector2 to)
{
float step = from.Distance(to) / 20;
for (var i = 0; i < 20; i++)
{
var p = from.Extend(to, step * i);
if (NavMesh.GetCollisionFlags(p.X, p.Y).HasFlag(CollisionFlags.Wall))
return true;
}
return false;
}
private void castWOnAngle(Vector2 playerPos, Vector2 targetPos, float ag)
{
var posW = playerPos.Extend(targetPos, azir.Spells.W.Range);
if (!RotatePoint(posW, playerPos, ag).IsWall())
azir.Spells.W.Cast(RotatePoint(posW, playerPos, ag));
}
