private static void Process(int x, int z, bool keepExisting)
{
TerrainTopologyMap topologyMap = TerrainMeta.TopologyMap;
float normZ = topologyMap.Coordinate(z);
float normX = topologyMap.Coordinate(x);
int topology = topologyMap.GetTopology(x, z);
if ((topology & 8389632) != 0)
{
return;
}
float slope = TerrainMeta.HeightMap.GetSlope(normX, normZ);
float splat = TerrainMeta.SplatMap.GetSplat(normX, normZ, 8);
if ((double)slope > 40.0 || (double)splat > 0.400000005960464)
{
topologyMap.AddTopology(x, z, 2);
}
else
{
if (keepExisting || (double)slope >= 20.0 || ((double)splat >= 0.200000002980232 || (topology & 55296) == 0))
{
return;
}
topologyMap.RemoveTopology(x, z, 2);
}
}
public void AdjustTerrainHeight()
{
TerrainHeightMap heightMap = TerrainMeta.HeightMap;
TerrainTopologyMap topologyMap = TerrainMeta.TopologyMap;
float single6 = 1f;
float randomScale = this.RandomScale;
float outerPadding = this.OuterPadding;
float innerPadding = this.InnerPadding;
float outerFade = this.OuterFade;
float innerFade = this.InnerFade;
float terrainOffset = this.TerrainOffset * TerrainMeta.OneOverSize.y;
float width = this.Width * 0.5f;
Vector3 startPoint = this.Path.GetStartPoint();
Vector3 endPoint = this.Path.GetEndPoint();
Vector3 startTangent = this.Path.GetStartTangent();
Vector3 vector32 = PathList.rot90 * startTangent;
Vector3 vector33 = startPoint - (vector32 * (width + outerPadding + outerFade));
Vector3 vector34 = startPoint + (vector32 * (width + outerPadding + outerFade));
float length = this.Path.Length + single6;
for (float i = 0f; i < length; i += single6)
{
Vector3 vector35 = (this.Spline ? this.Path.GetPointCubicHermite(i) : this.Path.GetPoint(i));
float single7 = (startPoint - vector35).Magnitude2D();
float single8 = (endPoint - vector35).Magnitude2D();
float single9 = Mathf.InverseLerp(0f, width, Mathf.Min(single7, single8));
float single10 = Mathf.Lerp(width, width * randomScale, Noise.Billow(vector35.x, vector35.z, 2, 0.005f, 1f, 2f, 0.5f));
Vector3 vector36 = this.Path.GetTangent(i).XZ3D();
startTangent = vector36.normalized;
vector32 = PathList.rot90 * startTangent;
Ray ray = new Ray(vector35, startTangent);
Vector3 vector37 = vector35 - (vector32 * (single10 + outerPadding + outerFade));
Vector3 vector38 = vector35 + (vector32 * (single10 + outerPadding + outerFade));
float single11 = TerrainMeta.NormalizeY(vector35.y);
heightMap.ForEach(vector33, vector34, vector37, vector38, (int x, int z) => {
float single = heightMap.Coordinate(x);
float single1 = heightMap.Coordinate(z);
if ((topologyMap.GetTopology(single, single1) & this.Topology) != 0)
{
return;
}
Vector3 vector3 = TerrainMeta.Denormalize(new Vector3(single, single11, single1));
Vector3 vector31 = ray.ClosestPoint(vector3);
float single2 = (vector3 - vector31).Magnitude2D();
float single3 = Mathf.InverseLerp(single10 + outerPadding + outerFade, single10 + outerPadding, single2);
float single4 = Mathf.InverseLerp(single10 - innerPadding, single10 - innerPadding - innerFade, single2);
float single5 = TerrainMeta.NormalizeY(vector31.y);
single3 = Mathf.SmoothStep(0f, 1f, single3);
single4 = Mathf.SmoothStep(0f, 1f, single4);
heightMap.SetHeight(x, z, single5 + terrainOffset * single4, single9 * single3);
});
vector33 = vector37;
vector34 = vector38;
}
}
private bool TestPlacingCloseToRoad(ref Placement placement, Target target)
{
TerrainHeightMap heightMap = TerrainMeta.HeightMap;
TerrainTopologyMap topologyMap = TerrainMeta.TopologyMap;
if (heightMap == null)
{
return(true);
}
if (topologyMap == null)
{
return(true);
}
OBB oBB = new OBB(placement.position, Vector3.one, placement.rotation, bounds);
float num = Mathf.Abs(heightMap.GetHeight(oBB.position) - oBB.position.y);
if (num > 9f)
{
return(true);
}
float radius = Mathf.Lerp(3f, 0f, num / 9f);
Vector3 position = oBB.position;
Vector3 point = oBB.GetPoint(-1f, 0f, -1f);
Vector3 point2 = oBB.GetPoint(-1f, 0f, 1f);
Vector3 point3 = oBB.GetPoint(1f, 0f, -1f);
Vector3 point4 = oBB.GetPoint(1f, 0f, 1f);
int topology = topologyMap.GetTopology(position, radius);
int topology2 = topologyMap.GetTopology(point, radius);
int topology3 = topologyMap.GetTopology(point2, radius);
int topology4 = topologyMap.GetTopology(point3, radius);
int topology5 = topologyMap.GetTopology(point4, radius);
if (((topology | topology2 | topology3 | topology4 | topology5) & 0x800) == 0)
{
return(true);
}
return(false);
}
public override void Process(uint seed)
{
TerrainTopologyMap topologyMap = TerrainMeta.TopologyMap;
int num = topologyMap.res;
Parallel.For(0, num, (int z) => {
for (int i = 0; i < num; i++)
{
if (topologyMap.GetTopology(i, z, 4194306))
{
topologyMap.AddTopology(i, z, 512);
}
else if (!this.KeepExisting)
{
topologyMap.RemoveTopology(i, z, 512);
}
}
});
}
public static void Process(int x, int z)
{
TerrainTopologyMap topologyMap = TerrainMeta.TopologyMap;
float normZ = topologyMap.Coordinate(z);
float normX = topologyMap.Coordinate(x);
if ((topologyMap.GetTopology(x, z) & 0x800400) == 0)
{
float slope = TerrainMeta.HeightMap.GetSlope(normX, normZ);
float splat = TerrainMeta.SplatMap.GetSplat(normX, normZ, 8);
if (slope > 40f || splat > 0.4f)
{
topologyMap.AddTopology(x, z, 2);
}
else
{
topologyMap.RemoveTopology(x, z, 2);
}
}
}
public override void Process(uint seed)
{
TerrainTopologyMap topomap = TerrainMeta.TopologyMap;
int topores = topomap.res;
Parallel.For(0, topores, delegate(int z)
{
for (int i = 0; i < topores; i++)
{
if (topomap.GetTopology(i, z, 4194306))
{
topomap.AddTopology(i, z, 512);
}
else if (!KeepExisting)
{
topomap.RemoveTopology(i, z, 512);
}
}
});
}
public override void Process(uint seed)
{
TerrainTopologyMap topomap = TerrainMeta.TopologyMap;
int topores = topomap.res;
Parallel.For(0, topores, (Action <int>)(z =>
{
for (int x = 0; x < topores; ++x)
{
if (topomap.GetTopology(x, z, 4194306))
{
topomap.AddTopology(x, z, 512);
}
else if (!this.KeepExisting)
{
topomap.RemoveTopology(x, z, 512);
}
}
}));
}
private static void Process(int x, int z, bool keepExisting)
{
TerrainTopologyMap topologyMap = TerrainMeta.TopologyMap;
float normZ = topologyMap.Coordinate(z);
float normX = topologyMap.Coordinate(x);
int topology = topologyMap.GetTopology(x, z);
if (!World.Procedural || (topology & 0x800400) == 0)
{
float slope = TerrainMeta.HeightMap.GetSlope(normX, normZ);
float splat = TerrainMeta.SplatMap.GetSplat(normX, normZ, 8);
if (slope > 40f || splat > 0.4f)
{
topologyMap.AddTopology(x, z, 2);
}
else if (!keepExisting)
{
topologyMap.RemoveTopology(x, z, 2);
}
}
}
public static void Process(int x, int z)
{
TerrainTopologyMap topologyMap = TerrainMeta.TopologyMap;
float single = topologyMap.Coordinate(z);
float single1 = topologyMap.Coordinate(x);
if ((topologyMap.GetTopology(x, z) & 8389632) == 0)
{
float slope = TerrainMeta.HeightMap.GetSlope(single1, single);
float splat = TerrainMeta.SplatMap.GetSplat(single1, single, 8);
if (slope > 40f || splat > 0.4f)
{
topologyMap.AddTopology(x, z, 2);
return;
}
if (slope < 20f && splat < 0.2f)
{
topologyMap.RemoveTopology(x, z, 2);
}
}
}
private static void Process(int x, int z, bool keepExisting)
{
TerrainTopologyMap topologyMap = TerrainMeta.TopologyMap;
float single = topologyMap.Coordinate(z);
float single1 = topologyMap.Coordinate(x);
int topology = topologyMap.GetTopology(x, z);
if ((topology & 8389632) == 0)
{
float slope = TerrainMeta.HeightMap.GetSlope(single1, single);
float splat = TerrainMeta.SplatMap.GetSplat(single1, single, 8);
if (slope > 40f || splat > 0.4f)
{
topologyMap.AddTopology(x, z, 2);
return;
}
if (!keepExisting && slope < 20f && splat < 0.2f && (topology & 55296) != 0)
{
topologyMap.RemoveTopology(x, z, 2);
}
}
}
public override void Process(uint seed)
{
List <PathList> pathLists = new List <PathList>();
TerrainHeightMap heightMap = TerrainMeta.HeightMap;
TerrainTopologyMap topologyMap = TerrainMeta.TopologyMap;
List <MonumentInfo> monuments = TerrainMeta.Path.Monuments;
if (monuments.Count == 0)
{
return;
}
int num = Mathf.NextPowerOfTwo((int)((float)((float)World.Size) / 10f));
int[,] numArray = new int[num, num];
float single = 5f;
for (int i = 0; i < num; i++)
{
float single1 = ((float)i + 0.5f) / (float)num;
for (int j = 0; j < num; j++)
{
float single2 = ((float)j + 0.5f) / (float)num;
int num1 = SeedRandom.Range(ref seed, 100, 500);
float slope = heightMap.GetSlope(single2, single1);
int topology = topologyMap.GetTopology(single2, single1, single);
int num2 = 2295686;
int num3 = 49152;
if (slope > 20f || (topology & num2) != 0)
{
numArray[i, j] = 2147483647;
}
else if ((topology & num3) == 0)
{
numArray[i, j] = 1 + (int)(slope * slope * 10f) + num1;
}
else
{
numArray[i, j] = 2500;
}
}
}
PathFinder pathFinder = new PathFinder(numArray, true);
List <GenerateRoadLayout.PathSegment> pathSegments = new List <GenerateRoadLayout.PathSegment>();
List <GenerateRoadLayout.PathNode> pathNodes = new List <GenerateRoadLayout.PathNode>();
List <GenerateRoadLayout.PathNode> pathNodes1 = new List <GenerateRoadLayout.PathNode>();
List <PathFinder.Point> points = new List <PathFinder.Point>();
List <PathFinder.Point> points1 = new List <PathFinder.Point>();
List <PathFinder.Point> points2 = new List <PathFinder.Point>();
foreach (MonumentInfo monument in monuments)
{
bool count = pathNodes.Count == 0;
foreach (TerrainPathConnect target in monument.GetTargets(InfrastructureType.Road))
{
PathFinder.Node node = pathFinder.FindClosestWalkable(target.GetPoint(num), 100000);
if (node == null)
{
continue;
}
GenerateRoadLayout.PathNode pathNode = new GenerateRoadLayout.PathNode()
{
monument = monument,
target = target,
node = node
};
if (!count)
{
pathNodes1.Add(pathNode);
}
else
{
pathNodes.Add(pathNode);
}
}
}
while (pathNodes1.Count != 0)
{
points1.Clear();
points2.Clear();
points1.AddRange(
from x in pathNodes
select x.node.point);
points1.AddRange(points);
points2.AddRange(
from x in pathNodes1
select x.node.point);
PathFinder.Node node1 = pathFinder.FindPathUndirected(points1, points2, 100000);
if (node1 != null)
{
GenerateRoadLayout.PathSegment pathSegment = new GenerateRoadLayout.PathSegment();
for (PathFinder.Node k = node1; k != null; k = k.next)
{
if (k == node1)
{
pathSegment.start = k;
}
if (k.next == null)
{
pathSegment.end = k;
}
}
pathSegments.Add(pathSegment);
GenerateRoadLayout.PathNode pathNode1 = pathNodes1.Find((GenerateRoadLayout.PathNode x) => {
if (x.node.point == pathSegment.start.point)
{
return(true);
}
return(x.node.point == pathSegment.end.point);
});
pathNodes.AddRange(
from x in pathNodes1
where x.monument == pathNode1.monument
select x);
pathNodes1.RemoveAll((GenerateRoadLayout.PathNode x) => x.monument == pathNode1.monument);
int num4 = 1;
for (PathFinder.Node l = node1; l != null; l = l.next)
{
if (num4 % 8 == 0)
{
points.Add(l.point);
}
num4++;
}
}
else
{
GenerateRoadLayout.PathNode item = pathNodes1[0];
pathNodes.AddRange(
from x in pathNodes1
where x.monument == item.monument
select x);
pathNodes1.RemoveAll((GenerateRoadLayout.PathNode x) => x.monument == item.monument);
}
}
foreach (GenerateRoadLayout.PathNode pathNode2 in pathNodes)
{
GenerateRoadLayout.PathSegment pathSegment1 = pathSegments.Find((GenerateRoadLayout.PathSegment x) => {
if (x.start.point == pathNode2.node.point)
{
return(true);
}
return(x.end.point == pathNode2.node.point);
});
if (pathSegment1 == null)
{
continue;
}
if (pathSegment1.start.point != pathNode2.node.point)
{
if (pathSegment1.end.point != pathNode2.node.point)
{
continue;
}
pathSegment1.end.next = pathNode2.node;
pathSegment1.end = pathFinder.FindEnd(pathNode2.node);
pathSegment1.target = pathNode2.target;
}
else
{
PathFinder.Node node2 = pathNode2.node;
PathFinder.Node node3 = pathFinder.Reverse(pathNode2.node);
node2.next = pathSegment1.start;
pathSegment1.start = node3;
pathSegment1.origin = pathNode2.target;
}
}
List <Vector3> vector3s = new List <Vector3>();
foreach (GenerateRoadLayout.PathSegment pathSegment2 in pathSegments)
{
bool flag = false;
bool flag1 = false;
for (PathFinder.Node m = pathSegment2.start; m != null; m = m.next)
{
float single3 = ((float)m.point.x + 0.5f) / (float)num;
float single4 = ((float)m.point.y + 0.5f) / (float)num;
if (pathSegment2.start == m && pathSegment2.origin != null)
{
flag = true;
single3 = TerrainMeta.NormalizeX(pathSegment2.origin.transform.position.x);
single4 = TerrainMeta.NormalizeZ(pathSegment2.origin.transform.position.z);
}
else if (pathSegment2.end == m && pathSegment2.target != null)
{
flag1 = true;
single3 = TerrainMeta.NormalizeX(pathSegment2.target.transform.position.x);
single4 = TerrainMeta.NormalizeZ(pathSegment2.target.transform.position.z);
}
float single5 = TerrainMeta.DenormalizeX(single3);
float single6 = TerrainMeta.DenormalizeZ(single4);
float single7 = Mathf.Max(heightMap.GetHeight(single3, single4), 1f);
vector3s.Add(new Vector3(single5, single7, single6));
}
if (vector3s.Count == 0)
{
continue;
}
if (vector3s.Count >= 2)
{
PathList pathList = new PathList(string.Concat("Road ", pathLists.Count), vector3s.ToArray())
{
Width = 10f,
InnerPadding = 1f,
OuterPadding = 1f,
InnerFade = 1f,
OuterFade = 8f,
RandomScale = 0.75f,
MeshOffset = 0f,
TerrainOffset = -0.5f,
Topology = 2048,
Splat = 128,
Start = flag,
End = flag1
};
pathLists.Add(pathList);
}
vector3s.Clear();
}
foreach (PathList pathList1 in pathLists)
{
pathList1.Path.Smoothen(2);
}
TerrainMeta.Path.Roads.AddRange(pathLists);
}
public override void Process(uint seed)
{
if (World.Networked)
{
TerrainMeta.Path.Rivers.Clear();
TerrainMeta.Path.Rivers.AddRange(World.GetPaths("River"));
return;
}
List <PathList> list = new List <PathList>();
TerrainHeightMap heightMap = TerrainMeta.HeightMap;
TerrainTopologyMap topologyMap = TerrainMeta.TopologyMap;
List <Vector3> list2 = new List <Vector3>();
for (float num = TerrainMeta.Position.z; num < TerrainMeta.Position.z + TerrainMeta.Size.z; num += 50f)
{
for (float num2 = TerrainMeta.Position.x; num2 < TerrainMeta.Position.x + TerrainMeta.Size.x; num2 += 50f)
{
Vector3 vector = new Vector3(num2, 0f, num);
float num3 = (vector.y = heightMap.GetHeight(vector));
if (vector.y <= 5f)
{
continue;
}
Vector3 normal = heightMap.GetNormal(vector);
if (normal.y <= 0.01f)
{
continue;
}
Vector2 normalized = new Vector2(normal.x, normal.z).normalized;
list2.Add(vector);
float radius = 18f;
int num4 = 18;
for (int i = 0; i < 10000; i++)
{
vector.x += normalized.x;
vector.z += normalized.y;
if (heightMap.GetSlope(vector) > 30f)
{
break;
}
float height = heightMap.GetHeight(vector);
if (height > num3 + 10f)
{
break;
}
float num5 = Mathf.Min(height, num3);
vector.y = Mathf.Lerp(vector.y, num5, 0.15f);
int topology = topologyMap.GetTopology(vector, radius);
int topology2 = topologyMap.GetTopology(vector);
int num6 = 2694148;
int num7 = 128;
if ((topology & num6) != 0)
{
list2.Add(vector);
break;
}
if ((topology2 & num7) != 0 && --num4 <= 0)
{
list2.Add(vector);
if (list2.Count >= 25)
{
int num8 = TerrainMeta.Path.Rivers.Count + list.Count;
PathList pathList = new PathList("River " + num8, list2.ToArray());
pathList.Width = 36f;
pathList.InnerPadding = 1f;
pathList.OuterPadding = 1f;
pathList.InnerFade = 10f;
pathList.OuterFade = 20f;
pathList.RandomScale = 0.75f;
pathList.MeshOffset = -0.5f;
pathList.TerrainOffset = -1.5f;
pathList.Topology = 16384;
pathList.Splat = 64;
pathList.Start = true;
pathList.End = true;
list.Add(pathList);
}
break;
}
if (i % 12 == 0)
{
list2.Add(vector);
}
normal = heightMap.GetNormal(vector);
normalized = new Vector2(normalized.x + 0.15f * normal.x, normalized.y + 0.15f * normal.z).normalized;
num3 = num5;
}
list2.Clear();
}
}
list.Sort((PathList a, PathList b) => b.Path.Points.Length.CompareTo(a.Path.Points.Length));
int num9 = Mathf.RoundToInt(10f * TerrainMeta.Size.x * TerrainMeta.Size.z * 1E-06f);
int num10 = Mathf.NextPowerOfTwo((int)((float)World.Size / 36f));
bool[,] array = new bool[num10, num10];
for (int j = 0; j < list.Count; j++)
{
if (j >= num9)
{
list.RemoveUnordered(j--);
continue;
}
PathList pathList2 = list[j];
bool flag = false;
for (int k = 0; k < j; k++)
{
if (Vector3.Distance(list[k].Path.GetStartPoint(), pathList2.Path.GetStartPoint()) < 100f)
{
list.RemoveUnordered(j--);
flag = true;
break;
}
}
if (flag)
{
continue;
}
int num11 = -1;
int num12 = -1;
for (int l = 0; l < pathList2.Path.Points.Length; l++)
{
Vector3 vector2 = pathList2.Path.Points[l];
int num13 = Mathf.Clamp((int)(TerrainMeta.NormalizeX(vector2.x) * (float)num10), 0, num10 - 1);
int num14 = Mathf.Clamp((int)(TerrainMeta.NormalizeZ(vector2.z) * (float)num10), 0, num10 - 1);
if (num11 == num13 && num12 == num14)
{
continue;
}
if (array[num14, num13])
{
list.RemoveUnordered(j--);
flag = true;
break;
}
if (num11 != num13 && num12 != num14)
{
if (num11 != -1)
{
array[num14, num11] = true;
}
if (num12 != -1)
{
array[num12, num13] = true;
}
num11 = num13;
num12 = num14;
array[num14, num13] = true;
}
else
{
num11 = num13;
num12 = num14;
array[num14, num13] = true;
}
}
}
for (int m = 0; m < list.Count; m++)
{
list[m].Name = "River " + (TerrainMeta.Path.Rivers.Count + m);
}
foreach (PathList item in list)
{
item.Path.Smoothen(4);
item.Path.RecalculateTangents();
}
TerrainMeta.Path.Rivers.AddRange(list);
}
public override void Process(uint seed)
{
List <PathList> pathLists = new List <PathList>();
TerrainHeightMap heightMap = TerrainMeta.HeightMap;
TerrainTopologyMap topologyMap = TerrainMeta.TopologyMap;
List <Vector3> vector3s = new List <Vector3>();
for (float i = TerrainMeta.Position.z; i < TerrainMeta.Position.z + TerrainMeta.Size.z; i += 50f)
{
for (float j = TerrainMeta.Position.x; j < TerrainMeta.Position.x + TerrainMeta.Size.x; j += 50f)
{
Vector3 vector3 = new Vector3(j, 0f, i);
float height = heightMap.GetHeight(vector3);
float single = height;
vector3.y = height;
float single1 = single;
if (vector3.y > 5f)
{
Vector3 normal = heightMap.GetNormal(vector3);
if (normal.y > 0.01f)
{
Vector2 vector2 = new Vector2(normal.x, normal.z);
Vector2 vector21 = vector2.normalized;
vector3s.Add(vector3);
float single2 = 12f;
int num = 12;
for (int k = 0; k < 10000; k++)
{
vector3.x += vector21.x;
vector3.z += vector21.y;
if (heightMap.GetSlope(vector3) > 30f)
{
break;
}
float height1 = heightMap.GetHeight(vector3);
if (height1 > single1 + 10f)
{
break;
}
vector3.y = Mathf.Min(height1, single1);
vector3s.Add(vector3);
int topology = topologyMap.GetTopology(vector3, single2);
int topology1 = topologyMap.GetTopology(vector3);
int num1 = 2694148;
int num2 = 128;
if ((topology & num1) != 0)
{
break;
}
if ((topology1 & num2) != 0)
{
int num3 = num - 1;
num = num3;
if (num3 <= 0)
{
if (vector3s.Count < 300)
{
break;
}
PathList pathList = new PathList(string.Concat("River ", pathLists.Count), vector3s.ToArray())
{
Width = 24f,
InnerPadding = 0.5f,
OuterPadding = 0.5f,
InnerFade = 8f,
OuterFade = 16f,
RandomScale = 0.75f,
MeshOffset = -0.4f,
TerrainOffset = -2f,
Topology = 16384,
Splat = 64,
Start = true,
End = true
};
pathLists.Add(pathList);
break;
}
}
normal = heightMap.GetNormal(vector3);
vector2 = new Vector2(vector21.x + 0.15f * normal.x, vector21.y + 0.15f * normal.z);
vector21 = vector2.normalized;
single1 = vector3.y;
}
vector3s.Clear();
}
}
}
}
pathLists.Sort((PathList a, PathList b) => ((int)b.Path.Points.Length).CompareTo((int)a.Path.Points.Length));
int num4 = Mathf.RoundToInt(10f * TerrainMeta.Size.x * TerrainMeta.Size.z * 1E-06f);
int num5 = Mathf.NextPowerOfTwo((int)((float)((float)World.Size) / 24f));
bool[,] flagArray = new bool[num5, num5];
for (int l = 0; l < pathLists.Count; l++)
{
if (l < num4)
{
PathList item = pathLists[l];
for (int m = 0; m < l; m++)
{
if (Vector3.Distance(pathLists[m].Path.GetStartPoint(), item.Path.GetStartPoint()) < 100f)
{
int num6 = l;
l = num6 - 1;
pathLists.RemoveUnordered <PathList>(num6);
}
}
int num7 = -1;
int num8 = -1;
for (int n = 0; n < (int)item.Path.Points.Length; n++)
{
Vector3 points = item.Path.Points[n];
int num9 = Mathf.Clamp((int)(TerrainMeta.NormalizeX(points.x) * (float)num5), 0, num5 - 1);
int num10 = Mathf.Clamp((int)(TerrainMeta.NormalizeZ(points.z) * (float)num5), 0, num5 - 1);
if (num7 != num9 || num8 != num10)
{
if (!flagArray[num10, num9])
{
num7 = num9;
num8 = num10;
flagArray[num10, num9] = true;
}
else
{
int num11 = l;
l = num11 - 1;
pathLists.RemoveUnordered <PathList>(num11);
break;
}
}
}
}
else
{
int num12 = l;
l = num12 - 1;
pathLists.RemoveUnordered <PathList>(num12);
}
}
TerrainMeta.Path.Rivers.AddRange(pathLists);
}
public override void Process(uint seed)
{
List <PathList> pathListList = new List <PathList>();
TerrainHeightMap heightMap = TerrainMeta.HeightMap;
TerrainTopologyMap topologyMap = TerrainMeta.TopologyMap;
List <MonumentInfo> monuments = TerrainMeta.Path.Monuments;
if (monuments.Count == 0)
{
return;
}
int res = Mathf.NextPowerOfTwo((int)((double)World.Size / 10.0));
int[,] costmap = new int[res, res];
float radius = 5f;
for (int index1 = 0; index1 < res; ++index1)
{
float normZ = ((float)index1 + 0.5f) / (float)res;
for (int index2 = 0; index2 < res; ++index2)
{
float normX = ((float)index2 + 0.5f) / (float)res;
float slope = heightMap.GetSlope(normX, normZ);
int topology = topologyMap.GetTopology(normX, normZ, radius);
int num1 = 2295174;
int num2 = 55296;
int num3 = 512;
costmap[index1, index2] = (topology & num1) == 0 ? ((topology & num2) == 0 ? ((topology & num3) == 0 ? 1 + (int)((double)slope * (double)slope * 10.0) : 1000) : 2500) : int.MaxValue;
}
}
PathFinder pathFinder = new PathFinder(costmap, true);
List <GeneratePowerlineLayout.PathSegment> pathSegmentList = new List <GeneratePowerlineLayout.PathSegment>();
List <GeneratePowerlineLayout.PathNode> source1 = new List <GeneratePowerlineLayout.PathNode>();
List <GeneratePowerlineLayout.PathNode> source2 = new List <GeneratePowerlineLayout.PathNode>();
List <PathFinder.Point> pointList = new List <PathFinder.Point>();
List <PathFinder.Point> startList = new List <PathFinder.Point>();
List <PathFinder.Point> endList = new List <PathFinder.Point>();
foreach (MonumentInfo monumentInfo in monuments)
{
bool flag = source1.Count == 0;
foreach (TerrainPathConnect target in monumentInfo.GetTargets(InfrastructureType.Power))
{
PathFinder.Point point = target.GetPoint(res);
PathFinder.Node closestWalkable = pathFinder.FindClosestWalkable(point, 100000);
if (closestWalkable != null)
{
GeneratePowerlineLayout.PathNode pathNode = new GeneratePowerlineLayout.PathNode();
pathNode.monument = monumentInfo;
pathNode.node = closestWalkable;
if (flag)
{
source1.Add(pathNode);
}
else
{
source2.Add(pathNode);
}
}
}
}
while (source2.Count != 0)
{
startList.Clear();
endList.Clear();
startList.AddRange(source1.Select <GeneratePowerlineLayout.PathNode, PathFinder.Point>((Func <GeneratePowerlineLayout.PathNode, PathFinder.Point>)(x => x.node.point)));
startList.AddRange((IEnumerable <PathFinder.Point>)pointList);
endList.AddRange(source2.Select <GeneratePowerlineLayout.PathNode, PathFinder.Point>((Func <GeneratePowerlineLayout.PathNode, PathFinder.Point>)(x => x.node.point)));
PathFinder.Node pathUndirected = pathFinder.FindPathUndirected(startList, endList, 100000);
if (pathUndirected == null)
{
GeneratePowerlineLayout.PathNode copy = source2[0];
source1.AddRange(source2.Where <GeneratePowerlineLayout.PathNode>((Func <GeneratePowerlineLayout.PathNode, bool>)(x => Object.op_Equality((Object)x.monument, (Object)copy.monument))));
source2.RemoveAll((Predicate <GeneratePowerlineLayout.PathNode>)(x => Object.op_Equality((Object)x.monument, (Object)copy.monument)));
}
else
{
GeneratePowerlineLayout.PathSegment segment = new GeneratePowerlineLayout.PathSegment();
for (PathFinder.Node node = pathUndirected; node != null; node = node.next)
{
if (node == pathUndirected)
{
segment.start = node;
}
if (node.next == null)
{
segment.end = node;
}
}
pathSegmentList.Add(segment);
GeneratePowerlineLayout.PathNode copy = source2.Find((Predicate <GeneratePowerlineLayout.PathNode>)(x =>
{
if (!(x.node.point == segment.start.point))
{
return(x.node.point == segment.end.point);
}
return(true);
}));
source1.AddRange(source2.Where <GeneratePowerlineLayout.PathNode>((Func <GeneratePowerlineLayout.PathNode, bool>)(x => Object.op_Equality((Object)x.monument, (Object)copy.monument))));
source2.RemoveAll((Predicate <GeneratePowerlineLayout.PathNode>)(x => Object.op_Equality((Object)x.monument, (Object)copy.monument)));
int num = 1;
for (PathFinder.Node node = pathUndirected; node != null; node = node.next)
{
if (num % 8 == 0)
{
pointList.Add(node.point);
}
++num;
}
}
}
List <Vector3> vector3List = new List <Vector3>();
foreach (GeneratePowerlineLayout.PathSegment pathSegment in pathSegmentList)
{
for (PathFinder.Node node = pathSegment.start; node != null; node = node.next)
{
float normX = ((float)node.point.x + 0.5f) / (float)res;
float normZ = ((float)node.point.y + 0.5f) / (float)res;
float height01 = heightMap.GetHeight01(normX, normZ);
vector3List.Add(TerrainMeta.Denormalize(new Vector3(normX, height01, normZ)));
}
if (vector3List.Count != 0)
{
if (vector3List.Count >= 8)
{
pathListList.Add(new PathList("Powerline " + (object)pathListList.Count, vector3List.ToArray())
{
Start = true,
End = true
});
}
vector3List.Clear();
}
}
TerrainMeta.Path.Powerlines.AddRange((IEnumerable <PathList>)pathListList);
}
public override void Process(uint seed)
{
List <PathList> pathListList = new List <PathList>();
TerrainHeightMap heightMap = TerrainMeta.HeightMap;
TerrainTopologyMap topologyMap = TerrainMeta.TopologyMap;
List <MonumentInfo> monuments = TerrainMeta.Path.Monuments;
if (monuments.Count == 0)
{
return;
}
int res = Mathf.NextPowerOfTwo((int)((double)World.Size / 10.0));
int[,] costmap = new int[res, res];
float radius = 5f;
for (int index1 = 0; index1 < res; ++index1)
{
float normZ = ((float)index1 + 0.5f) / (float)res;
for (int index2 = 0; index2 < res; ++index2)
{
float normX = ((float)index2 + 0.5f) / (float)res;
int num1 = SeedRandom.Range(ref seed, 100, 500);
float slope = heightMap.GetSlope(normX, normZ);
int topology = topologyMap.GetTopology(normX, normZ, radius);
int num2 = 2295686;
int num3 = 49152;
costmap[index1, index2] = (double)slope > 20.0 || (topology & num2) != 0 ? int.MaxValue : ((topology & num3) == 0 ? 1 + (int)((double)slope * (double)slope * 10.0) + num1 : 2500);
}
}
PathFinder pathFinder = new PathFinder(costmap, true);
List <GenerateRoadLayout.PathSegment> pathSegmentList = new List <GenerateRoadLayout.PathSegment>();
List <GenerateRoadLayout.PathNode> source1 = new List <GenerateRoadLayout.PathNode>();
List <GenerateRoadLayout.PathNode> source2 = new List <GenerateRoadLayout.PathNode>();
List <PathFinder.Point> pointList = new List <PathFinder.Point>();
List <PathFinder.Point> startList = new List <PathFinder.Point>();
List <PathFinder.Point> endList = new List <PathFinder.Point>();
foreach (MonumentInfo monumentInfo in monuments)
{
bool flag = source1.Count == 0;
foreach (TerrainPathConnect target in monumentInfo.GetTargets(InfrastructureType.Road))
{
PathFinder.Point point = target.GetPoint(res);
PathFinder.Node closestWalkable = pathFinder.FindClosestWalkable(point, 100000);
if (closestWalkable != null)
{
GenerateRoadLayout.PathNode pathNode = new GenerateRoadLayout.PathNode();
pathNode.monument = monumentInfo;
pathNode.target = target;
pathNode.node = closestWalkable;
if (flag)
{
source1.Add(pathNode);
}
else
{
source2.Add(pathNode);
}
}
}
}
while (source2.Count != 0)
{
startList.Clear();
endList.Clear();
startList.AddRange(source1.Select <GenerateRoadLayout.PathNode, PathFinder.Point>((Func <GenerateRoadLayout.PathNode, PathFinder.Point>)(x => x.node.point)));
startList.AddRange((IEnumerable <PathFinder.Point>)pointList);
endList.AddRange(source2.Select <GenerateRoadLayout.PathNode, PathFinder.Point>((Func <GenerateRoadLayout.PathNode, PathFinder.Point>)(x => x.node.point)));
PathFinder.Node pathUndirected = pathFinder.FindPathUndirected(startList, endList, 100000);
if (pathUndirected == null)
{
GenerateRoadLayout.PathNode copy = source2[0];
source1.AddRange(source2.Where <GenerateRoadLayout.PathNode>((Func <GenerateRoadLayout.PathNode, bool>)(x => Object.op_Equality((Object)x.monument, (Object)copy.monument))));
source2.RemoveAll((Predicate <GenerateRoadLayout.PathNode>)(x => Object.op_Equality((Object)x.monument, (Object)copy.monument)));
}
else
{
GenerateRoadLayout.PathSegment segment = new GenerateRoadLayout.PathSegment();
for (PathFinder.Node node = pathUndirected; node != null; node = node.next)
{
if (node == pathUndirected)
{
segment.start = node;
}
if (node.next == null)
{
segment.end = node;
}
}
pathSegmentList.Add(segment);
GenerateRoadLayout.PathNode copy = source2.Find((Predicate <GenerateRoadLayout.PathNode>)(x =>
{
if (!(x.node.point == segment.start.point))
{
return(x.node.point == segment.end.point);
}
return(true);
}));
source1.AddRange(source2.Where <GenerateRoadLayout.PathNode>((Func <GenerateRoadLayout.PathNode, bool>)(x => Object.op_Equality((Object)x.monument, (Object)copy.monument))));
source2.RemoveAll((Predicate <GenerateRoadLayout.PathNode>)(x => Object.op_Equality((Object)x.monument, (Object)copy.monument)));
int num = 1;
for (PathFinder.Node node = pathUndirected; node != null; node = node.next)
{
if (num % 8 == 0)
{
pointList.Add(node.point);
}
++num;
}
}
}
foreach (GenerateRoadLayout.PathNode pathNode in source1)
{
GenerateRoadLayout.PathNode target = pathNode;
GenerateRoadLayout.PathSegment pathSegment = pathSegmentList.Find((Predicate <GenerateRoadLayout.PathSegment>)(x =>
{
if (!(x.start.point == target.node.point))
{
return(x.end.point == target.node.point);
}
return(true);
}));
if (pathSegment != null)
{
if (pathSegment.start.point == target.node.point)
{
PathFinder.Node node1 = target.node;
PathFinder.Node node2 = pathFinder.Reverse(target.node);
PathFinder.Node start = pathSegment.start;
node1.next = start;
pathSegment.start = node2;
pathSegment.origin = target.target;
}
else if (pathSegment.end.point == target.node.point)
{
pathSegment.end.next = target.node;
pathSegment.end = pathFinder.FindEnd(target.node);
pathSegment.target = target.target;
}
}
}
List <Vector3> vector3List = new List <Vector3>();
foreach (GenerateRoadLayout.PathSegment pathSegment in pathSegmentList)
{
bool flag1 = false;
bool flag2 = false;
for (PathFinder.Node node = pathSegment.start; node != null; node = node.next)
{
float normX = ((float)node.point.x + 0.5f) / (float)res;
float normZ = ((float)node.point.y + 0.5f) / (float)res;
if (pathSegment.start == node && Object.op_Inequality((Object)pathSegment.origin, (Object)null))
{
flag1 = true;
normX = TerrainMeta.NormalizeX((float)((Component)pathSegment.origin).get_transform().get_position().x);
normZ = TerrainMeta.NormalizeZ((float)((Component)pathSegment.origin).get_transform().get_position().z);
}
else if (pathSegment.end == node && Object.op_Inequality((Object)pathSegment.target, (Object)null))
{
flag2 = true;
normX = TerrainMeta.NormalizeX((float)((Component)pathSegment.target).get_transform().get_position().x);
normZ = TerrainMeta.NormalizeZ((float)((Component)pathSegment.target).get_transform().get_position().z);
}
float num1 = TerrainMeta.DenormalizeX(normX);
float num2 = TerrainMeta.DenormalizeZ(normZ);
float num3 = Mathf.Max(heightMap.GetHeight(normX, normZ), 1f);
vector3List.Add(new Vector3(num1, num3, num2));
}
if (vector3List.Count != 0)
{
if (vector3List.Count >= 2)
{
pathListList.Add(new PathList("Road " + (object)pathListList.Count, vector3List.ToArray())
{
Width = 10f,
InnerPadding = 1f,
OuterPadding = 1f,
InnerFade = 1f,
OuterFade = 8f,
RandomScale = 0.75f,
MeshOffset = -0.0f,
TerrainOffset = -0.5f,
Topology = 2048,
Splat = 128,
Start = flag1,
End = flag2
});
}
vector3List.Clear();
}
}
foreach (PathList pathList in pathListList)
{
pathList.Path.Smoothen(2);
}
TerrainMeta.Path.Roads.AddRange((IEnumerable <PathList>)pathListList);
}
public override void Process(uint seed)
{
List <PathList> pathLists = new List <PathList>();
TerrainHeightMap heightMap = TerrainMeta.HeightMap;
TerrainTopologyMap topologyMap = TerrainMeta.TopologyMap;
List <MonumentInfo> monuments = TerrainMeta.Path.Monuments;
if (monuments.Count == 0)
{
return;
}
int num = Mathf.NextPowerOfTwo((int)((float)((float)World.Size) / 10f));
int[,] numArray = new int[num, num];
float single = 5f;
for (int i = 0; i < num; i++)
{
float single1 = ((float)i + 0.5f) / (float)num;
for (int j = 0; j < num; j++)
{
float single2 = ((float)j + 0.5f) / (float)num;
float slope = heightMap.GetSlope(single2, single1);
int topology = topologyMap.GetTopology(single2, single1, single);
int num1 = 2295174;
int num2 = 55296;
int num3 = 512;
if ((topology & num1) != 0)
{
numArray[i, j] = 2147483647;
}
else if ((topology & num2) != 0)
{
numArray[i, j] = 2500;
}
else if ((topology & num3) == 0)
{
numArray[i, j] = 1 + (int)(slope * slope * 10f);
}
else
{
numArray[i, j] = 1000;
}
}
}
PathFinder pathFinder = new PathFinder(numArray, true);
List <GeneratePowerlineLayout.PathSegment> pathSegments = new List <GeneratePowerlineLayout.PathSegment>();
List <GeneratePowerlineLayout.PathNode> pathNodes = new List <GeneratePowerlineLayout.PathNode>();
List <GeneratePowerlineLayout.PathNode> pathNodes1 = new List <GeneratePowerlineLayout.PathNode>();
List <PathFinder.Point> points = new List <PathFinder.Point>();
List <PathFinder.Point> points1 = new List <PathFinder.Point>();
List <PathFinder.Point> points2 = new List <PathFinder.Point>();
foreach (MonumentInfo monument in monuments)
{
bool count = pathNodes.Count == 0;
foreach (TerrainPathConnect target in monument.GetTargets(InfrastructureType.Power))
{
PathFinder.Point point = target.GetPoint(num);
PathFinder.Node node = pathFinder.FindClosestWalkable(point, 100000);
if (node == null)
{
continue;
}
GeneratePowerlineLayout.PathNode pathNode = new GeneratePowerlineLayout.PathNode()
{
monument = monument,
node = node
};
if (!count)
{
pathNodes1.Add(pathNode);
}
else
{
pathNodes.Add(pathNode);
}
}
}
while (pathNodes1.Count != 0)
{
points1.Clear();
points2.Clear();
points1.AddRange(
from x in pathNodes
select x.node.point);
points1.AddRange(points);
points2.AddRange(
from x in pathNodes1
select x.node.point);
PathFinder.Node node1 = pathFinder.FindPathUndirected(points1, points2, 100000);
if (node1 != null)
{
GeneratePowerlineLayout.PathSegment pathSegment = new GeneratePowerlineLayout.PathSegment();
for (PathFinder.Node k = node1; k != null; k = k.next)
{
if (k == node1)
{
pathSegment.start = k;
}
if (k.next == null)
{
pathSegment.end = k;
}
}
pathSegments.Add(pathSegment);
GeneratePowerlineLayout.PathNode pathNode1 = pathNodes1.Find((GeneratePowerlineLayout.PathNode x) => {
if (x.node.point == pathSegment.start.point)
{
return(true);
}
return(x.node.point == pathSegment.end.point);
});
pathNodes.AddRange(
from x in pathNodes1
where x.monument == pathNode1.monument
select x);
pathNodes1.RemoveAll((GeneratePowerlineLayout.PathNode x) => x.monument == pathNode1.monument);
int num4 = 1;
for (PathFinder.Node l = node1; l != null; l = l.next)
{
if (num4 % 8 == 0)
{
points.Add(l.point);
}
num4++;
}
}
else
{
GeneratePowerlineLayout.PathNode item = pathNodes1[0];
pathNodes.AddRange(
from x in pathNodes1
where x.monument == item.monument
select x);
pathNodes1.RemoveAll((GeneratePowerlineLayout.PathNode x) => x.monument == item.monument);
}
}
List <Vector3> vector3s = new List <Vector3>();
foreach (GeneratePowerlineLayout.PathSegment pathSegment1 in pathSegments)
{
for (PathFinder.Node m = pathSegment1.start; m != null; m = m.next)
{
float single3 = ((float)m.point.x + 0.5f) / (float)num;
float single4 = ((float)m.point.y + 0.5f) / (float)num;
float height01 = heightMap.GetHeight01(single3, single4);
vector3s.Add(TerrainMeta.Denormalize(new Vector3(single3, height01, single4)));
}
if (vector3s.Count == 0)
{
continue;
}
if (vector3s.Count >= 8)
{
PathList pathList = new PathList(string.Concat("Powerline ", pathLists.Count), vector3s.ToArray())
{
Start = true,
End = true
};
pathLists.Add(pathList);
}
vector3s.Clear();
}
TerrainMeta.Path.Powerlines.AddRange(pathLists);
}