public void FloodForValues(ref sFloodForValuesArgs Args)
{
int num;
PathfinderNode otherNode;
PathfinderNode node3;
PathfinderNode node4 = Args.CurrentPath.Nodes[0];
Args.SourceNodes[0] = node4;
int index = 1;
Args.NodeValues[node4.Layer_NodeNum] = 0f;
for (int i = 0; i < index; i++)
{
node3 = Args.SourceNodes[i];
int num9 = node3.ConnectionCount - 1;
num = 0;
while (num <= num9)
{
PathfinderConnection connection = node3.Connections[num];
otherNode = connection.GetOtherNode(node3);
if ((otherNode.ParentNode == Args.SourceParentNodeA) | (otherNode.ParentNode == Args.SourceParentNodeB))
{
float num6 = Args.NodeValues[node3.Layer_NodeNum] + connection.Value;
if (num6 < Args.NodeValues[otherNode.Layer_NodeNum])
{
Args.NodeValues[otherNode.Layer_NodeNum] = num6;
Args.SourceNodes[index] = otherNode;
index++;
}
}
num++;
}
}
int num10 = Args.FinishNodeCount - 1;
for (num = 0; num <= num10; num++)
{
float maxValue;
PathfinderNode node;
float num5;
if (Args.FinishIsParent)
{
node = null;
maxValue = float.MaxValue;
int num11 = Args.FinishNodes[num].NodeCount - 1;
for (int j = 0; j <= num11; j++)
{
node3 = Args.FinishNodes[num].Nodes[j];
num5 = Args.NodeValues[node3.Layer_NodeNum];
if (num5 < maxValue)
{
maxValue = num5;
node = node3;
}
}
node3 = node;
}
else
{
node3 = Args.FinishNodes[num];
}
if (node3 != null)
{
index = 0;
maxValue = Args.NodeValues[node3.Layer_NodeNum];
if (maxValue != float.MaxValue)
{
int num2;
while (true)
{
Args.SourceNodes[index] = node3;
index++;
if (node3 == node4)
{
break;
}
node = null;
int num12 = node3.ConnectionCount - 1;
num2 = 0;
while (num2 <= num12)
{
otherNode = node3.Connections[num2].GetOtherNode(node3);
if ((otherNode.ParentNode == Args.SourceParentNodeA) | (otherNode.ParentNode == Args.SourceParentNodeB))
{
num5 = Args.NodeValues[otherNode.Layer_NodeNum];
if (num5 < maxValue)
{
maxValue = num5;
node = otherNode;
}
}
num2++;
}
if (node == null)
{
Args.BestPaths[num] = null;
continue;
}
node3 = node;
}
Path path = new Path();
Args.BestPaths[num] = path;
path.Value = Args.NodeValues[Args.FinishNodes[num].Layer_NodeNum];
path.NodeCount = index;
path.Nodes = new PathfinderNode[(path.NodeCount - 1) + 1];
int num13 = path.NodeCount - 1;
for (num2 = 0; num2 <= num13; num2++)
{
path.Nodes[num2] = Args.SourceNodes[(index - num2) - 1];
}
}
}
}
}
public void FloodForValues(sFloodForValuesArgs Args)
{
PathfinderNode CurrentNode = default(PathfinderNode);
PathfinderNode ConnectedNode = default(PathfinderNode);
int A = 0;
int SourceNodeCount = 0;
int SourceNodeNum = 0;
PathfinderConnection tmpConnection = default(PathfinderConnection);
float ResultValue = 0;
Path BestPath = default(Path);
PathfinderNode StartNode = default(PathfinderNode);
int B = 0;
float BestDist = 0;
float Dist = 0;
PathfinderNode BestNode = default(PathfinderNode);
int C = 0;
StartNode = Args.CurrentPath.Nodes[0];
Args.SourceNodes[0] = StartNode;
SourceNodeCount = 1;
Args.NodeValues[StartNode.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 ( ConnectedNode.ParentNode == Args.SourceParentNodeA || ConnectedNode.ParentNode == Args.SourceParentNodeB )
{
ResultValue = Args.NodeValues[CurrentNode.Layer_NodeNum] + tmpConnection.Value;
if ( ResultValue < Args.NodeValues[ConnectedNode.Layer_NodeNum] )
{
Args.NodeValues[ConnectedNode.Layer_NodeNum] = ResultValue;
Args.SourceNodes[SourceNodeCount] = ConnectedNode;
SourceNodeCount++;
}
}
}
SourceNodeNum++;
}
for ( A = 0; A <= Args.FinishNodeCount - 1; A++ )
{
if ( Args.FinishIsParent )
{
BestNode = null;
BestDist = float.MaxValue;
for ( C = 0; C <= Args.FinishNodes[A].NodeCount - 1; C++ )
{
CurrentNode = Args.FinishNodes[A].Nodes[C];
Dist = Args.NodeValues[CurrentNode.Layer_NodeNum];
if ( Dist < BestDist )
{
BestDist = Dist;
BestNode = CurrentNode;
}
}
CurrentNode = BestNode;
}
else
{
CurrentNode = Args.FinishNodes[A];
}
if ( CurrentNode == null )
{
//no path
return;
}
SourceNodeCount = 0;
BestDist = Args.NodeValues[CurrentNode.Layer_NodeNum];
if ( BestDist == float.MaxValue )
{
//no path
return;
}
do
{
Args.SourceNodes[SourceNodeCount] = CurrentNode;
SourceNodeCount++;
if ( CurrentNode == StartNode )
{
break;
}
BestNode = null;
for ( B = 0; B <= CurrentNode.ConnectionCount - 1; B++ )
{
tmpConnection = CurrentNode.Connections[B];
ConnectedNode = tmpConnection.GetOtherNode(CurrentNode);
if ( ConnectedNode.ParentNode == Args.SourceParentNodeA || ConnectedNode.ParentNode == Args.SourceParentNodeB )
{
Dist = Args.NodeValues[ConnectedNode.Layer_NodeNum];
if ( Dist < BestDist )
{
BestDist = Dist;
BestNode = ConnectedNode;
}
}
}
if ( BestNode == null )
{
Args.BestPaths[A] = null;
//no path
return;
}
CurrentNode = BestNode;
} while ( true );
BestPath = new Path();
Args.BestPaths[A] = BestPath;
BestPath.Value = Args.NodeValues[Args.FinishNodes[A].Layer_NodeNum];
BestPath.NodeCount = SourceNodeCount;
BestPath.Nodes = new PathfinderNode[BestPath.NodeCount];
for ( B = 0; B <= BestPath.NodeCount - 1; B++ )
{
BestPath.Nodes[B] = Args.SourceNodes[SourceNodeCount - B - 1];
}
}
}
public void FloodForValues(ref sFloodForValuesArgs Args)
{
var CurrentNode = default(PathfinderNode);
var ConnectedNode = default(PathfinderNode);
var A = 0;
var SourceNodeCount = 0;
var SourceNodeNum = 0;
var tmpConnection = default(PathfinderConnection);
float ResultValue = 0;
var BestPath = default(Path);
var StartNode = default(PathfinderNode);
var B = 0;
float BestDist = 0;
float Dist = 0;
var BestNode = default(PathfinderNode);
var C = 0;
StartNode = Args.CurrentPath.Nodes[0];
Args.SourceNodes[0] = StartNode;
SourceNodeCount = 1;
Args.NodeValues[StartNode.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 (ConnectedNode.ParentNode == Args.SourceParentNodeA || ConnectedNode.ParentNode == Args.SourceParentNodeB)
{
ResultValue = Args.NodeValues[CurrentNode.Layer_NodeNum] + tmpConnection.Value;
if (ResultValue < Args.NodeValues[ConnectedNode.Layer_NodeNum])
{
Args.NodeValues[ConnectedNode.Layer_NodeNum] = ResultValue;
Args.SourceNodes[SourceNodeCount] = ConnectedNode;
SourceNodeCount++;
}
}
}
SourceNodeNum++;
}
for (A = 0; A <= Args.FinishNodeCount - 1; A++)
{
if (Args.FinishIsParent)
{
BestNode = null;
BestDist = float.MaxValue;
for (C = 0; C <= Args.FinishNodes[A].NodeCount - 1; C++)
{
CurrentNode = Args.FinishNodes[A].Nodes[C];
Dist = Args.NodeValues[CurrentNode.Layer_NodeNum];
if (Dist < BestDist)
{
BestDist = Dist;
BestNode = CurrentNode;
}
}
CurrentNode = BestNode;
}
else
{
CurrentNode = Args.FinishNodes[A];
}
if (CurrentNode == null)
{
//no path
return;
}
SourceNodeCount = 0;
BestDist = Args.NodeValues[CurrentNode.Layer_NodeNum];
if (BestDist == float.MaxValue)
{
//no path
return;
}
do
{
Args.SourceNodes[SourceNodeCount] = CurrentNode;
SourceNodeCount++;
if (CurrentNode == StartNode)
{
break;
}
BestNode = null;
for (B = 0; B <= CurrentNode.ConnectionCount - 1; B++)
{
tmpConnection = CurrentNode.Connections[B];
ConnectedNode = tmpConnection.GetOtherNode(CurrentNode);
if (ConnectedNode.ParentNode == Args.SourceParentNodeA || ConnectedNode.ParentNode == Args.SourceParentNodeB)
{
Dist = Args.NodeValues[ConnectedNode.Layer_NodeNum];
if (Dist < BestDist)
{
BestDist = Dist;
BestNode = ConnectedNode;
}
}
}
if (BestNode == null)
{
Args.BestPaths[A] = null;
//no path
return;
}
CurrentNode = BestNode;
} while (true);
BestPath = new Path();
Args.BestPaths[A] = BestPath;
BestPath.Value = Args.NodeValues[Args.FinishNodes[A].Layer_NodeNum];
BestPath.NodeCount = SourceNodeCount;
BestPath.Nodes = new PathfinderNode[BestPath.NodeCount];
for (B = 0; B <= BestPath.NodeCount - 1; B++)
{
BestPath.Nodes[B] = Args.SourceNodes[SourceNodeCount - B - 1];
}
}
}
