Example #1
0
        public static bool Prefix(World __instance, ref bool __result, int tile)
        {
            BiomeDef biome = __instance.grid[tile].biome;
            // Set via modext caves
            ModExt_Biome_GenStep_BetterCaves extCaves = biome.GetModExtension <ModExt_Biome_GenStep_BetterCaves>();

            if (extCaves != null)
            {
                __result = true;
                return(false);
            }
            // Set via modext feature control
            ModExt_Biome_FeatureControl extFtControl = biome.GetModExtension <ModExt_Biome_FeatureControl>();

            if (extFtControl != null)
            {
                if (extFtControl.overwriteCaves == GenFeatureTristate.Add)
                {
                    __result = true;
                    return(false);
                }
                if (extFtControl.overwriteCaves == GenFeatureTristate.Remove)
                {
                    __result = false;
                    return(false);
                }
            }
            return(true);
        }
Example #2
0
        public static bool Prefix(Map map)
        {
            if (!Find.World.HasCaves(map.Tile))
            {
                return(false);
            }
            ModExt_Biome_GenStep_BetterCaves extCaves = map.Biome.GetModExtension <ModExt_Biome_GenStep_BetterCaves>();

            if (extCaves == null || (extCaves.terrainPatchMakerCaveWater == null && extCaves.terrainPatchMakerCaveGravel == null))
            {
                return(true);
            }
            ModuleBase      noiseWater  = new Perlin(extCaves.terrainPatchMakerFrequencyCaveWater, 2.0, 0.5, 6, Rand.Int, QualityMode.Medium);
            ModuleBase      noiseGravel = new Perlin(extCaves.terrainPatchMakerFrequencyCaveGravel, 2.0, 0.5, 6, Rand.Int, QualityMode.Medium);
            MapGenFloatGrid caves       = MapGenerator.Caves;

            foreach (IntVec3 c in map.AllCells)
            {
                if (caves[c] > 0f)
                {
                    TerrainDef terrain = c.GetTerrain(map);
                    if (!terrain.IsRiver)
                    {
                        // Try set water terrain
                        float      valWater        = (float)noiseWater.GetValue(c);
                        TerrainDef currentTerrain  = map.terrainGrid.TerrainAt(c);
                        TerrainDef newTerrainWater = TerrainThresholdWEO.TerrainAtValue(extCaves.terrainPatchMakerCaveWater, valWater, currentTerrain);
                        if (newTerrainWater != null)
                        {
                            map.terrainGrid.SetTerrain(c, newTerrainWater);
                        }
                        else
                        {
                            // Try set gravel terrain if no water was set first
                            float      valGravel        = (float)noiseGravel.GetValue(c);
                            TerrainDef newTerrainGravel = TerrainThresholdWEO.TerrainAtValue(extCaves.terrainPatchMakerCaveGravel, valGravel, currentTerrain);
                            if (newTerrainGravel != null)
                            {
                                map.terrainGrid.SetTerrain(c, newTerrainGravel);
                            }
                        }
                    }
                }
            }
            return(false);
        }
        public override void Generate(Map map, GenStepParams parms)
        {
            if (!Find.World.HasCaves(map.Tile))
            {
                return;
            }
            ModExt_Biome_GenStep_BetterCaves extCaves = map.Biome.GetModExtension <ModExt_Biome_GenStep_BetterCaves>();

            if (extCaves == null)
            {
                return;
            }
            this.extCaves    = extCaves;
            directionNoise   = new Perlin(DirectionNoiseFrequency, 2.0, 0.5, 4, Rand.Int, QualityMode.Medium);
            tunnelWidthNoise = new Perlin(TunnelWidthNoiseFrequency, 2.0, 0.5, 4, Rand.Int, QualityMode.Medium);
            tunnelWidthNoise = new ScaleBias(0.4, 1.0, tunnelWidthNoise);
            MapGenFloatGrid elevation = MapGenerator.Elevation;
            BoolGrid        visited   = new BoolGrid(map);
            List <IntVec3>  rockCells = new List <IntVec3>();

            foreach (IntVec3 cell in map.AllCells)
            {
                if (!visited[cell] && this.IsRock(cell, elevation, map))
                {
                    rockCells.Clear();
                    map.floodFiller.FloodFill(cell, (IntVec3 x) => IsRock(x, elevation, map), delegate(IntVec3 x)
                    {
                        visited[x] = true;
                        rockCells.Add(x);
                    });
                    Trim(rockCells, map);
                    RemoveSmallDisconnectedSubGroups(rockCells, map);
                    if (rockCells.Count >= extCaves.minRocksToGenerateAnyTunnel)
                    {
                        StartWithTunnel(rockCells, map);
                    }
                }
            }
            // Smooth caves after generation
            SmoothGenerated(map);
        }