protected override void OnSimulate() { if (!CanMove) { return; } if (IsMoving) { if (canPathfind) { if (repathCount <= 0) { if (viableDestination) { if (Pathfinder.GetPathNode(cachedBody.Position.x, cachedBody.Position.y, out currentNode)) { if (straightPath) { if (forcePathfind || Pathfinder.NeedsPath(currentNode, destinationNode)) { if (Pathfinder.FindPath(Destination, currentNode, destinationNode, myPath)) { hasPath = true; pathIndex = 0; } else { if (IsFormationMoving) { StartMove(MyMovementGroup.Destination); IsFormationMoving = false; } } straightPath = false; repathCount = RepathRate; } else { repathCount = StraightRepathRate; } } else { if (forcePathfind || Pathfinder.NeedsPath(currentNode, destinationNode)) { if (Pathfinder.FindPath(Destination, currentNode, destinationNode, myPath)) { hasPath = true; pathIndex = 0; } else { if (IsFormationMoving) { StartMove(MyMovementGroup.Destination); IsFormationMoving = false; } } repathCount = RepathRate; } else { straightPath = true; repathCount = StraightRepathRate; } } } else { } } else { hasPath = false; if (IsFormationMoving) { StartMove(MyMovementGroup.Destination); IsFormationMoving = false; } } } else { if (hasPath) { repathCount--; } else { repathCount--; } } if (straightPath) { targetPos = Destination; } else if (hasPath) { if (pathIndex >= myPath.Count) { pathIndex = myPath.Count - 1; } targetPos = myPath[pathIndex]; } else { targetPos = Destination; } } else { targetPos = Destination; } movementDirection = targetPos - cachedBody.Position; movementDirection.Normalize(out distance); if (targetPos.x != lastTargetPos.x || targetPos.y != lastTargetPos.y) { lastTargetPos = targetPos; targetDirection = movementDirection; } if (distance > closingDistance) { desiredVelocity = (movementDirection); if (movementDirection.Cross(lastMovementDirection.x, lastMovementDirection.y) != 0) { lastMovementDirection = movementDirection; cachedTurn.StartTurnRaw(movementDirection); } } else { if (distance < FixedMath.Mul(closingDistance, CollisionStopMultiplier)) { Arrive(); return; } desiredVelocity = (movementDirection * (distance) / (closingDistance)); } desiredVelocity *= timescaledSpeed; cachedBody._velocity += (desiredVelocity - cachedBody._velocity) * timescaledAcceleration; if (distance <= closingDistance) { pathIndex++; } cachedBody.VelocityChanged = true; if (collidedWithTrackedAgent) { if (collidedCount >= CollisionStopCount) { collidedCount = 0; collidingAgent = null; Arrive(); } else { if (lastPosition.FastDistance(cachedBody.Position.x, cachedBody.Position.y) < collisionStopTreshold) { collidedCount++; } else { lastPosition = cachedBody.Position; collidedCount = 0; } } collidedWithTrackedAgent = false; } else { collidingAgent = null; collidedCount = 0; } } else { if (cachedBody.VelocityFastMagnitude > 0) { cachedBody._velocity -= cachedBody._velocity * timescaledAcceleration; cachedBody.VelocityChanged = true; } stopTime++; } }
public static long Cos(long theta) { long sin = Sin(theta); return(FixedMath.Sqrt(FixedMath.One - (sin.Mul(sin)))); }
public static long ToLong(this float f1) { return(FixedMath.Create(f1)); }
public Vector2d(Vector3 vec) { this.x = FixedMath.Create(vec.x); this.y = FixedMath.Create(vec.z); }
public GridSettings() { Init(256, 256, FixedMath.Create(-128), FixedMath.Create(-128), true); }
public Vector2d(Vector2 vec2) { this.x = FixedMath.Create(vec2.x); this.y = FixedMath.Create(vec2.y); }
public Vector3 ToVector3(float z = 0f) { return(new Vector3((float)FixedMath.ToDouble(this.x), z, (float)FixedMath.ToDouble(this.y))); }
public void Initialize(LSBody b1, LSBody b2) { IsValid = true; if (!IsValid) { return; } if (OnlyAffectBody1) { Body1 = b1; Body2 = b2; } else { if (b1.ID < b2.ID) { Body1 = b1; Body2 = b2; } else { Body1 = b2; Body2 = b1; } } _ranIndex = -1; _isColliding = false; DistX = 0; DistY = 0; PenetrationX = 0; PenetrationY = 0; FastCollideDistance = b1.Radius + b2.Radius; FastCollideDistance *= FastCollideDistance; LeCollisionType = CollisionType.None; if (Body1.Shape == ColliderType.None || Body2.Shape == ColliderType.None) { } else if (Body1.Shape == ColliderType.Circle) { if (Body2.Shape == ColliderType.Circle) { LeCollisionType = CollisionType.Circle_Circle; } else if (Body2.Shape == ColliderType.AABox) { LeCollisionType = CollisionType.Circle_AABox; } else if (Body2.Shape == ColliderType.Polygon) { LeCollisionType = CollisionType.Circle_Polygon; } } else if (Body1.Shape == ColliderType.AABox) { if (Body2.Shape == ColliderType.Circle) { LeCollisionType = CollisionType.Circle_AABox; } else if (Body2.Shape == ColliderType.AABox) { LeCollisionType = CollisionType.AABox_AABox; } else if (Body2.Shape == ColliderType.Polygon) { LeCollisionType = CollisionType.AABox_Polygon; } } else if (Body1.Shape == ColliderType.Polygon) { if (Body2.Shape == ColliderType.Circle) { LeCollisionType = CollisionType.Circle_Polygon; } else if (Body2.Shape == ColliderType.AABox) { LeCollisionType = CollisionType.AABox_Polygon; } else if (Body2.Shape == ColliderType.Polygon) { LeCollisionType = CollisionType.Polygon_Polygon; } } DoPhysics = ((Body1.IsTrigger || Body2.IsTrigger) == false); if (DoPhysics) { } //TODO: Space out checks when culled //TODO: The time between collision checks might cause goofy behavior //Maybe use a distance or velocity heuristic for culling instead of time since last collision //It wouldn't be able to replace partitions because of raycasts and fast-moving objects //Let's see if this works well or if something better is needed. if (Body1.PreventCulling || Body2.PreventCulling) { //Never cull CullCounter = -1; } else { //Immediately check collision CullCounter = 0; //If collision distance is too large, don't cull based on distance PreventDistanceCull = FastCollideDistance > PhysicsManager.CullFastDistanceMax; LastCollidedFrame = LockstepManager.FrameCount; FastDistanceOffset = FixedMath.Sqrt(FastCollideDistance >> FixedMath.SHIFT_AMOUNT) + FixedMath.One * 2; FastDistanceOffset *= FastDistanceOffset; } Active = true; _Version++; }
public static void FixedNumberField(string label, ref long Value, long max = 0) { var value = FixedMath.Create(EditorGUILayout.DoubleField(label, Math.Round(FixedMath.ToDouble(Value), 2, MidpointRounding.AwayFromZero))); if (max == 0 || value <= max) { Value = value; } else { Value = max; } }
public void update(float x, float y) { m_Center.x = FixedMath.Create(x); m_Center.y = FixedMath.Create(y); init(m_Center, m_Half.x, m_Half.y); }
internal void DistributeCollision() { if (!DoPhysics) { return; } switch (LeCollisionType) { case CollisionType.Circle_Circle: dist = FixedMath.Sqrt(FastDistance >> FixedMath.SHIFT_AMOUNT); depth = (Body1.Radius + Body2.Radius - dist); if (depth <= 0) { return; } if (dist == 0) { dist = 1; } //Minimum vector to no longer be colliding DistX = (DistX * depth / dist); DistY = (DistY * depth / dist); //Resolving collision //Note: Immovable bodies don't check collision against each other so this case doesn't need to be considered if (Body1.Immovable || (Body2.Immovable == false && Body1.Priority > Body2.Priority)) { //Invert adjustment values when Body2 is being moved DistX *= -1; DistY *= -1; DistributeCircle_CirclePriority(Body1, Body2); } else { if (OnlyAffectBody1) { return; } if (Body2.Immovable || Body2.Priority > Body1.Priority) { DistributeCircle_CirclePriority(Body2, Body1); } else { DistX /= 2; DistY /= 2; DistributeCircle(Body1); DistX *= -1; DistY *= -1; DistributeCircle(Body2); } } break; case CollisionType.Circle_AABox: if (Body1.Shape == ColliderType.AABox) { DistributeCircle_Box(Body1, Body2); } else { DistributeCircle_Box(Body2, Body1); } break; case CollisionType.Circle_Polygon: if (Body1.Shape == ColliderType.Circle) { this.DistributeCircle_Poly(Body1, Body2); } else { this.DistributeCircle_Poly(Body2, Body1); } break; } }
public bool Overlaps(FastList <Vector2d> outputIntersectionPoints) { outputIntersectionPoints.FastClear(); //Checks if this object overlaps the line formed by p1 and p2 switch (this.Shape) { case ColliderType.Circle: { bool overlaps = false; //Check if the circle completely fits between the line long projPos = this._position.Dot(cacheAxis.x, cacheAxis.y); //Circle withing bounds? if (projPos >= axisMin && projPos <= axisMax) { long projPerp = this._position.Dot(cacheAxisNormal.x, cacheAxisNormal.y); long perpDif = (cacheProjPerp - projPerp); long perpDist = perpDif.Abs(); if (perpDist <= _radius) { overlaps = true; } if (overlaps) { long sin = (perpDif); long cos = FixedMath.Sqrt(_radius.Mul(_radius) - sin.Mul(sin)); if (cos == 0) { outputIntersectionPoints.Add((cacheAxis * projPos) + perpVector); } else { outputIntersectionPoints.Add(cacheAxis * (projPos - cos) + perpVector); outputIntersectionPoints.Add(cacheAxis * (projPos + cos) + perpVector); } } } else { //If not, check distances to points long p1Dist = _position.FastDistance(cacheP1.x, cacheP2.y); if (p1Dist <= this.FastRadius) { outputIntersectionPoints.Add(cacheP1); overlaps = true; } long p2Dist = _position.FastDistance(cacheP2.x, cacheP2.y); if (p2Dist <= this.FastRadius) { outputIntersectionPoints.Add(cacheP2); overlaps = true; } } return(overlaps); } //break; case ColliderType.AABox: { } break; case ColliderType.Polygon: { bool intersected = false; for (int i = 0; i < this.Vertices.Length; i++) { int edgeIndex = i; Vector2d pivot = this.RealPoints [edgeIndex]; Vector2d edge = this.Edges [edgeIndex]; long proj1 = 0; int nextIndex = edgeIndex + 1 < this.RealPoints.Length ? edgeIndex + 1 : 0; Vector2d nextPoint = RealPoints [nextIndex]; long proj2 = (nextPoint - pivot).Dot(edge); long min; long max; if (proj1 < proj2) { min = proj1; max = proj2; } else { min = proj2; max = proj1; } long lineProj1 = (cacheP1 - pivot).Dot(edge); long lineProj2 = (cacheP2 - pivot).Dot(edge); long lineMin; long lineMax; if (lineProj1 < lineProj2) { lineMin = lineProj1; lineMax = lineProj2; } else { lineMin = lineProj2; lineMax = lineProj1; } if (CollisionPair.CheckOverlap(min, max, lineMin, lineMax)) { Vector2d edgeNorm = this.EdgeNorms [edgeIndex]; long normProj = 0; long normLineProj1 = (cacheP1 - pivot).Dot(edgeNorm); long normLineProj2 = (cacheP2 - pivot).Dot(edgeNorm); long normLineMin; long normLineMax; if (normLineProj1 < normLineProj2) { normLineMin = normLineProj1; normLineMax = normLineProj2; } else { normLineMin = normLineProj2; normLineMax = normLineProj1; } if (normProj >= normLineMin && normProj <= normLineMax) { long revProj1 = pivot.Dot(LSBody.cacheAxisNormal); long revProj2 = nextPoint.Dot(cacheAxisNormal); long revMin; long revMax; if (revProj1 < revProj2) { revMin = revProj1; revMax = revProj2; } else { revMin = revProj2; revMax = revProj1; } if (LSBody.cacheProjPerp >= revMin && LSBody.cacheProjPerp <= revMax) { intersected = true; if (LSBody.calculateIntersections) { long fraction = normLineProj1.Abs().Div(normLineMax - normLineMin); long intersectionProj = FixedMath.Lerp(lineProj1, lineProj2, fraction); outputIntersectionPoints.Add(edge * intersectionProj + pivot); if (outputIntersectionPoints.Count == 2) { break; } } } } } } return(intersected); } //break; } return(false); }
protected override void OnSimulate() { if (!CanMove) { return; } if (IsMoving) { Agent.SetState(AnimState.Moving); if (CanPathfind) { if (DoPathfind) { DoPathfind = false; if (viableDestination) { if (Pathfinder.GetStartNode(cachedBody.Position, out currentNode)) { if (currentNode.DoesEqual(this.destinationNode)) { if (this.RepathTries >= 1) { this.Arrive(); } } else { if (straightPath) { if (Pathfinder.NeedsPath(currentNode, destinationNode, this.GridSize)) { if (Pathfinder.FindPath(Destination, currentNode, destinationNode, myPath, GridSize, GetNodeHash(destinationNode))) { hasPath = true; pathIndex = 0; } else { if (IsFormationMoving) { StartMove(MyMovementGroup.Destination); IsFormationMoving = false; } } straightPath = false; } else { } } else { if (Pathfinder.NeedsPath(currentNode, destinationNode, this.GridSize)) { if (Pathfinder.FindPath(Destination, currentNode, destinationNode, myPath, GridSize, GetNodeHash(destinationNode))) { hasPath = true; pathIndex = 0; } else { if (IsFormationMoving) { StartMove(MyMovementGroup.Destination); IsFormationMoving = false; } } } else { straightPath = true; } } } } else { } } else { hasPath = false; if (IsFormationMoving) { StartMove(MyMovementGroup.Destination); IsFormationMoving = false; } } } else { } if (straightPath) { targetPos = Destination; } else if (hasPath) { if (pathIndex >= myPath.Count) { targetPos = this.Destination; } else { targetPos = myPath [pathIndex]; } } else { targetPos = Destination; } } else { targetPos = Destination; } movementDirection = targetPos - cachedBody._position; movementDirection.Normalize(out distance); if (targetPos.x != lastTargetPos.x || targetPos.y != lastTargetPos.y) { lastTargetPos = targetPos; targetDirection = movementDirection; } bool movingToWaypoint = (this.hasPath && this.pathIndex < myPath.Count - 1); long stuckThreshold = 1; if (distance > closingDistance || movingToWaypoint) { desiredVelocity = (movementDirection); if (CanTurn) { CachedTurn.StartTurnDirection(movementDirection); } stuckThreshold = this.timescaledAcceleration / 4; } else { if (distance < FixedMath.Mul(closingDistance, StopMultiplier)) { Arrive(); return; } if (this.SlowArrival) { long closingSpeed = distance.Div(closingDistance); desiredVelocity = movementDirection * (closingSpeed); stuckThreshold = closingSpeed / LockstepManager.FrameRate; } else { desiredVelocity = (movementDirection); stuckThreshold = this.timescaledAcceleration; } } //If unit has not moved stuckThreshold in a frame, it's stuck StuckTime++; if (GetCanAutoStop()) { if (Agent.Body.Position.FastDistance(AveragePosition) <= (stuckThreshold * stuckThreshold)) { if (StuckTime > StuckTimeThreshold) { if (movingToWaypoint) { this.pathIndex++; } else { if (RepathTries < StuckRepathTries) { DoPathfind = true; RepathTries++; } else { RepathTries = 0; this.Arrive(); } } StuckTime = 0; } } else { if (StuckTime > 0) { StuckTime -= 1; } RepathTries = 0; } } if (movingToWaypoint) { if ( ( this.pathIndex >= 0 && distance < closingDistance && (movementDirection).Dot(waypointDirection) < 0 ) || distance < FixedMath.Mul(closingDistance, FixedMath.Half)) { this.pathIndex++; } } desiredVelocity *= Speed; cachedBody._velocity += GetAdjustVector(desiredVelocity); cachedBody.VelocityChanged = true; } else { //Slowin' down if (cachedBody.VelocityFastMagnitude > 0) { cachedBody.Velocity += GetAdjustVector(Vector2d.zero); } StoppedTime++; } AutoStopPauser--; CollisionStopPauser--; StopPauseLooker--; AveragePosition = AveragePosition.Lerped(Agent.Body.Position, FixedMath.One / 2); }
public Vector3d(int X, int Y, int Z) { this.x = FixedMath.Create(X); this.y = FixedMath.Create(Y); this.z = FixedMath.Create(Z); }
private void DistributeCollision() { if (Body1.OnContact.IsNotNull()) { Body1.OnContact(Body2); } if (Body2.OnContact.IsNotNull()) { Body2.OnContact(Body1); } if (Body1.IsTrigger || Body2.IsTrigger) { return; } switch (LeCollisionType) { case CollisionType.Circle_Circle: DistX = Body1._position.x - Body2._position.x; DistY = Body1._position.y - Body2._position.y; dist = FixedMath.Sqrt((DistX * DistX + DistY * DistY) >> FixedMath.SHIFT_AMOUNT); if (dist == 0) { const int randomMax = (int)((long)int.MaxValue % (FixedMath.One / 64)); Body1._position.x += LSUtility.GetRandom(randomMax) - randomMax / 2; Body1._position.y += LSUtility.GetRandom(randomMax) - randomMax / 2; Body1.PositionChanged = true; Body2._position.x += LSUtility.GetRandom(randomMax) - randomMax / 2; Body2._position.y += LSUtility.GetRandom(randomMax) - randomMax / 2; Body2.PositionChanged = true; return; } depth = (Body1.Radius + Body2.Radius - dist); if (depth <= 0) { return; } DistX = (DistX * depth / dist) / 2L; DistY = (DistY * depth / dist) / 2L; //Switch, used to be const bool applyVelocity = false; //Resolving collision if (Body1.Immovable && Body1.isActiveAndEnabled || (Body2.Immovable == false && Body1.Priority > Body2.Priority)) { Body2._position.x -= DistX; Body2._position.y -= DistY; Body2.PositionChanged = true; if (applyVelocity) { Body2._velocity.x -= DistX; Body2.VelocityChanged = true; } } else if (Body2.Immovable || Body2.Priority > Body1.Priority) { Body1._position.x += DistX; Body1._position.y += DistY; Body1.PositionChanged = true; if (applyVelocity) { Body1._velocity.x += DistX; Body1._velocity.y += DistY; Body1.VelocityChanged = true; } } else { DistX /= 2; DistY /= 2; Body1._position.x += DistX; Body1._position.y += DistY; Body2._position.x -= DistX; Body2._position.y -= DistY; Body1.PositionChanged = true; Body2.PositionChanged = true; if (applyVelocity) { DistX /= 8; DistY /= 8; Body1._velocity.x += DistX; Body1._velocity.y += DistY; Body1.VelocityChanged = true; Body2._velocity.x -= DistX; Body2._velocity.y -= DistY; Body2.VelocityChanged = true; } } break; case CollisionType.Circle_AABox: if (Body1.Shape == ColliderType.AABox) { DistributeCircle_Box(Body1, Body2); } else { DistributeCircle_Box(Body2, Body1); } break; case CollisionType.Circle_Polygon: if (Body1.Shape == ColliderType.Circle) { this.DistributeCircle_Poly(Body1, Body2); } else { this.DistributeCircle_Poly(Body2, Body1); } break; } }
public static double Round(long value) { return(Math.Round(FixedMath.ToDouble(value), 2, MidpointRounding.AwayFromZero)); }
protected override void OnSimulate() { if (!CanMove) { return; } if (IsMoving) { if (CanPathfind) { if (repathCount <= 0) { if (viableDestination) { if (Pathfinder.GetPathNode(cachedBody._position.x, cachedBody._position.y, out currentNode)) { if (straightPath) { if (forcePathfind || Pathfinder.NeedsPath(currentNode, destinationNode, this.GridSize)) { if (Pathfinder.FindPath(Destination, currentNode, destinationNode, myPath, GridSize)) { hasPath = true; pathIndex = 0; } else { if (IsFormationMoving) { StartMove(MyMovementGroup.Destination); IsFormationMoving = false; } } straightPath = false; repathCount = RepathRate; } else { repathCount = StraightRepathRate; } } else { if (forcePathfind || Pathfinder.NeedsPath(currentNode, destinationNode, this.GridSize)) { if (Pathfinder.FindPath(Destination, currentNode, destinationNode, myPath, GridSize)) { hasPath = true; pathIndex = 0; } else { if (IsFormationMoving) { StartMove(MyMovementGroup.Destination); IsFormationMoving = false; } } repathCount = RepathRate; } else { straightPath = true; repathCount = StraightRepathRate; } } } else { } } else { hasPath = false; if (IsFormationMoving) { StartMove(MyMovementGroup.Destination); IsFormationMoving = false; } } } else { if (hasPath) { //TODO: fix this shit repathCount--; } else { repathCount--; } } if (straightPath) { targetPos = Destination; } else if (hasPath) { if (pathIndex >= myPath.Count) { targetPos = this.Destination; } else { targetPos = myPath [pathIndex]; } } else { targetPos = Destination; } } else { targetPos = Destination; } movementDirection = targetPos - cachedBody._position; movementDirection.Normalize(out distance); if (targetPos.x != lastTargetPos.x || targetPos.y != lastTargetPos.y) { lastTargetPos = targetPos; targetDirection = movementDirection; } bool movingToWaypoint = (this.hasPath && this.pathIndex < myPath.Count - 1); if (distance > closingDistance || movingToWaypoint) { desiredVelocity = (movementDirection); if (movementDirection.Cross(lastMovementDirection.x, lastMovementDirection.y).AbsMoreThan(FixedMath.Half)) { lastMovementDirection = movementDirection; if (CanTurn) { CachedTurn.StartTurnDirection(movementDirection); } } } else { if (distance < FixedMath.Mul(closingDistance, CollisionStopMultiplier)) { Arrive(); return; } desiredVelocity = (movementDirection * (distance) / (closingDistance)); } if (movingToWaypoint) { if (distance < FixedMath.Mul(closingDistance, FixedMath.One)) { this.pathIndex++; } } desiredVelocity *= timescaledSpeed; cachedBody._velocity += (desiredVelocity - cachedBody._velocity) * timescaledAcceleration; cachedBody.VelocityChanged = true; } else { if (cachedBody.VelocityFastMagnitude > 0) { cachedBody._velocity -= cachedBody._velocity * timescaledAcceleration; cachedBody.VelocityChanged = true; } stopTime++; } }
public static void DoubleField(Rect position, GUIContent label, ref long value, bool timescaled = false) { double scale = Scale(timescaled); value = FixedMath.Create(EditorGUI.DoubleField(position, label, value.ToDouble() * scale) / scale); }
public Vector2d(float xFloat, float yFloat) { this.x = FixedMath.Create(xFloat); this.y = FixedMath.Create(yFloat); }
public static void FixedNumberField(GUIContent content, int Rounding, ref long Value) { Value = FixedMath.Create(EditorGUILayout.DoubleField(content, Math.Round(FixedMath.ToDouble(Value), Rounding, MidpointRounding.AwayFromZero))); }
public Vector2d(double xDoub, double yDoub) { this.x = FixedMath.Create(xDoub); this.y = FixedMath.Create(yDoub); }
public static long GetRandomOne() { return(FixedMath.Create(GetRandom(), int.MaxValue)); }
public long z; //Height public Vector3d(Vector3 vec3) { this.x = FixedMath.Create(vec3.x); this.y = FixedMath.Create(vec3.z); this.z = FixedMath.Create(vec3.y); }
/// <summary> /// World pos to relative position on grid. /// </summary> /// <returns>The relative x.</returns> /// <param name="xPos">X position.</param> public static long GetRelativeX(long xPos) { return((xPos >> AdditionalShiftSize) - (FixedMath.Create(BoundX))); }
void BehaveWithTarget() { if (Target.IsActive == false || Target.SpawnVersion != targetVersion) { StopEngage(); BehaveWithNoTarget(); return; } Vector2d targetDirection = Target.Body._position - cachedBody._position; long fastMag = targetDirection.FastMagnitude(); if (fastMag <= fastRangeToTarget) { if (!inRange) { if (CanMove) { cachedMove.StopMove(); } } Agent.SetState(AnimState.Engaging); long mag = FixedMath.Sqrt(fastMag >> FixedMath.SHIFT_AMOUNT); //cachedTurn.StartTurn(targetDirection / mag); bool withinTurn = TrackAttackAngle == false || (fastMag != 0 && cachedBody._rotation.Dot(targetDirection.x, targetDirection.y) > 0 && cachedBody._rotation.Cross(targetDirection.x, targetDirection.y).Abs() <= AttackAngle); bool needTurn = mag != 0 && !withinTurn; if (needTurn) { if (CanTurn) { targetDirection /= mag; cachedTurn.StartTurn(targetDirection); } } else { if (attackCount <= 0) { attackCount = attackFrameCount; Fire(); } } if (inRange == false) { inRange = true; } } else { if (CanMove) { if (cachedMove.IsMoving == false) { cachedMove.StartMove(Target.Body._position); cachedBody.Priority = basePriority; } else { if (Target.Body.PositionChanged || inRange) { cachedMove.Destination = Target.Body._position; } } } if (isAttackMoving || isFocused == false) { searchCount -= 1; if (searchCount <= 0) { searchCount = SearchRate; if (ScanAndEngage()) { } else { } } } if (inRange == true) { inRange = false; } } }
public static long GetRelativeY(long yPos) { return((yPos >> AdditionalShiftSize) - (FixedMath.Create(BoundY))); }
public static double ToFormattedDouble(this long f1) { return(Math.Round(FixedMath.ToDouble(f1), 2, MidpointRounding.AwayFromZero)); }
public static long GetWorldY(int gridY) { return((FixedMath.Create(gridY + BoundY)) << AdditionalShiftSize); }
public void Simulate() { if (PositionChanged || RotationChanged) { if (PositionChanged) { FuturePosition.x = Position.x + Velocity.x * PhysicsManager.ColSpreadMul; FuturePosition.y = Position.y + Velocity.y * PhysicsManager.ColSpreadMul; this.transform.position = Position.ToVector3(this.transform.position.y); } else { } if (RotationChanged) { this.transform.rotation = Quaternion.LookRotation(new Vector3(FixedMath.ToFloat(Rotation.x), 0, FixedMath.ToFloat(Rotation.y))); } else { } BuildPoints(); BuildBounds(); PositionChanged = false; RotationChanged = false; } else { } }
/// <summary> /// This vector's magnitude. /// </summary> public long Magnitude() { return(FixedMath.Sqrt((this.x * this.x + this.y * this.y) >> FixedMath.SHIFT_AMOUNT)); }