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); }