Survivalcraft API 1.8.2.3 v1.8.2.3
Survivalcraft 2.4
载入中...
搜索中...
未找到
TerrainContentsGenerator24.cs
浏览该文件的文档.
1using Engine;
2
3namespace Game {
4 public class TerrainContentsGenerator24 : ITerrainContentsGenerator {
5 public class CavePoint {
6 public Vector3 Position;
7
8 public Vector3 Direction;
9
10 public int BrushType;
11
12 public int Length;
13
14 public int StepsTaken;
15 }
16
17 public class Grid2d {
18 public int m_sizeX;
19
20 public int m_sizeY;
21
22 public float[] m_data;
23
24 public int SizeX => m_sizeX;
25
26 public int SizeY => m_sizeY;
27
28 public Grid2d(int sizeX, int sizeY) {
29 m_sizeX = sizeX;
30 m_sizeY = sizeY;
31 m_data = new float[m_sizeX * m_sizeY];
32 }
33
34 public virtual float Get(int x, int y) => m_data[x + y * m_sizeX];
35
36 public virtual void Set(int x, int y, float value) {
37 m_data[x + y * m_sizeX] = value;
38 }
39
40 public virtual float Sample(float x, float y) {
41 int num = (int)MathF.Floor(x);
42 int num2 = (int)MathF.Floor(y);
43 int num3 = (int)MathF.Ceiling(x);
44 int num4 = (int)MathF.Ceiling(y);
45 float f = x - num;
46 float f2 = y - num2;
47 float x2 = m_data[num + num2 * m_sizeX];
48 float x3 = m_data[num3 + num2 * m_sizeX];
49 float x4 = m_data[num + num4 * m_sizeX];
50 float x5 = m_data[num3 + num4 * m_sizeX];
51 float x6 = MathUtils.Lerp(x2, x3, f);
52 float x7 = MathUtils.Lerp(x4, x5, f);
53 return MathUtils.Lerp(x6, x7, f2);
54 }
55 }
56
57 public class Grid3d {
58 public int m_sizeX;
59
60 public int m_sizeY;
61
62 public int m_sizeZ;
63
64 public int m_sizeXY;
65
66 public float[] m_data;
67
68 public int SizeX => m_sizeX;
69
70 public int SizeY => m_sizeY;
71
72 public int SizeZ => m_sizeZ;
73
74 public Grid3d(int sizeX, int sizeY, int sizeZ) {
75 m_sizeX = sizeX;
76 m_sizeY = sizeY;
77 m_sizeZ = sizeZ;
78 m_sizeXY = m_sizeX * m_sizeY;
79 m_data = new float[m_sizeX * m_sizeY * m_sizeZ];
80 }
81
82 public virtual void Get8(int x,
83 int y,
84 int z,
85 out float v111,
86 out float v211,
87 out float v121,
88 out float v221,
89 out float v112,
90 out float v212,
91 out float v122,
92 out float v222) {
93 int num = x + y * m_sizeX + z * m_sizeXY;
94 v111 = m_data[num];
95 v211 = m_data[num + 1];
96 v121 = m_data[num + m_sizeX];
97 v221 = m_data[num + 1 + m_sizeX];
98 v112 = m_data[num + m_sizeXY];
99 v212 = m_data[num + 1 + m_sizeXY];
100 v122 = m_data[num + m_sizeX + m_sizeXY];
101 v222 = m_data[num + 1 + m_sizeX + m_sizeXY];
102 }
103
104 public virtual float Get(int x, int y, int z) => m_data[x + y * m_sizeX + z * m_sizeXY];
105
106 public virtual void Set(int x, int y, int z, float value) {
107 m_data[x + y * m_sizeX + z * m_sizeXY] = value;
108 }
109
110 public virtual float Sample(float x, float y, float z) {
111 int num = (int)MathF.Floor(x);
112 int num2 = (int)MathF.Ceiling(x);
113 int num3 = (int)MathF.Floor(y);
114 int num4 = (int)MathF.Ceiling(y);
115 int num5 = (int)MathF.Floor(z);
116 int num6 = (int)MathF.Ceiling(z);
117 float f = x - num;
118 float f2 = y - num3;
119 float f3 = z - num5;
120 float x2 = m_data[num + num3 * m_sizeX + num5 * m_sizeX * m_sizeY];
121 float x3 = m_data[num2 + num3 * m_sizeX + num5 * m_sizeX * m_sizeY];
122 float x4 = m_data[num + num4 * m_sizeX + num5 * m_sizeX * m_sizeY];
123 float x5 = m_data[num2 + num4 * m_sizeX + num5 * m_sizeX * m_sizeY];
124 float x6 = m_data[num + num3 * m_sizeX + num6 * m_sizeX * m_sizeY];
125 float x7 = m_data[num2 + num3 * m_sizeX + num6 * m_sizeX * m_sizeY];
126 float x8 = m_data[num + num4 * m_sizeX + num6 * m_sizeX * m_sizeY];
127 float x9 = m_data[num2 + num4 * m_sizeX + num6 * m_sizeX * m_sizeY];
128 float x10 = MathUtils.Lerp(x2, x3, f);
129 float x11 = MathUtils.Lerp(x4, x5, f);
130 float x12 = MathUtils.Lerp(x6, x7, f);
131 float x13 = MathUtils.Lerp(x8, x9, f);
132 float x14 = MathUtils.Lerp(x10, x11, f2);
133 float x15 = MathUtils.Lerp(x12, x13, f2);
134 return MathUtils.Lerp(x14, x15, f3);
135 }
136 }
137
138 public static List<TerrainBrush> m_coalBrushes;
139
140 public static List<TerrainBrush> m_ironBrushes;
141
142 public static List<TerrainBrush> m_copperBrushes;
143
144 public static List<TerrainBrush> m_saltpeterBrushes;
145
146 public static List<TerrainBrush> m_sulphurBrushes;
147
148 public static List<TerrainBrush> m_diamondBrushes;
149
150 public static List<TerrainBrush> m_germaniumBrushes;
151
152 public static List<TerrainBrush> m_dirtPocketBrushes;
153
154 public static List<TerrainBrush> m_gravelPocketBrushes;
155
156 public static List<TerrainBrush> m_limestonePocketBrushes;
157
158 public static List<TerrainBrush> m_sandPocketBrushes;
159
160 public static List<TerrainBrush> m_basaltPocketBrushes;
161
162 public static List<TerrainBrush> m_granitePocketBrushes;
163
164 public static List<TerrainBrush> m_clayPocketBrushes;
165
166 public static List<TerrainBrush> m_waterPocketBrushes;
167
168 public static List<TerrainBrush> m_magmaPocketBrushes;
169
170 public static List<List<TerrainBrush>> m_caveBrushesByType;
171
172 public SubsystemTerrain m_subsystemTerrain;
173
174 public SubsystemBottomSuckerBlockBehavior m_subsystemBottomSuckerBlockBehavior;
175
176 public WorldSettings m_worldSettings;
177
178 public int m_seed;
179
180 public Vector2? m_islandSize;
181
182 public Vector2 m_oceanCorner;
183
184 public Vector2 m_temperatureOffset;
185
186 public Vector2 m_humidityOffset;
187
188 public Vector2 m_mountainsOffset;
189
190 public Vector2 m_riversOffset;
191
192 public float TGBiomeScaling;
193
194 public float TGShoreFluctuations;
195
196 public float TGShoreFluctuationsScaling;
197
198 public float TGOceanSlope;
199
200 public float TGOceanSlopeVariation;
201
202 public float TGIslandsFrequency;
203
204 public float TGDensityBias;
205
206 public float TGHeightBias;
207
208 public float TGHillsPercentage;
209
210 public float TGHillsStrength;
211
212 public int TGHillsOctaves;
213
214 public float TGHillsFrequency;
215
216 public float TGHillsPersistence;
217
218 public float TGMountainsStrength;
219
220 public float TGMountainRangeFreq;
221
222 public float TGMountainsPercentage;
223
224 public static float TGMountainsDetailFreq;
225
226 public static int TGMountainsDetailOctaves;
227
228 public static float TGMountainsDetailPersistence;
229
230 public float TGRiversStrength;
231
232 public float TGTurbulenceStrength;
233
234 public float TGTurbulenceFreq;
235
236 public int TGTurbulenceOctaves;
237
238 public float TGTurbulencePersistence;
239
240 public float TGMinTurbulence;
241
242 public float TGTurbulenceZero;
243
244 public static float TGSurfaceMultiplier;
245
246 public bool TGWater;
247
248 public bool TGExtras;
249
250 public bool TGCavesAndPockets;
251
252 public virtual int OceanLevel => 64 + m_worldSettings.SeaLevelOffset;
253
254 public List<ChunkGenerationStep> ChunkGenerationStep1 = [];
255 public List<ChunkGenerationStep> ChunkGenerationStep2 = [];
256 public List<ChunkGenerationStep> ChunkGenerationStep3 = [];
257 public List<ChunkGenerationStep> ChunkGenerationStep4 = [];
258
279
280 public TerrainContentsGenerator24(SubsystemTerrain subsystemTerrain) {
281 m_subsystemTerrain = subsystemTerrain;
282 m_subsystemBottomSuckerBlockBehavior = subsystemTerrain.Project.FindSubsystem<SubsystemBottomSuckerBlockBehavior>(true);
283 SubsystemGameInfo subsystemGameInfo = subsystemTerrain.Project.FindSubsystem<SubsystemGameInfo>(true);
284 m_worldSettings = subsystemGameInfo.WorldSettings;
285 m_seed = subsystemGameInfo.WorldSeed;
286 m_islandSize = m_worldSettings.TerrainGenerationMode == TerrainGenerationMode.Island ? new Vector2?(m_worldSettings.IslandSize) : null;
287 Random random = new(m_seed);
288 float num = m_islandSize.HasValue ? MathUtils.Min(m_islandSize.Value.X, m_islandSize.Value.Y) : float.MaxValue;
289 m_oceanCorner = new Vector2(-200f, -200f);
290 m_temperatureOffset = new Vector2(random.Float(-3000f, 3000f), random.Float(-3000f, 3000f));
291 m_humidityOffset = new Vector2(random.Float(-3000f, 3000f), random.Float(-3000f, 3000f));
292 m_mountainsOffset = new Vector2(random.Float(-3000f, 3000f), random.Float(-3000f, 3000f));
293 m_riversOffset = new Vector2(random.Float(-3000f, 3000f), random.Float(-3000f, 3000f));
294 TGBiomeScaling = (m_worldSettings.TerrainGenerationMode == TerrainGenerationMode.Island ? 1f : 1.75f) * m_worldSettings.BiomeSize;
295 TGShoreFluctuations = Math.Clamp(2f * num, 0f, 150f);
296 TGShoreFluctuationsScaling = Math.Clamp(0.04f * num, 0.5f, 3f);
297 TGOceanSlope = 0.006f;
298 TGOceanSlopeVariation = 0.004f;
299 TGIslandsFrequency = 0.01f;
300 TGDensityBias = 55f;
301 TGHeightBias = 1f;
302 TGRiversStrength = 1f;
303 TGMountainsStrength = 220f;
304 TGMountainRangeFreq = 0.0006f;
305 TGMountainsPercentage = 0.11f;
306 TGMountainsDetailFreq = 0.003f;
307 TGMountainsDetailOctaves = 3;
308 TGMountainsDetailPersistence = 0.53f;
309 TGHillsPercentage = 0.28f;
310 TGHillsStrength = 32f;
311 TGHillsOctaves = 1;
312 TGHillsFrequency = 0.014f;
313 TGHillsPersistence = 0.5f;
314 TGTurbulenceStrength = 55f;
315 TGTurbulenceFreq = 0.03f;
316 TGTurbulenceOctaves = 1;
317 TGTurbulencePersistence = 0.5f;
318 TGMinTurbulence = 0.04f;
319 TGTurbulenceZero = 0.84f;
320 TGSurfaceMultiplier = 2f;
321 TGWater = true;
322 TGExtras = true;
323 TGCavesAndPockets = true;
324 //Step 1
325 ChunkGenerationStep1.Add(new ChunkGenerationStep(1000, chunk => GenerateSurfaceParameters(chunk, 0, 0, 16, 8)));
326 ChunkGenerationStep1.Add(new ChunkGenerationStep(2000, chunk => GenerateTerrain(chunk, 0, 0, 16, 8)));
327 //Step 2
328 ChunkGenerationStep2.Add(new ChunkGenerationStep(1000, chunk => GenerateSurfaceParameters(chunk, 0, 8, 16, 16)));
329 ChunkGenerationStep2.Add(new ChunkGenerationStep(2000, chunk => GenerateTerrain(chunk, 0, 8, 16, 16)));
330 //Step 3
331 ChunkGenerationStep3.Add(new ChunkGenerationStep(100, GenerateCaves));
332 ChunkGenerationStep3.Add(new ChunkGenerationStep(200, GeneratePockets));
333 ChunkGenerationStep3.Add(new ChunkGenerationStep(300, GenerateMinerals));
334 ChunkGenerationStep3.Add(new ChunkGenerationStep(400, GenerateSurface));
335 ChunkGenerationStep3.Add(new ChunkGenerationStep(500, PropagateFluidsDownwards));
336 //step 4
337 ChunkGenerationStep4.Add(new ChunkGenerationStep(100, GenerateGrassAndPlants));
338 ChunkGenerationStep4.Add(new ChunkGenerationStep(200, GenerateLogs));
339 ChunkGenerationStep4.Add(new ChunkGenerationStep(300, GenerateTrees));
340 ChunkGenerationStep4.Add(new ChunkGenerationStep(400, GenerateCacti));
341 ChunkGenerationStep4.Add(new ChunkGenerationStep(500, GeneratePumpkins));
342 ChunkGenerationStep4.Add(new ChunkGenerationStep(600, GenerateKelp));
343 ChunkGenerationStep4.Add(new ChunkGenerationStep(700, GenerateSeagrass));
344 ChunkGenerationStep4.Add(new ChunkGenerationStep(800, GenerateBottomSuckers));
345 ChunkGenerationStep4.Add(new ChunkGenerationStep(900, GenerateTraps));
346 ChunkGenerationStep4.Add(new ChunkGenerationStep(1000, GenerateIvy));
347 ChunkGenerationStep4.Add(new ChunkGenerationStep(1100, GenerateGraves));
348 ChunkGenerationStep4.Add(new ChunkGenerationStep(1200, GenerateCairns));
349 ChunkGenerationStep4.Add(new ChunkGenerationStep(1300, GenerateSnowAndIce));
350 ChunkGenerationStep4.Add(new ChunkGenerationStep(1400, GenerateBedrockAndAir));
351 ChunkGenerationStep4.Add(new ChunkGenerationStep(1500, UpdateFluidIsTop));
352 ModsManager.HookAction(
353 "TerrainContentsGenerator24Initialize",
354 loader => {
355 loader.TerrainContentsGenerator24Initialize(this, subsystemTerrain);
356 return false;
357 }
358 );
359 ChunkGenerationStep1.Sort((a, b) => a.GenerateOrder.CompareTo(b.GenerateOrder));
360 ChunkGenerationStep2.Sort((a, b) => a.GenerateOrder.CompareTo(b.GenerateOrder));
361 ChunkGenerationStep3.Sort((a, b) => a.GenerateOrder.CompareTo(b.GenerateOrder));
362 ChunkGenerationStep4.Sort((a, b) => a.GenerateOrder.CompareTo(b.GenerateOrder));
363 }
364
365 public virtual Vector3 FindCoarseSpawnPosition() {
366 Vector2 vector = Vector2.Zero;
367 float num = float.MinValue;
368 for (int i = 0; i < 1000; i += 5) {
369 for (int j = 0; j <= 10; j += 5) {
370 for (int k = 0; k < 2; k++) {
371 float num2;
372 float x;
373 if (k == 0) {
374 num2 = m_oceanCorner.Y + i;
375 x = CalculateOceanShoreX(num2) + j;
376 }
377 else {
378 x = m_oceanCorner.X + i;
379 num2 = CalculateOceanShoreZ(x) + j;
380 }
381 float num3 = ScoreSpawnPosition(Terrain.ToCell(x), Terrain.ToCell(num2));
382 if (num3 > num) {
383 vector = new Vector2(x, num2);
384 num = num3;
385 }
386 }
387 }
388 }
389 Vector3 ans = new(vector.X, CalculateHeight(vector.X, vector.Y), vector.Y);
390 ModsManager.HookAction(
391 "FindCoarseSpawnPosition",
392 loader => {
393 loader.FindCoarseSpawnPosition(this, ref ans);
394 return false;
395 }
396 );
397 return ans;
398 }
399
400 public virtual void GenerateChunkContentsPass1(TerrainChunk chunk) {
401 foreach (ChunkGenerationStep step in ChunkGenerationStep1) {
402 CallChunkGenerationStepAction(step, chunk);
403 }
404 }
405
406 public virtual void GenerateChunkContentsPass2(TerrainChunk chunk) {
407 foreach (ChunkGenerationStep step in ChunkGenerationStep2) {
408 CallChunkGenerationStepAction(step, chunk);
409 }
410 }
411
412 public virtual void GenerateChunkContentsPass3(TerrainChunk chunk) {
413 foreach (ChunkGenerationStep step in ChunkGenerationStep3) {
414 CallChunkGenerationStepAction(step, chunk);
415 }
416 }
417
418 public virtual void GenerateChunkContentsPass4(TerrainChunk chunk) {
419 foreach (ChunkGenerationStep step in ChunkGenerationStep4) {
420 CallChunkGenerationStepAction(step, chunk);
421 }
422 }
423
424 public virtual float CalculateOceanShoreDistance(float x, float z) {
425 if (m_islandSize.HasValue) {
426 float num = CalculateOceanShoreX(z);
427 float num2 = CalculateOceanShoreZ(x);
428 float num3 = CalculateOceanShoreX(z + 1000f) + m_islandSize.Value.X;
429 float num4 = CalculateOceanShoreZ(x + 1000f) + m_islandSize.Value.Y;
430 return MathUtils.Min(x - num, z - num2, num3 - x, num4 - z);
431 }
432 float num5 = CalculateOceanShoreX(z);
433 float num6 = CalculateOceanShoreZ(x);
434 return MathUtils.Min(x - num5, z - num6);
435 }
436
437 public virtual float CalculateMountainRangeFactor(float x, float z) => SimplexNoise.OctavedNoise(
438 x + m_mountainsOffset.X,
439 z + m_mountainsOffset.Y,
440 TGMountainRangeFreq / TGBiomeScaling,
441 3,
442 1.91f,
443 0.75f,
444 true
445 );
446
447 public virtual float CalculateHeight(float x, float z) {
448 float num = TGOceanSlope
449 + TGOceanSlopeVariation
450 * MathUtils.PowSign(2f * SimplexNoise.OctavedNoise(x + m_mountainsOffset.X, z + m_mountainsOffset.Y, 0.01f, 1, 2f, 0.5f) - 1f, 0.5f);
451 float num2 = CalculateOceanShoreDistance(x, z);
452 float num3 = MathUtils.Saturate(2f - 0.05f * MathF.Abs(num2));
453 float num4 = MathUtils.Saturate(MathF.Sin(TGIslandsFrequency * num2));
454 float num5 = MathUtils.Saturate(MathUtils.Saturate((0f - num) * num2) - 0.85f * num4);
455 float num6 = MathUtils.Saturate(MathUtils.Saturate(0.05f * (0f - num2 - 10f)) - num4);
456 float v = CalculateMountainRangeFactor(x, z);
457 float f = (1f - num3) * SimplexNoise.OctavedNoise(x, z, 0.001f / TGBiomeScaling, 2, 2f, 0.5f);
458 float f2 = (1f - num3) * SimplexNoise.OctavedNoise(x, z, 0.0017f / TGBiomeScaling, 2, 4f, 0.7f);
459 float num7 = (1f - num6) * (1f - num3) * Squish(v, 1f - TGHillsPercentage, 1f - TGMountainsPercentage);
460 float num8 = (1f - num6) * Squish(v, 1f - TGMountainsPercentage, 1f);
461 float num9 = 1f * SimplexNoise.OctavedNoise(x, z, TGHillsFrequency, TGHillsOctaves, 1.93f, TGHillsPersistence);
462 float amplitudeStep = MathUtils.Lerp(0.75f * TGMountainsDetailPersistence, 1.33f * TGMountainsDetailPersistence, f);
463 float num10 = 1.5f * SimplexNoise.OctavedNoise(x, z, TGMountainsDetailFreq, TGMountainsDetailOctaves, 1.98f, amplitudeStep) - 0.5f;
464 float num11 = MathUtils.Lerp(80f, 35f, MathUtils.Saturate(1f * num8 + 0.5f * num7 + MathUtils.Saturate(1f - num2 / 30f)));
465 float x2 = MathUtils.Lerp(-2f, -4f, MathUtils.Saturate(num8 + 0.5f * num7));
466 float num12 = MathUtils.Saturate(
467 1.5f - num11 * MathF.Abs(2f * SimplexNoise.OctavedNoise(x + m_riversOffset.X, z + m_riversOffset.Y, 0.001f, 4, 2f, 0.5f) - 1f)
468 );
469 float num13 = -50f * num5 + TGHeightBias;
470 float num14 = MathUtils.Lerp(0f, 8f, f);
471 float num15 = MathUtils.Lerp(0f, -6f, f2);
472 float num16 = TGHillsStrength * num7 * num9;
473 float num17 = TGMountainsStrength * num8 * num10;
474 float f3 = TGRiversStrength * num12;
475 float num18 = num13 + num14 + num15 + num17 + num16;
476 float num19 = MathUtils.Min(MathUtils.Lerp(num18, x2, f3), num18);
477 return Math.Clamp(64f + num19, 10f, 251f);
478 }
479
480 public virtual int CalculateTemperature(float x, float z) => Math.Clamp(
481 (int)(MathUtils.Saturate(
482 3f * SimplexNoise.OctavedNoise(x + m_temperatureOffset.X, z + m_temperatureOffset.Y, 0.0015f / TGBiomeScaling, 5, 2f, 0.6f)
483 - 1.1f
484 + m_worldSettings.TemperatureOffset / 16f
485 )
486 * 16f),
487 0,
488 15
489 );
490
491 public virtual int CalculateHumidity(float x, float z) => Math.Clamp(
492 (int)(MathUtils.Saturate(
493 3f * SimplexNoise.OctavedNoise(x + m_humidityOffset.X, z + m_humidityOffset.Y, 0.0012f / TGBiomeScaling, 5, 2f, 0.6f)
494 - 0.9f
495 + m_worldSettings.HumidityOffset / 16f
496 )
497 * 16f),
498 0,
499 15
500 );
501
502 public static float Squish(float v, float zero, float one) => MathUtils.Saturate((v - zero) / (one - zero));
503
504 public virtual float CalculateOceanShoreX(float z) => m_oceanCorner.X
505 + TGShoreFluctuations * SimplexNoise.OctavedNoise(z, 0f, 0.005f / TGShoreFluctuationsScaling, 4, 1.95f, 1f);
506
507 public virtual float CalculateOceanShoreZ(float x) => m_oceanCorner.Y
508 + TGShoreFluctuations * SimplexNoise.OctavedNoise(0f, x, 0.005f / TGShoreFluctuationsScaling, 4, 1.95f, 1f);
509
510 public virtual float CalculateForestDensity(float x, float z) {
511 Point2 point = Terrain.ToChunk(new Vector2(x, z));
512 bool flag = MathUtils.Hash((uint)(point.X + 1000 * point.Y)) % 1000 < 300;
513 return MathUtils.Saturate((SimplexNoise.OctavedNoise(point.X, point.Y, 0.1f, 2, 2f, 0.5f) - 0.25f) / 0.2f + (flag ? 0.6f : 0f));
514 }
515
516 public virtual float ScoreSpawnPosition(int x, int z) {
517 int num = CalculateTemperature(x, z);
518 int num2 = CalculateHumidity(x, z);
519 float x2 = CalculateMountainRangeFactor(x, z);
520 float num3 = CalculateHeight(x, z);
521 float x3 = CalculateHeight(x - 8, z - 8);
522 float x4 = CalculateHeight(x - 8, z + 8);
523 float x5 = CalculateHeight(x + 8, z - 8);
524 float x6 = CalculateHeight(x + 8, z + 8);
525 float num4 = MathUtils.Min(num3, MathUtils.Max(x3, x4, x5, x6));
526 float x7 = MathUtils.Max(num3, MathUtils.Max(x3, x4, x5, x6)) - num4;
527 float num5 = 0f;
528 int num6 = 0;
529 for (int i = -4; i <= 4; i += 2) {
530 for (int j = -4; j <= 4; j += 2) {
531 num5 += CalculateForestDensity(x + i * 16, z + j * 16);
532 num6++;
533 }
534 }
535 num5 /= num6;
536 int num7 = Math.Max(Math.Abs(x), Math.Abs(z));
537 float num8 = 0f;
538 num8 -= 0.001f * DistanceFromRange(num7, 0f, 400f);
539 switch (m_subsystemTerrain.SubsystemGameInfo.WorldSettings.StartingPositionMode) {
540 case StartingPositionMode.Easy:
541 num8 -= DistanceFromRange(num, 5f, 15f);
542 num8 -= DistanceFromRange(num2, 4f, 15f);
543 num8 -= 2f * DistanceFromRange(num3, 67f, 72f);
544 num8 -= 2f * DistanceFromRange(x7, 0f, 4f);
545 num8 -= 30f * DistanceFromRange(x2, 0f, 0.75f);
546 return num8 - 30f * DistanceFromRange(num5, 0.75f, 1f);
547 case StartingPositionMode.Medium:
548 num8 -= DistanceFromRange(num, 3f, 4f);
549 num8 -= 2f * DistanceFromRange(num3, 67f, 76f);
550 num8 -= 2f * DistanceFromRange(x7, 0f, 6f);
551 num8 -= 30f * DistanceFromRange(x2, 0f, 0.8f);
552 return num8 - 30f * DistanceFromRange(num5, 0.5f, 1f);
553 default:
554 num8 -= DistanceFromRange(num, 0f, 0f);
555 return num8 - 2f * DistanceFromRange(num3, 67f, 80f);
556 }
557 }
558
559 public static float DistanceFromRange(float x, float min, float max) {
560 if (x < min) {
561 return min - x;
562 }
563 if (x > max) {
564 return x - max;
565 }
566 return 0f;
567 }
568
569 public virtual void GenerateSurfaceParameters(TerrainChunk chunk, int x1, int z1, int x2, int z2) {
570 for (int i = x1; i < x2; i++) {
571 for (int j = z1; j < z2; j++) {
572 int num = i + chunk.Origin.X;
573 int num2 = j + chunk.Origin.Y;
574 int temperature = CalculateTemperature(num, num2);
575 int humidity = CalculateHumidity(num, num2);
576 chunk.SetTemperatureFast(i, j, temperature);
577 chunk.SetHumidityFast(i, j, humidity);
578 }
579 }
580 }
581
582 public virtual void GenerateTerrain(TerrainChunk chunk, int x1, int z1, int x2, int z2) {
583 int num = x2 - x1;
584 int num2 = z2 - z1;
585 _ = m_subsystemTerrain.Terrain;
586 int num3 = chunk.Origin.X + x1;
587 int num4 = chunk.Origin.Y + z1;
588 Grid2d grid2d = new(num, num2);
589 Grid2d grid2d2 = new(num, num2);
590 for (int i = 0; i < num2; i++) {
591 for (int j = 0; j < num; j++) {
592 grid2d.Set(j, i, CalculateOceanShoreDistance(j + num3, i + num4));
593 grid2d2.Set(j, i, CalculateMountainRangeFactor(j + num3, i + num4));
594 }
595 }
596 Grid3d grid3d = new(num / 4 + 1, 33, num2 / 4 + 1);
597 for (int k = 0; k < grid3d.SizeX; k++) {
598 for (int l = 0; l < grid3d.SizeZ; l++) {
599 int num5 = k * 4 + num3;
600 int num6 = l * 4 + num4;
601 float num7 = CalculateHeight(num5, num6);
602 float v = CalculateMountainRangeFactor(num5, num6);
603 float num8 = MathUtils.Lerp(TGMinTurbulence, 1f, Squish(v, TGTurbulenceZero, 1f));
604 for (int m = 0; m < grid3d.SizeY; m++) {
605 int num9 = m * 8;
606 float num10 = TGTurbulenceStrength
607 * num8
608 * MathUtils.Saturate(num7 - num9)
609 * (2f
610 * SimplexNoise.OctavedNoise(
611 num5,
612 num9,
613 num6,
614 TGTurbulenceFreq,
615 TGTurbulenceOctaves,
616 4f,
617 TGTurbulencePersistence
618 )
619 - 1f);
620 float num11 = num9 + num10;
621 float num12 = num7 - num11;
622 num12 += MathUtils.Max(4f * (TGDensityBias - num9), 0f);
623 grid3d.Set(k, m, l, num12);
624 }
625 }
626 }
627 int oceanLevel = OceanLevel;
628 for (int n = 0; n < grid3d.SizeX - 1; n++) {
629 for (int num13 = 0; num13 < grid3d.SizeZ - 1; num13++) {
630 for (int num14 = 0; num14 < grid3d.SizeY - 1; num14++) {
631 grid3d.Get8(
632 n,
633 num14,
634 num13,
635 out float v2,
636 out float v3,
637 out float v4,
638 out float v5,
639 out float v6,
640 out float v7,
641 out float v8,
642 out float v9
643 );
644 float num15 = (v3 - v2) / 4f;
645 float num16 = (v5 - v4) / 4f;
646 float num17 = (v7 - v6) / 4f;
647 float num18 = (v9 - v8) / 4f;
648 float num19 = v2;
649 float num20 = v4;
650 float num21 = v6;
651 float num22 = v8;
652 for (int num23 = 0; num23 < 4; num23++) {
653 float num24 = (num21 - num19) / 4f;
654 float num25 = (num22 - num20) / 4f;
655 float num26 = num19;
656 float num27 = num20;
657 for (int num28 = 0; num28 < 4; num28++) {
658 float num29 = (num27 - num26) / 8f;
659 float num30 = num26;
660 int num31 = num23 + n * 4;
661 int num32 = num28 + num13 * 4;
662 int x3 = x1 + num31;
663 int z3 = z1 + num32;
664 float x4 = grid2d.Get(num31, num32);
665 float num33 = grid2d2.Get(num31, num32);
666 int temperatureFast = chunk.GetTemperatureFast(x3, z3);
667 int humidityFast = chunk.GetHumidityFast(x3, z3);
668 float f = num33 - 0.01f * humidityFast;
669 float num34 = MathUtils.Lerp(100f, 0f, f);
670 float num35 = MathUtils.Lerp(300f, 30f, f);
671 bool flag = (temperatureFast > 8 && humidityFast < 8 && num33 < 0.97f) || (MathF.Abs(x4) < 16f && num33 < 0.97f);
672 int num36 = TerrainChunk.CalculateCellIndex(x3, 0, z3);
673 for (int num37 = 0; num37 < 8; num37++) {
674 int num38 = num37 + num14 * 8;
675 int value = 0;
676 if (num30 < 0f) {
677 if (num38 <= oceanLevel) {
678 value = 18;
679 }
680 }
681 else {
682 value = !flag ? !(num30 < num35) ? 67 : 3 :
683 !(num30 < num34) ? !(num30 < num35) ? 67 : 3 : 4;
684 }
685 chunk.SetCellValueFast(num36 + num38, value);
686 num30 += num29;
687 }
688 num26 += num24;
689 num27 += num25;
690 }
691 num19 += num15;
692 num20 += num16;
693 num21 += num17;
694 num22 += num18;
695 }
696 }
697 }
698 }
699 }
700
701 public virtual void GenerateSurface(TerrainChunk chunk) {
702 Terrain terrain = m_subsystemTerrain.Terrain;
703 Random random = new(m_seed + chunk.Coords.X + 101 * chunk.Coords.Y);
704 for (int i = 0; i < 16; i++) {
705 for (int j = 0; j < 16; j++) {
706 int num = i + chunk.Origin.X;
707 int num2 = j + chunk.Origin.Y;
708 int num3 = TerrainChunk.CalculateCellIndex(i, 254, j);
709 int num4 = 254;
710 while (num4 >= 0) {
711 int cellValue = chunk.GetCellValueFast(num3);
712 int num5 = Terrain.ExtractContents(cellValue);
713 if (!BlocksManager.Blocks[num5].IsTransparent_(cellValue)) {
714 float num6 = CalculateMountainRangeFactor(num, num2);
715 int temperature = terrain.GetTemperature(num, num2);
716 int humidity = terrain.GetHumidity(num, num2);
717 int num7;
718 if (num5 == 4) {
719 num7 = temperature > 4 && temperature < 7 ? 6 : 7;
720 }
721 else {
722 int num8 = temperature / 4;
723 int num9 = num4 + 1 < 255 ? chunk.GetCellContentsFast(i, num4 + 1, j) : 0;
724 num7 = num4 > 120 && SubsystemWeather.IsPlaceFrozen(temperature, num4) ? 62 :
725 (num4 < 66 || num4 == 84 + num8 || num4 == 103 + num8) && humidity == 9 && temperature % 6 == 1 ? 66 :
726 num9 != 18 || humidity <= 8 || humidity % 2 != 0 || temperature % 3 != 0 ? 2 : 72;
727 }
728 int num10;
729 if (num7 == 62) {
730 num10 = (int)Math.Clamp(1f * -temperature, 1f, 7f);
731 }
732 else {
733 float num11 = MathUtils.Saturate((num4 - 100f) * 0.05f);
734 float f = MathUtils.Saturate(
735 MathUtils.Saturate((num6 - 0.9f) / 0.1f) - MathUtils.Saturate((humidity - 3f) / 12f) + TGSurfaceMultiplier * num11
736 );
737 int min = (int)MathUtils.Lerp(4f, 0f, f);
738 int max = (int)MathUtils.Lerp(7f, 0f, f);
739 num10 = MathUtils.Min(random.Int(min, max), num4);
740 }
741 int num12 = TerrainChunk.CalculateCellIndex(i, num4 + 1, j);
742 for (int k = num12 - num10; k < num12; k++) {
743 if (Terrain.ExtractContents(chunk.GetCellValueFast(k)) != 0) {
744 int value = Terrain.ReplaceContents(num7);
745 chunk.SetCellValueFast(k, value);
746 }
747 }
748 break;
749 }
750 num4--;
751 num3--;
752 }
753 }
754 }
755 }
756
757 public virtual void GenerateMinerals(TerrainChunk chunk) {
758 if (!TGCavesAndPockets) {
759 return;
760 }
761 int x = chunk.Coords.X;
762 int y = chunk.Coords.Y;
763 for (int i = x - 1; i <= x + 1; i++) {
764 for (int j = y - 1; j <= y + 1; j++) {
765 Random random = new(m_seed + i + 119 * j);
766 int num = random.Int(0, 10);
767 for (int k = 0; k < num; k++) {
768 random.Int(0, 1);
769 }
770 float num2 = CalculateMountainRangeFactor(i * 16, j * 16);
771 int num3 = (int)(5f + 3f * num2 * SimplexNoise.OctavedNoise(i, j, 0.33f, 1, 1f, 1f));
772 for (int l = 0; l < num3; l++) {
773 int x2 = i * 16 + random.Int(0, 15);
774 int y2 = random.Int(5, 200);
775 int z = j * 16 + random.Int(0, 15);
776 m_coalBrushes[random.Int(0, m_coalBrushes.Count - 1)].PaintFastSelective(chunk, x2, y2, z, 3);
777 }
778 int num4 = (int)(6f + 2f * num2 * SimplexNoise.OctavedNoise(i + 1211, j + 396, 0.33f, 1, 1f, 1f));
779 for (int m = 0; m < num4; m++) {
780 int x3 = i * 16 + random.Int(0, 15);
781 int y3 = random.Int(20, 65);
782 int z2 = j * 16 + random.Int(0, 15);
783 m_copperBrushes[random.Int(0, m_copperBrushes.Count - 1)].PaintFastSelective(chunk, x3, y3, z2, 3);
784 }
785 int num5 = (int)(5f + 2f * num2 * SimplexNoise.OctavedNoise(i + 713, j + 211, 0.33f, 1, 1f, 1f));
786 for (int n = 0; n < num5; n++) {
787 int x4 = i * 16 + random.Int(0, 15);
788 int y4 = random.Int(2, 40);
789 int z3 = j * 16 + random.Int(0, 15);
790 m_ironBrushes[random.Int(0, m_ironBrushes.Count - 1)].PaintFastSelective(chunk, x4, y4, z3, 67);
791 }
792 int num6 = (int)(3f + 3f * num2 * SimplexNoise.OctavedNoise(i + 915, j + 272, 0.33f, 1, 1f, 1f));
793 for (int num7 = 0; num7 < num6; num7++) {
794 int x5 = i * 16 + random.Int(0, 15);
795 int y5 = random.Int(50, 90);
796 int z4 = j * 16 + random.Int(0, 15);
797 m_saltpeterBrushes[random.Int(0, m_saltpeterBrushes.Count - 1)].PaintFastSelective(chunk, x5, y5, z4, 4);
798 }
799 int num8 = (int)(3f + 2f * num2 * SimplexNoise.OctavedNoise(i + 711, j + 1194, 0.33f, 1, 1f, 1f));
800 for (int num9 = 0; num9 < num8; num9++) {
801 int x6 = i * 16 + random.Int(0, 15);
802 int y6 = random.Int(2, 40);
803 int z5 = j * 16 + random.Int(0, 15);
804 m_sulphurBrushes[random.Int(0, m_sulphurBrushes.Count - 1)].PaintFastSelective(chunk, x6, y6, z5, 67);
805 }
806 int num10 = (int)(0.5f + 2f * num2 * SimplexNoise.OctavedNoise(i + 432, j + 907, 0.33f, 1, 1f, 1f));
807 for (int num11 = 0; num11 < num10; num11++) {
808 int x7 = i * 16 + random.Int(0, 15);
809 int y7 = random.Int(2, 15);
810 int z6 = j * 16 + random.Int(0, 15);
811 m_diamondBrushes[random.Int(0, m_diamondBrushes.Count - 1)].PaintFastSelective(chunk, x7, y7, z6, 67);
812 }
813 int num12 = (int)(3f + 2f * num2 * SimplexNoise.OctavedNoise(i + 799, j + 131, 0.33f, 1, 1f, 1f));
814 for (int num13 = 0; num13 < num12; num13++) {
815 int x8 = i * 16 + random.Int(0, 15);
816 int y8 = random.Int(2, 50);
817 int z7 = j * 16 + random.Int(0, 15);
818 m_germaniumBrushes[random.Int(0, m_germaniumBrushes.Count - 1)].PaintFastSelective(chunk, x8, y8, z7, 67);
819 }
820 }
821 }
822 }
823
824 public virtual void GeneratePockets(TerrainChunk chunk) {
825 if (!TGCavesAndPockets) {
826 return;
827 }
828 for (int i = -1; i <= 1; i++) {
829 for (int j = -1; j <= 1; j++) {
830 int num = i + chunk.Coords.X;
831 int num2 = j + chunk.Coords.Y;
832 Random random = new(m_seed + num + 71 * num2);
833 int num3 = random.Int(0, 10);
834 for (int k = 0; k < num3; k++) {
835 random.Int(0, 1);
836 }
837 float num4 = CalculateMountainRangeFactor(num * 16, num2 * 16);
838 for (int l = 0; l < 5; l++) {
839 int x = num * 16 + random.Int(0, 15);
840 int y = random.Int(50, 150);
841 int z = num2 * 16 + random.Int(0, 15);
842 m_dirtPocketBrushes[random.Int(0, m_dirtPocketBrushes.Count - 1)].PaintFastSelective(chunk, x, y, z, 3);
843 }
844 for (int m = 0; m < 20; m++) {
845 int x2 = num * 16 + random.Int(0, 15);
846 int y2 = random.Int(20, 120);
847 int z2 = num2 * 16 + random.Int(0, 15);
848 m_gravelPocketBrushes[random.Int(0, m_gravelPocketBrushes.Count - 1)].PaintFastSelective(chunk, x2, y2, z2, 3);
849 }
850 for (int n = 0; n < 5; n++) {
851 int x3 = num * 16 + random.Int(0, 15);
852 int y3 = random.Int(10, 200);
853 int z3 = num2 * 16 + random.Int(0, 15);
854 m_limestonePocketBrushes[random.Int(0, m_limestonePocketBrushes.Count - 1)].PaintFastSelective(chunk, x3, y3, z3, 3);
855 }
856 for (int num5 = 0; num5 < 1; num5++) {
857 int x4 = num * 16 + random.Int(0, 15);
858 int y4 = random.Int(50, 70);
859 int z4 = num2 * 16 + random.Int(0, 15);
860 m_clayPocketBrushes[random.Int(0, m_clayPocketBrushes.Count - 1)].PaintFastSelective(chunk, x4, y4, z4, 3);
861 }
862 for (int num6 = 0; num6 < 20; num6++) {
863 int x5 = num * 16 + random.Int(0, 15);
864 int y5 = random.Int(20, 120);
865 int z5 = num2 * 16 + random.Int(0, 15);
866 m_sandPocketBrushes[random.Int(0, m_sandPocketBrushes.Count - 1)].PaintFastSelective(chunk, x5, y5, z5, 4);
867 }
868 for (int num7 = 0; num7 < 4; num7++) {
869 int x6 = num * 16 + random.Int(0, 15);
870 int y6 = random.Int(40, 60);
871 int z6 = num2 * 16 + random.Int(0, 15);
872 m_basaltPocketBrushes[random.Int(0, m_basaltPocketBrushes.Count - 1)].PaintFastSelective(chunk, x6, y6, z6, 4);
873 }
874 for (int num8 = 0; num8 < 3; num8++) {
875 int x7 = num * 16 + random.Int(0, 15);
876 int y7 = random.Int(20, 40);
877 int z7 = num2 * 16 + random.Int(0, 15);
878 m_basaltPocketBrushes[random.Int(0, m_basaltPocketBrushes.Count - 1)].PaintFastSelective(chunk, x7, y7, z7, 3);
879 }
880 for (int num9 = 0; num9 < 6; num9++) {
881 int x8 = num * 16 + random.Int(0, 15);
882 int y8 = random.Int(4, 50);
883 int z8 = num2 * 16 + random.Int(0, 15);
884 m_granitePocketBrushes[random.Int(0, m_granitePocketBrushes.Count - 1)].PaintFastSelective(chunk, x8, y8, z8, 67);
885 }
886 for (int num10 = 0; num10 < 20; num10++) {
887 int x9 = num * 16 + random.Int(0, 15);
888 int y9 = random.Int(4, 120);
889 int z9 = num2 * 16 + random.Int(0, 15);
890 m_gravelPocketBrushes[random.Int(0, m_gravelPocketBrushes.Count - 1)].PaintFastSelective(chunk, x9, y9, z9, 67);
891 }
892 if (random.Bool(0.02f + 0.01f * num4)) {
893 int num11 = num * 16;
894 int num12 = random.Int(40, 60);
895 int num13 = num2 * 16;
896 int num14 = random.Int(1, 3);
897 for (int num15 = 0; num15 < num14; num15++) {
898 Vector2 vector = random.Vector2(7f);
899 int num16 = 8 + (int)MathF.Round(vector.X);
900 int num17 = 0;
901 int num18 = 8 + (int)MathF.Round(vector.Y);
902 m_waterPocketBrushes[random.Int(0, m_waterPocketBrushes.Count - 1)]
903 .PaintFast(chunk, num11 + num16, num12 + num17, num13 + num18);
904 }
905 }
906 if (random.Bool(0.06f + 0.05f * num4)) {
907 int num19 = num * 16;
908 int num20 = random.Int(15, 42);
909 int num21 = num2 * 16;
910 int num22 = random.Int(1, 2);
911 for (int num23 = 0; num23 < num22; num23++) {
912 Vector2 vector2 = random.Vector2(7f);
913 int num24 = 8 + (int)MathF.Round(vector2.X);
914 int num25 = random.Int(0, 1);
915 int num26 = 8 + (int)MathF.Round(vector2.Y);
916 m_magmaPocketBrushes[random.Int(0, m_magmaPocketBrushes.Count - 1)]
917 .PaintFast(chunk, num19 + num24, num20 + num25, num21 + num26);
918 }
919 }
920 }
921 }
922 }
923
924 public virtual void GenerateCaves(TerrainChunk chunk) {
925 if (!TGCavesAndPockets) {
926 return;
927 }
928 List<CavePoint> list = [];
929 int x = chunk.Coords.X;
930 int y = chunk.Coords.Y;
931 for (int i = x - 2; i <= x + 2; i++) {
932 for (int j = y - 2; j <= y + 2; j++) {
933 list.Clear();
934 Random random = new(m_seed + i + 9973 * j);
935 int num = i * 16 + random.Int(0, 15);
936 int num2 = j * 16 + random.Int(0, 15);
937 float probability = 0.5f;
938 if (!random.Bool(probability)) {
939 continue;
940 }
941 int num3 = (int)CalculateHeight(num, num2);
942 int num4 = (int)CalculateHeight(num + 3, num2);
943 int num5 = (int)CalculateHeight(num, num2 + 3);
944 Vector3 position = new(num, num3 - 1, num2);
945 Vector3 v = new(3f, num4 - num3, 0f);
946 Vector3 v2 = new(0f, num5 - num3, 3f);
947 Vector3 direction = Vector3.Normalize(Vector3.Cross(v, v2));
948 if (direction.Y > -0.6f) {
949 list.Add(new CavePoint { Position = position, Direction = direction, BrushType = 0, Length = random.Int(80, 240) });
950 }
951 int num6 = i * 16 + 8;
952 int num7 = j * 16 + 8;
953 int num8 = 0;
954 while (num8 < list.Count) {
955 CavePoint cavePoint = list[num8];
956 List<TerrainBrush> list2 = m_caveBrushesByType[cavePoint.BrushType];
957 list2[random.Int(0, list2.Count - 1)]
958 .PaintFastAvoidWater(
959 chunk,
960 Terrain.ToCell(cavePoint.Position.X),
961 Terrain.ToCell(cavePoint.Position.Y),
962 Terrain.ToCell(cavePoint.Position.Z)
963 );
964 cavePoint.Position += 2f * cavePoint.Direction;
965 cavePoint.StepsTaken += 2;
966 float num9 = cavePoint.Position.X - num6;
967 float num10 = cavePoint.Position.Z - num7;
968 if (random.Bool(0.5f)) {
969 Vector3 vector = Vector3.Normalize(random.Vector3(1f));
970 if ((num9 < -25.5f && vector.X < 0f)
971 || (num9 > 25.5f && vector.X > 0f)) {
972 vector.X = 0f - vector.X;
973 }
974 if ((num10 < -25.5f && vector.Z < 0f)
975 || (num10 > 25.5f && vector.Z > 0f)) {
976 vector.Z = 0f - vector.Z;
977 }
978 if ((cavePoint.Direction.Y < -0.5f && vector.Y < -10f)
979 || (cavePoint.Direction.Y > 0.1f && vector.Y > 0f)) {
980 vector.Y = 0f - vector.Y;
981 }
982 cavePoint.Direction = Vector3.Normalize(cavePoint.Direction + 0.5f * vector);
983 }
984 if (cavePoint.StepsTaken > 20
985 && random.Bool(0.06f)) {
986 cavePoint.Direction = Vector3.Normalize(random.Vector3(1f) * new Vector3(1f, 0.33f, 1f));
987 }
988 if (cavePoint.StepsTaken > 20
989 && random.Bool(0.05f)) {
990 cavePoint.Direction.Y = 0f;
991 cavePoint.BrushType = MathUtils.Min(cavePoint.BrushType + 2, m_caveBrushesByType.Count - 1);
992 }
993 if (cavePoint.StepsTaken > 30
994 && random.Bool(0.03f)) {
995 cavePoint.Direction.X = 0f;
996 cavePoint.Direction.Y = -1f;
997 cavePoint.Direction.Z = 0f;
998 }
999 if (cavePoint.StepsTaken > 30
1000 && cavePoint.Position.Y < 30f
1001 && random.Bool(0.02f)) {
1002 cavePoint.Direction.X = 0f;
1003 cavePoint.Direction.Y = 1f;
1004 cavePoint.Direction.Z = 0f;
1005 }
1006 if (random.Bool(0.33f)) {
1007 cavePoint.BrushType = (int)(MathF.Pow(random.Float(0f, 0.999f), 7f) * m_caveBrushesByType.Count);
1008 }
1009 if (random.Bool(0.06f)
1010 && list.Count < 12
1011 && cavePoint.StepsTaken > 20
1012 && cavePoint.Position.Y < 58f) {
1013 list.Add(
1014 new CavePoint {
1015 Position = cavePoint.Position,
1016 Direction = Vector3.Normalize(random.Vector3(1f, 1f) * new Vector3(1f, 0.33f, 1f)),
1017 BrushType = (int)(MathF.Pow(random.Float(0f, 0.999f), 7f) * m_caveBrushesByType.Count),
1018 Length = random.Int(40, 180)
1019 }
1020 );
1021 }
1022 if (cavePoint.StepsTaken >= cavePoint.Length
1023 || MathF.Abs(num9) > 34f
1024 || MathF.Abs(num10) > 34f
1025 || cavePoint.Position.Y < 5f
1026 || cavePoint.Position.Y > 246f) {
1027 num8++;
1028 }
1029 else if (cavePoint.StepsTaken % 20 == 0) {
1030 float num11 = CalculateHeight(cavePoint.Position.X, cavePoint.Position.Z);
1031 if (cavePoint.Position.Y > num11 + 1f) {
1032 num8++;
1033 }
1034 }
1035 }
1036 }
1037 }
1038 }
1039
1040 public virtual void GenerateLogs(TerrainChunk chunk) {
1041 if (!TGExtras) {
1042 return;
1043 }
1044 Terrain terrain = m_subsystemTerrain.Terrain;
1045 int x = chunk.Origin.X;
1046 int num = x + 16;
1047 int y = chunk.Origin.Y;
1048 int num2 = y + 16;
1049 int x2 = chunk.Coords.X;
1050 int y2 = chunk.Coords.Y;
1051 for (int i = x2; i <= x2; i++) {
1052 for (int j = y2; j <= y2; j++) {
1053 Random random = new(m_seed + i + 3943 * j);
1054 int humidity = CalculateHumidity(i * 16, j * 16);
1055 int num3 = CalculateTemperature(i * 16, j * 16);
1056 float num4 = MathUtils.Saturate(
1057 (SimplexNoise.OctavedNoise(i, j, 0.1f, 2, 2f, 0.5f) - 0.25f) / 0.2f + (random.Bool(0.25f) ? 0.5f : 0f)
1058 );
1059 int num5 = 0;
1060 if (num4 > 0.9f) {
1061 num5 = random.Int(1, 2);
1062 }
1063 else if (num4 > 0.5f) {
1064 num5 = random.Int(0, 1);
1065 }
1066 int num6 = 0;
1067 for (int k = 0; k < 16; k++) {
1068 if (num6 >= num5) {
1069 break;
1070 }
1071 int num7 = i * 16 + random.Int(0, 15);
1072 int num8 = j * 16 + random.Int(0, 15);
1073 int num9 = terrain.CalculateTopmostCellHeight(num7, num8);
1074 if (num9 < 66) {
1075 continue;
1076 }
1077 int cellContentsFast = terrain.GetCellContentsFast(num7, num9, num8);
1078 if (cellContentsFast != 2
1079 && cellContentsFast != 8) {
1080 continue;
1081 }
1082 num9++;
1083 int num10 = random.Int(3, 7);
1084 Point3 point = CellFace.FaceToPoint3(random.Int(0, 3));
1085 if (point.X < 0
1086 && num7 - num10 + 1 < 0) {
1087 point.X *= -1;
1088 }
1089 if (point.X > 0
1090 && num7 + num10 - 1 > 15) {
1091 point.X *= -1;
1092 }
1093 if (point.Z < 0
1094 && num8 - num10 + 1 < 0) {
1095 point.Z *= -1;
1096 }
1097 if (point.Z > 0
1098 && num8 + num10 - 1 > 15) {
1099 point.Z *= -1;
1100 }
1101 bool flag = true;
1102 bool flag2 = false;
1103 bool flag3 = false;
1104 for (int l = 0; l < num10; l++) {
1105 int num11 = num7 + point.X * l;
1106 int num12 = num8 + point.Z * l;
1107 if (num11 < x + 1
1108 || num11 >= num - 1
1109 || num12 < y + 1
1110 || num12 >= num2 - 1) {
1111 flag = false;
1112 break;
1113 }
1114 if (BlocksManager.Blocks[terrain.GetCellContentsFast(num11, num9, num12)].IsCollidable) {
1115 flag = false;
1116 break;
1117 }
1118 if (BlocksManager.Blocks[terrain.GetCellContentsFast(num11, num9 - 1, num12)].IsCollidable) {
1119 if (l <= MathUtils.Max(num10 / 2, 0)) {
1120 flag2 = true;
1121 }
1122 if (l >= MathUtils.Min(num10 / 2 + 1, num10 - 1)) {
1123 flag3 = true;
1124 }
1125 }
1126 }
1127 if (!(flag && flag2 && flag3)) {
1128 continue;
1129 }
1130 Point3 point2 = point.X != 0 ? new Point3(0, 0, 1) : new Point3(1, 0, 0);
1131 TreeType? treeType = PlantsManager.GenerateRandomTreeType(
1132 random,
1133 num3 + SubsystemWeather.GetTemperatureAdjustmentAtHeight(num9),
1134 humidity,
1135 num9,
1136 2f
1137 );
1138 if (treeType.HasValue) {
1139 int treeTrunkValue = PlantsManager.GetTreeTrunkValue(treeType.Value);
1140 treeTrunkValue = Terrain.ReplaceData(
1141 treeTrunkValue,
1142 WoodBlock.SetCutFace(Terrain.ExtractData(treeTrunkValue), point.X != 0 ? 1 : 0)
1143 );
1144 int treeLeavesValue = PlantsManager.GetTreeLeavesValue(treeType.Value);
1145 for (int m = 0; m < num10; m++) {
1146 int num13 = num7 + point.X * m;
1147 int num14 = num8 + point.Z * m;
1148 terrain.SetCellValueFast(num13, num9, num14, treeTrunkValue);
1149 if (m > num10 / 2) {
1150 if (random.Bool(0.5f)
1151 && !BlocksManager.Blocks[terrain.GetCellContentsFast(num13 + point2.X, num9, num14 + point2.Z)]
1152 .IsCollidable) {
1153 terrain.SetCellValueFast(num13 + point2.X, num9, num14 + point2.Z, treeLeavesValue);
1154 }
1155 if (random.Bool(0.05f)
1156 && !BlocksManager.Blocks[terrain.GetCellContentsFast(num13 + point2.X, num9, num14 + point2.Z)]
1157 .IsCollidable) {
1158 terrain.SetCellValueFast(num13 + point2.X, num9, num14 + point2.Z, treeTrunkValue);
1159 }
1160 if (random.Bool(0.5f)
1161 && !BlocksManager.Blocks[terrain.GetCellContentsFast(num13 - point2.X, num9, num14 - point2.Z)]
1162 .IsCollidable) {
1163 terrain.SetCellValueFast(num13 - point2.X, num9, num14 - point2.Z, treeLeavesValue);
1164 }
1165 if (random.Bool(0.05f)
1166 && !BlocksManager.Blocks[terrain.GetCellContentsFast(num13 - point2.X, num9, num14 - point2.Z)]
1167 .IsCollidable) {
1168 terrain.SetCellValueFast(num13 - point2.X, num9, num14 - point2.Z, treeTrunkValue);
1169 }
1170 if (random.Bool(0.5f)
1171 && !BlocksManager.Blocks[terrain.GetCellContentsFast(num13, num9 + 1, num14)].IsCollidable) {
1172 terrain.SetCellValueFast(num13, num9 + 1, num14, treeLeavesValue);
1173 }
1174 }
1175 }
1176 }
1177 num6++;
1178 }
1179 }
1180 }
1181 }
1182
1183 public virtual void GenerateTrees(TerrainChunk chunk) {
1184 if (!TGExtras) {
1185 return;
1186 }
1187 Terrain terrain = m_subsystemTerrain.Terrain;
1188 _ = chunk.Origin.X;
1189 _ = chunk.Origin.Y;
1190 int x = chunk.Coords.X;
1191 int y = chunk.Coords.Y;
1192 for (int i = x; i <= x; i++) {
1193 for (int j = y; j <= y; j++) {
1194 Random random = new(m_seed + i + 3943 * j);
1195 int humidity = CalculateHumidity(i * 16, j * 16);
1196 int num = CalculateTemperature(i * 16, j * 16);
1197 float num2 = CalculateForestDensity(i * 16, j * 16);
1198 int num3 = (int)(6f * num2);
1199 int num4 = 0;
1200 for (int k = 0; k < 36; k++) {
1201 if (num4 >= num3) {
1202 break;
1203 }
1204 int num5 = i * 16 + random.Int(2, 13);
1205 int num6 = j * 16 + random.Int(2, 13);
1206 int num7 = terrain.CalculateTopmostCellHeight(num5, num6);
1207 if (num7 < 66) {
1208 continue;
1209 }
1210 int cellContentsFast = terrain.GetCellContentsFast(num5, num7, num6);
1211 if (cellContentsFast != 2
1212 && cellContentsFast != 8) {
1213 continue;
1214 }
1215 num7++;
1216 if (!BlocksManager.Blocks[terrain.GetCellContentsFast(num5 + 1, num7, num6)].IsCollidable
1217 && !BlocksManager.Blocks[terrain.GetCellContentsFast(num5 - 1, num7, num6)].IsCollidable
1218 && !BlocksManager.Blocks[terrain.GetCellContentsFast(num5, num7, num6 + 1)].IsCollidable
1219 && !BlocksManager.Blocks[terrain.GetCellContentsFast(num5, num7, num6 - 1)].IsCollidable) {
1220 TreeType? treeType = PlantsManager.GenerateRandomTreeType(
1221 random,
1222 num + SubsystemWeather.GetTemperatureAdjustmentAtHeight(num7),
1223 humidity,
1224 num7
1225 );
1226 if (treeType.HasValue) {
1227 ReadOnlyList<TerrainBrush> treeBrushes = PlantsManager.GetTreeBrushes(treeType.Value);
1228 TerrainBrush terrainBrush = treeBrushes[random.Int(treeBrushes.Count)];
1229 terrainBrush.PaintFast(chunk, num5, num7, num6);
1230 chunk.AddBrushPaint(num5, num7, num6, terrainBrush);
1231 }
1232 num4++;
1233 }
1234 }
1235 }
1236 }
1237 }
1238
1239 public virtual void GenerateBedrockAndAir(TerrainChunk chunk) {
1240 int value = Terrain.MakeBlockValue(1);
1241 for (int i = 0; i < 16; i++) {
1242 for (int j = 0; j < 16; j++) {
1243 int num = i + chunk.Origin.X;
1244 int num2 = j + chunk.Origin.Y;
1245 float num3 = 2 + (int)(4f * SimplexNoise.OctavedNoise(num, num2, 0.1f, 1, 1f, 1f));
1246 for (int k = 0; k < num3; k++) {
1247 chunk.SetCellValueFast(i, k, j, value);
1248 }
1249 chunk.SetCellValueFast(i, 255, j, 0);
1250 }
1251 }
1252 }
1253
1254 public virtual void GenerateGrassAndPlants(TerrainChunk chunk) {
1255 if (!TGExtras) {
1256 return;
1257 }
1258 Random random = new(m_seed + chunk.Coords.X + 3943 * chunk.Coords.Y);
1259 for (int i = 0; i < 16; i++) {
1260 for (int j = 0; j < 16; j++) {
1261 for (int num = 254; num >= 0; num--) {
1262 int cellValueFast = chunk.GetCellValueFast(i, num, j);
1263 int num2 = Terrain.ExtractContents(cellValueFast);
1264 if (num2 != 0) {
1265 if (!(BlocksManager.Blocks[num2] is FluidBlock)) {
1266 int temperatureFast = chunk.GetTemperatureFast(i, j);
1267 int humidityFast = chunk.GetHumidityFast(i, j);
1268 int num3 = PlantsManager.GenerateRandomPlantValue(random, cellValueFast, temperatureFast, humidityFast, num + 1);
1269 if (num3 != 0) {
1270 chunk.SetCellValueFast(i, num + 1, j, num3);
1271 }
1272 if (num2 == 2) {
1273 chunk.SetCellValueFast(i, num, j, Terrain.MakeBlockValue(8, 0, 0));
1274 }
1275 }
1276 break;
1277 }
1278 }
1279 }
1280 }
1281 }
1282
1283 public virtual void GenerateBottomSuckers(TerrainChunk chunk) {
1284 if (!TGExtras) {
1285 return;
1286 }
1287 Random random = new(m_seed + chunk.Coords.X + 2210 * chunk.Coords.Y);
1288 for (int i = 0; i < 16; i++) {
1289 for (int j = 0; j < 16; j++) {
1290 if (!random.Bool(0.2f)) {
1291 continue;
1292 }
1293 int num = chunk.Origin.X + i;
1294 int num2 = chunk.Origin.Y + j;
1295 int temperatureFast = chunk.GetTemperatureFast(i, j);
1296 if (CalculateOceanShoreDistance(num, num2) > 10f) {
1297 continue;
1298 }
1299 int num3 = 0;
1300 for (int num4 = 254; num4 >= 0; num4--) {
1301 if (Terrain.ExtractContents(chunk.GetCellValueFast(i, num4, j)) == 18) {
1302 num3++;
1303 int face = random.Int(0, 5);
1304 Point3 point = CellFace.FaceToPoint3(face);
1305 if (i + point.X >= 0
1306 && i + point.X < 16
1307 && num4 + point.Y >= 0
1308 && num4 + point.Y < 254
1309 && j + point.Z >= 0
1310 && j + point.Z < 16) {
1311 int cellValueFast = chunk.GetCellValueFast(i + point.X, num4 + point.Y, j + point.Z);
1312 if (m_subsystemBottomSuckerBlockBehavior.IsSupport(cellValueFast, CellFace.OppositeFace(face))) {
1313 int num5 = 0;
1314 float num6 = 0.6f;
1315 float num7 = 0.4f;
1316 if (temperatureFast < 8) {
1317 num6 = 0.9f;
1318 num7 = 0.1f;
1319 }
1320 if (num3 > 6) {
1321 num6 *= 0.25f;
1322 }
1323 if (num3 > 12) {
1324 num7 *= 0.5f;
1325 }
1326 if (num3 < 4) {
1327 num7 *= 0.5f;
1328 }
1329 if (num4 < 45) {
1330 num6 *= 0.1f;
1331 num7 *= 0.1f;
1332 }
1333 float num8 = random.Float(0f, 1f);
1334 num8 -= num6;
1335 if ( /*num5 == 0 && */num8 < 0f) {
1336 num5 = 226;
1337 }
1338 num8 -= num7;
1339 if (num5 == 0
1340 && num8 < 0f) {
1341 num5 = 229;
1342 }
1343 if (num5 != 0) {
1344 int face2 = random.Int(0, 3);
1345 int data = BottomSuckerBlock.SetFace(BottomSuckerBlock.SetSubvariant(0, face2), CellFace.OppositeFace(face));
1346 int value = Terrain.MakeBlockValue(num5, 0, data);
1347 chunk.SetCellValueFast(i, num4, j, value);
1348 }
1349 }
1350 }
1351 }
1352 else {
1353 num3 = 0;
1354 }
1355 }
1356 }
1357 }
1358 }
1359
1360 public virtual void GenerateCacti(TerrainChunk chunk) {
1361 if (!TGExtras) {
1362 return;
1363 }
1364 int x = chunk.Coords.X;
1365 int y = chunk.Coords.Y;
1366 Random random = new(m_seed + x + 1991 * y);
1367 if (!random.Bool(0.5f)) {
1368 return;
1369 }
1370 int num = random.Int(0, MathUtils.Max(1, 1));
1371 for (int i = 0; i < num; i++) {
1372 int num2 = random.Int(3, 12);
1373 int num3 = random.Int(3, 12);
1374 int humidityFast = chunk.GetHumidityFast(num2, num3);
1375 int temperatureFast = chunk.GetTemperatureFast(num2, num3);
1376 if (humidityFast >= 6
1377 || temperatureFast <= 8) {
1378 continue;
1379 }
1380 for (int j = 0; j < 8; j++) {
1381 int num4 = num2 + random.Int(-2, 2);
1382 int num5 = num3 + random.Int(-2, 2);
1383 for (int num6 = 251; num6 >= 0; num6--) {
1384 switch (Terrain.ExtractContents(chunk.GetCellValueFast(num4, num6, num5))) {
1385 case 7: {
1386 for (int k = num6 + 1;
1387 k <= num6 + 3
1388 && chunk.GetCellContentsFast(num4 + 1, k, num5) == 0
1389 && chunk.GetCellContentsFast(num4 - 1, k, num5) == 0
1390 && chunk.GetCellContentsFast(num4, k, num5 + 1) == 0
1391 && chunk.GetCellContentsFast(num4, k, num5 - 1) == 0;
1392 k++) {
1393 chunk.SetCellValueFast(num4, k, num5, Terrain.MakeBlockValue(127));
1394 }
1395 break;
1396 }
1397 case 0: continue;
1398 }
1399 break;
1400 }
1401 }
1402 }
1403 }
1404
1405 public virtual void GeneratePumpkins(TerrainChunk chunk) {
1406 if (!TGExtras) {
1407 return;
1408 }
1409 int x = chunk.Coords.X;
1410 int y = chunk.Coords.Y;
1411 Random random = new(m_seed + x + 1495 * y);
1412 if (!random.Bool(0.2f)) {
1413 return;
1414 }
1415 int num = random.Int(0, MathUtils.Max(1, 1));
1416 for (int i = 0; i < num; i++) {
1417 int num2 = random.Int(1, 14);
1418 int num3 = random.Int(1, 14);
1419 int humidityFast = chunk.GetHumidityFast(num2, num3);
1420 int temperatureFast = chunk.GetTemperatureFast(num2, num3);
1421 if (humidityFast < 10
1422 || temperatureFast <= 6) {
1423 continue;
1424 }
1425 for (int j = 0; j < 5; j++) {
1426 int x2 = num2 + random.Int(-1, 1);
1427 int z = num3 + random.Int(-1, 1);
1428 for (int num4 = 254; num4 >= 0; num4--) {
1429 switch (Terrain.ExtractContents(chunk.GetCellValueFast(x2, num4, z))) {
1430 case 8:
1431 chunk.SetCellValueFast(
1432 x2,
1433 num4 + 1,
1434 z,
1435 random.Bool(0.25f) ? Terrain.MakeBlockValue(244) : Terrain.MakeBlockValue(131)
1436 ); break;
1437 case 0: continue;
1438 }
1439 break;
1440 }
1441 }
1442 }
1443 }
1444
1445 public virtual void GenerateKelp(TerrainChunk chunk) {
1446 if (!TGExtras) {
1447 return;
1448 }
1449 int x = chunk.Coords.X;
1450 int y = chunk.Coords.Y;
1451 Random random = new(0);
1452 float num = 0f;
1453 for (int i = 0; i < 9; i++) {
1454 int num2 = i % 3 - 1;
1455 int num3 = i / 3 - 1;
1456 random.Seed(m_seed + x + num2 + 850 * (y + num3));
1457 if (random.Bool(0.2f)) {
1458 num = MathUtils.Max(num, 0.025f);
1459 if (i == 4) {
1460 num = MathUtils.Max(num, 0.1f);
1461 }
1462 }
1463 }
1464 if (num == 0f) {
1465 return;
1466 }
1467 random.Seed(m_seed + x + 850 * y);
1468 int num4 = random.Int(0, MathUtils.Max((int)(256f * num), 1));
1469 for (int j = 0; j < num4; j++) {
1470 int num5 = random.Int(2, 13);
1471 int num6 = random.Int(2, 13);
1472 int num7 = num5 + chunk.Origin.X;
1473 int num8 = num6 + chunk.Origin.Y;
1474 int num9 = random.Int(10, 26);
1475 int num10 = 6;
1476 bool flag = true;
1477 if (CalculateOceanShoreDistance(num7, num8) > 5f) {
1478 num10 = 4;
1479 flag = false;
1480 }
1481 if (num9 <= 0) {
1482 continue;
1483 }
1484 for (int k = 0; k < num9; k++) {
1485 int x2 = num5 + random.Int(-2, 2);
1486 int z = num6 + random.Int(-2, 2);
1487 int num11 = 0;
1488 for (int num12 = 254; num12 >= 0; num12--) {
1489 int num13 = Terrain.ExtractContents(chunk.GetCellValueFast(x2, num12, z));
1490 Block block = BlocksManager.Blocks[num13];
1491 if (num13 != 0) {
1492 if (!(block is WaterBlock)) {
1493 if ((num13 == 2 || num13 == 7 || num13 == 72)
1494 && num11 >= 2) {
1495 int num14 = flag ? random.Int(num11 - 2, num11 - 1) : random.Int(num11 - 1, num11);
1496 for (int l = 0; l < num14; l++) {
1497 chunk.SetCellValueFast(x2, num12 + 1 + l, z, Terrain.MakeBlockValue(232));
1498 }
1499 }
1500 break;
1501 }
1502 num11++;
1503 if (num11 > num10) {
1504 break;
1505 }
1506 }
1507 }
1508 }
1509 }
1510 }
1511
1512 public virtual void GenerateSeagrass(TerrainChunk chunk) {
1513 if (!TGExtras) {
1514 return;
1515 }
1516 int x = chunk.Coords.X;
1517 int y = chunk.Coords.Y;
1518 Random random = new(m_seed + x + 378 * y);
1519 for (int i = 0; i < 6; i++) {
1520 int num = random.Int(1, 14);
1521 int num2 = random.Int(1, 14);
1522 int num3 = chunk.Origin.X + num;
1523 int num4 = chunk.Origin.Y + num2;
1524 bool flag = CalculateOceanShoreDistance(num3, num4) < 10f;
1525 int num5 = random.Int(1, 3);
1526 for (int j = 0; j < num5; j++) {
1527 int x2 = num + random.Int(-1, 1);
1528 int z = num2 + random.Int(-1, 1);
1529 int num6 = 0;
1530 for (int num7 = 254; num7 >= 0; num7--) {
1531 int num8 = Terrain.ExtractContents(chunk.GetCellValueFast(x2, num7, z));
1532 switch (num8) {
1533 case 18:
1534 num6++;
1535 if (num6 <= 16) {
1536 continue;
1537 }
1538 break;
1539 default:
1540 if (num6 > 1
1541 && (num8 == 2 || num8 == 7 || num8 == 72 || num8 == 3)) {
1542 int x3 = !random.Bool(0.1f) ? 1 : 2;
1543 x3 = flag ? MathUtils.Min(x3, num6 - 1) : MathUtils.Min(x3, num6);
1544 for (int k = 0; k < x3; k++) {
1545 chunk.SetCellValueFast(x2, num7 + 1 + k, z, Terrain.MakeBlockValue(233));
1546 }
1547 }
1548 break;
1549 case 0: continue;
1550 }
1551 break;
1552 }
1553 }
1554 }
1555 }
1556
1557 public virtual void GenerateIvy(TerrainChunk chunk) {
1558 if (!TGExtras) {
1559 return;
1560 }
1561 Random random = new(m_seed + chunk.Coords.X + 2191 * chunk.Coords.Y);
1562 int num = random.Int(0, MathUtils.Max(12, 1));
1563 for (int i = 0; i < num; i++) {
1564 int num2 = random.Int(4, 11);
1565 int num3 = random.Int(4, 11);
1566 int humidityFast = chunk.GetHumidityFast(num2, num3);
1567 int temperatureFast = chunk.GetTemperatureFast(num2, num3);
1568 if (humidityFast < 10
1569 || temperatureFast < 10) {
1570 continue;
1571 }
1572 int num4 = chunk.CalculateTopmostCellHeight(num2, num3);
1573 for (int j = 0; j < 100; j++) {
1574 int num5 = num2 + random.Int(-3, 3);
1575 int num6 = Math.Clamp(num4 + random.Int(-12, 1), 1, 255);
1576 int num7 = num3 + random.Int(-3, 3);
1577 switch (Terrain.ExtractContents(chunk.GetCellValueFast(num5, num6, num7))) {
1578 case 2:
1579 case 3:
1580 case 8:
1581 case 9:
1582 case 12:
1583 case 66:
1584 case 67: {
1585 int num8 = random.Int(0, 3);
1586 for (int k = 0; k < 4; k++) {
1587 int face = (k + num8) % 4;
1588 Point3 point = CellFace.FaceToPoint3(face);
1589 if (chunk.GetCellContentsFast(num5 + point.X, num6, num7 + point.Z) != 0) {
1590 continue;
1591 }
1592 int num9 = num6 - 1;
1593 while (num9 >= 1
1594 && chunk.GetCellContentsFast(num5 + point.X, num9, num7 + point.Z) == 0
1595 && chunk.GetCellContentsFast(num5, num9, num7) != 0) {
1596 num9--;
1597 }
1598 if (chunk.GetCellContentsFast(num5 + point.X, num9, num7 + point.Z) != 0) {
1599 break;
1600 }
1601 num9++;
1602 int value = Terrain.MakeBlockValue(197, 0, IvyBlock.SetFace(0, CellFace.OppositeFace(face)));
1603 while (num9 >= 1
1604 && chunk.GetCellContentsFast(num5 + point.X, num9, num7 + point.Z) == 0) {
1605 chunk.SetCellValueFast(num5 + point.X, num9, num7 + point.Z, value);
1606 if (IvyBlock.IsGrowthStopCell(num5 + point.X, num9, num7 + point.Z)) {
1607 break;
1608 }
1609 num9--;
1610 }
1611 break;
1612 }
1613 break;
1614 }
1615 }
1616 }
1617 }
1618 }
1619
1620 public virtual void GenerateTraps(TerrainChunk chunk) {
1621 if (!TGExtras) {
1622 return;
1623 }
1624 int x = chunk.Coords.X;
1625 int y = chunk.Coords.Y;
1626 _ = m_subsystemTerrain.Terrain;
1627 Random random = new(m_seed + x + 2113 * y);
1628 if (!random.Bool(0.15f)
1629 || !(CalculateOceanShoreDistance(chunk.Origin.X, chunk.Origin.Y) > 50f)) {
1630 return;
1631 }
1632 int num = random.Int(0, MathUtils.Max(2, 1));
1633 for (int i = 0; i < num; i++) {
1634 int num2 = random.Int(2, 5);
1635 int num3 = random.Int(2, 5);
1636 int num4 = random.Int(1, 16 - num2 - 2);
1637 int num5 = random.Int(1, 16 - num3 - 2);
1638 bool flag = random.Float(0f, 1f) < 0.5f;
1639 int num6 = random.Int(3, 5);
1640 int? num7 = null;
1641 int num8 = num4 - 1;
1642 while (true) {
1643 if (num8 < num4 + num2 + 1) {
1644 for (int j = num5 - 1; j < num5 + num3 + 1; j++) {
1645 int num9 = chunk.CalculateTopmostCellHeight(num8, j);
1646 int num10 = MathUtils.Max(num9 - 20, 5);
1647 while (num9 >= num10
1648 && chunk.GetCellContentsFast(num8, num9, j) != 8) {
1649 num9--;
1650 }
1651 if (num7.HasValue
1652 && num7 != num9) {
1653 goto end_IL_01a0;
1654 }
1655 num7 = num9;
1656 if (chunk.GetCellContentsFast(num8, num9, j) != 8) {
1657 goto end_IL_01a0;
1658 }
1659 }
1660 num8++;
1661 continue;
1662 }
1663 if (!num7.HasValue
1664 || num7 - num6 < 5) {
1665 break;
1666 }
1667 for (int k = num4; k < num4 + num2; k++) {
1668 for (int l = num5; l < num5 + num3; l++) {
1669 for (int num11 = num7.Value - 1; num11 >= num7 - num6 + 1; num11--) {
1670 chunk.SetCellValueFast(k, num11, l, Terrain.MakeBlockValue(0));
1671 }
1672 chunk.SetCellValueFast(k, num7.Value, l, Terrain.MakeBlockValue(87));
1673 if (flag) {
1674 int data = SpikedPlankBlock.SetSpikesState(0, random.Float(0f, 1f) < 0.33f);
1675 chunk.SetCellValueFast(k, num7.Value - num6 + 1, l, Terrain.MakeBlockValue(86, 0, data));
1676 }
1677 }
1678 }
1679 break;
1680 end_IL_01a0:
1681 break;
1682 }
1683 }
1684 }
1685
1686 public virtual void GenerateGraves(TerrainChunk chunk) {
1687 if (!TGExtras) {
1688 return;
1689 }
1690 int x = chunk.Coords.X;
1691 int y = chunk.Coords.Y;
1692 Random random = new((int)MathUtils.Hash((uint)(m_seed + x + 10323 * y)));
1693 if (!(random.Float(0f, 1f) < 0.033f)
1694 || !(CalculateOceanShoreDistance(chunk.Origin.X, chunk.Origin.Y) > 10f)) {
1695 return;
1696 }
1697 int num = random.Int(0, MathUtils.Max(1, 1));
1698 for (int i = 0; i < num; i++) {
1699 int num2 = random.Int(6, 9);
1700 int num3 = random.Int(6, 9);
1701 int num4 = random.Bool(0.2f) ? random.Int(6, 20) : random.Int(1, 5);
1702 bool flag = random.Bool(0.5f);
1703 for (int j = 0; j < num4; j++) {
1704 int num5 = num2 + random.Int(-4, 4);
1705 int num6 = num3 + random.Int(-4, 4);
1706 int num7 = chunk.CalculateTopmostCellHeight(num5, num6);
1707 if (num7 < 10
1708 || num7 > 246) {
1709 continue;
1710 }
1711 int num8 = random.Int(0, 3);
1712 for (int k = 0; k < 4; k++) {
1713 int num9 = (k + num8) % 4;
1714 Point3 p = CellFace.FaceToPoint3(num9);
1715 Point3 p2 = new(-p.Z, p.Y, p.X);
1716 int num10 = p.X < 0 ? num5 - 2 : num5 - 1;
1717 int num11 = p.X > 0 ? num5 + 2 : num5 + 1;
1718 int num12 = p.Z < 0 ? num6 - 2 : num6 - 1;
1719 int num13 = p.Z > 0 ? num6 + 2 : num6 + 1;
1720 for (int l = num10; l <= num11; l++) {
1721 for (int m = num7 - 2; m <= num7 + 2; m++) {
1722 for (int n = num12; n <= num13; n++) {
1723 int num14 = Terrain.ExtractContents(chunk.GetCellValueFast(l, m, n));
1724 Block block = BlocksManager.Blocks[num14];
1725 if (m > num7) {
1726 if (!block.IsCollidable) {
1727 continue;
1728 }
1729 }
1730 else if (num14 == 8
1731 || num14 == 2
1732 || num14 == 7
1733 || num14 == 3
1734 || num14 == 4) {
1735 continue;
1736 }
1737 goto IL_06ac;
1738 }
1739 }
1740 }
1741 int num15 = random.Int(0, 7);
1742 int data = GravestoneBlock.SetVariant(GravestoneBlock.SetRotation(0, num9 % 2), num15);
1743 int? num16 = null;
1744 int contents = 217;
1745 int contents2 = 136;
1746 if (num15 >= 4
1747 && !flag) {
1748 int cellContentsFast = chunk.GetCellContentsFast(num5, num7, num6);
1749 if (cellContentsFast == 7
1750 || cellContentsFast == 4) {
1751 num16 = Terrain.MakeBlockValue(4);
1752 contents = 51;
1753 contents2 = 52;
1754 }
1755 else if (random.Float(0f, 1f) < 0.5f) {
1756 num16 = Terrain.MakeBlockValue(3);
1757 contents = 217;
1758 contents2 = 136;
1759 }
1760 else {
1761 num16 = Terrain.MakeBlockValue(67);
1762 contents = 96;
1763 contents2 = 95;
1764 }
1765 }
1766 bool flag2 = num16.HasValue && random.Bool(0.33f);
1767 float num17 = random.Float(0f, 1f);
1768 float num18 = random.Float(0f, 1f);
1769 int num19 = random.Int(-1, 0);
1770 int num20 = random.Int(1, 2);
1771 int num21 = flag2 ? num7 + 2 : num7 + 1;
1772 chunk.SetCellValueFast(num5, num21, num6, Terrain.MakeBlockValue(189, 0, data));
1773 for (int num22 = num19; num22 <= num20; num22++) {
1774 int num23 = num5 + p.X * num22;
1775 int num24 = num6 + p.Z * num22;
1776 if (num22 == 0
1777 || num22 == 1) {
1778 chunk.SetCellValueFast(num23, num21 - 2, num24, Terrain.MakeBlockValue(190));
1779 if (num16.HasValue) {
1780 chunk.SetCellValueFast(num23, num21 - 1, num24, num16.Value);
1781 if (num22 == 1) {
1782 int num25 = 0;
1783 if (num18 < 0.2f) {
1784 num25 = Terrain.MakeBlockValue(20);
1785 }
1786 else if (num18 < 0.3f) {
1787 num25 = Terrain.MakeBlockValue(24);
1788 }
1789 else if (num18 < 0.4f) {
1790 num25 = Terrain.MakeBlockValue(25);
1791 }
1792 else if (num18 < 0.5f) {
1793 num25 = Terrain.MakeBlockValue(31, 0, 4);
1794 }
1795 else if (num18 < 0.6f) {
1796 num25 = Terrain.MakeBlockValue(132, 0, CellFace.OppositeFace(num9));
1797 }
1798 if (num25 != 0) {
1799 chunk.SetCellValueFast(num23, num21, num24, num25);
1800 }
1801 }
1802 }
1803 }
1804 if (!flag2) {
1805 continue;
1806 }
1807 if (num17 < 0.3f) {
1808 int value = Terrain.MakeBlockValue(contents, 0, StairsBlock.SetRotation(0, CellFace.Point3ToFace(p2)));
1809 int value2 = Terrain.MakeBlockValue(
1810 contents,
1811 0,
1812 StairsBlock.SetRotation(0, CellFace.OppositeFace(CellFace.Point3ToFace(p2)))
1813 );
1814 chunk.SetCellValueFast(num23 + p2.X, num21 - 1, num24 + p2.Z, value);
1815 chunk.SetCellValueFast(num23 - p2.X, num21 - 1, num24 - p2.Z, value2);
1816 if (num22 == -1) {
1817 int value3 = Terrain.MakeBlockValue(
1818 contents,
1819 0,
1820 StairsBlock.SetRotation(0, CellFace.OppositeFace(CellFace.Point3ToFace(p)))
1821 );
1822 chunk.SetCellValueFast(num23, num21 - 1, num24, value3);
1823 }
1824 if (num22 == 2) {
1825 int value4 = Terrain.MakeBlockValue(contents, 0, StairsBlock.SetRotation(0, CellFace.Point3ToFace(p)));
1826 chunk.SetCellValueFast(num23, num21 - 1, num24, value4);
1827 }
1828 }
1829 else if (num17 < 0.4f) {
1830 chunk.SetCellValueFast(num23 + p2.X, num21 - 1, num24 + p2.Z, Terrain.MakeBlockValue(contents2));
1831 chunk.SetCellValueFast(num23 - p2.X, num21 - 1, num24 - p2.Z, Terrain.MakeBlockValue(contents2));
1832 if (num22 == -1) {
1833 chunk.SetCellValueFast(num23, num21 - 1, num24, Terrain.MakeBlockValue(contents2));
1834 }
1835 if (num22 == 2) {
1836 chunk.SetCellValueFast(num23, num21 - 1, num24, Terrain.MakeBlockValue(contents2));
1837 }
1838 }
1839 else if (num17 < 0.6f) {
1840 if (num22 == 0
1841 || num22 == 1) {
1842 chunk.SetCellValueFast(
1843 num23 + p2.X,
1844 num21 - 1,
1845 num24 + p2.Z,
1846 Terrain.MakeBlockValue(31, 0, CellFace.Point3ToFace(p2))
1847 );
1848 chunk.SetCellValueFast(
1849 num23 - p2.X,
1850 num21 - 1,
1851 num24 - p2.Z,
1852 Terrain.MakeBlockValue(31, 0, CellFace.OppositeFace(CellFace.Point3ToFace(p2)))
1853 );
1854 }
1855 if (num22 == -1) {
1856 chunk.SetCellValueFast(num23, num21 - 1, num24, Terrain.MakeBlockValue(31, 0, CellFace.OppositeFace(num9)));
1857 }
1858 if (num22 == 2) {
1859 chunk.SetCellValueFast(num23, num21 - 1, num24, Terrain.MakeBlockValue(31, 0, num9));
1860 }
1861 }
1862 }
1863 break;
1864 IL_06ac: ;
1865 }
1866 }
1867 }
1868 }
1869
1870 public virtual void GenerateCairns(TerrainChunk chunk) {
1871 int num = 190;
1872 Point2 point = default;
1873 for (int i = 0; i < 16; i++) {
1874 for (int j = 0; j < 16; j++) {
1875 if (Terrain.ExtractContents(chunk.GetCellValueFast(i, num, j)) == 0) {
1876 continue;
1877 }
1878 for (int k = num + 1; k < 256; k++) {
1879 if (Terrain.ExtractContents(chunk.GetCellValueFast(i, k, j)) == 0) {
1880 num = k;
1881 point = new Point2(i, j);
1882 break;
1883 }
1884 }
1885 }
1886 }
1887 if (num >= 190 /*&& num <= 255 */
1888 && point.X >= 1
1889 && point.X < 15
1890 && point.Y >= 1
1891 && point.Y < 15) {
1892 int data = Math.Clamp((int)(4f * MathUtils.LinearStep(190f, 256f, num)), 0, 3);
1893 chunk.SetCellValueFast(point.X, num, point.Y, Terrain.MakeBlockValue(258, 0, data));
1894 }
1895 }
1896
1897 public virtual void GenerateSnowAndIce(TerrainChunk chunk) {
1898 for (int i = 0; i < 16; i++) {
1899 for (int j = 0; j < 16; j++) {
1900 int num = i + chunk.Origin.X;
1901 int num2 = j + chunk.Origin.Y;
1902 for (int num3 = 254; num3 >= 0; num3--) {
1903 int cellValueFast = chunk.GetCellValueFast(i, num3, j);
1904 int num4 = Terrain.ExtractContents(cellValueFast);
1905 if (num4 != 0) {
1906 if (!SubsystemWeather.IsPlaceFrozen(chunk.GetTemperatureFast(i, j), num3)) {
1907 break;
1908 }
1909 if (BlocksManager.Blocks[num4] is WaterBlock) {
1910 if (CalculateOceanShoreDistance(num, num2) > -20f) {
1911 float num5 = 1 + (int)(2f * MathUtils.Sqr(SimplexNoise.OctavedNoise(num, num2, 0.2f, 1, 2f, 1f)));
1912 for (int k = 0; k < num5; k++) {
1913 if (num3 - k > 0) {
1914 if (!(BlocksManager.Blocks[chunk.GetCellContentsFast(i, num3 - k, j)] is WaterBlock)) {
1915 break;
1916 }
1917 chunk.SetCellValueFast(i, num3 - k, j, 62);
1918 }
1919 }
1920 if (SubsystemWeather.ShaftHasSnowOnIce(num, num2)) {
1921 chunk.SetCellValueFast(i, num3 + 1, j, 61);
1922 }
1923 }
1924 }
1925 else if (SubsystemSnowBlockBehavior.CanSupportSnow(cellValueFast)) {
1926 chunk.SetCellValueFast(i, num3 + 1, j, 61);
1927 }
1928 if (num4 == 8) {
1929 chunk.SetCellValueFast(i, num3, j, Terrain.MakeBlockValue(8, 0, 1));
1930 }
1931 break;
1932 }
1933 }
1934 }
1935 }
1936 }
1937
1938 public virtual void PropagateFluidsDownwards(TerrainChunk chunk) {
1939 for (int i = 0; i < 16; i++) {
1940 for (int j = 0; j < 16; j++) {
1941 int num = TerrainChunk.CalculateCellIndex(i, 255, j);
1942 int num2 = 0;
1943 int num3 = 255;
1944 while (num3 >= 0) {
1945 int num4 = Terrain.ExtractContents(chunk.GetCellValueFast(num));
1946 if (num4 == 0
1947 && num2 != 0
1948 && BlocksManager.FluidBlocks[num2] != null) {
1949 chunk.SetCellValueFast(num, num2);
1950 num4 = num2;
1951 }
1952 num2 = num4;
1953 num3--;
1954 num--;
1955 }
1956 }
1957 }
1958 }
1959
1960 public virtual void UpdateFluidIsTop(TerrainChunk chunk) {
1961 for (int i = 0; i < 16; i++) {
1962 for (int j = 0; j < 16; j++) {
1963 int num = TerrainChunk.CalculateCellIndex(i, 255, j);
1964 int num2 = 0;
1965 int num3 = 255;
1966 while (num3 >= 0) {
1967 int cellValueFast = chunk.GetCellValueFast(num);
1968 int num4 = Terrain.ExtractContents(cellValueFast);
1969 if (num4 != num2
1970 && BlocksManager.FluidBlocks[num4] != null
1971 && BlocksManager.FluidBlocks[num2] == null) {
1972 int data = Terrain.ExtractData(cellValueFast);
1973 chunk.SetCellValueFast(num, Terrain.MakeBlockValue(num4, 0, FluidBlock.SetIsTop(data, true)));
1974 }
1975 num2 = num4;
1976 num3--;
1977 num--;
1978 }
1979 }
1980 }
1981 }
1982
1983 public static void CreateBrushes() {
1984 Random random = new(24);
1985 for (int i = 0; i < 16; i++) {
1986 TerrainBrush terrainBrush = new();
1987 int num = random.Int(4, 12);
1988 for (int j = 0; j < num; j++) {
1989 Vector3 vector = 0.5f * Vector3.Normalize(new Vector3(random.Float(-1f, 1f), random.Float(-1f, 1f), random.Float(-1f, 1f)));
1990 int num2 = random.Int(3, 8);
1991 Vector3 zero = Vector3.Zero;
1992 for (int k = 0; k < num2; k++) {
1993 terrainBrush.AddBox(
1994 (int)MathF.Floor(zero.X),
1995 (int)MathF.Floor(zero.Y),
1996 (int)MathF.Floor(zero.Z),
1997 1,
1998 1,
1999 1,
2000 16
2001 );
2002 zero += vector;
2003 }
2004 }
2005 if (i == 0) {
2006 terrainBrush.AddCell(0, 0, 0, 150);
2007 }
2008 terrainBrush.Compile();
2009 m_coalBrushes.Add(terrainBrush);
2010 }
2011 for (int l = 0; l < 16; l++) {
2012 TerrainBrush terrainBrush2 = new();
2013 int num3 = random.Int(3, 7);
2014 for (int m = 0; m < num3; m++) {
2015 Vector3 vector2 = 0.5f * Vector3.Normalize(new Vector3(random.Float(-1f, 1f), random.Float(-1f, 1f), random.Float(-1f, 1f)));
2016 int num4 = random.Int(3, 6);
2017 Vector3 zero2 = Vector3.Zero;
2018 for (int n = 0; n < num4; n++) {
2019 terrainBrush2.AddBox(
2020 (int)MathF.Floor(zero2.X),
2021 (int)MathF.Floor(zero2.Y),
2022 (int)MathF.Floor(zero2.Z),
2023 1,
2024 1,
2025 1,
2026 39
2027 );
2028 zero2 += vector2;
2029 }
2030 }
2031 terrainBrush2.Compile();
2032 m_ironBrushes.Add(terrainBrush2);
2033 }
2034 for (int num5 = 0; num5 < 16; num5++) {
2035 TerrainBrush terrainBrush3 = new();
2036 int num6 = random.Int(4, 10);
2037 for (int num7 = 0; num7 < num6; num7++) {
2038 Vector3 vector3 = 0.5f * Vector3.Normalize(new Vector3(random.Float(-1f, 1f), random.Float(-2f, 2f), random.Float(-1f, 1f)));
2039 int num8 = random.Int(3, 6);
2040 Vector3 zero3 = Vector3.Zero;
2041 for (int num9 = 0; num9 < num8; num9++) {
2042 terrainBrush3.AddBox(
2043 (int)MathF.Floor(zero3.X),
2044 (int)MathF.Floor(zero3.Y),
2045 (int)MathF.Floor(zero3.Z),
2046 1,
2047 1,
2048 1,
2049 41
2050 );
2051 zero3 += vector3;
2052 }
2053 }
2054 terrainBrush3.Compile();
2055 m_copperBrushes.Add(terrainBrush3);
2056 }
2057 for (int num10 = 0; num10 < 16; num10++) {
2058 TerrainBrush terrainBrush4 = new();
2059 int num11 = random.Int(8, 16);
2060 for (int num12 = 0; num12 < num11; num12++) {
2061 Vector3 vector4 = 0.5f
2062 * Vector3.Normalize(new Vector3(random.Float(-1f, 1f), random.Float(-0.25f, 0.25f), random.Float(-1f, 1f)));
2063 int num13 = random.Int(4, 8);
2064 Vector3 zero4 = Vector3.Zero;
2065 for (int num14 = 0; num14 < num13; num14++) {
2066 terrainBrush4.AddBox(
2067 (int)MathF.Floor(zero4.X),
2068 (int)MathF.Floor(zero4.Y),
2069 (int)MathF.Floor(zero4.Z),
2070 1,
2071 1,
2072 1,
2073 100
2074 );
2075 zero4 += vector4;
2076 }
2077 }
2078 terrainBrush4.Compile();
2079 m_saltpeterBrushes.Add(terrainBrush4);
2080 }
2081 for (int num15 = 0; num15 < 16; num15++) {
2082 TerrainBrush terrainBrush5 = new();
2083 int num16 = random.Int(4, 10);
2084 for (int num17 = 0; num17 < num16; num17++) {
2085 Vector3 vector5 = 0.5f * Vector3.Normalize(new Vector3(random.Float(-1f, 1f), random.Float(-1f, 1f), random.Float(-1f, 1f)));
2086 int num18 = random.Int(3, 6);
2087 Vector3 zero5 = Vector3.Zero;
2088 for (int num19 = 0; num19 < num18; num19++) {
2089 terrainBrush5.AddBox(
2090 (int)MathF.Floor(zero5.X),
2091 (int)MathF.Floor(zero5.Y),
2092 (int)MathF.Floor(zero5.Z),
2093 1,
2094 1,
2095 1,
2096 101
2097 );
2098 zero5 += vector5;
2099 }
2100 }
2101 terrainBrush5.Compile();
2102 m_sulphurBrushes.Add(terrainBrush5);
2103 }
2104 for (int num20 = 0; num20 < 16; num20++) {
2105 TerrainBrush terrainBrush6 = new();
2106 int num21 = random.Int(2, 6);
2107 for (int num22 = 0; num22 < num21; num22++) {
2108 Vector3 vector6 = 0.5f * Vector3.Normalize(new Vector3(random.Float(-1f, 1f), random.Float(-1f, 1f), random.Float(-1f, 1f)));
2109 int num23 = random.Int(3, 6);
2110 Vector3 zero6 = Vector3.Zero;
2111 for (int num24 = 0; num24 < num23; num24++) {
2112 terrainBrush6.AddBox(
2113 (int)MathF.Floor(zero6.X),
2114 (int)MathF.Floor(zero6.Y),
2115 (int)MathF.Floor(zero6.Z),
2116 1,
2117 1,
2118 1,
2119 112
2120 );
2121 zero6 += vector6;
2122 }
2123 }
2124 terrainBrush6.Compile();
2125 m_diamondBrushes.Add(terrainBrush6);
2126 }
2127 for (int num25 = 0; num25 < 16; num25++) {
2128 TerrainBrush terrainBrush7 = new();
2129 int num26 = random.Int(4, 10);
2130 for (int num27 = 0; num27 < num26; num27++) {
2131 Vector3 vector7 = 0.5f * Vector3.Normalize(new Vector3(random.Float(-1f, 1f), random.Float(-1f, 1f), random.Float(-1f, 1f)));
2132 int num28 = random.Int(3, 6);
2133 Vector3 zero7 = Vector3.Zero;
2134 for (int num29 = 0; num29 < num28; num29++) {
2135 terrainBrush7.AddBox(
2136 (int)MathF.Floor(zero7.X),
2137 (int)MathF.Floor(zero7.Y),
2138 (int)MathF.Floor(zero7.Z),
2139 1,
2140 1,
2141 1,
2142 148
2143 );
2144 zero7 += vector7;
2145 }
2146 }
2147 terrainBrush7.Compile();
2148 m_germaniumBrushes.Add(terrainBrush7);
2149 }
2150 for (int num30 = 0; num30 < 16; num30++) {
2151 TerrainBrush terrainBrush8 = new();
2152 int num31 = random.Int(16, 32);
2153 for (int num32 = 0; num32 < num31; num32++) {
2154 Vector3 vector8 = 0.5f
2155 * Vector3.Normalize(new Vector3(random.Float(-1f, 1f), random.Float(-0.75f, 0.75f), random.Float(-1f, 1f)));
2156 int num33 = random.Int(6, 12);
2157 Vector3 zero8 = Vector3.Zero;
2158 for (int num34 = 0; num34 < num33; num34++) {
2159 terrainBrush8.AddBox(
2160 (int)MathF.Floor(zero8.X),
2161 (int)MathF.Floor(zero8.Y),
2162 (int)MathF.Floor(zero8.Z),
2163 1,
2164 1,
2165 1,
2166 2
2167 );
2168 zero8 += vector8;
2169 }
2170 }
2171 terrainBrush8.Compile();
2172 m_dirtPocketBrushes.Add(terrainBrush8);
2173 }
2174 for (int num35 = 0; num35 < 16; num35++) {
2175 TerrainBrush terrainBrush9 = new();
2176 int num36 = random.Int(16, 32);
2177 for (int num37 = 0; num37 < num36; num37++) {
2178 Vector3 vector9 = 0.5f
2179 * Vector3.Normalize(new Vector3(random.Float(-1f, 1f), random.Float(-0.75f, 0.75f), random.Float(-1f, 1f)));
2180 int num38 = random.Int(6, 12);
2181 Vector3 zero9 = Vector3.Zero;
2182 for (int num39 = 0; num39 < num38; num39++) {
2183 terrainBrush9.AddBox(
2184 (int)MathF.Floor(zero9.X),
2185 (int)MathF.Floor(zero9.Y),
2186 (int)MathF.Floor(zero9.Z),
2187 1,
2188 1,
2189 1,
2190 6
2191 );
2192 zero9 += vector9;
2193 }
2194 }
2195 terrainBrush9.Compile();
2196 m_gravelPocketBrushes.Add(terrainBrush9);
2197 }
2198 for (int num40 = 0; num40 < 16; num40++) {
2199 TerrainBrush terrainBrush10 = new();
2200 int num41 = random.Int(16, 32);
2201 for (int num42 = 0; num42 < num41; num42++) {
2202 Vector3 vector10 = 0.5f
2203 * Vector3.Normalize(new Vector3(random.Float(-1f, 1f), random.Float(-0.75f, 0.75f), random.Float(-1f, 1f)));
2204 int num43 = random.Int(6, 12);
2205 Vector3 zero10 = Vector3.Zero;
2206 for (int num44 = 0; num44 < num43; num44++) {
2207 terrainBrush10.AddBox(
2208 (int)MathF.Floor(zero10.X),
2209 (int)MathF.Floor(zero10.Y),
2210 (int)MathF.Floor(zero10.Z),
2211 1,
2212 1,
2213 1,
2214 66
2215 );
2216 zero10 += vector10;
2217 }
2218 }
2219 terrainBrush10.Compile();
2220 m_limestonePocketBrushes.Add(terrainBrush10);
2221 }
2222 for (int num45 = 0; num45 < 16; num45++) {
2223 TerrainBrush terrainBrush11 = new();
2224 int num46 = random.Int(16, 32);
2225 for (int num47 = 0; num47 < num46; num47++) {
2226 Vector3 vector11 = 0.5f * Vector3.Normalize(new Vector3(random.Float(-1f, 1f), random.Float(-0.1f, 0.1f), random.Float(-1f, 1f)));
2227 int num48 = random.Int(6, 12);
2228 Vector3 zero11 = Vector3.Zero;
2229 for (int num49 = 0; num49 < num48; num49++) {
2230 terrainBrush11.AddBox(
2231 (int)MathF.Floor(zero11.X),
2232 (int)MathF.Floor(zero11.Y),
2233 (int)MathF.Floor(zero11.Z),
2234 1,
2235 1,
2236 1,
2237 72
2238 );
2239 zero11 += vector11;
2240 }
2241 }
2242 terrainBrush11.Compile();
2243 m_clayPocketBrushes.Add(terrainBrush11);
2244 }
2245 for (int num50 = 0; num50 < 16; num50++) {
2246 TerrainBrush terrainBrush12 = new();
2247 int num51 = random.Int(16, 32);
2248 for (int num52 = 0; num52 < num51; num52++) {
2249 Vector3 vector12 = 0.5f
2250 * Vector3.Normalize(new Vector3(random.Float(-1f, 1f), random.Float(-0.75f, 0.75f), random.Float(-1f, 1f)));
2251 int num53 = random.Int(6, 12);
2252 Vector3 zero12 = Vector3.Zero;
2253 for (int num54 = 0; num54 < num53; num54++) {
2254 terrainBrush12.AddBox(
2255 (int)MathF.Floor(zero12.X),
2256 (int)MathF.Floor(zero12.Y),
2257 (int)MathF.Floor(zero12.Z),
2258 1,
2259 1,
2260 1,
2261 7
2262 );
2263 zero12 += vector12;
2264 }
2265 }
2266 terrainBrush12.Compile();
2267 m_sandPocketBrushes.Add(terrainBrush12);
2268 }
2269 for (int num55 = 0; num55 < 16; num55++) {
2270 TerrainBrush terrainBrush13 = new();
2271 int num56 = random.Int(16, 32);
2272 for (int num57 = 0; num57 < num56; num57++) {
2273 Vector3 vector13 = 0.5f
2274 * Vector3.Normalize(new Vector3(random.Float(-1f, 1f), random.Float(-0.75f, 0.75f), random.Float(-1f, 1f)));
2275 int num58 = random.Int(6, 12);
2276 Vector3 zero13 = Vector3.Zero;
2277 for (int num59 = 0; num59 < num58; num59++) {
2278 terrainBrush13.AddBox(
2279 (int)MathF.Floor(zero13.X),
2280 (int)MathF.Floor(zero13.Y),
2281 (int)MathF.Floor(zero13.Z),
2282 1,
2283 1,
2284 1,
2285 67
2286 );
2287 zero13 += vector13;
2288 }
2289 }
2290 terrainBrush13.Compile();
2291 m_basaltPocketBrushes.Add(terrainBrush13);
2292 }
2293 for (int num60 = 0; num60 < 16; num60++) {
2294 TerrainBrush terrainBrush14 = new();
2295 int num61 = random.Int(16, 32);
2296 for (int num62 = 0; num62 < num61; num62++) {
2297 Vector3 vector14 = 0.5f * Vector3.Normalize(new Vector3(random.Float(-1f, 1f), random.Float(-1f, 1f), random.Float(-1f, 1f)));
2298 int num63 = random.Int(5, 10);
2299 Vector3 zero14 = Vector3.Zero;
2300 for (int num64 = 0; num64 < num63; num64++) {
2301 terrainBrush14.AddBox(
2302 (int)MathF.Floor(zero14.X),
2303 (int)MathF.Floor(zero14.Y),
2304 (int)MathF.Floor(zero14.Z),
2305 1,
2306 1,
2307 1,
2308 3
2309 );
2310 zero14 += vector14;
2311 }
2312 }
2313 terrainBrush14.Compile();
2314 m_granitePocketBrushes.Add(terrainBrush14);
2315 }
2316 int[] array = [4, 6, 8];
2317 for (int num65 = 0; num65 < 4 * array.Length; num65++) {
2318 TerrainBrush terrainBrush15 = new();
2319 int num66 = array[num65 / 4];
2320 int num67 = num65 % 2 + 1;
2321 float num68 = num65 % 4 == 2 ? 0.5f : 1f;
2322 int num69 = num65 % 4 == 1 ? num66 * num66 : 2 * num66 * num66;
2323 for (int num70 = 0; num70 < num69; num70++) {
2324 Vector2 vector15 = random.Vector2(0f, num66);
2325 float num71 = vector15.Length();
2326 int num72 = random.Int(3, 4);
2327 int sizeY = 1 + (int)MathUtils.Lerp(MathUtils.Max(num66 / 3, 2.5f) * num68, 0f, num71 / num66) + random.Int(0, 1);
2328 terrainBrush15.AddBox(
2329 (int)MathF.Floor(vector15.X),
2330 0,
2331 (int)MathF.Floor(vector15.Y),
2332 num72,
2333 sizeY,
2334 num72,
2335 0
2336 );
2337 terrainBrush15.AddBox(
2338 (int)MathF.Floor(vector15.X),
2339 -num67,
2340 (int)MathF.Floor(vector15.Y),
2341 num72,
2342 num67,
2343 num72,
2344 18
2345 );
2346 }
2347 terrainBrush15.Compile();
2348 m_waterPocketBrushes.Add(terrainBrush15);
2349 }
2350 int[] array2 = [8, 12, 14, 16];
2351 for (int num73 = 0; num73 < 4 * array2.Length; num73++) {
2352 TerrainBrush terrainBrush16 = new();
2353 int num74 = array2[num73 / 4];
2354 int num75 = num74 + 2;
2355 float num76 = num73 % 4 == 2 ? 0.5f : 1f;
2356 int num77 = num73 % 4 == 1 ? num74 * num74 : 2 * num74 * num74;
2357 for (int num78 = 0; num78 < num77; num78++) {
2358 Vector2 vector16 = random.Vector2(0f, num74);
2359 float num79 = vector16.Length();
2360 int num80 = random.Int(3, 4);
2361 int sizeY2 = 1 + (int)MathUtils.Lerp(MathUtils.Max(num74 / 3, 2.5f) * num76, 0f, num79 / num74) + random.Int(0, 1);
2362 int num81 = 1 + (int)MathUtils.Lerp(num75, 0f, num79 / num74) + random.Int(0, 1);
2363 terrainBrush16.AddBox(
2364 (int)MathF.Floor(vector16.X),
2365 0,
2366 (int)MathF.Floor(vector16.Y),
2367 num80,
2368 sizeY2,
2369 num80,
2370 0
2371 );
2372 terrainBrush16.AddBox(
2373 (int)MathF.Floor(vector16.X),
2374 -num81,
2375 (int)MathF.Floor(vector16.Y),
2376 num80,
2377 num81,
2378 num80,
2379 92
2380 );
2381 }
2382 terrainBrush16.Compile();
2383 m_magmaPocketBrushes.Add(terrainBrush16);
2384 }
2385 for (int num82 = 0; num82 < 7; num82++) {
2386 m_caveBrushesByType.Add([]);
2387 for (int num83 = 0; num83 < 3; num83++) {
2388 TerrainBrush terrainBrush17 = new();
2389 int num84 = 6 + 4 * num82;
2390 int max = 3 + num82 / 3;
2391 int max2 = 9 + num82;
2392 for (int num85 = 0; num85 < num84; num85++) {
2393 int num86 = random.Int(2, max);
2394 int num87 = random.Int(8, max2) - 2 * num86;
2395 Vector3 vector17 = 0.5f * new Vector3(random.Float(-1f, 1f), random.Float(0f, 1f), random.Float(-1f, 1f));
2396 Vector3 zero15 = Vector3.Zero;
2397 for (int num88 = 0; num88 < num87; num88++) {
2398 terrainBrush17.AddBox(
2399 (int)MathF.Floor(zero15.X) - num86 / 2,
2400 (int)MathF.Floor(zero15.Y) - num86 / 2,
2401 (int)MathF.Floor(zero15.Z) - num86 / 2,
2402 num86,
2403 num86,
2404 num86,
2405 0
2406 );
2407 zero15 += vector17;
2408 }
2409 }
2410 terrainBrush17.Compile();
2411 m_caveBrushesByType[num82].Add(terrainBrush17);
2412 }
2413 }
2414 ModsManager.HookAction(
2415 "OnTerrainBrushesCreated",
2416 loader => {
2417 loader.OnTerrainBrushesCreated();
2418 return false;
2419 }
2420 );
2421 }
2422
2423 public virtual void CallChunkGenerationStepAction(ChunkGenerationStep step, TerrainChunk chunk) {
2424 try {
2425 if (step.ShouldGenerate) {
2426 step.GenerateAction(chunk);
2427 }
2428 }
2429 catch (Exception e) {
2430 if (!step.ErrorLogged) {
2431 Log.Error($"ChunkGenerationStep \"{step.Name}\" at generateOrder {step.GenerateOrder}");
2432 Log.Error(e);
2433 }
2434 step.ErrorLogged = true;
2435 }
2436 }
2437 }
2438}
Vector3
Engine.Vector3 Vector3
定义 SubsystemAudio.cs:5
Engine.Log.Error
static void Error(object message)
定义 Log.cs:80
Engine.MathUtils.Min
static int Min(int x1, int x2)
定义 MathUtils.cs:7
Engine.MathUtils.Hash
static int Hash(int key)
定义 MathUtils.cs:63
Engine.MathUtils.Saturate
static float Saturate(float x)
定义 MathUtils.cs:163
Engine.MathUtils.PowSign
static float PowSign(float x, float n)
定义 MathUtils.cs:211
Engine.MathUtils.Max
static int Max(int x1, int x2)
定义 MathUtils.cs:18
Engine.MathUtils.Sqr
static int Sqr(int x)
定义 MathUtils.cs:43
Engine.MathUtils.Lerp
static float Lerp(float x1, float x2, float f)
定义 MathUtils.cs:213
Engine.MathUtils.LinearStep
static float LinearStep(float zero, float one, float f)
定义 MathUtils.cs:363
Game.Block.IsTransparent_
virtual bool IsTransparent_(int value)
定义 Block.cs:262
Game.Block.IsCollidable
bool IsCollidable
定义 Block.cs:51
Game.BlocksManager.FluidBlocks
static FluidBlock[] FluidBlocks
定义 BlocksManager.cs:44
Game.BottomSuckerBlock.SetSubvariant
static int SetSubvariant(int data, int face)
定义 BottomSuckerBlock.cs:32
Game.BottomSuckerBlock.SetFace
static int SetFace(int data, int face)
定义 BottomSuckerBlock.cs:28
Game.ChunkGenerationStep.GenerateAction
Action< TerrainChunk > GenerateAction
定义 ChunkGenerationStep.cs:10
Game.FluidBlock.SetIsTop
static int SetIsTop(int data, bool isTop)
定义 FluidBlock.cs:202
Game.GravestoneBlock.SetVariant
static int SetVariant(int data, int variant)
定义 GravestoneBlock.cs:176
Game.GravestoneBlock.SetRotation
static int SetRotation(int data, int rotation)
定义 GravestoneBlock.cs:172
Game.IvyBlock.SetFace
static int SetFace(int data, int face)
定义 IvyBlock.cs:291
Game.IvyBlock.IsGrowthStopCell
static bool IsGrowthStopCell(int x, int y, int z)
定义 IvyBlock.cs:293
Game.PlantsManager.GenerateRandomPlantValue
static int GenerateRandomPlantValue(Random random, int groundValue, int temperature, int humidity, int y)
定义 PlantsManager.cs:282
Game.PlantsManager.GetTreeBrushes
static ReadOnlyList< TerrainBrush > GetTreeBrushes(TreeType treeType)
定义 PlantsManager.cs:280
Game.PlantsManager.GenerateRandomTreeType
static ? TreeType GenerateRandomTreeType(Random random, int temperature, int humidity, int y, float densityMultiplier=1f)
定义 PlantsManager.cs:331
Game.PlantsManager.GetTreeTrunkValue
static int GetTreeTrunkValue(TreeType treeType)
定义 PlantsManager.cs:276
Game.PlantsManager.GetTreeLeavesValue
static int GetTreeLeavesValue(TreeType treeType)
定义 PlantsManager.cs:278
Game.Random.Vector3
Vector3 Vector3()
定义 Random.cs:98
Game.Random.Float
float Float()
定义 Random.cs:58
Game.Random.Vector2
Vector2 Vector2()
定义 Random.cs:76
Game.SimplexNoise.OctavedNoise
static float OctavedNoise(float x, float frequency, int octaves, float frequencyStep, float amplitudeStep, bool ridged=false)
定义 SimplexNoise.cs:732
Game.SpikedPlankBlock.SetSpikesState
static int SetSpikesState(int data, bool spikesState)
定义 SpikedPlankBlock.cs:65
Game.StairsBlock.SetRotation
static int SetRotation(int data, int rotation)
定义 StairsBlock.cs:418
Game.SubsystemWeather.ShaftHasSnowOnIce
static Func< int, int, bool > ShaftHasSnowOnIce
定义 SubsystemWeather.cs:100
Game.SubsystemWeather.GetTemperatureAdjustmentAtHeight
static Func< int, int > GetTemperatureAdjustmentAtHeight
定义 SubsystemWeather.cs:96
Game.SubsystemWeather.IsPlaceFrozen
static Func< int, int, bool > IsPlaceFrozen
定义 SubsystemWeather.cs:99
Game.TerrainBrush.PaintFast
void PaintFast(TerrainChunk chunk, int x, int y, int z)
定义 TerrainBrush.cs:333
Game.TerrainBrush.AddBox
void AddBox(int x, int y, int z, int sizeX, int sizeY, int sizeZ, Brush brush)
定义 TerrainBrush.cs:166
Game.TerrainBrush.AddCell
void AddCell(int x, int y, int z, Brush brush)
定义 TerrainBrush.cs:157
Game.TerrainChunk.CalculateCellIndex
static int CalculateCellIndex(int x, int y, int z)
定义 TerrainChunk.cs:138
Game.TerrainChunk.AddBrushPaint
virtual void AddBrushPaint(int x, int y, int z, TerrainBrush brush)
定义 TerrainChunk.cs:239
Game.TerrainChunk.GetCellValueFast
virtual int GetCellValueFast(int index)
定义 TerrainChunk.cs:165
Game.TerrainChunk.SetCellValueFast
virtual void SetCellValueFast(int x, int y, int z, int value)
定义 TerrainChunk.cs:171
Game.TerrainChunk.GetTemperatureFast
virtual int GetTemperatureFast(int x, int z)
定义 TerrainChunk.cs:199
Game.TerrainChunk.SetHumidityFast
virtual void SetHumidityFast(int x, int z, int humidity)
定义 TerrainChunk.cs:211
Game.TerrainChunk.SetTemperatureFast
virtual void SetTemperatureFast(int x, int z, int temperature)
定义 TerrainChunk.cs:203
Game.TerrainChunk.GetCellContentsFast
virtual int GetCellContentsFast(int x, int y, int z)
定义 TerrainChunk.cs:183
Game.TerrainChunk.GetHumidityFast
virtual int GetHumidityFast(int x, int z)
定义 TerrainChunk.cs:207
Game.TerrainChunk.CalculateTopmostCellHeight
virtual int CalculateTopmostCellHeight(int x, int z)
定义 TerrainChunk.cs:152
Game.TerrainContentsGenerator24.Grid2d.Set
virtual void Set(int x, int y, float value)
定义 TerrainContentsGenerator24.cs:36
Game.TerrainContentsGenerator24.Grid3d.Get8
virtual void Get8(int x, int y, int z, out float v111, out float v211, out float v121, out float v221, out float v112, out float v212, out float v122, out float v222)
定义 TerrainContentsGenerator24.cs:82
Game.TerrainContentsGenerator24.Grid3d.Sample
virtual float Sample(float x, float y, float z)
定义 TerrainContentsGenerator24.cs:110
Game.TerrainContentsGenerator24.Grid3d.Set
virtual void Set(int x, int y, int z, float value)
定义 TerrainContentsGenerator24.cs:106
Game.TerrainContentsGenerator24.GenerateBottomSuckers
virtual void GenerateBottomSuckers(TerrainChunk chunk)
定义 TerrainContentsGenerator24.cs:1283
Game.TerrainContentsGenerator24.CalculateOceanShoreDistance
virtual float CalculateOceanShoreDistance(float x, float z)
定义 TerrainContentsGenerator24.cs:424
Game.TerrainContentsGenerator24.GenerateBedrockAndAir
virtual void GenerateBedrockAndAir(TerrainChunk chunk)
定义 TerrainContentsGenerator24.cs:1239
Game.TerrainContentsGenerator24.GenerateLogs
virtual void GenerateLogs(TerrainChunk chunk)
定义 TerrainContentsGenerator24.cs:1040
Game.TerrainContentsGenerator24.GenerateSnowAndIce
virtual void GenerateSnowAndIce(TerrainChunk chunk)
定义 TerrainContentsGenerator24.cs:1897
Game.TerrainContentsGenerator24.m_subsystemBottomSuckerBlockBehavior
SubsystemBottomSuckerBlockBehavior m_subsystemBottomSuckerBlockBehavior
定义 TerrainContentsGenerator24.cs:174
Game.TerrainContentsGenerator24.UpdateFluidIsTop
virtual void UpdateFluidIsTop(TerrainChunk chunk)
定义 TerrainContentsGenerator24.cs:1960
Game.TerrainContentsGenerator24.GenerateCacti
virtual void GenerateCacti(TerrainChunk chunk)
定义 TerrainContentsGenerator24.cs:1360
Game.TerrainContentsGenerator24.GenerateChunkContentsPass3
virtual void GenerateChunkContentsPass3(TerrainChunk chunk)
定义 TerrainContentsGenerator24.cs:412
Game.TerrainContentsGenerator24.TerrainContentsGenerator24
TerrainContentsGenerator24(SubsystemTerrain subsystemTerrain)
定义 TerrainContentsGenerator24.cs:280
Game.TerrainContentsGenerator24.CalculateForestDensity
virtual float CalculateForestDensity(float x, float z)
定义 TerrainContentsGenerator24.cs:510
Game.TerrainContentsGenerator24.GenerateChunkContentsPass1
virtual void GenerateChunkContentsPass1(TerrainChunk chunk)
定义 TerrainContentsGenerator24.cs:400
Game.TerrainContentsGenerator24.GenerateChunkContentsPass2
virtual void GenerateChunkContentsPass2(TerrainChunk chunk)
定义 TerrainContentsGenerator24.cs:406
Game.TerrainContentsGenerator24.CalculateMountainRangeFactor
virtual float CalculateMountainRangeFactor(float x, float z)
定义 TerrainContentsGenerator24.cs:437
Game.TerrainContentsGenerator24.GenerateGraves
virtual void GenerateGraves(TerrainChunk chunk)
定义 TerrainContentsGenerator24.cs:1686
Game.TerrainContentsGenerator24.GenerateSurface
virtual void GenerateSurface(TerrainChunk chunk)
定义 TerrainContentsGenerator24.cs:701
Game.TerrainContentsGenerator24.CallChunkGenerationStepAction
virtual void CallChunkGenerationStepAction(ChunkGenerationStep step, TerrainChunk chunk)
定义 TerrainContentsGenerator24.cs:2423
Game.TerrainContentsGenerator24.CalculateHeight
virtual float CalculateHeight(float x, float z)
定义 TerrainContentsGenerator24.cs:447
Game.TerrainContentsGenerator24.GenerateKelp
virtual void GenerateKelp(TerrainChunk chunk)
定义 TerrainContentsGenerator24.cs:1445
Game.TerrainContentsGenerator24.GenerateTraps
virtual void GenerateTraps(TerrainChunk chunk)
定义 TerrainContentsGenerator24.cs:1620
Game.TerrainContentsGenerator24.GenerateTerrain
virtual void GenerateTerrain(TerrainChunk chunk, int x1, int z1, int x2, int z2)
定义 TerrainContentsGenerator24.cs:582
Game.TerrainContentsGenerator24.GeneratePumpkins
virtual void GeneratePumpkins(TerrainChunk chunk)
定义 TerrainContentsGenerator24.cs:1405
Game.TerrainContentsGenerator24.CalculateTemperature
virtual int CalculateTemperature(float x, float z)
定义 TerrainContentsGenerator24.cs:480
Game.TerrainContentsGenerator24.GenerateMinerals
virtual void GenerateMinerals(TerrainChunk chunk)
定义 TerrainContentsGenerator24.cs:757
Game.TerrainContentsGenerator24.GenerateSurfaceParameters
virtual void GenerateSurfaceParameters(TerrainChunk chunk, int x1, int z1, int x2, int z2)
定义 TerrainContentsGenerator24.cs:569
Game.TerrainContentsGenerator24.DistanceFromRange
static float DistanceFromRange(float x, float min, float max)
定义 TerrainContentsGenerator24.cs:559
Game.TerrainContentsGenerator24.GenerateTrees
virtual void GenerateTrees(TerrainChunk chunk)
定义 TerrainContentsGenerator24.cs:1183
Game.TerrainContentsGenerator24.PropagateFluidsDownwards
virtual void PropagateFluidsDownwards(TerrainChunk chunk)
定义 TerrainContentsGenerator24.cs:1938
Game.TerrainContentsGenerator24.Squish
static float Squish(float v, float zero, float one)
定义 TerrainContentsGenerator24.cs:502
Game.TerrainContentsGenerator24.GenerateChunkContentsPass4
virtual void GenerateChunkContentsPass4(TerrainChunk chunk)
定义 TerrainContentsGenerator24.cs:418
Game.TerrainContentsGenerator24.GenerateCairns
virtual void GenerateCairns(TerrainChunk chunk)
定义 TerrainContentsGenerator24.cs:1870
Game.TerrainContentsGenerator24.GenerateGrassAndPlants
virtual void GenerateGrassAndPlants(TerrainChunk chunk)
定义 TerrainContentsGenerator24.cs:1254
Game.TerrainContentsGenerator24.GenerateCaves
virtual void GenerateCaves(TerrainChunk chunk)
定义 TerrainContentsGenerator24.cs:924
Game.TerrainContentsGenerator24.GeneratePockets
virtual void GeneratePockets(TerrainChunk chunk)
定义 TerrainContentsGenerator24.cs:824
Game.TerrainContentsGenerator24.m_caveBrushesByType
static List< List< TerrainBrush > > m_caveBrushesByType
定义 TerrainContentsGenerator24.cs:170
Game.TerrainContentsGenerator24.GenerateSeagrass
virtual void GenerateSeagrass(TerrainChunk chunk)
定义 TerrainContentsGenerator24.cs:1512
Game.Terrain.ToChunk
static Point2 ToChunk(Vector2 p)
定义 Terrain.cs:206
Game.Terrain.ExtractContents
static int ExtractContents(int value)
定义 Terrain.cs:303
Game.Terrain.ReplaceData
static int ReplaceData(int value, int data)
定义 Terrain.cs:331
Game.Terrain.GetHumidity
virtual int GetHumidity(int x, int z)
定义 Terrain.cs:276
Game.Terrain.SetCellValueFast
virtual void SetCellValueFast(int x, int y, int z, int value)
定义 Terrain.cs:252
Game.Terrain.ToCell
static int ToCell(float x)
定义 Terrain.cs:210
Game.Terrain.GetCellContentsFast
virtual int GetCellContentsFast(int x, int y, int z)
定义 Terrain.cs:244
Game.Terrain.ReplaceContents
static int ReplaceContents(int value, int contents)
方块值的最低10位，替换为目标Content
定义 Terrain.cs:322
Game.Terrain.MakeBlockValue
static int MakeBlockValue(int contents)
定义 Terrain.cs:298
Game.Terrain.ExtractData
static int ExtractData(int value)
定义 Terrain.cs:307
Game.Terrain.CalculateTopmostCellHeight
virtual int CalculateTopmostCellHeight(int x, int z)
定义 Terrain.cs:256
Game.Terrain.GetTemperature
virtual int GetTemperature(int x, int z)
定义 Terrain.cs:268
Game.WoodBlock.SetCutFace
static int SetCutFace(int data, int cutFace)
定义 WoodBlock.cs:107
GameEntitySystem.Project.FindSubsystem
virtual Subsystem FindSubsystem(Type type, string name, bool throwOnError)
定义 Project.cs:110
ModsManager.HookAction
static void HookAction(string HookName, Func< ModLoader, bool > action)
执行Hook
定义 ModsManager.cs:146
Engine.Vector2.Zero
static readonly Vector2 Zero
定义 Vector2.cs:7
Engine.Vector2.Round
static Vector2 Round(Vector2 v)
定义 Vector2.cs:77
Engine.Vector3.Cross
static Vector3 Cross(Vector3 v1, Vector3 v2)
定义 Vector3.cs:114
Engine.Vector3.Normalize
static Vector3 Normalize(Vector3 v)
定义 Vector3.cs:154
Engine.Vector3.Zero
static readonly Vector3 Zero
定义 Vector3.cs:9
Game.CellFace.OppositeFace
static int OppositeFace(int face)
定义 CellFace.cs:46
Game.CellFace.FaceToPoint3
static Point3 FaceToPoint3(int face)
定义 CellFace.cs:48
Game.CellFace.Point3ToFace
static int Point3ToFace(Point3 p, int maxFace=5)
定义 CellFace.cs:54