private async void Arrow(Particle particle, Vector3 position, string id)
{
var endPosition = position.Extend(position + particle.GetControlPoint(1), 3000);
var color = Color;
DrawRange($"ArrowStart_{id}", position, 100, color, 170);
DrawRange($"ArrowEnd_{id}", endPosition, 100, color, 170);
DrawLine($"Arrow_{id}", position, endPosition, 115, 185, Color.DarkRed);
var rawGameTime = GameManager.RawGameTime;
do
{
var distance = (GameManager.RawGameTime - rawGameTime) * 900;
if (distance > 3000)
{
break;
}
DrawRange($"ArrowMove_{id}", position.Extend(endPosition, distance), 100, color, 170);
await Task.Delay(20);
}while (particle.IsValid);
DrawRangeRemove($"ArrowStart_{id}");
DrawRangeRemove($"ArrowEnd_{id}");
DrawRangeRemove($"ArrowMove_{id}");
DrawLineRemove($"Arrow_{id}");
}
private Vector3 CalculateEndPos(Vector3 start, Vector3 end, float maxRange)
{
try
{
var dist = start.Distance(end);
var endPos = end;
if (dist > maxRange)
{
endPos = start.Extend(end, maxRange);
}
if (endPos.IsWall())
{
for (var i = 0; i < 200; i = i + 10)
{
var pos = start.Extend(endPos, dist + i);
if (!pos.IsWall())
{
return(pos);
}
}
}
return(endPos);
}
catch (Exception ex)
{
//Global.Logger.AddItem(new LogItem(ex));
}
return(end);
}
public static Vector3 Away(this Vector3 myPos, Vector3 threatPos, float range, float add = 200,
float resolution = 40)
{
Vector3 r = threatPos.Extend(myPos, range).To3D();
Vector3 re = threatPos.Extend(myPos, range + add).To3D();
if (!NavMesh.GetCollisionFlags(re).HasFlag(CollisionFlags.Wall))
{
return(r);
}
for (int i = 1; i < resolution; i++)
{
if (
!NavMesh.GetCollisionFlags(re.RotatedAround(threatPos, 3.14f / resolution * i))
.HasFlag(CollisionFlags.Wall))
{
return(r.RotatedAround(threatPos, 3.14f / resolution * i));
}
if (
!NavMesh.GetCollisionFlags(re.RotatedAround(threatPos, 3.14f / resolution * i * -1f))
.HasFlag(CollisionFlags.Wall))
{
return(r.RotatedAround(threatPos, 3.14f / resolution * i * -1f));
}
}
return(r);
}
private void Between()
{
AutoWalker.SetMode(Orbwalker.ActiveModes.LaneClear);
Vector3 p = AvgPos(_currentWave);
if (p.Distance(AutoWalker.MyNexus) > MyTurret.Distance(AutoWalker.MyNexus))
{
AIHeroClient ally =
EntityManager.Heroes.Allies.Where(
al => !al.IsMe &&
AutoWalker.P.Distance(al) < 1500 &&
al.Distance(EnemyTurret) < p.Distance(EnemyTurret) + 100 &&
_currentLogic.LocalAwareness.LocalDomination(al) < -10000)
.OrderBy(l => l.Distance(AutoWalker.P))
.FirstOrDefault();
if (ally != null &&
Math.Abs(p.Distance(AutoWalker.EnemyNexus) - AutoWalker.P.Distance(AutoWalker.EnemyNexus)) < 200)
{
p = ally.Position.Extend(MyTurret, 160).To3DWorld() + _randomVector;
}
p =
p.Extend(p.Extend(
AutoWalker.P.Distance(MyTurret) < AutoWalker.P.Distance(EnemyTurret)
? MyTurret
: EnemyTurret,
400).To3D().RotatedAround(p, 1.57f), _randomExtend).To3DWorld();
AutoWalker.WalkTo(p);
}
else
{
UnderMyTurret();
}
}
private static void DrawLineIfWallBetween(Vector3 startPos, Obj_AI_Base target)
{
Vector3 endPos = YasuoCalcs.GetDashingEnd(target);
List <Vector3> inbetweenPoints = new List <Vector3>();
Vector2 wallStartPosition = Vector2.Zero;
Vector2 wallEndPosition = Vector2.Zero;
//get every point between yasuo's position and the end position of the dash extended to a range of 1000.
//1 point is every 1/100 of total length
for (int i = 0; i <= 100; i++)
{
inbetweenPoints.Add(startPos.Extend(startPos.Extend(endPos, 1000), i * (startPos.Distance(startPos.Extend(endPos, 1000)) / 100)).To3D());
}
//for every point in the list of points, find the beginning and the end of the wal
foreach (Vector2 vec in inbetweenPoints)
{
if (vec.IsWall())
{
if (wallStartPosition == Vector2.Zero)
{
wallStartPosition = vec;
}
}
else if (wallEndPosition == Vector2.Zero && wallStartPosition != Vector2.Zero)
{
wallEndPosition = vec;
}
}
//draw the wall in the color blue
if (wallStartPosition != Vector2.Zero && wallEndPosition != Vector2.Zero)
{
double wallWidth = Math.Round(wallStartPosition.Distance(wallEndPosition)),
distanceToWall = Math.Round(startPos.Distance(wallStartPosition)),
totalDistance = Math.Round(wallStartPosition.Distance(wallEndPosition) + startPos.Distance(wallStartPosition)),
monsterDist = Math.Round(target.Position.Distance(wallStartPosition));
Drawing.DrawLine(wallStartPosition.To3D().WorldToScreen(), wallEndPosition.To3D().WorldToScreen(), 10, System.Drawing.Color.Black);
//if the end point of yasuos dash brings him at least halfway between the two points (closer to the wall end than to the walls beginning)
//and the wall has to be thinner than yasuo's total dash range. TESTED THIS TO CONFIRM IT WORKS
//if (endPos.Distance(wallEndPosition) < endPos.Distance(wallStartPosition) && wallStartPosition.Distance(wallEndPosition) <= Program.E.Range)
if (totalDistance <= 630)
{
Drawing.DrawLine(startPos.WorldToScreen(), startPos.Extend(endPos, 1000).To3D().WorldToScreen(), 3, System.Drawing.Color.Green);
}
else
{
Drawing.DrawLine(startPos.WorldToScreen(), startPos.Extend(endPos, 1000).To3D().WorldToScreen(), 3, System.Drawing.Color.Red);
}
Drawing.DrawText(wallStartPosition.To3D().WorldToScreen(), System.Drawing.Color.Purple, wallStartPosition.Distance(wallEndPosition).ToString(), 15);
Drawing.DrawText(startPos.Extend(endPos, 1000).To3D().WorldToScreen(), System.Drawing.Color.Purple, (wallStartPosition.Distance(wallEndPosition) + startPos.Distance(wallStartPosition)).ToString(), 15);
Drawing.DrawCircle(endPos, 50, System.Drawing.Color.White);
}
}
/// <summary>
/// The Ultimate Cone.
/// </summary>
public Vector2Geometry.Sector UltimateCone()
{
var targetPos = End;
var range = SpellClass.R.Range - UtilityClass.Player.BoundingRadius;
var dir = (targetPos - UtilityClass.Player.ServerPosition).Normalized();
var spot = targetPos + dir * range;
return(new Vector2Geometry.Sector((Vector2)End.Extend(UtilityClass.Player.ServerPosition, End.Distance(UtilityClass.Player) + UtilityClass.Player.BoundingRadius * 3), (Vector2)spot, SpellClass.R2.Width, range));
}
public static Vector3[] Symmetry(this Vector3 center, Vector3 direction, float Range = 0)
{
if (Range.Equals(0))
{
Range = center.Distance(direction);
}
Vector3 pos1 = center.Extend(direction, Range).To3DWorld();
Vector3 pos2 = center.Extend(direction, -Range).To3DWorld();
return(new Vector3[] { pos1, pos2 });
}
public static Vector3 GetBestConeAndLinearCastPosition(this Spell.Skillshot cone, Spell.Skillshot linearSpell, List <Obj_AI_Base> enemies, Vector3 sourcePosition, out int bestHitNumber)
{
int radius = (int)cone.Range;
enemies = enemies.Where(a => a.MeetsCriteria() && a.Position(linearSpell.CastDelay).IsInRange(sourcePosition, radius)).ToList();
bestHitNumber = 0;
Vector3 castPosition = Vector3.Zero;
//if there is nothing that meets the criteria
if (enemies.Count() == 0)
{
return(castPosition);
}
List <Tuple <Geometry.Polygon.Sector, Vector3> > conePositions = new List <Tuple <Geometry.Polygon.Sector, Vector3> >();
Vector3 extendingPosition = sourcePosition + new Vector3(0, radius, 0);
//checks every 15 degrees
for (int i = 0; i < 24; i++)
{
Vector3 endPosition = extendingPosition.To2D().RotateAroundPoint(sourcePosition.To2D(), (float)((i * 15) * Math.PI / 180)).To3D((int)sourcePosition.Z);
Geometry.Polygon.Sector sector = new Geometry.Polygon.Sector(sourcePosition,
endPosition, (float)(cone.ConeAngleDegrees * Math.PI / 180), radius);
conePositions.Add(Tuple.Create(sector, endPosition));
}
//order list by most hit by Q1 and Q2
conePositions = conePositions.OrderByDescending(a => a.Item1.EnemiesHitInSectorAndRectangle(new Geometry.Polygon.Rectangle(sourcePosition, a.Item2, linearSpell.Width), enemies, linearSpell.CastDelay)).ToList();
//only leave the ones with the highest amount
conePositions = conePositions.Where(a => a.Item1.EnemiesHitInSectorAndRectangle(new Geometry.Polygon.Rectangle(sourcePosition, a.Item2, linearSpell.Width), enemies, linearSpell.CastDelay) == conePositions[0].Item1.EnemiesHitInSectorAndRectangle(new Geometry.Polygon.Rectangle(sourcePosition, a.Item2, linearSpell.Width), enemies, linearSpell.CastDelay)).ToList();
//from the ones with the most Sector/Line enemies hit, find the one with the most in the rectangle
conePositions = conePositions.OrderByDescending(a => new Geometry.Polygon.Rectangle(sourcePosition, a.Item2, linearSpell.Width).EnemiesHitInRectangle(enemies, linearSpell.CastDelay)).ToList();
//only take the ones with the most enemies
conePositions = conePositions.Where(a => new Geometry.Polygon.Rectangle(sourcePosition, a.Item2, linearSpell.Width).EnemiesHitInRectangle(enemies, linearSpell.CastDelay) == new Geometry.Polygon.Rectangle(sourcePosition, conePositions[0].Item2, linearSpell.Width).EnemiesHitInRectangle(enemies, linearSpell.CastDelay)).ToList();
//from the ones with the most sector/line enemies hit AND the most line enemies hit, find the ones with the most sector area
conePositions = conePositions.OrderByDescending(a => a.Item1.EnemiesHitInSector(enemies, cone.CastDelay)).ToList();
Tuple <Geometry.Polygon.Sector, Vector3> bestCone = conePositions.First();
Geometry.Polygon.Rectangle spellRectangle = new Geometry.Polygon.Rectangle(sourcePosition, bestCone.Item2, linearSpell.Width);
bestHitNumber = bestCone.Item1.EnemiesHitInSectorAndRectangle(spellRectangle, enemies, linearSpell.CastDelay);
if (bestHitNumber == 1)
{
return(sourcePosition.Extend(bestCone.Item1.GetEnemiesHitInSectorAndRectangle(spellRectangle, enemies, linearSpell.CastDelay).FirstOrDefault().Position, radius - 1).To3D((int)sourcePosition.Z));
}
return(sourcePosition.Extend(bestCone.Item2, radius - 1).To3D((int)sourcePosition.Z));
}
public static Vector3 ClosestWall(Vector3 startPos, Vector3 endPos)
{
var distance = startPos.Distance(endPos);
for (int i = 1; i < 6; i++)
{
if (startPos.Extend(endPos, distance + 70 * i).IsWall())
{
return(startPos.Extend(endPos, distance + 70 * i));
}
}
return(endPos);
}
public static Vector3 ClosestWall(Vector3 StartPos, Vector3 EndPos)
{
var distance = StartPos.Distance(EndPos);
for (int i = 1; i < 8; i++)
{
if (StartPos.Extend(EndPos, distance + 55 * i).IsWall())
{
return(StartPos.Extend(EndPos, distance + 55 * i));
}
}
return(EndPos);
}
/// <summary>
/// Checking Collision
/// </summary>
/// <param name="start">Start Position</param>
/// <param name="end">End Position</param>
/// <param name="range">Range</param>
/// <param name="width">Width of spell</param>
/// <param name="speed">Speed of spell</param>
/// <param name="castdelay">Delay of spell</param>
/// <returns></returns>
public static Vector2 Linear_Collision_Point(Vector3 start, Vector3 end, uint range, int width, int speed, int castdelay)
{
var possiblecolldies = EntityManager.Enemies.Where(x => x.IsValidTarget(range));
var spellpolygon = new Geometry.Polygon.Rectangle(start, start.Extend(end, range).To3D(), width);
var time = start.Distance(end) / speed * 1000 + castdelay;
var collidetarget = possiblecolldies.OrderBy(x => x.Distance(start)).FirstOrDefault(x => spellpolygon.IsInside(Prediction.Position.PredictUnitPosition(x, (int)time + 1)));
if (collidetarget != null)
{
return(start.Extend(end, start.Distance(collidetarget)));
}
return(Vector2.Zero);
}
public static Vector3 GetFirstNonWallPos(Vector3 startPos, Vector3 endPos)
{
int distance = 0;
for (int i = 0; i < Vayne.emenu.Item("PushDistance").GetValue <Slider>().Value; 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 override bool UseAbility(Vector3 position)
{
var distance = Math.Max(this.Owner.AttackRange(), this.Owner.Distance2D(position) - this.CastRange);
var startPosition = position.Extend(this.Owner.Position, distance);
return(this.UseAbility(startPosition, position));
}
public void SetLane()
{
if (MainMenu.GetMenu("AB").Get <Slider>("lane").CurrentValue != 1)
{
switch (MainMenu.GetMenu("AB").Get <Slider>("lane").CurrentValue)
{
case 2:
ChangeLane(Lane.Top);
break;
case 3:
ChangeLane(Lane.Mid);
break;
case 4:
ChangeLane(Lane.Bot);
break;
}
}
else if (ObjectManager.Get <Obj_AI_Turret>().Count() == 24)
{
waiting = true;
Vector3 p = GetAllyTurret("R_03_A").Position;
Core.DelayAction(() => SafeFunctions.Ping(PingCategory.OnMyWay, p.Randomized()), RandGen.r.Next(1500, 3000));
AutoWalker.SetMode(Orbwalker.ActiveModes.Combo);
AutoWalker.WalkTo(p.Extend(AutoWalker.MyNexus, 200 + RandGen.r.NextFloat(0, 100)).To3DWorld().Randomized());
EarlySelectLane();
}
else
{
SelectMostPushedLane();
}
}
public static Vector3 GetBestWallHopPos(Vector3 start, float range)
{
var spots = new Dictionary <Vector3, float>();
float thickness = 0f;
for (int i = 0; i < range; i += 1)
{
var end = start.Extend(Game.CursorPos, i);
if (IsWallAt(end))
{
thickness += 10;
continue;
}
if (!spots.ContainsKey(end))
{
spots.Add(end, thickness);
}
}
var spot = spots.OrderBy(x => x.Key.Distance(Game.CursorPos)).ThenBy(x => x.Value).FirstOrDefault(x => x.Value > 50 && x.Value < range);
DebugConsole.WriteLine($"THICK: {spot.Value}", MessageState.Warn);
return(spot.Key);
}
private async void IceBlast(Particle particle, Vector3 startPosition)
{
var rotation = particle.GetControlPoint(1);
var endPosition = startPosition + (particle.GetControlPoint(5).X *rotation);
var radius = startPosition.Distance(endPosition) / 20;
DrawRange("IceBlastStart", startPosition, 100, Color.DarkRed, 180);
DrawRange("IceBlastEnd", endPosition, 275 + radius, Color, 180);
DrawLine("IceBlast", startPosition, endPosition, 150, 185, Color.DarkRed);
var rawGameTime = GameManager.RawGameTime;
var speed = startPosition.Distance(startPosition + rotation) * 1.04f;
finish = false;
do
{
var position = startPosition.Extend(endPosition, (GameManager.RawGameTime - rawGameTime) * speed);
DrawRange("IceBlastPosition", position, 100, Color.Red, 180);
await Task.Delay(10);
}while (!finish);
DrawRangeRemove("IceBlastStart");
DrawRangeRemove("IceBlastEnd");
DrawLineRemove("IceBlast");
DrawRangeRemove("IceBlastPosition");
}
/// <summary>
/// Transforms a three-dimensional point represented by a specified vector by this
/// transformation matrix.
/// </summary>
/// <param name="v">The vector to transform.</param>
/// <returns>The transformed vector.</returns>
public Vector3 TransformPoint(Vector3 v)
{
var factor = this * v.Extend(1);
factor *= 1 / factor.W;
return(factor.Truncate());
}
private static bool CheckPosStun(Vector3 pos)
{
if (pos.IsWall())
{
return(true);
}
if (pos.Extend(Player.Position, -120).IsWall())
{
return(true);
}
var result = GetRockObject(200, pos);
if (result != null)
{
return(true);
}
else
{
result = GetGrassObject(50, pos);
if (result != null)
{
return(true);
}
else
{
return(IsWater(pos));
}
}
}
private static void SpellsDetector_OnSkillShotDetected(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args, Database.SkillShotSpells.SSpell spell, Vector3 Start, Vector3 End, float Range, float Width, MissileClient missile)
{
var caster = sender as AIHeroClient;
if (caster == null)
{
return;
}
var spellrange = Range;
var endpos = spell.IsFixedRange ? Start.Extend(End, spellrange).To3D() : End;
if (spell.type == Database.SkillShotSpells.Type.CircleMissile && End.Distance(Start) < Range)
{
endpos = End;
}
var newactive = new ActiveSpells
{
Start = Start, End = endpos, Range = spellrange, Width = Width, spell = spell, EndTime = (endpos.Distance(Start) / spell.Speed) + (spell.CastDelay / 1000) + Game.Time, Caster = caster, Missile = missile, ArriveTime = (Start.Distance(Player.Instance) / spell.Speed) - (spell.CastDelay / 1000)
};
if (!DetectedSpells.Contains(newactive))
{
DetectedSpells.Add(newactive);
}
}
private void Move(Vector3 pos)
{
if (!m_attackInProgress && (!CanAttack(60) || CanAttack()))
{
if (!m_Configuration.DontMoveMouseOver || ObjectManager.Player.Distance(Game.CursorPos, true) > ObjectManager.Player.BoundingRadius * ObjectManager.Player.BoundingRadius * 4)
{
Vector3 playerPos = ObjectManager.Player.ServerPosition;
if (playerPos.Distance(pos, true) < m_Configuration.HoldAreaRadius * m_Configuration.HoldAreaRadius)
{
ObjectManager.Player.IssueOrder(GameObjectOrder.Stop, playerPos);
m_lastMoveTick = Utils.TickCount + m_rnd.Next(1, 70);
return;
}
if (ObjectManager.Player.Distance(pos, true) < 22500)
{
pos = playerPos.Extend(pos, (m_rnd.NextFloat(0.6f, 1) + 0.2f) * 400);
}
if (m_lastMoveTick + Math.Min(10, Game.Ping) < Utils.TickCount)
{
ObjectManager.Player.IssueOrder(GameObjectOrder.MoveTo, pos);
m_lastMoveTick = Utils.TickCount + m_rnd.Next(1, 70);
}
}
}
}
/// <summary>
/// Determines whether dash is wall-jump.
/// </summary>
/// <param name="start">start</param>
/// <param name="direction">The direction.</param>
/// <param name="dashRange">The dash range.</param>
public bool IsWallDash(Vector3 start, Vector3 direction, float dashRange)
{
var dashEndPos = start.Extend(direction, dashRange);
var firstWallPoint = this.GetFirstWallPoint(start, dashEndPos);
if (firstWallPoint.Equals(Vector3.Zero))
{
// No Wall
return(false);
}
if (dashEndPos.IsWall())
// End Position is in Wall
{
var wallWidth = this.GetWallWidth(firstWallPoint, dashEndPos);
if (wallWidth > this.Menu.Item("MinWallWidth").GetValue <Slider>().Value &&
wallWidth - firstWallPoint.Distance(dashEndPos) < wallWidth * 0.6f)
{
return(true);
}
}
else
// End Position is not a Wall
{
return(true);
}
return(false);
}
private static IEnumerable <Vector3> GetPossibleJumpPositions(Vector3 pos)
{
var pointList = new List <Vector3>();
for (var j = 680; j >= 50; j -= 50)
{
var offset = (int)(2 * Math.PI * j / 50);
for (var i = 0; i <= offset; i++)
{
var angle = i * Math.PI * 2 / offset;
var point = new Vector3((float)(pos.X + j * Math.Cos(angle)),
(float)(pos.Y - j * Math.Sin(angle)),
pos.Z);
if (!NavMesh.GetCollisionFlags(point).HasFlag(CollisionFlags.Wall) && point.Distance(_player.Position) < pos.Distance(_player.Position) - 400 &&
point.Distance(pos.Extend(_player.Position, 600)) <= 250)
{
pointList.Add(point);
}
}
}
return(pointList);
}
private void SetActPos()
{
if (_actPosition == _newPosition)
{
_newPosition = Game.CursorPos;
return;
}
if (_actPosition.Distance(_newPosition) > 3000)
{
_newPosition = Game.CursorPos;
_actPosition = Game.CursorPos;
return;
}
var l = _actPosition.Distance(_newPosition);
var dSpeed = _speed;
if (l < dSpeed)
{
dSpeed = l / 2;
}
if (l < 70)
{
_actPosition = _newPosition;
return;
}
_actPosition = _actPosition.Extend(_offsetPosition.IsValid() ? _offsetPosition : _newPosition, dSpeed);
}
public void DrawArcRectangle(Vector3 startPosition, Vector3 endPosition, float startRadius, float endRadius = 0)
{
if (rectangle[0] != null)
{
return;
}
if (endRadius <= 0)
{
endRadius = startRadius;
}
var difference = startPosition - endPosition;
var rotation = difference.Rotated(MathUtil.DegreesToRadians(90));
rotation.Normalize();
var start = rotation * startRadius;
var end = rotation * endRadius;
var correctedEnd = startPosition.Extend(
endPosition,
startPosition.Distance2D(endPosition) - endRadius * 0.45f);
var rightStartPosition = startPosition + start;
var leftStartPosition = startPosition - start;
var rightEndPosition = correctedEnd + end;
var leftEndPosition = correctedEnd - end;
rectangle[0] = DrawLine(rightStartPosition, rightEndPosition);
rectangle[1] = DrawLine(rightStartPosition, leftStartPosition);
rectangle[2] = DrawLine(leftStartPosition, leftEndPosition);
rectangle[3] = DrawArc(endPosition, startPosition, endRadius);
}
/// <summary>
/// Orders move hero to given position
/// </summary>
/// <param name="pos"></param>
private void Move(Vector3 pos)
{
if (!m_attackInProgress && CanMove() && (!CanAttack(60) || CanAttack()))
{
Vector3 playerPos = ObjectManager.Player.ServerPosition;
bool holdzone = m_Configuration.DontMoveMouseOver || m_Configuration.HoldAreaRadius != 0;
var holdzoneRadiusSqr = Math.Max(m_Configuration.HoldAreaRadius * m_Configuration.HoldAreaRadius, ObjectManager.Player.BoundingRadius * ObjectManager.Player.BoundingRadius * 4);
if (holdzone && playerPos.Distance(pos, true) < holdzoneRadiusSqr)
{
if ((Utils.TickCount + Game.Ping / 2 - m_lastAATick) * 0.6f >= 1000f / (ObjectManager.Player.GetAttackSpeed() * m_baseWindUp))
{
ObjectManager.Player.IssueOrder(GameObjectOrder.Stop, playerPos);
}
m_lastMoveTick = Utils.TickCount + m_rnd.Next(1, 20);
return;
}
if (ObjectManager.Player.Distance(pos, true) < 22500)
{
pos = playerPos.Extend(pos, (m_rnd.NextFloat(0.6f, 1.01f) + 0.2f) * 400);
}
if (m_lastMoveTick + 50 + Math.Min(60, Game.Ping) < Utils.TickCount)
{
ObjectManager.Player.IssueOrder(GameObjectOrder.MoveTo, pos);
m_lastMoveTick = Utils.TickCount + m_rnd.Next(1, 20);
}
}
}
public static Vector3 GetBestLinearPredictionPos(this Spell.Skillshot self, List <Obj_AI_Base> enemies, Vector3 sourcePosition, out int enemiesHit)
{
enemiesHit = 0;
enemies = enemies.Where(a => a.MeetsCriteria() && a.Position(self.CastDelay).IsInRange(sourcePosition, self.Range)).ToList();
Vector3 castPosition = Vector3.Zero;
//if there is nothing that meets the criteria
if (enemies.Count() == 0)
{
return(castPosition);
}
List <Tuple <Geometry.Polygon.Rectangle, Vector3> > rectPositions = new List <Tuple <Geometry.Polygon.Rectangle, Vector3> >();
Vector3 extendingPosition = sourcePosition + new Vector3(0, self.Range, 0);
//checks every 15 degrees
for (int i = 0; i < 24; i++)
{
Vector3 endPosition = extendingPosition.To2D().RotateAroundPoint(sourcePosition.To2D(), (float)((i * 15) * Math.PI / 180)).To3D((int)sourcePosition.Z);
Geometry.Polygon.Rectangle rect = new Geometry.Polygon.Rectangle(sourcePosition, endPosition, self.Width);
rectPositions.Add(Tuple.Create(rect, endPosition));
}
Tuple <Geometry.Polygon.Rectangle, Vector3> bestPos = null;
if (self.AllowedCollisionCount == 1)
{
bestPos = rectPositions.Where(a =>
enemies.Where(enemy => a.Item1.IsInside(enemy)).OrderBy(enemy => enemy.Position(self.CastDelay).Distance(sourcePosition)).FirstOrDefault() != null
).FirstOrDefault();
if (bestPos != null)
{
enemiesHit = 1;
}
}
else
{
bestPos = rectPositions.OrderByDescending(a =>
enemies.Where(enemy => a.Item1.IsInside(enemy.Position(self.CastDelay))).Count()
).FirstOrDefault();
if (bestPos != null)
{
enemiesHit = enemies.Where(enemy => bestPos.Item1.IsInside(enemy.Position(self.CastDelay))).Count();
}
}
if (bestPos != null)
{
return(sourcePosition.Extend(bestPos.Item2, self.Range / 2).To3D((int)sourcePosition.Z));
}
else
{
return(Vector3.Zero);
}
}
public static Vector3 GetBestDaggerPoint(Vector3 position, Obj_AI_Base target)
{
if (target.Position.IsInRange(position, 150))
{
return(position);
}
return(position.Extend(target, 150).To3D());
}
public override bool UseAbility(Vector3 position)
{
// simple position to get as close as possible to target
var distance = Math.Max(this.Owner.AttackRange(), this.Owner.Distance2D(position) - this.CastRange);
var startPosition = position.Extend(this.Owner.Position, distance);
return(this.UseAbility(startPosition, position));
}
public static Vector3 GetPlayerPosition(int timeModMs = 0)
{
if (Player.Instance.IsDashing() && _dashEndTime < Environment.TickCount + timeModMs)
{
return(_startPos.Extend(_endPos, 475 * ((_dashEndTime - (Environment.TickCount + timeModMs)) / ((_dashStartTime - _dashEndTime) == 0 ? 1 : (_dashStartTime - _dashEndTime)))).To3D());
}
return(Player.Instance.Position);
}
private static Vector3 ExtendWallpos(Obj_AI_Base ts, Vector3 point)
{
if (ts == null)
{
throw new ArgumentNullException("ts");
}
return(point.Extend(ts.Position, point.Distance(ts.Position) + 25));
}
private static float GetWallWidth(Vector3 start, Vector3 direction, int maxWallWidth = 350, int step = 1)
{
var thickness = 0f;
if (!start.IsValid() || !direction.IsValid())
{
return thickness;
}
for (var i = 0; i < maxWallWidth; i = i + step)
{
if (NavMesh.GetCollisionFlags(start.Extend(direction, i)) == CollisionFlags.Wall || start.Extend(direction, i).IsWall())
{
thickness += step;
}
}
return thickness;
}
public static Obj_AI_Base GetTarget(Vector3 fromPosition)
{
var targetList =
EntityManager.Heroes.Enemies.Where(
h =>
h.IsValidTarget(SpellManager.E.Range) && !h.HasBuffOfType(BuffType.SpellShield)
&& !h.HasBuffOfType(BuffType.SpellImmunity)
&& h.Health > ObjectManager.Player.GetAutoAttackDamage(h, true) * 2).ToList();
if (!targetList.Any())
{
return null;
}
foreach (var enemy in targetList)
{
var prediction = SpellManager.E.GetPrediction(enemy);
var predictionsList = new List<Vector3>
{
enemy.ServerPosition,
enemy.Position,
prediction.CastPosition,
prediction.UnitPosition
};
var wallsFound = 0;
foreach (var position in predictionsList)
{
var distance = fromPosition.Distance(position);
for (var i = 0; i < Config.Settings.Condemn.PushDistance; i += (int)enemy.BoundingRadius)
{
var finalPosition = fromPosition.Extend(position, distance + i).To3D();
if (NavMesh.GetCollisionFlags(finalPosition).HasFlag(CollisionFlags.Wall)
|| NavMesh.GetCollisionFlags(finalPosition).HasFlag(CollisionFlags.Building))
{
wallsFound++;
break;
}
}
}
if (wallsFound >= Config.Settings.Condemn.Accuracy)
{
return enemy;
}
}
return null;
}
public static float GetWallWidth(Vector3 start, Vector3 direction, int maxWallWidth = 350, int step = 1)
{
var thickness = 0f;
if (start.IsValid() && direction.IsValid())
{
for (var i = 0; i < maxWallWidth; i = i + step)
{
if (NavMesh.GetCollisionFlags(start.Extend(direction, i)) == CollisionFlags.Wall
|| start.Extend(direction, i).IsWall())
{
// Console.WriteLine("Thickness: " + thickness);
thickness += step;
}
else
{
return thickness;
}
}
}
return thickness;
}
public static Vector3 GetFirstWallPoint(Vector3 start, Vector3 end, int step = 1)
{
if (start.IsValid() && end.IsValid())
{
var distance = start.Distance(end);
for (var i = 0; i < distance; i = i + step)
{
var newPoint = start.Extend(end, i);
if (NavMesh.GetCollisionFlags(newPoint) == CollisionFlags.Wall || newPoint.IsWall())
{
return newPoint;
}
}
}
return Vector3.Zero;
}
/// <summary>
/// Gets the first wall point/node, w/e.
/// </summary>
/// <param name="playerPosition"></param>
/// <param name="endPosition"></param>
/// <param name="step"></param>
/// <returns></returns>
public Vector3 FirstWallPoint(Vector3 playerPosition, Vector3 endPosition, int step = 1)
{
if (!playerPosition.IsValid() || !endPosition.IsValid())
{
return Vector3.Zero;
}
var distance = playerPosition.Distance(endPosition);
for (var i = 0; i < distance; i = i + step)
{
var newPoint = playerPosition.Extend(endPosition, i);
if (NavMesh.GetCollisionFlags(newPoint) == CollisionFlags.Wall || newPoint.IsWall())
{
return newPoint;
}
}
return Vector3.Zero;
}
/// <summary>
/// Returns true if there is a Wall between X pos and Y pos.
/// </summary>
public static bool AnyWallInBetween(Vector3 startPos, Vector3 endPos)
{
for (var i = 0; i < startPos.Distance(endPos); i++)
{
if (NavMesh.GetCollisionFlags(startPos.Extend(endPos, i)) == CollisionFlags.Wall)
{
return true;
}
}
return false;
}
static Vector3 getPos(AIHeroClient target, int c)
{
AIHeroClient ally1 = EntityManager.Heroes.Allies.FirstOrDefault(ally => ally.HealthPercent > Settings.InsecToHP && Player.Instance.Distance(ally) <= Settings.InsecToRange && ally.Name != Player.Instance.Name);
Vector3 moveTo = new Vector3();
Vector3 allyPos = new Vector3();
Vector3 point = new Vector3();
if (ally1 != null)
point = ally1.Position;
else
point = Vector3.Zero;
allyPos = point;
if (allyPos == Vector3.Zero) return Vector3.Zero;
Vector3 targetPos = target.Position;
//From the Ally position we extended (the distance between both + 100) units in the target direction THANKS @WUJU!
if (c == 3) { moveTo = allyPos.Extend(target, ally1.Distance(target) - Settings.Dist).To3DWorld(); }
if (c == 1) { moveTo = allyPos.Extend(target, ally1.Distance(target) + Settings.Dist).To3DWorld(); }
if (NavMesh.GetCollisionFlags(moveTo) == CollisionFlags.Building || NavMesh.GetCollisionFlags(moveTo) == CollisionFlags.Wall)
{
return Vector3.Zero;
}
_moveTo = moveTo;
return moveTo;
}
private static void WardBush(Vector3 from, Vector3 endPosition)
{
if (!MenuExtensions.GetItemValue<bool>("iseriesr.vayne.misc.condemn.wardbush"))
{
return;
}
var wardSlot = Items.GetWardSlot();
if (wardSlot != null)
{
var wardPos = from.Extend(endPosition, from.Distance(endPosition) - 65f);
if (NavMesh.IsWallOfGrass(wardPos, 65))
{
if (Items.CanUseItem(wardSlot.Slot))
{
Items.UseItem(wardSlot.Slot, wardPos);
}
}
}
}
/// <summary>
/// Wall Lentgh
/// </summary>
/// <param name="start"></param>
/// <param name="end"></param>
/// <returns></returns>
public static float GetWallLength(Vector3 start, Vector3 end)
{
double distance = Vector3.Distance(start, end);
var firstPosition = Vector3.Zero;
var lastPosition = Vector3.Zero;
for (uint i = 0; i < distance; i += 10)
{
var tempPosition = start.Extend(end, i);
if (tempPosition.IsWall() && firstPosition == Vector3.Zero)
{
firstPosition = tempPosition;
}
lastPosition = tempPosition;
if (!lastPosition.IsWall() && firstPosition != Vector3.Zero)
{
break;
}
}
return Vector3.Distance(firstPosition, lastPosition);
}
/// <summary>
/// Checks For Wall
/// </summary>
/// <param name="start"></param>
/// <param name="end"></param>
/// <returns></returns>
public static bool IsOverWall(Vector3 start, Vector3 end)
{
double distance = Vector3.Distance(start, end);
for (uint i = 0; i < distance; i += 10)
{
var tempPosition = start.Extend(end, i).To2D();
if (tempPosition.IsWall())
{
return true;
}
}
return false;
}
public static Vector3 Extend(Vector3 from, Vector3 to, float x)
{
return from.Extend(to, x);
}
/// <summary>
/// First wall Point
/// </summary>
/// <param name="start"></param>
/// <param name="end"></param>
/// <returns></returns>
public static Vector3 GetFirstWallPoint(Vector3 start, Vector3 end)
{
double distance = Vector3.Distance(start, end);
for (uint i = 0; i < distance; i += 10)
{
var tempPosition = start.Extend(end, i);
if (!tempPosition.IsWall())
{
return tempPosition.Extend(start, -35);
}
}
return Vector3.Zero;
}
