static void Postfix(IntVec3 c, ref TerrainDef __result)
{
if (__result == TerrainDef.Named("Sandstone_Rough"))
{
__result = GenStep_RocksFromGrid.RockDefAt(c).building.naturalTerrain;
}
}
private void GenIsland(IntVec3 current, ModuleBase island, Map map)
{
if (island.GetValue(current) > 0.55)
{
map.terrainGrid.SetTerrain(current, GenStep_RocksFromGrid.RockDefAt(current).naturalTerrain);
}
}
public static void Postfix(ref TerrainDef __result, IntVec3 c, Map map)
{
BiomeDef biome = map.Biome;
// General cell terrain replcement
ModExt_Biome_Replacement extReplacement = biome.GetModExtension <ModExt_Biome_Replacement>() ?? ModExt_Biome_Replacement.Default;
// Replace sand (mostly from beach)
if (__result == RimWorld.TerrainDefOf.Sand)
{
__result = extReplacement.sandReplacement;
}
// Replace gravel
if (__result == RimWorld.TerrainDefOf.Gravel)
{
__result = extReplacement.gravelReplacement;
}
// Addtitional island terrainPatchMaker by fertility
if (biome.HasModExtension <ModExt_Biome_GenStep_Islands>())
{
TerrainDef newTerrain = IslandNoises.TerrainAtFromTerrainPatchMakerByFertility(c, map, __result);
if (newTerrain != null)
{
__result = newTerrain;
}
}
// Post-terrain-gen terrain replacement
// Replace filler stone
if (__result == TerrainDefOf.FillerStone)
{
__result = GenStep_RocksFromGrid.RockDefAt(c).building.naturalTerrain;
}
}
private void SetRockySoil(IntVec3 current, Map map)
{
if (current.GetTerrain(map) == RWBTerrainDefOf.RWBRockySoil)
{
if (GenStep_RocksFromGrid.RockDefAt(current).naturalTerrain.defName.Contains("Sand"))
{
map.terrainGrid.SetTerrain(current, RWBTerrainDefOf.RWBSandstoneSoil);
}
if (GenStep_RocksFromGrid.RockDefAt(current).naturalTerrain.defName.Contains("Marble"))
{
map.terrainGrid.SetTerrain(current, RWBTerrainDefOf.RWBMarbleSoil);
}
if (GenStep_RocksFromGrid.RockDefAt(current).naturalTerrain.defName.Contains("Slate"))
{
map.terrainGrid.SetTerrain(current, RWBTerrainDefOf.RWBSlateSoil);
}
if (GenStep_RocksFromGrid.RockDefAt(current).naturalTerrain.defName.Contains("Granite"))
{
map.terrainGrid.SetTerrain(current, RWBTerrainDefOf.RWBGraniteSoil);
}
if (GenStep_RocksFromGrid.RockDefAt(current).naturalTerrain.defName.Contains("Lime"))
{
map.terrainGrid.SetTerrain(current, RWBTerrainDefOf.RWBLimestoneSoil);
}
}
}
/// <summary>
/// Identifies the terrain def that would have been used at the given map location.
/// Swiped from GenStep_Terrain. Extracted for performance reasons.
/// </summary>
private static TerrainDef TerrainFrom(IntVec3 c, Map map, float elevation, float fertility, RiverMakerTerrainAt riverTerrainAt, BeachMakerBeachTerrainAt beachTerrainAt, bool preferSolid)
{
TerrainDef terrainDef = null;
if (riverTerrainAt != null)
{
terrainDef = riverTerrainAt(c, true);
}
TerrainDef result;
if (terrainDef == null && preferSolid)
{
result = GenStep_RocksFromGrid.RockDefAt(c).building.naturalTerrain;
}
else
{
var terrain = beachTerrainAt(c, map.Biome);
if (terrain == TerrainDefOf.WaterOceanDeep)
{
result = terrain;
}
else if (terrainDef != null && terrainDef.IsRiver)
{
result = terrainDef;
}
else if (terrain != null)
{
result = terrain;
}
else if (terrainDef != null)
{
result = terrainDef;
}
else
{
for (int i = 0; i < map.Biome.terrainPatchMakers.Count; i++)
{
terrain = map.Biome.terrainPatchMakers[i].TerrainAt(c, map, fertility);
if (terrain != null)
{
return(terrain);
}
}
if (elevation > 0.55f && elevation < 0.61f)
{
result = TerrainDefOf.Gravel;
}
else if (elevation >= 0.61f)
{
result = GenStep_RocksFromGrid.RockDefAt(c).building.naturalTerrain;
}
else
{
terrain = TerrainThreshold.TerrainAtValue(map.Biome.terrainsByFertility, fertility);
result = terrain ?? TerrainDefOf.Sand;
}
}
}
return(result);
}
/// <summary>
/// Finds the actual terrain types.
/// Copied from Vanilla, probably needs heavy cleanup
/// </summary>
private TerrainDef TerrainFrom(IntVec3 c, Map map, float elevation, float fertility, bool preferSolid)
{
TerrainDef terrainDef = null;
if (terrainDef == null && preferSolid)
{
return(GenStep_RocksFromGrid.RockDefAt(c).building.naturalTerrain);
}
TerrainDef terrainDef2 = BeachMaker.BeachTerrainAt(c, map.Biome);
if (terrainDef2 == TerrainDefOf.WaterOceanDeep)
{
return(terrainDef2);
}
if (terrainDef != null && terrainDef.IsRiver)
{
return(terrainDef);
}
if (terrainDef2 != null)
{
return(terrainDef2);
}
if (terrainDef != null)
{
return(terrainDef);
}
for (int i = 0; i < map.Biome.terrainPatchMakers.Count; i++)
{
terrainDef2 = map.Biome.terrainPatchMakers[i].TerrainAt(c, map, fertility);
if (terrainDef2 != null)
{
return(terrainDef2);
}
}
if (elevation > 0.55f && elevation < 0.61f)
{
return(TerrainDefOf.Gravel);
}
if (elevation >= 0.61f)
{
return(GenStep_RocksFromGrid.RockDefAt(c).building.naturalTerrain);
}
terrainDef2 = TerrainThreshold.TerrainAtValue(map.Biome.terrainsByFertility, fertility);
if (terrainDef2 != null)
{
return(terrainDef2);
}
return(TerrainDefOf.Sand);
}
// Token: 0x0600001C RID: 28 RVA: 0x00002B78 File Offset: 0x00000D78
public override void Generate(Map map, GenStepParams parms)
{
map.regionAndRoomUpdater.Enabled = false;
foreach (IntVec3 intVec in map.AllCells)
{
ThingDef def = GenStep_RocksFromGrid.RockDefAt(intVec);
bool flag = ((UndergroundMapParent)map.info.parent).holeLocation.DistanceTo(intVec) > 5f;
if (flag)
{
GenSpawn.Spawn(def, intVec, map, WipeMode.Vanish);
}
map.roofGrid.SetRoof(intVec, RoofDefOf.RoofRockThick);
}
GenStep_ScatterLumpsMineable genStep_ScatterLumpsMineable = new GenStep_ScatterLumpsMineable();
float num = 16f;
genStep_ScatterLumpsMineable.countPer10kCellsRange = new FloatRange(num, num);
genStep_ScatterLumpsMineable.Generate(map, default);
map.regionAndRoomUpdater.Enabled = true;
}
public override void Generate(Map map)
{
Log.Message("hey2");
if (!Find.World.grid[map.Tile].biome.Equals(BiomeDef.Named("Caves")))
{
RocksFromGrid.baseGenstep.Generate(map);
return;
}
MapGenFloatGrid elevation = MapGenerator.Elevation;
int x = map.Size.x;
int z = map.Size.z;
int[,] array = MapGen.GenMap(x, z, 5, 0.5);
RocksFromGrid.RiverMap = MapGen.GenRiver(x, z, null);
foreach (IntVec3 current in map.AllCells)
{
if (array[current.x, current.z] == 1 && RocksFromGrid.RiverMap[current.x, current.z] == 0)
{
GenSpawn.Spawn(GenStep_RocksFromGrid.RockDefAt(current), current, map);
}
map.roofGrid.SetRoof(current, RoofDefOf.RoofRockThick);
}
}
public override void Generate(Map map, GenStepParams parms)
{
Log.Message("Generating cavern roofs");
map.regionAndRoomUpdater.Enabled = false;
float num = 0.7f;
MapGenFloatGrid elevation = MapGenerator.Elevation;
foreach (IntVec3 current in map.AllCells)
{
float num2 = elevation[current];
if (num2 > num)
{
ThingDef def = GenStep_RocksFromGrid.RockDefAt(current);
GenSpawn.Spawn(def, current, map, WipeMode.Vanish);
}
map.roofGrid.SetRoof(current, BiomesCoreDefOf.BMT_RockRoofStable);
}
//BoolGrid visited = new BoolGrid(map);
//List<IntVec3> toRemove = new List<IntVec3>();
//foreach (IntVec3 current2 in map.AllCells)
//{
// if (!visited[current2])
// {
// toRemove.Clear();
// map.floodFiller.FloodFill(current2, (IntVec3 x) => true, delegate (IntVec3 x)
// {
// visited[x] = true;
// toRemove.Add(x);
// }, 2147483647, false, null);
// if (toRemove.Count < 20)
// {
// for (int j = 0; j < toRemove.Count; j++)
// {
// map.roofGrid.SetRoof(toRemove[j], null);
// }
// }
// }
//}
GenStep_ScatterLumpsMineable genStep_ScatterLumpsMineable = new GenStep_ScatterLumpsMineable();
genStep_ScatterLumpsMineable.maxValue = this.maxMineableValue;
float num3 = 10f;
switch (Find.WorldGrid[map.Tile].hilliness)
{
case Hilliness.Flat:
num3 = 4f;
break;
case Hilliness.SmallHills:
num3 = 8f;
break;
case Hilliness.LargeHills:
num3 = 11f;
break;
case Hilliness.Mountainous:
num3 = 15f;
break;
case Hilliness.Impassable:
num3 = 16f;
break;
}
genStep_ScatterLumpsMineable.countPer10kCellsRange = new FloatRange(num3, num3);
genStep_ScatterLumpsMineable.Generate(map, parms);
map.regionAndRoomUpdater.Enabled = true;
}
public override void Generate(Map map)
{
if (map.Biome.defName != "RWBCavern")
{
return;
}
ModuleBase roof = new Perlin(0.04, 2.0, 0.5, 4, Rand.Int, QualityMode.Medium);
MapGenFloatGrid arg_3B_0 = MapGenerator.Elevation;
//Log.Error("Called");
foreach (IntVec3 current in map.AllCells)
{
map.roofGrid.SetRoof(current, RoofDefOf.RoofRockThick);
//Thing thing = map.edificeGrid.InnerArray[map.cellIndices.CellToIndex(current)];
if (current.GetFirstBuilding(map) == null)
{
if (current.GetTerrain(map) == TerrainDefOf.Soil || current.GetTerrain(map) == TerrainDefOf.Gravel)
{
map.terrainGrid.SetTerrain(current, GenStep_RocksFromGrid.RockDefAt(current).naturalTerrain);
}
//Log.Error("change?");
}
if (isWater(current, map))
{
for (int i = -2; i < 3; i++)
{
for (int j = -2; j < 3; j++)
{
IntVec3 tvec = new IntVec3(current.x + i, current.y, current.z + j);
if (tvec.InBounds(map) && !isWater(tvec, map) && tvec.GetTerrain(map).defName != "Mud")
{
if (tvec.GetFirstBuilding(map) != null)
{
tvec.GetFirstBuilding(map).Destroy();
}
map.terrainGrid.SetTerrain(tvec, TerrainDefOf.Soil);
//map.roofGrid.SetRoof(tvec, RoofDefOf.RoofRockThick);
}
}
}
}
}
foreach (IntVec3 current in map.AllCells)
{
if (current.GetTerrain(map).defName == "SoilRich")
{
map.terrainGrid.SetTerrain(current, GenStep_RocksFromGrid.RockDefAt(current).naturalTerrain);
//map.roofGrid.SetRoof(current, RoofDefOf.RoofRockThick);
}
if (current.GetTerrain(map) == TerrainDefOf.WaterShallow)
{
for (int i = -2; i < 3; i++)
{
for (int j = -2; j < 3; j++)
{
IntVec3 tvec = new IntVec3(current.x + i, current.y, current.z + j);
if (tvec.InBounds(map) && tvec.GetTerrain(map) == GenStep_RocksFromGrid.RockDefAt(current).naturalTerrain)
{
if (tvec.GetFirstBuilding(map) != null)
{
tvec.GetFirstBuilding(map).Destroy();
}
map.terrainGrid.SetTerrain(tvec, TerrainDefOf.Soil);
//map.roofGrid.SetRoof(tvec, RoofDefOf.RoofRockThick);
}
}
}
}
if (current.GetTerrain(map).defName == "Mud")
{
map.terrainGrid.SetTerrain(current, TerrainDefOf.Soil);
}
if (current.GetTerrain(map) == TerrainDefOf.Soil)
{
int count = 0;
for (int i = -2; i < 3; i++)
{
for (int j = -2; j < 3; j++)
{
IntVec3 tvec = new IntVec3(current.x + i, current.y, current.z + j);
if (tvec.InBounds(map) && (tvec.GetTerrain(map) == TerrainDefOf.WaterMovingDeep || tvec.GetTerrain(map) == TerrainDefOf.WaterMovingShallow))
{
count++;
}
}
}
if (count > 1)
{
map.terrainGrid.SetTerrain(current, TerrainDefOf.WaterMovingShallow);
}
}
GenRoof(current, roof, map);
if (isStone(current, map) && current.GetFirstBuilding(map) == null)
{
System.Random rand = new System.Random();
int r2 = rand.Next(0, 1001);
//for (int i = 0; i < 100; i++)
//{
// r2 = rand.Next(0, 1001);
// //r2 = r2 + 0;
// //Log.Error(r2.ToString());
//}
rand = new System.Random();
r2 = Rand.RangeInclusive(0, 1000);
if (r2 < 10)
{
//Log.Error(r2.ToString());
string str = "RWBStalagmite";
//int r = rand.Next(1, 5);
//for (int i = 0; i < 100; i++)
//{
// r = Rand.RangeInclusive(1,4);
// //Log.Error(r.ToString());
// r = r + 0;
//}
//if (GenStep_RocksFromGrid.RockDefAt(current).naturalTerrain.defName.Contains("Sand"))
//{
// str = str + "A";
//}
//if (GenStep_RocksFromGrid.RockDefAt(current).naturalTerrain.defName.Contains("Marble"))
//{
// str = str + "E";
//}
//if (GenStep_RocksFromGrid.RockDefAt(current).naturalTerrain.defName.Contains("Slate"))
//{
// str = str + "D";
//}
//if (GenStep_RocksFromGrid.RockDefAt(current).naturalTerrain.defName.Contains("Granite"))
//{
// str = str + "B";
//}
//if (GenStep_RocksFromGrid.RockDefAt(current).naturalTerrain.defName.Contains("Lime"))
//{
// str = str + "C";
//}
//if (r == 1)
//{
// str = str + "A";
//}
//if (r == 2)
//{
// str = str + "B";
//}
//if (r == 3)
//{
// str = str + "C";
//}
//if (r == 4)
//{
// str = str + "D";
//}
GenSpawn.Spawn(ThingDef.Named(str), current, map);
}
}
if (current.GetTerrain(map) == RWBTerrainDefOf.RockySoil)
{
if (GenStep_RocksFromGrid.RockDefAt(current).naturalTerrain.defName.Contains("Sand"))
{
map.terrainGrid.SetTerrain(current, RWBTerrainDefOf.SandstoneSoil);
}
if (GenStep_RocksFromGrid.RockDefAt(current).naturalTerrain.defName.Contains("Marble"))
{
map.terrainGrid.SetTerrain(current, RWBTerrainDefOf.MarbleSoil);
}
if (GenStep_RocksFromGrid.RockDefAt(current).naturalTerrain.defName.Contains("Slate"))
{
map.terrainGrid.SetTerrain(current, RWBTerrainDefOf.SlateSoil);
}
if (GenStep_RocksFromGrid.RockDefAt(current).naturalTerrain.defName.Contains("Granite"))
{
map.terrainGrid.SetTerrain(current, RWBTerrainDefOf.GraniteSoil);
}
if (GenStep_RocksFromGrid.RockDefAt(current).naturalTerrain.defName.Contains("Lime"))
{
map.terrainGrid.SetTerrain(current, RWBTerrainDefOf.LimestoneSoil);
}
}
}
map.regionAndRoomUpdater.Enabled = true;
map.regionAndRoomUpdater.RebuildAllRegionsAndRooms();
}
private TerrainDef TerrainFrom(IntVec3 c, Map map, float elevation, float fertility, bool preferSolid)
{
TerrainDef terrainDef = null;
if (terrainDef == null && preferSolid)
{
return(GenStep_RocksFromGrid.RockDefAt(c).building.naturalTerrain);
}
TerrainDef terrainDef2 = BeachMaker.BeachTerrainAt(c, map.Biome);
if (terrainDef2 == TerrainDefOf.WaterOceanDeep)
{
return(terrainDef2);
}
if (terrainDef != null && terrainDef.IsRiver)
{
return(terrainDef);
}
if (terrainDef2 != null)
{
return(terrainDef2);
}
if (terrainDef != null)
{
return(terrainDef);
}
for (int i = 0; i < map.Biome.terrainPatchMakers.Count; i++)
{
terrainDef2 = map.Biome.terrainPatchMakers[i].TerrainAt(c, map, fertility);
if (terrainDef2 != null)
{
return(terrainDef2);
}
}
if (elevation > 0.55f && elevation < 0.61f)
{
return(TerrainDefOf.Gravel);
}
if (elevation >= 0.61f)
{
return(GenStep_RocksFromGrid.RockDefAt(c).building.naturalTerrain);
}
terrainDef2 = TerrainThreshold.TerrainAtValue(map.Biome.terrainsByFertility, fertility);
if (terrainDef2 != null)
{
return(terrainDef2);
}
if (!GenStep_TerrainUpper.debug_WarnedMissingTerrain)
{
Log.Error(string.Concat(new object[]
{
"No terrain found in biome ",
map.Biome.defName,
" for elevation=",
elevation,
", fertility=",
fertility
}));
GenStep_TerrainUpper.debug_WarnedMissingTerrain = true;
}
return(TerrainDefOf.Sand);
}
public override void Generate(Map map)
{
if (map.TileInfo.WaterCovered)
{
return;
}
map.regionAndRoomUpdater.Enabled = false;
float num = 0.7f;
List <RoofThreshold> list = new List <RoofThreshold>();
list.Add(new RoofThreshold
{
roofDef = RoofDefOf.RoofRockThick,
minGridVal = num * 1.14f
});
list.Add(new RoofThreshold
{
roofDef = RoofDefOf.RoofRockThin,
minGridVal = num * 1.04f
});
MapGenFloatGrid elevation = MapGenerator.Elevation;
foreach (IntVec3 current in map.AllCells)
{
float num2 = elevation[current];
if (num2 > num)
{
ThingDef def = GenStep_RocksFromGrid.RockDefAt(current);
GenSpawn.Spawn(def, current, map);
for (int i = 0; i < list.Count; i++)
{
if (num2 > list[i].minGridVal)
{
map.roofGrid.SetRoof(current, list[i].roofDef);
break;
}
}
}
}
BoolGrid visited = new BoolGrid(map);
List <IntVec3> toRemove = new List <IntVec3>();
foreach (IntVec3 current2 in map.AllCells)
{
if (!visited[current2])
{
if (this.IsNaturalRoofAt(current2, map))
{
toRemove.Clear();
map.floodFiller.FloodFill(current2, (IntVec3 x) => this.IsNaturalRoofAt(x, map), delegate(IntVec3 x)
{
visited[x] = true;
toRemove.Add(x);
}, false);
if (toRemove.Count < 20)
{
for (int j = 0; j < toRemove.Count; j++)
{
map.roofGrid.SetRoof(toRemove[j], null);
}
}
}
}
}
GenStep_ScatterLumpsMineable genStep_ScatterLumpsMineable = new GenStep_ScatterLumpsMineable();
float num3 = 10f;
// Use RA values here
var defExtension = def.GetModExtension <GenStepExtension>() ?? new GenStepExtension();
switch (Find.WorldGrid[map.Tile].hilliness)
{
case Hilliness.Flat:
num3 = defExtension.FlatMineablesPer10kCells;
break;
case Hilliness.SmallHills:
num3 = defExtension.SmallHillsMineablesPer10kCells;
break;
case Hilliness.LargeHills:
num3 = defExtension.LargeHillsMineablesPer10kCells;
break;
case Hilliness.Mountainous:
num3 = defExtension.MountainousMineablesPer10kCells;
break;
case Hilliness.Impassable:
num3 = 16f;
break;
}
genStep_ScatterLumpsMineable.countPer10kCellsRange = new FloatRange(num3, num3);
genStep_ScatterLumpsMineable.Generate(map);
map.regionAndRoomUpdater.Enabled = true;
}
public override void Generate(Map map, GenStepParams parms)
{
if (!map.Biome.HasModExtension <BiomesMap>())
{
return;
}
if (!map.Biome.GetModExtension <BiomesMap>().isIsland)
{
return;
}
if (!map.Biome.GetModExtension <BiomesMap>().addIslandHills)
{
return;
}
Log.Message("[Biomes Core] Generating island hills...");
map.regionAndRoomUpdater.Enabled = false;
float roofThreshhold = 0.7f;
List <GenStep_IslandRocksFromGrid.RoofThreshold> list = new List <GenStep_IslandRocksFromGrid.RoofThreshold>();
list.Add(new GenStep_IslandRocksFromGrid.RoofThreshold
{
roofDef = RoofDefOf.RoofRockThick,
minGridVal = roofThreshhold * 1.14f
});
list.Add(new GenStep_IslandRocksFromGrid.RoofThreshold
{
roofDef = RoofDefOf.RoofRockThin,
minGridVal = roofThreshhold * 1.04f
});
MapGenFloatGrid elevation = MapGenerator.Elevation;
MapGenFloatGrid caves = MapGenerator.Caves;
foreach (IntVec3 current in map.AllCells)
{
float curElev = elevation[current];
if (curElev > roofThreshhold)
{
if (caves[current] <= 0f)
{
ThingDef def = GenStep_RocksFromGrid.RockDefAt(current);
GenSpawn.Spawn(def, current, map, WipeMode.Vanish);
}
for (int i = 0; i < list.Count; i++)
{
if (curElev > list[i].minGridVal)
{
map.roofGrid.SetRoof(current, list[i].roofDef);
break;
}
}
}
}
BoolGrid visited = new BoolGrid(map);
List <IntVec3> toRemove = new List <IntVec3>();
foreach (IntVec3 current2 in map.AllCells)
{
if (!visited[current2])
{
if (this.IsNaturalRoofAt(current2, map))
{
toRemove.Clear();
map.floodFiller.FloodFill(current2, (IntVec3 x) => this.IsNaturalRoofAt(x, map), delegate(IntVec3 x)
{
visited[x] = true;
toRemove.Add(x);
}, 2147483647, false, null);
if (toRemove.Count < MinRoofedCellsPerGroup)
{
for (int j = 0; j < toRemove.Count; j++)
{
map.roofGrid.SetRoof(toRemove[j], null);
}
}
}
}
}
GenStep_ScatterLumpsMineable genStep_ScatterLumpsMineable = new GenStep_ScatterLumpsMineable();
genStep_ScatterLumpsMineable.maxValue = this.maxMineableValue;
float oreTuning = 10f;
switch (Find.WorldGrid[map.Tile].hilliness)
{
case Hilliness.Flat:
oreTuning = 4f;
break;
case Hilliness.SmallHills:
oreTuning = 8f;
break;
case Hilliness.LargeHills:
oreTuning = 11f;
break;
case Hilliness.Mountainous:
oreTuning = 15f;
break;
case Hilliness.Impassable:
oreTuning = 16f;
break;
}
// This scales the amount of available ore for islands
oreTuning *= 0.8f;
genStep_ScatterLumpsMineable.countPer10kCellsRange = new FloatRange(oreTuning, oreTuning);
genStep_ScatterLumpsMineable.Generate(map, parms);
map.regionAndRoomUpdater.Enabled = true;
}
private TerrainDef TerrainFrom(IntVec3 c, Map map, float elevation, float fertility, RiverMaker river, bool preferSolid)
{
TerrainDef terrainDef = null;
if (c.Walkable(map) && SurroundedWithWalls(c, map) && Rand.Chance(0.2f))
{
return(TerrainDefOf.Gravel);
}
if (river != null)
{
terrainDef = river.TerrainAt(c, recordForValidation: true);
}
if (terrainDef == null && preferSolid)
{
return(GenStep_RocksFromGridUnderground.RockDefAt(c).building.naturalTerrain);
}
TerrainDef terrainDef2 = BeachMaker.BeachTerrainAt(c, map.Biome);
if (terrainDef2 == TerrainDefOf.WaterOceanDeep)
{
return(terrainDef2);
}
if (terrainDef != null && terrainDef.IsRiver)
{
return(terrainDef);
}
if (terrainDef2 != null)
{
return(terrainDef2);
}
if (terrainDef != null)
{
return(terrainDef);
}
for (int i = 0; i < map.Biome.terrainPatchMakers.Count; i++)
{
terrainDef2 = map.Biome.terrainPatchMakers[i].TerrainAt(c, map, fertility);
if (terrainDef2 != null)
{
return(terrainDef2);
}
}
if (elevation > 0.55f && elevation < 0.61f)
{
return(TerrainDefOf.Gravel);
}
if (elevation >= 0.61f)
{
return(GenStep_RocksFromGrid.RockDefAt(c).building.naturalTerrain);
}
terrainDef2 = TerrainThreshold.TerrainAtValue(map.Biome.terrainsByFertility, fertility);
if (terrainDef2 != null)
{
ZLogger.Message("8 Terrain: " + terrainDef2 + " - Loc: " + c);
return(terrainDef2);
}
if (!debug_WarnedMissingTerrain)
{
debug_WarnedMissingTerrain = true;
}
return(TerrainDefOf.Sand);
}
private static bool Prefix(IntVec3 c, Map map, float elevation, float fertility, ref TerrainDef __result)
{
if (map.Biome.defName.Contains("Archipelago"))
{
float adjustment = 0.0f;
if (Controller.Settings.waterLevel < 1)
{
adjustment = -0.1f;
}
else if (Controller.Settings.waterLevel < 2)
{
adjustment = -0.05f;
}
else if (Controller.Settings.waterLevel < 3)
{
}
else if (Controller.Settings.waterLevel < 4)
{
adjustment = 0.05f;
}
else
{
adjustment = 0.1f;
}
bool lakeIsles = false;
if (map.Biome.defName.Contains("_Fresh"))
{
lakeIsles = true;
}
if (elevation < 0.75f)
{
Building edifice = c.GetEdifice(map);
if (edifice != null)
{
edifice.Destroy(DestroyMode.Vanish);
}
map.roofGrid.SetRoof(c, null);
for (int i = -1; i < 2; i++)
{
for (int j = -1; j < 2; j++)
{
int x = c.x + i;
int z = c.z + j;
if (x >= 0 && z >= 0 && x < map.Size.x && z < map.Size.z)
{
IntVec3 newSpot = new IntVec3(x, 0, z);
if (map.roofGrid.RoofAt(newSpot) != null)
{
if (map.roofGrid.RoofAt(newSpot).isThickRoof)
{
map.roofGrid.SetRoof(newSpot, RoofDefOf.RoofRockThin);
}
else
{
if ((i == 0 && j != 0) || (i != 0 && j == 0))
{
if (Rand.Value < 0.33)
{
map.roofGrid.SetRoof(newSpot, null);
}
}
}
}
}
}
}
}
if (elevation > 0.65f && elevation <= 0.69f)
{
__result = TerrainDefOf.Gravel;
return(false);
}
if (elevation > 0.69f & elevation < 0.71f)
{
__result = TerrainDefOf.Gravel;
return(false);
}
if (elevation >= 0.71f)
{
__result = GenStep_RocksFromGrid.RockDefAt(c).building.naturalTerrain;
return(false);
}
TerrainDef deepWater = TerrainDefOf.WaterOceanDeep;
TerrainDef shallowWater = TerrainDefOf.WaterOceanShallow;
if (lakeIsles.Equals(true))
{
deepWater = TerrainDefOf.WaterDeep;
shallowWater = TerrainDefOf.WaterShallow;
}
if (elevation < 0.35f + adjustment)
{
__result = deepWater;
return(false);
}
if (elevation < 0.45f + adjustment)
{
__result = shallowWater;
return(false);
}
TerrainDef borderTerrainL = TerrainDefOf.Sand;
TerrainDef borderTerrainH = TerrainDefOf.Sand;
if (lakeIsles.Equals(true))
{
if (map.Biome.defName.Contains("Boreal") || map.Biome.defName.Contains("Tundra"))
{
borderTerrainL = TerrainDef.Named("Mud");
borderTerrainH = TerrainDef.Named("MossyTerrain");
}
else if (map.Biome.defName.Contains("ColdBog") || map.Biome.defName.Contains("Swamp"))
{
borderTerrainL = TerrainDef.Named("Marsh");
borderTerrainH = TerrainDef.Named("MarshyTerrain");
}
else if (map.Biome.defName.Contains("Temperate") || map.Biome.defName.Contains("Tropical"))
{
borderTerrainL = TerrainDef.Named("Mud");
borderTerrainH = TerrainDef.Named("SoilRich");
}
}
if (elevation < 0.47f + adjustment)
{
__result = borderTerrainL;
return(false);
}
if (elevation < 0.50f + adjustment)
{
__result = borderTerrainH;
return(false);
}
TerrainDef terrainDef = TerrainThreshold.TerrainAtValue(map.Biome.terrainsByFertility, fertility);
if (terrainDef != null)
{
__result = terrainDef;
return(false);
}
__result = borderTerrainH;
return(false);
}
return(true);
}
public TerrainDef TerrainFrom(IntVec3 c, Map map, float elevation, float fertility, bool preferSolid)
{
TerrainDef terrainDef = null;
TerrainDef terrainDef2 = null;
if (terrainDef == null && preferSolid)
{
return(GenStep_RocksFromGrid.RockDefAt(c).building.naturalTerrain);
}
//TerrainDef terrainDef2 = BeachMaker.BeachTerrainAt(c, map.Biome);
if (terrainDef2 == TerrainDefOf.WaterOceanDeep)
{
return(terrainDef2);
}
if (terrainDef == TerrainDefOf.WaterMovingShallow || terrainDef == TerrainDefOf.WaterOceanDeep)
{
return(terrainDef);
}
if (terrainDef2 != null)
{
return(terrainDef2);
}
if (terrainDef != null)
{
return(terrainDef);
}
for (int i = 0; i < biome1.terrainPatchMakers.Count; i++)
{
terrainDef2 = biome1.terrainPatchMakers[i].TerrainAt(c, map, fertility);
if (terrainDef2 != null)
{
return(terrainDef2);
}
}
/* if (elevation > 0.55f && elevation < 0.61f)
* {
* return TerrainDefOf.Gravel;
* }*/
if (elevation >= 0.61f)
{
return(theBaseRocks);
// return GenStep_RocksFromGrid.RockDefAt(c).naturalTerrain;
}
terrainDef2 = TerrainThreshold.TerrainAtValue(biome1.terrainsByFertility, fertility);
if (terrainDef2 != null)
{
return(terrainDef2);
}
if (!GenStep_TerrainFarcasterDeltaServitus.debug_WarnedMissingTerrain)
{
Log.Error(string.Concat(new object[]
{
"No terrain found in biome ",
biome1.defName,
" for elevation=",
elevation,
", fertility=",
fertility
}));
GenStep_TerrainFarcasterDeltaServitus.debug_WarnedMissingTerrain = true;
}
return(TerrainDefOf.Sand);
}
