diff --git a/README.md b/README.md index 5e40f63..69be8aa 100644 --- a/README.md +++ b/README.md @@ -1,3 +1,27 @@ # TerrainAPI +# About + +TerrainAPI is a complete rewrite of the Chunk Decorator Classes in BTA, it allows for mods to easily add and modify world features and structures in BTA. TerrainAPI is also setup to allow lots of configurability to the user, allowing them to modify the world generation themselves. + +Some user configurable things being: +- Tree densities +- Ore densities +- Ore spawn heights +- Lake densities +- Plant densities + +## How to include TerrainAPI in a project +Add this in your `build.gradle`: +```groovy +repositories { + mavenCentral() + maven { url = "https://jitpack.io" } +} + +dependencies { + modImplementation 'com.github.UselessSolutions:TerrainAPI:v${project.terrain_api_version}' +} +``` + Documentation Eventually! :) diff --git a/build.gradle b/build.gradle index 611e393..84e164f 100644 --- a/build.gradle +++ b/build.gradle @@ -1,16 +1,30 @@ plugins { - id 'babric-loom' version '1.1.+' + id 'fabric-loom' version '1.7.bta' id 'java' } +import org.gradle.internal.os.OperatingSystem + +project.ext.lwjglVersion = "3.3.4" + +switch (OperatingSystem.current()) { + case OperatingSystem.LINUX: + project.ext.lwjglNatives = "natives-linux" + break + case OperatingSystem.WINDOWS: + project.ext.lwjglNatives = "natives-windows" + break + case OperatingSystem.MAC_OS: + project.ext.lwjglNatives = "natives-macos" +} + group = project.mod_group archivesBaseName = project.mod_name version = project.mod_version loom { - gluedMinecraftJar() noIntermediateMappings() - customMinecraftManifest.set("https://github.com/Turnip-Labs/bta-manifest-repo/releases/download/v${project.bta_version}/${project.bta_version}.json") + customMinecraftMetadata.set("https://downloads.betterthanadventure.net/bta-client/${project.bta_channel}/v${project.bta_version}/manifest.json") } repositories { @@ -24,6 +38,14 @@ repositories { name = 'Fabric' url = 'https://maven.fabricmc.net/' } + maven { + name = 'SignalumMavenInfrastructure' + url = 'https://maven.thesignalumproject.net/infrastructure' + } + maven { + name = 'SignalumMavenReleases' + url = 'https://maven.thesignalumproject.net/releases' + } ivy { url = "https://github.com/Better-than-Adventure" patternLayout { @@ -33,25 +55,17 @@ repositories { metadataSources { artifact() } } ivy { - url = "https://github.com/Turnip-Labs" + url = "https://downloads.betterthanadventure.net/bta-client/${project.bta_channel}/" patternLayout { - artifact "[organisation]/releases/download/v[revision]/[module]-[revision].jar" + artifact "/v[revision]/client.jar" m2compatible = true } metadataSources { artifact() } } ivy { - url = "https://github.com/Turnip-Labs" + url = "https://downloads.betterthanadventure.net/bta-server/${project.bta_channel}/" patternLayout { - artifact "[organisation]/releases/download/[revision]/[module]-[revision].jar" - m2compatible = true - } - metadataSources { artifact() } - } - ivy { - url = "https://github.com/Turnip-Labs" - patternLayout { - artifact "[organisation]/releases/download/[revision]/[module]-bta-[revision].jar" + artifact "/v[revision]/server.jar" m2compatible = true } metadataSources { artifact() } @@ -64,48 +78,49 @@ repositories { } metadataSources { artifact() } } - ivy { - url = "https://github.com/MartinSVK12" - patternLayout { - artifact "[organisation]/releases/download/[revision]/[module]-[revision].jar" - m2compatible = true - } - metadataSources { artifact() } - } - ivy { - url = "https://github.com/UselessBullets" - patternLayout { - artifact "[organisation]/releases/download/v[revision]/[module]-[revision].jar" - m2compatible = true - } - metadataSources { artifact() } - } + } dependencies { - minecraft "bta-download-repo:bta:${project.bta_version}" + minecraft "::${project.bta_version}" mappings loom.layered() {} modRuntimeOnly "objects:client:43db9b498cb67058d2e12d394e6507722e71bb45" // https://piston-data.mojang.com/v1/objects/43db9b498cb67058d2e12d394e6507722e71bb45/client.jar - modImplementation "fabric-loader:fabric-loader:${project.loader_version}" + modImplementation "net.fabricmc:fabric-loader:${project.loader_version}" // Helper library // If you do not need Halplibe you can comment this line out or delete this line - modImplementation "com.github.Turnip-Labs:bta-halplibe:${project.halplibe_version}" + implementation("turniplabs:halplibe:${project.halplibe_version}") - modImplementation "ModMenu:ModMenu:2.0.0" - //modImplementation "Useless-Profiler:profiler:1.0.1" + modImplementation("turniplabs:modmenu-bta:${project.mod_menu_version}") implementation "org.slf4j:slf4j-api:1.8.0-beta4" implementation "org.apache.logging.log4j:log4j-slf4j18-impl:2.16.0" - implementation 'com.google.guava:guava:30.0-jre' - implementation group: 'com.google.code.gson', name: 'gson', version: '2.8.9' - + implementation 'com.google.guava:guava:33.0.0-jre' + implementation group: 'com.google.code.gson', name: 'gson', version: '2.10.1' var log4jVersion = "2.20.0" implementation("org.apache.logging.log4j:log4j-core:${log4jVersion}") implementation("org.apache.logging.log4j:log4j-api:${log4jVersion}") implementation("org.apache.logging.log4j:log4j-1.2-api:${log4jVersion}") + + include(implementation("org.apache.commons:commons-lang3:3.12.0")) + + modImplementation("com.github.zarzelcow:legacy-lwjgl3:1.0.4") + implementation platform("org.lwjgl:lwjgl-bom:$lwjglVersion") + + runtimeOnly "org.lwjgl:lwjgl::$lwjglNatives" + runtimeOnly "org.lwjgl:lwjgl-assimp::$lwjglNatives" + runtimeOnly "org.lwjgl:lwjgl-glfw::$lwjglNatives" + runtimeOnly "org.lwjgl:lwjgl-openal::$lwjglNatives" + runtimeOnly "org.lwjgl:lwjgl-opengl::$lwjglNatives" + runtimeOnly "org.lwjgl:lwjgl-stb::$lwjglNatives" + implementation "org.lwjgl:lwjgl:$lwjglVersion" + implementation "org.lwjgl:lwjgl-assimp:$lwjglVersion" + implementation "org.lwjgl:lwjgl-glfw:$lwjglVersion" + implementation "org.lwjgl:lwjgl-openal:$lwjglVersion" + implementation "org.lwjgl:lwjgl-opengl:$lwjglVersion" + implementation "org.lwjgl:lwjgl-stb:$lwjglVersion" } java { @@ -114,7 +129,7 @@ java { withSourcesJar() } -tasks.withType(JavaCompile) { +tasks.withType(JavaCompile).configureEach { options.release.set 8 } @@ -124,6 +139,11 @@ jar { } } +configurations.configureEach { + // Removes LWJGL2 dependencies + exclude group: "org.lwjgl.lwjgl" +} + processResources { inputs.property "version", version diff --git a/gradle.properties b/gradle.properties index 991e276..3fce05e 100644 --- a/gradle.properties +++ b/gradle.properties @@ -1,15 +1,17 @@ org.gradle.jvmargs=-Xmx2G # BTA -bta_version=1.7.7.0_02 +bta_version=7.3 +bta_channel=release # Loader -loader_version=0.14.19-babric.1-bta +loader_version=0.15.6-bta.7 # HalpLibe -halplibe_version=2.7.0 +halplibe_version=5.1.0 +mod_menu_version=3.0.0 # Mod -mod_version=1.3.1 +mod_version=1.5.0-7.3 mod_group=useless mod_name=terrainapi diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties index 8049c68..0d18421 100644 --- a/gradle/wrapper/gradle-wrapper.properties +++ b/gradle/wrapper/gradle-wrapper.properties @@ -1,5 +1,5 @@ distributionBase=GRADLE_USER_HOME distributionPath=wrapper/dists -distributionUrl=https\://services.gradle.org/distributions/gradle-7.5-bin.zip +distributionUrl=https\://services.gradle.org/distributions/gradle-8.8-bin.zip zipStoreBase=GRADLE_USER_HOME zipStorePath=wrapper/dists diff --git a/jitpack.yml b/jitpack.yml new file mode 100644 index 0000000..efde7bf --- /dev/null +++ b/jitpack.yml @@ -0,0 +1,2 @@ +jdk: + - openjdk17 diff --git a/lib/modmenu-bta-3.0.0.jar b/lib/modmenu-bta-3.0.0.jar new file mode 100644 index 0000000..3eb6296 Binary files /dev/null and b/lib/modmenu-bta-3.0.0.jar differ diff --git a/settings.gradle b/settings.gradle index 46d2434..8b12c9d 100644 --- a/settings.gradle +++ b/settings.gradle @@ -1,17 +1,21 @@ pluginManagement { - repositories { - maven { - name = 'Fabric' - url = 'https://maven.fabricmc.net/' - } - gradlePluginPortal() - maven { - name = 'Jitpack' - url = 'https://jitpack.io' - } - maven { - name = 'Babric' - url = 'https://maven.glass-launcher.net/babric' - } - } -} \ No newline at end of file + repositories { + gradlePluginPortal() + maven { + name = 'Fabric' + url = 'https://maven.fabricmc.net/' + } + maven { + name = 'Jitpack' + url = 'https://jitpack.io' + } + maven { + name = 'Babric' + url = 'https://maven.glass-launcher.net/babric' + } + maven { + name = 'SignalumMavenInfrastructure' + url = 'https://maven.thesignalumproject.net/infrastructure' + } + } +} diff --git a/src/main/java/useless/terrainapi/TerrainMain.java b/src/main/java/useless/terrainapi/TerrainMain.java index 50f7d8a..a98b5d1 100644 --- a/src/main/java/useless/terrainapi/TerrainMain.java +++ b/src/main/java/useless/terrainapi/TerrainMain.java @@ -5,15 +5,15 @@ import com.google.gson.GsonBuilder; import net.fabricmc.api.ModInitializer; import net.fabricmc.loader.api.FabricLoader; -import org.jetbrains.annotations.ApiStatus; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import turniplabs.halplibe.util.GameStartEntrypoint; import useless.terrainapi.api.TerrainAPI; import useless.terrainapi.config.ConfigManager; import useless.terrainapi.initialization.TerrainInitialization; -public class TerrainMain implements ModInitializer { +public class TerrainMain implements ModInitializer, GameStartEntrypoint { public static final Gson GSON = (new GsonBuilder()).setFieldNamingPolicy(FieldNamingPolicy.LOWER_CASE_WITH_UNDERSCORES).setPrettyPrinting().excludeFieldsWithoutExposeAnnotation().create(); public static final String MOD_ID = "terrain-api"; public static final Logger LOGGER = LoggerFactory.getLogger(MOD_ID); @@ -25,8 +25,13 @@ public class TerrainMain implements ModInitializer { public void onInitialize() { LOGGER.info("TerrainMain initialized."); } - @ApiStatus.Internal - public static void loadModules(){ + @Override + public void beforeGameStart() { + + } + + @Override + public void afterGameStart() { LOCK_API = false; new TerrainInitialization().onInitialize(); FabricLoader.getInstance().getEntrypoints("terrain-api", TerrainAPI.class).forEach(api -> { diff --git a/src/main/java/useless/terrainapi/config/ConfigManager.java b/src/main/java/useless/terrainapi/config/ConfigManager.java index 882520d..45e0734 100644 --- a/src/main/java/useless/terrainapi/config/ConfigManager.java +++ b/src/main/java/useless/terrainapi/config/ConfigManager.java @@ -23,7 +23,7 @@ private static void prepareBiomeConfigFile(String id) { if (fileHashMap.get(id) != null) { return; } - Path filePath = Paths.get(FabricLoader.getInstance().getConfigDirectory() + "/" + TerrainMain.MOD_ID); + Path filePath = Paths.get(FabricLoader.getInstance().getConfigDir() + "/" + TerrainMain.MOD_ID); try { Files.createDirectories(filePath); } catch (IOException e) { diff --git a/src/main/java/useless/terrainapi/config/OreConfig.java b/src/main/java/useless/terrainapi/config/OreConfig.java index 41f09cc..204ff04 100644 --- a/src/main/java/useless/terrainapi/config/OreConfig.java +++ b/src/main/java/useless/terrainapi/config/OreConfig.java @@ -23,8 +23,14 @@ public class OreConfig extends APIConfig { /** * Map of Block key generation range */ - @SerializedName(value = "Vertical Range") @Expose - public HashMap verticalRange = new HashMap<>(); + @SerializedName(value = "Vertical Starting Range") @Expose + public HashMap verticalStartingRange = new HashMap<>(); + + /** + * Map of Block key generation range + */ + @SerializedName(value = "Vertical Ending Range") @Expose + public HashMap verticalEndingRange = new HashMap<>(); /**Creates an ore entry, this can be used directly by OreFeatures#addManagedOreFeature or directly by referencing the HashMaps themselves * @param block The block to be generated, the block key is used as the key for the hashmap @@ -32,26 +38,45 @@ public class OreConfig extends APIConfig { * @param chances Number of chances per chunk to generate an ore patch, this values scales with world height * @param range Value from [0, 1], it's the fraction from the bottom of the world to the surface that the ore can generate */ - public void setOreValues(String modID, Block block, int clusterSize, int chances, float range){ + public void setOreValues(String modID, Block block, int clusterSize, int chances, float range){ String key = block.getKey(); if (this.clusterSize.containsKey(key) && this.getConfigOverride()){ return; } - if (this.clusterSize.getOrDefault(key, clusterSize) != clusterSize || this.chancesPerChunk.getOrDefault(key, chances) != chances || this.verticalRange.getOrDefault(key, range) != range){ + if (this.clusterSize.getOrDefault(key, clusterSize) != clusterSize || this.chancesPerChunk.getOrDefault(key, chances) != chances || this.verticalStartingRange.getOrDefault(key, 0f) != 0 || this.verticalStartingRange.getOrDefault(key, range) != range){ TerrainMain.LOGGER.warn(modID + String.format(" has changed block %s to generate %d blocks with %d chances and a range of %f", block.getKey(), clusterSize, chances, range)); } - setOreValues(block, clusterSize, chances, range); + setOreValues(block, clusterSize, chances, 0, range); } /**Creates an ore entry, this can be used directly by OreFeatures#addManagedOreFeature or directly by referencing the HashMaps themselves * @param block The block to be generated, the block key is used as the key for the hashmap * @param clusterSize Size in blocks of an ore vein * @param chances Number of chances per chunk to generate an ore patch, this values scales with world height - * @param range Value from [0, 1], it's the fraction from the bottom of the world to the surface that the ore can generate + * @param startingRange Value from [0, 1], it's the fraction from the bottom of the world to the surface that the ore can generate + * @param endingRange Value from [0, 1], it's the fraction from the bottom of the world to the surface that the ore can generate + */ + public void setOreValues(String modID, Block block, int clusterSize, int chances, float startingRange, float endingRange){ + String key = block.getKey(); + if (this.clusterSize.containsKey(key) && this.getConfigOverride()){ + return; + } + if (this.clusterSize.getOrDefault(key, clusterSize) != clusterSize || this.chancesPerChunk.getOrDefault(key, chances) != chances || this.verticalStartingRange.getOrDefault(key, startingRange) != startingRange || this.verticalEndingRange.getOrDefault(key, endingRange) != endingRange){ + TerrainMain.LOGGER.warn(modID + String.format(" has changed block %s to generate %d blocks with %d chances and a range of [%f, %f]", block.getKey(), clusterSize, chances, startingRange, endingRange)); + } + setOreValues(block, clusterSize, chances, startingRange, endingRange); + } + /**Creates an ore entry, this can be used directly by OreFeatures#addManagedOreFeature or directly by referencing the HashMaps themselves + * @param block The block to be generated, the block key is used as the key for the hashmap + * @param clusterSize Size in blocks of an ore vein + * @param chances Number of chances per chunk to generate an ore patch, this values scales with world height + * @param startingRange Value from [0, 1], it's the fraction from the bottom of the world to the surface that the ore can generate + * @param endingRange Value from [0, 1], it's the fraction from the bottom of the world to the surface that the ore can generate */ @ApiStatus.Internal - protected void setOreValues(Block block, int clusterSize, int chances, float range){ + protected void setOreValues(Block block, int clusterSize, int chances, float startingRange, float endingRange){ this.clusterSize.put(block.getKey(), clusterSize); this.chancesPerChunk.put(block.getKey(), chances); - this.verticalRange.put(block.getKey(), range); + this.verticalStartingRange.put(block.getKey(), startingRange); + this.verticalEndingRange.put(block.getKey(), endingRange); } } diff --git a/src/main/java/useless/terrainapi/generation/ChunkDecoratorAPI.java b/src/main/java/useless/terrainapi/generation/ChunkDecoratorAPI.java index 80e9871..838308c 100644 --- a/src/main/java/useless/terrainapi/generation/ChunkDecoratorAPI.java +++ b/src/main/java/useless/terrainapi/generation/ChunkDecoratorAPI.java @@ -1,7 +1,7 @@ package useless.terrainapi.generation; -import net.minecraft.core.block.Block; -import net.minecraft.core.block.BlockSand; +import net.minecraft.core.block.BlockLogicSand; +import net.minecraft.core.block.Blocks; import net.minecraft.core.world.World; import net.minecraft.core.world.biome.Biome; import net.minecraft.core.world.chunk.Chunk; @@ -47,11 +47,13 @@ public void decorate(Chunk chunk){ random.setSeed(chunkSeed); parameterBase = new Parameters(biome, random, chunk, this); - BlockSand.fallInstantly = true; + BlockLogicSand.fallInstantly = true; + world.scheduledUpdatesAreImmediate = true; decorateAPI(); - BlockSand.fallInstantly = false; + BlockLogicSand.fallInstantly = false; + world.scheduledUpdatesAreImmediate = false; } @ApiStatus.Internal public abstract void decorateAPI(); @@ -72,8 +74,8 @@ public void generateWithChancesUnderground(WorldFeature worldFeature, float chan generateWithChancesUnderground(worldFeature, chances, rangeY, x, z, 0, 0, random); } @ApiStatus.Internal - public void generateWithChancesUnderground(Function featureFunction, Parameters parameters, float chances, int rangeY, int x, int z, Random random){ - generateWithChancesUnderground(featureFunction, parameters, chances, rangeY, x, z, 0, 0, random); + public void generateWithChancesUnderground(Function featureFunction, Parameters parameters, float chances, int startingY, int endingY, int x, int z, Random random){ + generateWithChancesUnderground(featureFunction, parameters, chances, startingY, endingY, x, z, 0, 0, random); } /** @@ -86,16 +88,17 @@ public void generateWithChancesUnderground(WorldFeature worldFeature, float chan int posX = x + random.nextInt(16) + xOff; int posY = minY + random.nextInt(rangeY); int posZ = z + random.nextInt(16) + zOff; - worldFeature.generate(world, random, posX, posY, posZ); + worldFeature.place(world, random, posX, posY, posZ); } } @ApiStatus.Internal - public void generateWithChancesUnderground(Function featureFunction, Parameters parameters, float chances, int rangeY, int x, int z, int xOff, int zOff, Random random){ + public void generateWithChancesUnderground(Function featureFunction, Parameters parameters, float chances, int startingY, int endingY, int x, int z, int xOff, int zOff, Random random){ for (int i = 0; i < chances; i++) { int posX = x + random.nextInt(16) + xOff; - int posY = minY + random.nextInt(rangeY); + int offset = endingY - startingY >= 1 ? random.nextInt(endingY - startingY) : 0; + int posY = minY + startingY + offset; int posZ = z + random.nextInt(16) + zOff; - featureFunction.apply(parameters).generate(world, random, posX, posY, posZ); + featureFunction.apply(parameters).place(world, random, posX, posY, posZ); } } /** @@ -120,7 +123,7 @@ public void generateWithChancesSurface(WorldFeature worldFeature, float chances, int posX = x + random.nextInt(16) + xOff; int posZ = z + random.nextInt(16) + zOff; int posY = this.world.getHeightValue(posX, posZ); - worldFeature.generate(world, random, posX, posY, posZ); + worldFeature.place(world, random, posX, posY, posZ); } } @ApiStatus.Internal @@ -129,7 +132,7 @@ public void generateWithChancesSurface(Function featur int posX = x + random.nextInt(16) + xOff; int posZ = z + random.nextInt(16) + zOff; int posY = this.world.getHeightValue(posX, posZ); - featureFunction.apply(parameters).generate(world, random, posX, posY, posZ); + featureFunction.apply(parameters).place(world, random, posX, posY, posZ); } } @ApiStatus.Internal @@ -140,10 +143,10 @@ public void freezeSurface(int x, int z){ int dy = this.world.getHeightValue(dx, dz); Biome localBiome = this.world.getBlockBiome(dx, dy, dz); if ((localBiome.hasSurfaceSnow() || this.world.worldType == WorldTypes.OVERWORLD_WINTER) && dy > 0 && dy < this.world.getHeightBlocks() && this.world.isAirBlock(dx, dy, dz) && this.world.getBlockMaterial(dx, dy - 1, dz).blocksMotion()) { - this.world.setBlockWithNotify(dx, dy, dz, Block.layerSnow.id); + this.world.setBlockWithNotify(dx, dy, dz, Blocks.LAYER_SNOW.id()); } - if (!localBiome.hasSurfaceSnow() && this.world.worldType != WorldTypes.OVERWORLD_WINTER || this.world.getBlockId(dx, oceanY - 1, dz) != Block.fluidWaterStill.id && this.world.getBlockId(dx, oceanY - 1, dz) != Block.fluidWaterFlowing.id) continue; - this.world.setBlockWithNotify(dx, oceanY - 1, dz, Block.ice.id); + if (!localBiome.hasSurfaceSnow() && this.world.worldType != WorldTypes.OVERWORLD_WINTER || this.world.getBlockId(dx, oceanY - 1, dz) != Blocks.FLUID_WATER_STILL.id() && this.world.getBlockId(dx, oceanY - 1, dz) != Blocks.FLUID_WATER_FLOWING.id()) continue; + this.world.setBlockWithNotify(dx, oceanY - 1, dz, Blocks.ICE.id()); } } } diff --git a/src/main/java/useless/terrainapi/generation/floating/api/ChunkGeneratorFloatingAPI.java b/src/main/java/useless/terrainapi/generation/floating/api/ChunkGeneratorFloatingAPI.java index 7bcf957..05dd0bc 100644 --- a/src/main/java/useless/terrainapi/generation/floating/api/ChunkGeneratorFloatingAPI.java +++ b/src/main/java/useless/terrainapi/generation/floating/api/ChunkGeneratorFloatingAPI.java @@ -1,7 +1,7 @@ package useless.terrainapi.generation.floating.api; import net.minecraft.core.world.World; -import net.minecraft.core.world.generate.MapGenCaves; +import net.minecraft.core.world.generate.CavesLargeFeature; import net.minecraft.core.world.generate.chunk.perlin.ChunkGeneratorPerlin; import net.minecraft.core.world.generate.chunk.perlin.overworld.SurfaceGeneratorOverworld; import net.minecraft.core.world.generate.chunk.perlin.paradise.TerrainGeneratorParadise; @@ -9,6 +9,6 @@ public class ChunkGeneratorFloatingAPI extends ChunkGeneratorPerlin { public ChunkGeneratorFloatingAPI(World world) { - super(world, new ChunkDecoratorOverworldAPI(world), new TerrainGeneratorParadise(world), new SurfaceGeneratorOverworld(world), new MapGenCaves(false)); + super(world, new ChunkDecoratorOverworldAPI(world), new TerrainGeneratorParadise(world), new SurfaceGeneratorOverworld(world), new CavesLargeFeature[]{new CavesLargeFeature()}); } } diff --git a/src/main/java/useless/terrainapi/generation/hell/HellFunctions.java b/src/main/java/useless/terrainapi/generation/hell/HellFunctions.java index 9ebb35f..ba85d5c 100644 --- a/src/main/java/useless/terrainapi/generation/hell/HellFunctions.java +++ b/src/main/java/useless/terrainapi/generation/hell/HellFunctions.java @@ -32,7 +32,7 @@ public static Void generateLabyrinths(Parameters parameters){ } if (parameters.random.nextInt(512) != 0) continue; Random lRand = parameters.chunk.getChunkRandom(75644760L); - new WorldFeatureLabyrinth().generate(parameters.decorator.world, lRand, xPos, yPos, zPos); + new WorldFeatureLabyrinth().place(parameters.decorator.world, lRand, xPos, yPos, zPos); } return null; } @@ -50,7 +50,7 @@ public static Void generateRandomFluid(Parameters parameters){ int blockX = x + parameters.random.nextInt(16) + 8; int blockY = parameters.decorator.minY + parameters.random.nextInt(parameters.random.nextInt(parameters.decorator.rangeY - 8) + 8); int blockZ = z + parameters.random.nextInt(16) + 8; - new WorldFeatureLiquid(fluidId).generate(parameters.decorator.world, parameters.random, blockX, blockY, blockZ); + new WorldFeatureLiquid(fluidId).place(parameters.decorator.world, parameters.random, blockX, blockY, blockZ); } return null; } @@ -68,7 +68,7 @@ public static Void generateLavaLakeFeature(Parameters parameters){ int yf = parameters.decorator.minY + parameters.random.nextInt(parameters.decorator.rangeY); int zf = z + parameters.random.nextInt(16) + 8; if (yf < parameters.decorator.minY + parameters.decorator.rangeY / 2 || parameters.random.nextInt(10) == 0) { - new WorldFeatureLake(Block.fluidLavaStill.id).generate(parameters.decorator.world, parameters.random, xf, yf, zf); + new WorldFeatureLake(Block.fluidLavaStill.id).place(parameters.decorator.world, parameters.random, xf, yf, zf); } } return null; @@ -87,9 +87,9 @@ public static Void generateObsidianLakeFeature(Parameters parameters){ int j8 = z + parameters.random.nextInt(16) + 8; if (i5 < parameters.decorator.minY + parameters.decorator.rangeY / 2 || parameters.random.nextInt(10) == 0) { if (parameters.random.nextInt(4) == 0) { - new WorldFeatureLake(Block.obsidian.id).generate(parameters.decorator.world, parameters.random, j1, i5, j8); + new WorldFeatureLake(Block.obsidian.id).place(parameters.decorator.world, parameters.random, j1, i5, j8); } else { - new WorldFeatureLake(Block.fluidLavaStill.id).generate(parameters.decorator.world, parameters.random, j1, i5, j8); + new WorldFeatureLake(Block.fluidLavaStill.id).place(parameters.decorator.world, parameters.random, j1, i5, j8); } } } @@ -135,7 +135,7 @@ public static Void generateTrees(Parameters parameters){ int xf = x + parameters.random.nextInt(16) + 8; int zf = z + parameters.random.nextInt(16) + 8; int yf = parameters.decorator.world.getHeightValue(xf, zf); - getTreeFeature(parameters).generate(parameters.decorator.world, parameters.random, xf, yf, zf); + getTreeFeature(parameters).place(parameters.decorator.world, parameters.random, xf, yf, zf); } return null; } diff --git a/src/main/java/useless/terrainapi/generation/hell/api/ChunkDecoratorOverworldHellAPI.java b/src/main/java/useless/terrainapi/generation/hell/api/ChunkDecoratorOverworldHellAPI.java index 3a36605..c979ad3 100644 --- a/src/main/java/useless/terrainapi/generation/hell/api/ChunkDecoratorOverworldHellAPI.java +++ b/src/main/java/useless/terrainapi/generation/hell/api/ChunkDecoratorOverworldHellAPI.java @@ -41,8 +41,8 @@ public void decorateAPI() { generateBiomeFeature(parameterBase.biome,xCoord, zCoord, parameterBase.random, parameterBase.chunk); generateRandomFeatures(parameterBase.biome,xCoord, zCoord, parameterBase.random, parameterBase.chunk); - if (this.world.getBlockId(xCoord, minY + this.world.getWorldType().getOceanY() - 1, zCoord) == this.world.getWorldType().getOceanBlock()) { - this.world.setBlockWithNotify(xCoord, minY + this.world.getWorldType().getOceanY() - 1, zCoord, this.world.getWorldType().getOceanBlock()); + if (this.world.getBlockId(xCoord, minY + this.world.getWorldType().getOceanY() - 1, zCoord) == this.world.getWorldType().getOceanY()) { + this.world.setBlockWithNotify(xCoord, minY + this.world.getWorldType().getOceanY() - 1, zCoord, this.world.getWorldType().getOceanBlockId()); } } @ApiStatus.Internal @@ -60,10 +60,11 @@ public void generateOreFeatures(Biome biome, int x, int z, Random random, Chunk int density = oreFeatures.densityFunctionsList.get(i) .apply(new Parameters(parameterBase, oreFeatures.densityParametersList.get(i))); - float rangeModifier = oreFeatures.rangeModifierList.get(i); + float startingRange = oreFeatures.startingRangeList.get(i); + float endingRange = oreFeatures.endingRangeList.get(i); generateWithChancesUnderground(oreFeatures.featureFunctionsList.get(i), new Parameters(parameterBase, oreFeatures.featureParametersList.get(i)), - density, (int) (rangeModifier * rangeY), x, z, random); + density, (int) (startingRange * rangeY), (int) (endingRange * rangeY), x, z, random); } } @ApiStatus.Internal @@ -76,15 +77,16 @@ public void generateRandomFeatures(Biome biome, int x, int z, Random random, Chu int density = randomFeatures.densityFunctionsList.get(i) .apply(new Parameters(parameterBase, randomFeatures.densityParametersList.get(i))); - float rangeModifier = randomFeatures.rangeModifierList.get(i); - if (-1.01 <= rangeModifier && rangeModifier <= -0.99){ + float startingRange = randomFeatures.startingRangeList.get(i); + float endingRange = randomFeatures.endingRangeList.get(i); + if (-1.01 <= startingRange && startingRange <= -0.99 || -1.01 <= endingRange && endingRange <= -0.99){ generateWithChancesSurface(featureFunction, new Parameters(parameterBase, randomFeatures.featureParametersList.get(i)), density, x, z, 8, 8, random); } else { generateWithChancesUnderground(featureFunction, new Parameters(parameterBase, randomFeatures.featureParametersList.get(i)), - density, (int) (rangeModifier * rangeY), x, z, 8, 8, random); + density, (int) (startingRange * rangeY), (int) (endingRange * rangeY), x, z, 8, 8, random); } } } @@ -97,15 +99,16 @@ public void generateBiomeFeature(Biome biome, int x, int z, Random random, Chunk int density = biomeFeatures.densityFunctionsList.get(i) .apply(new Parameters(parameterBase, biomeFeatures.densityParametersList.get(i))); - float rangeModifier = biomeFeatures.rangeModifierList.get(i); - if (-1.01 <= rangeModifier && rangeModifier <= -0.99){ + float startingRange = biomeFeatures.startingRangeList.get(i); + float endingRange = biomeFeatures.endingRangeList.get(i); + if (-1.01 <= startingRange && startingRange <= -0.99 || -1.01 <= endingRange && endingRange <= -0.99){ generateWithChancesSurface(featureFunction, new Parameters(parameterBase, biomeFeatures.featureParametersList.get(i)), density, x, z, 8, 8, random); } else { generateWithChancesUnderground(featureFunction, new Parameters(parameterBase, biomeFeatures.featureParametersList.get(i)), - density, (int) (rangeModifier * rangeY), x, z, 8, 8, random); + density, (int) (startingRange * rangeY), (int) (endingRange * rangeY), x, z, 8, 8, random); } } } diff --git a/src/main/java/useless/terrainapi/generation/hell/api/ChunkGeneratorOverworldHellAPI.java b/src/main/java/useless/terrainapi/generation/hell/api/ChunkGeneratorOverworldHellAPI.java index e2de6e0..355e7a5 100644 --- a/src/main/java/useless/terrainapi/generation/hell/api/ChunkGeneratorOverworldHellAPI.java +++ b/src/main/java/useless/terrainapi/generation/hell/api/ChunkGeneratorOverworldHellAPI.java @@ -1,13 +1,13 @@ package useless.terrainapi.generation.hell.api; import net.minecraft.core.world.World; -import net.minecraft.core.world.generate.MapGenCaves; +import net.minecraft.core.world.generate.CavesLargeFeature; import net.minecraft.core.world.generate.chunk.perlin.ChunkGeneratorPerlin; import net.minecraft.core.world.generate.chunk.perlin.overworld.SurfaceGeneratorOverworld; import net.minecraft.core.world.generate.chunk.perlin.overworld.TerrainGeneratorOverworld; public class ChunkGeneratorOverworldHellAPI extends ChunkGeneratorPerlin { public ChunkGeneratorOverworldHellAPI(World world) { - super(world, new ChunkDecoratorOverworldHellAPI(world), new TerrainGeneratorOverworld(world), new SurfaceGeneratorOverworld(world), new MapGenCaves(false)); + super(world, new ChunkDecoratorOverworldHellAPI(world), new TerrainGeneratorOverworld(world), new SurfaceGeneratorOverworld(world), new CavesLargeFeature[]{new CavesLargeFeature()}); } } diff --git a/src/main/java/useless/terrainapi/generation/nether/api/ChunkDecoratorNetherAPI.java b/src/main/java/useless/terrainapi/generation/nether/api/ChunkDecoratorNetherAPI.java index 32ed41a..263d841 100644 --- a/src/main/java/useless/terrainapi/generation/nether/api/ChunkDecoratorNetherAPI.java +++ b/src/main/java/useless/terrainapi/generation/nether/api/ChunkDecoratorNetherAPI.java @@ -1,17 +1,17 @@ package useless.terrainapi.generation.nether.api; -import net.minecraft.core.block.BlockSand; +import net.minecraft.core.block.BlockLogicSand; import net.minecraft.core.world.World; import net.minecraft.core.world.biome.Biome; import net.minecraft.core.world.chunk.Chunk; import net.minecraft.core.world.generate.feature.WorldFeature; import org.jetbrains.annotations.ApiStatus; import useless.terrainapi.config.ConfigManager; -import useless.terrainapi.generation.nether.NetherConfig; import useless.terrainapi.generation.ChunkDecoratorAPI; import useless.terrainapi.generation.Parameters; import useless.terrainapi.generation.StructureFeatures; import useless.terrainapi.generation.nether.NetherBiomeFeatures; +import useless.terrainapi.generation.nether.NetherConfig; import useless.terrainapi.generation.nether.NetherOreFeatures; import useless.terrainapi.generation.nether.NetherRandomFeatures; @@ -44,9 +44,9 @@ public void decorate(Chunk chunk) { parameterBase = new Parameters(biome, random, chunk, this); - BlockSand.fallInstantly = true; + BlockLogicSand.fallInstantly = true; decorateAPI(); - BlockSand.fallInstantly = false; + BlockLogicSand.fallInstantly = false; } @Override @@ -75,10 +75,11 @@ public void generateOreFeatures(Biome biome, int x, int z, Random random, Chunk int density = oreFeatures.densityFunctionsList.get(i) .apply(new Parameters(parameterBase, oreFeatures.densityParametersList.get(i))); - float rangeModifier = oreFeatures.rangeModifierList.get(i); + float startingRange = oreFeatures.startingRangeList.get(i); + float endingRange = oreFeatures.endingRangeList.get(i); generateWithChancesUnderground(oreFeatures.featureFunctionsList.get(i), new Parameters(parameterBase, oreFeatures.featureParametersList.get(i)), - density, (int) (rangeModifier * rangeY), x, z, random); + density, (int) (startingRange * rangeY), (int) (endingRange * rangeY), x, z, random); } } @ApiStatus.Internal @@ -91,15 +92,16 @@ public void generateRandomFeatures(Biome biome, int x, int z, Random random, Chu int density = randomFeatures.densityFunctionsList.get(i) .apply(new Parameters(parameterBase, randomFeatures.densityParametersList.get(i))); - float rangeModifier = randomFeatures.rangeModifierList.get(i); - if (-1.01 <= rangeModifier && rangeModifier <= -0.99){ + float startingRange = randomFeatures.startingRangeList.get(i); + float endingRange = randomFeatures.endingRangeList.get(i); + if (-1.01 <= startingRange && startingRange <= -0.99 || -1.01 <= endingRange && endingRange <= -0.99){ generateWithChancesSurface(featureFunction, new Parameters(parameterBase, randomFeatures.featureParametersList.get(i)), density, x, z, 8, 8, random); } else { generateWithChancesUnderground(featureFunction, new Parameters(parameterBase, randomFeatures.featureParametersList.get(i)), - density, (int) (rangeModifier * rangeY), x, z, 8, 8, random); + density, (int) (startingRange * rangeY), (int) (endingRange * rangeY), x, z, 8, 8, random); } } } @@ -112,15 +114,16 @@ public void generateBiomeFeature(Biome biome, int x, int z, Random random, Chunk int density = biomeFeatures.densityFunctionsList.get(i) .apply(new Parameters(parameterBase, biomeFeatures.densityParametersList.get(i))); - float rangeModifier = biomeFeatures.rangeModifierList.get(i); - if (-1.01 <= rangeModifier && rangeModifier <= -0.99){ + float startingRange = biomeFeatures.startingRangeList.get(i); + float endingRange = biomeFeatures.endingRangeList.get(i); + if (-1.01 <= startingRange && startingRange <= -0.99 || -1.01 <= endingRange && endingRange <= -0.99){ generateWithChancesSurface(featureFunction, new Parameters(parameterBase, biomeFeatures.featureParametersList.get(i)), density, x, z, 8, 8, random); } else { generateWithChancesUnderground(featureFunction, new Parameters(parameterBase, biomeFeatures.featureParametersList.get(i)), - density, (int) (rangeModifier * rangeY), x, z, 8, 8, random); + density, (int) (startingRange * rangeY), (int) (endingRange * rangeY), x, z, 8, 8, random); } } } diff --git a/src/main/java/useless/terrainapi/generation/nether/api/ChunkGeneratorNetherAPI.java b/src/main/java/useless/terrainapi/generation/nether/api/ChunkGeneratorNetherAPI.java index 4f9de65..1e53f02 100644 --- a/src/main/java/useless/terrainapi/generation/nether/api/ChunkGeneratorNetherAPI.java +++ b/src/main/java/useless/terrainapi/generation/nether/api/ChunkGeneratorNetherAPI.java @@ -1,13 +1,13 @@ package useless.terrainapi.generation.nether.api; import net.minecraft.core.world.World; -import net.minecraft.core.world.generate.MapGenCavesHell; +import net.minecraft.core.world.generate.CavesLargeFeature; import net.minecraft.core.world.generate.chunk.perlin.ChunkGeneratorPerlin; import net.minecraft.core.world.generate.chunk.perlin.nether.SurfaceGeneratorNether; import net.minecraft.core.world.generate.chunk.perlin.nether.TerrainGeneratorNether; public class ChunkGeneratorNetherAPI extends ChunkGeneratorPerlin { public ChunkGeneratorNetherAPI(World world) { - super(world, new ChunkDecoratorNetherAPI(world), new TerrainGeneratorNether(world), new SurfaceGeneratorNether(world), new MapGenCavesHell()); + super(world, new ChunkDecoratorNetherAPI(world), new TerrainGeneratorNether(world), new SurfaceGeneratorNether(world), new CavesLargeFeature[]{new CavesLargeFeature()}); } } diff --git a/src/main/java/useless/terrainapi/generation/overworld/OverworldBiomeFeatures.java b/src/main/java/useless/terrainapi/generation/overworld/OverworldBiomeFeatures.java index aa31173..200d13a 100644 --- a/src/main/java/useless/terrainapi/generation/overworld/OverworldBiomeFeatures.java +++ b/src/main/java/useless/terrainapi/generation/overworld/OverworldBiomeFeatures.java @@ -12,7 +12,9 @@ public class OverworldBiomeFeatures extends GeneratorFeatures { @ApiStatus.Internal - public List rangeModifierList = new ArrayList<>(); + public List startingRangeList = new ArrayList<>(); + @ApiStatus.Internal + public List endingRangeList = new ArrayList<>(); /**Adds a world feature entry * @param feature WorldFeature to generate @@ -41,7 +43,20 @@ public void addFeature(WorldFeature feature, float rangeModifier, int chances, B * @param rangeModifier Fraction of the world from the bottom to the surface to generate inside, a value of -1 indicates to spawn on the surface only */ public void addFeature(Function featureFunction, Object[] featureParameters, Function densityFunction, Object[] densityParameters, float rangeModifier){ + addFeature(featureFunction, featureParameters, densityFunction, densityParameters, 0, rangeModifier); + } + + /**Adds a world feature entry + * @param featureFunction Function that takes a Parameters object and returns a WorldFeature + * @param featureParameters Object[] of additional parameters that will be included with the Parameters object passed into the feature function + * @param densityFunction Function that takes a Parameters object and returns an Integer representing the number of attempts per chunk + * @param densityParameters Object[] of additional parameters that will be included with the Parameters object passed into the density function + * @param startingRange Fraction of the world from the bottom to the surface to generate inside, a value of -1 indicates to spawn on the surface only + * @param endingRange Fraction of the world from the bottom to the surface to generate inside, a value of -1 indicates to spawn on the surface only + */ + public void addFeature(Function featureFunction, Object[] featureParameters, Function densityFunction, Object[] densityParameters, float startingRange, float endingRange){ super.addFeature(featureFunction, featureParameters, densityFunction, densityParameters); - rangeModifierList.add(rangeModifier); + startingRangeList.add(startingRange); + endingRangeList.add(endingRange); } } diff --git a/src/main/java/useless/terrainapi/generation/overworld/OverworldConfig.java b/src/main/java/useless/terrainapi/generation/overworld/OverworldConfig.java index 852967f..f2b0e03 100644 --- a/src/main/java/useless/terrainapi/generation/overworld/OverworldConfig.java +++ b/src/main/java/useless/terrainapi/generation/overworld/OverworldConfig.java @@ -6,10 +6,10 @@ import net.minecraft.core.data.registry.Registries; import net.minecraft.core.world.biome.Biome; import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; import useless.terrainapi.config.OreConfig; import useless.terrainapi.util.Utilities; -import javax.annotation.Nullable; import java.util.HashMap; public class OverworldConfig extends OreConfig { @@ -18,18 +18,44 @@ public class OverworldConfig extends OreConfig { @Expose @SerializedName(value = "Grass Density") public HashMap grassDensityMap = new HashMap<>(); @Expose @SerializedName(value = "Flower Density") + @Deprecated public HashMap flowerDensityMap = new HashMap<>(); @Expose @SerializedName(value = "Yellow Flower Density") + @Deprecated public HashMap yellowFlowerDensityMap = new HashMap<>(); @Expose @SerializedName(value = "Tree Density") public HashMap treeDensityMap = new HashMap<>(); @Expose @SerializedName(value = "Lake Density") public HashMap lakeDensityMap = new HashMap<>(); + @Expose @SerializedName(value = "World Feature Chance") + public HashMap featureChanceMap = new HashMap<>(); public int defaultLakeDensity = 4; + /** Specifies the inverse of the chance of a world feature via key + */ + public void addFeatureChance(String modId, String key, int chanceINV) { + if (getConfigOverride() && getFeatureChance(modId, key) != null){ + return; + } + featureChanceMap.put(modId + ":" + key, chanceINV); + } + /** + * @return the inverse of the chance of a world feature via key + */ + @Nullable + public Integer getFeatureChance(String modId, String key){ + return featureChanceMap.get(modId + ":" + key); + } + /** + * @return the inverse of the chance of a world feature via key + */ + public int getFeatureChanceOrDefault(String modId, String key, int defaultValue){ + return featureChanceMap.getOrDefault(modId + ":" + key, defaultValue); + } + /**Specifies the block to randomly replace some grass with in the specified biome */ - public void addRandomGrassBlock(Biome biome, Block block) { + public void addRandomGrassBlocks(Biome biome, Block block) { if (getConfigOverride() && getRandomGrassBlock(biome) != null){ return; } @@ -40,7 +66,7 @@ public void addRandomGrassBlock(Biome biome, Block block) { * @return Biome's random grass block, returns null if there is no entry for the biome */ @Nullable - public Block getRandomGrassBlock(Biome biome){ + public Block getRandomGrassBlock(Biome biome){ return Utilities.getBlock(biomeRandomGrassBlock.get(Registries.BIOMES.getKey(biome))); } @@ -48,8 +74,8 @@ public Block getRandomGrassBlock(Biome biome){ * @return Biome's random grass block, returns defaultValue if there is no entry for the biome */ @NotNull - public Block getRandomGrassBlock(Biome biome, Block defaultValue){ - Block returnBlock = Utilities.getBlock(biomeRandomGrassBlock.get(Registries.BIOMES.getKey(biome))); + public Block getRandomGrassBlock(Biome biome, Block defaultValue){ + Block returnBlock = Utilities.getBlock(biomeRandomGrassBlock.get(Registries.BIOMES.getKey(biome))); if (returnBlock == null){ returnBlock = defaultValue; } @@ -81,8 +107,10 @@ public Integer getGrassDensity(Biome biome, int defaultValue){ return grassDensityMap.getOrDefault(Registries.BIOMES.getKey(biome), defaultValue); } - /**Specifies the number of chances for red/yellow flowers patches to spawn for the specified biome + /** + * @deprecated As of BTA 7.2 flower generation has changed in such a way where using maps for each flower density is impractical */ + @Deprecated public void addFlowerDensity(Biome biome, int density){ if (getConfigOverride() && getFlowerDensity(biome) != null){ return; @@ -91,23 +119,27 @@ public void addFlowerDensity(Biome biome, int density){ } /** - * @return Biome's red/yellow density, returns null if there is no entry for the biome + * @deprecated As of BTA 7.2 flower generation has changed in such a way where using maps for each flower density is impractical */ + @Deprecated @Nullable public Integer getFlowerDensity(Biome biome){ return flowerDensityMap.get(Registries.BIOMES.getKey(biome)); } /** - * @return Biome's red/yellow density, returns defaultValue if there is no entry for the biome + * @deprecated As of BTA 7.2 flower generation has changed in such a way where using maps for each flower density is impractical */ + @Deprecated @NotNull public Integer getFlowerDensity(Biome biome, int defaultValue){ return flowerDensityMap.getOrDefault(Registries.BIOMES.getKey(biome), defaultValue); } - /**Specifies the number of chances for yellow flowers to spawn for the specified biome + /** + * @deprecated As of BTA 7.2 flower generation has changed in such a way where using maps for each flower density is impractical */ + @Deprecated public void addYellowFlowerDensity(Biome biome, int density){ if (getConfigOverride() && getYellowFlowerDensity(biome) != null){ return; @@ -116,16 +148,19 @@ public void addYellowFlowerDensity(Biome biome, int density){ } /** - * @return Biome's yellow flower density, returns null if there is no entry for the biome + * @deprecated As of BTA 7.2 flower generation has changed in such a way where using maps for each flower density is impractical */ + @Deprecated + @Nullable public Integer getYellowFlowerDensity(Biome biome){ return yellowFlowerDensityMap.get(Registries.BIOMES.getKey(biome)); } /** - * @return Biome's yellow flower density, returns defaultValue if there is no entry for the biome + * @deprecated As of BTA 7.2 flower generation has changed in such a way where using maps for each flower density is impractical */ + @Deprecated @NotNull public Integer getYellowFlowerDensity(Biome biome, int defaultValue){ return yellowFlowerDensityMap.getOrDefault(Registries.BIOMES.getKey(biome), defaultValue); diff --git a/src/main/java/useless/terrainapi/generation/overworld/OverworldFunctions.java b/src/main/java/useless/terrainapi/generation/overworld/OverworldFunctions.java index 41da05c..33c0764 100644 --- a/src/main/java/useless/terrainapi/generation/overworld/OverworldFunctions.java +++ b/src/main/java/useless/terrainapi/generation/overworld/OverworldFunctions.java @@ -1,6 +1,7 @@ package useless.terrainapi.generation.overworld; import net.minecraft.core.block.Block; +import net.minecraft.core.block.Blocks; import net.minecraft.core.block.material.Material; import net.minecraft.core.world.biome.Biome; import net.minecraft.core.world.biome.Biomes; @@ -21,7 +22,7 @@ public class OverworldFunctions { */ public static WorldFeature getTreeFeature(Parameters parameters){ WorldFeature treeFeature = parameters.biome.getRandomWorldGenForTrees(parameters.random); - treeFeature.func_517_a(1.0, 1.0, 1.0); + treeFeature.init(1.0, 1.0, 1.0); return treeFeature; } @@ -62,20 +63,20 @@ public static int getTreeDensity(Parameters parameters){ * @return Randomly returns tall grass or the random grass for the biome as specified in the OverworldConfig biomeRandomGrassBlock hashmap */ public static WorldFeature grassTypeCondition(Parameters parameters){ - Block block = Block.tallgrass; + Block block = Blocks.TALLGRASS; if (Utilities.checkForBiomeInBiomes(parameters.biome, overworldConfig.biomeRandomGrassBlock.keySet().toArray(new String[0])) && parameters.random.nextInt(3) != 0) { block = overworldConfig.getRandomGrassBlock(parameters.biome, block); } - return new WorldFeatureTallGrass(block.id); + return new WorldFeatureTallGrass(block.id()); } /**Vanilla flower feature generator * @param parameters Parameters Container * @return Randomly returns yellow or red flower features */ public static WorldFeature flowerTypeCondition(Parameters parameters){ - int blockId = Block.flowerYellow.id; + int blockId = Blocks.FLOWER_YELLOW.id(); if (parameters.random.nextInt(3) != 0) { - blockId = Block.flowerRed.id; + blockId = Blocks.FLOWER_RED.id(); } return new WorldFeatureTallGrass(blockId); } @@ -121,9 +122,9 @@ public static Void generateDungeons(Parameters parameters){ int yPos = parameters.decorator.minY + parameters.random.nextInt(parameters.decorator.rangeY); int zPos = z + parameters.random.nextInt(16) + 8; if (parameters.random.nextInt(2) == 0){ - new WorldFeatureDungeon(Block.brickClay.id, Block.brickClay.id, null).generate(parameters.decorator.world, parameters.random, xPos, yPos, zPos); + new WorldFeatureDungeon(Blocks.BRICK_CLAY.id(), Blocks.BRICK_CLAY.id(), null).place(parameters.decorator.world, parameters.random, xPos, yPos, zPos); } else { - new WorldFeatureDungeon(Block.cobbleStone.id, Block.cobbleStoneMossy.id, null).generate(parameters.decorator.world, parameters.random, xPos, yPos, zPos); + new WorldFeatureDungeon(Blocks.COBBLE_STONE.id(), Blocks.COBBLE_STONE_MOSSY.id(), null).place(parameters.decorator.world, parameters.random, xPos, yPos, zPos); } } return null; @@ -144,9 +145,9 @@ public static Void generateLabyrinths(Parameters parameters){ if (parameters.random.nextInt(5) == 0) { yPos -= parameters.random.nextInt(10) + 30; } - if (parameters.random.nextInt(700) != 0) continue; + if (parameters.random.nextInt((int)parameters.customParameters[0]) != 0) continue; Random lRand = parameters.chunk.getChunkRandom(75644760L); - new WorldFeatureLabyrinth().generate(parameters.decorator.world, lRand, xPos, yPos, zPos); + new WorldFeatureLabyrinth().place(parameters.decorator.world, lRand, xPos, yPos, zPos); } return null; } @@ -168,7 +169,7 @@ public static Void generateSwamp(Parameters parameters){ int topBlock = parameters.decorator.world.getHeightValue(x + dx, z + dz); int id = parameters.decorator.world.getBlockId(x + dx, topBlock - 1, z + dz); - if (id != Block.grass.id) continue; + if (id != Blocks.GRASS.id()) continue; int posXId = parameters.decorator.world.getBlockId(x + dx + 1, topBlock - 1, z + dz); if (posXId == 0) continue; @@ -181,12 +182,12 @@ public static Void generateSwamp(Parameters parameters){ int negYId = parameters.decorator.world.getBlockId(x + dx, topBlock - 2, z + dz); if (negYId == 0) continue; - if ((!Block.blocksList[posXId].blockMaterial.isSolid() && Block.blocksList[posXId].blockMaterial != Material.water) - || (!Block.blocksList[negXId].blockMaterial.isSolid() && Block.blocksList[negXId].blockMaterial != Material.water) - || (!Block.blocksList[posZId].blockMaterial.isSolid() && Block.blocksList[posZId].blockMaterial != Material.water) - || (!Block.blocksList[negZId].blockMaterial.isSolid() && Block.blocksList[negZId].blockMaterial != Material.water) - || !Block.blocksList[negYId].blockMaterial.isSolid()) continue; - parameters.decorator.world.setBlock(x + dx, topBlock - 1, z + dz, Block.fluidWaterStill.id); + if ((!Blocks.blocksList[posXId].getMaterial().isSolid() && Blocks.blocksList[posXId].getMaterial() != Material.water) + || (!Blocks.blocksList[negXId].getMaterial().isSolid() && Blocks.blocksList[negXId].getMaterial() != Material.water) + || (!Blocks.blocksList[posZId].getMaterial().isSolid() && Blocks.blocksList[posZId].getMaterial() != Material.water) + || (!Blocks.blocksList[negZId].getMaterial().isSolid() && Blocks.blocksList[negZId].getMaterial() != Material.water) + || !Blocks.blocksList[negYId].getMaterial().isSolid()) continue; + parameters.decorator.world.setBlock(x + dx, topBlock - 1, z + dz, Blocks.FLUID_WATER_STILL.id()); parameters.decorator.world.setBlock(x + dx, topBlock, z + dz, 0); } } @@ -203,14 +204,14 @@ public static Void generateLakeFeature(Parameters parameters){ int z = parameters.chunk.zPosition * 16; if (lakeChance != 0 && parameters.random.nextInt(lakeChance) == 0) { - int fluid = Block.fluidWaterStill.id; + int fluid = Blocks.FLUID_WATER_STILL.id(); if (parameters.biome.hasSurfaceSnow()) { - fluid = Block.ice.id; + fluid = Blocks.ICE.id(); } int xf = x + parameters.random.nextInt(16) + 8; int yf = parameters.decorator.minY + parameters.random.nextInt(parameters.decorator.rangeY); int zf = z + parameters.random.nextInt(16) + 8; - new WorldFeatureLake(fluid).generate(parameters.decorator.world, parameters.random, xf, yf, zf); + new WorldFeatureLake(fluid).place(parameters.decorator.world, parameters.random, xf, yf, zf); } return null; } @@ -227,7 +228,7 @@ public static Void generateLavaLakeFeature(Parameters parameters){ int yf = parameters.decorator.minY + parameters.random.nextInt(parameters.random.nextInt(parameters.decorator.rangeY - parameters.decorator.rangeY / 16) + parameters.decorator.rangeY / 16); int zf = z + parameters.random.nextInt(16) + 8; if (yf < parameters.decorator.minY + parameters.decorator.rangeY / 2 || parameters.random.nextInt(10) == 0) { - new WorldFeatureLake(Block.fluidLavaStill.id).generate(parameters.decorator.world, parameters.random, xf, yf, zf); + new WorldFeatureLake(Blocks.FLUID_LAVA_STILL.id()).place(parameters.decorator.world, parameters.random, xf, yf, zf); } } return null; @@ -245,7 +246,7 @@ public static Void generateRandomFluid(Parameters parameters){ int blockX = x + parameters.random.nextInt(16) + 8; int blockY = parameters.decorator.minY + parameters.random.nextInt(parameters.random.nextInt(parameters.decorator.rangeY - 8) + 8); int blockZ = z + parameters.random.nextInt(16) + 8; - new WorldFeatureLiquid(fluidId).generate(parameters.decorator.world, parameters.random, blockX, blockY, blockZ); + new WorldFeatureLiquid(fluidId).place(parameters.decorator.world, parameters.random, blockX, blockY, blockZ); } return null; } @@ -262,7 +263,7 @@ public static Void generateTrees(Parameters parameters){ int xf = x + parameters.random.nextInt(16) + 8; int zf = z + parameters.random.nextInt(16) + 8; int yf = parameters.decorator.world.getHeightValue(xf, zf); - getTreeFeature(parameters).generate(parameters.decorator.world, parameters.random, xf, yf, zf); + getTreeFeature(parameters).place(parameters.decorator.world, parameters.random, xf, yf, zf); } return null; } diff --git a/src/main/java/useless/terrainapi/generation/overworld/OverworldOreFeatures.java b/src/main/java/useless/terrainapi/generation/overworld/OverworldOreFeatures.java index b7fd474..e7f708d 100644 --- a/src/main/java/useless/terrainapi/generation/overworld/OverworldOreFeatures.java +++ b/src/main/java/useless/terrainapi/generation/overworld/OverworldOreFeatures.java @@ -15,7 +15,9 @@ public class OverworldOreFeatures extends GeneratorFeatures { @ApiStatus.Internal - public List rangeModifierList = new ArrayList<>(); + public List startingRangeList = new ArrayList<>(); + @ApiStatus.Internal + public List endingRangeList = new ArrayList<>(); public OreConfig config; public OverworldOreFeatures(OreConfig config){ this.config = config; @@ -48,8 +50,20 @@ public void addFeature(WorldFeature feature, int chances, float rangeModifier, B * @param rangeModifier Fraction of the world from the bottom to the surface to generate inside, a value of -1 indicates to spawn on the surface only */ public void addFeature(Function featureFunction, Object[] featureParameters, Function densityFunction, Object[] densityParameters, float rangeModifier){ + addFeature(featureFunction, featureParameters, densityFunction, densityParameters, 0, rangeModifier); + } + /**Adds a world feature entry + * @param featureFunction Function that takes a Parameters object and returns a WorldFeature + * @param featureParameters Object[] of additional parameters that will be included with the Parameters object passed into the feature function + * @param densityFunction Function that takes a Parameters object and returns an Integer representing the number of attempts per chunk + * @param densityParameters Object[] of additional parameters that will be included with the Parameters object passed into the density function + * @param startingRange Fraction of the world from the bottom to the surface to generate inside, a value of -1 indicates to spawn on the surface only + * @param endingRange Fraction of the world from the bottom to the surface to generate inside, a value of -1 indicates to spawn on the surface only + */ + public void addFeature(Function featureFunction, Object[] featureParameters, Function densityFunction, Object[] densityParameters, float startingRange, float endingRange){ super.addFeature(featureFunction, featureParameters, densityFunction, densityParameters); - rangeModifierList.add(rangeModifier); + startingRangeList.add(startingRange); + endingRangeList.add(endingRange); } /**Adds an WorldFeatureOre, which has its generation characteristics managed by OreConfig @@ -59,7 +73,7 @@ public void addFeature(Function featureFunction, Objec * @param defaultRange Value from [0, 1], it's the default fraction from the bottom of the world to the surface that the ore can generate * @param hasStoneStates Does ore have states for each stone type */ - public void addManagedOreFeature(String modID, Block block, int defaultClusterSize, int defaultChances, float defaultRange, boolean hasStoneStates){ + public void addManagedOreFeature(String modID, Block block, int defaultClusterSize, int defaultChances, float defaultRange, boolean hasStoneStates){ config.setOreValues(modID, block, defaultClusterSize, defaultChances, defaultRange); addManagedOreFeature(block, hasStoneStates); } @@ -68,8 +82,23 @@ public void addManagedOreFeature(String modID, Block block, int defaultClusterSi * @param block Ore to generate * @param hasStoneStates Does ore have states for each stone type */ - public void addManagedOreFeature(Block block, boolean hasStoneStates){ + public void addManagedOreFeature(Block block, boolean hasStoneStates){ String currentBlock = block.getKey(); - addFeature(new WorldFeatureOre(block.id, config.clusterSize.get(currentBlock), hasStoneStates), config.chancesPerChunk.get(currentBlock), config.verticalRange.get(currentBlock)); + addFeature((Parameters x) -> new WorldFeatureOre(block.id(), config.clusterSize.get(currentBlock)), null, + OverworldFunctions::getStandardOreBiomesDensity, new Object[]{config.chancesPerChunk.get(currentBlock), null}, + config.verticalStartingRange.get(currentBlock), config.verticalEndingRange.get(currentBlock)); } + /**Adds an WorldFeatureOre, which has its generation characteristics managed by OreConfig + * @param block Ore to generate + * @param defaultClusterSize Default size in blocks of an ore vein + * @param defaultChances Default number of chances per chunk to generate an ore patch, this values scales with world height + * @param defaultStartingRange Value from [0, 1], it's the default fraction from the bottom of the world to the surface that the ore can generate + * @param defaultEndingRange Value from [0, 1], it's the default fraction from the bottom of the world to the surface that the ore can generate + * @param hasStoneStates Does ore have states for each stone type + */ + public void addManagedOreFeature(String modID, Block block, int defaultClusterSize, int defaultChances, float defaultStartingRange, float defaultEndingRange, boolean hasStoneStates){ + config.setOreValues(modID, block, defaultClusterSize, defaultChances, defaultStartingRange, defaultEndingRange); + addManagedOreFeature(block, hasStoneStates); + } + } diff --git a/src/main/java/useless/terrainapi/generation/overworld/OverworldRandomFeatures.java b/src/main/java/useless/terrainapi/generation/overworld/OverworldRandomFeatures.java index 96b67da..0e1c448 100644 --- a/src/main/java/useless/terrainapi/generation/overworld/OverworldRandomFeatures.java +++ b/src/main/java/useless/terrainapi/generation/overworld/OverworldRandomFeatures.java @@ -12,7 +12,9 @@ public class OverworldRandomFeatures extends GeneratorFeatures { @ApiStatus.Internal - public List rangeModifierList = new ArrayList<>(); + public List startingRangeList = new ArrayList<>(); + @ApiStatus.Internal + public List endingRangeList = new ArrayList<>(); @ApiStatus.Internal public List inverseProbabilityList = new ArrayList<>(); /**Adds a world feature entry, will only generate on the surface @@ -52,8 +54,21 @@ public void addFeature(WorldFeature feature, int inverseProbability, float range * @param rangeModifier Fraction of the world from the bottom to the surface to generate inside, a value of -1 indicates to spawn on the surface only */ public void addFeature(Function featureFunction, Object[] featureParameters, Function densityFunction, Object[] densityParameters, int inverseProbability, float rangeModifier){ + addFeature(featureFunction, featureParameters, densityFunction, densityParameters, inverseProbability, 0, rangeModifier); + } + /**Adds a world feature entry + * @param featureFunction Function that takes a Parameters object and returns a WorldFeature + * @param featureParameters Object[] of additional parameters that will be included with the Parameters object passed into the feature function + * @param densityFunction Function that takes a Parameters object and returns an Integer representing the number of attempts per chunk + * @param densityParameters Object[] of additional parameters that will be included with the Parameters object passed into the density function + * @param inverseProbability Inverse of the probability, example inverseProbability of 2 means a 50% chance + * @param startingRange Fraction of the world from the bottom to the surface to generate inside, a value of -1 indicates to spawn on the surface only + * @param endingRange Fraction of the world from the bottom to the surface to generate inside, a value of -1 indicates to spawn on the surface only + */ + public void addFeature(Function featureFunction, Object[] featureParameters, Function densityFunction, Object[] densityParameters, int inverseProbability, float startingRange, float endingRange){ super.addFeature(featureFunction, featureParameters, densityFunction, densityParameters); - rangeModifierList.add(rangeModifier); + endingRangeList.add(endingRange); + startingRangeList.add(startingRange); inverseProbabilityList.add(inverseProbability); } } diff --git a/src/main/java/useless/terrainapi/generation/overworld/api/ChunkDecoratorOverworldAPI.java b/src/main/java/useless/terrainapi/generation/overworld/api/ChunkDecoratorOverworldAPI.java index 41e05f8..ae7dde8 100644 --- a/src/main/java/useless/terrainapi/generation/overworld/api/ChunkDecoratorOverworldAPI.java +++ b/src/main/java/useless/terrainapi/generation/overworld/api/ChunkDecoratorOverworldAPI.java @@ -61,10 +61,11 @@ public void generateOreFeatures(Biome biome, int x, int z, Random random, Chunk int density = oreFeatures.densityFunctionsList.get(i) .apply(new Parameters(parameterBase, oreFeatures.densityParametersList.get(i))); - float rangeModifier = oreFeatures.rangeModifierList.get(i); + float startingRange = oreFeatures.startingRangeList.get(i); + float endingRange = oreFeatures.endingRangeList.get(i); generateWithChancesUnderground(oreFeatures.featureFunctionsList.get(i), new Parameters(parameterBase, oreFeatures.featureParametersList.get(i)), - density, (int) (rangeModifier * rangeY), x, z, random); + density, (int) (startingRange * rangeY), (int) (endingRange * rangeY), x, z, random); } } @ApiStatus.Internal @@ -77,15 +78,16 @@ public void generateRandomFeatures(Biome biome, int x, int z, Random random, Chu int density = randomFeatures.densityFunctionsList.get(i) .apply(new Parameters(parameterBase, randomFeatures.densityParametersList.get(i))); - float rangeModifier = randomFeatures.rangeModifierList.get(i); - if (-1.01 <= rangeModifier && rangeModifier <= -0.99){ + float startingRange = randomFeatures.startingRangeList.get(i); + float endingRange = randomFeatures.endingRangeList.get(i); + if (-1.01 <= startingRange && startingRange <= -0.99 || -1.01 <= endingRange && endingRange <= -0.99){ generateWithChancesSurface(featureFunction, new Parameters(parameterBase, randomFeatures.featureParametersList.get(i)), density, x, z, 8, 8, random); } else { generateWithChancesUnderground(featureFunction, new Parameters(parameterBase, randomFeatures.featureParametersList.get(i)), - density, (int) (rangeModifier * rangeY), x, z, 8, 8, random); + density, (int) (startingRange * rangeY), (int) (endingRange * rangeY), x, z, 8, 8, random); } } } @@ -98,15 +100,16 @@ public void generateBiomeFeature(Biome biome, int x, int z, Random random, Chunk int density = biomeFeatures.densityFunctionsList.get(i) .apply(new Parameters(parameterBase, biomeFeatures.densityParametersList.get(i))); - float rangeModifier = biomeFeatures.rangeModifierList.get(i); - if (-1.01 <= rangeModifier && rangeModifier <= -0.99){ + float startingRange = biomeFeatures.startingRangeList.get(i); + float endingRange = biomeFeatures.endingRangeList.get(i); + if (-1.01 <= startingRange && startingRange <= -0.99 || -1.01 <= endingRange && endingRange <= -0.99){ generateWithChancesSurface(featureFunction, new Parameters(parameterBase, biomeFeatures.featureParametersList.get(i)), density, x, z, 8, 8, random); } else { generateWithChancesUnderground(featureFunction, new Parameters(parameterBase, biomeFeatures.featureParametersList.get(i)), - density, (int) (rangeModifier * rangeY), x, z, 8, 8, random); + density, (int) (startingRange * rangeY), (int) (endingRange * rangeY), x, z, 8, 8, random); } } } diff --git a/src/main/java/useless/terrainapi/generation/overworld/api/ChunkGeneratorOverworldAPI.java b/src/main/java/useless/terrainapi/generation/overworld/api/ChunkGeneratorOverworldAPI.java index c2a396f..59f285c 100644 --- a/src/main/java/useless/terrainapi/generation/overworld/api/ChunkGeneratorOverworldAPI.java +++ b/src/main/java/useless/terrainapi/generation/overworld/api/ChunkGeneratorOverworldAPI.java @@ -1,13 +1,13 @@ package useless.terrainapi.generation.overworld.api; import net.minecraft.core.world.World; -import net.minecraft.core.world.generate.MapGenCaves; +import net.minecraft.core.world.generate.CavesLargeFeature; import net.minecraft.core.world.generate.chunk.perlin.ChunkGeneratorPerlin; import net.minecraft.core.world.generate.chunk.perlin.overworld.SurfaceGeneratorOverworld; import net.minecraft.core.world.generate.chunk.perlin.overworld.TerrainGeneratorOverworld; public class ChunkGeneratorOverworldAPI extends ChunkGeneratorPerlin { public ChunkGeneratorOverworldAPI(World world) { - super(world, new ChunkDecoratorOverworldAPI(world), new TerrainGeneratorOverworld(world), new SurfaceGeneratorOverworld(world), new MapGenCaves(false)); + super(world, new ChunkDecoratorOverworldAPI(world), new TerrainGeneratorOverworld(world), new SurfaceGeneratorOverworld(world), new CavesLargeFeature[]{new CavesLargeFeature()}); } } diff --git a/src/main/java/useless/terrainapi/generation/overworld/api/MapGenCavesAPI.java b/src/main/java/useless/terrainapi/generation/overworld/api/MapGenCavesAPI.java deleted file mode 100644 index acb845e..0000000 --- a/src/main/java/useless/terrainapi/generation/overworld/api/MapGenCavesAPI.java +++ /dev/null @@ -1,177 +0,0 @@ -package useless.terrainapi.generation.overworld.api; - -import net.minecraft.core.block.Block; -import net.minecraft.core.block.tag.BlockTags; -import net.minecraft.core.util.helper.MathHelper; -import net.minecraft.core.world.World; -import net.minecraft.core.world.generate.MapGenBase; -import org.jetbrains.annotations.ApiStatus; - -import java.util.Random; -@ApiStatus.Experimental -public class MapGenCavesAPI extends MapGenBase { - private final boolean isAlphaWorldType; - - public MapGenCavesAPI(boolean isAlphaWorldType) { - this.isAlphaWorldType = isAlphaWorldType; - } - @Override - protected void doGeneration(World world, int chunkX, int chunkZ, int baseChunkX, int baseChunkZ, short[] data) { - int cavesToGenerate = rand.nextInt(rand.nextInt(rand.nextInt(40) + 1) + 1); - if (rand.nextInt(15) != 0) { - cavesToGenerate = 0; - } - for (int i = 0; i < cavesToGenerate; ++i) { - double blockX = chunkX * 16 + rand.nextInt(16); - double blockY = rand.nextInt(rand.nextInt(this.worldObj.getHeightBlocks() - 8) + 8); - double blockZ = chunkZ * 16 + rand.nextInt(16); - int numBranches = 1; - if (rand.nextInt(4) == 0) { - this.generateHubRoom(rand.nextLong(), baseChunkX, baseChunkZ, data, blockX, blockY, blockZ); - numBranches += rand.nextInt(4); - } - for (int l1 = 0; l1 < numBranches; ++l1) { - float f = rand.nextFloat() * 3.141593f * 2.0f; - float f1 = (rand.nextFloat() - 0.5f) * 2.0f / 8.0f; - float initialRadius = rand.nextFloat() * 2.0f + rand.nextFloat(); - this.generateCave(rand.nextLong(), baseChunkX, baseChunkZ, data, blockX, blockY, blockZ, initialRadius, f, f1, 0, 0, 1.0); - } - } - } - protected void generateHubRoom(long seed, int baseChunkX, int baseChunkZ, short[] data, double blockX, double blockY, double blockZ) { - this.generateCave(seed, baseChunkX, baseChunkZ, data, blockX, blockY, blockZ, 1.0f + rand.nextFloat() * 6.0f, 0.0f, 0.0f, -1, -1, 0.5); - } - protected void generateCave(long seed, int baseChunkX, int baseChunkZ, short[] data, double blockX, double blockY, double blockZ, float initialRadius, float rotHor, float rotVer, int startPos, int endPos, double heightMod) { - boolean sharpRotVer; - double chunkMiddleX = baseChunkX * 16 + 8; - double chunkMiddleZ = baseChunkZ * 16 + 8; - float rotHorOffset = 0.0f; - float rotVerOffset = 0.0f; - Random random = new Random(seed); - if (endPos <= 0) { - int maxLength = this.radiusChunk * 16 - 16; - endPos = maxLength - random.nextInt(maxLength / 4); - } - boolean noBranches = false; - if (startPos == -1) { - startPos = endPos / 2; - noBranches = true; - } - int branchPos = random.nextInt(endPos / 2) + endPos / 4; - sharpRotVer = random.nextInt(6) == 0; - while (startPos < endPos) { - double width = 1.5 + (double)(MathHelper.sin((float)startPos * 3.141593f / (float)endPos) * initialRadius * 1.0f); - double height = width * heightMod; - float xzScale = MathHelper.cos(rotVer); - float yOffset = MathHelper.sin(rotVer); - blockX += MathHelper.cos(rotHor) * xzScale; - blockY += yOffset; - blockZ += MathHelper.sin(rotHor) * xzScale; - if (sharpRotVer) { - rotVer *= 0.92f; - } else { - rotVer *= 0.7f; - } - rotVer += rotVerOffset * 0.1f; - rotHor += rotHorOffset * 0.1f; - rotVerOffset *= 0.9f; - rotHorOffset *= 0.75f; - rotVerOffset += (random.nextFloat() - random.nextFloat()) * random.nextFloat() * 2.0f; - rotHorOffset += (random.nextFloat() - random.nextFloat()) * random.nextFloat() * 4.0f; - if (!noBranches && startPos == branchPos && initialRadius > 1.0f) { - this.generateCave(random.nextLong(), baseChunkX, baseChunkZ, data, blockX, blockY, blockZ, random.nextFloat() * 0.5f + 0.5f, rotHor - 1.570796f, rotVer / 3.0f, startPos, endPos, 1.0); - this.generateCave(random.nextLong(), baseChunkX, baseChunkZ, data, blockX, blockY, blockZ, random.nextFloat() * 0.5f + 0.5f, rotHor + 1.570796f, rotVer / 3.0f, startPos, endPos, 1.0); - return; - } - if (noBranches || random.nextInt(4) != 0) { - double dxFromMiddle = blockX - chunkMiddleX; - double dzFromMiddle = blockZ - chunkMiddleZ; - double length = endPos - startPos; - double maxRadius = initialRadius + 2.0f + 16.0f; - if (dxFromMiddle * dxFromMiddle + dzFromMiddle * dzFromMiddle - length * length > maxRadius * maxRadius) { - return; - } - if (!(blockX < chunkMiddleX - 16.0 - width * 2.0 || blockZ < chunkMiddleZ - 16.0 - width * 2.0 || blockX > chunkMiddleX + 16.0 + width * 2.0 || blockZ > chunkMiddleZ + 16.0 + width * 2.0)) { - int x; - int minX = MathHelper.floor_double(blockX - width) - baseChunkX * 16 - 1; - int maxX = MathHelper.floor_double(blockX + width) - baseChunkX * 16 + 1; - int minY = MathHelper.floor_double(blockY - height) - 1; - int maxY = MathHelper.floor_double(blockY + height) + 1; - int minZ = MathHelper.floor_double(blockZ - width) - baseChunkZ * 16 - 1; - int maxZ = MathHelper.floor_double(blockZ + width) - baseChunkZ * 16 + 1; - if (minX < 0) { - minX = 0; - } - if (maxX > 16) { - maxX = 16; - } - if (minY < 1) { - minY = 1; - } - if (maxY > this.worldObj.getHeightBlocks() - 8) { - maxY = this.worldObj.getHeightBlocks() - 8; - } - if (minZ < 0) { - minZ = 0; - } - if (maxZ > 16) { - maxZ = 16; - } - boolean hasHitWater = false; - for (x = minX; !hasHitWater && x < maxX; ++x) { - for (int z = minZ; !hasHitWater && z < maxZ; ++z) { - for (int y = maxY + 1; !hasHitWater && y >= minY - 1; --y) { - int index = (x * 16 + z) * this.worldObj.getHeightBlocks() + y; - int blockId = data[index] & 0xFFFF; - if (y >= this.worldObj.getHeightBlocks()) continue; - if (Block.hasTag(blockId, BlockTags.IS_WATER)) { - hasHitWater = true; - } - if (y == minY - 1 || x == minX || x == maxX - 1 || z == minZ || z == maxZ - 1) continue; - y = minY; - } - } - } - if (!hasHitWater) { - for (x = minX; x < maxX; ++x) { - double xPercentage = ((double)(x + baseChunkX * 16) + 0.5 - blockX) / width; - for (int z = minZ; z < maxZ; ++z) { - double zPercentage = ((double)(z + baseChunkZ * 16) + 0.5 - blockZ) / width; - int index = (x * 16 + z) * this.worldObj.getHeightBlocks() + maxY; - boolean replaceTopBlock = false; - if (xPercentage * xPercentage + zPercentage * zPercentage >= 1.0) continue; - for (int y = maxY - 1; y >= minY; --y) { - double yPercentage = ((double)y + 0.5 - blockY) / height; - if (yPercentage > -0.7 && xPercentage * xPercentage + yPercentage * yPercentage + zPercentage * zPercentage < 1.0) { - int blockId = data[index] & 0xFFFF; - if (Block.hasTag(blockId, BlockTags.CAVE_GEN_REPLACES_SURFACE)) { - replaceTopBlock = true; - } - if (Block.hasTag(blockId, BlockTags.CAVES_CUT_THROUGH)) { - if (y < 10) { - data[index] = (short)Block.fluidLavaStill.id; - } else { - data[index] = 0; - if (replaceTopBlock) { - int id = data[index - 1] & 0xFFFF; - if (id == Block.dirt.id) { - data[index - 1] = this.isAlphaWorldType ? (short)Block.grassRetro.id : (short)Block.grass.id; - } else if (id == Block.dirtScorched.id) { - data[index - 1] = (short)Block.grassScorched.id; - } - } - } - } - } - --index; - } - } - } - if (noBranches) break; - } - } - } - ++startPos; - } - } -} diff --git a/src/main/java/useless/terrainapi/generation/paradise/api/ChunkGeneratorParadiseAPI.java b/src/main/java/useless/terrainapi/generation/paradise/api/ChunkGeneratorParadiseAPI.java index 5c704e2..516a355 100644 --- a/src/main/java/useless/terrainapi/generation/paradise/api/ChunkGeneratorParadiseAPI.java +++ b/src/main/java/useless/terrainapi/generation/paradise/api/ChunkGeneratorParadiseAPI.java @@ -1,7 +1,7 @@ package useless.terrainapi.generation.paradise.api; import net.minecraft.core.world.World; -import net.minecraft.core.world.generate.MapGenCaves; +import net.minecraft.core.world.generate.CavesLargeFeature; import net.minecraft.core.world.generate.chunk.perlin.ChunkGeneratorPerlin; import net.minecraft.core.world.generate.chunk.perlin.overworld.SurfaceGeneratorOverworld; import net.minecraft.core.world.generate.chunk.perlin.paradise.TerrainGeneratorParadise; @@ -10,6 +10,6 @@ public class ChunkGeneratorParadiseAPI extends ChunkGeneratorPerlin { public ChunkGeneratorParadiseAPI(World world) { - super(world, new ChunkDecoratorOverworldAPI(world), new TerrainGeneratorParadise(world), new SurfaceGeneratorOverworld(world), new MapGenCaves(false)); + super(world, new ChunkDecoratorOverworldAPI(world), new TerrainGeneratorParadise(world), new SurfaceGeneratorOverworld(world), new CavesLargeFeature[]{new CavesLargeFeature()}); } } diff --git a/src/main/java/useless/terrainapi/generation/retro/RetroFunctions.java b/src/main/java/useless/terrainapi/generation/retro/RetroFunctions.java index ae97e00..4705bb2 100644 --- a/src/main/java/useless/terrainapi/generation/retro/RetroFunctions.java +++ b/src/main/java/useless/terrainapi/generation/retro/RetroFunctions.java @@ -22,7 +22,7 @@ public static Void generateDungeon(Parameters parameters){ int structX = x + parameters.random.nextInt(16) + 8; int structY = parameters.decorator.minY + parameters.random.nextInt(parameters.decorator.rangeY); int structZ = z + parameters.random.nextInt(16) + 8; - new WorldFeatureDungeon(Block.cobbleStone.id, Block.cobbleStoneMossy.id, null).generate(parameters.decorator.world, parameters.random, structX, structY, structZ); + new WorldFeatureDungeon(Block.cobbleStone.id, Block.cobbleStoneMossy.id, null).place(parameters.decorator.world, parameters.random, structX, structY, structZ); } return null; } @@ -71,7 +71,7 @@ public static Void generateTrees(Parameters parameters){ int xf = x + parameters.random.nextInt(16) + 8; int zf = z + parameters.random.nextInt(16) + 8; int yf = parameters.decorator.world.getHeightValue(xf, zf); - getTreeFeature(parameters).generate(parameters.decorator.world, parameters.random, xf, yf, zf); + getTreeFeature(parameters).place(parameters.decorator.world, parameters.random, xf, yf, zf); } return null; } diff --git a/src/main/java/useless/terrainapi/generation/retro/api/ChunkDecoratorRetroAPI.java b/src/main/java/useless/terrainapi/generation/retro/api/ChunkDecoratorRetroAPI.java index d1c537d..c50ebf4 100644 --- a/src/main/java/useless/terrainapi/generation/retro/api/ChunkDecoratorRetroAPI.java +++ b/src/main/java/useless/terrainapi/generation/retro/api/ChunkDecoratorRetroAPI.java @@ -57,10 +57,11 @@ public void generateOreFeatures(Biome biome, int x, int z, Random random, Chunk int density = oreFeatures.densityFunctionsList.get(i) .apply(new Parameters(parameterBase, oreFeatures.densityParametersList.get(i))); - float rangeModifier = oreFeatures.rangeModifierList.get(i); + float startingRange = oreFeatures.startingRangeList.get(i); + float endingRange = oreFeatures.endingRangeList.get(i); generateWithChancesUnderground(oreFeatures.featureFunctionsList.get(i), new Parameters(parameterBase, oreFeatures.featureParametersList.get(i)), - density, (int) (rangeModifier * rangeY), x, z, random); + density, (int) (startingRange * rangeY), (int) (endingRange * rangeY), x, z, random); } } @ApiStatus.Internal @@ -73,15 +74,16 @@ public void generateRandomFeatures(Biome biome, int x, int z, Random random, Chu int density = randomFeatures.densityFunctionsList.get(i) .apply(new Parameters(parameterBase, randomFeatures.densityParametersList.get(i))); - float rangeModifier = randomFeatures.rangeModifierList.get(i); - if (-1.01 <= rangeModifier && rangeModifier <= -0.99){ + float startingRange = randomFeatures.startingRangeList.get(i); + float endingRange = randomFeatures.endingRangeList.get(i); + if (-1.01 <= startingRange && startingRange <= -0.99 || -1.01 <= endingRange && endingRange <= -0.99){ generateWithChancesSurface(featureFunction, new Parameters(parameterBase, randomFeatures.featureParametersList.get(i)), density, x, z, 8, 8, random); } else { generateWithChancesUnderground(featureFunction, new Parameters(parameterBase, randomFeatures.featureParametersList.get(i)), - density, (int) (rangeModifier * rangeY), x, z, 8, 8, random); + density, (int) (startingRange * rangeY), (int) (endingRange * rangeY), x, z, 8, 8, random); } } } @@ -94,15 +96,16 @@ public void generateBiomeFeature(Biome biome, int x, int z, Random random, Chunk int density = biomeFeatures.densityFunctionsList.get(i) .apply(new Parameters(parameterBase, biomeFeatures.densityParametersList.get(i))); - float rangeModifier = biomeFeatures.rangeModifierList.get(i); - if (-1.01 <= rangeModifier && rangeModifier <= -0.99){ + float startingRange = biomeFeatures.startingRangeList.get(i); + float endingRange = biomeFeatures.endingRangeList.get(i); + if (-1.01 <= startingRange && startingRange <= -0.99 || -1.01 <= endingRange && endingRange <= -0.99){ generateWithChancesSurface(featureFunction, new Parameters(parameterBase, biomeFeatures.featureParametersList.get(i)), density, x, z, 8, 8, random); } else { generateWithChancesUnderground(featureFunction, new Parameters(parameterBase, biomeFeatures.featureParametersList.get(i)), - density, (int) (rangeModifier * rangeY), x, z, 8, 8, random); + density, (int) (startingRange * rangeY), (int) (endingRange * rangeY), x, z, 8, 8, random); } } } diff --git a/src/main/java/useless/terrainapi/generation/retro/api/ChunkGeneratorRetroAPI.java b/src/main/java/useless/terrainapi/generation/retro/api/ChunkGeneratorRetroAPI.java index 72609e5..ba2a0c7 100644 --- a/src/main/java/useless/terrainapi/generation/retro/api/ChunkGeneratorRetroAPI.java +++ b/src/main/java/useless/terrainapi/generation/retro/api/ChunkGeneratorRetroAPI.java @@ -1,13 +1,13 @@ package useless.terrainapi.generation.retro.api; import net.minecraft.core.world.World; -import net.minecraft.core.world.generate.MapGenCaves; +import net.minecraft.core.world.generate.CavesLargeFeature; import net.minecraft.core.world.generate.chunk.perlin.ChunkGeneratorPerlin; import net.minecraft.core.world.generate.chunk.perlin.overworld.retro.SurfaceGeneratorOverworldRetro; import net.minecraft.core.world.generate.chunk.perlin.overworld.retro.TerrainGeneratorOverworldRetro; public class ChunkGeneratorRetroAPI extends ChunkGeneratorPerlin { public ChunkGeneratorRetroAPI(World world) { - super(world, new ChunkDecoratorRetroAPI(world), new TerrainGeneratorOverworldRetro(world), new SurfaceGeneratorOverworldRetro(world), new MapGenCaves(true)); + super(world, new ChunkDecoratorRetroAPI(world), new TerrainGeneratorOverworldRetro(world), new SurfaceGeneratorOverworldRetro(world), new CavesLargeFeature[]{new CavesLargeFeature()}); } } diff --git a/src/main/java/useless/terrainapi/generation/woods/api/ChunkGeneratorOverworldWoodsAPI.java b/src/main/java/useless/terrainapi/generation/woods/api/ChunkGeneratorOverworldWoodsAPI.java index bf7ec06..955b66c 100644 --- a/src/main/java/useless/terrainapi/generation/woods/api/ChunkGeneratorOverworldWoodsAPI.java +++ b/src/main/java/useless/terrainapi/generation/woods/api/ChunkGeneratorOverworldWoodsAPI.java @@ -1,7 +1,7 @@ package useless.terrainapi.generation.woods.api; import net.minecraft.core.world.World; -import net.minecraft.core.world.generate.MapGenCaves; +import net.minecraft.core.world.generate.CavesLargeFeature; import net.minecraft.core.world.generate.chunk.perlin.ChunkGeneratorPerlin; import net.minecraft.core.world.generate.chunk.perlin.overworld.SurfaceGeneratorOverworld; import net.minecraft.core.world.generate.chunk.perlin.overworld.TerrainGeneratorOverworld; @@ -9,6 +9,6 @@ public class ChunkGeneratorOverworldWoodsAPI extends ChunkGeneratorPerlin { public ChunkGeneratorOverworldWoodsAPI(World world) { - super(world, new ChunkDecoratorOverworldAPI(world, 50), new TerrainGeneratorOverworld(world), new SurfaceGeneratorOverworld(world), new MapGenCaves(false)); + super(world, new ChunkDecoratorOverworldAPI(world, 50), new TerrainGeneratorOverworld(world), new SurfaceGeneratorOverworld(world), new CavesLargeFeature[]{new CavesLargeFeature()}); } } diff --git a/src/main/java/useless/terrainapi/initialization/worldtypes/HellInitialization.java b/src/main/java/useless/terrainapi/initialization/worldtypes/HellInitialization.java index 1e72767..ae94431 100644 --- a/src/main/java/useless/terrainapi/initialization/worldtypes/HellInitialization.java +++ b/src/main/java/useless/terrainapi/initialization/worldtypes/HellInitialization.java @@ -1,6 +1,7 @@ package useless.terrainapi.initialization.worldtypes; import net.minecraft.core.block.Block; +import net.minecraft.core.block.Blocks; import net.minecraft.core.world.generate.feature.WorldFeatureClay; import net.minecraft.core.world.generate.feature.WorldFeatureDeadBush; import useless.terrainapi.TerrainMain; @@ -22,32 +23,35 @@ public class HellInitialization extends BaseInitialization { public static final OverworldBiomeFeatures biomeFeatures = ChunkDecoratorOverworldHellAPI.biomeFeatures; @Override protected void initValues() { - hellConfig.setOreValues(TerrainMain.MOD_ID, Block.blockClay, 32, 20, 1); + hellConfig.setOreValues(TerrainMain.MOD_ID, Blocks.BLOCK_CLAY, 32, 20, 1); } @Override protected void initStructure() { structureFeatures.addFeature(HellFunctions::generateLavaLakeFeature, null); structureFeatures.addFeature(HellFunctions::generateObsidianLakeFeature, null); - structureFeatures.addFeature(HellFunctions::generateRandomFluid, new Object[]{50, Block.fluidWaterFlowing.id}); + structureFeatures.addFeature(HellFunctions::generateRandomFluid, new Object[]{50, Blocks.FLUID_WATER_FLOWING.id()}); structureFeatures.addFeature(OverworldFunctions::generateDungeons, null); structureFeatures.addFeature(HellFunctions::generateLabyrinths, null); - structureFeatures.addFeature(OverworldFunctions::generateRandomFluid, new Object[]{5, Block.fluidWaterFlowing.id}); - structureFeatures.addFeature(HellFunctions::generateRandomFluid, new Object[]{20, Block.fluidLavaFlowing.id}); + structureFeatures.addFeature(OverworldFunctions::generateRandomFluid, new Object[]{5, Blocks.FLUID_WATER_FLOWING.id()}); + structureFeatures.addFeature(HellFunctions::generateRandomFluid, new Object[]{20, Blocks.FLUID_LAVA_FLOWING.id()}); } @Override protected void initOre() { - String blockKey = Block.blockClay.getKey(); - oreFeatures.addFeature(new WorldFeatureClay(hellConfig.clusterSize.get(blockKey)), hellConfig.chancesPerChunk.get(blockKey), hellConfig.verticalRange.get(blockKey)); - oreFeatures.addManagedOreFeature(TerrainMain.MOD_ID, Block.dirt, 32, 20, 1, false); - oreFeatures.addManagedOreFeature(TerrainMain.MOD_ID, Block.gravel, 32, 10, 1, false); - oreFeatures.addManagedOreFeature(TerrainMain.MOD_ID, Block.oreCoalStone, 16, 20, 1, true); - oreFeatures.addManagedOreFeature(TerrainMain.MOD_ID, Block.oreIronStone, 8, 20, 1f/2, true); - oreFeatures.addManagedOreFeature(TerrainMain.MOD_ID, Block.oreGoldStone, 8, 2, 1f/4, true); - oreFeatures.addManagedOreFeature(TerrainMain.MOD_ID, Block.oreRedstoneStone, 7, 8, 1f/8, true); - oreFeatures.addManagedOreFeature(TerrainMain.MOD_ID, Block.oreDiamondStone, 7, 1, 1f/8,true); - oreFeatures.addManagedOreFeature(TerrainMain.MOD_ID, Block.oreLapisStone, 6, 1, 1f/4, true); + String blockKey = Blocks.BLOCK_CLAY.getKey(); + oreFeatures.addFeature( + (x) -> new WorldFeatureClay(hellConfig.clusterSize.get(blockKey)), null, + OverworldFunctions::getStandardOreBiomesDensity, new Object[]{hellConfig.chancesPerChunk.get(blockKey), null}, + hellConfig.verticalStartingRange.get(blockKey), hellConfig.verticalEndingRange.get(blockKey)); + oreFeatures.addManagedOreFeature(TerrainMain.MOD_ID, Blocks.DIRT, 32, 20, 1, false); + oreFeatures.addManagedOreFeature(TerrainMain.MOD_ID, Blocks.GRAVEL, 32, 10, 1, false); + oreFeatures.addManagedOreFeature(TerrainMain.MOD_ID, Blocks.ORE_COAL_STONE, 16, 20, 1, true); + oreFeatures.addManagedOreFeature(TerrainMain.MOD_ID, Blocks.ORE_IRON_STONE, 8, 20, 1f/2, true); + oreFeatures.addManagedOreFeature(TerrainMain.MOD_ID, Blocks.ORE_GOLD_STONE, 8, 2, 1f/4, true); + oreFeatures.addManagedOreFeature(TerrainMain.MOD_ID, Blocks.ORE_REDSTONE_STONE, 7, 8, 1f/8, true); + oreFeatures.addManagedOreFeature(TerrainMain.MOD_ID, Blocks.ORE_DIAMOND_STONE, 7, 1, 1f/8,true); + oreFeatures.addManagedOreFeature(TerrainMain.MOD_ID, Blocks.ORE_LAPIS_STONE, 6, 1, 1f/4, true); } @Override @@ -58,6 +62,6 @@ protected void initRandom() { @Override protected void initBiome() { biomeFeatures.addFeature(HellFunctions::getTreeFeature, null, HellFunctions::getTreeDensity, null, -1f); - biomeFeatures.addFeature(new WorldFeatureDeadBush(Block.deadbush.id), 1, 10, null); + biomeFeatures.addFeature(new WorldFeatureDeadBush(Blocks.DEADBUSH.id()), 1, 10, null); } } diff --git a/src/main/java/useless/terrainapi/initialization/worldtypes/NetherInitialization.java b/src/main/java/useless/terrainapi/initialization/worldtypes/NetherInitialization.java index d638754..ab9ca4f 100644 --- a/src/main/java/useless/terrainapi/initialization/worldtypes/NetherInitialization.java +++ b/src/main/java/useless/terrainapi/initialization/worldtypes/NetherInitialization.java @@ -1,6 +1,7 @@ package useless.terrainapi.initialization.worldtypes; import net.minecraft.core.block.Block; +import net.minecraft.core.block.Blocks; import net.minecraft.core.world.generate.feature.*; import useless.terrainapi.TerrainMain; import useless.terrainapi.generation.Parameters; @@ -21,8 +22,8 @@ protected void initStructure() { @Override protected void initOre() { - ChunkDecoratorNetherAPI.oreFeatures.addFeature(new WorldFeatureNetherLava(Block.fluidLavaFlowing.id), 8,120/128f); - ChunkDecoratorNetherAPI.oreFeatures.addManagedOreFeature(TerrainMain.MOD_ID, Block.oreNethercoalNetherrack, 12, 10, 120/128f, false); + ChunkDecoratorNetherAPI.oreFeatures.addFeature(new WorldFeatureNetherLava(Blocks.FLUID_LAVA_FLOWING.id()), 8,120/128f); + ChunkDecoratorNetherAPI.oreFeatures.addManagedOreFeature(TerrainMain.MOD_ID, Blocks.ORE_NETHERCOAL_NETHERRACK, 12, 10, 120/128f, false); ChunkDecoratorNetherAPI.oreFeatures.addFeature((Parameters x) -> new WorldFeatureFire(), null, NetherFunctions::netherFireDensity, null, 120/128f); ChunkDecoratorNetherAPI.oreFeatures.addFeature((Parameters x) -> new WorldFeatureGlowstoneA(), null, NetherFunctions::netherFireDensity, null, 120/128f); ChunkDecoratorNetherAPI.oreFeatures.addFeature(new WorldFeatureGlowstoneB(), 10, 120/128f); @@ -30,7 +31,7 @@ protected void initOre() { @Override protected void initRandom() { - ChunkDecoratorNetherAPI.randomFeatures.addFeature(new WorldFeatureLake(Block.fluidLavaStill.id), 8, 120/128f); + ChunkDecoratorNetherAPI.randomFeatures.addFeature(new WorldFeatureLake(Blocks.FLUID_LAVA_STILL.id()), 8, 120/128f); } @Override diff --git a/src/main/java/useless/terrainapi/initialization/worldtypes/OverworldInitialization.java b/src/main/java/useless/terrainapi/initialization/worldtypes/OverworldInitialization.java index 68f77c0..3350f93 100644 --- a/src/main/java/useless/terrainapi/initialization/worldtypes/OverworldInitialization.java +++ b/src/main/java/useless/terrainapi/initialization/worldtypes/OverworldInitialization.java @@ -1,6 +1,6 @@ package useless.terrainapi.initialization.worldtypes; -import net.minecraft.core.block.Block; +import net.minecraft.core.block.Blocks; import net.minecraft.core.world.biome.Biome; import net.minecraft.core.world.biome.Biomes; import net.minecraft.core.world.generate.feature.*; @@ -20,7 +20,7 @@ public class OverworldInitialization extends BaseInitialization { public static final OverworldBiomeFeatures biomeFeatures = ChunkDecoratorOverworldAPI.biomeFeatures; @Override protected void initValues() { - overworldConfig.setOreValues(TerrainMain.MOD_ID, Block.blockClay, 32, 20, 1f); + overworldConfig.setOreValues(TerrainMain.MOD_ID, Blocks.BLOCK_CLAY, 32, 20, 1f); overworldConfig.addGrassDensity(Biomes.OVERWORLD_FOREST, 2); overworldConfig.addGrassDensity(Biomes.OVERWORLD_MEADOW, 2); @@ -59,10 +59,10 @@ protected void initValues() { overworldConfig.addTreeDensity(Biomes.OVERWORLD_SWAMPLAND, 4); overworldConfig.addTreeDensity(Biomes.OVERWORLD_OUTBACK_GRASSY, 0); - overworldConfig.addRandomGrassBlock(Biomes.OVERWORLD_RAINFOREST, Block.tallgrassFern); - overworldConfig.addRandomGrassBlock(Biomes.OVERWORLD_SWAMPLAND, Block.tallgrassFern); - overworldConfig.addRandomGrassBlock(Biomes.OVERWORLD_BOREAL_FOREST, Block.tallgrassFern); - overworldConfig.addRandomGrassBlock(Biomes.OVERWORLD_TAIGA, Block.tallgrassFern); + overworldConfig.addRandomGrassBlocks(Biomes.OVERWORLD_RAINFOREST, Blocks.TALLGRASS_FERN); + overworldConfig.addRandomGrassBlocks(Biomes.OVERWORLD_SWAMPLAND, Blocks.TALLGRASS_FERN); + overworldConfig.addRandomGrassBlocks(Biomes.OVERWORLD_BOREAL_FOREST, Blocks.TALLGRASS_FERN); + overworldConfig.addRandomGrassBlocks(Biomes.OVERWORLD_TAIGA, Blocks.TALLGRASS_FERN); overworldConfig.addLakeDensity(Biomes.OVERWORLD_SWAMPLAND, 2); overworldConfig.addLakeDensity(Biomes.OVERWORLD_DESERT, 0); @@ -70,35 +70,40 @@ protected void initValues() { @Override protected void initStructure() { + overworldConfig.addFeatureChance(TerrainMain.MOD_ID, "labyrinth", 700); + structureFeatures.addFeature(OverworldFunctions::generateSwamp, null); structureFeatures.addFeature(OverworldFunctions::generateLakeFeature, null); structureFeatures.addFeature(OverworldFunctions::generateLavaLakeFeature, null); structureFeatures.addFeature(OverworldFunctions::generateDungeons, null); - structureFeatures.addFeature(OverworldFunctions::generateLabyrinths, null); - structureFeatures.addFeature(OverworldFunctions::generateRandomFluid, new Object[]{50, Block.fluidWaterFlowing.id}); - structureFeatures.addFeature(OverworldFunctions::generateRandomFluid, new Object[]{20, Block.fluidLavaFlowing.id}); + structureFeatures.addFeature(OverworldFunctions::generateLabyrinths, new Object[]{overworldConfig.getFeatureChanceOrDefault(TerrainMain.MOD_ID, "labyrinth", 700)}); + structureFeatures.addFeature(OverworldFunctions::generateRandomFluid, new Object[]{50, Blocks.FLUID_WATER_FLOWING.id()}); + structureFeatures.addFeature(OverworldFunctions::generateRandomFluid, new Object[]{20, Blocks.FLUID_LAVA_FLOWING.id()}); } @Override protected void initOre() { - String currentBlock = Block.blockClay.getKey(); - oreFeatures.addFeature(new WorldFeatureClay(overworldConfig.clusterSize.get(currentBlock)), overworldConfig.chancesPerChunk.get(currentBlock), overworldConfig.verticalRange.get(currentBlock)); - oreFeatures.addManagedOreFeature(TerrainMain.MOD_ID,Block.dirt, 32, 20, 1f, false); - oreFeatures.addManagedOreFeature(TerrainMain.MOD_ID,Block.gravel, 32, 10, 1f, false); - oreFeatures.addManagedOreFeature(TerrainMain.MOD_ID,Block.oreCoalStone, 16, 20, 1f, true); - oreFeatures.addManagedOreFeature(TerrainMain.MOD_ID,Block.oreIronStone, 8, 20, 1/2f, true); - oreFeatures.addManagedOreFeature(TerrainMain.MOD_ID,Block.oreGoldStone, 8, 2, 1/4f, true); - oreFeatures.addManagedOreFeature(TerrainMain.MOD_ID,Block.oreRedstoneStone, 7, 8, 1/8f, true); - oreFeatures.addManagedOreFeature(TerrainMain.MOD_ID,Block.oreDiamondStone, 7, 1, 1/8f, true); - oreFeatures.addManagedOreFeature(TerrainMain.MOD_ID,Block.mossStone, 32, 1, 1/2f, true); - oreFeatures.addManagedOreFeature(TerrainMain.MOD_ID,Block.oreLapisStone, 6, 1, 1/8f, true); + String currentBlocks = Blocks.BLOCK_CLAY.getKey(); + oreFeatures.addFeature( + (x) -> new WorldFeatureClay(overworldConfig.clusterSize.get(currentBlocks)), null, + OverworldFunctions::getStandardOreBiomesDensity, new Object[]{overworldConfig.chancesPerChunk.get(currentBlocks), null}, + overworldConfig.verticalStartingRange.get(currentBlocks), overworldConfig.verticalEndingRange.get(currentBlocks)); + oreFeatures.addManagedOreFeature(TerrainMain.MOD_ID, Blocks.DIRT, 32, 20, 1f, false); + oreFeatures.addManagedOreFeature(TerrainMain.MOD_ID,Blocks.GRAVEL, 32, 10, 1f, false); + oreFeatures.addManagedOreFeature(TerrainMain.MOD_ID,Blocks.ORE_COAL_STONE, 16, 20, 1f, true); + oreFeatures.addManagedOreFeature(TerrainMain.MOD_ID,Blocks.ORE_IRON_STONE, 8, 20, 1/2f, true); + oreFeatures.addManagedOreFeature(TerrainMain.MOD_ID,Blocks.ORE_GOLD_STONE, 8, 2, 1/4f, true); + oreFeatures.addManagedOreFeature(TerrainMain.MOD_ID,Blocks.ORE_REDSTONE_STONE, 7, 8, 1/8f, true); + oreFeatures.addManagedOreFeature(TerrainMain.MOD_ID,Blocks.ORE_DIAMOND_STONE, 7, 1, 1/8f, true); + oreFeatures.addManagedOreFeature(TerrainMain.MOD_ID,Blocks.MOSS_STONE, 32, 1, 1/2f, true); + oreFeatures.addManagedOreFeature(TerrainMain.MOD_ID,Blocks.ORE_LAPIS_STONE, 6, 1, 1/8f, true); } @Override protected void initRandom() { - randomFeatures.addFeature(new WorldFeatureFlowers(Block.flowerRed.id), 2, 1); - randomFeatures.addFeature(new WorldFeatureFlowers(Block.mushroomBrown.id), 4, 1); - randomFeatures.addFeature(new WorldFeatureFlowers(Block.mushroomRed.id), 8, 1); + randomFeatures.addFeature(new WorldFeatureFlowers(Blocks.FLOWER_RED.id(), 1, true), 2, 1); Dont know what to put for count + randomFeatures.addFeature(new WorldFeatureFlowers(Blocks.MUSHROOM_BROWN.id(), 1, true), 4, 1); Dont know what to put for count + randomFeatures.addFeature(new WorldFeatureFlowers(Blocks.MUSHROOM_RED.id(), 1, true), 8, 1); Dont know what to put for count randomFeatures.addFeatureSurface(new WorldFeatureSugarCane(), 5); randomFeatures.addFeatureSurface(new WorldFeaturePumpkin(), 128); randomFeatures.addFeatureSurface(new WorldFeatureSponge(), 64); @@ -110,10 +115,10 @@ protected void initBiome() { biomeFeatures.addFeature(OverworldFunctions::getTreeFeature, null, OverworldFunctions::getTreeDensity, null, -1f); biomeFeatures.addFeatureSurface(new WorldFeatureSugarCaneTall(), 1, new Biome[]{Biomes.OVERWORLD_RAINFOREST}); biomeFeatures.addFeature(OverworldFunctions::flowerTypeCondition, null, (Parameters x) -> overworldConfig.getFlowerDensity(x.biome, 0), null, 1f); - biomeFeatures.addFeature((Parameters x) -> new WorldFeatureFlowers(Block.flowerYellow.id), null, (Parameters x) -> overworldConfig.getYellowFlowerDensity(x.biome, 0), null, 1); + biomeFeatures.addFeature((Parameters x) -> new WorldFeatureFlowers(Blocks.FLOWER_YELLOW.id(), 1, true), null, (Parameters x) -> overworldConfig.getYellowFlowerDensity(x.biome, 0), null, 1); Dont know what to put for count biomeFeatures.addFeature(OverworldFunctions::grassTypeCondition, null, (Parameters x) -> overworldConfig.getGrassDensity(x.biome, 0), null, 1); biomeFeatures.addFeature(new WorldFeatureSpinifexPatch(), 1, 4, new Biome[]{Biomes.OVERWORLD_OUTBACK}); - biomeFeatures.addFeature(new WorldFeatureDeadBush(Block.deadbush.id), 1, 2, new Biome[]{Biomes.OVERWORLD_DESERT}); + biomeFeatures.addFeature(new WorldFeatureDeadBush(Blocks.DEADBUSH.id()), 1, 2, new Biome[]{Biomes.OVERWORLD_DESERT}); biomeFeatures.addFeature(new WorldFeatureCactus(), 1, 10, new Biome[]{Biomes.OVERWORLD_DESERT}); } } diff --git a/src/main/java/useless/terrainapi/initialization/worldtypes/RetroInitialization.java b/src/main/java/useless/terrainapi/initialization/worldtypes/RetroInitialization.java index 02f1d59..651a75e 100644 --- a/src/main/java/useless/terrainapi/initialization/worldtypes/RetroInitialization.java +++ b/src/main/java/useless/terrainapi/initialization/worldtypes/RetroInitialization.java @@ -1,6 +1,7 @@ package useless.terrainapi.initialization.worldtypes; import net.minecraft.core.block.Block; +import net.minecraft.core.block.Blocks; import net.minecraft.core.world.generate.feature.WorldFeatureCactus; import net.minecraft.core.world.generate.feature.WorldFeatureClay; import net.minecraft.core.world.generate.feature.WorldFeatureFlowers; @@ -24,40 +25,43 @@ public class RetroInitialization extends BaseInitialization { public static final OverworldBiomeFeatures biomeFeatures = ChunkDecoratorRetroAPI.biomeFeatures; @Override protected void initValues() { - retroConfig.setOreValues(TerrainMain.MOD_ID, Block.blockClay, 32, 10, 1); + retroConfig.setOreValues(TerrainMain.MOD_ID, Blocks.BLOCK_CLAY, 32, 10, 1); } @Override protected void initStructure() { structureFeatures.addFeature(RetroFunctions::generateDungeon, null); - structureFeatures.addFeature(OverworldFunctions::generateRandomFluid, new Object[]{50, Block.fluidWaterFlowing.id}); - structureFeatures.addFeature(OverworldFunctions::generateRandomFluid, new Object[]{20, Block.fluidLavaFlowing.id}); + structureFeatures.addFeature(OverworldFunctions::generateRandomFluid, new Object[]{50, Blocks.FLUID_WATER_FLOWING.id()}); + structureFeatures.addFeature(OverworldFunctions::generateRandomFluid, new Object[]{20, Blocks.FLUID_LAVA_FLOWING.id()}); } @Override protected void initOre() { - String currentBlock = Block.blockClay.getKey(); - oreFeatures.addFeature(new WorldFeatureClay(retroConfig.clusterSize.get(currentBlock)), retroConfig.chancesPerChunk.get(currentBlock), retroConfig.verticalRange.get(currentBlock)); - oreFeatures.addManagedOreFeature(TerrainMain.MOD_ID, Block.dirt, 32, 20, 1, false); - oreFeatures.addManagedOreFeature(TerrainMain.MOD_ID, Block.gravel, 32, 10, 1, false); - oreFeatures.addManagedOreFeature(TerrainMain.MOD_ID, Block.oreCoalStone, 16, 20, 1, true); - oreFeatures.addManagedOreFeature(TerrainMain.MOD_ID, Block.oreIronStone, 8, 20, 1f/2, true); - oreFeatures.addManagedOreFeature(TerrainMain.MOD_ID, Block.oreGoldStone, 8, 2, 1f/4, true); - oreFeatures.addManagedOreFeature(TerrainMain.MOD_ID, Block.oreRedstoneStone, 7, 8, 1f/8, true); - oreFeatures.addManagedOreFeature(TerrainMain.MOD_ID, Block.oreDiamondStone, 7, 1, 1f/8, true); + String currentBlock = Blocks.BLOCK_CLAY.getKey(); + oreFeatures.addFeature( + (x) -> new WorldFeatureClay(retroConfig.clusterSize.get(currentBlock)), null, + OverworldFunctions::getStandardOreBiomesDensity, new Object[]{retroConfig.chancesPerChunk.get(currentBlock), null}, + retroConfig.verticalStartingRange.get(currentBlock), retroConfig.verticalEndingRange.get(currentBlock)); + oreFeatures.addManagedOreFeature(TerrainMain.MOD_ID, Blocks.DIRT, 32, 20, 1, false); + oreFeatures.addManagedOreFeature(TerrainMain.MOD_ID,Blocks.GRAVEL, 32, 10, 1, false); + oreFeatures.addManagedOreFeature(TerrainMain.MOD_ID,Blocks.ORE_COAL_STONE, 16, 20, 1f, true); + oreFeatures.addManagedOreFeature(TerrainMain.MOD_ID,Blocks.ORE_IRON_STONE, 8, 20, 1f/2, true); + oreFeatures.addManagedOreFeature(TerrainMain.MOD_ID,Blocks.ORE_GOLD_STONE, 8, 2, 1f/4, true); + oreFeatures.addManagedOreFeature(TerrainMain.MOD_ID,Blocks.ORE_REDSTONE_STONE, 7, 8, 1f/8, true); + oreFeatures.addManagedOreFeature(TerrainMain.MOD_ID,Blocks.ORE_DIAMOND_STONE, 7, 1, 1f/8, true); } @Override protected void initRandom() { - randomFeatures.addFeature(new WorldFeatureFlowers(Block.flowerRed.id), 2, 1); - randomFeatures.addFeature(new WorldFeatureFlowers(Block.mushroomBrown.id), 4, 1); - randomFeatures.addFeature(new WorldFeatureFlowers(Block.mushroomRed.id), 8, 1); + randomFeatures.addFeature(new WorldFeatureFlowers(Blocks.FLOWER_RED.id(), 1, false), 2, 1); Dont know what to put for count + randomFeatures.addFeature(new WorldFeatureFlowers(Blocks.MUSHROOM_BROWN.id(), 1, false), 4, 1); Dont know what to put for count + randomFeatures.addFeature(new WorldFeatureFlowers(Blocks.MUSHROOM_RED.id(), 1, false), 8, 1); Dont know what to put for count } @Override protected void initBiome() { biomeFeatures.addFeature(RetroFunctions::getTreeFeature, null, RetroFunctions::getTreeDensity, null, -1f); - biomeFeatures.addFeature(new WorldFeatureFlowers(Block.flowerYellow.id), 1, 2, null); + biomeFeatures.addFeature(new WorldFeatureFlowers(Blocks.FLOWER_YELLOW.id(), 1, false), 1, 2, null); Dont know what to put for count biomeFeatures.addFeature(new WorldFeatureSugarCane(), 1, 10, null); biomeFeatures.addFeature(new WorldFeatureCactus(), 1, 1, null); } diff --git a/src/main/java/useless/terrainapi/mixin/MinecraftMixin.java b/src/main/java/useless/terrainapi/mixin/MinecraftMixin.java deleted file mode 100644 index 7cac115..0000000 --- a/src/main/java/useless/terrainapi/mixin/MinecraftMixin.java +++ /dev/null @@ -1,16 +0,0 @@ -package useless.terrainapi.mixin; - -import net.minecraft.client.Minecraft; -import org.spongepowered.asm.mixin.Mixin; -import org.spongepowered.asm.mixin.injection.At; -import org.spongepowered.asm.mixin.injection.Inject; -import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; -import useless.terrainapi.TerrainMain; - -@Mixin(value = Minecraft.class, remap = false, priority = 999) -public class MinecraftMixin { - @Inject(method = "startGame()V", at = @At("HEAD")) - private void initializeGeneration(CallbackInfo ci){ - TerrainMain.loadModules(); - } -} diff --git a/src/main/java/useless/terrainapi/mixin/MinecraftServerMixin.java b/src/main/java/useless/terrainapi/mixin/MinecraftServerMixin.java deleted file mode 100644 index 3171bdd..0000000 --- a/src/main/java/useless/terrainapi/mixin/MinecraftServerMixin.java +++ /dev/null @@ -1,16 +0,0 @@ -package useless.terrainapi.mixin; - -import net.minecraft.server.MinecraftServer; -import org.spongepowered.asm.mixin.Mixin; -import org.spongepowered.asm.mixin.injection.At; -import org.spongepowered.asm.mixin.injection.Inject; -import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable; -import useless.terrainapi.TerrainMain; - -@Mixin(value = MinecraftServer.class, remap = false, priority = 999) -public class MinecraftServerMixin { - @Inject(method = "startServer()Z", at = @At("HEAD")) - private void initializeGeneration(CallbackInfoReturnable cir){ - TerrainMain.loadModules(); - } -} diff --git a/src/main/java/useless/terrainapi/mixin/worldtypes/WorldTypeFloatingMixin.java b/src/main/java/useless/terrainapi/mixin/worldtypes/WorldTypeFloatingMixin.java index 63ae1e4..47f46c5 100644 --- a/src/main/java/useless/terrainapi/mixin/worldtypes/WorldTypeFloatingMixin.java +++ b/src/main/java/useless/terrainapi/mixin/worldtypes/WorldTypeFloatingMixin.java @@ -2,7 +2,7 @@ import net.minecraft.core.world.World; import net.minecraft.core.world.generate.chunk.ChunkGenerator; -import net.minecraft.core.world.type.WorldTypeOverworldFloating; +import net.minecraft.core.world.type.overworld.WorldTypeOverworldFloating; import org.spongepowered.asm.mixin.Mixin; import org.spongepowered.asm.mixin.injection.At; import org.spongepowered.asm.mixin.injection.Inject; diff --git a/src/main/java/useless/terrainapi/mixin/worldtypes/WorldTypeNetherMixin.java b/src/main/java/useless/terrainapi/mixin/worldtypes/WorldTypeNetherMixin.java index ebbd4e4..31491ee 100644 --- a/src/main/java/useless/terrainapi/mixin/worldtypes/WorldTypeNetherMixin.java +++ b/src/main/java/useless/terrainapi/mixin/worldtypes/WorldTypeNetherMixin.java @@ -2,7 +2,7 @@ import net.minecraft.core.world.World; import net.minecraft.core.world.generate.chunk.ChunkGenerator; -import net.minecraft.core.world.type.WorldTypeNether; +import net.minecraft.core.world.type.nether.WorldTypeNether; import org.spongepowered.asm.mixin.Mixin; import org.spongepowered.asm.mixin.injection.At; import org.spongepowered.asm.mixin.injection.Inject; diff --git a/src/main/java/useless/terrainapi/mixin/worldtypes/WorldTypeOverworldHellMixin.java b/src/main/java/useless/terrainapi/mixin/worldtypes/WorldTypeOverworldHellMixin.java index c522bc1..a9fbd80 100644 --- a/src/main/java/useless/terrainapi/mixin/worldtypes/WorldTypeOverworldHellMixin.java +++ b/src/main/java/useless/terrainapi/mixin/worldtypes/WorldTypeOverworldHellMixin.java @@ -2,7 +2,7 @@ import net.minecraft.core.world.World; import net.minecraft.core.world.generate.chunk.ChunkGenerator; -import net.minecraft.core.world.type.WorldTypeOverworldHell; +import net.minecraft.core.world.type.overworld.WorldTypeOverworldHell; import org.spongepowered.asm.mixin.Mixin; import org.spongepowered.asm.mixin.injection.At; import org.spongepowered.asm.mixin.injection.Inject; diff --git a/src/main/java/useless/terrainapi/mixin/worldtypes/WorldTypeOverworldMixin.java b/src/main/java/useless/terrainapi/mixin/worldtypes/WorldTypeOverworldMixin.java index 8c19c51..2b5d291 100644 --- a/src/main/java/useless/terrainapi/mixin/worldtypes/WorldTypeOverworldMixin.java +++ b/src/main/java/useless/terrainapi/mixin/worldtypes/WorldTypeOverworldMixin.java @@ -2,7 +2,7 @@ import net.minecraft.core.world.World; import net.minecraft.core.world.generate.chunk.ChunkGenerator; -import net.minecraft.core.world.type.WorldTypeOverworld; +import net.minecraft.core.world.type.overworld.WorldTypeOverworld; import org.spongepowered.asm.mixin.Mixin; import org.spongepowered.asm.mixin.injection.At; import org.spongepowered.asm.mixin.injection.Inject; diff --git a/src/main/java/useless/terrainapi/mixin/worldtypes/WorldTypeOverworldRetroMixin.java b/src/main/java/useless/terrainapi/mixin/worldtypes/WorldTypeOverworldRetroMixin.java index 4caaa89..23108f4 100644 --- a/src/main/java/useless/terrainapi/mixin/worldtypes/WorldTypeOverworldRetroMixin.java +++ b/src/main/java/useless/terrainapi/mixin/worldtypes/WorldTypeOverworldRetroMixin.java @@ -2,7 +2,7 @@ import net.minecraft.core.world.World; import net.minecraft.core.world.generate.chunk.ChunkGenerator; -import net.minecraft.core.world.type.WorldTypeOverworldRetro; +import net.minecraft.core.world.type.overworld.WorldTypeOverworldRetro; import org.spongepowered.asm.mixin.Mixin; import org.spongepowered.asm.mixin.injection.At; import org.spongepowered.asm.mixin.injection.Inject; diff --git a/src/main/java/useless/terrainapi/mixin/worldtypes/WorldTypeOverworldWoodsMixin.java b/src/main/java/useless/terrainapi/mixin/worldtypes/WorldTypeOverworldWoodsMixin.java index 6d9ac46..b9326b0 100644 --- a/src/main/java/useless/terrainapi/mixin/worldtypes/WorldTypeOverworldWoodsMixin.java +++ b/src/main/java/useless/terrainapi/mixin/worldtypes/WorldTypeOverworldWoodsMixin.java @@ -2,7 +2,7 @@ import net.minecraft.core.world.World; import net.minecraft.core.world.generate.chunk.ChunkGenerator; -import net.minecraft.core.world.type.WorldTypeOverworldWoods; +import net.minecraft.core.world.type.overworld.WorldTypeOverworldWoods; import org.spongepowered.asm.mixin.Mixin; import org.spongepowered.asm.mixin.injection.At; import org.spongepowered.asm.mixin.injection.Inject; diff --git a/src/main/java/useless/terrainapi/mixin/worldtypes/WorldTypeParadiseMixin.java b/src/main/java/useless/terrainapi/mixin/worldtypes/WorldTypeParadiseMixin.java index d75e8a3..cb2926f 100644 --- a/src/main/java/useless/terrainapi/mixin/worldtypes/WorldTypeParadiseMixin.java +++ b/src/main/java/useless/terrainapi/mixin/worldtypes/WorldTypeParadiseMixin.java @@ -2,7 +2,7 @@ import net.minecraft.core.world.World; import net.minecraft.core.world.generate.chunk.ChunkGenerator; -import net.minecraft.core.world.type.WorldTypeParadise; +import net.minecraft.core.world.type.paradise.WorldTypeParadise; import org.spongepowered.asm.mixin.Mixin; import org.spongepowered.asm.mixin.injection.At; import org.spongepowered.asm.mixin.injection.Inject; diff --git a/src/main/java/useless/terrainapi/util/Utilities.java b/src/main/java/useless/terrainapi/util/Utilities.java index 09c2bed..71cc243 100644 --- a/src/main/java/useless/terrainapi/util/Utilities.java +++ b/src/main/java/useless/terrainapi/util/Utilities.java @@ -57,14 +57,14 @@ public static T[] concatenate(T[] a, T[] b) { } /**Finds a block by its block key - * @param key Block Key + * @param translationKey Block Key * @return Block if Block exists, null otherwise */ @Nullable - public static Block getBlock(String key){ - if (key == null){ + public static Block getBlock(String translationKey){ + if (translationKey == null){ return null; } - return Block.getBlockByName(key); + return Block.setupTranslationKey(translationKey); } } diff --git a/src/main/resources/fabric.mod.json b/src/main/resources/fabric.mod.json index 27ad50c..f71eb63 100644 --- a/src/main/resources/fabric.mod.json +++ b/src/main/resources/fabric.mod.json @@ -21,19 +21,23 @@ "main": [ "useless.terrainapi.TerrainMain" ], + "afterGameStart": [ + "useless.terrainapi.TerrainMain" + ], "terrain-api": [ - "useless.terrainapi.initialization.TerrainInitialization" + "useless.terrainapi.initialization.TerrainInitialization" ] }, "mixins": [ "terrainapi.mixins.json" ], - "depends": { - "fabricloader": ">=0.13.3" - }, - "suggests": { - }, + "depends": { + "minecraft": "*", + "fabricloader": ">=0.15.5" + }, + "suggests": { + }, "custom": { "modmenu:api": true } diff --git a/src/main/resources/terrainapi.mixins.json b/src/main/resources/terrainapi.mixins.json index f9295ef..a5c73c6 100644 --- a/src/main/resources/terrainapi.mixins.json +++ b/src/main/resources/terrainapi.mixins.json @@ -4,8 +4,6 @@ "package": "useless.terrainapi.mixin", "compatibilityLevel": "JAVA_8", "mixins": [ - "MinecraftMixin", - "MinecraftServerMixin", "worldtypes.WorldTypeFloatingMixin", "worldtypes.WorldTypeNetherMixin", "worldtypes.WorldTypeOverworldHellMixin",