public PathList[] GetPath(PathfinderNode[] StartNodes, PathfinderNode FinishNode, int Accuracy, int MinClearance) { int StartNodeCount = StartNodes.GetUpperBound(0) + 1; PathList[] Paths = new PathList[NodeLayerCount]; PathfinderNode[,] LayerStartNodes = new PathfinderNode[NodeLayerCount, StartNodeCount]; PathfinderNode[] LayerFinishNodes = new PathfinderNode[NodeLayerCount]; int LayerNum = 0; PathfinderNode[] Destinations = new PathfinderNode[24]; int DestinationCount = 0; bool FinishIsParent = default(bool); bool IsInaccurate; int[] CalcNodeCount = new int[24]; sFloodRouteArgs FloodRouteArgs = new sFloodRouteArgs(); int FinalLayer = 0; bool[] StartCanReach = new bool[StartNodeCount]; PathfinderNode tmpNodeA = default(PathfinderNode); PathfinderNode tmpNodeB = default(PathfinderNode); int CanReachCount = 0; int FirstLayer = 0; Path[] BestPaths = new Path[24]; float[] BestValues = new float[24]; int PathNum = 0; bool StopMultiPathing = default(bool); bool[] Visit = NetworkLargeArrays.Nodes_Booleans; float[] NodeValues = NetworkLargeArrays.Nodes_ValuesA; PathfinderNode[] Nodes_Nodes = NetworkLargeArrays.Nodes_Nodes; Path StartPath = NetworkLargeArrays.Nodes_Path; int A = 0; int B = 0; int C = 0; int D = 0; int 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; int LastLayer = 0; do { LastLayer = LayerNum; LayerNum--; if ( LayerNum < FinalLayer ) { break; } else 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; IsInaccurate = 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(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 FloodRoute(sFloodRouteArgs 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 != null ) { if ( Args.Visit[ConnectedNode.ParentNode.Layer_NodeNum] ) { if ( ConnectedNode.Clearance >= Args.MinClearance ) { 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 != null ) { if ( Args.Visit[ConnectedNode.ParentNode.Layer_NodeNum] ) { Dist = Args.NodeValues[ConnectedNode.Layer_NodeNum]; if ( Dist < BestDist ) { BestDist = Dist; BestNode = ConnectedNode; } } } } if ( BestNode == null ) { Args.BestPaths[A] = null; 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 PathList[] GetPath(PathfinderNode[] StartNodes, PathfinderNode FinishNode, int Accuracy, int MinClearance) { int num; int num4; int num9; int num13 = StartNodes.GetUpperBound(0) + 1; PathList[] listArray2 = new PathList[(this.NodeLayerCount - 1) + 1]; PathfinderNode[,] nodeArray3 = new PathfinderNode[(this.NodeLayerCount - 1) + 1, (num13 - 1) + 1]; PathfinderNode[] nodeArray2 = new PathfinderNode[(this.NodeLayerCount - 1) + 1]; PathfinderNode[] nodeArray = new PathfinderNode[0x18]; int[] numArray2 = new int[0x18]; bool[] flagArray = new bool[(num13 - 1) + 1]; Path[] pathArray = new Path[0x18]; float[] numArray = new float[0x18]; bool[] flagArray2 = this.NetworkLargeArrays.Nodes_Booleans; float[] numArray3 = this.NetworkLargeArrays.Nodes_ValuesA; PathfinderNode[] nodeArray4 = this.NetworkLargeArrays.Nodes_Nodes; Path path = this.NetworkLargeArrays.Nodes_Path; int index = StartNodes[0].Layer.Network_LayerNum; nodeArray2[index] = FinishNode; int num2 = index; while (true) { if (nodeArray2[num2].ParentNode == null) { num9 = num2; break; } nodeArray2[num2 + 1] = nodeArray2[num2].ParentNode; num2++; } int num14 = num13 - 1; for (num = 0; num <= num14; num++) { 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++; } } if (num4 != 0) { int num11 = num9; listArray2[num11].Paths = new Path[] { new Path() }; listArray2[num11].PathCount = 1; listArray2[num11].Paths[0].Nodes = new PathfinderNode[] { nodeArray2[num11] }; listArray2[num11].Paths[0].NodeCount = 1; do { int num3; int num5; int num6; int num7; bool flag; int num12; bool flag3; PathfinderNode node; PathfinderNode otherNode; int num10 = num11; num11--; if (num11 < index) { return listArray2; } if (flag3) { if (Accuracy < 0) { Debugger.Break(); } int num15 = listArray2[num10].PathCount - 1; for (num12 = 0; num12 <= num15; num12++) { numArray2[num12] = Math.Min(Accuracy, listArray2[num10].Paths[num12].NodeCount - 1); } nodeArray[0] = listArray2[num10].Paths[0].Nodes[numArray2[0]]; num6 = 1; flag = true; } else { if (Accuracy >= 0) { int num16 = listArray2[num10].PathCount - 1; for (num12 = 0; num12 <= num16; num12++) { if (listArray2[num10].Paths[num12].NodeCount > Accuracy) { flag3 = true; break; } } } nodeArray[0] = nodeArray2[num11]; if (num11 == index) { num6 = 1; } else { int num17 = nodeArray[0].ConnectionCount - 1; num = 0; while (num <= num17) { nodeArray[1 + num] = nodeArray[0].Connections[num].GetOtherNode(nodeArray[0]); num++; } num6 = 1 + nodeArray[0].ConnectionCount; } int num18 = listArray2[num10].PathCount - 1; for (num12 = 0; num12 <= num18; num12++) { numArray2[num12] = listArray2[num10].Paths[num12].NodeCount - 1; } flag = false; } int num19 = listArray2[num10].PathCount - 1; for (num12 = 0; num12 <= num19; num12++) { int num20 = numArray2[num12]; num = 0; while (num <= num20) { node = listArray2[num10].Paths[num12].Nodes[num]; int num21 = node.ConnectionCount - 1; num5 = 0; while (num5 <= num21) { otherNode = node.Connections[num5].GetOtherNode(node); int num22 = otherNode.ConnectionCount - 1; num7 = 0; while (num7 <= num22) { num3 = otherNode.Connections[num7].GetOtherNode(otherNode).Layer_NodeNum; flagArray2[num3] = false; num7++; } num5++; } num++; } } int num23 = listArray2[num10].PathCount - 1; num12 = 0; while (num12 <= num23) { int num24 = numArray2[num12]; num = 0; while (num <= num24) { node = listArray2[num10].Paths[num12].Nodes[num]; num3 = node.Layer_NodeNum; flagArray2[num3] = true; int num25 = node.NodeCount - 1; num7 = 0; while (num7 <= num25) { num3 = node.Nodes[num7].Layer_NodeNum; numArray3[num3] = float.MaxValue; num7++; } int num26 = node.ConnectionCount - 1; for (num5 = 0; num5 <= num26; num5++) { otherNode = node.Connections[num5].GetOtherNode(node); num3 = otherNode.Layer_NodeNum; flagArray2[num3] = true; int num27 = otherNode.NodeCount - 1; for (num7 = 0; num7 <= num27; num7++) { num3 = otherNode.Nodes[num7].Layer_NodeNum; numArray3[num3] = float.MaxValue; } } num++; } num12++; } sFloodRouteArgs args = new sFloodRouteArgs { CurrentPath = path, FinishNodes = nodeArray, FinishNodeCount = num6, FinishIsParent = flag, Visit = flagArray2, NodeValues = numArray3, SourceNodes = nodeArray4, MinClearance = MinClearance }; int num28 = num6 - 1; for (num = 0; num <= num28; num++) { pathArray[num] = null; numArray[num] = float.MaxValue; } int num29 = num13 - 1; for (num = 0; num <= num29; num++) { if (flagArray[num]) { path.NodeCount = 1; path.Nodes[0] = nodeArray3[num11, num]; path.Value = 0f; args.BestPaths = new Path[(num6 - 1) + 1]; this.FloodRoute(ref args); int num30 = num6 - 1; num12 = 0; while (num12 <= num30) { if ((args.BestPaths[num12] != null) && (args.BestPaths[num12].Value < numArray[num12])) { numArray[num12] = args.BestPaths[num12].Value; pathArray[num12] = args.BestPaths[num12]; } num12++; } } } listArray2[num11].Paths = new Path[(num6 - 1) + 1]; listArray2[num11].PathCount = 0; int num31 = num6 - 1; for (num12 = 0; num12 <= num31; num12++) { if (pathArray[num12] != null) { listArray2[num11].Paths[listArray2[num11].PathCount] = pathArray[num12]; PathList[] listArray3 = listArray2; int num32 = num11; listArray3[num32].PathCount++; } } listArray2[num11].Paths = (Path[]) Utils.CopyArray((Array) listArray2[num11].Paths, new Path[(listArray2[num11].PathCount - 1) + 1]); } while (listArray2[num11].PathCount != 0); } return null; }
public void FloodRoute(ref sFloodRouteArgs 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 != null) && Args.Visit[otherNode.ParentNode.Layer_NodeNum]) && (otherNode.Clearance >= Args.MinClearance)) { 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 != null) && Args.Visit[otherNode.ParentNode.Layer_NodeNum]) { 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 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 FloodRoute(ref sFloodRouteArgs 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 != null) { if (Args.Visit[ConnectedNode.ParentNode.Layer_NodeNum]) { if (ConnectedNode.Clearance >= Args.MinClearance) { 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 != null) { if (Args.Visit[ConnectedNode.ParentNode.Layer_NodeNum]) { Dist = Args.NodeValues[ConnectedNode.Layer_NodeNum]; if (Dist < BestDist) { BestDist = Dist; BestNode = ConnectedNode; } } } } if (BestNode == null) { Args.BestPaths[A] = null; 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]; } } }