public static int GenerateDeltaCount(int size)
{
long fixSize = FixedMath.Create(size);
int ret = FixedMath.Mul(FixedMath.Mul(fixSize, fixSize), FixedMath.Pi).CeilToInt();
return(ret);
}
protected override void OnSimulate()
{
if (!CanMove)
{
return;
}
//TODO: Organize/split this function
if (IsMoving)
{
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 = timescaledAcceleration / LockstepManager.FrameRate;
long slowDistance = cachedBody.VelocityMagnitude.Div(timescaledDecceleration);
if (distance > slowDistance || movingToWaypoint)
{
desiredVelocity = (movementDirection);
if (CanTurn)
{
cachedTurn.StartTurnDirection(movementDirection);
}
}
else
{
if (distance < FixedMath.Mul(closingDistance, StopMultiplier))
{
Arrive();
//TODO: Don't skip this frame of slowing down
return;
}
if (distance > closingDistance)
{
if (CanTurn)
{
cachedTurn.StartTurnDirection(movementDirection);
}
}
if (distance <= slowDistance)
{
long closingSpeed = distance.Div(slowDistance);
if (CanTurn)
{
cachedTurn.StartTurnDirection(movementDirection);
}
desiredVelocity = movementDirection * closingSpeed;
decellerating = true;
//Reduce occurence of units preventing other units from reaching destination
stuckThreshold *= 4;
}
}
//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
{
decellerating = true;
//Slowin' down
if (cachedBody.VelocityMagnitude > 0)
{
cachedBody.Velocity += GetAdjustVector(Vector2d.zero);
}
StoppedTime++;
}
decellerating = false;
AutoStopPauser--;
CollisionStopPauser--;
StopPauseLooker--;
AveragePosition = AveragePosition.Lerped(Agent.Body.Position, FixedMath.One / 2);
}