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 modProgram.sResult PassageNodeHeightLevel(clsPassageNodeHeightLevelArgs Args)
{
int num2;
bool flag;
int num4;
modProgram.sResult result2;
clsPassageNode other;
int num6;
int[] mapLevelCount;
int level;
result2.Problem = "";
result2.Success = false;
int[] numArray2 = new int[(this.LevelCount - 1) + 1];
int[] numArray = new int[(this.LevelCount - 1) + 1];
int num7 = Args.PassageNode.ConnectionCount - 1;
for (num2 = 0; num2 <= num7; num2++)
{
other = Args.PassageNode.Connections[num2].GetOther();
if (other.Level >= 0)
{
mapLevelCount = numArray2;
level = other.Level;
mapLevelCount[level]++;
flag = true;
}
if (other.IsWater)
{
num6++;
}
}
if (num6 > 0)
{
num4 = 0;
}
else
{
int num;
int num3;
if (Args.PassageNodesMinLevel.Nodes[Args.PassageNode.Num] > Args.PassageNodesMaxLevel.Nodes[Args.PassageNode.Num])
{
result2.Problem = "Error: Min height more than max.";
return result2;
}
if (!flag)
{
num = 0x7fffffff;
num3 = 0;
int num9 = Args.PassageNodesMaxLevel.Nodes[Args.PassageNode.Num];
for (num2 = Args.PassageNodesMinLevel.Nodes[Args.PassageNode.Num]; num2 <= num9; num2++)
{
if (Args.MapLevelCount[num2] < num)
{
num = Args.MapLevelCount[num2];
numArray[0] = num2;
num3 = 1;
}
else if (Args.MapLevelCount[num2] == num)
{
numArray[num3] = num2;
num3++;
}
}
num4 = numArray[(int) Math.Round((double) ((float) (App.Random.Next() * num3)))];
}
else
{
int num5 = (int) Math.Round((double) ((float) (App.Random.Next() * Args.ActionTotal)));
if (num5 < Args.FlatsCutoff)
{
num = 0;
num3 = 0;
int num10 = Args.PassageNodesMaxLevel.Nodes[Args.PassageNode.Num];
for (num2 = Args.PassageNodesMinLevel.Nodes[Args.PassageNode.Num]; num2 <= num10; num2++)
{
if (numArray2[num2] > num)
{
num = numArray2[num2];
numArray[0] = num2;
num3 = 1;
}
else if (numArray2[num2] == num)
{
numArray[num3] = num2;
num3++;
}
}
}
else if (num5 < Args.PassagesCutoff)
{
num3 = 0;
int num11 = Args.PassageNodesMaxLevel.Nodes[Args.PassageNode.Num];
for (num2 = Args.PassageNodesMinLevel.Nodes[Args.PassageNode.Num]; num2 <= num11; num2++)
{
if (numArray2[num2] == 1)
{
numArray[num3] = num2;
num3++;
continue;
}
if (numArray2[num2] == 2)
{
num3 = 0;
clsPassageNode node2 = null;
int num12 = Args.PassageNode.ConnectionCount - 1;
num = 0;
while (num <= num12)
{
other = Args.PassageNode.Connections[num].GetOther();
if (other.Level == num2)
{
if (node2 == null)
{
node2 = other;
}
else
{
if (node2.FindConnection(other) == null)
{
numArray[num3] = num2;
num3++;
}
break;
}
}
num++;
}
if (num == Args.PassageNode.ConnectionCount)
{
Interaction.MsgBox("Error: two nodes not found", MsgBoxStyle.ApplicationModal, null);
}
}
}
}
else if (num5 < Args.VariationCutoff)
{
num3 = 0;
}
else
{
result2.Problem = "Error: Random number out of range.";
return result2;
}
if (num3 == 0)
{
num = 0x7fffffff;
num3 = 0;
int num13 = Args.PassageNodesMaxLevel.Nodes[Args.PassageNode.Num];
for (num2 = Args.PassageNodesMinLevel.Nodes[Args.PassageNode.Num]; num2 <= num13; num2++)
{
if (numArray2[num2] < num)
{
num = numArray2[num2];
numArray[0] = num2;
num3 = 1;
}
else if (numArray2[num2] == num)
{
numArray[num3] = num2;
num3++;
}
}
}
num4 = numArray[(int) Math.Round((double) ((float) (App.Random.Next() * num3)))];
}
}
int num14 = this.SymmetryBlockCount - 1;
for (num2 = 0; num2 <= num14; num2++)
{
this.PassageNodes[num2, Args.PassageNode.Num].Level = num4;
}
this.PassageNodesMinLevelSet(Args.PassageNode, Args.PassageNodesMinLevel, num4, this.MaxLevelTransition);
this.PassageNodesMaxLevelSet(Args.PassageNode, Args.PassageNodesMaxLevel, num4, this.MaxLevelTransition);
mapLevelCount = Args.MapLevelCount;
level = num4;
mapLevelCount[level]++;
result2.Success = true;
return result2;
}
private App.sResult PassageNodeHeightLevel(clsPassageNodeHeightLevelArgs Args)
{
App.sResult ReturnResult = new App.sResult();
ReturnResult.Problem = "";
ReturnResult.Success = false;
int[] LevelCounts = new int[LevelCount];
int WaterCount = 0;
bool ConnectedToLevel = default(bool);
clsPassageNode tmpPassageNodeB = default(clsPassageNode);
clsPassageNode tmpPassageNodeC = default(clsPassageNode);
int EligableCount = 0;
int[] Eligables = new int[LevelCount];
int NewHeightLevel = 0;
int RandomAction = 0;
int A = 0;
int B = 0;
for ( B = 0; B <= Args.PassageNode.ConnectionCount - 1; B++ )
{
tmpPassageNodeB = Args.PassageNode.Connections[B].GetOther();
if ( tmpPassageNodeB.Level >= 0 )
{
LevelCounts[tmpPassageNodeB.Level]++;
ConnectedToLevel = true;
}
if ( tmpPassageNodeB.IsWater )
{
WaterCount++;
}
}
if ( WaterCount > 0 )
{
NewHeightLevel = 0;
}
else if ( Args.PassageNodesMinLevel.Nodes[Args.PassageNode.Num] > Args.PassageNodesMaxLevel.Nodes[Args.PassageNode.Num] )
{
ReturnResult.Problem = "Error: Min height more than max.";
return ReturnResult;
}
else if ( !ConnectedToLevel )
{
//switch to the most uncommon level on the map
A = int.MaxValue;
EligableCount = 0;
for ( B = Args.PassageNodesMinLevel.Nodes[Args.PassageNode.Num]; B <= Args.PassageNodesMaxLevel.Nodes[Args.PassageNode.Num]; B++ )
{
if ( Args.MapLevelCount[B] < A )
{
A = Args.MapLevelCount[B];
Eligables[0] = B;
EligableCount = 1;
}
else if ( Args.MapLevelCount[B] == A )
{
Eligables[EligableCount] = B;
EligableCount++;
}
}
NewHeightLevel = Eligables[(int)(Conversion.Int(VBMath.Rnd() * EligableCount))];
}
else
{
RandomAction = Convert.ToInt32(Conversion.Int(VBMath.Rnd() * Args.ActionTotal));
if ( RandomAction < Args.FlatsCutoff )
{
//extend the level that surrounds this most
A = 0;
EligableCount = 0;
for ( B = Args.PassageNodesMinLevel.Nodes[Args.PassageNode.Num]; B <= Args.PassageNodesMaxLevel.Nodes[Args.PassageNode.Num]; B++ )
{
if ( LevelCounts[B] > A )
{
A = LevelCounts[B];
Eligables[0] = B;
EligableCount = 1;
}
else if ( LevelCounts[B] == A )
{
Eligables[EligableCount] = B;
EligableCount++;
}
}
}
else if ( RandomAction < Args.PassagesCutoff )
{
//extend any level that surrounds only once, or twice by nodes that aren't already connected
EligableCount = 0;
for ( B = Args.PassageNodesMinLevel.Nodes[Args.PassageNode.Num]; B <= Args.PassageNodesMaxLevel.Nodes[Args.PassageNode.Num]; B++ )
{
if ( LevelCounts[B] == 1 )
{
Eligables[EligableCount] = B;
EligableCount++;
}
else if ( LevelCounts[B] == 2 )
{
EligableCount = 0;
tmpPassageNodeC = null;
for ( A = 0; A <= Args.PassageNode.ConnectionCount - 1; A++ )
{
tmpPassageNodeB = Args.PassageNode.Connections[A].GetOther();
if ( tmpPassageNodeB.Level == B )
{
if ( tmpPassageNodeC == null )
{
tmpPassageNodeC = tmpPassageNodeB;
}
else
{
if ( tmpPassageNodeC.FindConnection(tmpPassageNodeB) == null )
{
Eligables[EligableCount] = B;
EligableCount++;
}
break;
}
}
}
if ( A == Args.PassageNode.ConnectionCount )
{
MessageBox.Show("Error: two nodes not found");
}
}
}
}
else if ( RandomAction < Args.VariationCutoff )
{
EligableCount = 0;
}
else
{
ReturnResult.Problem = "Error: Random number out of range.";
return ReturnResult;
}
if ( EligableCount == 0 )
{
//extend the most uncommon surrounding
A = int.MaxValue;
EligableCount = 0;
for ( B = Args.PassageNodesMinLevel.Nodes[Args.PassageNode.Num]; B <= Args.PassageNodesMaxLevel.Nodes[Args.PassageNode.Num]; B++ )
{
if ( LevelCounts[B] < A )
{
A = LevelCounts[B];
Eligables[0] = B;
EligableCount = 1;
}
else if ( LevelCounts[B] == A )
{
Eligables[EligableCount] = B;
EligableCount++;
}
}
}
NewHeightLevel = Eligables[(int)(Conversion.Int(VBMath.Rnd() * EligableCount))];
}
for ( B = 0; B <= SymmetryBlockCount - 1; B++ )
{
PassageNodes[B, Args.PassageNode.Num].Level = NewHeightLevel;
}
PassageNodesMinLevelSet(Args.PassageNode, Args.PassageNodesMinLevel, NewHeightLevel, MaxLevelTransition);
PassageNodesMaxLevelSet(Args.PassageNode, Args.PassageNodesMaxLevel, NewHeightLevel, MaxLevelTransition);
Args.MapLevelCount[NewHeightLevel]++;
ReturnResult.Success = true;
return ReturnResult;
}
