public static void WallTumble()
{
foreach (var delayedAction in DelayedActions)
{
if (delayedAction.Value <= Environment.TickCount)
{
delayedAction.Key.Invoke();
DelayedActions.Remove(delayedAction.Key);
return;
}
}
if (!Program.Q.IsReady()) return;
Vector2 drakeWallQPos = new Vector2(11514, 4462);
Vector2 midWallQPos = new Vector2(6667, 8794);
var selectedPos = drakeWallQPos.Distance(_Player) < midWallQPos.Distance(_Player) ? drakeWallQPos : midWallQPos;
var walkPos = drakeWallQPos.Distance(_Player) < midWallQPos.Distance(_Player)
? new Vector2(12050, 4827)
: new Vector2(6962, 8952);
if (_Player.Distance(walkPos) < 200 && _Player.Distance(walkPos) > 1)
{
Player.IssueOrder(GameObjectOrder.MoveTo, walkPos.To3D());
}
else if(_Player.Distance(walkPos) <= 10)
{
Player.IssueOrder(GameObjectOrder.MoveTo, walkPos.To3D());
DelayedActions.Add(delegate {Program.Q.Cast(selectedPos.To3D());}, Environment.TickCount + 106 + (Game.Ping/2));
}
}
public static Vector3 GetTumblePos(this Obj_AI_Base target)
{
//if the target is not a melee and he's alone he's not really a danger to us, proceed to 1v1 him :^ )
if (!target.IsMelee && Heroes.Player.CountEnemiesInRange(800) == 1) return Game.CursorPos;
var aRC = new Geometry.Circle(Heroes.Player.ServerPosition.To2D(), 300).ToPolygon().ToClipperPath();
var cursorPos = Game.CursorPos;
var targetPosition = target.ServerPosition;
var pList = new List<Vector3>();
var additionalDistance = (0.106 + Game.Ping / 2000f) * target.MoveSpeed;
if (!cursorPos.IsDangerousPosition()) return cursorPos;
foreach (var p in aRC)
{
var v3 = new Vector2(p.X, p.Y).To3D();
if (target.IsFacing(Heroes.Player))
{
if (!v3.IsDangerousPosition() && v3.Distance(targetPosition) < 550) pList.Add(v3);
}
else
{
if (!v3.IsDangerousPosition() && v3.Distance(targetPosition) < 550 - additionalDistance) pList.Add(v3);
}
}
if (Heroes.Player.UnderTurret() || Heroes.Player.CountEnemiesInRange(800) == 1)
{
return pList.Count > 1 ? pList.OrderBy(el => el.Distance(cursorPos)).FirstOrDefault() : Vector3.Zero;
}
return pList.Count > 1 ? pList.OrderBy(el => el.Distance(cursorPos)).FirstOrDefault() : Vector3.Zero;
}
public static void WallTumble()
{
if (Game.MapId != GameMapId.SummonersRift) return;
if (!Vayne.Q.IsReady())
{
Orbwalker.DisableMovement = false;
return;
}
Orbwalker.DisableMovement = true;
Vector2 drakeWallQPos = new Vector2(11514, 4462);
Vector2 midWallQPos = new Vector2(6667, 8794);
var selectedPos = drakeWallQPos.Distance(_Player) < midWallQPos.Distance(_Player) ? drakeWallQPos : midWallQPos;
var walkPos = drakeWallQPos.Distance(_Player) < midWallQPos.Distance(_Player)
? new Vector2(12050, 4827)
: new Vector2(6962, 8952);
if (_Player.Distance(walkPos) < 200 && _Player.Distance(walkPos) > 60)
{
Player.IssueOrder(GameObjectOrder.MoveTo, walkPos.To3D());
}
else if (_Player.Distance(walkPos) <= 50)
{
Player.CastSpell(SpellSlot.Q, selectedPos.To3D());
}
}
/// <summary>
/// Checks enemy hero collisions
/// </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>
/// <param name="isArc">Checks collision for arc spell</param>
/// <returns>true if collision found</returns>
public static bool CheckAllyHeroCollision(Vector2 from, Vector2 to, float width, float delay, float missileSpeed = 0, bool isArc = false)
{
var spellHitBox = ClipperWrapper.MakePaths(ClipperWrapper.DefineRectangle(from, to, width));
if (isArc)
{
spellHitBox = ClipperWrapper.MakePaths(new SPrediction.Geometry.Polygon(
ClipperWrapper.DefineArc(from - new Vector2(875 / 2f, 20), to, (float)Math.PI * (to.Distance(from) / 875f), 410, 200 * (to.Distance(from) / 875f)),
ClipperWrapper.DefineArc(from - new Vector2(875 / 2f, 20), to, (float)Math.PI * (to.Distance(from) / 875f), 410, 320 * (to.Distance(from) / 875f))));
}
return HeroManager.Allies.AsParallel().Any(p => ClipperWrapper.IsIntersects(ClipperWrapper.MakePaths(ClipperWrapper.DefineCircle(Prediction.GetFastUnitPosition(p, delay, missileSpeed), p.BoundingRadius)), spellHitBox));
}
/// <summary>
/// Gets Prediction result
/// </summary>
/// <param name="target">Target for spell</param>
/// <param name="width">Spell width</param>
/// <param name="delay">Spell delay</param>
/// <param name="missileSpeed">Spell missile speed</param>
/// <param name="range">Spell range</param>
/// <param name="collisionable">Spell collisionable</param>
/// <param name="type">Spell skillshot type</param>
/// <param name="path">Waypoints 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="avgp">Average Path Lenght</param>
/// <param name="from">Spell casted position</param>
/// <param name="rangeCheckFrom"></param>
/// <returns>Prediction result as <see cref="Prediction.Result"/></returns>
public static Prediction.Result GetPrediction(Obj_AI_Base target, float width, float delay, float missileSpeed, float range, bool collisionable, List<Vector2> path, float avgt, float movt, float avgp, Vector2 from, Vector2 rangeCheckFrom)
{
Prediction.Result result = Prediction.GetPrediction(target, width, delay, missileSpeed, range, collisionable, SkillshotType.SkillshotCircle, path, avgt, movt, avgp, from, rangeCheckFrom);
if (result.HitChance >= HitChance.Low && delay >= 1.0f && width < 250)
{
result.CastPosition += (result.CastPosition - from + target.Direction.To2D()).Normalized() * width / 2f;
if (from.Distance(result.CastPosition) > range - Prediction.GetArrivalTime(from.Distance(result.CastPosition), delay, missileSpeed) * target.MoveSpeed * (100 - Prediction.predMenu.Item("SPREDMAXRANGEIGNORE").GetValue<Slider>().Value) / 100f)
result.HitChance = HitChance.OutOfRange;
}
return result;
}
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 FastPredResult FastPrediction(Vector2 from, Obj_AI_Base unit, int delay, int speed)
{
var tDelay = delay / 1000f + (from.Distance(unit) / speed);
var d = tDelay * unit.MoveSpeed;
var path = unit.Path;
if (path.Length > d)
{
return new FastPredResult
{
IsMoving = true,
CurrentPos = unit.ServerPosition.To2D(),
PredictedPos = CutPath(path, d)[0].To2D(),
};
}
if (path.Count() == 0)
{
return new FastPredResult
{
IsMoving = false,
CurrentPos = unit.ServerPosition.To2D(),
PredictedPos = unit.ServerPosition.To2D(),
};
}
return new FastPredResult
{
IsMoving = false,
CurrentPos = path[path.Count() - 1].To2D(),
PredictedPos = path[path.Count() - 1].To2D(),
};
}
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 Vector3 GetPRADAPos(this AIHeroClient target)
{
if (target == null) return Vector3.Zero;
var aRC = new Geometry.Circle(Heroes.Player.ServerPosition.To2D(), 300).ToPolygon().ToClipperPath();
var tP = target.ServerPosition;
var pList = new List<Vector3>();
foreach (var p in aRC)
{
var v3 = new Vector2(p.X, p.Y).To3D();
if (!v3.UnderTurret(true) && v3.Distance(tP) > 325 && v3.Distance(tP) < Heroes.Player.AttackRange &&
(v3.CountEnemiesInRange(425) <= v3.CountAlliesInRange(325))) pList.Add(v3);
}
return pList.Count > 1 ? pList.OrderByDescending(el => el.Distance(tP)).FirstOrDefault() : Vector3.Zero;
}
public static FastPredResult FastPrediction(Vector2 from, Obj_AI_Base unit, int delay, int speed)
{
var tDelay = delay/1000f + (from.Distance(unit)/speed);
var d = tDelay*unit.MoveSpeed;
var path = unit.GetWaypoints();
if (path.PathLength() > d)
{
return new FastPredResult
{
IsMoving = true,
CurrentPos = unit.ServerPosition.To2D(),
PredictedPos = path.CutPath((int) d)[0]
};
}
if (path.Count == 0)
{
return new FastPredResult
{
IsMoving = false,
CurrentPos = unit.ServerPosition.To2D(),
PredictedPos = unit.ServerPosition.To2D()
};
}
return new FastPredResult
{
IsMoving = false,
CurrentPos = path[path.Count - 1],
PredictedPos = path[path.Count - 1]
};
}
public static PositionInfo InitPositionInfo(Vector2 pos, float extraDelayBuffer, float extraEvadeDistance, Vector2 lastMovePos, Spell lowestEvadeTimeSpell) //clean this shit up
{
var extraDist = Evade.menu.SubMenu("MiscSettings").SubMenu("ExtraBuffers").Item("ExtraCPADistance").GetValue<Slider>().Value;
var posInfo = canHeroWalkToPos(pos, myHero.MoveSpeed, extraDelayBuffer + Game.Ping, extraDist);
posInfo.isDangerousPos = CheckDangerousPos(pos, 6);
posInfo.hasExtraDistance = extraEvadeDistance > 0 ? CheckDangerousPos(pos, extraEvadeDistance) : false;// ? 1 : 0;
posInfo.closestDistance = posInfo.distanceToMouse;
posInfo.intersectionTime = GetIntersectTime(lowestEvadeTimeSpell, myHero.ServerPosition.To2D(), pos);
posInfo.distanceToMouse = pos.Distance(lastMovePos);
posInfo.posDistToChamps = GetDistanceToChampions(pos);
if (Evade.menu.SubMenu("MiscSettings").SubMenu("FastEvade").Item("RejectMinDistance").GetValue<Slider>().Value > 0
&& Evade.menu.SubMenu("MiscSettings").SubMenu("FastEvade").Item("RejectMinDistance").GetValue<Slider>().Value >
posInfo.closestDistance) //reject closestdistance
{
posInfo.rejectPosition = true;
}
if (Evade.menu.SubMenu("MiscSettings").SubMenu("ExtraBuffers").Item("MinComfortZone").GetValue<Slider>().Value >
posInfo.posDistToChamps)
{
posInfo.hasComfortZone = false;
}
return posInfo;
}
public Arc(Vector2 start, Vector2 end, int hitbox)
{
Start = start;
End = end;
HitBox = hitbox;
Distance = Start.Distance(End);
}
private static int CountEnemiesUltRange(Vector2 CastPosition)
{
int count = 0;
foreach (Vector3 EnemyPos in GetEnemyInPos())
if (CastPosition.Distance(EnemyPos) <= 425)
count++;
return count;
}
public static bool CanEscapeWithFlash(Vector2 pos)
{
foreach (Obj_AI_Turret turret in ObjectManager.Get<Obj_AI_Turret>().Where(turret => turret.IsEnemy && turret.Health > 0))
{
if (pos.Distance(turret.Position.To2D()) < (1800 + Player.BoundingRadius))
return true;
}
return false;
}
public static double AngleBetween(Vector2 a, Vector2 b, Vector2 c)
{
var a1 = c.Distance(b);
var b1 = a.Distance(c);
var c1 = b.Distance(a);
if (a1 == 0 || c1 == 0) { return 0; }
return Math.Acos((a1 * a1 + c1 * c1 - b1 * b1) / (2 * a1 * c1)) * (180 / Math.PI);
}
public static void Drawing_OnDraw()
{
Vector2 drakeWallQPos = new Vector2(12050, 4827);
Vector2 midWallQPos = new Vector2(6962, 8952);
if (drakeWallQPos.Distance(_Player) < 3000)
new Circle() { Color = _Player.Distance(drakeWallQPos) <= 100 ? Color.DodgerBlue : Color.White, Radius = 100 }.Draw(drakeWallQPos.To3D());
if (midWallQPos.Distance(_Player) < 3000)
new Circle() { Color = _Player.Distance(midWallQPos) <= 100 ? Color.DodgerBlue : Color.White, Radius = 100 }.Draw(midWallQPos.To3D());
}
/// <summary>
/// アイテムと自機の当たり判定
/// </summary>
/// <returns>
/// The collision detection.
/// </returns>
/// <param name='mySpritePosition'>
/// My sprite position.
/// </param>
public static Item1 ItemCollisionDetection(Vector2 mySpritePosition)
{
foreach(Item1 item in ItemList){
if(mySpritePosition.Distance(item.Sprite.Position) < 50){
return item;
}
}
return null;
}
/// <summary>
/// Gets closest on circle point
/// </summary>
/// <param name="center">Circle center</param>
/// <param name="radius">Circle radius</param>
/// <param name="pointStart">Point start</param>
/// <param name="pointEnd">Point end</param>
/// <returns></returns>
internal static Vector2 ClosestCirclePoint(Vector2 center, float radius, Vector2 pointStart, Vector2 pointEnd)
{
Vector2 point;
if (pointStart.Distance(center) < pointEnd.Distance(center))
point = pointStart;
else
point = pointEnd;
Vector2 v = (point - center);
return center + v / v.Length() * radius;
}
public static bool GetPredPos(Obj_AI_Hero enemy, bool additionalReactionTime = false, bool additionalBarrelTime = false)
{
PredPos = SPrediction.Prediction.GetFastUnitPosition(enemy, Config.Menu.Item("misc.enemyReactionTime").GetValue<Slider>().Value);
float reactionDistance = Config.Menu.Item("misc.enemyReactionTime").GetValue<Slider>().Value + (additionalReactionTime? Config.Menu.Item("misc.additionalReactionTime").GetValue<Slider>().Value : 0) * enemy.MoveSpeed*0.001f;
if (PredPos.Distance(enemy) > reactionDistance)
{
PredPos = enemy.Position.Extend(PredPos.To3D(), reactionDistance).To2D();
}
return true;
}
/// <summary>
/// Gets Aoe Prediction result
/// </summary>
/// <param name="width">Spell width</param>
/// <param name="delay">Spell delay</param>
/// <param name="missileSpeed">Spell missile speed</param>
/// <param name="range">Spell range</param>
/// <param name="from">Spell casted position</param>
/// <param name="rangeCheckFrom"></param>
/// <returns>Prediction result as <see cref="Prediction.AoeResult" /></returns>
public static Prediction.AoeResult GetAoePrediction(float width, float delay, float missileSpeed, float range,
Vector2 from, Vector2 rangeCheckFrom)
{
var result = new Prediction.AoeResult {HitCount = 0};
var enemies =
HeroManager.Enemies.Where(
p =>
p.IsValidTarget() &&
Prediction.GetFastUnitPosition(p, delay, 0, from).Distance(rangeCheckFrom) < range);
if (enemies.Count() > 0)
{
var posSummary = Vector2.Zero;
enemies.AsParallel()
.ForAll(p => posSummary += Prediction.GetFastUnitPosition(p, delay, missileSpeed, from));
var center = posSummary/enemies.Count();
float flyTime = 0;
if (missileSpeed != 0)
flyTime = from.Distance(center)/missileSpeed;
posSummary = Vector2.Zero;
var predictionResults = new List<Tuple<Prediction.Result, float>>();
foreach (var enemy in enemies)
{
var prediction = GetPrediction(enemy, width, delay + flyTime, 0, range, false, enemy.GetWaypoints(),
enemy.AvgMovChangeTime(), enemy.LastMovChangeTime(), enemy.AvgPathLenght(),
enemy.LastAngleDiff(), from, rangeCheckFrom);
if (prediction.HitChance > HitChance.Medium)
{
posSummary += prediction.UnitPosition;
predictionResults.Add(new Tuple<Prediction.Result, float>(prediction, enemy.BoundingRadius));
}
}
if (predictionResults.Count > 0)
{
center = posSummary/predictionResults.Count;
result.CastPosition = center;
foreach (var res in predictionResults)
{
if (
LeagueSharp.Common.Geometry.CircleCircleIntersection(center, res.Item1.UnitPosition, width,
res.Item2).Length > 1)
result.HitCount++;
}
}
predictionResults.Clear();
GC.Collect(GC.GetGeneration(predictionResults));
}
return result;
}
public static double BadaoAngleBetween(Vector2 a, Vector2 center, Vector2 c)
{
float a1 = c.Distance(center);
float b1 = a.Distance(c);
float c1 = center.Distance(a);
if (a1 == 0 || c1 == 0) { return 0; }
else
{
return Math.Acos((a1 * a1 + c1 * c1 - b1 * b1) / (2 * a1 * c1)) * (180 / Math.PI);
}
}
//-----------------------------------------------CountRHits(Vector2 CastPosition)-------------------------------------------
static int CountRHits(Vector2 CastPosition)
{
int Hits = new int();
foreach (Vector3 EnemyPos in GetEnemiesPosition())
{
if (CastPosition.Distance(EnemyPos) <= 260) Hits += 1;
}
return Hits;
}
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 Vector3 GetPositioning(this Obj_AI_Base target)
{
var cursorPos = Game.CursorPos;
//if the target is not a melee and he's alone he's not really a danger to us, proceed to 1v1 him :^ )
if (!target.IsMelee && Heroes.Player.CountEnemiesInRange(800) == 1) return cursorPos;
if (!cursorPos.IsDangerousPosition()) return cursorPos;
var aRC = new Geometry.Circle(Heroes.Player.ServerPosition.To2D(), 575).ToPolygon().ToClipperPath();
var targetPosition = Prediction.GetPrediction(target, 1800f).UnitPosition;
var pList = new List<Vector3>();
if (!cursorPos.IsDangerousPosition() || Player.UnderTurret() || Game.CursorPos.UnderTurret(true) || Player.CountEnemiesInRange(1400) == 1) return cursorPos;
foreach (var p in aRC)
{
var v3 = new Vector2(p.X, p.Y).To3D();
if (!v3.IsDangerousPosition() && v3.Distance(targetPosition) > 375 && v3.Distance(targetPosition) < 600) pList.Add(v3);
}
return pList.Count > 1 ? pList.OrderBy(el => el.Distance(cursorPos)).FirstOrDefault() : Vector3.Zero;
}
public static Vector2? GetFirstWallPoint(Vector2 from, Vector2 to, float step = 25)
{
var direction = (to - from).Normalized();
for (float d = 0; d < from.Distance(to); d = d + step)
{
var testPoint = from + d * direction;
var flags = NavMesh.GetCollisionFlags(testPoint.X, testPoint.Y);
if (flags.HasFlag(CollisionFlags.Wall) || flags.HasFlag(CollisionFlags.Building))
{
return from + (d - step) * direction;
}
}
return null;
}
//From B$.Common
public static Vector2[] CircleCircleIntersection(Vector2 center1, Vector2 center2, float radius1, float radius2)
{
var distance = center1.Distance(center2);
if (distance > radius1 + radius2 || (distance <= Math.Abs(radius1 - radius2)))
{
return new Vector2[] { };
}
var a = (radius1 * radius1 - radius2 * radius2 + distance * distance) / (2 * distance);
var h = (float)Math.Sqrt(radius1 * radius1 - a * a);
var direction = (center2 - center1).Normalized();
var pa = center1 + a * direction;
var intersection1 = pa + h * direction.Perpendicular();
var intersection2 = pa - h * direction.Perpendicular();
return new[] { intersection1, intersection2 };
}
public static Vector2[] CircleCircleIntersection(Vector2 center1, Vector2 center2, float radius1, float radius2)
{
var D = center1.Distance(center2);
if (D > radius1 + radius2 || (D <= Math.Abs(radius1 - radius2)))
{
return new Vector2[] { };
}
var A = (radius1 * radius1 - radius2 * radius2 + D * D) / (2 * D);
var H = (float)Math.Sqrt(radius1 * radius1 - A * A);
var Direction = (center2 - center1).Normalized();
var PA = center1 + A * Direction;
var S1 = PA + H * Direction.Perpendicular();
var S2 = PA - H * Direction.Perpendicular();
return new[] { S1, S2 };
}
public static bool CanReach(Vector2 start, Vector2 end, List<Geometry.Polygon> polygons, bool checkWalls = false)
{
if (start == end)
{
return false;
}
//TODO Disable if the distance to the start position is high
if (checkWalls)
{
var nPoints = 2;
var step = start.Distance(end) / nPoints;
var direction = (end - start).Normalized();
for (int i = 0; i <= nPoints; i++)
{
var p = start + i * step * direction;
if (p.IsWall())
{
return false;
}
}
}
foreach (var polygon in polygons)
{
for (int i = 0; i < polygon.Points.Count; i++)
{
var a = polygon.Points[i];
var b = polygon.Points[i == polygon.Points.Count - 1 ? 0 : i + 1];
if (Evade.Utils.LineSegmentsCross(start, end, a, b))
{
return false;
}
}
}
return true;
}
public static Vector3 GetAggressiveTumblePos(this Obj_AI_Base target)
{
var cursorPos = Game.CursorPos;
if (!cursorPos.IsDangerousPosition()) return cursorPos;
//if the target is not a melee and he's alone he's not really a danger to us, proceed to 1v1 him :^ )
if (!target.IsMelee && Heroes.Player.CountEnemiesInRange(800) == 1) return cursorPos;
var aRC = new Geometry.Circle(Heroes.Player.ServerPosition.To2D(), 300).ToPolygon().ToClipperPath();
var targetPosition = target.ServerPosition;
foreach (var p in aRC)
{
var v3 = new Vector2(p.X, p.Y).To3D();
var dist = v3.Distance(targetPosition);
if (dist > 325 && dist < 450)
{
return v3;
}
}
return Vector3.Zero;
}
