public static void GaussianBlur2D(float[] data, int len1, int len2, int iterations = 1)
{
float[] singleArray = data;
float[] singleArray1 = new float[len1 * len2];
for (int i = 0; i < iterations; i++)
{
for (int j = 0; j < len1; j++)
{
int num = Mathf.Max(0, j - 1);
int num1 = Mathf.Min(len1 - 1, j + 1);
for (int k = 0; k < len2; k++)
{
int num2 = Mathf.Max(0, k - 1);
int num3 = Mathf.Min(len2 - 1, k + 1);
float single = singleArray[j * len2 + k] * 4f + singleArray[j * len2 + num2] + singleArray[j * len2 + num3] + singleArray[num * len2 + k] + singleArray[num1 * len2 + k];
singleArray1[j * len2 + k] = single * 0.125f;
}
}
GenericsUtil.Swap <float[]>(ref singleArray, ref singleArray1);
}
if (singleArray != data)
{
Buffer.BlockCopy(singleArray, 0, data, 0, (int)data.Length * 4);
}
}
public static void Average2D(float[] data, int len1, int len2, int len3, int iterations = 1)
{
float[] src = data;
float[] dst = new float[len1 * len2 * len3];
for (int i = 0; i < iterations; i++)
{
Parallel.For(0, len1, delegate(int x)
{
int num = Mathf.Max(0, x - 1);
int num2 = Mathf.Min(len1 - 1, x + 1);
for (int j = 0; j < len2; j++)
{
int num3 = Mathf.Max(0, j - 1);
int num4 = Mathf.Min(len2 - 1, j + 1);
for (int k = 0; k < len3; k++)
{
float num5 = src[(x * len2 + j) * len3 + k] + src[(x * len2 + num3) * len3 + k] + src[(x * len2 + num4) * len3 + k] + src[(num * len2 + j) * len3 + k] + src[(num2 * len2 + j) * len3 + k];
dst[(x * len2 + j) * len3 + k] = num5 * 0.2f;
}
}
});
GenericsUtil.Swap(ref src, ref dst);
}
if (src != data)
{
Buffer.BlockCopy(src, 0, data, 0, data.Length * 4);
}
}
public static void Average2D(float[] data, int len1, int len2, int iterations = 1)
{
Action <int> action = null;
float[] singleArray = new float[len1 * len2];
for (int i1 = 0; i1 < iterations; i1++)
{
int num4 = len1;
Action <int> action1 = action;
if (action1 == null)
{
Action <int> action2 = (int x) => {
int num = Mathf.Max(0, x - 1);
int num1 = Mathf.Min(len1 - 1, x + 1);
for (int i = 0; i < len2; i++)
{
int num2 = Mathf.Max(0, i - 1);
int num3 = Mathf.Min(len2 - 1, i + 1);
float single = data[x * len2 + i] + data[x * len2 + num2] + data[x * len2 + num3] + data[num * len2 + i] + data[num1 * len2 + i];
singleArray[x * len2 + i] = single * 0.2f;
}
};
Action <int> action3 = action2;
action = action2;
action1 = action3;
}
Parallel.For(0, num4, action1);
GenericsUtil.Swap <float[]>(ref data, ref singleArray);
}
if (data != data)
{
Buffer.BlockCopy(data, 0, data, 0, (int)data.Length * 4);
}
}
public static void Average2D(float[] data, int len1, int len2, int iterations = 1)
{
float[] src = data;
float[] dst = new float[len1 * len2];
for (int index1 = 0; index1 < iterations; ++index1)
{
Parallel.For(0, len1, (Action <int>)(x =>
{
int num1 = Mathf.Max(0, x - 1);
int num2 = Mathf.Min(len1 - 1, x + 1);
for (int index = 0; index < len2; ++index)
{
int num3 = Mathf.Max(0, index - 1);
int num4 = Mathf.Min(len2 - 1, index + 1);
float num5 = src[x * len2 + index] + src[x * len2 + num3] + src[x * len2 + num4] + src[num1 * len2 + index] + src[num2 * len2 + index];
dst[x * len2 + index] = num5 * 0.2f;
}
}));
GenericsUtil.Swap <float[]>(ref src, ref dst);
}
if (src == data)
{
return;
}
Buffer.BlockCopy((Array)src, 0, (Array)data, 0, data.Length * 4);
}
public static void GaussianBlur2D(float[] data, int len1, int len2, int iterations = 1)
{
float[] a = data;
float[] b = new float[len1 * len2];
for (int i = 0; i < iterations; i++)
{
for (int j = 0; j < len1; j++)
{
int num = Mathf.Max(0, j - 1);
int num2 = Mathf.Min(len1 - 1, j + 1);
for (int k = 0; k < len2; k++)
{
int num3 = Mathf.Max(0, k - 1);
int num4 = Mathf.Min(len2 - 1, k + 1);
float num5 = a[j * len2 + k] * 4f + a[j * len2 + num3] + a[j * len2 + num4] + a[num * len2 + k] + a[num2 * len2 + k];
b[j * len2 + k] = num5 * 0.125f;
}
}
GenericsUtil.Swap(ref a, ref b);
}
if (a != data)
{
Buffer.BlockCopy(a, 0, data, 0, data.Length * 4);
}
}
public static void GaussianBlur2D(float[] data, int len1, int len2, int len3, int iterations = 1)
{
float[] src = data;
float[] dst = new float[len1 * len2 * len3];
for (int index1 = 0; index1 < iterations; ++index1)
{
Parallel.For(0, len1, (Action <int>)(x =>
{
int num1 = Mathf.Max(0, x - 1);
int num2 = Mathf.Min(len1 - 1, x + 1);
for (int index1 = 0; index1 < len2; ++index1)
{
int num3 = Mathf.Max(0, index1 - 1);
int num4 = Mathf.Min(len2 - 1, index1 + 1);
for (int index2 = 0; index2 < len3; ++index2)
{
float num5 = src[(x * len2 + index1) * len3 + index2] * 4f + src[(x * len2 + num3) * len3 + index2] + src[(x * len2 + num4) * len3 + index2] + src[(num1 * len2 + index1) * len3 + index2] + src[(num2 * len2 + index1) * len3 + index2];
dst[(x * len2 + index1) * len3 + index2] = num5 * 0.125f;
}
}
}));
GenericsUtil.Swap <float[]>(ref src, ref dst);
}
if (src == data)
{
return;
}
Buffer.BlockCopy((Array)src, 0, (Array)data, 0, data.Length * 4);
}
public static void GaussianBlur2D(float[] data, int len1, int len2, int iterations = 1)
{
float[] a = data;
float[] b = new float[len1 * len2];
for (int index1 = 0; index1 < iterations; ++index1)
{
for (int index2 = 0; index2 < len1; ++index2)
{
int num1 = Mathf.Max(0, index2 - 1);
int num2 = Mathf.Min(len1 - 1, index2 + 1);
for (int index3 = 0; index3 < len2; ++index3)
{
int num3 = Mathf.Max(0, index3 - 1);
int num4 = Mathf.Min(len2 - 1, index3 + 1);
float num5 = a[index2 * len2 + index3] * 4f + a[index2 * len2 + num3] + a[index2 * len2 + num4] + a[num1 * len2 + index3] + a[num2 * len2 + index3];
b[index2 * len2 + index3] = num5 * 0.125f;
}
}
GenericsUtil.Swap <float[]>(ref a, ref b);
}
if (a == data)
{
return;
}
Buffer.BlockCopy((Array)a, 0, (Array)data, 0, data.Length * 4);
}
public static void GaussianBlur2D(float[] data, int len1, int len2, int len3, int iterations = 1)
{
Action <int> action = null;
float[] singleArray = new float[len1 * len2 * len3];
for (int i1 = 0; i1 < iterations; i1++)
{
int num4 = len1;
Action <int> action1 = action;
if (action1 == null)
{
Action <int> action2 = (int x) => {
int num = Mathf.Max(0, x - 1);
int num1 = Mathf.Min(len1 - 1, x + 1);
for (int i = 0; i < len2; i++)
{
int num2 = Mathf.Max(0, i - 1);
int num3 = Mathf.Min(len2 - 1, i + 1);
for (int j = 0; j < len3; j++)
{
float single = data[(x * len2 + i) * len3 + j] * 4f + data[(x * len2 + num2) * len3 + j] + data[(x * len2 + num3) * len3 + j] + data[(num * len2 + i) * len3 + j] + data[(num1 * len2 + i) * len3 + j];
singleArray[(x * len2 + i) * len3 + j] = single * 0.125f;
}
}
};
Action <int> action3 = action2;
action = action2;
action1 = action3;
}
Parallel.For(0, num4, action1);
GenericsUtil.Swap <float[]>(ref data, ref singleArray);
}
if (data != data)
{
Buffer.BlockCopy(data, 0, data, 0, (int)data.Length * 4);
}
}
public override void Process(uint seed)
{
int priority;
if ((ulong)World.Size < (long)this.MinSize)
{
return;
}
TerrainHeightMap heightMap = TerrainMeta.HeightMap;
Prefab <MonumentInfo>[] prefabArray = Prefab.Load <MonumentInfo>(string.Concat("assets/bundled/prefabs/autospawn/", this.ResourceFolder), null, null, true);
if (prefabArray == null || prefabArray.Length == 0)
{
return;
}
prefabArray.Shuffle <Prefab <MonumentInfo> >(seed);
prefabArray.BubbleSort <Prefab <MonumentInfo> >();
Vector3 position = TerrainMeta.Position;
Vector3 size = TerrainMeta.Size;
float single = position.x;
float single1 = position.z;
float single2 = position.x + size.x;
float single3 = position.z + size.z;
int num = 0;
List <PlaceMonuments.SpawnInfo> spawnInfos = new List <PlaceMonuments.SpawnInfo>();
int num1 = 0;
List <PlaceMonuments.SpawnInfo> spawnInfos1 = new List <PlaceMonuments.SpawnInfo>();
for (int i = 0; i < 10; i++)
{
num = 0;
spawnInfos.Clear();
Prefab <MonumentInfo>[] prefabArray1 = prefabArray;
for (int j = 0; j < (int)prefabArray1.Length; j++)
{
Prefab <MonumentInfo> prefab = prefabArray1[j];
if (prefab.Parameters)
{
priority = (int)prefab.Parameters.Priority + (int)PrefabPriority.Low;
}
else
{
priority = 1;
}
int num2 = priority;
int num3 = num2 * num2 * num2 * num2;
for (int k = 0; k < 10000; k++)
{
float single4 = SeedRandom.Range(ref seed, single, single2);
float single5 = SeedRandom.Range(ref seed, single1, single3);
float single6 = TerrainMeta.NormalizeX(single4);
float single7 = TerrainMeta.NormalizeZ(single5);
float single8 = SeedRandom.Value(ref seed);
float factor = this.Filter.GetFactor(single6, single7);
if (factor * factor >= single8)
{
float height = heightMap.GetHeight(single6, single7);
Vector3 vector3 = new Vector3(single4, height, single5);
Quaternion obj = prefab.Object.transform.localRotation;
Vector3 obj1 = prefab.Object.transform.localScale;
if (!this.CheckRadius(spawnInfos, vector3, (float)this.Distance))
{
prefab.ApplyDecorComponents(ref vector3, ref obj, ref obj1);
if ((!prefab.Component || prefab.Component.CheckPlacement(vector3, obj, obj1)) && prefab.ApplyTerrainAnchors(ref vector3, obj, obj1, this.Filter) && prefab.ApplyTerrainChecks(vector3, obj, obj1, this.Filter) && prefab.ApplyTerrainFilters(vector3, obj, obj1, null) && prefab.ApplyWaterChecks(vector3, obj, obj1) && !prefab.CheckEnvironmentVolumes(vector3, obj, obj1, EnvironmentType.Underground))
{
PlaceMonuments.SpawnInfo spawnInfo = new PlaceMonuments.SpawnInfo()
{
prefab = prefab,
position = vector3,
rotation = obj,
scale = obj1
};
spawnInfos.Add(spawnInfo);
num += num3;
break;
}
}
}
}
}
if (num > num1)
{
num1 = num;
GenericsUtil.Swap <List <PlaceMonuments.SpawnInfo> >(ref spawnInfos, ref spawnInfos1);
}
}
foreach (PlaceMonuments.SpawnInfo spawnInfo1 in spawnInfos1)
{
Prefab prefab1 = spawnInfo1.prefab;
Vector3 vector31 = spawnInfo1.position;
Quaternion quaternion = spawnInfo1.rotation;
Vector3 vector32 = spawnInfo1.scale;
prefab1.ApplyTerrainPlacements(vector31, quaternion, vector32);
prefab1.ApplyTerrainModifiers(vector31, quaternion, vector32);
World.AddPrefab("Monument", prefab1.ID, vector31, quaternion, vector32);
}
}
public override void Process(uint seed)
{
int priority;
if ((ulong)World.Size < (long)this.MinSize)
{
return;
}
TerrainHeightMap heightMap = TerrainMeta.HeightMap;
Prefab <MonumentInfo>[] prefabArray = Prefab.Load <MonumentInfo>(string.Concat("assets/bundled/prefabs/autospawn/", this.ResourceFolder), null, null, true);
if (prefabArray == null || prefabArray.Length == 0)
{
return;
}
prefabArray.Shuffle <Prefab <MonumentInfo> >(seed);
prefabArray.BubbleSort <Prefab <MonumentInfo> >();
Vector3 position = TerrainMeta.Position;
Vector3 size = TerrainMeta.Size;
float maxDistanceFromTerrain = position.x - (float)this.MaxDistanceFromTerrain;
float minDistanceFromTerrain = position.x - (float)this.MinDistanceFromTerrain;
float single = position.x + size.x + (float)this.MinDistanceFromTerrain;
float maxDistanceFromTerrain1 = position.x + size.x + (float)this.MaxDistanceFromTerrain;
float single1 = position.z - (float)this.MaxDistanceFromTerrain;
int num = this.MinDistanceFromTerrain;
float minDistanceFromTerrain1 = position.z + size.z + (float)this.MinDistanceFromTerrain;
float maxDistanceFromTerrain2 = position.z + size.z + (float)this.MaxDistanceFromTerrain;
int num1 = 0;
List <PlaceMonumentsOffshore.SpawnInfo> spawnInfos = new List <PlaceMonumentsOffshore.SpawnInfo>();
int num2 = 0;
List <PlaceMonumentsOffshore.SpawnInfo> spawnInfos1 = new List <PlaceMonumentsOffshore.SpawnInfo>();
for (int i = 0; i < 10; i++)
{
num1 = 0;
spawnInfos.Clear();
Prefab <MonumentInfo>[] prefabArray1 = prefabArray;
for (int j = 0; j < (int)prefabArray1.Length; j++)
{
Prefab <MonumentInfo> prefab = prefabArray1[j];
if (prefab.Parameters)
{
priority = (int)prefab.Parameters.Priority + (int)PrefabPriority.Low;
}
else
{
priority = 1;
}
int num3 = priority;
int num4 = num3 * num3 * num3 * num3;
for (int k = 0; k < 10000; k++)
{
float single2 = 0f;
float single3 = 0f;
switch (seed % 4)
{
case 0:
{
single2 = SeedRandom.Range(ref seed, maxDistanceFromTerrain, minDistanceFromTerrain);
single3 = SeedRandom.Range(ref seed, single1, maxDistanceFromTerrain2);
break;
}
case 1:
{
single2 = SeedRandom.Range(ref seed, single, maxDistanceFromTerrain1);
single3 = SeedRandom.Range(ref seed, single1, maxDistanceFromTerrain2);
break;
}
case 2:
{
single2 = SeedRandom.Range(ref seed, maxDistanceFromTerrain, maxDistanceFromTerrain1);
single3 = SeedRandom.Range(ref seed, single1, single1);
break;
}
case 3:
{
single2 = SeedRandom.Range(ref seed, maxDistanceFromTerrain, maxDistanceFromTerrain1);
single3 = SeedRandom.Range(ref seed, minDistanceFromTerrain1, maxDistanceFromTerrain2);
break;
}
}
float single4 = TerrainMeta.NormalizeX(single2);
float height = heightMap.GetHeight(single4, TerrainMeta.NormalizeZ(single3));
Vector3 vector3 = new Vector3(single2, height, single3);
Quaternion obj = prefab.Object.transform.localRotation;
Vector3 obj1 = prefab.Object.transform.localScale;
if (!this.CheckRadius(spawnInfos, vector3, (float)this.DistanceBetweenMonuments))
{
prefab.ApplyDecorComponents(ref vector3, ref obj, ref obj1);
if ((!prefab.Component || prefab.Component.CheckPlacement(vector3, obj, obj1)) && !prefab.CheckEnvironmentVolumes(vector3, obj, obj1, EnvironmentType.Underground))
{
PlaceMonumentsOffshore.SpawnInfo spawnInfo = new PlaceMonumentsOffshore.SpawnInfo()
{
prefab = prefab,
position = vector3,
rotation = obj,
scale = obj1
};
spawnInfos.Add(spawnInfo);
num1 += num4;
break;
}
}
}
}
if (num1 > num2)
{
num2 = num1;
GenericsUtil.Swap <List <PlaceMonumentsOffshore.SpawnInfo> >(ref spawnInfos, ref spawnInfos1);
}
}
foreach (PlaceMonumentsOffshore.SpawnInfo spawnInfo1 in spawnInfos1)
{
Prefab prefab1 = spawnInfo1.prefab;
Vector3 vector31 = spawnInfo1.position;
Quaternion quaternion = spawnInfo1.rotation;
Vector3 vector32 = spawnInfo1.scale;
prefab1.ApplyTerrainPlacements(vector31, quaternion, vector32);
prefab1.ApplyTerrainModifiers(vector31, quaternion, vector32);
World.AddPrefab("Monument", prefab1.ID, vector31, quaternion, vector32);
}
}
public override void Process(uint seed)
{
if ((long)World.Size < (long)this.MinSize)
{
return;
}
TerrainHeightMap heightMap = TerrainMeta.HeightMap;
Prefab <MonumentInfo>[] array = Prefab.Load <MonumentInfo>("assets/bundled/prefabs/autospawn/" + this.ResourceFolder, (GameManager)null, (PrefabAttribute.Library)null, true);
if (array == null || array.Length == 0)
{
return;
}
array.Shuffle <Prefab <MonumentInfo> >(seed);
array.BubbleSort <Prefab <MonumentInfo> >();
Vector3 position1 = TerrainMeta.Position;
Vector3 size = TerrainMeta.Size;
float x1 = (float)position1.x;
float z1 = (float)position1.z;
float num1 = (float)(position1.x + size.x);
float num2 = (float)(position1.z + size.z);
List <PlaceMonuments.SpawnInfo> a = new List <PlaceMonuments.SpawnInfo>();
int num3 = 0;
List <PlaceMonuments.SpawnInfo> b = new List <PlaceMonuments.SpawnInfo>();
for (int index1 = 0; index1 < 10; ++index1)
{
int num4 = 0;
a.Clear();
foreach (Prefab <MonumentInfo> prefab in array)
{
int num5 = Object.op_Implicit((Object)prefab.Parameters) ? (int)(prefab.Parameters.Priority + 1) : 1;
int num6 = num5 * num5 * num5 * num5;
for (int index2 = 0; index2 < 10000; ++index2)
{
float x2 = SeedRandom.Range(ref seed, x1, num1);
float z2 = SeedRandom.Range(ref seed, z1, num2);
float normX = TerrainMeta.NormalizeX(x2);
float normZ = TerrainMeta.NormalizeZ(z2);
float num7 = SeedRandom.Value(ref seed);
double factor = (double)this.Filter.GetFactor(normX, normZ);
if (factor * factor >= (double)num7)
{
float height = heightMap.GetHeight(normX, normZ);
Vector3 pos;
((Vector3) ref pos).\u002Ector(x2, height, z2);
Quaternion localRotation = prefab.Object.get_transform().get_localRotation();
Vector3 localScale = prefab.Object.get_transform().get_localScale();
if (!this.CheckRadius(a, pos, (float)this.Distance))
{
prefab.ApplyDecorComponents(ref pos, ref localRotation, ref localScale);
if ((!Object.op_Implicit((Object)prefab.Component) || prefab.Component.CheckPlacement(pos, localRotation, localScale)) && (prefab.ApplyTerrainAnchors(ref pos, localRotation, localScale, this.Filter) && prefab.ApplyTerrainChecks(pos, localRotation, localScale, this.Filter)) && (prefab.ApplyTerrainFilters(pos, localRotation, localScale, (SpawnFilter)null) && prefab.ApplyWaterChecks(pos, localRotation, localScale) && !prefab.CheckEnvironmentVolumes(pos, localRotation, localScale, EnvironmentType.Underground)))
{
a.Add(new PlaceMonuments.SpawnInfo()
{
prefab = (Prefab)prefab,
position = pos,
rotation = localRotation,
scale = localScale
});
num4 += num6;
break;
}
}
}
}
}
if (num4 > num3)
{
num3 = num4;
GenericsUtil.Swap <List <PlaceMonuments.SpawnInfo> >(ref a, ref b);
}
}
foreach (PlaceMonuments.SpawnInfo spawnInfo in b)
{
Prefab prefab = spawnInfo.prefab;
Vector3 position2 = spawnInfo.position;
Quaternion rotation = spawnInfo.rotation;
Vector3 scale = spawnInfo.scale;
prefab.ApplyTerrainPlacements(position2, rotation, scale);
prefab.ApplyTerrainModifiers(position2, rotation, scale);
World.AddPrefab("Monument", prefab.ID, position2, rotation, scale);
}
}
public override void Process(uint seed)
{
if ((long)World.Size < (long)this.MinSize)
{
return;
}
TerrainHeightMap heightMap = TerrainMeta.HeightMap;
Prefab <MonumentInfo>[] array = Prefab.Load <MonumentInfo>("assets/bundled/prefabs/autospawn/" + this.ResourceFolder, (GameManager)null, (PrefabAttribute.Library)null, true);
if (array == null || array.Length == 0)
{
return;
}
array.Shuffle <Prefab <MonumentInfo> >(seed);
array.BubbleSort <Prefab <MonumentInfo> >();
Vector3 position1 = TerrainMeta.Position;
Vector3 size = TerrainMeta.Size;
float num1 = (float)position1.x - (float)this.MaxDistanceFromTerrain;
float num2 = (float)position1.x - (float)this.MinDistanceFromTerrain;
float num3 = (float)(position1.x + size.x) + (float)this.MinDistanceFromTerrain;
float num4 = (float)(position1.x + size.x) + (float)this.MaxDistanceFromTerrain;
float num5 = (float)position1.z - (float)this.MaxDistanceFromTerrain;
int distanceFromTerrain = this.MinDistanceFromTerrain;
float num6 = (float)(position1.z + size.z) + (float)this.MinDistanceFromTerrain;
float num7 = (float)(position1.z + size.z) + (float)this.MaxDistanceFromTerrain;
List <PlaceMonumentsOffshore.SpawnInfo> a = new List <PlaceMonumentsOffshore.SpawnInfo>();
int num8 = 0;
List <PlaceMonumentsOffshore.SpawnInfo> b = new List <PlaceMonumentsOffshore.SpawnInfo>();
for (int index1 = 0; index1 < 10; ++index1)
{
int num9 = 0;
a.Clear();
foreach (Prefab <MonumentInfo> prefab in array)
{
int num10 = Object.op_Implicit((Object)prefab.Parameters) ? (int)(prefab.Parameters.Priority + 1) : 1;
int num11 = num10 * num10 * num10 * num10;
for (int index2 = 0; index2 < 10000; ++index2)
{
float x = 0.0f;
float z = 0.0f;
switch (seed % 4U)
{
case 0:
x = SeedRandom.Range(ref seed, num1, num2);
z = SeedRandom.Range(ref seed, num5, num7);
break;
case 1:
x = SeedRandom.Range(ref seed, num3, num4);
z = SeedRandom.Range(ref seed, num5, num7);
break;
case 2:
x = SeedRandom.Range(ref seed, num1, num4);
z = SeedRandom.Range(ref seed, num5, num5);
break;
case 3:
x = SeedRandom.Range(ref seed, num1, num4);
z = SeedRandom.Range(ref seed, num6, num7);
break;
}
float normX = TerrainMeta.NormalizeX(x);
float normZ = TerrainMeta.NormalizeZ(z);
float height = heightMap.GetHeight(normX, normZ);
Vector3 pos;
((Vector3) ref pos).\u002Ector(x, height, z);
Quaternion localRotation = prefab.Object.get_transform().get_localRotation();
Vector3 localScale = prefab.Object.get_transform().get_localScale();
if (!this.CheckRadius(a, pos, (float)this.DistanceBetweenMonuments))
{
prefab.ApplyDecorComponents(ref pos, ref localRotation, ref localScale);
if ((!Object.op_Implicit((Object)prefab.Component) || prefab.Component.CheckPlacement(pos, localRotation, localScale)) && !prefab.CheckEnvironmentVolumes(pos, localRotation, localScale, EnvironmentType.Underground))
{
a.Add(new PlaceMonumentsOffshore.SpawnInfo()
{
prefab = (Prefab)prefab,
position = pos,
rotation = localRotation,
scale = localScale
});
num9 += num11;
break;
}
}
}
}
if (num9 > num8)
{
num8 = num9;
GenericsUtil.Swap <List <PlaceMonumentsOffshore.SpawnInfo> >(ref a, ref b);
}
}
foreach (PlaceMonumentsOffshore.SpawnInfo spawnInfo in b)
{
Prefab prefab = spawnInfo.prefab;
Vector3 position2 = spawnInfo.position;
Quaternion rotation = spawnInfo.rotation;
Vector3 scale = spawnInfo.scale;
prefab.ApplyTerrainPlacements(position2, rotation, scale);
prefab.ApplyTerrainModifiers(position2, rotation, scale);
World.AddPrefab("Monument", prefab.ID, position2, rotation, scale);
}
}
