Last active
April 8, 2021 18:04
-
-
Save ubergarm/d43e59e3ee51a5e67aec8aaa86c5afab to your computer and use it in GitHub Desktop.
Configuration for Minecraft v1.12.2 mod `Topography` custom SkyIslandGeneratorV2() including Biomes O' Plenty and Thaumcraft biomes
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| // July 19. 2020 | |
| // https://gist.github.com/ubergarm/d43e59e3ee51a5e67aec8aaa86c5afab | |
| // Configuration for Minecraft v1.12.2 mod `Topography` custom SkyIslandGeneratorV2() including Biomes O' Plenty and Thaumcraft biomes | |
| // Based on Topography's default `Basic_Sky_Islands.txt` https://www.curseforge.com/minecraft/mc-mods/topography | |
| // Version Info: | |
| // - Minecraft v1.12.2 | |
| // - Mohist-1.12.2-7bb5453-server.jar | |
| // - forge-14.23.5.2854 | |
| // - Topography-1.12.2-1.14.2.jar | |
| // - BiomesOPlenty-1.12.2-7.0.1.2441-universal.jar | |
| // - Thaumcraft-1.12.2-6.1.BETA26.jar | |
| // - worleycaves-1.5.1.jar | |
| // Installation: | |
| // 1. Put this file into `<server>/config/topography/examples/` | |
| // 2. Add the following lines into `<server>/config/topography/Topography.txt` | |
| // skyMagicIslands = registerPreset("Sky Magic Islands", "images/Sky_Islands", "Sky Magic Islands using biomes o plenty.") | |
| // skyMagicIslands.registerDimension(0, "examples/Sky_Magic_Islands") | |
| // 3. Add `generator-settings={"Topography-Preset"\:"Sky Magic Islands"}` into `server.properties` | |
| // 4. Add `level-type=BIOMESOP` into `server.properties` | |
| //Sets the dimension to generate as the void biome. The sky islands will override this where they generate, so this will only be the biome between the islands. | |
| setSingleBiome("minecraft:void") | |
| //Add Vanilla Biome Types - Creates a new SkyIslandType. The argument is a biome id. | |
| forest = new SkyIslandType("minecraft:forest") | |
| forest.generateMineshafts(5) | |
| forest.generateStrongholds(20) | |
| forest.generateVillages(10) | |
| cold_taiga = new SkyIslandType("minecraft:taiga_cold") | |
| cold_taiga.generateMineshafts(5) | |
| cold_taiga.generateStrongholds(20) | |
| cold_taiga.generateVillages(10) | |
| desert = new SkyIslandType("minecraft:desert") | |
| desert.disableFluid() | |
| desert.generateMineshafts(5) | |
| desert.generateStrongholds(20) | |
| desert.generateVillages(10) | |
| mesa = new SkyIslandType("minecraft:mesa") | |
| mesa.generateMineshafts(5) | |
| mesa.generateStrongholds(20) | |
| mesa.generateVillages(10) | |
| jungle = new SkyIslandType("minecraft:jungle") | |
| jungle.generateMineshafts(5) | |
| jungle.generateStrongholds(20) | |
| jungle.generateVillages(10) | |
| plains = new SkyIslandType("minecraft:plains") | |
| plains.generateMineshafts(5) | |
| plains.generateStrongholds(20) | |
| plains.generateVillages(10) | |
| taiga = new SkyIslandType("minecraft:taiga") | |
| taiga.generateMineshafts(5) | |
| taiga.generateStrongholds(20) | |
| taiga.generateVillages(10) | |
| swamp = new SkyIslandType("minecraft:swampland") | |
| swamp.generateMineshafts(5) | |
| swamp.generateStrongholds(20) | |
| swamp.generateVillages(10) | |
| mushroom = new SkyIslandType("minecraft:mushroom_island") | |
| mushroom.generateMineshafts(5) | |
| mushroom.generateStrongholds(20) | |
| mushroom.generateVillages(10) | |
| ice_plains = new SkyIslandType("minecraft:ice_flats") | |
| ice_plains.generateMineshafts(5) | |
| ice_plains.generateStrongholds(20) | |
| ice_plains.generateVillages(10) | |
| savanna = new SkyIslandType("minecraft:savanna") | |
| savanna.generateMineshafts(5) | |
| savanna.generateStrongholds(20) | |
| savanna.generateVillages(10) | |
| roofed_forest = new SkyIslandType("minecraft:roofed_forest") | |
| roofed_forest.generateMineshafts(5) | |
| roofed_forest.generateStrongholds(20) | |
| roofed_forest.generateVillages(10) | |
| redwood_taiga = new SkyIslandType("minecraft:redwood_taiga") | |
| redwood_taiga.generateMineshafts(5) | |
| redwood_taiga.generateStrongholds(20) | |
| redwood_taiga.generateVillages(10) | |
| ocean = new SkyIslandType("minecraft:ocean") | |
| ocean.setFluidPercentage(0.6) | |
| lilypad = new ScatteredBlockGenerator(<minecraft:waterlily>, 164, 16) | |
| lilypad.addRequiredBlock(<minecraft:water>) | |
| ocean.addGenerator(lilypad) | |
| //===================================== | |
| // Add Biomes o plenty biome types | |
| bop_oasis = new SkyIslandType("biomesoplenty:oasis") | |
| bop_oasis.generateMineshafts(5) | |
| bop_oasis.generateStrongholds(20) | |
| bop_oasis.generateVillages(10) | |
| bop_woodland = new SkyIslandType("biomesoplenty:woodland") | |
| bop_woodland.generateMineshafts(5) | |
| bop_woodland.generateStrongholds(20) | |
| bop_woodland.generateVillages(10) | |
| bop_white_beach = new SkyIslandType("biomesoplenty:white_beach") | |
| bop_white_beach.generateMineshafts(5) | |
| bop_white_beach.generateStrongholds(20) | |
| bop_white_beach.generateVillages(10) | |
| bop_shrubland = new SkyIslandType("biomesoplenty:shrubland") | |
| bop_shrubland.generateMineshafts(5) | |
| bop_shrubland.generateStrongholds(20) | |
| bop_shrubland.generateVillages(10) | |
| bop_xeric_shrubland = new SkyIslandType("biomesoplenty:xeric_shrubland") | |
| bop_xeric_shrubland.generateMineshafts(5) | |
| bop_xeric_shrubland.generateStrongholds(20) | |
| bop_xeric_shrubland.generateVillages(10) | |
| bop_tropical_rainforest = new SkyIslandType("biomesoplenty:tropical_rainforest") | |
| bop_tropical_rainforest.generateMineshafts(5) | |
| bop_tropical_rainforest.generateStrongholds(20) | |
| bop_tropical_rainforest.generateVillages(10) | |
| bop_fen = new SkyIslandType("biomesoplenty:fen") | |
| bop_fen.generateMineshafts(5) | |
| bop_fen.generateStrongholds(20) | |
| bop_fen.generateVillages(10) | |
| bop_steppe = new SkyIslandType("biomesoplenty:steppe") | |
| bop_steppe.generateMineshafts(5) | |
| bop_steppe.generateStrongholds(20) | |
| bop_steppe.generateVillages(10) | |
| bop_alps_foothills = new SkyIslandType("biomesoplenty:alps_foothills") | |
| bop_alps_foothills.generateMineshafts(5) | |
| bop_alps_foothills.generateStrongholds(20) | |
| bop_alps_foothills.generateVillages(10) | |
| bop_redwood_forest_edge = new SkyIslandType("biomesoplenty:redwood_forest_edge") | |
| bop_redwood_forest_edge.generateMineshafts(5) | |
| bop_redwood_forest_edge.generateStrongholds(20) | |
| bop_redwood_forest_edge.generateVillages(10) | |
| bop_bayou = new SkyIslandType("biomesoplenty:bayou") | |
| bop_bayou.generateMineshafts(5) | |
| bop_bayou.generateStrongholds(20) | |
| bop_bayou.generateVillages(10) | |
| bop_mountain = new SkyIslandType("biomesoplenty:mountain") | |
| bop_mountain.generateMineshafts(5) | |
| bop_mountain.generateStrongholds(20) | |
| bop_mountain.generateVillages(10) | |
| bop_phantasmagoric_inferno = new SkyIslandType("biomesoplenty:phantasmagoric_inferno") | |
| bop_phantasmagoric_inferno.generateMineshafts(5) | |
| bop_phantasmagoric_inferno.generateStrongholds(20) | |
| bop_phantasmagoric_inferno.generateVillages(10) | |
| bop_overgrown_cliffs = new SkyIslandType("biomesoplenty:overgrown_cliffs") | |
| bop_overgrown_cliffs.generateMineshafts(5) | |
| bop_overgrown_cliffs.generateStrongholds(20) | |
| bop_overgrown_cliffs.generateVillages(10) | |
| bop_highland = new SkyIslandType("biomesoplenty:highland") | |
| bop_highland.generateMineshafts(5) | |
| bop_highland.generateStrongholds(20) | |
| bop_highland.generateVillages(10) | |
| bop_volcanic_island = new SkyIslandType("biomesoplenty:volcanic_island") | |
| bop_volcanic_island.generateMineshafts(5) | |
| bop_volcanic_island.generateStrongholds(20) | |
| bop_volcanic_island.generateVillages(10) | |
| bop_quagmire = new SkyIslandType("biomesoplenty:quagmire") | |
| bop_quagmire.generateMineshafts(5) | |
| bop_quagmire.generateStrongholds(20) | |
| bop_quagmire.generateVillages(10) | |
| bop_marsh = new SkyIslandType("biomesoplenty:marsh") | |
| bop_marsh.generateMineshafts(5) | |
| bop_marsh.generateStrongholds(20) | |
| bop_marsh.generateVillages(10) | |
| bop_chaparral = new SkyIslandType("biomesoplenty:chaparral") | |
| bop_chaparral.generateMineshafts(5) | |
| bop_chaparral.generateStrongholds(20) | |
| bop_chaparral.generateVillages(10) | |
| bop_flower_island = new SkyIslandType("biomesoplenty:flower_island") | |
| bop_flower_island.generateMineshafts(5) | |
| bop_flower_island.generateStrongholds(20) | |
| bop_flower_island.generateVillages(10) | |
| bop_flower_field = new SkyIslandType("biomesoplenty:flower_field") | |
| bop_flower_field.generateMineshafts(5) | |
| bop_flower_field.generateStrongholds(20) | |
| bop_flower_field.generateVillages(10) | |
| bop_wetland = new SkyIslandType("biomesoplenty:wetland") | |
| bop_wetland.generateMineshafts(5) | |
| bop_wetland.generateStrongholds(20) | |
| bop_wetland.generateVillages(10) | |
| bop_mystic_grove = new SkyIslandType("biomesoplenty:mystic_grove") | |
| bop_mystic_grove.generateMineshafts(5) | |
| bop_mystic_grove.generateStrongholds(20) | |
| bop_mystic_grove.generateVillages(10) | |
| bop_cold_desert = new SkyIslandType("biomesoplenty:cold_desert") | |
| bop_cold_desert.generateMineshafts(5) | |
| bop_cold_desert.generateStrongholds(20) | |
| bop_cold_desert.generateVillages(10) | |
| bop_mountain_foothills = new SkyIslandType("biomesoplenty:mountain_foothills") | |
| bop_mountain_foothills.generateMineshafts(5) | |
| bop_mountain_foothills.generateStrongholds(20) | |
| bop_mountain_foothills.generateVillages(10) | |
| bop_maple_woods = new SkyIslandType("biomesoplenty:maple_woods") | |
| bop_maple_woods.generateMineshafts(5) | |
| bop_maple_woods.generateStrongholds(20) | |
| bop_maple_woods.generateVillages(10) | |
| bop_coral_reef = new SkyIslandType("biomesoplenty:coral_reef") | |
| bop_coral_reef.generateMineshafts(5) | |
| bop_coral_reef.generateStrongholds(20) | |
| bop_coral_reef.generateVillages(10) | |
| bop_orchard = new SkyIslandType("biomesoplenty:orchard") | |
| bop_orchard.generateMineshafts(5) | |
| bop_orchard.generateStrongholds(20) | |
| bop_orchard.generateVillages(10) | |
| bop_moor = new SkyIslandType("biomesoplenty:moor") | |
| bop_moor.generateMineshafts(5) | |
| bop_moor.generateStrongholds(20) | |
| bop_moor.generateVillages(10) | |
| bop_land_of_lakes = new SkyIslandType("biomesoplenty:land_of_lakes") | |
| bop_land_of_lakes.generateMineshafts(5) | |
| bop_land_of_lakes.generateStrongholds(20) | |
| bop_land_of_lakes.generateVillages(10) | |
| bop_bog = new SkyIslandType("biomesoplenty:bog") | |
| bop_bog.generateMineshafts(5) | |
| bop_bog.generateStrongholds(20) | |
| bop_bog.generateVillages(10) | |
| bop_coniferous_forest = new SkyIslandType("biomesoplenty:coniferous_forest") | |
| bop_coniferous_forest.generateMineshafts(5) | |
| bop_coniferous_forest.generateStrongholds(20) | |
| bop_coniferous_forest.generateVillages(10) | |
| bop_eucalyptus_forest = new SkyIslandType("biomesoplenty:eucalyptus_forest") | |
| bop_eucalyptus_forest.generateMineshafts(5) | |
| bop_eucalyptus_forest.generateStrongholds(20) | |
| bop_eucalyptus_forest.generateVillages(10) | |
| bop_outback = new SkyIslandType("biomesoplenty:outback") | |
| bop_outback.generateMineshafts(5) | |
| bop_outback.generateStrongholds(20) | |
| bop_outback.generateVillages(10) | |
| bop_shield = new SkyIslandType("biomesoplenty:shield") | |
| bop_shield.generateMineshafts(5) | |
| bop_shield.generateStrongholds(20) | |
| bop_shield.generateVillages(10) | |
| bop_snowy_tundra = new SkyIslandType("biomesoplenty:snowy_tundra") | |
| bop_snowy_tundra.generateMineshafts(5) | |
| bop_snowy_tundra.generateStrongholds(20) | |
| bop_snowy_tundra.generateVillages(10) | |
| bop_alps = new SkyIslandType("biomesoplenty:alps") | |
| bop_alps.generateMineshafts(5) | |
| bop_alps.generateStrongholds(20) | |
| bop_alps.generateVillages(10) | |
| bop_wasteland = new SkyIslandType("biomesoplenty:wasteland") | |
| bop_wasteland.generateMineshafts(5) | |
| bop_wasteland.generateStrongholds(20) | |
| bop_wasteland.generateVillages(10) | |
| bop_lush_desert = new SkyIslandType("biomesoplenty:lush_desert") | |
| bop_lush_desert.generateMineshafts(5) | |
| bop_lush_desert.generateStrongholds(20) | |
| bop_lush_desert.generateVillages(10) | |
| bop_mangrove = new SkyIslandType("biomesoplenty:mangrove") | |
| bop_mangrove.generateMineshafts(5) | |
| bop_mangrove.generateStrongholds(20) | |
| bop_mangrove.generateVillages(10) | |
| bop_boreal_forest = new SkyIslandType("biomesoplenty:boreal_forest") | |
| bop_boreal_forest.generateMineshafts(5) | |
| bop_boreal_forest.generateStrongholds(20) | |
| bop_boreal_forest.generateVillages(10) | |
| bop_redwood_forest = new SkyIslandType("biomesoplenty:redwood_forest") | |
| bop_redwood_forest.generateMineshafts(5) | |
| bop_redwood_forest.generateStrongholds(20) | |
| bop_redwood_forest.generateVillages(10) | |
| bop_cherry_blossom_grove = new SkyIslandType("biomesoplenty:cherry_blossom_grove") | |
| bop_cherry_blossom_grove.generateMineshafts(5) | |
| bop_cherry_blossom_grove.generateStrongholds(20) | |
| bop_cherry_blossom_grove.generateVillages(10) | |
| bop_visceral_heap = new SkyIslandType("biomesoplenty:visceral_heap") | |
| bop_visceral_heap.generateMineshafts(5) | |
| bop_visceral_heap.generateStrongholds(20) | |
| bop_visceral_heap.generateVillages(10) | |
| bop_snowy_forest = new SkyIslandType("biomesoplenty:snowy_forest") | |
| bop_snowy_forest.generateMineshafts(5) | |
| bop_snowy_forest.generateStrongholds(20) | |
| bop_snowy_forest.generateVillages(10) | |
| bop_seasonal_forest = new SkyIslandType("biomesoplenty:seasonal_forest") | |
| bop_seasonal_forest.generateMineshafts(5) | |
| bop_seasonal_forest.generateStrongholds(20) | |
| bop_seasonal_forest.generateVillages(10) | |
| bop_temperate_rainforest = new SkyIslandType("biomesoplenty:temperate_rainforest") | |
| bop_temperate_rainforest.generateMineshafts(5) | |
| bop_temperate_rainforest.generateStrongholds(20) | |
| bop_temperate_rainforest.generateVillages(10) | |
| bop_dead_forest = new SkyIslandType("biomesoplenty:dead_forest") | |
| bop_dead_forest.generateMineshafts(5) | |
| bop_dead_forest.generateStrongholds(20) | |
| bop_dead_forest.generateVillages(10) | |
| bop_bamboo_forest = new SkyIslandType("biomesoplenty:bamboo_forest") | |
| bop_bamboo_forest.generateMineshafts(5) | |
| bop_bamboo_forest.generateStrongholds(20) | |
| bop_bamboo_forest.generateVillages(10) | |
| bop_corrupted_sands = new SkyIslandType("biomesoplenty:corrupted_sands") | |
| bop_corrupted_sands.generateMineshafts(5) | |
| bop_corrupted_sands.generateStrongholds(20) | |
| bop_corrupted_sands.generateVillages(10) | |
| bop_dead_swamp = new SkyIslandType("biomesoplenty:dead_swamp") | |
| bop_dead_swamp.generateMineshafts(5) | |
| bop_dead_swamp.generateStrongholds(20) | |
| bop_dead_swamp.generateVillages(10) | |
| bop_kelp_forest = new SkyIslandType("biomesoplenty:kelp_forest") | |
| bop_kelp_forest.generateMineshafts(5) | |
| bop_kelp_forest.generateStrongholds(20) | |
| bop_kelp_forest.generateVillages(10) | |
| bop_pasture = new SkyIslandType("biomesoplenty:pasture") | |
| bop_pasture.generateMineshafts(5) | |
| bop_pasture.generateStrongholds(20) | |
| bop_pasture.generateVillages(10) | |
| bop_glacier = new SkyIslandType("biomesoplenty:glacier") | |
| bop_glacier.generateMineshafts(5) | |
| bop_glacier.generateStrongholds(20) | |
| bop_glacier.generateVillages(10) | |
| bop_meadow = new SkyIslandType("biomesoplenty:meadow") | |
| bop_meadow.generateMineshafts(5) | |
| bop_meadow.generateStrongholds(20) | |
| bop_meadow.generateVillages(10) | |
| bop_lush_swamp = new SkyIslandType("biomesoplenty:lush_swamp") | |
| bop_lush_swamp.generateMineshafts(5) | |
| bop_lush_swamp.generateStrongholds(20) | |
| bop_lush_swamp.generateVillages(10) | |
| bop_fungi_forest = new SkyIslandType("biomesoplenty:fungi_forest") | |
| bop_fungi_forest.generateMineshafts(5) | |
| bop_fungi_forest.generateStrongholds(20) | |
| bop_fungi_forest.generateVillages(10) | |
| bop_tropical_island = new SkyIslandType("biomesoplenty:tropical_island") | |
| bop_tropical_island.generateMineshafts(5) | |
| bop_tropical_island.generateStrongholds(20) | |
| bop_tropical_island.generateVillages(10) | |
| bop_grassland = new SkyIslandType("biomesoplenty:grassland") | |
| bop_grassland.generateMineshafts(5) | |
| bop_grassland.generateStrongholds(20) | |
| bop_grassland.generateVillages(10) | |
| bop_prairie = new SkyIslandType("biomesoplenty:prairie") | |
| bop_prairie.generateMineshafts(5) | |
| bop_prairie.generateStrongholds(20) | |
| bop_prairie.generateVillages(10) | |
| bop_snowy_coniferous_forest = new SkyIslandType("biomesoplenty:snowy_coniferous_forest") | |
| bop_snowy_coniferous_forest.generateMineshafts(5) | |
| bop_snowy_coniferous_forest.generateStrongholds(20) | |
| bop_snowy_coniferous_forest.generateVillages(10) | |
| bop_tundra = new SkyIslandType("biomesoplenty:tundra") | |
| bop_tundra.generateMineshafts(5) | |
| bop_tundra.generateStrongholds(20) | |
| bop_tundra.generateVillages(10) | |
| bop_undergarden = new SkyIslandType("biomesoplenty:undergarden") | |
| bop_undergarden.generateMineshafts(5) | |
| bop_undergarden.generateStrongholds(20) | |
| bop_undergarden.generateVillages(10) | |
| bop_origin_island = new SkyIslandType("biomesoplenty:origin_island") | |
| bop_origin_island.generateMineshafts(5) | |
| bop_origin_island.generateStrongholds(20) | |
| bop_origin_island.generateVillages(10) | |
| bop_gravel_beach = new SkyIslandType("biomesoplenty:gravel_beach") | |
| bop_gravel_beach.generateMineshafts(5) | |
| bop_gravel_beach.generateStrongholds(20) | |
| bop_gravel_beach.generateVillages(10) | |
| bop_grove = new SkyIslandType("biomesoplenty:grove") | |
| bop_grove.generateMineshafts(5) | |
| bop_grove.generateStrongholds(20) | |
| bop_grove.generateVillages(10) | |
| bop_lavender_fields = new SkyIslandType("biomesoplenty:lavender_fields") | |
| bop_lavender_fields.generateMineshafts(5) | |
| bop_lavender_fields.generateStrongholds(20) | |
| bop_lavender_fields.generateVillages(10) | |
| bop_origin_beach = new SkyIslandType("biomesoplenty:origin_beach") | |
| bop_origin_beach.generateMineshafts(5) | |
| bop_origin_beach.generateStrongholds(20) | |
| bop_origin_beach.generateVillages(10) | |
| bop_rainforest = new SkyIslandType("biomesoplenty:rainforest") | |
| bop_rainforest.generateMineshafts(5) | |
| bop_rainforest.generateStrongholds(20) | |
| bop_rainforest.generateVillages(10) | |
| bop_sacred_springs = new SkyIslandType("biomesoplenty:sacred_springs") | |
| bop_sacred_springs.generateMineshafts(5) | |
| bop_sacred_springs.generateStrongholds(20) | |
| bop_sacred_springs.generateVillages(10) | |
| bop_crag = new SkyIslandType("biomesoplenty:crag") | |
| bop_crag.generateMineshafts(5) | |
| bop_crag.generateStrongholds(20) | |
| bop_crag.generateVillages(10) | |
| bop_brushland = new SkyIslandType("biomesoplenty:brushland") | |
| bop_brushland.generateMineshafts(5) | |
| bop_brushland.generateStrongholds(20) | |
| bop_brushland.generateVillages(10) | |
| bop_ominous_woods = new SkyIslandType("biomesoplenty:ominous_woods") | |
| bop_ominous_woods.generateMineshafts(5) | |
| bop_ominous_woods.generateStrongholds(20) | |
| bop_ominous_woods.generateVillages(10) | |
| //===================================== | |
| // Add Thaumcraft biome types | |
| thc_eerie = new SkyIslandType("thaumcraft:eerie") | |
| thc_eerie.generateMineshafts(5) | |
| thc_eerie.generateStrongholds(20) | |
| thc_eerie.generateVillages(10) | |
| thc_eldritch = new SkyIslandType("thaumcraft:eldritch") | |
| thc_eldritch.generateMineshafts(5) | |
| thc_eldritch.generateStrongholds(20) | |
| thc_eldritch.generateVillages(10) | |
| thc_magical_forest = new SkyIslandType("thaumcraft:magical_forest") | |
| thc_magical_forest.generateMineshafts(5) | |
| thc_magical_forest.generateStrongholds(20) | |
| thc_magical_forest.generateVillages(10) | |
| //===================================== | |
| //Creates a new SkyIslandGenerator, sets its grid region size, and adds it to the generator list for the dimension. | |
| skyIslands = new SkyIslandGeneratorV2() | |
| skyIslands.setRegionSize(29) | |
| addGenerator(skyIslands) | |
| // Add a hook to caves so worley's can work its magic under the islands, set min cave y to something higher for more caves | |
| // FIXME: this seems to be working, but can use more testing and tuning | |
| caves = new VanillaCaveGenerator() | |
| addGenerator(caves) | |
| //Adds sky islands. Arguments are horizontal radius, top height, bottom height, number of times to attempt to generate in each region, and whether each island should choose a random type (true), or if types should be used in order (false). | |
| large = skyIslands.addSkyIslands(100, 100, 62, 1, true) | |
| //Adds a SkyIslandType we created above to the island generator. | |
| large.addType(forest) | |
| large.addType(cold_taiga) | |
| large.addType(desert) | |
| large.addType(mesa) | |
| large.addType(jungle) | |
| large.addType(plains) | |
| large.addType(taiga) | |
| large.addType(swamp) | |
| large.addType(mushroom) | |
| large.addType(ice_plains) | |
| large.addType(savanna) | |
| large.addType(roofed_forest) | |
| large.addType(redwood_taiga) | |
| // Add biomes o plenty types to large | |
| large.addType(bop_oasis) | |
| large.addType(bop_woodland) | |
| large.addType(bop_white_beach) | |
| large.addType(bop_shrubland) | |
| large.addType(bop_xeric_shrubland) | |
| large.addType(bop_tropical_rainforest) | |
| large.addType(bop_fen) | |
| large.addType(bop_steppe) | |
| large.addType(bop_alps_foothills) | |
| large.addType(bop_redwood_forest_edge) | |
| large.addType(bop_bayou) | |
| large.addType(bop_mountain) | |
| large.addType(bop_phantasmagoric_inferno) | |
| large.addType(bop_overgrown_cliffs) | |
| large.addType(bop_highland) | |
| large.addType(bop_volcanic_island) | |
| large.addType(bop_quagmire) | |
| large.addType(bop_marsh) | |
| large.addType(bop_chaparral) | |
| large.addType(bop_flower_island) | |
| large.addType(bop_flower_field) | |
| large.addType(bop_wetland) | |
| large.addType(bop_mystic_grove) | |
| large.addType(bop_cold_desert) | |
| large.addType(bop_mountain_foothills) | |
| large.addType(bop_maple_woods) | |
| large.addType(bop_coral_reef) | |
| large.addType(bop_orchard) | |
| large.addType(bop_moor) | |
| large.addType(bop_land_of_lakes) | |
| large.addType(bop_bog) | |
| large.addType(bop_coniferous_forest) | |
| large.addType(bop_eucalyptus_forest) | |
| large.addType(bop_outback) | |
| large.addType(bop_shield) | |
| large.addType(bop_snowy_tundra) | |
| large.addType(bop_alps) | |
| large.addType(bop_wasteland) | |
| large.addType(bop_lush_desert) | |
| large.addType(bop_mangrove) | |
| large.addType(bop_boreal_forest) | |
| large.addType(bop_redwood_forest) | |
| large.addType(bop_cherry_blossom_grove) | |
| large.addType(bop_visceral_heap) | |
| large.addType(bop_snowy_forest) | |
| large.addType(bop_seasonal_forest) | |
| large.addType(bop_temperate_rainforest) | |
| large.addType(bop_dead_forest) | |
| large.addType(bop_bamboo_forest) | |
| large.addType(bop_corrupted_sands) | |
| large.addType(bop_dead_swamp) | |
| large.addType(bop_kelp_forest) | |
| large.addType(bop_pasture) | |
| large.addType(bop_glacier) | |
| large.addType(bop_meadow) | |
| large.addType(bop_lush_swamp) | |
| large.addType(bop_fungi_forest) | |
| large.addType(bop_tropical_island) | |
| large.addType(bop_grassland) | |
| large.addType(bop_prairie) | |
| large.addType(bop_snowy_coniferous_forest) | |
| large.addType(bop_tundra) | |
| large.addType(bop_undergarden) | |
| large.addType(bop_origin_island) | |
| large.addType(bop_gravel_beach) | |
| large.addType(bop_grove) | |
| large.addType(bop_lavender_fields) | |
| large.addType(bop_origin_beach) | |
| large.addType(bop_rainforest) | |
| large.addType(bop_sacred_springs) | |
| large.addType(bop_crag) | |
| large.addType(bop_brushland) | |
| large.addType(bop_ominous_woods) | |
| // Add Thaumcraft biome types | |
| large.addType(thc_eerie) | |
| large.addType(thc_eldritch) | |
| large.addType(thc_magical_forest) | |
| //===================================== | |
| oceanIslands = skyIslands.addSkyIslands(50, 50, 50, 4, false) | |
| oceanIslands.setFluidDepth(8) | |
| oceanIslands.addType(ocean) | |
| //===================================== | |
| medium = skyIslands.addSkyIslands(50, 50, 31, 32, true) | |
| medium.addType(forest) | |
| medium.addType(cold_taiga) | |
| medium.addType(desert) | |
| medium.addType(mesa) | |
| medium.addType(jungle) | |
| medium.addType(plains) | |
| medium.addType(taiga) | |
| medium.addType(swamp) | |
| medium.addType(mushroom) | |
| medium.addType(ice_plains) | |
| medium.addType(savanna) | |
| medium.addType(roofed_forest) | |
| medium.addType(redwood_taiga) | |
| // Add biomes o plenty types to medium | |
| medium.addType(bop_oasis) | |
| medium.addType(bop_woodland) | |
| medium.addType(bop_white_beach) | |
| medium.addType(bop_shrubland) | |
| medium.addType(bop_xeric_shrubland) | |
| medium.addType(bop_tropical_rainforest) | |
| medium.addType(bop_fen) | |
| medium.addType(bop_steppe) | |
| medium.addType(bop_alps_foothills) | |
| medium.addType(bop_redwood_forest_edge) | |
| medium.addType(bop_bayou) | |
| medium.addType(bop_mountain) | |
| medium.addType(bop_phantasmagoric_inferno) | |
| medium.addType(bop_overgrown_cliffs) | |
| medium.addType(bop_highland) | |
| medium.addType(bop_volcanic_island) | |
| medium.addType(bop_quagmire) | |
| medium.addType(bop_marsh) | |
| medium.addType(bop_chaparral) | |
| medium.addType(bop_flower_island) | |
| medium.addType(bop_flower_field) | |
| medium.addType(bop_wetland) | |
| medium.addType(bop_mystic_grove) | |
| medium.addType(bop_cold_desert) | |
| medium.addType(bop_mountain_foothills) | |
| medium.addType(bop_maple_woods) | |
| medium.addType(bop_coral_reef) | |
| medium.addType(bop_orchard) | |
| medium.addType(bop_moor) | |
| medium.addType(bop_land_of_lakes) | |
| medium.addType(bop_bog) | |
| medium.addType(bop_coniferous_forest) | |
| medium.addType(bop_eucalyptus_forest) | |
| medium.addType(bop_outback) | |
| medium.addType(bop_shield) | |
| medium.addType(bop_snowy_tundra) | |
| medium.addType(bop_alps) | |
| medium.addType(bop_wasteland) | |
| medium.addType(bop_lush_desert) | |
| medium.addType(bop_mangrove) | |
| medium.addType(bop_boreal_forest) | |
| medium.addType(bop_redwood_forest) | |
| medium.addType(bop_cherry_blossom_grove) | |
| medium.addType(bop_visceral_heap) | |
| medium.addType(bop_snowy_forest) | |
| medium.addType(bop_seasonal_forest) | |
| medium.addType(bop_temperate_rainforest) | |
| medium.addType(bop_dead_forest) | |
| medium.addType(bop_bamboo_forest) | |
| medium.addType(bop_corrupted_sands) | |
| medium.addType(bop_dead_swamp) | |
| medium.addType(bop_kelp_forest) | |
| medium.addType(bop_pasture) | |
| medium.addType(bop_glacier) | |
| medium.addType(bop_meadow) | |
| medium.addType(bop_lush_swamp) | |
| medium.addType(bop_fungi_forest) | |
| medium.addType(bop_tropical_island) | |
| medium.addType(bop_grassland) | |
| medium.addType(bop_prairie) | |
| medium.addType(bop_snowy_coniferous_forest) | |
| medium.addType(bop_tundra) | |
| medium.addType(bop_undergarden) | |
| medium.addType(bop_origin_island) | |
| medium.addType(bop_gravel_beach) | |
| medium.addType(bop_grove) | |
| medium.addType(bop_lavender_fields) | |
| medium.addType(bop_origin_beach) | |
| medium.addType(bop_rainforest) | |
| medium.addType(bop_sacred_springs) | |
| medium.addType(bop_crag) | |
| medium.addType(bop_brushland) | |
| medium.addType(bop_ominous_woods) | |
| // Add Thaumcraft biome types | |
| medium.addType(thc_eerie) | |
| medium.addType(thc_eldritch) | |
| medium.addType(thc_magical_forest) | |
| //===================================== | |
| // Add Vanilla Biomes to small types | |
| small = skyIslands.addSkyIslands(25, 25, 15, 64, true) | |
| small.addType(forest) | |
| small.addType(cold_taiga) | |
| small.addType(desert) | |
| small.addType(mesa) | |
| small.addType(jungle) | |
| small.addType(plains) | |
| small.addType(taiga) | |
| small.addType(swamp) | |
| small.addType(mushroom) | |
| small.addType(ice_plains) | |
| small.addType(savanna) | |
| small.addType(roofed_forest) | |
| small.addType(redwood_taiga) | |
| // Add biomes o plenty types to small islands | |
| small.addType(bop_oasis) | |
| small.addType(bop_woodland) | |
| small.addType(bop_white_beach) | |
| small.addType(bop_shrubland) | |
| small.addType(bop_xeric_shrubland) | |
| small.addType(bop_tropical_rainforest) | |
| small.addType(bop_fen) | |
| small.addType(bop_steppe) | |
| small.addType(bop_alps_foothills) | |
| small.addType(bop_redwood_forest_edge) | |
| small.addType(bop_bayou) | |
| small.addType(bop_mountain) | |
| small.addType(bop_phantasmagoric_inferno) | |
| small.addType(bop_overgrown_cliffs) | |
| small.addType(bop_highland) | |
| small.addType(bop_volcanic_island) | |
| small.addType(bop_quagmire) | |
| small.addType(bop_marsh) | |
| small.addType(bop_chaparral) | |
| small.addType(bop_flower_island) | |
| small.addType(bop_flower_field) | |
| small.addType(bop_wetland) | |
| small.addType(bop_mystic_grove) | |
| small.addType(bop_cold_desert) | |
| small.addType(bop_mountain_foothills) | |
| small.addType(bop_maple_woods) | |
| small.addType(bop_coral_reef) | |
| small.addType(bop_orchard) | |
| small.addType(bop_moor) | |
| small.addType(bop_land_of_lakes) | |
| small.addType(bop_bog) | |
| small.addType(bop_coniferous_forest) | |
| small.addType(bop_eucalyptus_forest) | |
| small.addType(bop_outback) | |
| small.addType(bop_shield) | |
| small.addType(bop_snowy_tundra) | |
| small.addType(bop_alps) | |
| small.addType(bop_wasteland) | |
| small.addType(bop_lush_desert) | |
| small.addType(bop_mangrove) | |
| small.addType(bop_boreal_forest) | |
| small.addType(bop_redwood_forest) | |
| small.addType(bop_cherry_blossom_grove) | |
| small.addType(bop_visceral_heap) | |
| small.addType(bop_snowy_forest) | |
| small.addType(bop_seasonal_forest) | |
| small.addType(bop_temperate_rainforest) | |
| small.addType(bop_dead_forest) | |
| small.addType(bop_bamboo_forest) | |
| small.addType(bop_corrupted_sands) | |
| small.addType(bop_dead_swamp) | |
| small.addType(bop_kelp_forest) | |
| small.addType(bop_pasture) | |
| small.addType(bop_glacier) | |
| small.addType(bop_meadow) | |
| small.addType(bop_lush_swamp) | |
| small.addType(bop_fungi_forest) | |
| small.addType(bop_tropical_island) | |
| small.addType(bop_grassland) | |
| small.addType(bop_prairie) | |
| small.addType(bop_snowy_coniferous_forest) | |
| small.addType(bop_tundra) | |
| small.addType(bop_undergarden) | |
| small.addType(bop_origin_island) | |
| small.addType(bop_gravel_beach) | |
| small.addType(bop_grove) | |
| small.addType(bop_lavender_fields) | |
| small.addType(bop_origin_beach) | |
| small.addType(bop_rainforest) | |
| small.addType(bop_sacred_springs) | |
| small.addType(bop_crag) | |
| small.addType(bop_brushland) | |
| small.addType(bop_ominous_woods) | |
| // Add Thaumcraft biome types | |
| small.addType(thc_eerie) | |
| small.addType(thc_eldritch) | |
| small.addType(thc_magical_forest) |
Yes, just delete all the lines referencing the vanilla biomes and
thaumcraft and the remaining ones will just be BOP types.
You can even add the BOP HELL biome types and see islands with Nether mobs
in the overworld 🤣
Does that answer your question?
// 3. Add `generator-settings={"Topography-Preset"\:"Sky Magic Islands"}` into `server.properties`
// 4. Add `level-type=BIOMESOP` into `server.properties`
Is it possible to do this in single player? Being able to add topogrophy generator settings on top of BOP world type generation is exactly what I've been looking for
Sure, I haven't tried the most recent versions of topography, but I finished my modpack which has the latest version of the gist code:
* [Sky Magic Islands Modpack](https://www.curseforge.com/minecraft/modpacks/sky-magic-islands)
* [Sky Magic Islands Modpack Github Topography Config Code](https://github.com/ubergarm/SkyMagicIslands/tree/master/config/topography)
It worked fine for single player worldgen just like server worldgen with
all the exact mod versions I assembled. Probably still works fine for newer
versions but may need some config tweaks.
Enjoy!
Thanks!
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
You seem to know a lot about this, would it be possible to have BOP run as Default but without the interference of "Vanilla" Biomes?