public void GenerateTilePathMap()
{
int num;
int num2;
this.TilePathMap = new PathfinderNetwork();
int num3 = this.Map.Terrain.TileSize.Y - 1;
for (num2 = 0; num2 <= num3; num2++)
{
int num4 = this.Map.Terrain.TileSize.X - 1;
num = 0;
while (num <= num4)
{
this.GenerateTerrainTiles[num, num2] = new GenerateTerrainTile();
this.GenerateTerrainTiles[num, num2].Node = new PathfinderNode(this.TilePathMap);
clsNodeTag tag = new clsNodeTag {
Pos = new modMath.sXY_int((int) Math.Round((double) ((num + 0.5) * 128.0)), (int) Math.Round((double) ((num2 + 0.5) * 128.0)))
};
this.GenerateTerrainTiles[num, num2].Node.Tag = tag;
num++;
}
}
int num5 = this.Map.Terrain.TileSize.Y - 1;
for (num2 = 0; num2 <= num5; num2++)
{
int num6 = this.Map.Terrain.TileSize.X - 1;
for (num = 0; num <= num6; num++)
{
PathfinderNode node;
PathfinderNode nodeA = this.GenerateTerrainTiles[num, num2].Node;
if (num > 0)
{
node = this.GenerateTerrainTiles[num - 1, num2].Node;
this.GenerateTerrainTiles[num, num2].LeftLink = nodeA.GetOrCreateConnection(node, this.GetNodePosDist(nodeA, node));
}
if (num2 > 0)
{
if (num > 0)
{
node = this.GenerateTerrainTiles[num - 1, num2 - 1].Node;
this.GenerateTerrainTiles[num, num2].TopLeftLink = nodeA.GetOrCreateConnection(node, this.GetNodePosDist(nodeA, node));
}
node = this.GenerateTerrainTiles[num, num2 - 1].Node;
this.GenerateTerrainTiles[num, num2].TopLink = nodeA.GetOrCreateConnection(node, this.GetNodePosDist(nodeA, node));
if (num < (this.Map.Terrain.TileSize.X - 1))
{
node = this.GenerateTerrainTiles[num + 1, num2 - 1].Node;
this.GenerateTerrainTiles[num, num2].TopRightLink = nodeA.GetOrCreateConnection(node, this.GetNodePosDist(nodeA, node));
}
}
if (num < (this.Map.Terrain.TileSize.X - 1))
{
node = this.GenerateTerrainTiles[num + 1, num2].Node;
this.GenerateTerrainTiles[num, num2].RightLink = nodeA.GetOrCreateConnection(node, this.GetNodePosDist(nodeA, node));
}
if (num2 < (this.Map.Terrain.TileSize.Y - 1))
{
if (num > 0)
{
node = this.GenerateTerrainTiles[num - 1, num2 + 1].Node;
this.GenerateTerrainTiles[num, num2].BottomLeftLink = nodeA.GetOrCreateConnection(node, this.GetNodePosDist(nodeA, node));
}
node = this.GenerateTerrainTiles[num, num2 + 1].Node;
this.GenerateTerrainTiles[num, num2].BottomLink = nodeA.GetOrCreateConnection(node, this.GetNodePosDist(nodeA, node));
if (num < (this.Map.Terrain.TileSize.X - 1))
{
node = this.GenerateTerrainTiles[num + 1, num2 + 1].Node;
this.GenerateTerrainTiles[num, num2].BottomRightLink = nodeA.GetOrCreateConnection(node, this.GetNodePosDist(nodeA, node));
}
}
}
}
this.TilePathMap.LargeArraysResize();
this.TilePathMap.FindCalc();
}
private clsPassageNodeNework MakePassageNodeNetwork()
{
int num;
clsPassageNodeNework nework2 = new clsPassageNodeNework {
Network = new PathfinderNetwork(),
PassageNodePathNodes = new PathfinderNode[(this.SymmetryBlockCount - 1) + 1, (this.PassageNodeCount - 1) + 1]
};
int num3 = this.PassageNodeCount - 1;
for (num = 0; num <= num3; num++)
{
int num4 = this.SymmetryBlockCount - 1;
for (int i = 0; i <= num4; i++)
{
nework2.PassageNodePathNodes[i, num] = new PathfinderNode(nework2.Network);
clsNodeTag tag = new clsNodeTag {
Pos = this.PassageNodes[i, num].Pos
};
nework2.PassageNodePathNodes[i, num].Tag = tag;
}
}
int num5 = this.ConnectionCount - 1;
for (num = 0; num <= num5; num++)
{
if (((this.Connections[num].PassageNodeA.Level == this.Connections[num].PassageNodeB.Level) | this.Connections[num].IsRamp) && !(this.Connections[num].PassageNodeA.IsWater | this.Connections[num].PassageNodeB.IsWater))
{
PathfinderNode nodeA = nework2.PassageNodePathNodes[this.Connections[num].PassageNodeA.MirrorNum, this.Connections[num].PassageNodeA.Num];
PathfinderNode otherNode = nework2.PassageNodePathNodes[this.Connections[num].PassageNodeB.MirrorNum, this.Connections[num].PassageNodeB.Num];
PathfinderConnection connection = nodeA.CreateConnection(otherNode, this.GetNodePosDist(nodeA, otherNode));
}
}
nework2.Network.LargeArraysResize();
nework2.Network.FindCalc();
return nework2;
}
public clsResult GenerateLayoutTerrain()
{
int num2;
int num4;
double magnitude;
clsNodeTag tag;
PathfinderNode node2;
int num8;
int num9;
modMath.sXY_int _int3;
clsResult result2 = new clsResult("Terrain heights");
this.Map = new clsMap(this.TileSize);
this.GenerateTerrainTiles = new GenerateTerrainTile[(this.Map.Terrain.TileSize.X - 1) + 1, (this.Map.Terrain.TileSize.Y - 1) + 1];
this.GenerateTerrainVertices = new GenerateTerrainVertex[this.Map.Terrain.TileSize.X + 1, this.Map.Terrain.TileSize.Y + 1];
this.VertexPathMap = new PathfinderNetwork();
int y = this.Map.Terrain.TileSize.Y;
for (num9 = 0; num9 <= y; num9++)
{
int x = this.Map.Terrain.TileSize.X;
num8 = 0;
while (num8 <= x)
{
this.GenerateTerrainVertices[num8, num9] = new GenerateTerrainVertex();
this.GenerateTerrainVertices[num8, num9].Node = new PathfinderNode(this.VertexPathMap);
tag = new clsNodeTag {
Pos = new modMath.sXY_int(num8 * 0x80, num9 * 0x80)
};
this.GenerateTerrainVertices[num8, num9].Node.Tag = tag;
num8++;
}
}
int num12 = this.Map.Terrain.TileSize.Y;
for (num9 = 0; num9 <= num12; num9++)
{
int num13 = this.Map.Terrain.TileSize.X;
for (num8 = 0; num8 <= num13; num8++)
{
PathfinderNode node3;
node2 = this.GenerateTerrainVertices[num8, num9].Node;
if (num8 > 0)
{
node3 = this.GenerateTerrainVertices[num8 - 1, num9].Node;
this.GenerateTerrainVertices[num8, num9].LeftLink = node2.GetOrCreateConnection(node3, this.GetNodePosDist(node2, node3));
}
if (num9 > 0)
{
if (num8 > 0)
{
node3 = this.GenerateTerrainVertices[num8 - 1, num9 - 1].Node;
this.GenerateTerrainVertices[num8, num9].TopLeftLink = node2.GetOrCreateConnection(node3, this.GetNodePosDist(node2, node3));
}
node3 = this.GenerateTerrainVertices[num8, num9 - 1].Node;
this.GenerateTerrainVertices[num8, num9].TopLink = node2.GetOrCreateConnection(node3, this.GetNodePosDist(node2, node3));
if (num8 < this.Map.Terrain.TileSize.X)
{
node3 = this.GenerateTerrainVertices[num8 + 1, num9 - 1].Node;
this.GenerateTerrainVertices[num8, num9].TopRightLink = node2.GetOrCreateConnection(node3, this.GetNodePosDist(node2, node3));
}
}
if (num8 < this.Map.Terrain.TileSize.X)
{
node3 = this.GenerateTerrainVertices[num8 + 1, num9].Node;
this.GenerateTerrainVertices[num8, num9].RightLink = node2.GetOrCreateConnection(node3, this.GetNodePosDist(node2, node3));
}
if (num9 < this.Map.Terrain.TileSize.Y)
{
if (num8 > 0)
{
node3 = this.GenerateTerrainVertices[num8 - 1, num9 + 1].Node;
this.GenerateTerrainVertices[num8, num9].BottomLeftLink = node2.GetOrCreateConnection(node3, this.GetNodePosDist(node2, node3));
}
node3 = this.GenerateTerrainVertices[num8, num9 + 1].Node;
this.GenerateTerrainVertices[num8, num9].BottomLink = node2.GetOrCreateConnection(node3, this.GetNodePosDist(node2, node3));
if (num8 < this.Map.Terrain.TileSize.X)
{
node3 = this.GenerateTerrainVertices[num8 + 1, num9 + 1].Node;
this.GenerateTerrainVertices[num8, num9].BottomRightLink = node2.GetOrCreateConnection(node3, this.GetNodePosDist(node2, node3));
}
}
}
}
this.VertexPathMap.LargeArraysResize();
this.VertexPathMap.FindCalc();
PathfinderLayer layer = this.VertexPathMap.get_GetNodeLayer(0);
PathfinderLayer layer2 = this.VertexPathMap.get_GetNodeLayer(this.JitterScale);
int num = layer2.GetNodeCount - 1;
int[] numArray = new int[num + 1];
clsBaseNodeLevels baseLevel = new clsBaseNodeLevels {
NodeLevels = new float[(layer.GetNodeCount - 1) + 1]
};
if (num > 0)
{
int num14 = num;
num2 = 0;
while (num2 <= num14)
{
Position.XY_dbl _dbl;
node2 = layer2.get_GetNode(num2);
num4 = 0;
_dbl.X = 0.0;
_dbl.Y = 0.0;
this.CalcNodePos(node2, ref _dbl, ref num4);
tag = new clsNodeTag();
tag.Pos.X = (int) Math.Round((double) (_dbl.X / ((double) num4)));
tag.Pos.Y = (int) Math.Round((double) (_dbl.Y / ((double) num4)));
node2.Tag = tag;
num2++;
}
}
int num15 = layer2.GetNodeCount - 1;
for (num = 0; num <= num15; num++)
{
bool flag;
tag = (clsNodeTag) layer2.get_GetNode(num).Tag;
numArray[num] = -1;
double num3 = 3.4028234663852886E+38;
clsConnection connection = null;
clsPassageNode passageNodeA = null;
int num16 = this.ConnectionCount - 1;
num2 = 0;
while (num2 <= num16)
{
if (this.Connections[num2].PassageNodeA.Level == this.Connections[num2].PassageNodeB.Level)
{
modMath.sXY_int _int2 = modMath.PointGetClosestPosOnLine(this.Connections[num2].PassageNodeA.Pos, this.Connections[num2].PassageNodeB.Pos, tag.Pos) - tag.Pos;
magnitude = (float) _int2.ToDoubles().GetMagnitude();
if (magnitude < num3)
{
num3 = magnitude;
_int2 = tag.Pos - this.Connections[num2].PassageNodeA.Pos;
_int3 = tag.Pos - this.Connections[num2].PassageNodeB.Pos;
if (_int2.ToDoubles().GetMagnitude() <= _int3.ToDoubles().GetMagnitude())
{
passageNodeA = this.Connections[num2].PassageNodeA;
}
else
{
passageNodeA = this.Connections[num2].PassageNodeB;
}
flag = true;
}
}
num2++;
}
int num17 = this.PassageNodeCount - 1;
for (num4 = 0; num4 <= num17; num4++)
{
int num18 = this.SymmetryBlockCount - 1;
for (int i = 0; i <= num18; i++)
{
_int3 = tag.Pos - this.PassageNodes[i, num4].Pos;
magnitude = (float) _int3.ToDoubles().GetMagnitude();
if (magnitude < num3)
{
num3 = magnitude;
passageNodeA = this.PassageNodes[i, num4];
flag = true;
}
}
}
if (flag)
{
numArray[num] = passageNodeA.Level;
}
else
{
numArray[num] = connection.PassageNodeA.Level;
}
if (numArray[num] < 0)
{
result2.ProblemAdd("Error: Node height is not set.");
return result2;
}
}
int num19 = this.LevelCount - 1;
num = 0;
while (num <= num19)
{
int num20 = layer2.GetNodeCount - 1;
num2 = 0;
while (num2 <= num20)
{
if (numArray[num2] >= num)
{
this.SetBaseLevel(layer2.get_GetNode(num2), num, baseLevel);
}
num2++;
}
num++;
}
int num7 = ((int) Math.Round((double) ((this.LevelHeight * this.Map.HeightMultiplier) * 2.0))) + 0x80;
clsSetBaseLevelRampArgs args = new clsSetBaseLevelRampArgs {
BaseLevel = baseLevel,
RampRadius = 320f
};
int num21 = this.ConnectionCount - 1;
for (num2 = 0; num2 <= num21; num2++)
{
args.Connection = this.Connections[num2];
_int3 = this.Connections[num2].PassageNodeA.Pos - this.Connections[num2].PassageNodeB.Pos;
args.RampLength = Math.Max((int) Math.Round((double) (_int3.ToDoubles().GetMagnitude() * 0.75)), num7 * Math.Abs((int) (this.Connections[num2].PassageNodeA.Level - this.Connections[num2].PassageNodeB.Level)));
int num22 = layer2.GetNodeCount - 1;
num = 0;
while (num <= num22)
{
if (this.Connections[num2].IsRamp)
{
tag = (clsNodeTag) layer2.get_GetNode(num).Tag;
_int3 = modMath.PointGetClosestPosOnLine(this.Connections[num2].PassageNodeA.Pos, this.Connections[num2].PassageNodeB.Pos, tag.Pos) - tag.Pos;
magnitude = (float) _int3.ToDoubles().GetMagnitude();
if (magnitude < (args.RampLength * 2f))
{
this.SetBaseLevelRamp(args, layer2.get_GetNode(num));
}
}
num++;
}
}
int num23 = layer.GetNodeCount - 1;
for (num = 0; num <= num23; num++)
{
tag = (clsNodeTag) layer.get_GetNode(num).Tag;
this.Map.Terrain.Vertices[(int) Math.Round((double) (((float) tag.Pos.X) / 128f)), (int) Math.Round((double) (((float) tag.Pos.Y) / 128f))].Height = (byte) Math.Round((double) (baseLevel.NodeLevels[num] * this.LevelHeight));
}
return result2;
}
private clsPassageNodeNework MakePassageNodeNetwork()
{
clsPassageNodeNework ReturnResult = new clsPassageNodeNework();
PathfinderConnection NewConnection;
clsNodeTag NodeTag = default(clsNodeTag);
PathfinderNode tmpNodeA = default(PathfinderNode);
PathfinderNode tmpNodeB = default(PathfinderNode);
int A = 0;
int B = 0;
ReturnResult.Network = new PathfinderNetwork();
ReturnResult.PassageNodePathNodes = new PathfinderNode[SymmetryBlockCount, PassageNodeCount];
for ( A = 0; A <= PassageNodeCount - 1; A++ )
{
for ( B = 0; B <= SymmetryBlockCount - 1; B++ )
{
ReturnResult.PassageNodePathNodes[B, A] = new PathfinderNode(ReturnResult.Network);
NodeTag = new clsNodeTag();
NodeTag.Pos = PassageNodes[B, A].Pos;
ReturnResult.PassageNodePathNodes[B, A].Tag = NodeTag;
}
}
for ( A = 0; A <= ConnectionCount - 1; A++ )
{
if ( Connections[A].PassageNodeA.Level == Connections[A].PassageNodeB.Level || Connections[A].IsRamp )
{
if ( !(Connections[A].PassageNodeA.IsWater || Connections[A].PassageNodeB.IsWater) )
{
tmpNodeA = ReturnResult.PassageNodePathNodes[Connections[A].PassageNodeA.MirrorNum, Connections[A].PassageNodeA.Num];
tmpNodeB = ReturnResult.PassageNodePathNodes[Connections[A].PassageNodeB.MirrorNum, Connections[A].PassageNodeB.Num];
NewConnection = tmpNodeA.CreateConnection(tmpNodeB, GetNodePosDist(tmpNodeA, tmpNodeB));
}
}
}
ReturnResult.Network.LargeArraysResize();
ReturnResult.Network.FindCalc();
return ReturnResult;
}
public void GenerateTilePathMap()
{
clsNodeTag NodeTag = default(clsNodeTag);
PathfinderNode tmpNodeA = default(PathfinderNode);
PathfinderNode tmpNodeB = default(PathfinderNode);
int X = 0;
int Y = 0;
TilePathMap = new PathfinderNetwork();
for ( Y = 0; Y <= Map.Terrain.TileSize.Y - 1; Y++ )
{
for ( X = 0; X <= Map.Terrain.TileSize.X - 1; X++ )
{
GenerateTerrainTiles[X, Y] = new GenerateTerrainTile();
GenerateTerrainTiles[X, Y].Node = new PathfinderNode(TilePathMap);
NodeTag = new clsNodeTag();
NodeTag.Pos = new sXY_int((int)((X + 0.5D) * 128.0D), (int)((Y + 0.5D) * 128.0D));
GenerateTerrainTiles[X, Y].Node.Tag = NodeTag;
}
}
for ( Y = 0; Y <= Map.Terrain.TileSize.Y - 1; Y++ )
{
for ( X = 0; X <= Map.Terrain.TileSize.X - 1; X++ )
{
tmpNodeA = GenerateTerrainTiles[X, Y].Node;
if ( X > 0 )
{
tmpNodeB = GenerateTerrainTiles[X - 1, Y].Node;
GenerateTerrainTiles[X, Y].LeftLink = tmpNodeA.GetOrCreateConnection(tmpNodeB, GetNodePosDist(tmpNodeA, tmpNodeB));
}
if ( Y > 0 )
{
if ( X > 0 )
{
tmpNodeB = GenerateTerrainTiles[X - 1, Y - 1].Node;
GenerateTerrainTiles[X, Y].TopLeftLink = tmpNodeA.GetOrCreateConnection(tmpNodeB, GetNodePosDist(tmpNodeA, tmpNodeB));
}
tmpNodeB = GenerateTerrainTiles[X, Y - 1].Node;
GenerateTerrainTiles[X, Y].TopLink = tmpNodeA.GetOrCreateConnection(tmpNodeB, GetNodePosDist(tmpNodeA, tmpNodeB));
if ( X < Map.Terrain.TileSize.X - 1 )
{
tmpNodeB = GenerateTerrainTiles[X + 1, Y - 1].Node;
GenerateTerrainTiles[X, Y].TopRightLink = tmpNodeA.GetOrCreateConnection(tmpNodeB, GetNodePosDist(tmpNodeA, tmpNodeB));
}
}
if ( X < Map.Terrain.TileSize.X - 1 )
{
tmpNodeB = GenerateTerrainTiles[X + 1, Y].Node;
GenerateTerrainTiles[X, Y].RightLink = tmpNodeA.GetOrCreateConnection(tmpNodeB, GetNodePosDist(tmpNodeA, tmpNodeB));
}
if ( Y < Map.Terrain.TileSize.Y - 1 )
{
if ( X > 0 )
{
tmpNodeB = GenerateTerrainTiles[X - 1, Y + 1].Node;
GenerateTerrainTiles[X, Y].BottomLeftLink = tmpNodeA.GetOrCreateConnection(tmpNodeB, GetNodePosDist(tmpNodeA, tmpNodeB));
}
tmpNodeB = GenerateTerrainTiles[X, Y + 1].Node;
GenerateTerrainTiles[X, Y].BottomLink = tmpNodeA.GetOrCreateConnection(tmpNodeB, GetNodePosDist(tmpNodeA, tmpNodeB));
if ( X < Map.Terrain.TileSize.X - 1 )
{
tmpNodeB = GenerateTerrainTiles[X + 1, Y + 1].Node;
GenerateTerrainTiles[X, Y].BottomRightLink = tmpNodeA.GetOrCreateConnection(tmpNodeB, GetNodePosDist(tmpNodeA, tmpNodeB));
}
}
}
}
TilePathMap.LargeArraysResize();
TilePathMap.FindCalc();
}
public clsResult GenerateLayoutTerrain()
{
clsResult ReturnResult = new clsResult("Terrain heights");
clsNodeTag NodeTag = default(clsNodeTag);
PathfinderNode tmpNodeA = default(PathfinderNode);
PathfinderNode tmpNodeB = default(PathfinderNode);
int A = 0;
int B = 0;
int C = 0;
int D = 0;
int X = 0;
int Y = 0;
sXY_int XY_int = new sXY_int();
double Dist = 0;
double BestDist = 0;
bool Flag = default(bool);
Map = new clsMap(TileSize);
GenerateTerrainTiles = new GenerateTerrainTile[Map.Terrain.TileSize.X, Map.Terrain.TileSize.Y];
GenerateTerrainVertices = new GenerateTerrainVertex[Map.Terrain.TileSize.X + 1, Map.Terrain.TileSize.Y + 1];
//set terrain heights
VertexPathMap = new PathfinderNetwork();
for ( Y = 0; Y <= Map.Terrain.TileSize.Y; Y++ )
{
for ( X = 0; X <= Map.Terrain.TileSize.X; X++ )
{
GenerateTerrainVertices[X, Y] = new GenerateTerrainVertex();
GenerateTerrainVertices[X, Y].Node = new PathfinderNode(VertexPathMap);
NodeTag = new clsNodeTag();
NodeTag.Pos = new sXY_int(X * 128, Y * 128);
GenerateTerrainVertices[X, Y].Node.Tag = NodeTag;
}
}
for ( Y = 0; Y <= Map.Terrain.TileSize.Y; Y++ )
{
for ( X = 0; X <= Map.Terrain.TileSize.X; X++ )
{
tmpNodeA = GenerateTerrainVertices[X, Y].Node;
if ( X > 0 )
{
tmpNodeB = GenerateTerrainVertices[X - 1, Y].Node;
GenerateTerrainVertices[X, Y].LeftLink = tmpNodeA.GetOrCreateConnection(tmpNodeB, GetNodePosDist(tmpNodeA, tmpNodeB));
}
if ( Y > 0 )
{
if ( X > 0 )
{
tmpNodeB = GenerateTerrainVertices[X - 1, Y - 1].Node;
GenerateTerrainVertices[X, Y].TopLeftLink = tmpNodeA.GetOrCreateConnection(tmpNodeB, GetNodePosDist(tmpNodeA, tmpNodeB));
}
tmpNodeB = GenerateTerrainVertices[X, Y - 1].Node;
GenerateTerrainVertices[X, Y].TopLink = tmpNodeA.GetOrCreateConnection(tmpNodeB, GetNodePosDist(tmpNodeA, tmpNodeB));
if ( X < Map.Terrain.TileSize.X )
{
tmpNodeB = GenerateTerrainVertices[X + 1, Y - 1].Node;
GenerateTerrainVertices[X, Y].TopRightLink = tmpNodeA.GetOrCreateConnection(tmpNodeB, GetNodePosDist(tmpNodeA, tmpNodeB));
}
}
if ( X < Map.Terrain.TileSize.X )
{
tmpNodeB = GenerateTerrainVertices[X + 1, Y].Node;
GenerateTerrainVertices[X, Y].RightLink = tmpNodeA.GetOrCreateConnection(tmpNodeB, GetNodePosDist(tmpNodeA, tmpNodeB));
}
if ( Y < Map.Terrain.TileSize.Y )
{
if ( X > 0 )
{
tmpNodeB = GenerateTerrainVertices[X - 1, Y + 1].Node;
GenerateTerrainVertices[X, Y].BottomLeftLink = tmpNodeA.GetOrCreateConnection(tmpNodeB, GetNodePosDist(tmpNodeA, tmpNodeB));
}
tmpNodeB = GenerateTerrainVertices[X, Y + 1].Node;
GenerateTerrainVertices[X, Y].BottomLink = tmpNodeA.GetOrCreateConnection(tmpNodeB, GetNodePosDist(tmpNodeA, tmpNodeB));
if ( X < Map.Terrain.TileSize.X )
{
tmpNodeB = GenerateTerrainVertices[X + 1, Y + 1].Node;
GenerateTerrainVertices[X, Y].BottomRightLink = tmpNodeA.GetOrCreateConnection(tmpNodeB, GetNodePosDist(tmpNodeA, tmpNodeB));
}
}
}
}
VertexPathMap.LargeArraysResize();
VertexPathMap.FindCalc();
PathfinderLayer BaseLayer = VertexPathMap.get_GetNodeLayer(0);
PathfinderLayer JitterLayer = VertexPathMap.get_GetNodeLayer(JitterScale);
A = JitterLayer.GetNodeCount - 1;
int[] NodeLevel = new int[A + 1];
clsBaseNodeLevels BaseNodeLevel = new clsBaseNodeLevels();
BaseNodeLevel.NodeLevels = new float[BaseLayer.GetNodeCount];
//set position of jitter layer nodes
Position.XY_dbl XY_dbl = default(Position.XY_dbl);
if ( A > 0 )
{
for ( B = 0; B <= A; B++ )
{
tmpNodeA = JitterLayer.get_GetNode(B);
C = 0;
XY_dbl.X = 0.0D;
XY_dbl.Y = 0.0D;
CalcNodePos(tmpNodeA, ref XY_dbl, ref C);
NodeTag = new clsNodeTag();
NodeTag.Pos.X = (int)(XY_dbl.X / C);
NodeTag.Pos.Y = (int)(XY_dbl.Y / C);
tmpNodeA.Tag = NodeTag;
}
}
//set node heights
clsConnection BestConnection = default(clsConnection);
clsPassageNode BestNode = default(clsPassageNode);
for ( A = 0; A <= JitterLayer.GetNodeCount - 1; A++ )
{
NodeTag = (clsNodeTag)(JitterLayer.get_GetNode(A).Tag);
NodeLevel[A] = -1;
BestDist = float.MaxValue;
BestConnection = null;
BestNode = null;
for ( B = 0; B <= ConnectionCount - 1; B++ )
{
//If Not (Connections(B).PassageNodeA.IsOnBorder Or Connections(B).PassageNodeB.IsOnBorder) Then
if ( Connections[B].PassageNodeA.Level == Connections[B].PassageNodeB.Level )
{
//only do this if the levels are the same
//this is to make sure nodes that are connected are actually connected on the terrain
XY_int = MathUtil.PointGetClosestPosOnLine(Connections[B].PassageNodeA.Pos, Connections[B].PassageNodeB.Pos, NodeTag.Pos);
Dist = Convert.ToSingle((XY_int - NodeTag.Pos).ToDoubles().GetMagnitude());
if ( Dist < BestDist )
{
BestDist = Dist;
if ( (NodeTag.Pos - Connections[B].PassageNodeA.Pos).ToDoubles().GetMagnitude() <=
(NodeTag.Pos - Connections[B].PassageNodeB.Pos).ToDoubles().GetMagnitude() )
{
BestNode = Connections[B].PassageNodeA;
}
else
{
BestNode = Connections[B].PassageNodeB;
}
Flag = true;
}
}
}
for ( C = 0; C <= PassageNodeCount - 1; C++ )
{
//If Not PassageNodesA(C).IsOnBorder Then
for ( D = 0; D <= SymmetryBlockCount - 1; D++ )
{
Dist = Convert.ToSingle((NodeTag.Pos - PassageNodes[D, C].Pos).ToDoubles().GetMagnitude());
if ( Dist < BestDist )
{
BestDist = Dist;
BestNode = PassageNodes[D, C];
Flag = true;
}
}
//End If
}
if ( Flag )
{
NodeLevel[A] = BestNode.Level;
}
else
{
NodeLevel[A] = BestConnection.PassageNodeA.Level;
}
if ( NodeLevel[A] < 0 )
{
ReturnResult.ProblemAdd("Error: Node height is not set.");
return ReturnResult;
}
}
for ( A = 0; A <= LevelCount - 1; A++ )
{
for ( B = 0; B <= JitterLayer.GetNodeCount - 1; B++ )
{
if ( NodeLevel[B] >= A )
{
SetBaseLevel(JitterLayer.get_GetNode(B), A, BaseNodeLevel);
}
}
}
//make ramp slopes
int MinRampLength = ((int)(LevelHeight * Map.HeightMultiplier * 2.0D)) + 128;
clsSetBaseLevelRampArgs RampArgs = new clsSetBaseLevelRampArgs();
RampArgs.BaseLevel = BaseNodeLevel;
RampArgs.RampRadius = 320.0F;
for ( B = 0; B <= ConnectionCount - 1; B++ )
{
RampArgs.Connection = Connections[B];
RampArgs.RampLength =
Math.Max(Convert.ToInt32((Connections[B].PassageNodeA.Pos - Connections[B].PassageNodeB.Pos).ToDoubles().GetMagnitude() * 0.75D),
MinRampLength * Math.Abs(Connections[B].PassageNodeA.Level - Connections[B].PassageNodeB.Level));
for ( A = 0; A <= JitterLayer.GetNodeCount - 1; A++ )
{
if ( Connections[B].IsRamp )
{
NodeTag = (clsNodeTag)(JitterLayer.get_GetNode(A).Tag);
XY_int = MathUtil.PointGetClosestPosOnLine(Connections[B].PassageNodeA.Pos, Connections[B].PassageNodeB.Pos, NodeTag.Pos);
Dist = Convert.ToSingle((XY_int - NodeTag.Pos).ToDoubles().GetMagnitude());
if ( Dist < RampArgs.RampLength * 2.0F )
{
SetBaseLevelRamp(RampArgs, JitterLayer.get_GetNode(A));
}
}
}
}
for ( A = 0; A <= BaseLayer.GetNodeCount - 1; A++ )
{
NodeTag = (clsNodeTag)(BaseLayer.get_GetNode(A).Tag);
Map.Terrain.Vertices[(int)(NodeTag.Pos.X / 128.0F), (int)(NodeTag.Pos.Y / 128.0F)].Height = (byte)(BaseNodeLevel.NodeLevels[A] * LevelHeight);
}
return ReturnResult;
}
private clsPassageNodeNework MakePassageNodeNetwork()
{
var ReturnResult = new clsPassageNodeNework();
var NodeTag = default(clsNodeTag);
var A = 0;
var B = 0;
ReturnResult.Network = new PathfinderNetwork();
ReturnResult.PassageNodePathNodes = new PathfinderNode[SymmetryBlockCount, PassageNodeCount];
for ( A = 0; A <= PassageNodeCount - 1; A++ )
{
for ( B = 0; B <= SymmetryBlockCount - 1; B++ )
{
ReturnResult.PassageNodePathNodes[B, A] = new PathfinderNode(ReturnResult.Network);
NodeTag = new clsNodeTag();
NodeTag.Pos = PassageNodes[B, A].Pos;
ReturnResult.PassageNodePathNodes[B, A].Tag = NodeTag;
}
}
ReturnResult.Network.LargeArraysResize();
ReturnResult.Network.FindCalc();
return ReturnResult;
}
