public void CheckIntegrity()
{
//make sure im still a good parent
if (NodeCount >= 2)
{
var Visited = new sVisited();
Visited.Visited = new bool[NodeCount];
var A = 0;
FloodCheckInternal(Nodes[0], ref Visited);
for (A = 0; A <= NodeCount - 1; A++)
{
if (!Visited.Visited[A])
{
goto DisbandAndFind;
}
}
}
if (NodeCount == 1 & ConnectionCount == 0)
{
goto DisbandAndFind;
}
if (NodeCount > 1)
{
SpanCalc();
}
else if (NodeCount == 0)
{
if (ParentNode != null)
{
var tmpNode = ParentNode;
tmpNode.Node_Remove(ParentNode_NodeNum);
tmpNode.CheckIntegrity();
}
if (Layer.Network_LayerNum > 0)
{
Deallocate();
}
}
return;
DisbandAndFind:
var B = 0;
var Children = new PathfinderNode[NodeCount];
for (B = 0; B <= NodeCount - 1; B++)
{
Children[B] = Nodes[B];
}
var ChildCount = NodeCount;
Disband();
for (B = 0; B <= ChildCount - 1; B++)
{
Children[B].Layer.Network.FindParentNode_Add(Children[B]);
}
}
public PathfinderNode GetOtherNode(PathfinderNode Self)
{
if (NodeA == Self)
{
return(NodeB);
}
return(NodeA);
}
public void Node_Add(PathfinderNode NewNode)
{
if (Nodes.GetUpperBound(0) < NodeCount)
{
Array.Resize(ref Nodes, (NodeCount + 1) * 2);
}
Nodes[NodeCount] = NewNode;
Nodes[NodeCount].Layer_NodeNum = NodeCount;
NodeCount++;
}
public PathfinderConnection(PathfinderConnection SourceConnection)
{
NodeA = SourceConnection.NodeA.ParentNode;
NodeB = SourceConnection.NodeB.ParentNode;
NodeA.Connection_Add(this, ref NodeA_ConnectionNum);
NodeB.Connection_Add(this, ref NodeB_ConnectionNum);
NodeA.Layer.Connection_Add(this);
ValueCalc();
}
private void RemoveFromNodes()
{
NodeA.Connection_Remove(NodeA_ConnectionNum);
NodeA = null;
NodeA_ConnectionNum = -1;
NodeB.Connection_Remove(NodeB_ConnectionNum);
NodeB = null;
NodeB_ConnectionNum = -1;
}
public void ForceDeallocate()
{
var A = 0;
for (A = 0; A <= ConnectionCount - 1; A++)
{
Connections[A].ForceDeallocate();
}
Connections = null;
Nodes = null;
ParentNode = null;
Layer = null;
}
public PathfinderConnection FindConnection(PathfinderNode NodeToFind)
{
var A = 0;
var tmpConnection = default(PathfinderConnection);
for (A = 0; A <= ConnectionCount - 1; A++)
{
tmpConnection = Connections[A];
if (tmpConnection.GetOtherNode(this) == NodeToFind)
{
return(tmpConnection);
}
}
return(null);
}
public void ChangedNode_Add(PathfinderNode NewChangedNode)
{
if (NewChangedNode.Layer_ChangedNodeNum >= 0)
{
return;
}
if (ChangedNodes.GetUpperBound(0) < ChangedNodeCount)
{
Array.Resize(ref ChangedNodes, ChangedNodeCount * 2 + 1 + 1);
}
ChangedNodes[ChangedNodeCount] = NewChangedNode;
ChangedNodes[ChangedNodeCount].Layer_ChangedNodeNum = ChangedNodeCount;
ChangedNodeCount++;
}
public void FindParentNode_Add(PathfinderNode NewFindParentNode)
{
if (NewFindParentNode.Network_FindParentNum >= 0)
{
return;
}
if (FindParentNodes.GetUpperBound(0) < FindParentNodeCount)
{
Array.Resize(ref FindParentNodes, (FindParentNodeCount + 1) * 2);
}
FindParentNodes[FindParentNodeCount] = NewFindParentNode;
FindParentNodes[FindParentNodeCount].Network_FindParentNum = FindParentNodeCount;
FindParentNodeCount++;
}
public PathfinderConnection GetOrCreateConnection(PathfinderNode OtherNode, float Value)
{
var tmpConnection = default(PathfinderConnection);
if (OtherNode.Layer != Layer)
{
return(null);
}
tmpConnection = FindConnection(OtherNode);
if (tmpConnection == null)
{
return(new PathfinderConnection(this, OtherNode, Value));
}
return(tmpConnection);
}
public void Node_Add(PathfinderNode NodeToAdd)
{
if (Layer == null)
{
Debugger.Break();
return;
}
if (NodeToAdd.Layer.Network_LayerNum != Layer.Network_LayerNum - 1)
{
Debugger.Break();
return;
}
if (NodeToAdd.ParentNode != null)
{
Debugger.Break();
return;
}
if (Layer_ChangedNodeNum < 0)
{
Layer.ChangedNode_Add(this);
}
NodeToAdd.ParentNode = this;
NodeToAdd.ParentNode_NodeNum = NodeCount;
Nodes[NodeCount] = NodeToAdd;
NodeCount++;
if (NodeToAdd.ConnectionCount == 0)
{
Debugger.Break();
}
if (NodeToAdd.Clearance > Clearance)
{
ClearanceSet(Clearance);
}
else
{
ClearanceCalc();
}
}
public void FloodCheckInternal(PathfinderNode CurrentNode, ref sVisited Visited)
{
var A = 0;
var tmpNode = default(PathfinderNode);
var tmpConnection = default(PathfinderConnection);
Visited.Visited[CurrentNode.ParentNode_NodeNum] = true;
for (A = 0; A <= CurrentNode.ConnectionCount - 1; A++)
{
tmpConnection = CurrentNode.Connections[A];
tmpNode = tmpConnection.GetOtherNode(CurrentNode);
if (tmpNode.ParentNode == this)
{
if (!Visited.Visited[tmpNode.ParentNode_NodeNum])
{
FloodCheckInternal(tmpNode, ref Visited);
}
}
}
}
public PathfinderConnection(PathfinderNode NewNodeA, PathfinderNode NewNodeB, float NewValue)
{
if (NewNodeA.Layer.Network_LayerNum > 0 | NewNodeB.Layer.Network_LayerNum > 0 | NewValue <= 0.0F)
{
Debugger.Break();
return;
}
Value = NewValue;
LinkCount = 1;
NodeA = NewNodeA;
NodeB = NewNodeB;
NodeA.Connection_Add(this, ref NodeA_ConnectionNum);
NodeB.Connection_Add(this, ref NodeB_ConnectionNum);
NodeA.Layer.Connection_Add(this);
RaiseDependant();
}
public bool NodeCanReachNode(PathfinderNode StartNode, PathfinderNode FinishNode)
{
var StartParent = StartNode;
var FinishParent = FinishNode;
do
{
if (StartParent == FinishParent)
{
return(true);
}
StartParent = StartParent.ParentNode;
if (StartParent == null)
{
return(false);
}
FinishParent = FinishParent.ParentNode;
if (FinishParent == null)
{
return(false);
}
} while (true);
}
public PathList[] GetPath(PathfinderNode[] StartNodes, PathfinderNode FinishNode, int Accuracy, int MinClearance)
{
var StartNodeCount = StartNodes.GetUpperBound(0) + 1;
var Paths = new PathList[NodeLayerCount];
var LayerStartNodes = new PathfinderNode[NodeLayerCount, StartNodeCount];
var LayerFinishNodes = new PathfinderNode[NodeLayerCount];
var LayerNum = 0;
var Destinations = new PathfinderNode[24];
var DestinationCount = 0;
var FinishIsParent = default(bool);
var CalcNodeCount = new int[24];
var FloodRouteArgs = new sFloodRouteArgs();
var FinalLayer = 0;
var StartCanReach = new bool[StartNodeCount];
var tmpNodeA = default(PathfinderNode);
var tmpNodeB = default(PathfinderNode);
var CanReachCount = 0;
var FirstLayer = 0;
var BestPaths = new Path[24];
var BestValues = new float[24];
var PathNum = 0;
var StopMultiPathing = default(bool);
var Visit = NetworkLargeArrays.Nodes_Booleans;
var NodeValues = NetworkLargeArrays.Nodes_ValuesA;
var Nodes_Nodes = NetworkLargeArrays.Nodes_Nodes;
var StartPath = NetworkLargeArrays.Nodes_Path;
var A = 0;
var B = 0;
var C = 0;
var D = 0;
var E = 0;
FinalLayer = StartNodes[0].Layer.Network_LayerNum;
LayerFinishNodes[FinalLayer] = FinishNode;
B = FinalLayer;
do
{
if (LayerFinishNodes[B].ParentNode == null)
{
FirstLayer = B;
break;
}
LayerFinishNodes[B + 1] = LayerFinishNodes[B].ParentNode;
B++;
} while (true);
for (A = 0; A <= StartNodeCount - 1; A++)
{
LayerStartNodes[FinalLayer, A] = StartNodes[A];
B = FinalLayer;
do
{
if (LayerStartNodes[B, A].ParentNode == null)
{
if (LayerStartNodes[B, A] == LayerFinishNodes[B])
{
StartCanReach[A] = true;
CanReachCount++;
}
break;
}
LayerStartNodes[B + 1, A] = LayerStartNodes[B, A].ParentNode;
B++;
} while (true);
}
if (CanReachCount == 0)
{
return(null);
}
LayerNum = FirstLayer;
Paths[LayerNum].Paths = new Path[0];
Paths[LayerNum].Paths[0] = new Path();
Paths[LayerNum].PathCount = 1;
Paths[LayerNum].Paths[0].Nodes = new PathfinderNode[1];
Paths[LayerNum].Paths[0].Nodes[0] = LayerFinishNodes[LayerNum];
Paths[LayerNum].Paths[0].NodeCount = 1;
var LastLayer = 0;
do
{
LastLayer = LayerNum;
LayerNum--;
if (LayerNum < FinalLayer)
{
break;
}
if (StopMultiPathing)
{
if (Accuracy < 0)
{
Debugger.Break();
}
for (PathNum = 0; PathNum <= Paths[LastLayer].PathCount - 1; PathNum++)
{
CalcNodeCount[PathNum] = Math.Min(Accuracy, Convert.ToInt32(Paths[LastLayer].Paths[PathNum].NodeCount - 1));
}
Destinations[0] = Paths[LastLayer].Paths[0].Nodes[CalcNodeCount[0]];
DestinationCount = 1;
FinishIsParent = true;
}
else
{
if (Accuracy >= 0)
{
for (PathNum = 0; PathNum <= Paths[LastLayer].PathCount - 1; PathNum++)
{
if (Paths[LastLayer].Paths[PathNum].NodeCount > Accuracy)
{
StopMultiPathing = true;
break;
}
}
}
Destinations[0] = LayerFinishNodes[LayerNum];
if (LayerNum == FinalLayer)
{
DestinationCount = 1;
}
else
{
for (A = 0; A <= Destinations[0].ConnectionCount - 1; A++)
{
Destinations[1 + A] = Destinations[0].Connections[A].GetOtherNode(Destinations[0]);
}
DestinationCount = 1 + Destinations[0].ConnectionCount;
}
for (PathNum = 0; PathNum <= Paths[LastLayer].PathCount - 1; PathNum++)
{
CalcNodeCount[PathNum] = Paths[LastLayer].Paths[PathNum].NodeCount - 1;
}
FinishIsParent = false;
}
for (PathNum = 0; PathNum <= Paths[LastLayer].PathCount - 1; PathNum++)
{
for (A = 0; A <= CalcNodeCount[PathNum]; A++)
{
tmpNodeA = Paths[LastLayer].Paths[PathNum].Nodes[A];
for (D = 0; D <= tmpNodeA.ConnectionCount - 1; D++)
{
tmpNodeB = tmpNodeA.Connections[D].GetOtherNode(tmpNodeA);
for (E = 0; E <= tmpNodeB.ConnectionCount - 1; E++)
{
C = tmpNodeB.Connections[E].GetOtherNode(tmpNodeB).Layer_NodeNum;
Visit[C] = false;
}
}
}
}
for (PathNum = 0; PathNum <= Paths[LastLayer].PathCount - 1; PathNum++)
{
for (A = 0; A <= CalcNodeCount[PathNum]; A++)
{
tmpNodeA = Paths[LastLayer].Paths[PathNum].Nodes[A];
C = tmpNodeA.Layer_NodeNum;
Visit[C] = true;
for (E = 0; E <= tmpNodeA.NodeCount - 1; E++)
{
C = tmpNodeA.Nodes[E].Layer_NodeNum;
NodeValues[C] = float.MaxValue;
}
for (D = 0; D <= tmpNodeA.ConnectionCount - 1; D++)
{
tmpNodeB = tmpNodeA.Connections[D].GetOtherNode(tmpNodeA);
C = tmpNodeB.Layer_NodeNum;
Visit[C] = true;
for (E = 0; E <= tmpNodeB.NodeCount - 1; E++)
{
C = tmpNodeB.Nodes[E].Layer_NodeNum;
NodeValues[C] = float.MaxValue;
}
}
}
}
FloodRouteArgs = new sFloodRouteArgs();
FloodRouteArgs.CurrentPath = StartPath;
FloodRouteArgs.FinishNodes = Destinations;
FloodRouteArgs.FinishNodeCount = DestinationCount;
FloodRouteArgs.FinishIsParent = FinishIsParent;
FloodRouteArgs.Visit = Visit;
FloodRouteArgs.NodeValues = NodeValues;
FloodRouteArgs.SourceNodes = Nodes_Nodes;
FloodRouteArgs.MinClearance = MinClearance;
for (A = 0; A <= DestinationCount - 1; A++)
{
BestPaths[A] = null;
BestValues[A] = float.MaxValue;
}
for (A = 0; A <= StartNodeCount - 1; A++)
{
if (StartCanReach[A])
{
StartPath.NodeCount = 1;
StartPath.Nodes[0] = LayerStartNodes[LayerNum, A];
StartPath.Value = 0.0F;
FloodRouteArgs.BestPaths = new Path[DestinationCount];
FloodRoute(ref FloodRouteArgs);
for (PathNum = 0; PathNum <= DestinationCount - 1; PathNum++)
{
if (FloodRouteArgs.BestPaths[PathNum] != null)
{
if (FloodRouteArgs.BestPaths[PathNum].Value < BestValues[PathNum])
{
BestValues[PathNum] = FloodRouteArgs.BestPaths[PathNum].Value;
BestPaths[PathNum] = FloodRouteArgs.BestPaths[PathNum];
}
}
}
}
}
Paths[LayerNum].Paths = new Path[DestinationCount];
Paths[LayerNum].PathCount = 0;
for (PathNum = 0; PathNum <= DestinationCount - 1; PathNum++)
{
if (BestPaths[PathNum] != null)
{
Paths[LayerNum].Paths[Paths[LayerNum].PathCount] = BestPaths[PathNum];
Paths[LayerNum].PathCount++;
}
}
Array.Resize(ref Paths[LayerNum].Paths, Paths[LayerNum].PathCount);
if (Paths[LayerNum].PathCount == 0)
{
return(null);
}
} while (true);
return(Paths);
}
public void Split()
{
if (NodeCount != 4)
{
Debugger.Break();
}
float Value = 0;
float BestValue = 0;
PathfinderNode BestNodeA = null;
PathfinderNode BestNodeB = null;
PathfinderNode BestNodeC = null;
PathfinderNode BestNodeD = null;
var A = 0;
var B = 0;
var tmpNodeA = default(PathfinderNode);
var tmpNodeB = default(PathfinderNode);
var tmpNodeC = default(PathfinderNode);
var tmpNodeD = default(PathfinderNode);
PathfinderConnection tmpConnectionA = null;
PathfinderConnection tmpConnectionB = null;
var C = 0;
var D = 0;
var Children = new PathfinderNode[NodeCount];
for (A = 0; A <= NodeCount - 1; A++)
{
Children[A] = Nodes[A];
}
var ChildCount = NodeCount;
var ThisLayer = Layer;
Disband();
BestValue = float.MaxValue;
for (A = 0; A <= ChildCount - 1; A++)
{
tmpNodeA = Children[A];
for (B = A + 1; B <= ChildCount - 1; B++)
{
tmpNodeB = Children[B];
for (C = 0; C <= ChildCount - 1; C++)
{
if (Children[C] != tmpNodeA && Children[C] != tmpNodeB)
{
break;
}
}
tmpNodeC = Children[C];
for (D = C + 1; D <= ChildCount - 1; D++)
{
if (Children[D] != tmpNodeA && Children[D] != tmpNodeB)
{
break;
}
}
tmpNodeD = Children[D];
for (C = 0; C <= tmpNodeA.ConnectionCount - 1; C++)
{
tmpConnectionA = tmpNodeA.Connections[C];
if (tmpConnectionA.GetOtherNode(tmpNodeA) == tmpNodeB)
{
break;
}
}
for (D = 0; D <= tmpNodeC.ConnectionCount - 1; D++)
{
tmpConnectionB = tmpNodeC.Connections[D];
if (tmpConnectionB.GetOtherNode(tmpNodeC) == tmpNodeD)
{
break;
}
}
if (C < tmpNodeA.ConnectionCount & D < tmpNodeC.ConnectionCount)
{
Value = tmpConnectionA.Value + tmpConnectionB.Value;
if (Value < BestValue)
{
BestValue = Value;
BestNodeA = tmpNodeA;
BestNodeB = tmpNodeB;
BestNodeC = tmpNodeC;
BestNodeD = tmpNodeD;
}
}
}
}
if (BestNodeA != null)
{
if (ParentNode != null)
{
tmpNodeA = ParentNode;
tmpNodeA.Node_Remove(ParentNode_NodeNum);
}
else
{
tmpNodeA = null;
}
if (tmpNodeA != null)
{
tmpNodeA.CheckIntegrity();
}
var NewNodeA = new PathfinderNode(ThisLayer);
var NewNodeB = new PathfinderNode(ThisLayer);
NewNodeA.Node_Add(BestNodeA);
NewNodeA.Node_Add(BestNodeB);
NewNodeA.SpanCalc();
BestNodeA.RaiseConnections();
BestNodeB.RaiseConnections();
NewNodeA.Layer.Network.FindParentNode_Add(NewNodeA);
NewNodeB.Node_Add(BestNodeC);
NewNodeB.Node_Add(BestNodeD);
NewNodeB.SpanCalc();
BestNodeC.RaiseConnections();
BestNodeD.RaiseConnections();
NewNodeB.Layer.Network.FindParentNode_Add(NewNodeB);
}
else
{
Debugger.Break();
}
}
public void FindParent()
{
var tmpNodeA = default(PathfinderNode);
float BestScore = 0;
PathfinderNode BestNode = null;
float Score = 0;
var A = 0;
var MakeNew = default(bool);
var B = 0;
var Count = 0;
var C = 0;
var Allow = default(bool);
var tmpConnection = default(PathfinderConnection);
var DestNode = default(PathfinderNode);
if (NodeCount == 0 & Layer.Network_LayerNum > 0)
{
Debugger.Break();
return;
}
if (ParentNode != null)
{
Debugger.Break();
return;
}
BestScore = float.MaxValue;
for (A = 0; A <= ConnectionCount - 1; A++)
{
tmpConnection = Connections[A];
DestNode = tmpConnection.GetOtherNode(this);
tmpNodeA = DestNode.ParentNode;
if (tmpNodeA == null)
{
tmpNodeA = tmpConnection.GetOtherNode(this);
Score = tmpConnection.Value * (0.98F + App.Random.Next() * 0.04F);
if (Score < BestScore)
{
BestScore = Score;
BestNode = tmpNodeA;
MakeNew = true;
}
}
else
{
//dont allow this to join to another when the other has 3 nodes and they only have one connection
if (tmpNodeA.NodeCount == 3)
{
Count = 0;
Allow = false;
for (B = 0; B <= tmpNodeA.NodeCount - 1; B++)
{
for (C = 0; C <= tmpNodeA.Nodes[B].ConnectionCount - 1; C++)
{
if (tmpNodeA.Nodes[B].Connections[C].GetOtherNode(tmpNodeA.Nodes[B]) == this)
{
Count++;
if (Count >= 2)
{
Allow = true;
goto CountFinished;
}
break;
}
}
}
CountFinished:
1.GetHashCode(); //TODO: cleanup this loop
}
else
{
Allow = true;
}
if (Allow)
{
Score = (DestNode.SiblingSpan + tmpConnection.Value) * (0.98F + App.Random.Next() * 0.04F);
if (Score < BestScore)
{
BestScore = Score;
BestNode = tmpNodeA;
MakeNew = false;
}
}
}
}
if (BestNode != null)
{
if (MakeNew)
{
var tmpLayer = default(PathfinderLayer);
if (Layer.ParentLayer == null)
{
tmpLayer = new PathfinderLayer(Layer.Network);
}
else
{
tmpLayer = Layer.ParentLayer;
}
var NewNode = new PathfinderNode(tmpLayer);
NewNode.Node_Add(this);
NewNode.Node_Add(BestNode);
NewNode.SpanCalc();
RaiseConnections();
BestNode.RaiseConnections();
NewNode.Layer.Network.FindParentNode_Add(NewNode);
}
else
{
if (BestNode != null)
{
BestNode.Node_Add(this);
if (BestNode.NodeCount >= 4)
{
BestNode.Split();
}
else
{
BestNode.SpanCalc();
RaiseConnections();
if (BestNode.ParentNode == null)
{
BestNode.Layer.Network.FindParentNode_Add(BestNode);
}
}
}
}
}
else if (ConnectionCount > 0)
{
//it is part of a network but there is no suitable parent to join, so make a new isolated parent
var tmpLayer = default(PathfinderLayer);
if (Layer.ParentLayer == null)
{
tmpLayer = new PathfinderLayer(Layer.Network);
}
else
{
tmpLayer = Layer.ParentLayer;
}
var NewNode = new PathfinderNode(tmpLayer);
NewNode.Node_Add(this);
NewNode.SpanCalc();
RaiseConnections();
NewNode.Layer.Network.FindParentNode_Add(NewNode);
}
}
public void FindCalc()
{
PathfinderNode[] ShuffledNodes = null;
var ShuffledNodeCount = 0;
int[] Positions = null;
var PositionCount = 0;
var RandNum = 0;
var A = 0;
while (FindParentNodeCount > 0)
{
Positions = new int[FindParentNodeCount];
ShuffledNodeCount = FindParentNodeCount;
ShuffledNodes = new PathfinderNode[ShuffledNodeCount];
for (A = 0; A <= FindParentNodeCount - 1; A++)
{
Positions[PositionCount] = PositionCount;
PositionCount++;
}
for (A = 0; A <= FindParentNodeCount - 1; A++)
{
RandNum = App.Random.Next() * PositionCount;
ShuffledNodes[Positions[RandNum]] = FindParentNodes[A];
PositionCount--;
if (RandNum < PositionCount)
{
Positions[RandNum] = Positions[PositionCount];
}
}
for (A = 0; A <= ShuffledNodeCount - 1; A++)
{
if (ShuffledNodes[A].Network_FindParentNum >= 0)
{
if (ShuffledNodes[A].ParentNode == null)
{
ShuffledNodes[A].FindParent();
}
FindParentNode_Remove(ShuffledNodes[A].Network_FindParentNum);
}
}
}
//remove empty layers
var LayerNum = NodeLayerCount - 1;
do
{
if (NodeLayers[LayerNum].NodeCount > 0)
{
break;
}
NodeLayers[LayerNum].Network_LayerNum = -1;
if (LayerNum == 0)
{
break;
}
NodeLayers[LayerNum - 1].ParentLayer = null;
LayerNum--;
} while (true);
if (LayerNum < NodeLayerCount - 1)
{
Array.Resize(ref NodeLayers, LayerNum + 1);
NodeLayerCount = LayerNum + 1;
}
}
public void ForceDeallocate()
{
DependantConnection = null;
NodeA = null;
NodeB = null;
}
public Path[] GetAllPaths(PathfinderNode[] StartNodes, PathfinderNode FinishNode, int MinClearance)
{
var StartNodeCount = StartNodes.GetUpperBound(0) + 1;
var LayerStartNodes = new PathfinderNode[32, StartNodeCount];
var LayerFinishNodes = new PathfinderNode[32];
var LayerNum = 0;
var FloodRouteDArgs = new sFloodRouteAllArgs();
var FinalLayer = 0;
var StartCanReach = new bool[StartNodeCount];
var tmpNodeA = default(PathfinderNode);
var CanReachCount = 0;
var FirstLayer = 0;
var SubPaths = new Path[32];
var Nodes_Nodes = NetworkLargeArrays.Nodes_Nodes;
var Visit = NetworkLargeArrays.Nodes_Booleans;
var NodeValues = NetworkLargeArrays.Nodes_ValuesA;
var NodeValuesB = NetworkLargeArrays.Nodes_ValuesB;
var A = 0;
var B = 0;
var C = 0;
var D = 0;
FinalLayer = StartNodes[0].Layer.Network_LayerNum;
LayerFinishNodes[FinalLayer] = FinishNode;
B = FinalLayer;
do
{
if (LayerFinishNodes[B].ParentNode == null)
{
FirstLayer = B;
break;
}
LayerFinishNodes[B + 1] = LayerFinishNodes[B].ParentNode;
B++;
} while (true);
for (A = 0; A <= StartNodeCount - 1; A++)
{
LayerStartNodes[FinalLayer, A] = StartNodes[A];
B = FinalLayer;
do
{
if (LayerStartNodes[B, A].ParentNode == null)
{
if (LayerStartNodes[B, A] == LayerFinishNodes[B])
{
StartCanReach[A] = true;
CanReachCount++;
}
break;
}
LayerStartNodes[B + 1, A] = LayerStartNodes[B, A].ParentNode;
B++;
} while (true);
}
if (CanReachCount == 0)
{
return(null);
}
LayerNum = FirstLayer;
SubPaths[LayerNum] = new Path();
SubPaths[LayerNum].Nodes = new[] { LayerFinishNodes[LayerNum] };
SubPaths[LayerNum].NodeCount = 1;
var LastLayer = 0;
do
{
LastLayer = LayerNum;
LayerNum--;
if (LayerNum < FinalLayer)
{
break;
}
for (A = 0; A <= SubPaths[LastLayer].NodeCount - 1; A++)
{
tmpNodeA = SubPaths[LastLayer].Nodes[A];
for (B = 0; B <= tmpNodeA.ConnectionCount - 1; B++)
{
C = tmpNodeA.Connections[B].GetOtherNode(tmpNodeA).Layer_NodeNum;
Visit[C] = false;
}
}
for (A = 0; A <= SubPaths[LastLayer].NodeCount - 1; A++)
{
tmpNodeA = SubPaths[LastLayer].Nodes[A];
C = tmpNodeA.Layer_NodeNum;
Visit[C] = true;
for (D = 0; D <= tmpNodeA.NodeCount - 1; D++)
{
C = tmpNodeA.Nodes[D].Layer_NodeNum;
NodeValues[C] = float.MaxValue;
NodeValuesB[C] = float.MaxValue;
}
}
FloodRouteDArgs = new sFloodRouteAllArgs();
FloodRouteDArgs.FinishNode = LayerFinishNodes[LayerNum];
FloodRouteDArgs.Visit = Visit;
FloodRouteDArgs.NodeValuesA = NodeValues;
FloodRouteDArgs.SourceNodes = Nodes_Nodes;
FloodRouteDArgs.NodeValuesB = NodeValuesB;
FloodRouteDArgs.MinClearance = MinClearance;
FloodRouteDArgs.BestTolerance = (float)(Math.Pow(1.1D, LayerNum));
FloodRouteDArgs.StartNodes = new PathfinderNode[StartNodeCount];
for (A = 0; A <= StartNodeCount - 1; A++)
{
if (StartCanReach[A])
{
FloodRouteDArgs.StartNodes[FloodRouteDArgs.StartNodeCount] = LayerStartNodes[LayerNum, A];
FloodRouteDArgs.StartNodeCount++;
}
}
Array.Resize(ref FloodRouteDArgs.StartNodes, FloodRouteDArgs.StartNodeCount);
FloodRouteAll(ref FloodRouteDArgs);
SubPaths[LayerNum] = new Path();
SubPaths[LayerNum].Nodes = new PathfinderNode[FloodRouteDArgs.BestNodeCount];
for (A = 0; A <= FloodRouteDArgs.BestNodeCount - 1; A++)
{
SubPaths[LayerNum].Nodes[A] = FloodRouteDArgs.SourceNodes[A];
}
SubPaths[LayerNum].NodeCount = FloodRouteDArgs.BestNodeCount;
if (FloodRouteDArgs.BestNodeCount == 0)
{
Debugger.Break();
return(SubPaths);
}
} while (true);
return(SubPaths);
}
