public clsResult GenerateRamps() { int num; int num6; int num7; int num9; clsResult result2 = new clsResult("Ramps"); int num13 = this.ConnectionCount - 1; for (num = 0; num <= num13; num++) { this.Connections[num].IsRamp = false; } clsPassageNodeNework nework = this.MakePassageNodeNetwork(); PathfinderNode[,] passageNodePathNodes = nework.PassageNodePathNodes; clsConnection[] connectionArray = new clsConnection[(this.ConnectionCount - 1) + 1]; PathfinderNode[] startNodes = new PathfinderNode[1]; bool[] flagArray = new bool[(this.ConnectionCount - 1) + 1]; int num14 = this.ConnectionCount - 1; int index = 0; while (index <= num14) { if (Math.Abs((int) (this.Connections[index].PassageNodeA.Level - this.Connections[index].PassageNodeB.Level)) == 1) { if ((!(this.Connections[index].PassageNodeA.IsOnBorder | this.Connections[index].PassageNodeB.IsOnBorder) & (this.Connections[index].PassageNodeA.MirrorNum == 0)) & (this.Connections[index].PassageNodeA.Num != this.Connections[index].PassageNodeB.Num)) { flagArray[index] = true; } else { flagArray[index] = false; } } else { flagArray[index] = false; } index++; } clsNodeConnectedness connectedness = new clsNodeConnectedness { NodeConnectedness = new float[(this.PassageNodeCount - 1) + 1], PassageNodeVisited = new bool[(this.SymmetryBlockCount - 1) + 1, (this.PassageNodeCount - 1) + 1], PassageNodePathNodes = passageNodePathNodes, PassageNodePathMap = nework.Network }; PathfinderConnection[] connectionArray2 = new PathfinderConnection[4]; clsUpdateNodeConnectednessArgs args3 = new clsUpdateNodeConnectednessArgs(); clsUpdateNetworkConnectednessArgs args2 = new clsUpdateNetworkConnectednessArgs(); args3.Args = connectedness; args2.Args = connectedness; args2.PassageNodeUpdated = new bool[(this.PassageNodeCount - 1) + 1]; args2.SymmetryBlockCount = this.SymmetryBlockCount; int num15 = this.PassageNodeCount - 1; for (num = 0; num <= num15; num++) { connectedness.NodeConnectedness[num] = 0f; int num16 = this.PassageNodeCount - 1; for (index = 0; index <= num16; index++) { int num17 = this.SymmetryBlockCount - 1; num7 = 0; while (num7 <= num17) { connectedness.PassageNodeVisited[num7, index] = false; num7++; } } args3.OriginalNode = this.PassageNodes[0, num]; this.UpdateNodeConnectedness(args3, this.PassageNodes[0, num]); } Label_0269: num6 = -1; double num4 = 1.0; double num5 = 0.0; int num10 = 0; int num18 = this.ConnectionCount - 1; index = 0; while (index <= num18) { if (flagArray[index] & !this.Connections[index].IsRamp) { if (this.CheckRampAngles(this.Connections[index], 1.3962634015954636, 2.0943951023931953, 0.0)) { modMath.sXY_int _int; startNodes[0] = passageNodePathNodes[this.Connections[index].PassageNodeA.MirrorNum, this.Connections[index].PassageNodeA.Num]; PathfinderNetwork.PathList[] listArray = nework.Network.GetPath(startNodes, passageNodePathNodes[this.Connections[index].PassageNodeB.MirrorNum, this.Connections[index].PassageNodeB.Num], -1, 0); double maxValue = double.MaxValue; _int.X = (int) Math.Round((double) (((double) (this.Connections[index].PassageNodeA.Pos.X + this.Connections[index].PassageNodeB.Pos.X)) / 2.0)); _int.Y = (int) Math.Round((double) (((double) (this.Connections[index].PassageNodeA.Pos.Y + this.Connections[index].PassageNodeB.Pos.Y)) / 2.0)); int num19 = this.TotalPlayerCount - 1; num9 = 0; while (num9 <= num19) { modMath.sXY_int _int2 = this.PlayerBases[num9].Pos - _int; double magnitude = _int2.ToDoubles().GetMagnitude(); if (magnitude < maxValue) { maxValue = magnitude; } num9++; } double num11 = Math.Max((double) (this.MaxDisconnectionDist * Math.Pow(this.RampBase, maxValue / 1024.0)), (double) 1.0); if (listArray == null) { double num12 = connectedness.NodeConnectedness[this.Connections[index].PassageNodeA.Num] + connectedness.NodeConnectedness[this.Connections[index].PassageNodeB.Num]; if (double.MaxValue > num4) { num4 = double.MaxValue; num5 = num12; connectionArray[0] = this.Connections[index]; num10 = 1; } else if (num12 < num5) { num5 = num12; connectionArray[0] = this.Connections[index]; num10 = 1; } else if (num12 == num5) { connectionArray[num10] = this.Connections[index]; num10++; } } else { if (listArray[0].PathCount != 1) { result2.ProblemAdd("Error: Invalid number of routes returned."); goto Label_088A; } if ((((double) listArray[0].Paths[0].Value) / num11) > num4) { num4 = ((double) listArray[0].Paths[0].Value) / num11; connectionArray[0] = this.Connections[index]; num10 = 1; } else if ((((double) listArray[0].Paths[0].Value) / num11) == num4) { connectionArray[num10] = this.Connections[index]; num10++; } else if (listArray[0].Paths[0].Value <= num11) { flagArray[index] = false; } } } else { flagArray[index] = false; } } else { flagArray[index] = false; } index++; } if (num10 > 0) { num6 = (int) Math.Round((double) ((float) (App.Random.Next() * num10))); connectionArray[num6].IsRamp = true; clsPassageNode passageNodeA = connectionArray[num6].PassageNodeA; clsPassageNode passageNodeB = connectionArray[num6].PassageNodeB; PathfinderNode nodeA = passageNodePathNodes[passageNodeA.MirrorNum, passageNodeA.Num]; PathfinderNode otherNode = passageNodePathNodes[passageNodeB.MirrorNum, passageNodeB.Num]; PathfinderConnection connection = nodeA.CreateConnection(otherNode, this.GetNodePosDist(nodeA, otherNode)); int num20 = connectionArray[num6].ReflectionCount - 1; for (num7 = 0; num7 <= num20; num7++) { connectionArray[num6].Reflections[num7].IsRamp = true; passageNodeA = connectionArray[num6].Reflections[num7].PassageNodeA; passageNodeB = connectionArray[num6].Reflections[num7].PassageNodeB; nodeA = passageNodePathNodes[passageNodeA.MirrorNum, passageNodeA.Num]; otherNode = passageNodePathNodes[passageNodeB.MirrorNum, passageNodeB.Num]; connection = nodeA.CreateConnection(otherNode, this.GetNodePosDist(nodeA, otherNode)); } nework.Network.FindCalc(); int num21 = this.PassageNodeCount - 1; for (num9 = 0; num9 <= num21; num9++) { args2.PassageNodeUpdated[num9] = false; } if (connectionArray[num6].PassageNodeA.MirrorNum == 0) { this.UpdateNetworkConnectedness(args2, connectionArray[num6].PassageNodeA); goto Label_0269; } if (connectionArray[num6].PassageNodeB.MirrorNum == 0) { this.UpdateNetworkConnectedness(args2, connectionArray[num6].PassageNodeB); goto Label_0269; } result2.ProblemAdd("Error: Initial ramp not in area 0."); } else { PathfinderNetwork.sFloodProximityArgs args; args.StartNode = nework.PassageNodePathNodes[0, 0]; args.NodeValues = nework.Network.NetworkLargeArrays.Nodes_ValuesA; int num22 = this.PassageNodeCount - 1; for (num = 0; num <= num22; num++) { int num23 = this.SymmetryBlockCount - 1; index = 0; while (index <= num23) { args.NodeValues[nework.PassageNodePathNodes[index, num].Layer_NodeNum] = float.MaxValue; index++; } } nework.Network.FloodProximity(ref args); int num24 = this.PassageNodeCount - 1; for (num = 0; num <= num24; num++) { int num25 = this.SymmetryBlockCount - 1; for (index = 0; index <= num25; index++) { if (!this.PassageNodes[index, num].IsWater && (args.NodeValues[nework.PassageNodePathNodes[index, num].Layer_NodeNum] == float.MaxValue)) { result2.ProblemAdd("Land is unreachable. Reduce variation or retry."); break; } } } } Label_088A: nework.Network.Deallocate(); return result2; }
public clsResult GenerateRamps() { clsResult ReturnResult = new clsResult("Ramps"); int A = 0; int B = 0; int C = 0; int E = 0; double BestDist = 0; int BestNum = 0; sXY_int XY_int = new sXY_int(); clsPassageNode tmpPassageNodeA = default(clsPassageNode); clsPassageNode tmpPassageNodeB = default(clsPassageNode); double Dist = 0; //make ramps for ( A = 0; A <= ConnectionCount - 1; A++ ) { Connections[A].IsRamp = false; } PathfinderNode tmpNodeA = default(PathfinderNode); PathfinderNode tmpNodeB = default(PathfinderNode); PathfinderNode[,] PassageNodePathNodes = null; PathfinderConnection NewConnection; clsPassageNodeNework PassageNodeNetwork = MakePassageNodeNetwork(); PassageNodePathNodes = PassageNodeNetwork.PassageNodePathNodes; clsConnection[] PossibleRamps = new clsConnection[ConnectionCount]; int PossibleRampCount = 0; PathfinderNode[] GetPathStartNodes = new PathfinderNode[1]; PathfinderNetwork.PathList[] ResultPaths = null; //ramp connections whose points are too far apart bool[] ConnectionsCanRamp = new bool[ConnectionCount]; for ( B = 0; B <= ConnectionCount - 1; B++ ) { C = Math.Abs(Connections[B].PassageNodeA.Level - Connections[B].PassageNodeB.Level); if ( C == 1 ) { if ( !(Connections[B].PassageNodeA.IsOnBorder || Connections[B].PassageNodeB.IsOnBorder) && Connections[B].PassageNodeA.MirrorNum == 0 && Connections[B].PassageNodeA.Num != Connections[B].PassageNodeB.Num ) { ConnectionsCanRamp[B] = true; } else { ConnectionsCanRamp[B] = false; } } else { ConnectionsCanRamp[B] = false; } } clsNodeConnectedness Connectedness = new clsNodeConnectedness(); Connectedness.NodeConnectedness = new float[PassageNodeCount]; Connectedness.PassageNodeVisited = new bool[SymmetryBlockCount, PassageNodeCount]; Connectedness.PassageNodePathNodes = PassageNodePathNodes; Connectedness.PassageNodePathMap = PassageNodeNetwork.Network; PathfinderConnection[] tmpPathConnection = new PathfinderConnection[4]; double Value = 0; double BestDistB = 0; double BaseDist = 0; double RampDist = 0; clsUpdateNodeConnectednessArgs UpdateNodeConnectednessArgs = new clsUpdateNodeConnectednessArgs(); clsUpdateNetworkConnectednessArgs UpdateNetworkConnectednessArgs = new clsUpdateNetworkConnectednessArgs(); UpdateNodeConnectednessArgs.Args = Connectedness; UpdateNetworkConnectednessArgs.Args = Connectedness; UpdateNetworkConnectednessArgs.PassageNodeUpdated = new bool[PassageNodeCount]; UpdateNetworkConnectednessArgs.SymmetryBlockCount = SymmetryBlockCount; for ( A = 0; A <= PassageNodeCount - 1; A++ ) { Connectedness.NodeConnectedness[A] = 0.0F; for ( B = 0; B <= PassageNodeCount - 1; B++ ) { for ( C = 0; C <= SymmetryBlockCount - 1; C++ ) { Connectedness.PassageNodeVisited[C, B] = false; } } UpdateNodeConnectednessArgs.OriginalNode = PassageNodes[0, A]; UpdateNodeConnectedness(UpdateNodeConnectednessArgs, PassageNodes[0, A]); } do { BestNum = -1; BestDist = 1.0F; //for connections that can already reach the other side BestDistB = 0.0F; //for connections that cant PossibleRampCount = 0; for ( B = 0; B <= ConnectionCount - 1; B++ ) { if ( ConnectionsCanRamp[B] && !Connections[B].IsRamp ) { if ( CheckRampAngles(Connections[B], Convert.ToDouble(80.0D * MathUtil.RadOf1Deg), Convert.ToDouble(120.0D * MathUtil.RadOf1Deg), 0.0D * MathUtil.RadOf1Deg) ) { GetPathStartNodes[0] = PassageNodePathNodes[Connections[B].PassageNodeA.MirrorNum, Connections[B].PassageNodeA.Num]; ResultPaths = PassageNodeNetwork.Network.GetPath(GetPathStartNodes, PassageNodePathNodes[Connections[B].PassageNodeB.MirrorNum, Connections[B].PassageNodeB.Num], -1, 0); BaseDist = double.MaxValue; XY_int.X = (int)((Connections[B].PassageNodeA.Pos.X + Connections[B].PassageNodeB.Pos.X) / 2.0D); XY_int.Y = (int)((Connections[B].PassageNodeA.Pos.Y + Connections[B].PassageNodeB.Pos.Y) / 2.0D); for ( E = 0; E <= TotalPlayerCount - 1; E++ ) { Dist = Convert.ToDouble((PlayerBases[E].Pos - XY_int).ToDoubles().GetMagnitude()); if ( Dist < BaseDist ) { BaseDist = Dist; } } RampDist = Math.Max(MaxDisconnectionDist * Math.Pow(RampBase, (BaseDist / 1024.0D)), 1.0F); if ( ResultPaths == null ) { Value = Connectedness.NodeConnectedness[Connections[B].PassageNodeA.Num] + Connectedness.NodeConnectedness[Connections[B].PassageNodeB.Num]; if ( double.MaxValue > BestDist ) { BestDist = double.MaxValue; BestDistB = Value; PossibleRamps[0] = Connections[B]; PossibleRampCount = 1; } else { if ( Value < BestDistB ) { BestDistB = Value; PossibleRamps[0] = Connections[B]; PossibleRampCount = 1; } else if ( Value == BestDistB ) { PossibleRamps[PossibleRampCount] = Connections[B]; PossibleRampCount++; } } } else if ( ResultPaths[0].PathCount != 1 ) { ReturnResult.ProblemAdd("Error: Invalid number of routes returned."); goto Finish; } else if ( ResultPaths[0].Paths[0].Value / RampDist > BestDist ) { BestDist = ResultPaths[0].Paths[0].Value / RampDist; PossibleRamps[0] = Connections[B]; PossibleRampCount = 1; } else if ( ResultPaths[0].Paths[0].Value / RampDist == BestDist ) { PossibleRamps[PossibleRampCount] = Connections[B]; PossibleRampCount++; } else if ( ResultPaths[0].Paths[0].Value <= RampDist ) { ConnectionsCanRamp[B] = false; } } else { ConnectionsCanRamp[B] = false; } } else { ConnectionsCanRamp[B] = false; } } if ( PossibleRampCount > 0 ) { BestNum = (int)(Conversion.Int(VBMath.Rnd() * PossibleRampCount)); PossibleRamps[BestNum].IsRamp = true; tmpPassageNodeA = PossibleRamps[BestNum].PassageNodeA; tmpPassageNodeB = PossibleRamps[BestNum].PassageNodeB; tmpNodeA = PassageNodePathNodes[tmpPassageNodeA.MirrorNum, tmpPassageNodeA.Num]; tmpNodeB = PassageNodePathNodes[tmpPassageNodeB.MirrorNum, tmpPassageNodeB.Num]; NewConnection = tmpNodeA.CreateConnection(tmpNodeB, GetNodePosDist(tmpNodeA, tmpNodeB)); for ( C = 0; C <= PossibleRamps[BestNum].ReflectionCount - 1; C++ ) { PossibleRamps[BestNum].Reflections[C].IsRamp = true; tmpPassageNodeA = PossibleRamps[BestNum].Reflections[C].PassageNodeA; tmpPassageNodeB = PossibleRamps[BestNum].Reflections[C].PassageNodeB; tmpNodeA = PassageNodePathNodes[tmpPassageNodeA.MirrorNum, tmpPassageNodeA.Num]; tmpNodeB = PassageNodePathNodes[tmpPassageNodeB.MirrorNum, tmpPassageNodeB.Num]; NewConnection = tmpNodeA.CreateConnection(tmpNodeB, GetNodePosDist(tmpNodeA, tmpNodeB)); } PassageNodeNetwork.Network.FindCalc(); for ( E = 0; E <= PassageNodeCount - 1; E++ ) { UpdateNetworkConnectednessArgs.PassageNodeUpdated[E] = false; } if ( PossibleRamps[BestNum].PassageNodeA.MirrorNum == 0 ) { UpdateNetworkConnectedness(UpdateNetworkConnectednessArgs, PossibleRamps[BestNum].PassageNodeA); } else if ( PossibleRamps[BestNum].PassageNodeB.MirrorNum == 0 ) { UpdateNetworkConnectedness(UpdateNetworkConnectednessArgs, PossibleRamps[BestNum].PassageNodeB); } else { ReturnResult.ProblemAdd("Error: Initial ramp not in area 0."); goto Finish; } } else { break; } } while ( true ); PathfinderNetwork.sFloodProximityArgs FloodArgs = new PathfinderNetwork.sFloodProximityArgs(); FloodArgs.StartNode = PassageNodeNetwork.PassageNodePathNodes[0, 0]; FloodArgs.NodeValues = PassageNodeNetwork.Network.NetworkLargeArrays.Nodes_ValuesA; for ( A = 0; A <= PassageNodeCount - 1; A++ ) { for ( B = 0; B <= SymmetryBlockCount - 1; B++ ) { FloodArgs.NodeValues[PassageNodeNetwork.PassageNodePathNodes[B, A].Layer_NodeNum] = float.MaxValue; } } PassageNodeNetwork.Network.FloodProximity(FloodArgs); for ( A = 0; A <= PassageNodeCount - 1; A++ ) { for ( B = 0; B <= SymmetryBlockCount - 1; B++ ) { if ( !PassageNodes[B, A].IsWater ) { if ( FloodArgs.NodeValues[PassageNodeNetwork.PassageNodePathNodes[B, A].Layer_NodeNum] == float.MaxValue ) { ReturnResult.ProblemAdd("Land is unreachable. Reduce variation or retry."); goto Finish; } } } } Finish: PassageNodeNetwork.Network.Deallocate(); return ReturnResult; }