public Path[] GetAllPaths(PathfinderNode[] StartNodes, PathfinderNode FinishNode, int MinClearance)
{
int StartNodeCount = StartNodes.GetUpperBound(0) + 1;
PathfinderNode[,] LayerStartNodes = new PathfinderNode[32, StartNodeCount];
PathfinderNode[] LayerFinishNodes = new PathfinderNode[32];
int LayerNum = 0;
PathfinderNode[] Destinations = new PathfinderNode[24];
sFloodRouteAllArgs FloodRouteDArgs = new sFloodRouteAllArgs();
int FinalLayer = 0;
bool[] StartCanReach = new bool[StartNodeCount];
PathfinderNode tmpNodeA = default(PathfinderNode);
int CanReachCount = 0;
int FirstLayer = 0;
Path[] SubPaths = new Path[32];
PathfinderNode[] Nodes_Nodes = NetworkLargeArrays.Nodes_Nodes;
bool[] Visit = NetworkLargeArrays.Nodes_Booleans;
float[] NodeValues = NetworkLargeArrays.Nodes_ValuesA;
float[] NodeValuesB = NetworkLargeArrays.Nodes_ValuesB;
int A = 0;
int B = 0;
int C = 0;
int 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;
int 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(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;
}
public void FloodRouteAll(sFloodRouteAllArgs Args)
{
PathfinderNode CurrentNode = default(PathfinderNode);
PathfinderNode ConnectedNode = default(PathfinderNode);
int SourceNodeCount = 0;
int SourceNodeNum = 0;
PathfinderConnection tmpConnection = default(PathfinderConnection);
float ResultValue = 0;
float BestValue = 0;
int A = 0;
SourceNodeCount = Args.StartNodeCount;
for ( A = 0; A <= SourceNodeCount - 1; A++ )
{
Args.SourceNodes[A] = Args.StartNodes[A];
Args.NodeValuesA[Args.StartNodes[A].Layer_NodeNum] = 0.0F;
}
SourceNodeNum = 0;
while ( SourceNodeNum < SourceNodeCount )
{
CurrentNode = Args.SourceNodes[SourceNodeNum];
for ( A = 0; A <= CurrentNode.ConnectionCount - 1; A++ )
{
tmpConnection = CurrentNode.Connections[A];
ConnectedNode = tmpConnection.GetOtherNode(CurrentNode);
if ( Args.Visit[ConnectedNode.ParentNode.Layer_NodeNum] )
{
if ( ConnectedNode.Clearance >= Args.MinClearance )
{
ResultValue = Args.NodeValuesA[CurrentNode.Layer_NodeNum] + tmpConnection.Value;
if ( ResultValue < Args.NodeValuesA[ConnectedNode.Layer_NodeNum] )
{
Args.NodeValuesA[ConnectedNode.Layer_NodeNum] = ResultValue;
Args.SourceNodes[SourceNodeCount] = ConnectedNode;
SourceNodeCount++;
}
}
}
}
SourceNodeNum++;
}
SourceNodeCount = 0;
BestValue = Args.NodeValuesA[Args.FinishNode.Layer_NodeNum];
if ( BestValue == float.MaxValue )
{
Args.BestNodeCount = 0;
return;
}
BestValue *= Args.BestTolerance;
Args.SourceNodes[0] = Args.FinishNode;
SourceNodeCount = 1;
Args.NodeValuesB[Args.FinishNode.Layer_NodeNum] = 0.0F;
SourceNodeNum = 0;
while ( SourceNodeNum < SourceNodeCount )
{
CurrentNode = Args.SourceNodes[SourceNodeNum];
for ( A = 0; A <= CurrentNode.ConnectionCount - 1; A++ )
{
tmpConnection = CurrentNode.Connections[A];
ConnectedNode = tmpConnection.GetOtherNode(CurrentNode);
if ( Args.Visit[ConnectedNode.ParentNode.Layer_NodeNum] )
{
ResultValue = Args.NodeValuesB[CurrentNode.Layer_NodeNum] + tmpConnection.Value;
if ( ResultValue < Args.NodeValuesB[ConnectedNode.Layer_NodeNum] )
{
Args.NodeValuesB[ConnectedNode.Layer_NodeNum] = ResultValue;
if ( Args.NodeValuesA[ConnectedNode.Layer_NodeNum] + ResultValue <= BestValue + 500.0F )
{
Args.SourceNodes[SourceNodeCount] = ConnectedNode;
SourceNodeCount++;
}
}
}
}
SourceNodeNum++;
}
Args.BestNodeCount = SourceNodeCount;
}
public Path[] GetAllPaths(PathfinderNode[] StartNodes, PathfinderNode FinishNode, int MinClearance)
{
int num4;
int num7;
sFloodRouteAllArgs args;
int num10 = StartNodes.GetUpperBound(0) + 1;
PathfinderNode[,] nodeArray3 = new PathfinderNode[0x20, (num10 - 1) + 1];
PathfinderNode[] nodeArray2 = new PathfinderNode[0x20];
PathfinderNode[] nodeArray = new PathfinderNode[0x18];
bool[] flagArray = new bool[(num10 - 1) + 1];
Path[] pathArray2 = new Path[0x20];
PathfinderNode[] nodeArray4 = this.NetworkLargeArrays.Nodes_Nodes;
bool[] flagArray2 = this.NetworkLargeArrays.Nodes_Booleans;
float[] numArray = this.NetworkLargeArrays.Nodes_ValuesA;
float[] numArray2 = this.NetworkLargeArrays.Nodes_ValuesB;
int index = StartNodes[0].Layer.Network_LayerNum;
nodeArray2[index] = FinishNode;
int num2 = index;
while (true)
{
if (nodeArray2[num2].ParentNode == null)
{
num7 = num2;
break;
}
nodeArray2[num2 + 1] = nodeArray2[num2].ParentNode;
num2++;
}
int num11 = num10 - 1;
int num = 0;
while (num <= num11)
{
nodeArray3[index, num] = StartNodes[num];
num2 = index;
while (true)
{
if (nodeArray3[num2, num].ParentNode == null)
{
if (nodeArray3[num2, num] == nodeArray2[num2])
{
flagArray[num] = true;
num4++;
}
break;
}
nodeArray3[num2 + 1, num] = nodeArray3[num2, num].ParentNode;
num2++;
}
num++;
}
if (num4 == 0)
{
return null;
}
int num9 = num7;
pathArray2[num9] = new Path();
pathArray2[num9].Nodes = new PathfinderNode[] { nodeArray2[num9] };
pathArray2[num9].NodeCount = 1;
do
{
int num3;
PathfinderNode node;
int num8 = num9;
num9--;
if (num9 < index)
{
return pathArray2;
}
int num12 = pathArray2[num8].NodeCount - 1;
num = 0;
while (num <= num12)
{
node = pathArray2[num8].Nodes[num];
int num13 = node.ConnectionCount - 1;
for (num2 = 0; num2 <= num13; num2++)
{
num3 = node.Connections[num2].GetOtherNode(node).Layer_NodeNum;
flagArray2[num3] = false;
}
num++;
}
int num14 = pathArray2[num8].NodeCount - 1;
num = 0;
while (num <= num14)
{
node = pathArray2[num8].Nodes[num];
num3 = node.Layer_NodeNum;
flagArray2[num3] = true;
int num15 = node.NodeCount - 1;
for (int i = 0; i <= num15; i++)
{
num3 = node.Nodes[i].Layer_NodeNum;
numArray[num3] = float.MaxValue;
numArray2[num3] = float.MaxValue;
}
num++;
}
args = new sFloodRouteAllArgs {
FinishNode = nodeArray2[num9],
Visit = flagArray2,
NodeValuesA = numArray,
SourceNodes = nodeArray4,
NodeValuesB = numArray2,
MinClearance = MinClearance,
BestTolerance = (float) Math.Pow(1.1, (double) num9),
StartNodes = new PathfinderNode[(num10 - 1) + 1]
};
int num16 = num10 - 1;
num = 0;
while (num <= num16)
{
if (flagArray[num])
{
args.StartNodes[args.StartNodeCount] = nodeArray3[num9, num];
args.StartNodeCount++;
}
num++;
}
args.StartNodes = (PathfinderNode[]) Utils.CopyArray((Array) args.StartNodes, new PathfinderNode[(args.StartNodeCount - 1) + 1]);
this.FloodRouteAll(ref args);
pathArray2[num9] = new Path();
pathArray2[num9].Nodes = new PathfinderNode[(args.BestNodeCount - 1) + 1];
int num17 = args.BestNodeCount - 1;
for (num = 0; num <= num17; num++)
{
pathArray2[num9].Nodes[num] = args.SourceNodes[num];
}
pathArray2[num9].NodeCount = args.BestNodeCount;
}
while (args.BestNodeCount != 0);
Debugger.Break();
return pathArray2;
}
public void FloodRouteAll(ref sFloodRouteAllArgs Args)
{
PathfinderNode otherNode;
PathfinderNode node2;
float num3;
PathfinderConnection connection;
int startNodeCount = Args.StartNodeCount;
int num6 = startNodeCount - 1;
int index = 0;
while (index <= num6)
{
Args.SourceNodes[index] = Args.StartNodes[index];
Args.NodeValuesA[Args.StartNodes[index].Layer_NodeNum] = 0f;
index++;
}
int num5 = 0;
while (num5 < startNodeCount)
{
node2 = Args.SourceNodes[num5];
int num7 = node2.ConnectionCount - 1;
index = 0;
while (index <= num7)
{
connection = node2.Connections[index];
otherNode = connection.GetOtherNode(node2);
if (Args.Visit[otherNode.ParentNode.Layer_NodeNum] && (otherNode.Clearance >= Args.MinClearance))
{
num3 = Args.NodeValuesA[node2.Layer_NodeNum] + connection.Value;
if (num3 < Args.NodeValuesA[otherNode.Layer_NodeNum])
{
Args.NodeValuesA[otherNode.Layer_NodeNum] = num3;
Args.SourceNodes[startNodeCount] = otherNode;
startNodeCount++;
}
}
index++;
}
num5++;
}
startNodeCount = 0;
float num2 = Args.NodeValuesA[Args.FinishNode.Layer_NodeNum];
if (num2 == float.MaxValue)
{
Args.BestNodeCount = 0;
}
else
{
num2 *= Args.BestTolerance;
Args.SourceNodes[0] = Args.FinishNode;
startNodeCount = 1;
Args.NodeValuesB[Args.FinishNode.Layer_NodeNum] = 0f;
for (num5 = 0; num5 < startNodeCount; num5++)
{
node2 = Args.SourceNodes[num5];
int num8 = node2.ConnectionCount - 1;
for (index = 0; index <= num8; index++)
{
connection = node2.Connections[index];
otherNode = connection.GetOtherNode(node2);
if (Args.Visit[otherNode.ParentNode.Layer_NodeNum])
{
num3 = Args.NodeValuesB[node2.Layer_NodeNum] + connection.Value;
if (num3 < Args.NodeValuesB[otherNode.Layer_NodeNum])
{
Args.NodeValuesB[otherNode.Layer_NodeNum] = num3;
if ((Args.NodeValuesA[otherNode.Layer_NodeNum] + num3) <= (num2 + 500f))
{
Args.SourceNodes[startNodeCount] = otherNode;
startNodeCount++;
}
}
}
}
}
Args.BestNodeCount = startNodeCount;
}
}
public void FloodRouteAll(ref sFloodRouteAllArgs Args)
{
var CurrentNode = default(PathfinderNode);
var ConnectedNode = default(PathfinderNode);
var SourceNodeCount = 0;
var SourceNodeNum = 0;
var tmpConnection = default(PathfinderConnection);
float ResultValue = 0;
float BestValue = 0;
var A = 0;
SourceNodeCount = Args.StartNodeCount;
for (A = 0; A <= SourceNodeCount - 1; A++)
{
Args.SourceNodes[A] = Args.StartNodes[A];
Args.NodeValuesA[Args.StartNodes[A].Layer_NodeNum] = 0.0F;
}
SourceNodeNum = 0;
while (SourceNodeNum < SourceNodeCount)
{
CurrentNode = Args.SourceNodes[SourceNodeNum];
for (A = 0; A <= CurrentNode.ConnectionCount - 1; A++)
{
tmpConnection = CurrentNode.Connections[A];
ConnectedNode = tmpConnection.GetOtherNode(CurrentNode);
if (Args.Visit[ConnectedNode.ParentNode.Layer_NodeNum])
{
if (ConnectedNode.Clearance >= Args.MinClearance)
{
ResultValue = Args.NodeValuesA[CurrentNode.Layer_NodeNum] + tmpConnection.Value;
if (ResultValue < Args.NodeValuesA[ConnectedNode.Layer_NodeNum])
{
Args.NodeValuesA[ConnectedNode.Layer_NodeNum] = ResultValue;
Args.SourceNodes[SourceNodeCount] = ConnectedNode;
SourceNodeCount++;
}
}
}
}
SourceNodeNum++;
}
SourceNodeCount = 0;
BestValue = Args.NodeValuesA[Args.FinishNode.Layer_NodeNum];
if (BestValue == float.MaxValue)
{
Args.BestNodeCount = 0;
return;
}
BestValue *= Args.BestTolerance;
Args.SourceNodes[0] = Args.FinishNode;
SourceNodeCount = 1;
Args.NodeValuesB[Args.FinishNode.Layer_NodeNum] = 0.0F;
SourceNodeNum = 0;
while (SourceNodeNum < SourceNodeCount)
{
CurrentNode = Args.SourceNodes[SourceNodeNum];
for (A = 0; A <= CurrentNode.ConnectionCount - 1; A++)
{
tmpConnection = CurrentNode.Connections[A];
ConnectedNode = tmpConnection.GetOtherNode(CurrentNode);
if (Args.Visit[ConnectedNode.ParentNode.Layer_NodeNum])
{
ResultValue = Args.NodeValuesB[CurrentNode.Layer_NodeNum] + tmpConnection.Value;
if (ResultValue < Args.NodeValuesB[ConnectedNode.Layer_NodeNum])
{
Args.NodeValuesB[ConnectedNode.Layer_NodeNum] = ResultValue;
if (Args.NodeValuesA[ConnectedNode.Layer_NodeNum] + ResultValue <= BestValue + 500.0F)
{
Args.SourceNodes[SourceNodeCount] = ConnectedNode;
SourceNodeCount++;
}
}
}
}
SourceNodeNum++;
}
Args.BestNodeCount = SourceNodeCount;
}
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);
}
