private void UpdateNetworkConnectedness(clsUpdateNetworkConnectednessArgs Args, clsPassageNode PassageNode) { clsUpdateNodeConnectednessArgs args = new clsUpdateNodeConnectednessArgs(); Args.PassageNodeUpdated[PassageNode.Num] = true; int num4 = PassageNode.ConnectionCount - 1; for (int i = 0; i <= num4; i++) { clsConnection connection = PassageNode.Connections[i].Connection; if (!(((connection.PassageNodeA.IsOnBorder | connection.PassageNodeB.IsOnBorder) | connection.PassageNodeA.IsWater) | connection.PassageNodeB.IsWater) & (connection.IsRamp | (connection.PassageNodeA.Level == connection.PassageNodeB.Level))) { clsPassageNode other = PassageNode.Connections[i].GetOther(); if (!Args.PassageNodeUpdated[other.Num] & (other.MirrorNum == 0)) { int num5 = this.PassageNodeCount - 1; for (int j = 0; j <= num5; j++) { int num6 = Args.SymmetryBlockCount - 1; for (int k = 0; k <= num6; k++) { Args.Args.PassageNodeVisited[k, j] = false; } } args.OriginalNode = PassageNode; args.Args = Args.Args; this.UpdateNodeConnectedness(args, PassageNode); } } } }
private bool PassageNodeHasRamp(clsPassageNode PassageNode) { int num2 = PassageNode.ConnectionCount - 1; for (int i = 0; i <= num2; i++) { if (PassageNode.Connections[i].Connection.IsRamp) { return true; } } return false; }
private void PassageNodesMinLevelSet(clsPassageNode PassageNode, clsPassageNodeLevels PassageNodesMinLevel, int Level, int LevelChange) { if (Level > PassageNodesMinLevel.Nodes[PassageNode.Num]) { PassageNodesMinLevel.Nodes[PassageNode.Num] = Level; int num2 = PassageNode.ConnectionCount - 1; for (int i = 0; i <= num2; i++) { clsPassageNode other = PassageNode.Connections[i].GetOther(); if (PassageNode.IsNearBorder | other.IsNearBorder) { this.PassageNodesMinLevelSet(other, PassageNodesMinLevel, Level - 1, LevelChange); } else { this.PassageNodesMinLevelSet(other, PassageNodesMinLevel, Level - LevelChange, LevelChange); } } } }
private bool CheckRampNodeRampAngles(clsPassageNode RampPassageNode, clsPassageNode OtherRampPassageNode, double RampAwayAngle, double MinSpacingAngle, double MinSpacingAngle2) { int num4 = RampPassageNode.ConnectionCount - 1; for (int i = 0; i <= num4; i++) { if (RampPassageNode.Connections[i].Connection.IsRamp) { modMath.sXY_int _int; clsPassageNode other = RampPassageNode.Connections[i].GetOther(); _int.X = other.Pos.X - RampPassageNode.Pos.X; _int.Y = other.Pos.Y - RampPassageNode.Pos.Y; double num3 = Math.Abs(modMath.AngleClamp(RampAwayAngle - _int.ToDoubles().GetAngle())); int num2 = Math.Abs((int) (other.Level - OtherRampPassageNode.Level)); if (num2 < 2) { if (num2 != 0) { Debugger.Break(); return false; } if (num3 < MinSpacingAngle) { return false; } } else if (num3 < MinSpacingAngle2) { return false; } } } return true; }
private bool MakePassageNodes(modMath.sXY_int Pos, bool IsOnBorder) { int num; modMath.sXY_int _int; modMath.sXY_int _int3; modMath.sXY_int[] _intArray = new modMath.sXY_int[4]; _int3.X = (int) Math.Round((double) (((double) (this.TileSize.X * 0x80)) / ((double) this.SymmetryBlockCountXY.X))); _int3.Y = (int) Math.Round((double) (((double) (this.TileSize.Y * 0x80)) / ((double) this.SymmetryBlockCountXY.Y))); _int.X = _int3.X - 1; _int.Y = _int3.Y - 1; int num3 = this.SymmetryBlockCount - 1; for (num = 0; num <= num3; num++) { modMath.sXY_int _int2 = TileOrientation.GetRotatedPos(this.SymmetryBlocks[num].Orientation, Pos, _int); _intArray[num].X = (this.SymmetryBlocks[num].XYNum.X * _int3.X) + _int2.X; _intArray[num].Y = (this.SymmetryBlocks[num].XYNum.Y * _int3.Y) + _int2.Y; int num4 = num - 1; for (int i = 0; i <= num4; i++) { modMath.sXY_int _int4 = _intArray[num] - _intArray[i]; if (_int4.ToDoubles().GetMagnitude() < ((this.NodeScale * 128f) * 2.0)) { return false; } } } int num5 = this.SymmetryBlockCount - 1; for (num = 0; num <= num5; num++) { clsPassageNode node = new clsPassageNode(); this.PassageNodes[num, this.PassageNodeCount] = node; node.Num = this.PassageNodeCount; node.MirrorNum = num; node.Pos = _intArray[num]; node.IsOnBorder = IsOnBorder; } this.PassageNodeCount++; return true; }
private bool CheckRampNodeRampAngles(clsPassageNode RampPassageNode, clsPassageNode OtherRampPassageNode, double RampAwayAngle, double MinSpacingAngle, double MinSpacingAngle2) { int ConnectionNum = 0; clsConnection tmpConnection = default(clsConnection); clsPassageNode OtherNode = default(clsPassageNode); sXY_int XY_int = new sXY_int(); double SpacingAngle = 0; int RampDifference = 0; for ( ConnectionNum = 0; ConnectionNum <= RampPassageNode.ConnectionCount - 1; ConnectionNum++ ) { tmpConnection = RampPassageNode.Connections[ConnectionNum].Connection; if ( tmpConnection.IsRamp ) { OtherNode = RampPassageNode.Connections[ConnectionNum].GetOther(); XY_int.X = OtherNode.Pos.X - RampPassageNode.Pos.X; XY_int.Y = OtherNode.Pos.Y - RampPassageNode.Pos.Y; SpacingAngle = Math.Abs(MathUtil.AngleClamp(RampAwayAngle - XY_int.ToDoubles().GetAngle())); RampDifference = Math.Abs(OtherNode.Level - OtherRampPassageNode.Level); if ( RampDifference >= 2 ) { if ( SpacingAngle < MinSpacingAngle2 ) { return false; } } else if ( RampDifference == 0 ) { if ( SpacingAngle < MinSpacingAngle ) { return false; } } else { Debugger.Break(); return false; } } } return true; }
private bool CheckRampNodeLevelAngles(clsPassageNode RampPassageNode, double RampAwayAngle, double MinSpacingAngle) { bool flag2 = this.PassageNodeHasRamp(RampPassageNode); int num3 = RampPassageNode.ConnectionCount - 1; for (int i = 0; i <= num3; i++) { clsConnection connection = RampPassageNode.Connections[i].Connection; clsPassageNode other = RampPassageNode.Connections[i].GetOther(); if (other.Level == RampPassageNode.Level) { int num2; bool flag3 = true; if (i == 0) { num2 = RampPassageNode.ConnectionCount - 1; } else { num2 = i - 1; } if (num2 != i) { if (RampPassageNode.Connections[num2].GetOther().Level == other.Level) { flag3 = false; } } else { flag3 = false; } if (i == (RampPassageNode.ConnectionCount - 1)) { num2 = 0; } else { num2 = i + 1; } if (num2 != i) { if (RampPassageNode.Connections[num2].GetOther().Level == other.Level) { flag3 = false; } } else { flag3 = false; } if (flag3) { modMath.sXY_int _int; _int.X = other.Pos.X - RampPassageNode.Pos.X; _int.Y = other.Pos.Y - RampPassageNode.Pos.Y; if (Math.Abs(modMath.AngleClamp(_int.ToDoubles().GetAngle() - RampAwayAngle)) < MinSpacingAngle) { return false; } } } } return true; }
public clsConnection(clsPassageNode NewPassageNodeA, clsPassageNode NewPassageNodeB) { clsPassageNode.sConnection NewConnection = new clsPassageNode.sConnection(); PassageNodeA = NewPassageNodeA; NewConnection.Connection = this; NewConnection.IsB = false; PassageNodeA.Connection_Add(NewConnection); PassageNodeB = NewPassageNodeB; NewConnection.Connection = this; NewConnection.IsB = true; PassageNodeB.Connection_Add(NewConnection); }
public clsConnection FindConnection(clsPassageNode PassageNode) { int A = 0; for ( A = 0; A <= ConnectionCount - 1; A++ ) { if ( Connections[A].GetOther() == PassageNode ) { return Connections[A].Connection; } } return null; }
private void UpdateNetworkConnectedness(clsUpdateNetworkConnectednessArgs Args, clsPassageNode PassageNode) { int A = 0; clsConnection tmpConnection = default(clsConnection); clsPassageNode tmpOtherNode = default(clsPassageNode); clsUpdateNodeConnectednessArgs NodeConnectednessArgs = new clsUpdateNodeConnectednessArgs(); int B = 0; int C = 0; Args.PassageNodeUpdated[PassageNode.Num] = true; for ( A = 0; A <= PassageNode.ConnectionCount - 1; A++ ) { tmpConnection = PassageNode.Connections[A].Connection; if ( !(tmpConnection.PassageNodeA.IsOnBorder || tmpConnection.PassageNodeB.IsOnBorder || tmpConnection.PassageNodeA.IsWater || tmpConnection.PassageNodeB.IsWater) && (tmpConnection.IsRamp || tmpConnection.PassageNodeA.Level == tmpConnection.PassageNodeB.Level) ) { tmpOtherNode = PassageNode.Connections[A].GetOther(); if ( !Args.PassageNodeUpdated[tmpOtherNode.Num] && tmpOtherNode.MirrorNum == 0 ) { for ( B = 0; B <= PassageNodeCount - 1; B++ ) { for ( C = 0; C <= Args.SymmetryBlockCount - 1; C++ ) { Args.Args.PassageNodeVisited[C, B] = false; } } NodeConnectednessArgs.OriginalNode = PassageNode; NodeConnectednessArgs.Args = Args.Args; UpdateNodeConnectedness(NodeConnectednessArgs, PassageNode); } } } }
private void UpdateNodeConnectedness(clsUpdateNodeConnectednessArgs Args, clsPassageNode PassageNode) { int A = 0; clsConnection tmpConnection = default(clsConnection); clsPassageNode tmpOtherNode = default(clsPassageNode); int PassableCount = 0; Args.Args.PassageNodeVisited[PassageNode.MirrorNum, PassageNode.Num] = true; for ( A = 0; A <= PassageNode.ConnectionCount - 1; A++ ) { tmpConnection = PassageNode.Connections[A].Connection; if ( !(tmpConnection.PassageNodeA.IsOnBorder || tmpConnection.PassageNodeB.IsOnBorder || tmpConnection.PassageNodeA.IsWater || tmpConnection.PassageNodeB.IsWater) && (tmpConnection.IsRamp || tmpConnection.PassageNodeA.Level == tmpConnection.PassageNodeB.Level) ) { tmpOtherNode = PassageNode.Connections[A].GetOther(); if ( !Args.Args.PassageNodeVisited[tmpOtherNode.MirrorNum, tmpOtherNode.Num] ) { UpdateNodeConnectedness(Args, tmpOtherNode); } PassableCount++; } } PathfinderNetwork.PathList[] Paths = null; PathfinderNode[] StartNodes = new PathfinderNode[1]; StartNodes[0] = Args.Args.PassageNodePathNodes[0, Args.OriginalNode.Num]; Paths = Args.Args.PassageNodePathMap.GetPath(StartNodes, Args.Args.PassageNodePathNodes[PassageNode.MirrorNum, PassageNode.Num], -1, 0); Args.Args.NodeConnectedness[Args.OriginalNode.Num] += (float)(PassableCount * Math.Pow(0.999D, Paths[0].Paths[0].Value)); }
private void PassageNodesMinLevelSet(clsPassageNode PassageNode, clsPassageNodeLevels PassageNodesMinLevel, int Level, int LevelChange) { int A = 0; clsPassageNode tmpPassageNode = default(clsPassageNode); if ( Level > PassageNodesMinLevel.Nodes[PassageNode.Num] ) { PassageNodesMinLevel.Nodes[PassageNode.Num] = Level; for ( A = 0; A <= PassageNode.ConnectionCount - 1; A++ ) { tmpPassageNode = PassageNode.Connections[A].GetOther(); if ( PassageNode.IsNearBorder || tmpPassageNode.IsNearBorder ) { PassageNodesMinLevelSet(tmpPassageNode, PassageNodesMinLevel, Level - 1, LevelChange); } else { PassageNodesMinLevelSet(tmpPassageNode, PassageNodesMinLevel, Level - LevelChange, LevelChange); } } } }
private bool PassageNodeHasRamp(clsPassageNode PassageNode) { int ConnectionNum = 0; for ( ConnectionNum = 0; ConnectionNum <= PassageNode.ConnectionCount - 1; ConnectionNum++ ) { if ( PassageNode.Connections[ConnectionNum].Connection.IsRamp ) { return true; } } return false; }
private bool MakePassageNodes(sXY_int Pos, bool IsOnBorder) { int A = 0; int B = 0; clsPassageNode tmpNode = default(clsPassageNode); sXY_int RotatedPos = new sXY_int(); sXY_int SymmetrySize = new sXY_int(); sXY_int[] Positions = new sXY_int[4]; sXY_int Limits = new sXY_int(); SymmetrySize.X = (int)(TileSize.X * App.TerrainGridSpacing / SymmetryBlockCountXY.X); SymmetrySize.Y = (int)(TileSize.Y * App.TerrainGridSpacing / SymmetryBlockCountXY.Y); Limits.X = SymmetrySize.X - 1; Limits.Y = SymmetrySize.Y - 1; for ( A = 0; A <= SymmetryBlockCount - 1; A++ ) { RotatedPos = TileUtil.GetRotatedPos(SymmetryBlocks[A].Orientation, Pos, Limits); Positions[A].X = SymmetryBlocks[A].XYNum.X * SymmetrySize.X + RotatedPos.X; Positions[A].Y = SymmetryBlocks[A].XYNum.Y * SymmetrySize.Y + RotatedPos.Y; for ( B = 0; B <= A - 1; B++ ) { if ( (Positions[A] - Positions[B]).ToDoubles().GetMagnitude() < NodeScale * App.TerrainGridSpacing * 2.0D ) { return false; } } } for ( A = 0; A <= SymmetryBlockCount - 1; A++ ) { tmpNode = new clsPassageNode(); PassageNodes[A, PassageNodeCount] = tmpNode; tmpNode.Num = PassageNodeCount; tmpNode.MirrorNum = A; tmpNode.Pos = Positions[A]; tmpNode.IsOnBorder = IsOnBorder; } PassageNodeCount++; return true; }
private void UpdateNodeConnectedness(clsUpdateNodeConnectednessArgs Args, clsPassageNode PassageNode) { int num2; Args.Args.PassageNodeVisited[PassageNode.MirrorNum, PassageNode.Num] = true; int num3 = PassageNode.ConnectionCount - 1; for (int i = 0; i <= num3; i++) { clsConnection connection = PassageNode.Connections[i].Connection; if (!(((connection.PassageNodeA.IsOnBorder | connection.PassageNodeB.IsOnBorder) | connection.PassageNodeA.IsWater) | connection.PassageNodeB.IsWater) & (connection.IsRamp | (connection.PassageNodeA.Level == connection.PassageNodeB.Level))) { clsPassageNode other = PassageNode.Connections[i].GetOther(); if (!Args.Args.PassageNodeVisited[other.MirrorNum, other.Num]) { this.UpdateNodeConnectedness(Args, other); } num2++; } } PathfinderNode[] startNodes = new PathfinderNode[] { Args.Args.PassageNodePathNodes[0, Args.OriginalNode.Num] }; PathfinderNetwork.PathList[] listArray = Args.Args.PassageNodePathMap.GetPath(startNodes, Args.Args.PassageNodePathNodes[PassageNode.MirrorNum, PassageNode.Num], -1, 0); float[] nodeConnectedness = Args.Args.NodeConnectedness; int num = Args.OriginalNode.Num; nodeConnectedness[num] += (float) (num2 * Math.Pow(0.999, (double) listArray[0].Paths[0].Value)); }
public clsResult GenerateLayout() { clsResult ReturnResult = new clsResult("Layout"); int X = 0; int Y = 0; int A = 0; int B = 0; int C = 0; int D = 0; int E = 0; int F = 0; int G = 0; int H = 0; TotalPlayerCount = TopLeftPlayerCount * SymmetryBlockCount; sXY_int SymmetrySize = new sXY_int(); SymmetrySize.X = (int)(TileSize.X * App.TerrainGridSpacing / SymmetryBlockCountXY.X); SymmetrySize.Y = (int)(TileSize.Y * App.TerrainGridSpacing / SymmetryBlockCountXY.Y); //create passage nodes int PassageRadius = (int)(128.0F * NodeScale); int MaxLikelyPassageNodeCount = 0; MaxLikelyPassageNodeCount = (int)(Math.Ceiling(Convert.ToDecimal(2.0D * TileSize.X * 128 * TileSize.Y * 128 / (Math.PI * PassageRadius * PassageRadius)))); PassageNodes = new clsPassageNode[SymmetryBlockCount, MaxLikelyPassageNodeCount]; int LoopCount = 0; int EdgeOffset = 0 * 128; bool PointIsValid; sXY_int EdgeSections = new sXY_int(); Position.XY_dbl EdgeSectionSize = default(Position.XY_dbl); sXY_int NewPointPos = new sXY_int(); if ( SymmetryBlockCountXY.X == 1 ) { EdgeSections.X = Convert.ToInt32( Conversion.Int((TileSize.X * App.TerrainGridSpacing - EdgeOffset * 2.0D) / (NodeScale * App.TerrainGridSpacing * 2.0F))); EdgeSectionSize.X = (TileSize.X * App.TerrainGridSpacing - EdgeOffset * 2.0D) / EdgeSections.X; EdgeSections.X--; } else { EdgeSections.X = (int) (Conversion.Int((TileSize.X * App.TerrainGridSpacing / SymmetryBlockCountXY.X - EdgeOffset) / (NodeScale * App.TerrainGridSpacing * 2.0F) - 0.5D)); EdgeSectionSize.X = Convert.ToDouble((TileSize.X * App.TerrainGridSpacing / SymmetryBlockCountXY.X - EdgeOffset) / (Convert.ToDouble( Conversion.Int((TileSize.X * App.TerrainGridSpacing / SymmetryBlockCountXY.X - EdgeOffset) / (NodeScale * App.TerrainGridSpacing * 2.0F) - 0.5D)) + 0.5D)); } if ( SymmetryBlockCountXY.Y == 1 ) { EdgeSections.Y = Convert.ToInt32( Conversion.Int((TileSize.Y * App.TerrainGridSpacing - EdgeOffset * 2.0D) / (NodeScale * App.TerrainGridSpacing * 2.0F))); EdgeSectionSize.Y = (TileSize.Y * App.TerrainGridSpacing - EdgeOffset * 2.0D) / EdgeSections.Y; EdgeSections.Y--; } else { EdgeSections.Y = Convert.ToInt32( Conversion.Int((TileSize.Y * App.TerrainGridSpacing / SymmetryBlockCountXY.Y - EdgeOffset) / (NodeScale * App.TerrainGridSpacing * 2.0F) - 0.5D)); EdgeSectionSize.Y = Convert.ToDouble((TileSize.Y * App.TerrainGridSpacing / SymmetryBlockCountXY.Y - EdgeOffset) / (Convert.ToDouble( Conversion.Int((TileSize.Y * App.TerrainGridSpacing / SymmetryBlockCountXY.Y - EdgeOffset) / (NodeScale * App.TerrainGridSpacing * 2.0F) - 0.5D)) + 0.5D)); } PassageNodeCount = 0; for ( Y = 0; Y <= EdgeSections.Y; Y++ ) { if ( !MakePassageNodes(new sXY_int(EdgeOffset, EdgeOffset + (int)(Y * EdgeSectionSize.Y)), true) ) { ReturnResult.ProblemAdd("Error: Bad border node."); return ReturnResult; } if ( SymmetryBlockCountXY.X == 1 ) { if ( !MakePassageNodes(new sXY_int(TileSize.X * App.TerrainGridSpacing - EdgeOffset, EdgeOffset + (int)(Y * EdgeSectionSize.Y)), true) ) { ReturnResult.ProblemAdd("Error: Bad border node."); return ReturnResult; } } } for ( X = 1; X <= EdgeSections.X; X++ ) { if ( !MakePassageNodes(new sXY_int(EdgeOffset + (int)(X * EdgeSectionSize.X), EdgeOffset), true) ) { ReturnResult.ProblemAdd("Error: Bad border node."); return ReturnResult; } if ( SymmetryBlockCountXY.Y == 1 ) { if ( !MakePassageNodes(new sXY_int(EdgeOffset + (int)(X * EdgeSectionSize.X), TileSize.Y * App.TerrainGridSpacing - EdgeOffset), true) ) { ReturnResult.ProblemAdd("Error: Bad border node."); return ReturnResult; } } } do { LoopCount = 0; do { PointIsValid = true; if ( SymmetryBlockCountXY.X == 1 ) { NewPointPos.X = (int)(EdgeOffset + Conversion.Int(VBMath.Rnd() * (SymmetrySize.X - EdgeOffset * 2 + 1))); } else { NewPointPos.X = EdgeOffset + (int)(Conversion.Int(VBMath.Rnd() * (SymmetrySize.X - EdgeOffset + 1))); } if ( SymmetryBlockCountXY.Y == 1 ) { NewPointPos.Y = EdgeOffset + (int)(Conversion.Int(VBMath.Rnd() * (SymmetrySize.Y - EdgeOffset * 2 + 1))); } else { NewPointPos.Y = EdgeOffset + Convert.ToInt32(Conversion.Int(VBMath.Rnd() * (SymmetrySize.Y - EdgeOffset + 1))); } for ( A = 0; A <= PassageNodeCount - 1; A++ ) { for ( B = 0; B <= SymmetryBlockCount - 1; B++ ) { if ( (PassageNodes[B, A].Pos - NewPointPos).ToDoubles().GetMagnitude() < PassageRadius * 2 ) { goto PointTooClose; } } } PointTooClose: if ( A == PassageNodeCount ) { if ( MakePassageNodes(NewPointPos, false) ) { break; } } LoopCount++; if ( LoopCount >= (int)(64.0F * TileSize.X * TileSize.Y / (NodeScale * NodeScale)) ) { goto PointMakingFinished; } } while ( true ); } while ( true ); PointMakingFinished: PassageNodes = (clsPassageNode[,]) Utils.CopyArray((Array)PassageNodes, new clsPassageNode[SymmetryBlockCount, PassageNodeCount]); //connect until all are connected without intersecting MathUtil.sIntersectPos IntersectPos = new MathUtil.sIntersectPos(); int MaxConDist2 = PassageRadius * 2 * 4; MaxConDist2 *= MaxConDist2; clsNearest NearestA = default(clsNearest); Nearests = new clsNearest[PassageNodeCount * 64]; clsPassageNode tmpPassageNodeA = default(clsPassageNode); clsPassageNode tmpPassageNodeB = default(clsPassageNode); clsTestNearestArgs NearestArgs = new clsTestNearestArgs(); int MinConDist = (int)(NodeScale * 1.25F * 128.0F); NearestArgs.MaxConDist2 = MaxConDist2; NearestArgs.MinConDist = MinConDist; for ( A = 0; A <= PassageNodeCount - 1; A++ ) { NearestArgs.PassageNodeA = PassageNodes[0, A]; for ( B = A; B <= PassageNodeCount - 1; B++ ) { for ( C = 0; C <= SymmetryBlockCount - 1; C++ ) { NearestArgs.PassageNodeB = PassageNodes[C, B]; if ( NearestArgs.PassageNodeA != NearestArgs.PassageNodeB ) { TestNearest(NearestArgs); } } } } clsNearest NearestB = default(clsNearest); bool Flag = default(bool); for ( G = 0; G <= NearestCount - 1; G++ ) { NearestA = Nearests[G]; for ( A = 0; A <= NearestA.NodeCount - 1; A++ ) { tmpPassageNodeA = NearestA.NodeA[A]; tmpPassageNodeB = NearestA.NodeB[A]; for ( H = 0; H <= NearestCount - 1; H++ ) { NearestB = Nearests[H]; if ( NearestB != NearestA ) { if ( NearestB.Dist2 < NearestA.Dist2 ) { Flag = true; } else if ( NearestB.Dist2 == NearestA.Dist2 ) { Flag = NearestA.Num > NearestB.Num; } else { Flag = false; } if ( Flag ) { for ( B = 0; B <= NearestB.NodeCount - 1; B++ ) { if ( !(tmpPassageNodeA == NearestB.NodeA[B] || tmpPassageNodeA == NearestB.NodeB[B] || tmpPassageNodeB == NearestB.NodeA[B] || tmpPassageNodeB == NearestB.NodeB[B]) ) { IntersectPos = MathUtil.GetLinesIntersectBetween(tmpPassageNodeA.Pos, tmpPassageNodeB.Pos, NearestB.NodeA[B].Pos, NearestB.NodeB[B].Pos); if ( IntersectPos.Exists ) { break; } } } if ( B < NearestB.NodeCount ) { NearestA.BlockedCount++; NearestB.BlockedNearests[NearestB.BlockedNearestCount] = NearestA; NearestB.BlockedNearestCount++; } } } } } } int ChangeCount = 0; Connections = new clsConnection[PassageNodeCount * 16]; do { //create valid connections ChangeCount = 0; G = 0; while ( G < NearestCount ) { NearestA = Nearests[G]; Flag = true; if ( NearestA.BlockedCount == 0 && Flag ) { F = ConnectionCount; for ( D = 0; D <= NearestA.NodeCount - 1; D++ ) { Connections[ConnectionCount] = new clsConnection(NearestA.NodeA[D], NearestA.NodeB[D]); ConnectionCount++; } for ( D = 0; D <= NearestA.NodeCount - 1; D++ ) { A = F + D; Connections[A].ReflectionCount = NearestA.NodeCount - 1; Connections[A].Reflections = new clsConnection[Connections[A].ReflectionCount]; B = 0; for ( E = 0; E <= NearestA.NodeCount - 1; E++ ) { if ( E != D ) { Connections[A].Reflections[B] = Connections[F + E]; B++; } } } for ( C = 0; C <= NearestA.BlockedNearestCount - 1; C++ ) { NearestA.BlockedNearests[C].Invalid = true; } NearestCount--; H = NearestA.Num; NearestA.Num = -1; if ( H != NearestCount ) { Nearests[H] = Nearests[NearestCount]; Nearests[H].Num = H; } ChangeCount++; } else { if ( !Flag ) { NearestA.Invalid = true; } G++; } } //remove blocked ones and their blocking effect G = 0; while ( G < NearestCount ) { NearestA = Nearests[G]; if ( NearestA.Invalid ) { NearestA.Num = -1; for ( D = 0; D <= NearestA.BlockedNearestCount - 1; D++ ) { NearestA.BlockedNearests[D].BlockedCount--; } NearestCount--; if ( G != NearestCount ) { Nearests[G] = Nearests[NearestCount]; Nearests[G].Num = G; } } else { G++; } } } while ( ChangeCount > 0 ); //put connections in order of angle for ( A = 0; A <= PassageNodeCount - 1; A++ ) { for ( B = 0; B <= SymmetryBlockCount - 1; B++ ) { PassageNodes[B, A].ReorderConnections(); PassageNodes[B, A].CalcIsNearBorder(); } } //get nodes in random order clsPassageNode[] PassageNodeListOrder = new clsPassageNode[PassageNodeCount]; int PassageNodeListOrderCount = 0; clsPassageNode[] PassageNodeOrder = new clsPassageNode[PassageNodeCount]; for ( A = 0; A <= PassageNodeCount - 1; A++ ) { PassageNodeListOrder[PassageNodeListOrderCount] = PassageNodes[0, A]; PassageNodeListOrderCount++; } B = 0; while ( PassageNodeListOrderCount > 0 ) { A = (int)(Conversion.Int(VBMath.Rnd() * PassageNodeListOrderCount)); PassageNodeOrder[B] = PassageNodeListOrder[A]; B++; PassageNodeListOrderCount--; PassageNodeListOrder[A] = PassageNodeListOrder[PassageNodeListOrderCount]; } //designate height levels LevelHeight = 255.0F / (LevelCount - 1); int BestNum = 0; double Dist = 0; clsPassageNodeHeightLevelArgs HeightsArgs = new clsPassageNodeHeightLevelArgs(); HeightsArgs.PassageNodesMinLevel.Nodes = new int[PassageNodeCount]; HeightsArgs.PassageNodesMaxLevel.Nodes = new int[PassageNodeCount]; HeightsArgs.MapLevelCount = new int[LevelCount]; sXY_int RotatedPos = new sXY_int(); for ( A = 0; A <= PassageNodeCount - 1; A++ ) { HeightsArgs.PassageNodesMinLevel.Nodes[A] = 0; HeightsArgs.PassageNodesMaxLevel.Nodes[A] = LevelCount - 1; } //create bases double[] BestDists = new double[BaseFlatArea]; clsPassageNode[] BestNodes = new clsPassageNode[BaseFlatArea]; int[] BestNodesReflectionNums = new int[BaseFlatArea]; int BestDistCount = 0; PlayerBases = new sPlayerBase[TotalPlayerCount]; for ( B = 0; B <= TopLeftPlayerCount - 1; B++ ) { BestDistCount = 0; for ( A = 0; A <= PassageNodeCount - 1; A++ ) { for ( E = 0; E <= SymmetryBlockCount - 1; E++ ) { tmpPassageNodeA = PassageNodes[E, A]; if ( !tmpPassageNodeA.IsOnBorder ) { Dist = (tmpPassageNodeA.Pos - PlayerBasePos[B]).ToDoubles().GetMagnitude(); for ( C = BestDistCount - 1; C >= 0; C-- ) { if ( Dist > BestDists[C] ) { break; } } C++; for ( D = Math.Min(BestDistCount - 1, BaseFlatArea - 2); D >= C; D-- ) { BestDists[D + 1] = BestDists[D]; BestNodes[D + 1] = BestNodes[D]; } if ( C < BaseFlatArea ) { BestDists[C] = Dist; BestNodes[C] = tmpPassageNodeA; BestDistCount = Math.Max(BestDistCount, C + 1); } } } } if ( BaseLevel < 0 ) { D = Convert.ToInt32(Conversion.Int(VBMath.Rnd() * LevelCount)); } else { D = BaseLevel; } HeightsArgs.MapLevelCount[D] += BestDistCount; for ( A = 0; A <= BestDistCount - 1; A++ ) { if ( BestNodes[A].MirrorNum == 0 ) { BestNodesReflectionNums[A] = -1; } else { for ( C = 0; C <= ((int)(SymmetryBlockCount / 2.0D)) - 1; C++ ) { if ( SymmetryBlocks[0].ReflectToNum[C] == BestNodes[A].MirrorNum ) { break; } } BestNodesReflectionNums[A] = C; } } for ( A = 0; A <= SymmetryBlockCount - 1; A++ ) { E = A * TopLeftPlayerCount + B; PlayerBases[E].NodeCount = BestDistCount; PlayerBases[E].Nodes = new clsPassageNode[PlayerBases[E].NodeCount]; for ( C = 0; C <= BestDistCount - 1; C++ ) { if ( BestNodesReflectionNums[C] < 0 ) { PlayerBases[E].Nodes[C] = PassageNodes[A, BestNodes[C].Num]; } else { PlayerBases[E].Nodes[C] = PassageNodes[SymmetryBlocks[A].ReflectToNum[BestNodesReflectionNums[C]], BestNodes[C].Num]; } PlayerBases[E].Nodes[C].PlayerBaseNum = E; PlayerBases[E].Nodes[C].Level = D; PassageNodesMinLevelSet(PlayerBases[E].Nodes[C], HeightsArgs.PassageNodesMinLevel, D, MaxLevelTransition); PassageNodesMaxLevelSet(PlayerBases[E].Nodes[C], HeightsArgs.PassageNodesMaxLevel, D, MaxLevelTransition); } //PlayerBases(E).CalcPos() RotatedPos = TileUtil.GetRotatedPos(SymmetryBlocks[A].Orientation, PlayerBasePos[B], new sXY_int(SymmetrySize.X - 1, SymmetrySize.Y - 1)); PlayerBases[E].Pos.X = SymmetryBlocks[A].XYNum.X * SymmetrySize.X + RotatedPos.X; PlayerBases[E].Pos.Y = SymmetryBlocks[A].XYNum.Y * SymmetrySize.Y + RotatedPos.Y; } } int WaterCount = 0; bool CanDoFlatsAroundWater = default(bool); int TotalWater = 0; int WaterSpawns = 0; for ( A = 0; A <= PassageNodeCount - 1; A++ ) { tmpPassageNodeA = PassageNodeOrder[A]; if ( tmpPassageNodeA.Level < 0 && !tmpPassageNodeA.IsOnBorder ) { WaterCount = 0; for ( B = 0; B <= tmpPassageNodeA.ConnectionCount - 1; B++ ) { tmpPassageNodeB = tmpPassageNodeA.Connections[B].GetOther(); if ( tmpPassageNodeB.IsWater ) { WaterCount++; } } CanDoFlatsAroundWater = true; for ( B = 0; B <= tmpPassageNodeA.ConnectionCount - 1; B++ ) { if ( HeightsArgs.PassageNodesMinLevel.Nodes[tmpPassageNodeA.Connections[B].GetOther().Num] > 0 ) { CanDoFlatsAroundWater = false; } } if ( CanDoFlatsAroundWater && ((WaterCount == 0 & WaterSpawns < WaterSpawnQuantity) || (WaterCount == 1 & TotalWaterQuantity - TotalWater > WaterSpawnQuantity - WaterSpawns)) && HeightsArgs.PassageNodesMinLevel.Nodes[tmpPassageNodeA.Num] == 0 & TotalWater < TotalWaterQuantity ) { if ( WaterCount == 0 ) { WaterSpawns++; } TotalWater++; C = tmpPassageNodeA.Num; for ( D = 0; D <= SymmetryBlockCount - 1; D++ ) { PassageNodes[D, C].IsWater = true; PassageNodes[D, C].Level = 0; } PassageNodesMinLevelSet(tmpPassageNodeA, HeightsArgs.PassageNodesMinLevel, 0, MaxLevelTransition); PassageNodesMaxLevelSet(tmpPassageNodeA, HeightsArgs.PassageNodesMaxLevel, 0, MaxLevelTransition); HeightsArgs.MapLevelCount[0]++; for ( B = 0; B <= tmpPassageNodeA.ConnectionCount - 1; B++ ) { tmpPassageNodeB = tmpPassageNodeA.Connections[B].GetOther(); PassageNodesMinLevelSet(tmpPassageNodeB, HeightsArgs.PassageNodesMinLevel, 0, MaxLevelTransition); PassageNodesMaxLevelSet(tmpPassageNodeB, HeightsArgs.PassageNodesMaxLevel, 0, MaxLevelTransition); } } } } clsPassageNode tmpPassageNodeC = default(clsPassageNode); App.sResult Result = new App.sResult(); HeightsArgs.FlatsCutoff = 1; HeightsArgs.PassagesCutoff = 1; HeightsArgs.VariationCutoff = 1; HeightsArgs.ActionTotal = 1; for ( A = 0; A <= PassageNodeCount - 1; A++ ) { tmpPassageNodeA = PassageNodeOrder[A]; if ( tmpPassageNodeA.Level < 0 && !tmpPassageNodeA.IsOnBorder && tmpPassageNodeA.IsNearBorder ) { HeightsArgs.PassageNode = tmpPassageNodeA; Result = PassageNodeHeightLevel(HeightsArgs); if ( !Result.Success ) { ReturnResult.ProblemAdd(Result.Problem); return ReturnResult; } } } HeightsArgs.FlatsCutoff = FlatsChance; HeightsArgs.PassagesCutoff = HeightsArgs.FlatsCutoff + PassagesChance; HeightsArgs.VariationCutoff = HeightsArgs.PassagesCutoff + VariationChance; HeightsArgs.ActionTotal = HeightsArgs.VariationCutoff; if ( HeightsArgs.ActionTotal <= 0 ) { ReturnResult.ProblemAdd("All height level behaviors are zero"); return ReturnResult; } for ( A = 0; A <= PassageNodeCount - 1; A++ ) { tmpPassageNodeA = PassageNodeOrder[A]; if ( tmpPassageNodeA.Level < 0 && !tmpPassageNodeA.IsOnBorder ) { HeightsArgs.PassageNode = tmpPassageNodeA; Result = PassageNodeHeightLevel(HeightsArgs); if ( !Result.Success ) { ReturnResult.ProblemAdd(Result.Problem); return ReturnResult; } } } //set edge points to the level of their neighbour for ( A = 0; A <= PassageNodeCount - 1; A++ ) { tmpPassageNodeA = PassageNodes[0, A]; if ( tmpPassageNodeA.IsOnBorder ) { if ( tmpPassageNodeA.Level >= 0 ) { ReturnResult.ProblemAdd("Error: Border has had its height set."); return ReturnResult; } //If tmpPassageNodeA.ConnectionCount <> 1 Then // ReturnResult.Problem = "Error: Border has incorrect connections." // Exit Function //End If tmpPassageNodeC = null; CanDoFlatsAroundWater = true; for ( B = 0; B <= tmpPassageNodeA.ConnectionCount - 1; B++ ) { tmpPassageNodeB = tmpPassageNodeA.Connections[B].GetOther(); if ( tmpPassageNodeB.Level >= 0 && !tmpPassageNodeB.IsOnBorder ) { if ( HeightsArgs.PassageNodesMinLevel.Nodes[tmpPassageNodeA.Num] <= tmpPassageNodeB.Level && HeightsArgs.PassageNodesMaxLevel.Nodes[tmpPassageNodeA.Num] >= tmpPassageNodeB.Level ) { if ( tmpPassageNodeC == null ) { tmpPassageNodeC = tmpPassageNodeB; } } } if ( HeightsArgs.PassageNodesMinLevel.Nodes[tmpPassageNodeB.Num] > 0 ) { CanDoFlatsAroundWater = false; } } //If tmpPassageNodeC Is Nothing Then // ReturnResult.Problem_Add("Error: No connection for border node") // Return ReturnResult //End If if ( tmpPassageNodeC != null ) { BestNum = tmpPassageNodeC.Level; PassageNodesMinLevelSet(tmpPassageNodeA, HeightsArgs.PassageNodesMinLevel, BestNum, MaxLevelTransition); PassageNodesMaxLevelSet(tmpPassageNodeA, HeightsArgs.PassageNodesMaxLevel, BestNum, MaxLevelTransition); for ( D = 0; D <= SymmetryBlockCount - 1; D++ ) { PassageNodes[D, A].IsWater = tmpPassageNodeC.IsWater && CanDoFlatsAroundWater; PassageNodes[D, A].Level = BestNum; } if ( tmpPassageNodeA.IsWater ) { for ( B = 0; B <= tmpPassageNodeA.ConnectionCount - 1; B++ ) { tmpPassageNodeB = tmpPassageNodeA.Connections[B].GetOther(); PassageNodesMinLevelSet(tmpPassageNodeB, HeightsArgs.PassageNodesMinLevel, tmpPassageNodeA.Level, MaxLevelTransition); PassageNodesMaxLevelSet(tmpPassageNodeB, HeightsArgs.PassageNodesMaxLevel, tmpPassageNodeA.Level, MaxLevelTransition); } } } } else if ( tmpPassageNodeA.Level < 0 ) { ReturnResult.ProblemAdd("Error: Node height not set"); return ReturnResult; } } //set level of edge points only connected to another border point for ( A = 0; A <= PassageNodeCount - 1; A++ ) { tmpPassageNodeA = PassageNodes[0, A]; if ( tmpPassageNodeA.IsOnBorder && tmpPassageNodeA.Level < 0 ) { tmpPassageNodeC = null; CanDoFlatsAroundWater = true; for ( B = 0; B <= tmpPassageNodeA.ConnectionCount - 1; B++ ) { tmpPassageNodeB = tmpPassageNodeA.Connections[B].GetOther(); if ( tmpPassageNodeB.Level >= 0 ) { if ( HeightsArgs.PassageNodesMinLevel.Nodes[tmpPassageNodeA.Num] <= tmpPassageNodeB.Level && HeightsArgs.PassageNodesMaxLevel.Nodes[tmpPassageNodeA.Num] >= tmpPassageNodeB.Level ) { if ( tmpPassageNodeC == null ) { tmpPassageNodeC = tmpPassageNodeB; } } } if ( HeightsArgs.PassageNodesMinLevel.Nodes[tmpPassageNodeB.Num] > 0 ) { CanDoFlatsAroundWater = false; } } if ( tmpPassageNodeC == null ) { ReturnResult.ProblemAdd("Error: No connection for border node"); return ReturnResult; } BestNum = tmpPassageNodeC.Level; PassageNodesMinLevelSet(tmpPassageNodeA, HeightsArgs.PassageNodesMinLevel, BestNum, MaxLevelTransition); PassageNodesMaxLevelSet(tmpPassageNodeA, HeightsArgs.PassageNodesMaxLevel, BestNum, MaxLevelTransition); for ( D = 0; D <= SymmetryBlockCount - 1; D++ ) { PassageNodes[D, A].IsWater = tmpPassageNodeC.IsWater && CanDoFlatsAroundWater; PassageNodes[D, A].Level = BestNum; } if ( tmpPassageNodeA.IsWater ) { for ( B = 0; B <= tmpPassageNodeA.ConnectionCount - 1; B++ ) { tmpPassageNodeB = tmpPassageNodeA.Connections[B].GetOther(); PassageNodesMinLevelSet(tmpPassageNodeB, HeightsArgs.PassageNodesMinLevel, tmpPassageNodeA.Level, MaxLevelTransition); PassageNodesMaxLevelSet(tmpPassageNodeB, HeightsArgs.PassageNodesMaxLevel, tmpPassageNodeA.Level, MaxLevelTransition); } } } } RampBase = 1.0D; MaxDisconnectionDist = 99999.0F; clsResult RampResult = GenerateRamps(); ReturnResult.Add(RampResult); return ReturnResult; }
public clsResult GenerateLayout() { int num; int num2; int level; int num5; bool flag; int num6; int baseLevel; int num9; modMath.sXY_int _int; Position.XY_dbl _dbl; bool flag2; int num12; int num13; int num14; clsNearest nearest; modProgram.sResult result3; modMath.sXY_int _int4; clsPassageNode node; clsPassageNode other; clsPassageNode node3; modMath.sXY_int _int5; int num41; int[] mapLevelCount; clsResult result4 = new clsResult("Layout"); this.TotalPlayerCount = this.TopLeftPlayerCount * this.SymmetryBlockCount; _int4.X = (int) Math.Round((double) (((double) (this.TileSize.X * 0x80)) / ((double) this.SymmetryBlockCountXY.X))); _int4.Y = (int) Math.Round((double) (((double) (this.TileSize.Y * 0x80)) / ((double) this.SymmetryBlockCountXY.Y))); int num19 = (int) Math.Round((double) (128f * this.NodeScale)); int num16 = (int) Math.Round(Math.Ceiling((double) (((((2.0 * this.TileSize.X) * 128.0) * this.TileSize.Y) * 128.0) / ((3.1415926535897931 * num19) * num19)))); this.PassageNodes = new clsPassageNode[(this.SymmetryBlockCount - 1) + 1, (num16 - 1) + 1]; int x = 0; if (this.SymmetryBlockCountXY.X == 1) { _int.X = (int) Math.Round(((double) (((this.TileSize.X * 0x80) - (x * 2.0)) / ((double) ((this.NodeScale * 128f) * 2f))))); _dbl.X = ((this.TileSize.X * 0x80) - (x * 2.0)) / ((double) _int.X); _int.X--; } else { _int.X = (int) Math.Round(((double) ((((((double) (this.TileSize.X * 0x80)) / ((double) this.SymmetryBlockCountXY.X)) - x) / ((double) ((this.NodeScale * 128f) * 2f))) - 0.5))); _dbl.X = ((((double) (this.TileSize.X * 0x80)) / ((double) this.SymmetryBlockCountXY.X)) - x) / (((double) ((((((double) (this.TileSize.X * 0x80)) / ((double) this.SymmetryBlockCountXY.X)) - x) / ((double) ((this.NodeScale * 128f) * 2f))) - 0.5)) + 0.5); } if (this.SymmetryBlockCountXY.Y == 1) { _int.Y = (int) Math.Round(((double) (((this.TileSize.Y * 0x80) - (x * 2.0)) / ((double) ((this.NodeScale * 128f) * 2f))))); _dbl.Y = ((this.TileSize.Y * 0x80) - (x * 2.0)) / ((double) _int.Y); _int.Y--; } else { _int.Y = (int) Math.Round(((double) ((((((double) (this.TileSize.Y * 0x80)) / ((double) this.SymmetryBlockCountXY.Y)) - x) / ((double) ((this.NodeScale * 128f) * 2f))) - 0.5))); _dbl.Y = ((((double) (this.TileSize.Y * 0x80)) / ((double) this.SymmetryBlockCountXY.Y)) - x) / (((double) ((((((double) (this.TileSize.Y * 0x80)) / ((double) this.SymmetryBlockCountXY.Y)) - x) / ((double) ((this.NodeScale * 128f) * 2f))) - 0.5)) + 0.5); } this.PassageNodeCount = 0; int y = _int.Y; for (int i = 0; i <= y; i++) { _int5 = new modMath.sXY_int(x, x + ((int) Math.Round((double) (i * _dbl.Y)))); if (!this.MakePassageNodes(_int5, true)) { result4.ProblemAdd("Error: Bad border node."); return result4; } if (this.SymmetryBlockCountXY.X == 1) { _int5 = new modMath.sXY_int((this.TileSize.X * 0x80) - x, x + ((int) Math.Round((double) (i * _dbl.Y)))); if (!this.MakePassageNodes(_int5, true)) { result4.ProblemAdd("Error: Bad border node."); return result4; } } } int num26 = _int.X; for (int j = 1; j <= num26; j++) { _int5 = new modMath.sXY_int(x + ((int) Math.Round((double) (j * _dbl.X))), x); if (!this.MakePassageNodes(_int5, true)) { result4.ProblemAdd("Error: Bad border node."); return result4; } if (this.SymmetryBlockCountXY.Y == 1) { _int5 = new modMath.sXY_int(x + ((int) Math.Round((double) (j * _dbl.X))), (this.TileSize.Y * 0x80) - x); if (!this.MakePassageNodes(_int5, true)) { result4.ProblemAdd("Error: Bad border node."); return result4; } } } Label_0538: num14 = 0; do { modMath.sXY_int _int2; if (this.SymmetryBlockCountXY.X == 1) { _int2.X = x + ((int) Math.Round((double) ((float) (App.Random.Next() * ((_int4.X - (x * 2)) + 1))))); } else { _int2.X = x + ((int) Math.Round((double) ((float) (App.Random.Next() * ((_int4.X - x) + 1))))); } if (this.SymmetryBlockCountXY.Y == 1) { _int2.Y = x + ((int) Math.Round((double) ((float) (App.Random.Next() * ((_int4.Y - (x * 2)) + 1))))); } else { _int2.Y = x + ((int) Math.Round((double) ((float) (App.Random.Next() * ((_int4.Y - x) + 1))))); } int num27 = this.PassageNodeCount - 1; num = 0; while (num <= num27) { int num28 = this.SymmetryBlockCount - 1; num2 = 0; while (num2 <= num28) { _int5 = this.PassageNodes[num2, num].Pos - _int2; if (_int5.ToDoubles().GetMagnitude() < (num19 * 2)) { break; } num2++; } num++; } if ((num == this.PassageNodeCount) && this.MakePassageNodes(_int2, false)) { goto Label_0538; } num14++; } while (num14 < ((int) Math.Round((double) (((64f * this.TileSize.X) * this.TileSize.Y) / (this.NodeScale * this.NodeScale))))); this.PassageNodes = (clsPassageNode[,]) Utils.CopyArray((Array) this.PassageNodes, new clsPassageNode[(this.SymmetryBlockCount - 1) + 1, (this.PassageNodeCount - 1) + 1]); int num15 = (num19 * 2) * 4; num15 *= num15; this.Nearests = new clsNearest[((this.PassageNodeCount * 0x40) - 1) + 1]; clsTestNearestArgs args2 = new clsTestNearestArgs(); int num17 = (int) Math.Round((double) ((this.NodeScale * 1.25f) * 128f)); args2.MaxConDist2 = num15; args2.MinConDist = num17; int num29 = this.PassageNodeCount - 1; num = 0; while (num <= num29) { args2.PassageNodeA = this.PassageNodes[0, num]; int num30 = this.PassageNodeCount - 1; num2 = num; while (num2 <= num30) { int num31 = this.SymmetryBlockCount - 1; num5 = 0; while (num5 <= num31) { args2.PassageNodeB = this.PassageNodes[num5, num2]; if (args2.PassageNodeA != args2.PassageNodeB) { this.TestNearest(args2); } num5++; } num2++; } num++; } int num32 = this.NearestCount - 1; for (num12 = 0; num12 <= num32; num12++) { nearest = this.Nearests[num12]; int num33 = nearest.NodeCount - 1; num = 0; while (num <= num33) { node = nearest.NodeA[num]; other = nearest.NodeB[num]; int num34 = this.NearestCount - 1; num13 = 0; while (num13 <= num34) { clsNearest nearest2 = this.Nearests[num13]; if (nearest2 != nearest) { if (nearest2.Dist2 < nearest.Dist2) { flag2 = true; } else if (nearest2.Dist2 == nearest.Dist2) { flag2 = nearest.Num > nearest2.Num; } else { flag2 = false; } if (flag2) { int num35 = nearest2.NodeCount - 1; num2 = 0; while (num2 <= num35) { if (!((((node == nearest2.NodeA[num2]) | (node == nearest2.NodeB[num2])) | (other == nearest2.NodeA[num2])) | (other == nearest2.NodeB[num2])) && modMath.GetLinesIntersectBetween(node.Pos, other.Pos, nearest2.NodeA[num2].Pos, nearest2.NodeB[num2].Pos).Exists) { break; } num2++; } if (num2 < nearest2.NodeCount) { clsNearest nearest3 = nearest; nearest3.BlockedCount++; clsNearest nearest4 = nearest2; nearest4.BlockedNearests[nearest4.BlockedNearestCount] = nearest; nearest3 = nearest4; nearest3.BlockedNearestCount++; nearest4 = null; } } } num13++; } num++; } } this.Connections = new clsConnection[((this.PassageNodeCount * 0x10) - 1) + 1]; do { num6 = 0; num12 = 0; while (num12 < this.NearestCount) { nearest = this.Nearests[num12]; flag2 = true; if ((nearest.BlockedCount == 0) & flag2) { int connectionCount = this.ConnectionCount; int num36 = nearest.NodeCount - 1; baseLevel = 0; while (baseLevel <= num36) { this.Connections[this.ConnectionCount] = new clsConnection(nearest.NodeA[baseLevel], nearest.NodeB[baseLevel]); this.ConnectionCount++; baseLevel++; } int num37 = nearest.NodeCount - 1; baseLevel = 0; while (baseLevel <= num37) { num = connectionCount + baseLevel; this.Connections[num].ReflectionCount = nearest.NodeCount - 1; this.Connections[num].Reflections = new clsConnection[(this.Connections[num].ReflectionCount - 1) + 1]; num2 = 0; int num38 = nearest.NodeCount - 1; num9 = 0; while (num9 <= num38) { if (num9 != baseLevel) { this.Connections[num].Reflections[num2] = this.Connections[connectionCount + num9]; num2++; } num9++; } baseLevel++; } int num39 = nearest.BlockedNearestCount - 1; num5 = 0; while (num5 <= num39) { nearest.BlockedNearests[num5].Invalid = true; num5++; } this.NearestCount--; num13 = nearest.Num; nearest.Num = -1; if (num13 != this.NearestCount) { this.Nearests[num13] = this.Nearests[this.NearestCount]; this.Nearests[num13].Num = num13; } num6++; } else { if (!flag2) { nearest.Invalid = true; } num12++; } } num12 = 0; while (num12 < this.NearestCount) { nearest = this.Nearests[num12]; if (nearest.Invalid) { nearest.Num = -1; int num40 = nearest.BlockedNearestCount - 1; baseLevel = 0; while (baseLevel <= num40) { clsNearest[] blockedNearests = nearest.BlockedNearests; num41 = baseLevel; blockedNearests[num41].BlockedCount--; baseLevel++; } this.NearestCount--; if (num12 != this.NearestCount) { this.Nearests[num12] = this.Nearests[this.NearestCount]; this.Nearests[num12].Num = num12; } } else { num12++; } } } while (num6 > 0); int num42 = this.PassageNodeCount - 1; for (num = 0; num <= num42; num++) { int num43 = this.SymmetryBlockCount - 1; for (num2 = 0; num2 <= num43; num2++) { this.PassageNodes[num2, num].ReorderConnections(); this.PassageNodes[num2, num].CalcIsNearBorder(); } } clsPassageNode[] nodeArray2 = new clsPassageNode[(this.PassageNodeCount - 1) + 1]; int index = 0; clsPassageNode[] nodeArray3 = new clsPassageNode[(this.PassageNodeCount - 1) + 1]; int num44 = this.PassageNodeCount - 1; num = 0; while (num <= num44) { nodeArray2[index] = this.PassageNodes[0, num]; index++; num++; } num2 = 0; while (index > 0) { num = (int) Math.Round((double) ((float) (App.Random.Next() * index))); nodeArray3[num2] = nodeArray2[num]; num2++; index--; nodeArray2[num] = nodeArray2[index]; } this.LevelHeight = 255f / ((float) (this.LevelCount - 1)); clsPassageNodeHeightLevelArgs args = new clsPassageNodeHeightLevelArgs { PassageNodesMinLevel = { Nodes = new int[(this.PassageNodeCount - 1) + 1] }, PassageNodesMaxLevel = { Nodes = new int[(this.PassageNodeCount - 1) + 1] }, MapLevelCount = new int[(this.LevelCount - 1) + 1] }; int num45 = this.PassageNodeCount - 1; num = 0; while (num <= num45) { args.PassageNodesMinLevel.Nodes[num] = 0; args.PassageNodesMaxLevel.Nodes[num] = this.LevelCount - 1; num++; } double[] numArray = new double[(this.BaseFlatArea - 1) + 1]; clsPassageNode[] nodeArray = new clsPassageNode[(this.BaseFlatArea - 1) + 1]; int[] numArray2 = new int[(this.BaseFlatArea - 1) + 1]; this.PlayerBases = new sPlayerBase[(this.TotalPlayerCount - 1) + 1]; int num46 = this.TopLeftPlayerCount - 1; num2 = 0; while (num2 <= num46) { int num3 = 0; int num47 = this.PassageNodeCount - 1; num = 0; while (num <= num47) { int num48 = this.SymmetryBlockCount - 1; num9 = 0; while (num9 <= num48) { node = this.PassageNodes[num9, num]; if (!node.IsOnBorder) { _int5 = node.Pos - this.PlayerBasePos[num2]; double magnitude = _int5.ToDoubles().GetMagnitude(); num5 = num3 - 1; while (num5 >= 0) { if (magnitude > numArray[num5]) { break; } num5 += -1; } num5++; int num49 = num5; baseLevel = Math.Min((int) (num3 - 1), (int) (this.BaseFlatArea - 2)); while (baseLevel >= num49) { numArray[baseLevel + 1] = numArray[baseLevel]; nodeArray[baseLevel + 1] = nodeArray[baseLevel]; baseLevel += -1; } if (num5 < this.BaseFlatArea) { numArray[num5] = magnitude; nodeArray[num5] = node; num3 = Math.Max(num3, num5 + 1); } } num9++; } num++; } if (this.BaseLevel < 0) { baseLevel = (int) Math.Round((double) ((float) (App.Random.Next() * this.LevelCount))); } else { baseLevel = this.BaseLevel; } mapLevelCount = args.MapLevelCount; num41 = baseLevel; mapLevelCount[num41] += num3; int num50 = num3 - 1; num = 0; while (num <= num50) { if (nodeArray[num].MirrorNum == 0) { numArray2[num] = -1; } else { int num51 = ((int) Math.Round((double) (((double) this.SymmetryBlockCount) / 2.0))) - 1; num5 = 0; while (num5 <= num51) { if (this.SymmetryBlocks[0].ReflectToNum[num5] == nodeArray[num].MirrorNum) { break; } num5++; } numArray2[num] = num5; } num++; } int num52 = this.SymmetryBlockCount - 1; num = 0; while (num <= num52) { num9 = (num * this.TopLeftPlayerCount) + num2; this.PlayerBases[num9].NodeCount = num3; this.PlayerBases[num9].Nodes = new clsPassageNode[(this.PlayerBases[num9].NodeCount - 1) + 1]; int num53 = num3 - 1; num5 = 0; while (num5 <= num53) { if (numArray2[num5] < 0) { this.PlayerBases[num9].Nodes[num5] = this.PassageNodes[num, nodeArray[num5].Num]; } else { this.PlayerBases[num9].Nodes[num5] = this.PassageNodes[this.SymmetryBlocks[num].ReflectToNum[numArray2[num5]], nodeArray[num5].Num]; } this.PlayerBases[num9].Nodes[num5].PlayerBaseNum = num9; this.PlayerBases[num9].Nodes[num5].Level = baseLevel; this.PassageNodesMinLevelSet(this.PlayerBases[num9].Nodes[num5], args.PassageNodesMinLevel, baseLevel, this.MaxLevelTransition); this.PassageNodesMaxLevelSet(this.PlayerBases[num9].Nodes[num5], args.PassageNodesMaxLevel, baseLevel, this.MaxLevelTransition); num5++; } _int5 = new modMath.sXY_int(_int4.X - 1, _int4.Y - 1); modMath.sXY_int _int3 = TileOrientation.GetRotatedPos(this.SymmetryBlocks[num].Orientation, this.PlayerBasePos[num2], _int5); this.PlayerBases[num9].Pos.X = (this.SymmetryBlocks[num].XYNum.X * _int4.X) + _int3.X; this.PlayerBases[num9].Pos.Y = (this.SymmetryBlocks[num].XYNum.Y * _int4.Y) + _int3.Y; num++; } num2++; } int num54 = this.PassageNodeCount - 1; for (num = 0; num <= num54; num++) { node = nodeArray3[num]; if ((node.Level < 0) & !node.IsOnBorder) { int num20; int num22; int num21 = 0; int num55 = node.ConnectionCount - 1; num2 = 0; while (num2 <= num55) { if (node.Connections[num2].GetOther().IsWater) { num21++; } num2++; } flag = true; int num56 = node.ConnectionCount - 1; num2 = 0; while (num2 <= num56) { if (args.PassageNodesMinLevel.Nodes[node.Connections[num2].GetOther().Num] > 0) { flag = false; } num2++; } if (((flag & (((num21 == 0) & (num22 < this.WaterSpawnQuantity)) | ((num21 == 1) & ((this.TotalWaterQuantity - num20) > (this.WaterSpawnQuantity - num22))))) & (args.PassageNodesMinLevel.Nodes[node.Num] == 0)) & (num20 < this.TotalWaterQuantity)) { if (num21 == 0) { num22++; } num20++; num5 = node.Num; int num57 = this.SymmetryBlockCount - 1; baseLevel = 0; while (baseLevel <= num57) { this.PassageNodes[baseLevel, num5].IsWater = true; this.PassageNodes[baseLevel, num5].Level = 0; baseLevel++; } this.PassageNodesMinLevelSet(node, args.PassageNodesMinLevel, 0, this.MaxLevelTransition); this.PassageNodesMaxLevelSet(node, args.PassageNodesMaxLevel, 0, this.MaxLevelTransition); mapLevelCount = args.MapLevelCount; num41 = 0; mapLevelCount[num41]++; int num58 = node.ConnectionCount - 1; num2 = 0; while (num2 <= num58) { other = node.Connections[num2].GetOther(); this.PassageNodesMinLevelSet(other, args.PassageNodesMinLevel, 0, this.MaxLevelTransition); this.PassageNodesMaxLevelSet(other, args.PassageNodesMaxLevel, 0, this.MaxLevelTransition); num2++; } } } } args.FlatsCutoff = 1; args.PassagesCutoff = 1; args.VariationCutoff = 1; args.ActionTotal = 1; int num59 = this.PassageNodeCount - 1; for (num = 0; num <= num59; num++) { node = nodeArray3[num]; if (((node.Level < 0) & !node.IsOnBorder) & node.IsNearBorder) { args.PassageNode = node; result3 = this.PassageNodeHeightLevel(args); if (!result3.Success) { result4.ProblemAdd(result3.Problem); return result4; } } } args.FlatsCutoff = this.FlatsChance; args.PassagesCutoff = args.FlatsCutoff + this.PassagesChance; args.VariationCutoff = args.PassagesCutoff + this.VariationChance; args.ActionTotal = args.VariationCutoff; if (args.ActionTotal <= 0) { result4.ProblemAdd("All height level behaviors are zero"); return result4; } int num60 = this.PassageNodeCount - 1; for (num = 0; num <= num60; num++) { node = nodeArray3[num]; if ((node.Level < 0) & !node.IsOnBorder) { args.PassageNode = node; result3 = this.PassageNodeHeightLevel(args); if (!result3.Success) { result4.ProblemAdd(result3.Problem); return result4; } } } int num61 = this.PassageNodeCount - 1; for (num = 0; num <= num61; num++) { node = this.PassageNodes[0, num]; if (node.IsOnBorder) { if (node.Level >= 0) { result4.ProblemAdd("Error: Border has had its height set."); return result4; } node3 = null; flag = true; int num62 = node.ConnectionCount - 1; num2 = 0; while (num2 <= num62) { other = node.Connections[num2].GetOther(); if ((((other.Level >= 0) & !other.IsOnBorder) && ((args.PassageNodesMinLevel.Nodes[node.Num] <= other.Level) & (args.PassageNodesMaxLevel.Nodes[node.Num] >= other.Level))) && (node3 == null)) { node3 = other; } if (args.PassageNodesMinLevel.Nodes[other.Num] > 0) { flag = false; } num2++; } if (node3 != null) { level = node3.Level; this.PassageNodesMinLevelSet(node, args.PassageNodesMinLevel, level, this.MaxLevelTransition); this.PassageNodesMaxLevelSet(node, args.PassageNodesMaxLevel, level, this.MaxLevelTransition); int num63 = this.SymmetryBlockCount - 1; baseLevel = 0; while (baseLevel <= num63) { this.PassageNodes[baseLevel, num].IsWater = node3.IsWater & flag; this.PassageNodes[baseLevel, num].Level = level; baseLevel++; } if (node.IsWater) { int num64 = node.ConnectionCount - 1; num2 = 0; while (num2 <= num64) { other = node.Connections[num2].GetOther(); this.PassageNodesMinLevelSet(other, args.PassageNodesMinLevel, node.Level, this.MaxLevelTransition); this.PassageNodesMaxLevelSet(other, args.PassageNodesMaxLevel, node.Level, this.MaxLevelTransition); num2++; } } } } else if (node.Level < 0) { result4.ProblemAdd("Error: Node height not set"); return result4; } } int num65 = this.PassageNodeCount - 1; for (num = 0; num <= num65; num++) { node = this.PassageNodes[0, num]; if (node.IsOnBorder & (node.Level < 0)) { node3 = null; flag = true; int num66 = node.ConnectionCount - 1; num2 = 0; while (num2 <= num66) { other = node.Connections[num2].GetOther(); if (((other.Level >= 0) && ((args.PassageNodesMinLevel.Nodes[node.Num] <= other.Level) & (args.PassageNodesMaxLevel.Nodes[node.Num] >= other.Level))) && (node3 == null)) { node3 = other; } if (args.PassageNodesMinLevel.Nodes[other.Num] > 0) { flag = false; } num2++; } if (node3 == null) { result4.ProblemAdd("Error: No connection for border node"); return result4; } level = node3.Level; this.PassageNodesMinLevelSet(node, args.PassageNodesMinLevel, level, this.MaxLevelTransition); this.PassageNodesMaxLevelSet(node, args.PassageNodesMaxLevel, level, this.MaxLevelTransition); int num67 = this.SymmetryBlockCount - 1; for (baseLevel = 0; baseLevel <= num67; baseLevel++) { this.PassageNodes[baseLevel, num].IsWater = node3.IsWater & flag; this.PassageNodes[baseLevel, num].Level = level; } if (node.IsWater) { int num68 = node.ConnectionCount - 1; for (num2 = 0; num2 <= num68; num2++) { other = node.Connections[num2].GetOther(); this.PassageNodesMinLevelSet(other, args.PassageNodesMinLevel, node.Level, this.MaxLevelTransition); this.PassageNodesMaxLevelSet(other, args.PassageNodesMaxLevel, node.Level, this.MaxLevelTransition); } } } } this.RampBase = 1.0; this.MaxDisconnectionDist = 99999f; clsResult resultToAdd = this.GenerateRamps(); result4.Add(resultToAdd); return result4; }
private bool CheckRampNodeLevelAngles(clsPassageNode RampPassageNode, double RampAwayAngle, double MinSpacingAngle) { int ConnectionNum = 0; clsConnection tmpConnection; clsPassageNode OtherPassageNode = default(clsPassageNode); int OtherNum = 0; bool NarrowConnection = default(bool); sXY_int XY_int = new sXY_int(); bool HasRamp = PassageNodeHasRamp(RampPassageNode); for ( ConnectionNum = 0; ConnectionNum <= RampPassageNode.ConnectionCount - 1; ConnectionNum++ ) { tmpConnection = RampPassageNode.Connections[ConnectionNum].Connection; OtherPassageNode = RampPassageNode.Connections[ConnectionNum].GetOther(); if ( OtherPassageNode.Level == RampPassageNode.Level ) { NarrowConnection = true; if ( ConnectionNum == 0 ) { OtherNum = RampPassageNode.ConnectionCount - 1; } else { OtherNum = ConnectionNum - 1; } if ( OtherNum != ConnectionNum ) { if ( RampPassageNode.Connections[OtherNum].GetOther().Level == OtherPassageNode.Level ) { NarrowConnection = false; } } else { NarrowConnection = false; } if ( ConnectionNum == RampPassageNode.ConnectionCount - 1 ) { OtherNum = 0; } else { OtherNum = ConnectionNum + 1; } if ( OtherNum != ConnectionNum ) { if ( RampPassageNode.Connections[OtherNum].GetOther().Level == OtherPassageNode.Level ) { NarrowConnection = false; } } else { NarrowConnection = false; } if ( NarrowConnection ) { XY_int.X = OtherPassageNode.Pos.X - RampPassageNode.Pos.X; XY_int.Y = OtherPassageNode.Pos.Y - RampPassageNode.Pos.Y; //If HasRamp Then // Return False //End If if ( Math.Abs(MathUtil.AngleClamp(XY_int.ToDoubles().GetAngle() - RampAwayAngle)) < MinSpacingAngle ) { return false; } //If PassageNodeHasRamp(OtherPassageNode) Then // Return False //End If } } } return true; }