public static bool GetModPlane(int index, ref PlanetRawData __instance, ref short __result)
{
Patch.Debug("scaleFactor " + __instance.GetFactoredScale(), LogLevel.Debug,
Patch.DebugGetModPlane);
Patch.Debug("index " + index, LogLevel.Debug,
Patch.DebugGetModPlane);
Patch.Debug("__instance.modData.Length " + __instance.modData.Length, LogLevel.Debug,
Patch.DebugGetModPlane);
Patch.Debug(
"test " + ((__instance.modData[index >> 1] >> (((index & 1) << 2) + 2)) & 3) * 133, LogLevel.Debug,
Patch.DebugGetModPlane);
float baseHeight = 20;
baseHeight += __instance.GetFactoredScale() * 200 * 100;
Patch.Debug("baseHeight " + baseHeight, LogLevel.Debug,
Patch.DebugGetModPlane);
__result = (short)(((__instance.modData[index >> 1] >> (((index & 1) << 2) + 2)) & 3) * 133 +
baseHeight);
Patch.Debug("GetModPlane __result " + __result, LogLevel.Debug,
Patch.DebugGetModPlane);
return(false);
}
public static int GetModPlaneInt(this PlanetRawData planetRawData, int index)
{
float baseHeight = 20;
baseHeight += planetRawData.GetFactoredScale() * 200 * 100;
return((int)(((planetRawData.modData[index >> 1] >> (((index & 1) << 2) + 2)) & 3) * 133 + baseHeight));
}
public static int ComputeFlattenTerrainReform(PlanetFactory factory, List <Vector3> points, Vector3 center, float fade0 = 3f)
{
PlanetRawData data = factory.planet.data;
tmpLevelChanges.Clear();
float realRadius = factory.planet.realRadius;
ushort[] heightData = data.heightData;
float heightDiff = (heightData[data.QueryIndex(center)] - factory.planet.realRadius * 100f + 20f) * 0.01f * 2f;
heightDiff = Mathf.Min(9f, Mathf.Abs(heightDiff));
fade0 += heightDiff;
float steps = realRadius * 3.1415927f / (factory.planet.precision * 2f);
int extent = Mathf.CeilToInt(fade0 * 1.414f / steps * 1.5f + 0.5f);
int cost = 0;
foreach (Vector3 vpos in points)
{
float longitude = BlueprintUtils.GetLongitudeRad(vpos.normalized);
float longCount = 2 * longitude / Mathf.PI;
float angleDistance = Mathf.Abs(longCount - Mathf.Round(longCount));
if (angleDistance <= 0.04)
{
cost += ScanTerrainDetailed(data, realRadius, vpos, extent, fade0);
}
else
{
cost += ScanTerrain(data, realRadius, vpos, extent, fade0);
}
}
return(cost);
}
public static void AddFactoredRadius(this PlanetRawData planetRawData, PlanetData planet)
{
FactoredRadius[planetRawData] = planet.GetScaleFactored();
}
public static float GetFactoredScale(this PlanetRawData planetRawData)
{
return(FactoredRadius.TryGetValue(planetRawData, out var result) ? result : 1f);
}
public virtual void GenerateVeins(bool sketchOnly)
{
lock (planet)
{
ThemeProto themeProto = LDB.themes.Select(planet.theme);
if (themeProto == null)
{
return;
}
System.Random random = new System.Random(planet.seed);
random.Next();
random.Next();
random.Next();
random.Next();
random.Next();
int num = random.Next();
System.Random random2 = new System.Random(num);
PlanetRawData data = planet.data;
float num2 = 2.1f / planet.radius;
VeinProto[] veinProtos = PlanetModelingManager.veinProtos;
int[] veinModelIndexs = PlanetModelingManager.veinModelIndexs;
int[] veinModelCounts = PlanetModelingManager.veinModelCounts;
int[] veinProducts = PlanetModelingManager.veinProducts;
int[] veinSpotArr = new int[veinProtos.Length];
float[] veinCountArr = new float[veinProtos.Length];
float[] veinOpacityArr = new float[veinProtos.Length];
if (themeProto.VeinSpot != null)
{
Array.Copy(themeProto.VeinSpot, 0, veinSpotArr, 1, Math.Min(themeProto.VeinSpot.Length, veinSpotArr.Length - 1));
}
if (themeProto.VeinCount != null)
{
Array.Copy(themeProto.VeinCount, 0, veinCountArr, 1, Math.Min(themeProto.VeinCount.Length, veinCountArr.Length - 1));
}
if (themeProto.VeinOpacity != null)
{
Array.Copy(themeProto.VeinOpacity, 0, veinOpacityArr, 1, Math.Min(themeProto.VeinOpacity.Length, veinOpacityArr.Length - 1));
}
float p = 1f;
ESpectrType spectr = planet.star.spectr;
switch (planet.star.type)
{
case EStarType.MainSeqStar:
switch (spectr)
{
case ESpectrType.M:
p = 2.5f;
break;
case ESpectrType.K:
p = 1f;
break;
case ESpectrType.G:
p = 0.7f;
break;
case ESpectrType.F:
p = 0.6f;
break;
case ESpectrType.A:
p = 1f;
break;
case ESpectrType.B:
p = 0.4f;
break;
case ESpectrType.O:
p = 1.6f;
break;
}
break;
case EStarType.GiantStar:
p = 2.5f;
break;
case EStarType.WhiteDwarf:
{
p = 3.5f;
veinSpotArr[9]++;
veinSpotArr[9]++;
for (int j = 1; j < 12; j++)
{
if (random.NextDouble() >= 0.44999998807907104)
{
break;
}
veinSpotArr[9]++;
}
veinCountArr[9] = 0.7f;
veinOpacityArr[9] = 1f;
veinSpotArr[10]++;
veinSpotArr[10]++;
for (int k = 1; k < 12; k++)
{
if (random.NextDouble() >= 0.44999998807907104)
{
break;
}
veinSpotArr[10]++;
}
veinCountArr[10] = 0.7f;
veinOpacityArr[10] = 1f;
veinSpotArr[12]++;
for (int l = 1; l < 12; l++)
{
if (random.NextDouble() >= 0.5)
{
break;
}
veinSpotArr[12]++;
}
veinCountArr[12] = 0.7f;
veinOpacityArr[12] = 0.3f;
break;
}
case EStarType.NeutronStar:
{
p = 4.5f;
veinSpotArr[14]++;
for (int m = 1; m < 12; m++)
{
if (random.NextDouble() >= 0.64999997615814209)
{
break;
}
veinSpotArr[14]++;
}
veinCountArr[14] = 0.7f;
veinOpacityArr[14] = 0.3f;
break;
}
case EStarType.BlackHole:
{
p = 5f;
veinSpotArr[14]++;
for (int i = 1; i < 12; i++)
{
if (random.NextDouble() >= 0.64999997615814209)
{
break;
}
veinSpotArr[14]++;
}
veinCountArr[14] = 0.7f;
veinOpacityArr[14] = 0.3f;
break;
}
}
for (int n = 0; n < themeProto.RareVeins.Length; n++)
{
int num3 = themeProto.RareVeins[n];
float num4 = ((planet.star.index != 0) ? themeProto.RareSettings[n * 4 + 1] : themeProto.RareSettings[n * 4]);
float num5 = themeProto.RareSettings[n * 4 + 2];
float num6 = themeProto.RareSettings[n * 4 + 3];
float num7 = num6;
num4 = 1f - Mathf.Pow(1f - num4, p);
num6 = 1f - Mathf.Pow(1f - num6, p);
num7 = 1f - Mathf.Pow(1f - num7, p);
if (!(random.NextDouble() < (double)num4))
{
continue;
}
veinSpotArr[num3]++;
veinCountArr[num3] = num6;
veinOpacityArr[num3] = num6;
for (int num8 = 1; num8 < 12; num8++)
{
if (random.NextDouble() >= (double)num5)
{
break;
}
veinSpotArr[num3]++;
}
}
float num9 = planet.star.resourceCoef;
bool flag = DSPGame.GameDesc.resourceMultiplier >= 99.5f;
if (planet.galaxy.birthPlanetId == planet.id)
{
num9 *= 2f / 3f;
}
float num10 = 1f;
num10 *= 1.1f;
Array.Clear(veinVectors, 0, veinVectors.Length);
Array.Clear(veinVectorTypes, 0, veinVectorTypes.Length);
veinVectorCount = 0;
Vector3 vector = default(Vector3);
if (planet.galaxy.birthPlanetId == planet.id)
{
Pose pose = planet.PredictPose(120.0);
vector = Maths.QInvRotateLF(pose.rotation, planet.star.uPosition - (VectorLF3)pose.position * 40000.0);
vector.Normalize();
vector *= 0.75f;
}
else
{
vector.x = (float)random2.NextDouble() * 2f - 1f;
vector.y = (float)random2.NextDouble() - 0.5f;
vector.z = (float)random2.NextDouble() * 2f - 1f;
vector.Normalize();
vector *= (float)(random2.NextDouble() * 0.4 + 0.2);
}
planet.veinSpotsSketch = veinSpotArr;
if (sketchOnly)
{
return;
}
for (int num11 = 1; num11 < 15; num11++)
{
if (veinVectorCount >= veinVectors.Length)
{
break;
}
EVeinType eVeinType = (EVeinType)num11;
int num12 = veinSpotArr[num11];
if (num12 > 1)
{
num12 += random2.Next(-1, 2);
}
for (int num13 = 0; num13 < num12; num13++)
{
int num14 = 0;
Vector3 zero = Vector3.zero;
bool flag2 = false;
while (num14++ < 200)
{
zero.x = (float)random2.NextDouble() * 2f - 1f;
zero.y = (float)random2.NextDouble() * 2f - 1f;
zero.z = (float)random2.NextDouble() * 2f - 1f;
if (eVeinType != EVeinType.Oil)
{
zero += vector;
}
zero.Normalize();
float num15 = data.QueryHeight(zero);
if (num15 < planet.radius || (eVeinType == EVeinType.Oil && num15 < planet.radius + 0.5f))
{
continue;
}
bool flag3 = false;
float num16 = ((eVeinType != EVeinType.Oil) ? 196f : 100f);
for (int num17 = 0; num17 < veinVectorCount; num17++)
{
if ((veinVectors[num17] - zero).sqrMagnitude < num2 * num2 * num16)
{
flag3 = true;
break;
}
}
if (flag3)
{
continue;
}
flag2 = true;
break;
}
if (flag2)
{
veinVectors[veinVectorCount] = zero;
veinVectorTypes[veinVectorCount] = eVeinType;
veinVectorCount++;
if (veinVectorCount == veinVectors.Length)
{
break;
}
}
}
}
Array.Clear(planet.veinAmounts, 0, planet.veinAmounts.Length);
data.veinCursor = 1;
planet.veinGroups = new PlanetData.VeinGroup[veinVectorCount];
tmp_vecs.Clear();
VeinData vein = default(VeinData);
for (int num18 = 0; num18 < veinVectorCount; num18++)
{
tmp_vecs.Clear();
Vector3 normalized = veinVectors[num18].normalized;
EVeinType eVeinType2 = veinVectorTypes[num18];
int num19 = (int)eVeinType2;
Quaternion quaternion = Quaternion.FromToRotation(Vector3.up, normalized);
Vector3 vector2 = quaternion * Vector3.right;
Vector3 vector3 = quaternion * Vector3.forward;
planet.veinGroups[num18].type = eVeinType2;
planet.veinGroups[num18].pos = normalized;
planet.veinGroups[num18].count = 0;
planet.veinGroups[num18].amount = 0L;
tmp_vecs.Add(Vector2.zero);
int num20 = Mathf.RoundToInt(veinCountArr[num19] * (float)random2.Next(20, 25));
if (eVeinType2 == EVeinType.Oil)
{
num20 = 1;
}
int num21 = 0;
while (num21++ < 20)
{
int count = tmp_vecs.Count;
for (int num22 = 0; num22 < count; num22++)
{
if (tmp_vecs.Count >= num20)
{
break;
}
if (tmp_vecs[num22].sqrMagnitude > 36f)
{
continue;
}
double num23 = random2.NextDouble() * Math.PI * 2.0;
Vector2 vector4 = new Vector2((float)Math.Cos(num23), (float)Math.Sin(num23));
vector4 += tmp_vecs[num22] * 0.2f;
vector4.Normalize();
Vector2 vector5 = tmp_vecs[num22] + vector4;
bool flag4 = false;
for (int num24 = 0; num24 < tmp_vecs.Count; num24++)
{
if ((tmp_vecs[num24] - vector5).sqrMagnitude < 0.85f)
{
flag4 = true;
break;
}
}
if (!flag4)
{
tmp_vecs.Add(vector5);
}
}
if (tmp_vecs.Count >= num20)
{
break;
}
}
int num25 = Mathf.RoundToInt(veinOpacityArr[num19] * 100000f * num9);
if (num25 < 20)
{
num25 = 20;
}
int num26 = ((num25 >= 16000) ? 15000 : Mathf.FloorToInt((float)num25 * 0.9375f));
int minValue = num25 - num26;
int maxValue = num25 + num26 + 1;
for (int num27 = 0; num27 < tmp_vecs.Count; num27++)
{
Vector3 vector6 = (tmp_vecs[num27].x * vector2 + tmp_vecs[num27].y * vector3) * num2;
vein.type = eVeinType2;
vein.groupIndex = (short)num18;
vein.modelIndex = (short)random2.Next(veinModelIndexs[num19], veinModelIndexs[num19] + veinModelCounts[num19]);
vein.amount = Mathf.RoundToInt((float)random2.Next(minValue, maxValue) * num10);
if (planet.veinGroups[num18].type != EVeinType.Oil)
{
vein.amount = Mathf.RoundToInt((float)vein.amount * DSPGame.GameDesc.resourceMultiplier);
}
if (vein.amount < 1)
{
vein.amount = 1;
}
if (flag && vein.type != EVeinType.Oil)
{
vein.amount = 1000000000;
}
vein.productId = veinProducts[num19];
vein.pos = normalized + vector6;
if (vein.type == EVeinType.Oil)
{
vein.pos = planet.aux.RawSnap(vein.pos);
}
vein.minerCount = 0;
float num28 = data.QueryHeight(vein.pos);
data.EraseVegetableAtPoint(vein.pos);
vein.pos = vein.pos.normalized * num28;
if (planet.waterItemId == 0 || !(num28 < planet.radius))
{
planet.veinAmounts[(uint)eVeinType2] += vein.amount;
planet.veinGroups[num18].count++;
planet.veinGroups[num18].amount += vein.amount;
data.AddVeinData(vein);
}
}
}
tmp_vecs.Clear();
}
}
public static bool GenBirthPoints(PlanetRawData rawData, int _birthSeed)
{
return(true);
}
public static void FlattenTerrainReformALT(this PlanetFactory planetFactory, Vector3 center, float radius, int reformSize, bool veinBuried, float localRadius, float realRadius, float fade0 = 3f)
{
if (planetFactory.tmp_ids == null)
{
planetFactory.tmp_ids = new int[1024];
}
if (planetFactory.tmp_entity_ids == null)
{
planetFactory.tmp_entity_ids = new int[1024];
}
Array.Clear(planetFactory.tmp_ids, 0, planetFactory.tmp_ids.Length);
Array.Clear(planetFactory.tmp_entity_ids, 0, planetFactory.tmp_entity_ids.Length);
Vector3 zero = Vector3.zero;
PlanetRawData data = planetFactory.planet.data;
ushort[] heightData = data.heightData;
float f = ((float)(int)heightData[data.QueryIndex(center)] - realRadius * 100f + 20f) * 0.01f * 2f;
//f = Mathf.Min(9f, Mathf.Abs(f));
f = Mathf.Min(5f, Mathf.Abs(f));
fade0 += f;
float areaRadius = radius + fade0;
short num = (short)(realRadius * 100f + 20f);
bool levelized = planetFactory.planet.levelized;
int num2 = Mathf.RoundToInt((center.magnitude - 0.2f - realRadius) / 1.33333325f);
int num3 = num2 * 133 + num - 60;
float num4 = localRadius * 100f - 20f;
foreach (KeyValuePair <int, int> tmp_levelChange in planetFactory.tmp_levelChanges)
{
/*
* if (tmp_levelChange.Value <= 0)
* {
* continue;
* }
*/
ushort num5 = heightData[tmp_levelChange.Key];
if (levelized)
{
if (num5 >= num3)
{
if (data.GetModLevel(tmp_levelChange.Key) < 3)
{
data.SetModPlane(tmp_levelChange.Key, num2);
}
planetFactory.planet.AddHeightMapModLevel(tmp_levelChange.Key, tmp_levelChange.Value);
}
}
else
{
Debug.Log("AddHeightMapModLevel: " + tmp_levelChange.Key + ", " + tmp_levelChange.Value);
planetFactory.planet.AddHeightMapModLevelALT(tmp_levelChange.Key, tmp_levelChange.Value);
}
if ((float)(int)num5 < num4)
{
planetFactory.planet.landPercentDirty = true;
}
}
if (planetFactory.planet.UpdateDirtyMeshes())
{
planetFactory.RenderLocalPlanetHeightmap();
}
radius -= (float)reformSize * 0.15f;
NearColliderLogic nearColliderLogic = planetFactory.planet.physics.nearColliderLogic;
int vegetablesInAreaNonAlloc = nearColliderLogic.GetVegetablesInAreaNonAlloc(center, areaRadius, planetFactory.tmp_ids);
float num6 = radius * radius;
for (int i = 0; i < vegetablesInAreaNonAlloc; i++)
{
int num7 = planetFactory.tmp_ids[i];
zero = planetFactory.vegePool[num7].pos;
zero -= center;
if (zero.x * zero.x + zero.y * zero.y + zero.z * zero.z <= num6 + 2.2f)
{
planetFactory.RemoveVegeWithComponents(num7);
continue;
}
float num8 = data.QueryModifiedHeight(planetFactory.vegePool[num7].pos) - 0.03f;
planetFactory.vegePool[num7].pos = planetFactory.vegePool[num7].pos.normalized * num8;
GameMain.gpuiManager.AlterModel(planetFactory.vegePool[num7].modelIndex, planetFactory.vegePool[num7].modelId, num7, planetFactory.vegePool[num7].pos, planetFactory.vegePool[num7].rot, setBuffer: false);
}
float num9 = 50f;
vegetablesInAreaNonAlloc = ((!veinBuried) ? nearColliderLogic.GetVeinsInOceanInAreaNonAlloc(center, areaRadius, planetFactory.tmp_ids) : nearColliderLogic.GetVeinsInAreaNonAlloc(center, areaRadius, planetFactory.tmp_ids));
for (int j = 0; j < vegetablesInAreaNonAlloc; j++)
{
int num10 = planetFactory.tmp_ids[j];
zero = planetFactory.veinPool[num10].pos;
float num11 = realRadius + 0.2f;
Vector3 vector = zero.normalized * num11 - center;
if (!(vector.x * vector.x + vector.y * vector.y + vector.z * vector.z <= num6 + 2f))
{
continue;
}
PlanetPhysics physics = planetFactory.planet.physics;
int colliderId = planetFactory.veinPool[num10].colliderId;
ColliderData colliderData = physics.GetColliderData(colliderId);
if (veinBuried)
{
num11 -= num9;
}
else
{
Vector3 center2 = zero.normalized * num11;
int entitiesInAreaWhenReformNonAlloc = nearColliderLogic.GetEntitiesInAreaWhenReformNonAlloc(center2, colliderData.radius, planetFactory.tmp_entity_ids);
if (entitiesInAreaWhenReformNonAlloc > 0)
{
num11 = zero.magnitude;
}
}
Vector3 pos = colliderData.pos.normalized * num11;
int num12 = colliderId >> 20;
colliderId &= 0xFFFFF;
physics.colChunks[num12].colliderPool[colliderId].pos = pos;
planetFactory.veinPool[num10].pos = zero.normalized * num11;
physics.RefreshColliders();
GameMain.gpuiManager.AlterModel(planetFactory.veinPool[num10].modelIndex, planetFactory.veinPool[num10].modelId, num10, planetFactory.veinPool[num10].pos, setBuffer: false);
}
planetFactory.tmp_levelChanges.Clear();
Array.Clear(planetFactory.tmp_ids, 0, planetFactory.tmp_ids.Length);
Array.Clear(planetFactory.tmp_ids, 0, planetFactory.tmp_entity_ids.Length);
GameMain.gpuiManager.SyncAllGPUBuffer();
}
public static int ComputeFlattenTerrainReformALT(this PlanetFactory planetFactory, Vector3[] points, Vector3 center, float radius, int pointsCount, float realRadius,
float fade0 = 3f, float fade1 = 1f)
{
PlanetRawData data = planetFactory.planet.data;
if (planetFactory.tmp_levelChanges == null)
{
planetFactory.tmp_levelChanges = new Dictionary <int, int>();
}
planetFactory.tmp_levelChanges.Clear();
Quaternion quaternion = Maths.SphericalRotation(center, 22.5f);
//float realRadius = planetFactory.planet.realRadius;
Vector3[] vertices = data.vertices;
ushort[] heightData = data.heightData;
float f = ((float)(int)heightData[data.QueryIndex(center)] - realRadius * 100f + 20f) * 0.01f * 2f;
Debug.Log("ComputeFlattenTerrainReformALT.heightData(center): " + heightData[data.QueryIndex(center)] + " , f: " + f);
//f = Mathf.Min(9f, Mathf.Abs(f));
f = Mathf.Min(5f, Mathf.Abs(f));
fade0 += f;
float radiusFade = radius + fade0;
float levelArea = radiusFade * radiusFade;
Debug.Log("ComputeFlattenTerrainReformALT.levelArea: " + levelArea + " , radius: " + radius + " , fade0: " + fade0);
// realRadius * (float)Math.PI / (200 * 2f);
float num3 = realRadius * (float)Math.PI / ((float)planetFactory.planet.precision * 2f);
int num4 = Mathf.CeilToInt(radiusFade * 1.414f / num3 + 0.5f);
Vector3[] array = new Vector3[9]
{
center,
center + quaternion * (new Vector3(0f, 0f, 1.414f) * radiusFade),
center + quaternion * (new Vector3(0f, 0f, -1.414f) * radiusFade),
center + quaternion * (new Vector3(1.414f, 0f, 0f) * radiusFade),
center + quaternion * (new Vector3(-1.414f, 0f, 0f) * radiusFade),
center + quaternion * (new Vector3(1f, 0f, 1f) * radiusFade),
center + quaternion * (new Vector3(-1f, 0f, -1f) * radiusFade),
center + quaternion * (new Vector3(1f, 0f, -1f) * radiusFade),
center + quaternion * (new Vector3(-1f, 0f, 1f) * radiusFade)
};
int stride = data.stride;
int dataLength = data.dataLength;
float minHeight = 6f;
int num6 = 0;
Vector3[] array2 = array;
Vector3 vector = default(Vector3);
Vector3 vector2 = default(Vector3);
foreach (Vector3 vpos in array2)
{
int num7 = data.QueryIndex(vpos);
for (int j = -num4; j <= num4; j++)
{
int num8 = num7 + j * stride;
if (num8 < 0 || num8 >= dataLength)
{
continue;
}
for (int k = -num4; k <= num4; k++)
{
int num9 = num8 + k;
if ((uint)num9 >= dataLength)
{
continue;
}
vector.x = vertices[num9].x * realRadius;
vector.y = vertices[num9].y * realRadius;
vector.z = vertices[num9].z * realRadius;
vector2.x = vector.x - center.x;
vector2.y = vector.y - center.y;
vector2.z = vector.z - center.z;
float squareSum = vector2.x * vector2.x + vector2.y * vector2.y + vector2.z * vector2.z;
if (squareSum > levelArea /*|| */)
{
continue;
}
float num10 = float.PositiveInfinity;
for (int l = 0; l < pointsCount; l++)
{
float num11 = points[l].x - vector.x;
float num12 = points[l].y - vector.y;
float num13 = points[l].z - vector.z;
float num14 = num11 * num11 + num12 * num12 + num13 * num13;
num10 = ((!(num10 < num14)) ? num14 : num10);
}
int num15 = 0;
int num16 = 0;
int num17 = 0;
num16 = data.GetModLevel(num9);
if (num10 <= minHeight)
{
num15 = 3;
}
else
{
num10 -= minHeight;
if (num10 > fade0 * fade0)
{
continue;
}
float num18 = num10 / (fade0 * fade0);
if (num18 <= 0.1111111f)
{
num15 = 2;
}
else if (num18 <= 0.4444444f)
{
num15 = 1;
}
else
{
if (!(num18 < 1f))
{
continue;
}
num15 = 0;
}
}
num17 = num15 - num16;
Debug.Log("CompALT.loop.jk\tnum9: " + num9 + "\t, squareSum: " + squareSum + "\t, contains: " + planetFactory.tmp_levelChanges.ContainsKey(num9)
+ "\t, modLevel: " + data.GetModLevel(num9) + "\t, num15: " + num15 + "\t, num16: " + num16 + "\t, num17: " + num17);
if (/*num15 >= num16 &&*/ num17 != 0)
{
planetFactory.tmp_levelChanges[num9] = num15;
float num19 = (float)(int)heightData[num9] * 0.01f;
float num20 = realRadius + 0.2f;
float num21 = num20 - num19;
if (num21 < 0f)
{
num21 *= 2f;
}
float f2 = 100f * (float)num17 * num21 * 0.3333333f;
num6 += Mathf.FloorToInt(f2);
}
}
}
}
return(num6);
}
public static bool QueryModifiedHeight(ref PlanetRawData __instance,
ref float __result, Vector3 vpos)
{
Patch.Debug("QueryModifiedHeight ", LogLevel.Debug,
Patch.DebugPlanetRawData);
vpos.Normalize();
var index1 = __instance.indexMap[__instance.PositionHash(vpos)];
var radiusPrecision =
(float)(3.14159274101257 / (__instance.precision * 2) * 1.20000004768372);
Patch.Debug("radiusPrecision " + radiusPrecision, LogLevel.Debug,
Patch.DebugPlanetRawData);
var radiusPrecisionSq = radiusPrecision * radiusPrecision;
Patch.Debug("radiusPrecisionSq " + radiusPrecisionSq, LogLevel.Debug,
Patch.DebugPlanetRawData);
var magnetudeOnPrecisionDummy = 0.0f;
var HeightTimePrecision = 0.0f;
var stride = __instance.stride;
for (var index2 = -1; index2 <= 3; ++index2)
{
for (var index3 = -1; index3 <= 3; ++index3)
{
var index4 = index1 + index2 + index3 * stride;
if ((uint)index4 < __instance.dataLength)
{
var sqrMagnitude = (__instance.vertices[index4] - vpos).sqrMagnitude;
Patch.Debug("sqrMagnitude " + sqrMagnitude, LogLevel.Debug,
Patch.DebugPlanetRawData);
if (sqrMagnitude <= (double)radiusPrecisionSq)
{
var magnetudeOnPrecision =
(float)(1.0 - Mathf.Sqrt(sqrMagnitude) / (double)radiusPrecision);
Patch.Debug("MagnetudeOnPrecision " + magnetudeOnPrecision, LogLevel.Debug,
Patch.DebugPlanetRawData);
magnetudeOnPrecision *= __instance.GetFactoredScale();
Patch.Debug("MagnetudeOnPrecision Patched " + magnetudeOnPrecision,
LogLevel.Debug,
Patch.DebugPlanetRawData);
var modLevel = __instance.GetModLevel(index4);
float heightDataFinal = __instance.heightData[index4];
Patch.Debug("heightDataFinal First " + heightDataFinal, LogLevel.Debug,
Patch.DebugPlanetRawData);
if (modLevel > 0)
{
// try patching here
var modPlane = __instance.GetModPlaneInt(index4);
Patch.Debug("modPlane " + modPlane, LogLevel.Debug,
Patch.DebugPlanetRawData);
if (modLevel == 3)
{
heightDataFinal = modPlane;
Patch.Debug("heightDataFinal Second " + heightDataFinal, LogLevel.Debug,
Patch.DebugPlanetRawData);
}
else
{
var num7 = modLevel * 0.3333333f;
heightDataFinal =
(float)(__instance.heightData[index4] * (1.0 - num7) +
modPlane * (double)num7);
Patch.Debug("heightDataFinal Third " + heightDataFinal, LogLevel.Debug,
Patch.DebugPlanetRawData);
}
}
Patch.Debug("__result num6 " + heightDataFinal, LogLevel.Debug,
Patch.DebugPlanetRawData);
magnetudeOnPrecisionDummy += magnetudeOnPrecision;
HeightTimePrecision += heightDataFinal * magnetudeOnPrecision;
Patch.Debug("heightDataFinal Third " + heightDataFinal, LogLevel.Debug,
Patch.DebugPlanetRawData);
}
}
}
}
if (magnetudeOnPrecisionDummy != 0.0)
{
__result = (float)(HeightTimePrecision / (double)magnetudeOnPrecisionDummy *
0.00999999977648258);
Patch.Debug("__result magnetudeOnPrecisionDummy" + __result, LogLevel.Debug,
Patch.DebugPlanetRawData);
return(false);
}
Debug.LogWarning("bad query");
__result = __instance.heightData[0] * 0.01f;
Patch.Debug("__result bad query" + __result, LogLevel.Debug,
Patch.DebugPlanetRawData);
return(false);
}
public static void FlattenTerrainReform(PlanetFactory factory, List <Vector3> points, Vector3 center)
{
if (factory.tmp_ids == null)
{
factory.tmp_ids = new int[1024];
}
if (factory.tmp_entity_ids == null)
{
factory.tmp_entity_ids = new int[1024];
}
Array.Clear(factory.tmp_ids, 0, factory.tmp_ids.Length);
Array.Clear(factory.tmp_entity_ids, 0, factory.tmp_entity_ids.Length);
PlanetRawData data = factory.planet.data;
ushort[] heightData = data.heightData;
short h = (short)(factory.planet.realRadius * 100f + 20f);
bool levelized = factory.planet.levelized;
int step = Mathf.RoundToInt((center.magnitude - 0.2f - factory.planet.realRadius) / 1.3333333f);
int heightT = step * 133 + h - 60;
float heightT2 = factory.planet.radius * 100f - 20f;
foreach (KeyValuePair <int, int> keyValuePair in tmpLevelChanges)
{
if (keyValuePair.Value > 0)
{
ushort height = heightData[keyValuePair.Key];
if (levelized)
{
if (height >= heightT)
{
if (data.GetModLevel(keyValuePair.Key) < 3)
{
data.SetModPlane(keyValuePair.Key, step);
}
factory.planet.AddHeightMapModLevel(keyValuePair.Key, keyValuePair.Value);
}
}
else
{
factory.planet.AddHeightMapModLevel(keyValuePair.Key, keyValuePair.Value);
}
if (height < heightT2)
{
factory.planet.landPercentDirty = true;
}
}
}
if (factory.planet.UpdateDirtyMeshes())
{
factory.RenderLocalPlanetHeightmap();
}
foreach (Vector3 point in points)
{
NearColliderLogic nearColliderLogic = factory.planet.physics.nearColliderLogic;
int num7 = nearColliderLogic.GetVegetablesInAreaNonAlloc(point, 1, factory.tmp_ids);
for (int i = 0; i < num7; i++)
{
int id = factory.tmp_ids[i];
Vector3 position = factory.vegePool[id].pos;
position -= point;
if (position.sqrMagnitude <= 9f)
{
factory.RemoveVegeWithComponents(id);
}
else
{
float d = data.QueryModifiedHeight(factory.vegePool[id].pos) - 0.03f;
factory.vegePool[id].pos = factory.vegePool[id].pos.normalized * d;
GameMain.gpuiManager.AlterModel(factory.vegePool[id].modelIndex, factory.vegePool[id].modelId, id,
factory.vegePool[id].pos, factory.vegePool[id].rot, false);
}
}
}
tmpLevelChanges.Clear();
Array.Clear(factory.tmp_ids, 0, factory.tmp_ids.Length);
Array.Clear(factory.tmp_ids, 0, factory.tmp_entity_ids.Length);
GameMain.gpuiManager.SyncAllGPUBuffer();
}
private static int ScanTerrain(PlanetRawData data, float realRadius, Vector3 vpos, int extent, float fade0)
{
int stride = data.stride;
int dataLength = data.dataLength;
const float minimum = 8f;
Vector3[] vertices = data.vertices;
ushort[] heightData = data.heightData;
int start = data.QueryIndex(vpos);
int cost = 0;
for (int i = -extent; i <= extent; i++)
{
int index = start + i * stride;
if (index < 0 || index >= dataLength)
{
continue;
}
for (int j = -extent; j <= extent; j++)
{
int finalIndex = index + j;
if ((ulong)finalIndex >= (ulong)dataLength)
{
continue;
}
Vector3 groundPos = vertices[finalIndex] * realRadius;
float closestDist = (vpos - groundPos).sqrMagnitude;
int currentLevel = data.GetModLevel(finalIndex);
if (tmpLevelChanges.ContainsKey(finalIndex))
{
currentLevel = tmpLevelChanges[finalIndex];
if (currentLevel == 3)
{
continue;
}
}
int fillLevel;
if (closestDist <= minimum)
{
fillLevel = 3;
}
else
{
closestDist -= minimum;
if (closestDist > fade0 * fade0)
{
continue;
}
float dist = closestDist / (fade0 * fade0);
if (dist <= 0.1111111f)
{
fillLevel = 2;
}
else if (dist <= 0.4444444f)
{
fillLevel = 1;
}
else
{
if (dist >= 1f)
{
continue;
}
fillLevel = 0;
}
}
int fillDiff = fillLevel - currentLevel;
if (fillLevel >= currentLevel && fillDiff != 0)
{
tmpLevelChanges[finalIndex] = fillLevel;
float height = heightData[finalIndex] * 0.01f;
float fillHeight = realRadius + 0.2f - height;
if (fillHeight < 0f)
{
fillHeight *= 2f;
}
float tileCost = 100f * fillDiff * fillHeight * 0.3333333f;
cost += Mathf.FloorToInt(tileCost);
}
}
}
return(cost);
}