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; }
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; }
private bool TestNearest(clsTestNearestArgs Args) { int num; int num2; modMath.sXY_int _int; if (Args.PassageNodeA.MirrorNum != 0) { Debugger.Break(); return false; } _int.X = Args.PassageNodeB.Pos.X - Args.PassageNodeA.Pos.X; _int.Y = Args.PassageNodeB.Pos.Y - Args.PassageNodeA.Pos.Y; int num3 = (_int.X * _int.X) + (_int.Y * _int.Y); if (num3 > Args.MaxConDist2) { return false; } int num6 = this.PassageNodeCount - 1; for (num = 0; num <= num6; num++) { int num7 = this.SymmetryBlockCount - 1; for (num2 = 0; num2 <= num7; num2++) { if ((this.PassageNodes[num2, num] != Args.PassageNodeA) & (this.PassageNodes[num2, num] != Args.PassageNodeB)) { modMath.sXY_int _int2 = modMath.PointGetClosestPosOnLine(Args.PassageNodeA.Pos, Args.PassageNodeB.Pos, this.PassageNodes[num2, num].Pos) - this.PassageNodes[num2, num].Pos; if (_int2.ToDoubles().GetMagnitude() < Args.MinConDist) { return false; } } } } clsNearest nearest = new clsNearest(); clsNearest nearest2 = nearest; nearest2.Num = this.NearestCount; nearest2.Dist2 = num3; if (Args.PassageNodeA.MirrorNum == Args.PassageNodeB.MirrorNum) { nearest2.NodeA = new clsPassageNode[(this.SymmetryBlockCount - 1) + 1]; nearest2.NodeB = new clsPassageNode[(this.SymmetryBlockCount - 1) + 1]; int num8 = this.SymmetryBlockCount - 1; for (num = 0; num <= num8; num++) { nearest2.NodeA[num] = this.PassageNodes[num, Args.PassageNodeA.Num]; nearest2.NodeB[num] = this.PassageNodes[num, Args.PassageNodeB.Num]; } nearest2.NodeCount = this.SymmetryBlockCount; } else { int num4; int num5; if (!this.SymmetryIsRotational) { if (Args.PassageNodeA.Num != Args.PassageNodeB.Num) { return false; } if (this.SymmetryBlockCount != 4) { nearest2.NodeA = new clsPassageNode[1]; nearest2.NodeB = new clsPassageNode[1]; nearest2.NodeA[0] = Args.PassageNodeA; nearest2.NodeB[0] = Args.PassageNodeB; nearest2.NodeCount = 1; goto Label_04A8; } nearest2.NodeA = new clsPassageNode[2]; nearest2.NodeB = new clsPassageNode[2]; num4 = (int) Math.Round((double) (((double) this.SymmetryBlockCount) / 2.0)); int num11 = num4 - 1; for (num5 = 0; num5 <= num11; num5++) { if (this.SymmetryBlocks[0].ReflectToNum[num5] == Args.PassageNodeB.MirrorNum) { break; } } } else { nearest2.NodeA = new clsPassageNode[(this.SymmetryBlockCount - 1) + 1]; nearest2.NodeB = new clsPassageNode[(this.SymmetryBlockCount - 1) + 1]; num4 = (int) Math.Round((double) (((double) this.SymmetryBlockCount) / 2.0)); int num9 = num4 - 1; num5 = 0; while (num5 <= num9) { if (this.SymmetryBlocks[0].ReflectToNum[num5] == Args.PassageNodeB.MirrorNum) { break; } num5++; } if (num5 == num4) { return false; } int num10 = this.SymmetryBlockCount - 1; for (num = 0; num <= num10; num++) { nearest2.NodeA[num] = this.PassageNodes[num, Args.PassageNodeA.Num]; nearest2.NodeB[num] = this.PassageNodes[this.SymmetryBlocks[num].ReflectToNum[num5], Args.PassageNodeB.Num]; } nearest2.NodeCount = this.SymmetryBlockCount; goto Label_04A8; } if (num5 == num4) { return false; } nearest2.NodeA[0] = Args.PassageNodeA; nearest2.NodeB[0] = Args.PassageNodeB; num2 = this.SymmetryBlocks[0].ReflectToNum[1 - num5]; nearest2.NodeA[1] = this.PassageNodes[num2, Args.PassageNodeA.Num]; nearest2.NodeB[1] = this.PassageNodes[this.SymmetryBlocks[num2].ReflectToNum[num5], Args.PassageNodeB.Num]; nearest2.NodeCount = 2; } Label_04A8: nearest2.BlockedNearests = new clsNearest[0x200]; nearest2 = null; this.Nearests[this.NearestCount] = nearest; this.NearestCount++; return true; }
private bool TestNearest(clsTestNearestArgs Args) { sXY_int XY_int = new sXY_int(); clsNearest NearestA = default(clsNearest); int Dist2 = 0; int A = 0; int B = 0; int ReflectionNum = 0; int ReflectionCount = 0; if ( Args.PassageNodeA.MirrorNum != 0 ) { Debugger.Break(); return false; } XY_int.X = Args.PassageNodeB.Pos.X - Args.PassageNodeA.Pos.X; XY_int.Y = Args.PassageNodeB.Pos.Y - Args.PassageNodeA.Pos.Y; Dist2 = XY_int.X * XY_int.X + XY_int.Y * XY_int.Y; if ( Dist2 > Args.MaxConDist2 ) { return false; } for ( A = 0; A <= PassageNodeCount - 1; A++ ) { for ( B = 0; B <= SymmetryBlockCount - 1; B++ ) { if ( PassageNodes[B, A] != Args.PassageNodeA && PassageNodes[B, A] != Args.PassageNodeB ) { XY_int = MathUtil.PointGetClosestPosOnLine(Args.PassageNodeA.Pos, Args.PassageNodeB.Pos, PassageNodes[B, A].Pos); if ( (XY_int - PassageNodes[B, A].Pos).ToDoubles().GetMagnitude() < Args.MinConDist ) { return false; } } } } NearestA = new clsNearest(); NearestA.Num = NearestCount; NearestA.Dist2 = Dist2; if ( Args.PassageNodeA.MirrorNum == Args.PassageNodeB.MirrorNum ) { NearestA.NodeA = new clsPassageNode[SymmetryBlockCount]; NearestA.NodeB = new clsPassageNode[SymmetryBlockCount]; for ( A = 0; A <= SymmetryBlockCount - 1; A++ ) { NearestA.NodeA[A] = PassageNodes[A, Args.PassageNodeA.Num]; NearestA.NodeB[A] = PassageNodes[A, Args.PassageNodeB.Num]; } NearestA.NodeCount = SymmetryBlockCount; } else { if ( SymmetryIsRotational ) { NearestA.NodeA = new clsPassageNode[SymmetryBlockCount]; NearestA.NodeB = new clsPassageNode[SymmetryBlockCount]; ReflectionCount = (int)(SymmetryBlockCount / 2.0D); for ( ReflectionNum = 0; ReflectionNum <= ReflectionCount - 1; ReflectionNum++ ) { if ( SymmetryBlocks[0].ReflectToNum[ReflectionNum] == Args.PassageNodeB.MirrorNum ) { break; } } if ( ReflectionNum == ReflectionCount ) { return false; } for ( A = 0; A <= SymmetryBlockCount - 1; A++ ) { NearestA.NodeA[A] = PassageNodes[A, Args.PassageNodeA.Num]; NearestA.NodeB[A] = PassageNodes[SymmetryBlocks[A].ReflectToNum[ReflectionNum], Args.PassageNodeB.Num]; } NearestA.NodeCount = SymmetryBlockCount; } else { if ( Args.PassageNodeA.Num != Args.PassageNodeB.Num ) { return false; } if ( SymmetryBlockCount == 4 ) { NearestA.NodeA = new clsPassageNode[2]; NearestA.NodeB = new clsPassageNode[2]; ReflectionCount = (int)(SymmetryBlockCount / 2.0D); for ( ReflectionNum = 0; ReflectionNum <= ReflectionCount - 1; ReflectionNum++ ) { if ( SymmetryBlocks[0].ReflectToNum[ReflectionNum] == Args.PassageNodeB.MirrorNum ) { break; } } if ( ReflectionNum == ReflectionCount ) { return false; } NearestA.NodeA[0] = Args.PassageNodeA; NearestA.NodeB[0] = Args.PassageNodeB; B = Convert.ToInt32(SymmetryBlocks[0].ReflectToNum[1 - ReflectionNum]); NearestA.NodeA[1] = PassageNodes[B, Args.PassageNodeA.Num]; NearestA.NodeB[1] = PassageNodes[SymmetryBlocks[B].ReflectToNum[ReflectionNum], Args.PassageNodeB.Num]; NearestA.NodeCount = 2; } else { NearestA.NodeA = new clsPassageNode[1]; NearestA.NodeB = new clsPassageNode[1]; NearestA.NodeA[0] = Args.PassageNodeA; NearestA.NodeB[0] = Args.PassageNodeB; NearestA.NodeCount = 1; } } } NearestA.BlockedNearests = new clsNearest[512]; Nearests[NearestCount] = NearestA; NearestCount++; return true; }