public override void Generate(Map map, GenStepParams parms) { BeachMaker.Init(map); RiverMaker riverMaker = GenerateRiver(map); List <IntVec3> list = new List <IntVec3>(); MapGenFloatGrid elevation = MapGenerator.Elevation; MapGenFloatGrid fertility = MapGenerator.Fertility; MapGenFloatGrid caves = MapGenerator.Caves; TerrainGrid terrainGrid = map.terrainGrid; foreach (IntVec3 allCell in map.AllCells) { Building edifice = allCell.GetEdifice(map); TerrainDef terrainDef = null; terrainDef = (((edifice == null || edifice.def.Fillage != FillCategory.Full) && !(caves[allCell] > 0f)) ? TerrainFrom(allCell, map, elevation[allCell], fertility[allCell], riverMaker, preferSolid: false) : TerrainFrom(allCell, map, elevation[allCell], fertility[allCell], riverMaker, preferSolid: true)); if (terrainDef.IsRiver && edifice != null) { list.Add(edifice.Position); edifice.Destroy(); } terrainGrid.SetTerrain(allCell, terrainDef); } riverMaker?.ValidatePassage(map); RemoveIslands(map); RoofCollapseCellsFinder.RemoveBulkCollapsingRoofs(list, map); BeachMaker.Cleanup(); foreach (TerrainPatchMaker terrainPatchMaker in map.Biome.terrainPatchMakers) { terrainPatchMaker.Cleanup(); } }
public override void Generate(Map map, GenStepParams parms) { if (map.TileInfo.WaterCovered) { return; } ModExt_Biome_FeatureControl extFtControl = map.Biome.GetModExtension <ModExt_Biome_FeatureControl>(); if (extFtControl == null || extFtControl.overwriteRockChunks != RockChunksOverwriteType.AddToCaves) { return; } freqFactorNoise = new Perlin(0.014999999664723873, 2.0, 0.5, 6, Rand.Int, QualityMode.Medium); freqFactorNoise = new ScaleBias(1.0, 1.0, freqFactorNoise); NoiseDebugUI.StoreNoiseRender(freqFactorNoise, "cave_rock_chunks_freq_factor"); MapGenFloatGrid elevation = MapGenerator.Elevation; foreach (IntVec3 cell in map.AllCells) { float probVal = PlaceProbabilityPerCell * freqFactorNoise.GetValue(cell); if (elevation[cell] >= ThreshLooseRock && Rand.Value < probVal) { GrowLowRockFormationFrom(cell, map); } } freqFactorNoise = null; }
public override void Generate(Map map, GenStepParams parms) { ModuleBase chambers = new Perlin(0.010, 1.7, 0.5, 6, Rand.Range(0, int.MaxValue), QualityMode.High); ModuleBase columns = new Perlin(0.150, 0.5, 0.5, 6, Rand.Range(0, int.MaxValue), QualityMode.High); columns = new ScaleBias(0.5, 0.5, columns); // push columns to the centers of chambers ModuleBase columnsNoise = new Invert(chambers); columnsNoise = new ScaleBias(3f, -2f, columnsNoise); columnsNoise = new Min(new Const(0.0), columnsNoise); columns = new Add(columns, columnsNoise); // broken tunnel network ModuleBase tunnels = new Perlin(0.01, 1.7, 0.5, 6, Rand.Range(0, int.MaxValue), QualityMode.High); ModuleBase tunnelsNoise = new Perlin(0.005, 0.0, 0.5, 6, Rand.Range(0, int.MaxValue), QualityMode.Medium); tunnels = new Abs(tunnels); tunnels = new Add(new Const(0.5), tunnels); tunnels = new Add(tunnels, new Clamp(0, 0.5, tunnelsNoise)); chambers = new Min(new Add(chambers, new Const(0.75)), tunnels); MapGenFloatGrid elevation = MapGenerator.Elevation; foreach (IntVec3 cell in map.AllCells) { elevation[cell] = Math.Max(columns.GetValue(cell), chambers.GetValue(cell)); } }
public override void Generate(Map map, GenStepParams parms) { if (Find.World.HasCaves(map.Tile)) { directionNoise = new Perlin(0.0020500000100582838, 2.0, 0.5, 4, Rand.Int, QualityMode.Medium); MapGenFloatGrid elevation = MapGenerator.Elevation; BoolGrid visited = new BoolGrid(map); List <IntVec3> group = new List <IntVec3>(); foreach (IntVec3 allCell in map.AllCells) { if (!visited[allCell] && IsRock(allCell, elevation, map)) { group.Clear(); map.floodFiller.FloodFill(allCell, (IntVec3 x) => IsRock(x, elevation, map), delegate(IntVec3 x) { visited[x] = true; group.Add(x); }); Trim(group, map); RemoveSmallDisconnectedSubGroups(group, map); if (group.Count >= 300) { DoOpenTunnels(group, map); DoClosedTunnels(group, map); } } } } }
public override void Generate(Map map, GenStepParams parms) { if (!Find.World.HasCaves(map.Tile)) { return; } Perlin perlin = new Perlin(0.079999998211860657, 2.0, 0.5, 6, Rand.Int, QualityMode.Medium); Perlin perlin2 = new Perlin(0.15999999642372131, 2.0, 0.5, 6, Rand.Int, QualityMode.Medium); MapGenFloatGrid caves = MapGenerator.Caves; foreach (IntVec3 current in map.AllCells) { if (caves[current] > 0f) { TerrainDef terrain = current.GetTerrain(map); if (!terrain.IsRiver) { float num = (float)perlin.GetValue((double)current.x, 0.0, (double)current.z); float num2 = (float)perlin2.GetValue((double)current.x, 0.0, (double)current.z); if (num > 0.93f) { map.terrainGrid.SetTerrain(current, TerrainDefOf.WaterShallow); } else if (num2 > 0.55f) { map.terrainGrid.SetTerrain(current, TerrainDefOf.Gravel); } } } } }
public override void Generate(Map map, GenStepParams parms) { if (Find.World.HasCaves(map.Tile)) { Perlin perlin = new Perlin(0.079999998211860657, 2.0, 0.5, 6, Rand.Int, QualityMode.Medium); Perlin perlin2 = new Perlin(0.15999999642372131, 2.0, 0.5, 6, Rand.Int, QualityMode.Medium); MapGenFloatGrid caves = MapGenerator.Caves; foreach (IntVec3 allCell in map.AllCells) { if (!(caves[allCell] <= 0f) && !allCell.GetTerrain(map).IsRiver) { float num = (float)perlin.GetValue(allCell.x, 0.0, allCell.z); float num2 = (float)perlin2.GetValue(allCell.x, 0.0, allCell.z); if (num > 0.93f) { map.terrainGrid.SetTerrain(allCell, TerrainDefOf.WaterShallow); } else if (num2 > 0.55f) { map.terrainGrid.SetTerrain(allCell, TerrainDefOf.Gravel); } } } } }
public override void Generate(Map map) { if (Find.World.HasCaves(map.Tile)) { Perlin perlin = new Perlin(0.079999998211860657, 2.0, 0.5, 6, Rand.Int, QualityMode.Medium); Perlin perlin2 = new Perlin(0.15999999642372131, 2.0, 0.5, 6, Rand.Int, QualityMode.Medium); MapGenFloatGrid caves = MapGenerator.Caves; foreach (IntVec3 allCell in map.AllCells) { IntVec3 current = allCell; if (!(caves[current] <= 0.0)) { TerrainDef terrain = current.GetTerrain(map); if (terrain != TerrainDefOf.WaterMovingShallow && terrain != TerrainDefOf.WaterMovingDeep) { float num = (float)perlin.GetValue((double)current.x, 0.0, (double)current.z); float num2 = (float)perlin2.GetValue((double)current.x, 0.0, (double)current.z); if (num > 0.93000000715255737) { map.terrainGrid.SetTerrain(current, TerrainDefOf.WaterShallow); } else if (num2 > 0.550000011920929) { map.terrainGrid.SetTerrain(current, TerrainDefOf.Gravel); } } } } } }
public override void Generate(Map map, GenStepParams parms) { var mapParent = map.Parent as MapParent_ZLevel; if (mapParent.hasCaves) { directionNoise = new Perlin(DirectionNoiseFrequency, 2.0, 0.5, 4, Rand.Int, QualityMode.Medium); MapGenFloatGrid elevation = MapGenerator.Elevation; BoolGrid visited = new BoolGrid(map); List <IntVec3> group = new List <IntVec3>(); foreach (IntVec3 allCell in map.AllCells) { if (!visited[allCell] && IsRock(allCell, elevation, map)) { group.Clear(); map.floodFiller.FloodFill(allCell, (IntVec3 x) => IsRock(x, elevation, map), delegate(IntVec3 x) { visited[x] = true; group.Add(x); }); Trim(group, map); RemoveSmallDisconnectedSubGroups(group, map); if (group.Count >= MinRocksToGenerateAnyTunnel) { DoOpenTunnels(group, map); DoClosedTunnels(group, map); } } } } }
public MapGridSet(MapGenFloatGrid elevationGrid, MapGenFloatGrid fertilityGrid, MapGenFloatGrid cavesGrid, Map map) { ElevationGrid = elevationGrid; FertilityGrid = fertilityGrid; CavesGrid = cavesGrid; Map = map; }
public override void Generate(Map map, GenStepParams parms) { if (map.Biome != Util_CaveBiome.CaveBiomeDef) { // Nothing to do in other biomes. return; } // Generate basic map elevation. NoiseRenderer.renderSize = new IntVec2(map.Size.x, map.Size.z); ModuleBase perlinMap = new Perlin(ElevationFreq, 1.0, 0.5, 6, Rand.Range(0, 2147483647), QualityMode.High); perlinMap = new ScaleBias(0.5, 0.5, perlinMap); NoiseDebugUI.StoreNoiseRender(perlinMap, "Cave: elev base"); perlinMap = new Multiply(perlinMap, new Const(ElevationFactorCave)); NoiseDebugUI.StoreNoiseRender(perlinMap, "Cave: elev cave-factored"); // Override base elevation grid so the GenStep_Terrain.Generate function uses this one. MapGenFloatGrid mapGenFloatGrid = MapGenerator.FloatGridNamed("Elevation"); foreach (IntVec3 current in map.AllCells) { mapGenFloatGrid[current] = perlinMap.GetValue(current); } }
public override void Generate(Map map) { //if (!Find.World.HasCaves(map.Tile)) //{ // return; //} this.directionNoise = new Perlin(0.0020500000100582838, 2.0, 0.5, 4, Rand.Int, QualityMode.Medium); MapGenFloatGrid elevation = MapGenerator.Elevation; BoolGrid visited = new BoolGrid(map); List <IntVec3> group = new List <IntVec3>(); foreach (IntVec3 current in map.AllCells) { if (!visited[current] && this.IsRock(current, elevation, map)) { group.Clear(); map.floodFiller.FloodFill(current, (IntVec3 x) => this.IsRock(x, elevation, map), delegate(IntVec3 x) { visited[x] = true; group.Add(x); }, 2147483647, false, null); this.Trim(group, map); //this.RemoveSmallDisconnectedSubGroups(group, map); if (group.Count >= 50) { this.DoOpenTunnels(group, map); this.DoClosedTunnels(group, map); } } } }
public override void Generate(Map map, GenStepParams parms) { if (!Find.World.HasCaves(map.Tile)) { return; } this.directionNoise = new Perlin(0.0020500000100582838, 2.0, 0.5, 4, Rand.Int, QualityMode.Medium); MapGenFloatGrid elevation = MapGenerator.Elevation; BoolGrid visited = new BoolGrid(map); List <IntVec3> group = new List <IntVec3>(); foreach (IntVec3 intVec in map.AllCells) { if (!visited[intVec] && this.IsRock(intVec, elevation, map)) { group.Clear(); map.floodFiller.FloodFill(intVec, (IntVec3 x) => this.IsRock(x, elevation, map), delegate(IntVec3 x) { visited[x] = true; group.Add(x); }, int.MaxValue, false, null); this.Trim(group, map); this.RemoveSmallDisconnectedSubGroups(group, map); if (group.Count >= 300) { this.DoOpenTunnels(group, map); this.DoClosedTunnels(group, map); } } } }
private void spawnPlant(IntVec3 place, MapGenFloatGrid caves, float desiredTotalDensity, ThingDef plantDef) { if (place.GetEdifice(map) == null && place.GetCover(map) == null && caves[place] <= 0f) { float num2 = map.fertilityGrid.FertilityAt(place); float num3 = num2 * desiredTotalDensity; if (Rand.Value < num3) { for (int j = 0; j < plantDef.plant.wildClusterSizeRange.RandomInRange; j++) { IntVec3 c2; if (j == 0) { c2 = place; } else if (!GenPlantReproduction.TryFindReproductionDestination(place, plantDef, SeedTargFindMode.MapGenCluster, map, out c2)) { break; } Plant plant = (Plant)ThingMaker.MakeThing(plantDef, null); plant.Growth = Rand.Range(0.07f, 1f); if (plant.def.plant.LimitedLifespan) { plant.Age = Rand.Range(0, Mathf.Max(plant.def.plant.LifespanTicks - 50, 0)); } GenSpawn.Spawn(plant, c2, map); } } } }
private IntVec3 FindRandomEdgeCellForTunnel(List <IntVec3> group, Map map) { MapGenFloatGrid caves = MapGenerator.Caves; IntVec3[] cardinalDirections = GenAdj.CardinalDirections; tmpCells.Clear(); tmpGroupSet.Clear(); tmpGroupSet.AddRange(group); for (int i = 0; i < group.Count; i++) { if (group[i].DistanceToEdge(map) < 3 || caves[group[i]] > 0f) { continue; } for (int j = 0; j < 4; j++) { IntVec3 item = group[i] + cardinalDirections[j]; if (!tmpGroupSet.Contains(item)) { tmpCells.Add(group[i]); break; } } } if (!tmpCells.Any()) { Log.Warning("Could not find any valid edge cell."); return(group.RandomElement()); } return(tmpCells.RandomElement()); }
public static void WorkOnMapGenerator(Map map) { MapGenFloatGrid elevation = MapGenerator.Elevation; MapGenFloatGrid fertility = MapGenerator.Fertility; foreach (IntVec3 cell in map.AllCells) { // Set elevation if (extIslands.calcElevationType == GenStepCalculationType.Set) { elevation[cell] = GetValueAt(cell, noiseElevation) * extIslands.elevationPostScale + extIslands.elevationPostOffset; } else if (extIslands.calcElevationType == GenStepCalculationType.Add) { elevation[cell] += GetValueAt(cell, noiseElevation) * extIslands.elevationPostScale + extIslands.elevationPostOffset; } // Set fertility if (extIslands.calcFertilityType == GenStepCalculationType.Set) { fertility[cell] = GetValueAt(cell, noiseFertility) * extIslands.fertilityPostScale + extIslands.fertilityPostOffset; } else if (extIslands.calcFertilityType == GenStepCalculationType.Add) { fertility[cell] += GetValueAt(cell, noiseFertility) * extIslands.fertilityPostScale + extIslands.fertilityPostOffset; } } }
public override void Generate(Map map, GenStepParams parms) { ModuleBase tunnels = new Perlin(0.024, 2.2, 0.5, 6, Rand.Range(0, int.MaxValue), QualityMode.High); tunnels = new ScaleBias(0.5, 0.5, tunnels); ModuleBase noise = new Perlin(0.02, 1.5, 0.5, 6, Rand.Range(0, int.MaxValue), QualityMode.Medium); MapGenFloatGrid elevation = MapGenerator.Elevation; foreach (IntVec3 cell in map.AllCells) { elevation[cell] = 0.53f + 2f * Math.Abs(tunnels.GetValue(cell) - 0.5f) + 0.10f * noise.GetValue(cell); } IntVec3 roomLoc = map.Center; roomLoc.x = (int)(Rand.Range(0.3f, 1.7f) * roomLoc.x); roomLoc.z = (int)(Rand.Range(0.3f, 1.7f) * roomLoc.z); ModuleBase roomNoise = new Perlin(Rand.Range(0.015f, 0.028f), 2.0, 0.5, 6, Rand.Range(0, 2147483647), QualityMode.High); float sizeAdj = Rand.Range(8f, 10f); foreach (IntVec3 cell in map.AllCells) { float distance = (float)Math.Sqrt(Math.Pow(cell.x - roomLoc.x, 2) + Math.Pow(cell.z - roomLoc.z, 2)); float addition = 25 * (1f - (sizeAdj * distance / map.Size.x)) + 15f * roomNoise.GetValue(cell); elevation[cell] -= Math.Max(0, addition); } }
private void SmoothGenerated(Map map) { MapGenFloatGrid caves = MapGenerator.Caves; List <IntVec3> caveCells = new List <IntVec3>(); foreach (IntVec3 cell in map.AllCells) { if (caves[cell] > 0f) { caveCells.Add(cell); } } GenMorphology.Close(caveCells, 3, map); foreach (IntVec3 cell in map.AllCells) { if (cell.CloseToEdge(map, 3)) // Skip changing caves near the edge { continue; } if (caveCells.Contains(cell)) // Cave spot on cell (cave should be there) { if (caves[cell] <= 0f) // No existing cave { caves[cell] = 1f; // Add new cave spot } } else // No cave spot on cell (cave should not be there) { if (caves[cell] > 0f) // Old existing cave { caves[cell] = 0f; // Remove cave spot } } } }
private IntVec3 FindRandomEdgeCellForTunnel(List <IntVec3> group, Map map) { MapGenFloatGrid caves = MapGenerator.Caves; IntVec3[] cardinalDirections = GenAdj.CardinalDirections; GenStep_ElevateEvelationForUnderground.tmpCells.Clear(); GenStep_ElevateEvelationForUnderground.tmpGroupSet.Clear(); GenStep_ElevateEvelationForUnderground.tmpGroupSet.AddRange(group); for (int i = 0; i < group.Count; i++) { if (group[i].DistanceToEdge(map) >= 3 && caves[group[i]] <= 0f) { for (int j = 0; j < 4; j++) { IntVec3 item = group[i] + cardinalDirections[j]; if (!GenStep_ElevateEvelationForUnderground.tmpGroupSet.Contains(item)) { GenStep_ElevateEvelationForUnderground.tmpCells.Add(group[i]); break; } } } } if (!GenStep_ElevateEvelationForUnderground.tmpCells.Any <IntVec3>()) { Log.Warning("Could not find any valid edge cell.", false); return(group.RandomElement <IntVec3>()); } return(GenStep_ElevateEvelationForUnderground.tmpCells.RandomElement <IntVec3>()); }
/// <summary> /// This is a heavily simplified version of the vanilla GenStep_Terrain /// Most of the original isn't needed, and there are several changes to the parts that are left /// </summary> /// <param name="map"></param> /// <param name="parms"></param> public override void Generate(Map map, GenStepParams parms) { //check if it's our biome. If not, skip if (map.Biome.defName != "RockMoonBiome") { return; } mapRadiusSize = map.Size.x / 2; List <IntVec3> list = new List <IntVec3>(); MapGenFloatGrid elevation = MapGenerator.Elevation; MapGenFloatGrid fertility = MapGenerator.Fertility; MapGenFloatGrid caves = MapGenerator.Caves; TerrainGrid terrainGrid = map.terrainGrid; foreach (IntVec3 current in map.AllCells) { Building edifice = current.GetEdifice(map); TerrainDef terrainDef; terrainDef = this.TerrainFrom(current, fertility[current]); terrainGrid.SetTerrain(current, terrainDef); } RoofCollapseCellsFinder.RemoveBulkCollapsingRoofs(list, map); BeachMaker.Cleanup(); foreach (TerrainPatchMaker current2 in map.Biome.terrainPatchMakers) { current2.Cleanup(); } }
public override void Generate(Map map, GenStepParams parms) { if (!map.Biome.HasModExtension <BiomesMap>()) { return; } if (!map.Biome.GetModExtension <BiomesMap>().isIsland) { return; } this.freqFactorNoise = new Perlin(0.014999999664723873, 2.0, 0.5, 6, Rand.Range(0, 999999), QualityMode.Medium); this.freqFactorNoise = new ScaleBias(1.0, 1.0, this.freqFactorNoise); NoiseDebugUI.StoreNoiseRender(this.freqFactorNoise, "rock_chunks_freq_factor"); MapGenFloatGrid elevation = MapGenerator.Elevation; foreach (IntVec3 current in map.AllCells) { float num = 0.006f * this.freqFactorNoise.GetValue(current); if (elevation[current] < 0.55f && Rand.Value < num) { this.GrowLowRockFormationFrom(current, map); } } this.freqFactorNoise = null; }
private float GetDistToCave(IntVec3 cell, List <IntVec3> group, Map map, float maxDist, bool treatOpenSpaceAsCave) { MapGenFloatGrid caves = MapGenerator.Caves; GenStep_Caves.tmpGroupSet.Clear(); GenStep_Caves.tmpGroupSet.AddRange(group); int num = GenRadial.NumCellsInRadius(maxDist); IntVec3[] radialPattern = GenRadial.RadialPattern; for (int i = 0; i < num; i++) { IntVec3 intVec = cell + radialPattern[i]; if (treatOpenSpaceAsCave && !GenStep_Caves.tmpGroupSet.Contains(intVec)) { goto IL_007b; } if (intVec.InBounds(map) && caves[intVec] > 0.0) { goto IL_007b; } continue; IL_007b: return(cell.DistanceTo(intVec)); } return(maxDist); }
public override void Generate(Map map, GenStepParams parms) { if (!Find.Storyteller.difficulty.allowCaveHives) { return; } if (BetterInfestationsMod.settings == null) { return; } if (!BetterInfestationsMod.settings.allowHiveMapGen) { return; } MapGenFloatGrid caves = MapGenerator.Caves; MapGenFloatGrid elevation = MapGenerator.Elevation; float num = 0.7f; int num2 = 0; rockCells.Clear(); foreach (IntVec3 current in map.AllCells) { if (elevation[current] > num) { rockCells.Add(current); } if (caves[current] > 0f) { num2++; } } List <IntVec3> list = (from c in map.AllCells where map.thingGrid.ThingsAt(c).Any((Thing thing) => thing.Faction != null) select c).ToList(); GenMorphology.Dilate(list, 50, map, null); HashSet <IntVec3> hashSet = new HashSet <IntVec3>(list); int num3 = GenMath.RoundRandom(num2 / 1000f); if (num3 > BetterInfestationsMod.settings.maxMapGenHives) { num3 = BetterInfestationsMod.settings.maxMapGenHives; } GenMorphology.Erode(rockCells, 10, map, null); possibleSpawnCells.Clear(); for (int i = 0; i < rockCells.Count; i++) { if (caves[rockCells[i]] > 0f && !hashSet.Contains(rockCells[i])) { possibleSpawnCells.Add(rockCells[i]); } } spawnedQueens.Clear(); for (int j = 0; j < num3; j++) { TrySpawnHive(map); } spawnedQueens.Clear(); }
public override void Generate(Map map) { if (map.Biome != Util_CaveBiome.CaveBiomeDef) { // Nothing to do in other biomes. return; } // Compute number of cave wells (5 for standard map 250x250, around 13 for bigest map 400x400). caveWellsNumber = Mathf.CeilToInt((map.Size.x * map.Size.z) / 12500); MapGenFloatGrid elevationGrid = MapGenerator.Elevation; foreach (IntVec3 cell in map.AllCells) { Thing thing = map.edificeGrid.InnerArray[map.cellIndices.CellToIndex(cell)]; if (thing != null && thing.def.holdsRoof) { map.roofGrid.SetRoof(cell, RoofDefOf.RoofRockThick); } else { // Spawn cave roof holder. GenSpawn.Spawn(Util_CaveBiome.CaveRoofDef, cell, map); } } // Update regions and rooms to be able to use the CanReachMapEdge function to find good cave well spots. map.regionAndRoomUpdater.Enabled = true; map.regionAndRoomUpdater.RebuildAllRegionsAndRooms(); // Get cave wells position. caveWellsPosition = GetCaveWellsPosition(map); // Spawn cave wells. // First cave well is always dry (to avoid starting thing scattering errors). SpawnDryCaveWellWithAnimalCorpsesAt(map, caveWellsPosition[0]); for (int caveWellIndex = 1; caveWellIndex < caveWellsNumber; caveWellIndex++) { if (Rand.Value < 0.5f) { // Spawn aqueous cave well. SpawnAqueousCaveWellAt(map, caveWellsPosition[caveWellIndex]); } else if (Rand.Value < 0.9f) { // Spawn dry cave well + fallen animal corpses. SpawnDryCaveWellWithAnimalCorpsesAt(map, caveWellsPosition[caveWellIndex]); } else { // Spawn dry cave well + sacrificial stone. SpawnDryCaveWellWithRitualStoneAt(map, caveWellsPosition[caveWellIndex]); } } // TODO: should correct null region error? May be due to artificial buildings. River should avoid this. // Update regions and rooms now that cave wells are spawned. map.regionAndRoomUpdater.RebuildAllRegionsAndRooms(); }
private bool IsRock(IntVec3 c, MapGenFloatGrid elevation, Map map) { if (c.InBounds(map)) { return(elevation[c] > 0.7f); } return(false); }
public override void Generate(Map map, GenStepParams parms) { if (!(map.Biome.defName == "BiomesPreview_Atoll")) { return; } MapGenFloatGrid fertility = MapGenerator.Fertility; // make ellipse centered on the map's center. Smaller maps get smaller ellipses IntRange NoiseRange = new IntRange(-50, 50); NoiseRange.min = (int)(0 - 0.15 * map.Size.x); NoiseRange.max = (int)(0.15 * map.Size.x); IntVec3 mapCenter = map.Center; int x = NoiseRange.RandomInRange; int z = NoiseRange.RandomInRange; IntVec3 focus1 = mapCenter; focus1.x += x; focus1.z += z; IntVec3 focus2 = mapCenter; focus2.x -= x; focus2.z -= z; List <IntVec3> shape = MakeEllipse(focus1, focus2, map); // generate random circles and cut them out of the ellipse, so that the final shape is squigglier // some circles won't overlap with the main shape, so maps can end up either really squiggly or almost perfectly elliptical. Variety! List <IntVec3> originalShape = shape; IntRange cutoutSizes = new IntRange(Math.Min(totalRange.min / 8, 56), Math.Min(totalRange.max / 3, 56)); int numCutouts = 6; for (int i = 0; i < numCutouts; i++) { IntVec3 tempCenter = map.AllCells.RandomElement(); if (!originalShape.Contains(tempCenter) && shape.Count >= 0.75 * originalShape.Count) { shape = shape.Except(GenRadial.RadialCellsAround(tempCenter, cutoutSizes.RandomInRange, true)).ToList(); } } Makelandmass(shape, ref fertility, map); SetNewTerrains(map); GenStep_OceanRockChunks genStep = new GenStep_OceanRockChunks(); genStep.Generate(map, parms); GenStep_OceanDeepResources deepLumps = new GenStep_OceanDeepResources(); deepLumps.Generate(map, parms); }
/// <summary> /// Makes the landmass shape on the map's fertility grid. /// Generates randomly-sized circles on each tile in the main shape and increments fertility in each circle. /// The circles "pile" up, resulting in a bumpy, irregular landmass with the same overall shape as the initial landCells list /// </summary> private void Makelandmass(List <IntVec3> landCells, ref MapGenFloatGrid fertility, Map map) { // smaller shapes get higher increments. For atolls, this lets smaller "hills" get tall enough to actually spawn water at the peak float fertIncrement = 0.06f; if (totalDist < 90) { fertIncrement = 0.09f; } if (totalDist < 70) { fertIncrement = 0.13f; } if (totalDist < 55) { fertIncrement = 0.2f; } if (totalDist < 30) { fertIncrement = 0.3f; } foreach (IntVec3 a in landCells) { if (Rand.Bool) { IntVec3 ne = a; List <IntVec3> island = new List <IntVec3>(); // Small chance of bigger circles. Helps the overall shape to look more natural. // For atolls, this helps to flatten/ spread out the sand and shallow water around the island. if (Rand.Chance(0.3f)) { if (Rand.Chance(0.2f)) { island = GenRadial.RadialCellsAround(ne, Math.Min(56, 3.5f * SizeRange.RandomInRange), true).ToList(); } else { island = GenRadial.RadialCellsAround(ne, Math.Min(56, 2.0f * SizeRange.RandomInRange), true).ToList(); } } else { island = GenRadial.RadialCellsAround(ne, Math.Min(56, SizeRange.RandomInRange), true).ToList(); } foreach (IntVec3 groundTile in island) { if (groundTile.InBounds(map)) { fertility[groundTile] += fertIncrement; } } } } }
public override void Generate(Map map, GenStepParams parms) { MapDesignerSettings settings = MapDesignerMod.mod.settings; lakeSize = settings.lakeSize * map.Size.x / 2; lakeRoundness = settings.lakeRoundness; lakeBeachSize = settings.lakeBeachSize; if (map.Biome.defName.Contains("BiomesIsland")) { lakeSize *= 0.5f; } MapGenFloatGrid lakeGrid = MapGenerator.FloatGridNamed("ZMD_Lake"); IntVec3 mapCenter = map.Center; ModuleBase moduleBase = new Perlin(0.020999999716877937, 2.0, 0.5, 6, Rand.Range(0, 2147483647), QualityMode.High); foreach (IntVec3 current in map.AllCells) { float distance = HelperMethods.DistanceBetweenPoints(current, mapCenter); lakeGrid[current] = 0f + lakeRoundness * moduleBase.GetValue(current) + 0.1f * (lakeSize - distance); } float deepBelow = lakeGrid[mapCenter] * (1 - settings.lakeDepth); MapGenFloatGrid elevation = MapGenerator.Elevation; MapGenFloatGrid fertility = MapGenerator.Fertility; float deepWater = -2005; float shallowWater = -1025; if (settings.flagLakeSalty) { deepWater = -2015; shallowWater = -1035; } float beachValue = Feature_TerrainFrom.ValueFromTerrain(settings.lakeShore); foreach (IntVec3 current in map.AllCells) { if (elevation[current] < 0.65f) // leaves mountains & most surrounding gravel untouched { if (lakeGrid[current] > deepBelow) { fertility[current] = deepWater; } else { if (lakeGrid[current] > 0f) { fertility[current] = shallowWater; } else if (lakeGrid[current] > 0f - 0.1f * lakeBeachSize) { fertility[current] = beachValue; } } } } }
private void GrowLowRockFormationFrom(IntVec3 root, Map map) { ThingDef filth_RubbleRock = ThingDefOf.Filth_RubbleRock; ThingDef mineableThing = Find.World.NaturalRockTypesIn(map.Tile).RandomElement <ThingDef>().building.mineableThing; Rot4 random = Rot4.Random; MapGenFloatGrid elevation = MapGenerator.Elevation; IntVec3 intVec = root; while (true) { Rot4 random2 = Rot4.Random; if (!(random2 == random)) { intVec += random2.FacingCell; if (!intVec.InBounds(map) || intVec.GetEdifice(map) != null || intVec.GetFirstItem(map) != null) { break; } if (elevation[intVec] > 0.55f) { return; } if (!map.terrainGrid.TerrainAt(intVec).affordances.Contains(TerrainAffordanceDefOf.Heavy)) { return; } GenSpawn.Spawn(mineableThing, intVec, map, WipeMode.Vanish); IntVec3[] adjacentCellsAndInside = GenAdj.AdjacentCellsAndInside; for (int i = 0; i < adjacentCellsAndInside.Length; i++) { IntVec3 b = adjacentCellsAndInside[i]; if (Rand.Value < 0.5f) { IntVec3 c = intVec + b; if (c.InBounds(map)) { bool flag = false; List <Thing> thingList = c.GetThingList(map); for (int j = 0; j < thingList.Count; j++) { Thing thing = thingList[j]; if (thing.def.category != ThingCategory.Plant && thing.def.category != ThingCategory.Item && thing.def.category != ThingCategory.Pawn) { flag = true; break; } } if (!flag) { FilthMaker.MakeFilth(c, map, filth_RubbleRock, 1); } } } } } } }
public override void Generate(Map map) { map.regionAndRoomUpdater.Enabled = false; List <ThingDef> list = map.Biome.AllWildPlants.ToList(); for (int i = 0; i < list.Count; i++) { GenStep_Plants.numExtant.Add(list[i], 0); } GenStep_Plants.desiredProportions = GenPlant.CalculateDesiredPlantProportions(map.Biome); MapGenFloatGrid caves = MapGenerator.Caves; float num = map.Biome.plantDensity * map.gameConditionManager.AggregatePlantDensityFactor(); foreach (IntVec3 item in map.AllCells.InRandomOrder(null)) { if (item.GetEdifice(map) == null && item.GetCover(map) == null && !(caves[item] > 0.0)) { float num2 = map.fertilityGrid.FertilityAt(item); float num3 = num2 * num; if (!(Rand.Value >= num3)) { IEnumerable <ThingDef> source = from def in list where def.CanEverPlantAt(item, map) select def; if (source.Any()) { ThingDef thingDef = source.RandomElementByWeight((ThingDef x) => GenStep_Plants.PlantChoiceWeight(x, map)); int randomInRange = thingDef.plant.wildClusterSizeRange.RandomInRange; for (int j = 0; j < randomInRange; j++) { IntVec3 loc = default(IntVec3); if (j == 0) { loc = item; } else if (!GenPlantReproduction.TryFindReproductionDestination(item, thingDef, SeedTargFindMode.MapGenCluster, map, out loc)) { break; } Plant plant = (Plant)ThingMaker.MakeThing(thingDef, null); plant.Growth = Rand.Range(0.07f, 1f); if (plant.def.plant.LimitedLifespan) { plant.Age = Rand.Range(0, Mathf.Max(plant.def.plant.LifespanTicks - 50, 0)); } GenSpawn.Spawn(plant, loc, map); GenStep_Plants.RecordAdded(thingDef); } } } } } GenStep_Plants.numExtant.Clear(); GenStep_Plants.desiredProportions.Clear(); GenStep_Plants.totalExtant = 0; map.regionAndRoomUpdater.Enabled = true; }
public static bool GenerateCavePlant_PreFix(Map map) { map.regionAndRoomUpdater.Enabled = false; MapGenFloatGrid caves = MapGenerator.Caves; List <ThingDef> source = (from x in DefDatabase <ThingDef> .AllDefsListForReading where x.category == ThingCategory.Plant && x.plant.cavePlant select x).ToList <ThingDef>(); foreach (IntVec3 c in map.AllCells.InRandomOrder(null)) { if (c.GetEdifice(map) == null && c.GetCover(map) == null && (caves[c] > 0f || map.Biome.defName == "RWBCavern") && c.Roofed(map) && map.fertilityGrid.FertilityAt(c) > 0f) { IEnumerable <ThingDef> source2 = from def in source where def.CanEverPlantAt(c, map) select def; if (source2.Any <ThingDef>()) { ThingDef thingDef = source2.RandomElement <ThingDef>(); int randomInRange = thingDef.plant.wildClusterSizeRange.RandomInRange; float chance; if (Math.Abs(map.Biome.CommonalityOfPlant(thingDef)) > Double.Epsilon) { chance = map.Biome.CommonalityOfPlant(thingDef); } else { chance = 0.18f; } if (Rand.Chance(chance)) { for (int i = 0; i < randomInRange; i++) { IntVec3 c2; if (i == 0) { c2 = c; } else if (!GenPlantReproduction.TryFindReproductionDestination(c, thingDef, SeedTargFindMode.MapGenCluster, map, out c2)) { break; } Plant plant = (Plant)ThingMaker.MakeThing(thingDef, null); plant.Growth = Rand.Range(0.07f, 1f); if (plant.def.plant.LimitedLifespan) { plant.Age = Rand.Range(0, Mathf.Max(plant.def.plant.LifespanTicks - 50, 0)); } GenSpawn.Spawn(plant, c2, map); } } } } } map.regionAndRoomUpdater.Enabled = true; return(false); }