/// <summary>
/// Sends out all Commands
/// </summary>
public static void SendOut()
{
if (outCommands.Count > 0)
{
bufferedBytes.FastClear();
for (int i = 0; i < outCommands.Count; i++)
{
bufferedBytes.AddRange(outCommands [i].Serialized);
}
if (bufferedBytes.Count > 0)
{
ClientManager.Distribute(bufferedBytes.ToArray());
}
outCommands.FastClear();
}
}
public void Setup(IAgentData interfacer)
{
gameObject.SetActive(true);
LoadComponents();
GameObject.DontDestroyOnLoad(gameObject);
setupAbilitys.FastClear();
MyAgentCode = interfacer.Name;
Data = interfacer;
SpawnVersion = 1;
CheckCasting = true;
Influencer = new LSInfluencer();
if (_visualCenter == null)
{
_visualCenter = CachedTransform;
}
if (Animator.IsNotNull())
{
Animator.Setup();
}
abilityManager.Setup(this);
Ringer = RingController.Create();
if (Ringer.IsNotNull())
{
Ringer.Setup(this);
}
Influencer.Setup(this);
Body.Setup(this);
SelectionRadiusSquared = _selectionRadius * _selectionRadius;
if (StatsBarer != null)
{
StatsBarer.Setup(this);
}
this.RegisterLockstep();
}
void UpdateCoordinates()
{
const long gridSpacing = FixedMath.One;
bufferCoordinates.FastClear();
CachedBody.GetCoveredSnappedPositions(gridSpacing, bufferCoordinates);
foreach (Vector2d vec in bufferCoordinates)
{
GridNode node = GridManager.GetNode(vec.x, vec.y);
if (node == null)
{
continue;
}
node.AddObstacle();
LastCoordinates.Add(node);
}
}
public void Initialize()
{
Diplomacy.FastClear();
for (int i = 0; i < TeamManager.Teams.Count; i++)
{
Team team = TeamManager.Teams[i];
if (team != this)
{
this.SetAllegiance(team, AllegianceType.Neutral);
}
}
TeamManager.UpdateDiplomacy(this);
TeamManager.Teams.Add(this);
this.SetAllegiance(this, AllegianceType.Friendly);
MainController = AgentController.Create();
MainController.JoinTeam(this);
}
public static bool FindPath(Vector2d Start, Vector2d End, FastList <Vector2d> outputVectorPath)
{
if (!GetPathNodes(Start.x, Start.y, End.x, End.y, out node1, out node2))
{
return(false);
}
if (FindPath(node1, node2, OutputPath))
{
outputVectorPath.FastClear();
length = OutputPath.Count - 1;
for (i = 0; i < length; i++)
{
outputVectorPath.Add(OutputPath [i].WorldPos);
}
outputVectorPath.Add(End);
return(true);
}
return(false);
}
public static void Simulate()
{
if (Offline)
{
ReceivedBytes.AddRange(BitConverter.GetBytes(LockstepManager.FrameCount));
for (i = 0; i < OutCommands.Count; i++)
{
ReceivedBytes.AddRange(OutCommands [i].Serialized);
}
AllReceivedBytes.AddRange(BitConverter.GetBytes(ReceivedBytes.Count));
AllReceivedBytes.AddRange(ReceivedBytes);
}
else
{
}
int frameCount = BitConverter.ToInt32(ReceivedBytes.innerArray, 0);
Index = 4;
FrameManager.EnsureCapacity(frameCount + 1);
Frame frame;
if (!FrameManager.HasFrame [frameCount])
{
frame = new Frame();
FrameManager.AddFrame(frameCount, frame);
while (Index < ReceivedBytes.Count)
{
Command com = new Command();
Index += com.Reconstruct(ReceivedBytes.innerArray, Index);
frame.AddCommand(com);
}
}
ReceivedBytes.FastClear();
OutCommands.FastClear();
}
public static IEnumerator StreamPlayback(Replay playbackReplay)
{
int lastFrameByteCount = 0;
int playbackPosition = 0;
byte[] playbackBytes = playbackReplay.Content;
bool getNextStream = true;
int frameCount = 0;
int nextFrame = -1;
yield return(null);
FrameManager.EndFrame = playbackReplay.LastCommandedFrameCount;
while (playbackPosition < playbackBytes.Length || frameCount <= nextFrame)
{
if (getNextStream == true)
{
bufferBytes.FastClear();
lastFrameByteCount = (int)BitConverter.ToUInt16(playbackBytes, playbackPosition);
playbackPosition += 2;
nextFrame = BitConverter.ToInt32(playbackBytes, playbackPosition);
bufferBytes.AddRange(playbackBytes, playbackPosition, lastFrameByteCount);
playbackPosition += lastFrameByteCount;
getNextStream = false;
}
if (nextFrame == frameCount)
{
getNextStream = true;
CommandManager.ProcessPacket(bufferBytes);
}
else
{
CommandManager.ProcessPacket(BitConverter.GetBytes(frameCount));
}
frameCount++;
}
yield break;
}
static IEnumerator Tick()
{
float accumulator = 0;
while (true)
{
if (IsSimulating && LockstepManager.GameStarted)
{
bufferBytes.FastClear();
bufferBytes.AddRange(BitConverter.GetBytes(InfluenceFrameCount));
InfluenceFrameCount++;
bufferBytes.AddRange(receivedBytes);
receivedBytes.FastClear();
Send(bufferBytes.ToArray());
}
accumulator = 0;
yield return(LSUtility.WaitRealTime(LockstepManager.BaseDeltaTime * LockstepManager.InfluenceResolution));
}
yield break;
}
public static bool FindPath(Vector2d End, GridNode startNode, GridNode endNode, FastList <Vector2d> outputVectorPath)
{
if (startNode.Unwalkable || endNode.Unwalkable)
{
return(false);
}
if (FindPath(startNode, endNode, OutputPath))
{
outputVectorPath.FastClear();
length = OutputPath.Count - 1;
for (i = 0; i < length; i++)
{
outputVectorPath.Add(OutputPath [i].WorldPos);
}
outputVectorPath.Add(End);
return(true);
}
return(false);
}
public void RaycastMove(Vector3d delta)
{
#if true
Vector3d nextPosition = this.Position;
nextPosition.Add(ref delta);
HitBodies.FastClear();
foreach (LSBody body in Raycaster.RaycastAll(this.Position, nextPosition))
{
if (this.BodyConditional(body))
{
HitBodies.Add(body);
}
}
if (HitBodies.Count > 0)
{
Hit();
}
this.Position = nextPosition;
#endif
}
public static bool FindPath(Vector2d Start, Vector2d End, FastList <Vector2d> outputVectorPath, int unitSize = 1)
{
bool canAddEnd = false;
if (!GetPathNodes(Start.x, Start.y, End.x, End.y, out node1, out node2, out canAddEnd))
{
return(false);
}
if (!NeedsPath(node1, node2, unitSize))
{
if (canAddEnd)
{
outputVectorPath.Add(End);
}
else
{
outputVectorPath.Add(node2.WorldPos);
}
return(true);
}
if (FindPath(node1, node2, OutputPath, unitSize))
{
outputVectorPath.FastClear();
length = OutputPath.Count;
for (i = 0; i < length; i++)
{
outputVectorPath.Add(OutputPath[i].WorldPos);
}
if (canAddEnd)
{
outputVectorPath.Add(End);
}
else
{
outputVectorPath.Add(node2.WorldPos);
}
return(true);
}
return(false);
}
private void Serialize()
{
Data.FastClear();
ushort highestID = 0;
for (int i = 0; i < selectedAgentLocalIDs.Count; i++)
{
ushort id = selectedAgentLocalIDs[i];
if (id > highestID)
{
highestID = id;
}
}
int headerLength = (highestID + 1 - 1) / 8 + 1;
Header = new BitArray(headerLength, false);
for (int i = 0; i < selectedAgentLocalIDs.Count; i++)
{
SerializeID(selectedAgentLocalIDs[i]);
}
}
public static void Initialize()
{
CollisionIterationCount = CollisionIterationSpread;
CollisionIterationMark = 0;
CollisionIterationRemain = 0;
PeakCount = 0;
CachedIDs.FastClear();
Array.Clear(SimObjects, 0, SimObjects.Length);
Array.Clear(SimObjectExists, 0, SimObjectExists.Length);
Array.Clear(CollisionPairs, 0, CollisionPairs.Length);
CachedIDs.Clear();
PeakCount = 0;
AssimilatedCount = 0;
CollisionPairCount = 0;
FastCollisionPairs.FastClear();
Partition.Initialize();
}
public void Setup(IAgentData interfacer)
{
gameObject.SetActive(true);
LoadComponents();
GameObject.DontDestroyOnLoad(gameObject);
setupAbilitys.FastClear();
MyAgentCode = interfacer.Name;
Data = interfacer;
SpawnVersion = 1;
CheckCasting = true;
Influencer = new LSInfluencer();
if (_visualCenter == null)
{
_visualCenter = CachedTransform;
}
if (Animator.IsNotNull())
{
Animator.Setup();
}
Body = UnityBody.InternalBody;
Body.Setup(this);
abilityManager.Setup(this);
Influencer.Setup(this);
SelectionRadiusSquared = SelectionRadius * SelectionRadius;
this.RegisterLockstep();
Setuped = true;
}
public static void Initialize()
{
PressedInputs = 0;
PressedDownInputs = 0;
PressedUpInputs = 0;
InputCount = 0;
inputPairs.FastClear();
AddInput(InputCode.Q, KeyCode.Q);
AddInput(InputCode.W, KeyCode.W);
AddInput(InputCode.E, KeyCode.E);
AddInput(InputCode.R, KeyCode.R);
AddInput(InputCode.A, KeyCode.A);
AddInput(InputCode.S, KeyCode.S);
AddInput(InputCode.D, KeyCode.D);
AddInput(InputCode.F, KeyCode.F);
AddInput(InputCode.Z, KeyCode.Z);
AddInput(InputCode.X, KeyCode.X);
AddInput(InputCode.C, KeyCode.C);
AddInput(InputCode.V, KeyCode.V);
AddInput(InputCode.M, KeyCode.M);
}
public static void Initialize()
{
PeakCount = 0;
CachedIDs.FastClear();
SimObjectExists.Clear();
//CollisionPairs.Clear ();
//SimObjects.Clear ();
CollisionPair.CurrentCollisionPair = null;
PeakCount = 0;
AssimilatedCount = 0;
FastCollisionPairs.FastClear();
Partition.Initialize();
if (SettingsChanged)
{
SettingsChanged = false;
}
}
private static void DestinationReached()
{
outputPath.FastClear();
TracePath.FastClear();
currentNode = endNode;
StartNodeIndex = startNode.gridIndex;
while (currentNode.gridIndex != StartNodeIndex)
{
TracePath.Add(currentNode);
oldNode = currentNode;
currentNode = currentNode.parent;
}
#if true
oldX = 0;
oldY = 0;
currentNode = TracePath[TracePath.Count - 1];
for (i = TracePath.Count - 2; i >= 0; i--)
{
oldNode = currentNode;
currentNode = TracePath.innerArray [i];
newX = currentNode.gridX - oldNode.gridX;
newY = currentNode.gridY - oldNode.gridY;
#if true
if (newX != oldX || newY != oldY)
{
outputPath.Add(oldNode);
oldX = newX;
oldY = newY;
}
#else
outputPath.Add(currentNode);
#endif
}
#endif
}
/// <summary>
/// Registers an object and returns a ticket to access variable info about the object.
/// Note: Ticket may vary on multiple clients and sessions.
/// </summary>
/// <param name="lockstepObject">Lockstep object.</param>
public static int Register(object lockstepObject)
{
Type type = lockstepObject.GetType();
string[] propertyNames;
LSVariableContainer container;
if (!CachedLockstepPropertyNames.TryGetValue(type, out propertyNames))
{
bufferPropertyNames.FastClear();
container = new LSVariableContainer(GetVariables(lockstepObject, type));
foreach (LSVariable info in container.Variables)
{
bufferPropertyNames.Add(info.Info.Name);
}
CachedLockstepPropertyNames.Add(type, bufferPropertyNames.ToArray());
}
else
{
container = new LSVariableContainer(GetVariables(lockstepObject, type, propertyNames));
}
return(Containers.Add(container));
}
public byte[] GetBytes () {
this.Serialize();
bufferBites.FastClear();
//Serialize header
int headerLength = Header.Length;
int headerArraySize = (headerLength - 1) / 8 + 1;
bufferBites.Add((byte)headerArraySize);
byte[] headerBytes = new byte[headerArraySize];
Header.CopyTo(headerBytes, 0);
bufferBites.AddRange(headerBytes);
//Serializing the good stuff
for (int i = 0; i < Header.Length; i++) {
if (Header.Get(i)) {
bufferBites.Add(Data[i]);
}
}
return bufferBites.ToArray();
}
public void Serialize(FastEnumerable <LSAgent> selectedAgents)
{
Data.FastClear();
selectedAgentLocalIDs.FastClear();
bufferAgents.FastClear();
selectedAgents.Enumerate(bufferAgents);
ushort highestID = 0;
for (int i = 0; i < bufferAgents.Count; i++)
{
ushort id = bufferAgents[i].LocalID;
if (id > highestID)
{
highestID = id;
}
}
int headerLength = (highestID + 1 - 1) / 8 + 1;
Header = new BitArray(headerLength, false);
for (int i = 0; i < bufferAgents.Count; i++)
{
SerializeAgent(bufferAgents[i]);
}
}
public void Reset()
{
ContainedDynamicObjects.FastClear();
ContainedImmovableObjects.FastClear();
}
/// <summary>
/// Finds a path and outputs it to <c>OutputPath</c>. Note: OutputPath is unpredictably changed.
/// </summary>
/// <returns>
/// Returns <c>true</c> if path was found and necessary, <c>false</c> if path to End is impossible or not found.
/// </returns>
/// <param name="startNode">Start node.</param>
/// <param name="endNode">End node.</param>
/// <param name="OutputPath">Return path.</param>
public static bool FindPath(GridNode startNode, GridNode endNode, FastList <GridNode> OutputPath)
{
#region Broadphase and Preperation
if (endNode.Unwalkable)
{
return(false);
}
if (startNode.Unwalkable)
{
return(false);
}
if (true)
{
#region Obstruction Test
//Tests if there is a direct path. If there is, no need to run AStar.
x0 = startNode.gridX;
y0 = startNode.gridY;
x1 = endNode.gridX;
y1 = endNode.gridY;
if (y1 > y0)
{
compare1 = y1 - y0;
}
else
{
compare1 = y0 - y1;
}
if (x1 > x0)
{
compare2 = x1 - x0;
}
else
{
compare2 = x0 - x1;
}
steep = compare1 > compare2;
if (steep)
{
t = x0; // swap x0 and y0
x0 = y0;
y0 = t;
t = x1; // swap x1 and y1
x1 = y1;
y1 = t;
}
if (x0 > x1)
{
t = x0; // swap x0 and x1
x0 = x1;
x1 = t;
t = y0; // swap y0 and y1
y0 = y1;
y1 = t;
}
dx = x1 - x0;
dy = (y1 - y0);
if (dy < 0)
{
dy = -dy;
}
error = dx / 2;
ystep = (y0 < y1) ? 1 : -1;
y = y0;
for (x = x0; x <= x1; x++)
{
retX = (steep ? y : x);
retY = (steep ? x : y);
if (GridManager.Grid [retX * GridManager.NodeCount + retY].Unwalkable)
{
break;
}
else if (x == x1)
{
OutputPath.FastClear();
OutputPath.Add(startNode);
OutputPath.Add(endNode);
return(true);
}
error = error - dy;
if (error < 0)
{
y += ystep;
error += dx;
}
}
#endregion
}
GridHeap.FastClear();
GridClosedSet.FastClear();
#endregion
#region AStar Algorithm
GridHeap.Add(startNode);
GridNode.HeuristicTargetX = endNode.gridX;
GridNode.HeuristicTargetY = endNode.gridY;
while (GridHeap.Count > 0)
{
currentNode = GridHeap.RemoveFirst();
GridClosedSet.Add(currentNode);
if (currentNode.gridIndex == endNode.gridIndex)
{
OutputPath.FastClear();
//Retraces the path then outputs it into OutputPath
//Also Simplifies the path
oldNode = endNode;
currentNode = endNode.parent;
oldX = int.MaxValue;
oldY = int.MaxValue;
StartNodeIndex = startNode.gridIndex;
//if (!endNode.Obstructed) OutputPath.Add (endNode);
while (oldNode.gridIndex != StartNodeIndex)
{
newX = currentNode.gridX - oldNode.gridX;
newY = currentNode.gridY - oldNode.gridY;
if ((newX != oldX || newY != oldY))
{
OutputPath.Add(oldNode);
oldX = newX;
oldY = newY;
}
oldNode = currentNode;
currentNode = currentNode.parent;
}
OutputPath.Add(startNode);
OutputPath.Reverse();
return(true);
}
for (i = 0; i < 8; i++)
{
neighbor = currentNode.NeighborNodes [i];
if (neighbor == null || neighbor.Unwalkable || GridClosedSet.Contains(neighbor))
{
continue;
}
newMovementCostToNeighbor = currentNode.gCost + (currentNode.NeighborDiagnal [i] ? 141 : 100);
if (!GridHeap.Contains(neighbor))
{
neighbor.gCost = newMovementCostToNeighbor;
//Optimized heuristic calculation
neighbor.CalculateHeurustic();
neighbor.parent = currentNode;
GridHeap.Add(neighbor);
}
else if (newMovementCostToNeighbor < neighbor.gCost)
{
neighbor.gCost = newMovementCostToNeighbor;
//Optimized heuristic calculation
neighbor.CalculateHeurustic();
neighbor.parent = currentNode;
GridHeap.UpdateItem(neighbor);
}
}
}
#endregion
return(false);
}
public Selection(FastEnumerable<LSAgent> selectedAgents) {
bufferAgents.FastClear();
selectedAgents.Enumerate(bufferAgents);
this.AddAgents(bufferAgents.ToArray());
}
private bool InternalRaycast(Vector2d From, Vector2d To, int ExceptionID)
{
_Version++;
MadeContact = false;
Hits.FastClear();
const int StepSize = 1 << Partition.ShiftSize;
x0 = From.x;
y0 = From.y;
x1 = To.x;
y1 = To.y;
if (y1 > y0)
{
compare1 = y1 - y0;
}
else
{
compare1 = y0 - y1;
}
if (x1 > x0)
{
compare2 = x1 - x0;
}
else
{
compare2 = x0 - x1;
}
steep = compare1 > compare2;
if (steep)
{
t = x0; // swap x0 and y0
x0 = y0;
y0 = t;
t = x1; // swap x1 and y1
x1 = y1;
y1 = t;
}
if (x0 > x1)
{
t = x0; // swap x0 and x1
x0 = x1;
x1 = t;
t = y0; // swap y0 and y1
y0 = y1;
y1 = t;
}
dx = x1 - x0;
dy = (y1 - y0);
if (dy < 0)
{
dy = -dy;
}
error = dx / 2;
ystep = (y0 < y1) ? StepSize : -StepSize;
y = y0;
AxisX = From.x - To.x;
AxisY = From.y - To.y;
Mag = FixedMath.Sqrt((AxisX * AxisX + AxisY * AxisY) >> FixedMath.SHIFT_AMOUNT);
if (Mag == 0)
{
return(false);
}
AxisX = FixedMath.Div(AxisX, Mag);
AxisY = FixedMath.Div(AxisY, Mag);
AxisMin = Vector2d.Dot(AxisX, AxisY, From.x, From.y);
AxisMax = Vector2d.Dot(AxisX, AxisY, To.x, To.y);
if (AxisMin > AxisMax)
{
SwapValue = AxisMin;
AxisMin = AxisMax;
AxisMax = SwapValue;
}
PerpProj = Vector2d.Dot(-AxisY, AxisX, From.x, From.y);
XMin = From.x;
XMax = To.x;
if (XMin > XMax)
{
SwapValue = XMin;
XMin = XMax;
XMax = SwapValue;
}
YMin = From.y;
YMax = To.y;
if (YMin > YMax)
{
SwapValue = YMin;
YMin = YMax;
YMax = SwapValue;
}
x = x0;
while (true)
{
if (steep)
{
retX = (y - Partition.OffsetX) / StepSize;
retY = (x - Partition.OffsetY) / StepSize;
}
else
{
retX = (x - Partition.OffsetX) / StepSize;
retY = (y - Partition.OffsetY) / StepSize;
}
PartitionNode node = Partition.Nodes [retX * Partition.Count + retY];
if (node.Count > 0)
{
for (i = 0; i < node.Count; i++)
{
DidHit = false;
LSBody body = PhysicsManager.SimObjects [node [i]];
if (body.RaycastVersion != _Version && body.ID != ExceptionID)
{
body.RaycastVersion = _Version;
switch (body.Shape)
{
case ColliderType.Circle:
Projection = Vector2d.Dot(AxisX, AxisY, body.Position.x, body.Position.y);
TestMin = Projection - body.Radius;
TestMax = Projection + body.Radius;
if (TestMin < AxisMax)
{
if (TestMax > AxisMin)
{
Projection = Vector2d.Dot(-AxisY, AxisX, body.Position.x, body.Position.y);
TestMin = Projection - body.Radius;
TestMax = Projection + body.Radius;
if (PerpProj < TestMax && PerpProj > TestMin)
{
DidHit = true;
}
}
}
break;
case ColliderType.AABox:
if (AxisMin < body.XMax)
{
if (AxisMax > body.XMin)
{
if (PerpProj < body.YMax)
{
if (PerpProj > body.YMin)
{
DidHit = true;
}
}
}
}
break;
}
if (DidHit)
{
Hits.Add(body);
MadeContact = true;
break;
}
}
}
}
error = error - dy;
if (error < 0)
{
y += ystep;
error += dx;
}
if (x >= x1)
{
break;
}
x += StepSize;
}
return(MadeContact);
}
public static void SmoothPath(FastList <GridNode> nodePath, Vector2d End, FastList <Vector2d> outputVectorPath, int unitSize)
{
outputVectorPath.FastClear();
length = nodePath.Count - 1;
//culling out unneded nodes
var StartNode = nodePath[0];
outputVectorPath.Add(StartNode.WorldPos);
GridNode oldNode = StartNode;
long oldX = 0;
long oldY = 0;
long newX = 0;
long newY = 0;
for (i = 1; i < length; i++)
{
GridNode node = nodePath[i];
bool important = false;
if (unitSize <= 1)
{
important = !node.Clearance;
}
else if (unitSize <= 3)
{
important = !node.ExtraClearance;
}
else
{
important = true;
}
//important = true;
if (important)
{
newX = node.gridX - oldNode.gridX;
newY = node.gridY - oldNode.gridY;
if (
(newX <= 1 && newX >= -1) &&
(newY <= 1 && newY >= -1)
)
{
if (newX == oldX && newY == oldY)
{
if (oldX != 0 || oldY != 0)
{
outputVectorPath.RemoveAt(outputVectorPath.Count - 1);
}
}
else
{
oldX = newX;
oldY = newY;
}
}
else
{
oldX = 0;
oldY = 0;
}
outputVectorPath.Add(node.WorldPos);
oldNode = node;
}
}
outputVectorPath.Add(End);
}
/// <summary>
/// Finds a path and outputs it to <c>outputPath</c>. Note: outputPath is unpredictably changed.
/// </summary>
/// <returns>
/// Returns <c>true</c> if path was found and necessary, <c>false</c> if path to End is impossible or not found.
/// </returns>
/// <param name="startNode">Start node.</param>
/// <param name="endNode">End node.</param>
/// <param name="outputPath">Return path.</param>
public static bool FindPath(GridNode _startNode, GridNode _endNode, FastList <GridNode> _outputPath, int _unitSize = 1)
{
startNode = _startNode;
endNode = _endNode;
outputPath = _outputPath;
unitSize = _unitSize;
#region Broadphase and Preperation
if (endNode.Unwalkable)
{
return(false);
}
if (startNode.Unwalkable)
{
return(false);
}
outputPath.FastClear();
if (System.Object.ReferenceEquals(startNode, endNode))
{
outputPath.Add(endNode);
return(true);
}
GridHeap.FastClear();
GridClosedSet.FastClear();
#endregion
#region AStar Algorithm
GridHeap.Add(startNode);
GridNode.HeuristicTargetX = endNode.gridX;
GridNode.HeuristicTargetY = endNode.gridY;
GridNode.PrepareUnpassableCheck(unitSize); //Prepare Unpassable check optimizations
while (GridHeap.Count > 0)
{
currentNode = GridHeap.RemoveFirst();
#if false
Gizmos.DrawCube(currentNode.WorldPos.ToVector3(), Vector3.one);
#endif
GridClosedSet.Add(currentNode);
if (currentNode.gridIndex == endNode.gridIndex)
{
//Retraces the path then outputs it into outputPath
//Also Simplifies the path
DestinationReached();
return(true);
}
/*
* for (i = 0; i < 8; i++) {
* neighbor = currentNode.NeighborNodes [i];
* if (CheckNeighborInvalid ()) {
* //continue;
* //microoptimization... continue is more expensive than letting the loop pass at the end
* } else {
* //0-3 = sides, 4-7 = diagonals
* if (i < 4) {
* newMovementCostToNeighbor = currentNode.gCost + 100;
* } else {
* if (i == 4) {
* if (!GridManager.UseDiagonalConnections)
* break;
* }
* newMovementCostToNeighbor = currentNode.gCost + 141;
* }
*
* AnalyzeNode();
* }
* }
*/
hasInvalidEdge = false;
for (int i = 0; i < 4; i++)
{
neighbor = currentNode.NeighborNodes[i];
if (CheckNeighborInvalid())
{
hasInvalidEdge = true;
}
else
{
newMovementCostToNeighbor = currentNode.gCost + 100;
AnalyzeNode();
}
}
if (hasInvalidEdge)
{
const int maxCornerObstructions = 1;
#region inlining diagonals
neighbor = currentNode.NeighborNodes[4];
if (!CheckNeighborInvalid())
{
if (GetObstructionCount(0, 1) <= maxCornerObstructions)
{
newMovementCostToNeighbor = currentNode.gCost + 141;
AnalyzeNode();
}
}
neighbor = currentNode.NeighborNodes[5];
if (!CheckNeighborInvalid())
{
if (GetObstructionCount(0, 2) <= maxCornerObstructions)
{
newMovementCostToNeighbor = currentNode.gCost + 141;
AnalyzeNode();
}
}
neighbor = currentNode.NeighborNodes[6];
if (!CheckNeighborInvalid())
{
if (GetObstructionCount(3, 1) <= maxCornerObstructions)
{
newMovementCostToNeighbor = currentNode.gCost + 141;
AnalyzeNode();
}
}
neighbor = currentNode.NeighborNodes[7];
if (!CheckNeighborInvalid())
{
if (GetObstructionCount(3, 2) <= maxCornerObstructions)
{
newMovementCostToNeighbor = currentNode.gCost + 141;
AnalyzeNode();
}
}
#endregion
}
else
{
//no need for specific stuff when edges are all valid
for (int i = 4; i < 8; i++)
{
neighbor = currentNode.NeighborNodes[i];
if (CheckNeighborInvalid())
{
}
else
{
newMovementCostToNeighbor = currentNode.gCost + 141;
AnalyzeNode();
}
}
}
}
#endregion
return(false);
}
public static void Initialize()
{
Teams.FastClear();
nextDistribute = 0;
}
/// <summary>
/// For re-useability
/// </summary>
/// <param name="canvas">Canvas.</param>
public void Initialize(FastList <byte> canvas)
{
canvas.FastClear();
Canvas = canvas;
}
public void Enumerate(FastList <T> output)
{
output.FastClear();
output.AddRange(this);
}
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);
}
