create TerraScriptAPIAddon

Implement other biome provider types, streamline pipeline config syntax, implement more locators

.editorconfig

@@ -105,7 +105,7 @@ ij_java_for_statement_wrap = off
 ij_java_generate_final_locals = false
 ij_java_generate_final_parameters = false
 ij_java_if_brace_force = never
-ij_java_imports_layout = *,|,javax.**,java.**,|,$*
+ij_java_imports_layout = *, |, javax.**, java.**, |, $*
 ij_java_indent_case_from_switch = true
 ij_java_insert_inner_class_imports = false
 ij_java_insert_override_annotation = true
@@ -137,7 +137,7 @@ ij_java_method_parameters_wrap = off
 ij_java_modifier_list_wrap = false
 ij_java_names_count_to_use_import_on_demand = 3
 ij_java_new_line_after_lparen_in_record_header = false
-ij_java_packages_to_use_import_on_demand = java.awt.*,javax.swing.*
+ij_java_packages_to_use_import_on_demand = java.awt.*, javax.swing.*
 ij_java_parameter_annotation_wrap = off
 ij_java_parentheses_expression_new_line_after_left_paren = false
 ij_java_parentheses_expression_right_paren_on_new_line = false
@@ -246,7 +246,7 @@ ij_java_wrap_comments = false
 ij_java_wrap_first_method_in_call_chain = false
 ij_java_wrap_long_lines = false
 
-[{*.gradle.kts,*.kt,*.kts,*.main.kts}]
+[{*.gradle.kts, *.kt, *.kts, *.main.kts}]
 ij_kotlin_align_in_columns_case_branch = false
 ij_kotlin_align_multiline_binary_operation = false
 ij_kotlin_align_multiline_extends_list = false
@@ -325,7 +325,7 @@ ij_kotlin_wrap_elvis_expressions = 1
 ij_kotlin_wrap_expression_body_functions = 0
 ij_kotlin_wrap_first_method_in_call_chain = false
 
-[{*.har,*.jsb2,*.jsb3,*.json,.babelrc,.eslintrc,.stylelintrc,bowerrc,jest.config}]
+[{*.har, *.jsb2, *.jsb3, *.json, .babelrc, .eslintrc, .stylelintrc, bowerrc, jest.config}]
 indent_size = 2
 ij_json_keep_blank_lines_in_code = 0
 ij_json_keep_indents_on_empty_lines = false
@@ -338,7 +338,7 @@ ij_json_spaces_within_braces = false
 ij_json_spaces_within_brackets = false
 ij_json_wrap_long_lines = false
 
-[{*.yaml,*.yml}]
+[{*.yaml, *.yml}]
 indent_size = 2
 ij_yaml_keep_indents_on_empty_lines = true
 ij_yaml_keep_line_breaks = true

.github/ISSUE_TEMPLATE/OTHER_ISSUES.md

@@ -8,4 +8,5 @@ assignees: ""
 ---
 
 ## Describe the issue
+
 <!-- Please describe the issue as clearly and as concisely as possible, without missing any details. -->

.github/ISSUE_TEMPLATE/config.yml

@@ -1,11 +1,11 @@
 blank_issues_enabled: false
 contact_links:
-  - name:  Which Issue Template do I Choose?
-    url:   https://github.com/PolyhedralDev/Terra/wiki/How-To-Choose-An-Issue-Template
+  - name: Which Issue Template do I Choose?
+    url: https://github.com/PolyhedralDev/Terra/wiki/How-To-Choose-An-Issue-Template
     about: Click this if you don't know which issue template to select. This will help you make sure you choose the right one and provide enough information for us to help you.
-  - name:  Terra Wiki
-    url:   https://github.com/PolyhedralDev/Terra/wiki
+  - name: Terra Wiki
+    url: https://github.com/PolyhedralDev/Terra/wiki
     about: Documentation for all things Terra.
-  - name:  Join the Support Discord
-    url:   https://discord.dfsek.com
+  - name: Join the Support Discord
+    url: https://discord.dfsek.com
     about: If you have a basic support question, join the Discord instead.

.github/workflows/build.yml

@@ -1,40 +0,0 @@
-# This workflow will build a Java project with Gradle
-# For more information see: https://help.github.com/actions/language-and-framework-guides/building-and-testing-java-with-gradle
-
-name: Java CI with Gradle
-
-on:
-  push:
-    tags:
-      - "v*" # Push events to matching v*, i.e. v1.0, v20.15.10
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    
-    steps:
-      - uses: actions/checkout@v2
-      
-      - name: Set up JDK 1.8
-        uses: actions/setup-java@v1
-        with:
-          java-version: 1.8
-      
-      - name: Build Terra
-        run:  gradle shadowJar
-      
-      - name: Upload artifacts
-        uses: actions/upload-artifact@v2
-        with:
-          name: Package
-          path: build/libs
-      
-      - name: Publish release
-        uses: marvinpinto/action-automatic-releases@latest
-        with:
-          repo_token: ${{ secrets.GITHUB_TOKEN }}
-          prerelease: false
-          files:      |
-                      build/libs/Terra-*.jar
-                      LICENSE
-                      

README.md

@@ -7,40 +7,47 @@ to your specifications, with no knowledge of Java required.
 
 * Paper+ servers (Paper, Tuinity, Purpur, etc): [SpigotMC](https://www.spigotmc.org/resources/85151/)
 * Fabric: [Modrinth](https://modrinth.com/mod/terra) / [CurseForge](https://www.curseforge.com/minecraft/mc-mods/terra-world-generator)
-* Forge **(ALPHA - NOT PRODUCTION-READY)**: [Modrinth](https://modrinth.com/mod/terra) / [CurseForge](https://www.curseforge.com/minecraft/mc-mods/terra-world-generator)
+* Forge **(ALPHA - NOT PRODUCTION-READY)**: [Modrinth](https://modrinth.com/mod/terra)
+  / [CurseForge](https://www.curseforge.com/minecraft/mc-mods/terra-world-generator)
 
 ## Building and Running Terra
 
-To build, simply run `./gradlew build` (`gradlew.bat build` on Windows). This will build all platforms, and
-produce JARs in `platforms/<platform>/build/libs`
+To build, simply run `./gradlew build` (`gradlew.bat build` on Windows). This will build all platforms, and produce JARs
+in `platforms/<platform>/build/libs`
 
 ### Production JARs:
+
 * Bukkit: `Terra-<version>-shaded.jar`
 * Fabric: `Terra-<version>-shaded-mapped.jar`
 * Forge: `Terra-<version>-shaded.jar`
 
 ### Building a Specific Platform
+
 To build a specific platform, run `gradlew :platforms:<platform>:build`.
 
 JARs are produced in `platforms/<platform>/build/libs`.
 
 ### Running Minecraft in the IDE
+
 To run Minecraft with Terra in the IDE (for testing) use the following tasks:
+
 * Bukkit
-  * `installPaper` - Install a [Paper](https://github.com/PaperMC/Paper) test server. (Only needs to be run once).
-  * `installPurpur` - Install a [Purpur](https://github.com/pl3xgaming/Purpur) test server. (Only needs to be run once).
-  * `runPaper` - Run the Paper test server with Terra (`installPaper` must have been run previously).
-  * `runPurpur` - Run the Purpur test server with Terra (`installPurpur` must have been run previously).
+    * `installPaper` - Install a [Paper](https://github.com/PaperMC/Paper) test server. (Only needs to be run once).
+    * `installPurpur` - Install a [Purpur](https://github.com/pl3xgaming/Purpur) test server. (Only needs to be run once).
+    * `runPaper` - Run the Paper test server with Terra (`installPaper` must have been run previously).
+    * `runPurpur` - Run the Purpur test server with Terra (`installPurpur` must have been run previously).
 * Fabric
-  * `runClient` - Run a Minecraft Fabric client with Terra installed.
-  * `runServer` - Run a Minecraft Fabric server with Terra installed.
+    * `runClient` - Run a Minecraft Fabric client with Terra installed.
+    * `runServer` - Run a Minecraft Fabric server with Terra installed.
 * Forge
-  * `runClient` - Run a Minecraft Forge client with Terra installed.
-  * `runServer` - Run a Minecraft Forge server with Terra installed.
+    * `runClient` - Run a Minecraft Forge client with Terra installed.
+    * `runServer` - Run a Minecraft Forge server with Terra installed.
+
 ## Contributing
-Contributions are welcome! If you want to see a feature in Terra, please, open an issue, or implement it yourself and
-submit a PR!
+
+Contributions are welcome! If you want to see a feature in Terra, please, open an issue, or implement it yourself and submit a PR!
 Join the discord [here](https://discord.gg/PXUEbbF) if you would like to talk more about the project!
 
 ## Beta
+
 Terra is still in beta! While it is stable, it is not feature-complete. There is a lot to be added!

build.gradle.kts

@@ -1,15 +1,20 @@
-import com.dfsek.terra.getGitHash
+import com.dfsek.terra.*
 
-val versionObj = Version("5", "3", "3", true)
+val versionObj = Version("6", "0", "0", true)
 
 allprojects {
     version = versionObj
     group = "com.dfsek.terra"
 
+    configureDependencies()
+    configureCompilation()
+    configurePublishing()
+
     tasks.withType<JavaCompile>().configureEach {
         options.isFork = true
         options.isIncremental = true
     }
+
     tasks.withType<Test>().configureEach {
         useJUnitPlatform()
 
@@ -18,11 +23,17 @@ allprojects {
         failFast = true
         maxParallelForks = (Runtime.getRuntime().availableProcessors() - 1).takeIf { it > 0 } ?: 1
 
-        reports.html.isEnabled = false
-        reports.junitXml.isEnabled = false
+        reports.html.required.set(false)
+        reports.junitXml.required.set(false)
     }
-
 }
+
+afterEvaluate {
+    project(":platforms").subprojects.forEach { // Platform projects are where distribution happens
+        it.configureDistribution()
+    }
+}
+
 /**
  * Version class that does version stuff.
  */

buildSrc/build.gradle.kts

@@ -10,4 +10,5 @@ repositories {
 
 dependencies {
     "implementation"("com.github.jengelman.gradle.plugins:shadow:+")
+    "implementation"("org.yaml:snakeyaml:1.27")
 }

buildSrc/src/main/kotlin/com/dfsek/terra/AddonConfig.kt

@@ -0,0 +1,41 @@
+package com.dfsek.terra
+
+import org.gradle.api.Project
+import org.gradle.api.Task
+import org.gradle.jvm.tasks.Jar
+import java.io.File
+import java.util.function.Predicate
+import kotlin.streams.asStream
+
+
+/**
+ * Configures a directory where addons will be put.
+ */
+fun Project.addonDir(dir: File, task: Task) {
+    task.doFirst {
+        dir.parentFile.mkdirs()
+        matchingAddons(dir) {
+            it.name.startsWith("Terra-") // Assume everything that starts with Terra- is a core addon.
+        }.forEach {
+            println("Deleting old addon: " + it.absolutePath)
+            it.delete()
+        }
+        project(":common:addons").subprojects.forEach { addonProject ->
+            val jar = (addonProject.tasks.named("jar").get() as Jar)
+
+            val target = File(dir, jar.archiveFileName.get())
+
+            val base = "${jar.archiveBaseName.get()}-${project.version}"
+
+            println("Copying addon ${jar.archiveFileName.get()} to ${target.absolutePath}. Base name: $base")
+
+            jar.archiveFile.orNull?.asFile?.copyTo(target)
+        }
+    }
+}
+
+fun matchingAddons(dir: File, matcher: Predicate<File>): Set<File> {
+    val matching = HashSet<File>()
+    dir.walk().maxDepth(1).asStream().filter(matcher).forEach(matching::add)
+    return matching
+}

buildSrc/src/main/kotlin/com/dfsek/terra/CommonConfig.kt

@@ -1,19 +1,8 @@
 package com.dfsek.terra
 
 import org.gradle.api.Project
-import org.gradle.api.tasks.testing.Test
-import org.gradle.kotlin.dsl.apply
-import org.gradle.kotlin.dsl.withType
 import java.io.ByteArrayOutputStream
 
-fun Project.configureCommon() {
-    configureDependencies()
-    configureCompilation()
-    configureDistribution()
-
-    version = rootProject.version
-}
-
 fun Project.getGitHash(): String {
     val stdout = ByteArrayOutputStream()
     exec {

buildSrc/src/main/kotlin/com/dfsek/terra/CompilationConfig.kt

@@ -2,7 +2,7 @@ package com.dfsek.terra
 
 import org.gradle.api.JavaVersion
 import org.gradle.api.Project
-import org.gradle.api.plugins.JavaPluginConvention
+import org.gradle.api.plugins.JavaPluginExtension
 import org.gradle.api.tasks.bundling.Jar
 import org.gradle.api.tasks.compile.JavaCompile
 import org.gradle.api.tasks.javadoc.Javadoc
@@ -11,9 +11,11 @@ import org.gradle.language.jvm.tasks.ProcessResources
 
 fun Project.configureCompilation() {
     apply(plugin = "maven-publish")
+    apply(plugin = "java")
+    apply(plugin = "java-library")
     apply(plugin = "idea")
 
-    configure<JavaPluginConvention> {
+    configure<JavaPluginExtension> {
         sourceCompatibility = JavaVersion.VERSION_16
         targetCompatibility = JavaVersion.VERSION_16
     }

buildSrc/src/main/kotlin/com/dfsek/terra/DependencyConfig.kt

@@ -1,10 +1,7 @@
 package com.dfsek.terra
 
 import org.gradle.api.Project
-import org.gradle.kotlin.dsl.apply
-import org.gradle.kotlin.dsl.dependencies
-import org.gradle.kotlin.dsl.invoke
-import org.gradle.kotlin.dsl.repositories
+import org.gradle.kotlin.dsl.*
 
 fun Project.configureDependencies() {
     apply(plugin = "java")
@@ -26,13 +23,22 @@ fun Project.configureDependencies() {
         maven { url = uri("https://papermc.io/repo/repository/maven-public/") }
         maven { url = uri("https://maven.fabricmc.net/") }
         gradlePluginPortal()
-        jcenter()
         mavenCentral()
     }
 
     dependencies {
         "testImplementation"("org.junit.jupiter:junit-jupiter-api:5.7.0")
         "testImplementation"("org.junit.jupiter:junit-jupiter-engine:5.7.0")
-        "api"("org.jetbrains:annotations:20.1.0")
+        "compileOnly"("org.jetbrains:annotations:20.1.0")
+
+        "compileOnly"("com.google.guava:guava:30.0-jre")
+        "testImplementation"("com.google.guava:guava:30.0-jre")
+    }
+
+    if (project(":common:addons").subprojects.contains(this)) { // If this is an addon project, depend on the API.
+        dependencies {
+            "compileOnly"(project(":common:api"))
+            "testImplementation"(project(":common:api"))
+        }
     }
 }

buildSrc/src/main/kotlin/com/dfsek/terra/DistributionConfig.kt

@@ -3,15 +3,23 @@ package com.dfsek.terra
 import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
 import org.gradle.api.DefaultTask
 import org.gradle.api.Project
-import org.gradle.api.plugins.BasePluginConvention
-import org.gradle.api.tasks.bundling.Jar
-import org.gradle.api.tasks.javadoc.Javadoc
-import org.gradle.kotlin.dsl.*
+import org.gradle.api.plugins.BasePluginExtension
+import org.gradle.jvm.tasks.Jar
+import org.gradle.kotlin.dsl.apply
+import org.gradle.kotlin.dsl.configure
+import org.gradle.kotlin.dsl.get
+import org.gradle.kotlin.dsl.named
+import org.yaml.snakeyaml.DumperOptions
+import org.yaml.snakeyaml.Yaml
 import java.io.File
+import java.io.FileInputStream
+import java.io.FileOutputStream
+import java.io.FileWriter
 import java.net.URL
+import java.util.zip.ZipEntry
+import java.util.zip.ZipOutputStream
 
 fun Project.configureDistribution() {
-    apply(plugin = "java-library")
     apply(plugin = "com.github.johnrengelman.shadow")
 
     val downloadDefaultPacks = tasks.create("downloadDefaultPacks") {
@@ -25,7 +33,85 @@ fun Project.configureDistribution() {
             downloadPack(netherPackUrl, project)
         }
     }
-    tasks["processResources"].dependsOn(downloadDefaultPacks)
+
+    val installAddons = tasks.create("installAddons") {
+        group = "terra"
+        project(":common:addons").subprojects.forEach {
+            it.afterEvaluate {
+                dependsOn(it.tasks.getByName("build")) // Depend on addon JARs
+            }
+        }
+
+        doFirst {
+            // The addons are copied into a JAR because of a ShadowJar bug
+            // which expands *all* JARs, even resource ones, into the fat JAR.
+            // To get around this, we copy all addon JARs into a *new* JAR,
+            // then, ShadowJar expands the newly created JAR, putting the original
+            // JARs where they should go.
+            //
+            // https://github.com/johnrengelman/shadow/issues/111
+            val dest = File(buildDir, "/resources/main/addons.jar")
+            dest.parentFile.mkdirs()
+
+            val zip = ZipOutputStream(FileOutputStream(dest))
+
+            project(":common:addons").subprojects.forEach { addonProject ->
+                val jar = (addonProject.tasks.named("jar").get() as Jar)
+                println("Packaging addon ${jar.archiveFileName.get()} to ${dest.absolutePath}.")
+
+                val entry = ZipEntry("addons/${jar.archiveFileName.get()}")
+                zip.putNextEntry(entry)
+                FileInputStream(jar.archiveFile.get().asFile).copyTo(zip)
+                zip.closeEntry()
+            }
+            zip.close()
+        }
+    }
+
+    val generateResourceManifest = tasks.create("generateResourceManifest") {
+        group = "terra"
+        dependsOn(downloadDefaultPacks)
+        dependsOn(installAddons)
+        doFirst {
+            val resources = HashMap<String, MutableList<String>>()
+            val packsDir = File("${project.buildDir}/resources/main/packs/")
+
+            packsDir.walkTopDown().forEach {
+                if (it.isDirectory || !it.name.endsWith(".zip")) return@forEach
+                resources.computeIfAbsent("packs") { ArrayList() }.add(it.name)
+            }
+
+            val langDir = File("${project(":common:implementation").buildDir}/resources/main/lang/")
+
+            langDir.walkTopDown().forEach {
+                if (it.isDirectory || !it.name.endsWith(".yml")) return@forEach
+                resources.computeIfAbsent("lang") { ArrayList() }.add(it.name)
+            }
+
+            project(":common:addons").subprojects.forEach { addonProject ->
+                val jar = (addonProject.tasks.named("jar").get() as Jar).archiveFileName.get()
+                resources.computeIfAbsent("addons") { ArrayList() }.add(jar)
+            }
+
+            val options = DumperOptions()
+            options.indent = 2
+            options.indentWithIndicator = true
+            options.indicatorIndent = 2
+            options.isPrettyFlow = true
+            options.defaultFlowStyle = DumperOptions.FlowStyle.BLOCK
+            options.defaultScalarStyle = DumperOptions.ScalarStyle.DOUBLE_QUOTED
+
+            val yaml = Yaml(options)
+
+            val manifest = File("${project.buildDir}/resources/main/resources.yml")
+
+            if (manifest.exists()) manifest.delete()
+            manifest.createNewFile()
+            yaml.dump(resources, FileWriter(manifest))
+        }
+    }
+
+    tasks["processResources"].dependsOn(generateResourceManifest)
 
     tasks.named<ShadowJar>("shadowJar") {
         // Tell shadow to download the packs
@@ -36,17 +122,14 @@ fun Project.configureDistribution() {
         archiveClassifier.set("shaded")
         setVersion(project.version)
         relocate("org.apache.commons", "com.dfsek.terra.lib.commons")
-        relocate("net.jafama", "com.dfsek.terra.lib.jafama")
         relocate("org.objectweb.asm", "com.dfsek.terra.lib.asm")
-        relocate("com.google.errorprone", "com.dfsek.terra.lib.google.errorprone")
-        relocate("com.google.j2objc", "com.dfsek.terra.lib.google.j2objc")
-        relocate("org.checkerframework", "com.dfsek.terra.lib.checkerframework")
-        relocate("org.javax.annotation", "com.dfsek.terra.lib.javax.annotation")
         relocate("org.json", "com.dfsek.terra.lib.json")
         relocate("org.yaml", "com.dfsek.terra.lib.yaml")
-        minimize()
     }
-    convention.getPlugin<BasePluginConvention>().archivesBaseName = project.name
+
+    configure<BasePluginExtension> {
+        archivesName.set(project.name)
+    }
 
     tasks.named<DefaultTask>("build") {
         dependsOn(tasks["shadowJar"])

buildSrc/src/main/kotlin/com/dfsek/terra/PublishingConfig.kt

@@ -0,0 +1,33 @@
+package com.dfsek.terra
+
+import org.gradle.api.Project
+import org.gradle.api.publish.PublishingExtension
+import org.gradle.api.publish.maven.MavenPublication
+import org.gradle.kotlin.dsl.*
+
+fun Project.configurePublishing() {
+    configure<PublishingExtension> {
+        publications {
+            create<MavenPublication>("mavenJava") {
+                artifact(tasks["sourcesJar"])
+                artifact(tasks["jar"])
+            }
+        }
+
+        repositories {
+            val mavenUrl = "https://repo.codemc.io/repository/maven-releases/"
+            //val mavenSnapshotUrl = "https://repo.codemc.io/repository/maven-snapshots/"
+
+            maven(mavenUrl) {
+                val mavenUsername: String? by project
+                val mavenPassword: String? by project
+                if (mavenUsername != null && mavenPassword != null) {
+                    credentials {
+                        username = mavenUsername
+                        password = mavenPassword
+                    }
+                }
+            }
+        }
+    }
+}

common/addons/README.md

@@ -0,0 +1,3 @@
+# Core Addons
+
+This directory contains the modularized "core addons" that implement Terra's default behavior.

common/addons/api-features/README.md

@@ -0,0 +1,8 @@
+# api-features
+Contains the API for feature generation.
+
+This API implemented in:
+ * `config-feature`
+ * `generation-stage-feature`
+ * `config-locators`
+ * `config-distributors`

common/addons/api-features/build.gradle.kts

@@ -0,0 +1,2 @@
+dependencies {
+}

common/addons/api-terrascript/build.gradle.kts

@@ -0,0 +1,3 @@
+dependencies {
+    "shadedApi"("commons-io:commons-io:2.6")
+}

common/addons/api-terrascript/src/main/java/com/dfsek/terra/addons/terrascript/api/Function.java

@@ -0,0 +1,26 @@
+package com.dfsek.terra.addons.terrascript.api;
+
+import com.dfsek.terra.addons.terrascript.api.lang.Returnable;
+import com.dfsek.terra.addons.terrascript.api.lang.Variable;
+import com.dfsek.terra.api.properties.Context;
+
+import java.util.Map;
+
+public interface Function<T> extends Returnable<T> {
+    Function<?> NULL = new Function<Object>() {
+        @Override
+        public ReturnType returnType() {
+            return null;
+        }
+
+        @Override
+        public Object apply(Context context, Map<String, Variable<?>> variableMap) {
+            return null;
+        }
+
+        @Override
+        public Position getPosition() {
+            return null;
+        }
+    };
+}

common/addons/api-terrascript/src/main/java/com/dfsek/terra/addons/terrascript/api/FunctionBuilder.java

@@ -1,8 +1,7 @@
-package com.dfsek.terra.api.structures.parser.lang.functions;
+package com.dfsek.terra.addons.terrascript.api;
 
-import com.dfsek.terra.api.structures.parser.exceptions.ParseException;
-import com.dfsek.terra.api.structures.parser.lang.Returnable;
-import com.dfsek.terra.api.structures.tokenizer.Position;
+import com.dfsek.terra.addons.terrascript.api.exception.ParseException;
+import com.dfsek.terra.addons.terrascript.api.lang.Returnable;
 
 import java.util.List;
 

common/addons/api-terrascript/src/main/java/com/dfsek/terra/addons/terrascript/api/Position.java

@@ -1,4 +1,4 @@
-package com.dfsek.terra.api.structures.tokenizer;
+package com.dfsek.terra.addons.terrascript.api;
 
 public class Position {
     private final int line;

common/addons/api-terrascript/src/main/java/com/dfsek/terra/addons/terrascript/api/StructureScript.java

@@ -0,0 +1,13 @@
+package com.dfsek.terra.addons.terrascript.api;
+
+import com.dfsek.terra.api.structure.Structure;
+import com.dfsek.terra.api.structure.rotation.Rotation;
+import com.dfsek.terra.api.vector.Vector3;
+import com.dfsek.terra.api.world.World;
+
+import java.util.Random;
+
+public interface StructureScript extends Structure {
+    @SuppressWarnings("try")
+    boolean test(Vector3 location, World world, Random random, Rotation rotation);
+}

common/addons/api-terrascript/src/main/java/com/dfsek/terra/addons/terrascript/api/TerraProperties.java

@@ -1,22 +1,25 @@
-package com.dfsek.terra.api.structures.script;
+package com.dfsek.terra.addons.terrascript.api;
 
-import com.dfsek.terra.api.structures.parser.lang.ImplementationArguments;
-import com.dfsek.terra.api.structures.structure.Rotation;
-import com.dfsek.terra.api.structures.structure.buffer.Buffer;
+import com.dfsek.terra.api.properties.Properties;
+import com.dfsek.terra.api.structure.buffer.Buffer;
+import com.dfsek.terra.api.structure.rotation.Rotation;
+import com.dfsek.terra.api.world.World;
 
 import java.util.Random;
 
-public class TerraImplementationArguments implements ImplementationArguments {
+public class TerraProperties implements Properties {
     private final Buffer buffer;
     private final Rotation rotation;
     private final Random random;
+    private final World world;
     private final int recursions;
     private boolean waterlog = false;
 
-    public TerraImplementationArguments(Buffer buffer, Rotation rotation, Random random, int recursions) {
+    public TerraProperties(Buffer buffer, Rotation rotation, Random random, World world, int recursions) {
         this.buffer = buffer;
         this.rotation = rotation;
         this.random = random;
+        this.world = world;
         this.recursions = recursions;
     }
 
@@ -43,4 +46,8 @@ public class TerraImplementationArguments implements ImplementationArguments {
     public void setWaterlog(boolean waterlog) {
         this.waterlog = waterlog;
     }
+
+    public World getWorld() {
+        return world;
+    }
 }

common/addons/api-terrascript/src/main/java/com/dfsek/terra/addons/terrascript/api/TerraScriptAPIAddon.java

@@ -0,0 +1,16 @@
+package com.dfsek.terra.addons.terrascript.api;
+
+import com.dfsek.terra.api.addon.TerraAddon;
+import com.dfsek.terra.api.addon.annotations.Addon;
+import com.dfsek.terra.api.addon.annotations.Author;
+import com.dfsek.terra.api.addon.annotations.Version;
+
+@Addon("api-terrascript")
+@Version("1.0.0")
+@Author("Terra")
+public class TerraScriptAPIAddon extends TerraAddon {
+    @Override
+    public void initialize() {
+
+    }
+}

common/addons/api-terrascript/src/main/java/com/dfsek/terra/addons/terrascript/api/buffer/Cell.java

@@ -0,0 +1,30 @@
+package com.dfsek.terra.addons.terrascript.api.buffer;
+
+import com.dfsek.terra.api.structure.buffer.BufferedItem;
+import com.dfsek.terra.api.vector.Vector3;
+import com.dfsek.terra.api.world.World;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Cell implements BufferedItem {
+    private final List<BufferedItem> items = new ArrayList<>();
+    private String mark = null;
+
+    @Override
+    public void paste(Vector3 origin, World world) {
+        items.forEach(item -> item.paste(origin.clone(), world));
+    }
+
+    public void add(BufferedItem item) {
+        items.add(item);
+    }
+
+    public String getMark() {
+        return mark;
+    }
+
+    public void setMark(String mark) {
+        this.mark = mark;
+    }
+}

common/addons/api-terrascript/src/main/java/com/dfsek/terra/addons/terrascript/api/buffer/DirectBuffer.java

@@ -0,0 +1,56 @@
+package com.dfsek.terra.addons.terrascript.api.buffer;
+
+import com.dfsek.terra.api.structure.buffer.Buffer;
+import com.dfsek.terra.api.structure.buffer.BufferedItem;
+import com.dfsek.terra.api.vector.Vector3;
+import com.dfsek.terra.api.world.Chunk;
+import com.dfsek.terra.api.world.World;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+/**
+ * Buffer implementation that directly pastes to the world.
+ */
+public class DirectBuffer implements Buffer {
+    private final Vector3 origin;
+    private final World target;
+    private final Map<Vector3, String> marks = new LinkedHashMap<>();
+
+    public DirectBuffer(Vector3 origin, World target) {
+        this.origin = origin;
+        this.target = target;
+    }
+
+    @Override
+    public void paste(Vector3 origin, Chunk chunk) {
+        // no-op
+    }
+
+    @Override
+    public void paste(Vector3 origin, World world) {
+        // no-op
+    }
+
+    @Override
+    public Buffer addItem(BufferedItem item, Vector3 location) {
+        item.paste(origin.clone().add(location), target);
+        return this;
+    }
+
+    @Override
+    public Vector3 getOrigin() {
+        return origin;
+    }
+
+    @Override
+    public String getMark(Vector3 location) {
+        return marks.get(location);
+    }
+
+    @Override
+    public Buffer setMark(String mark, Vector3 location) {
+        marks.put(location, mark);
+        return this;
+    }
+}

common/addons/api-terrascript/src/main/java/com/dfsek/terra/addons/terrascript/api/buffer/IntermediateBuffer.java

@@ -0,0 +1,48 @@
+package com.dfsek.terra.addons.terrascript.api.buffer;
+
+import com.dfsek.terra.api.structure.buffer.Buffer;
+import com.dfsek.terra.api.structure.buffer.BufferedItem;
+import com.dfsek.terra.api.vector.Vector3;
+import com.dfsek.terra.api.world.Chunk;
+import com.dfsek.terra.api.world.World;
+
+public class IntermediateBuffer implements Buffer {
+    private final Buffer original;
+    private final Vector3 offset;
+
+    public IntermediateBuffer(Buffer original, Vector3 offset) {
+        this.original = original;
+        this.offset = offset.clone();
+    }
+
+    @Override
+    public void paste(Vector3 origin, Chunk chunk) {
+        // no-op
+    }
+
+    @Override
+    public void paste(Vector3 origin, World world) {
+        // no-op
+    }
+
+    @Override
+    public Buffer addItem(BufferedItem item, Vector3 location) {
+        return original.addItem(item, location.clone().add(offset));
+    }
+
+    @Override
+    public Vector3 getOrigin() {
+        return original.getOrigin().clone().add(offset);
+    }
+
+    @Override
+    public String getMark(Vector3 location) {
+        return original.getMark(location.clone().add(offset));
+    }
+
+    @Override
+    public Buffer setMark(String mark, Vector3 location) {
+        original.setMark(mark, location.clone().add(offset));
+        return this;
+    }
+}

common/addons/api-terrascript/src/main/java/com/dfsek/terra/addons/terrascript/api/buffer/StructureBuffer.java

@@ -0,0 +1,68 @@
+package com.dfsek.terra.addons.terrascript.api.buffer;
+
+import com.dfsek.terra.api.structure.buffer.Buffer;
+import com.dfsek.terra.api.structure.buffer.BufferedItem;
+import com.dfsek.terra.api.vector.Vector3;
+import com.dfsek.terra.api.world.Chunk;
+import com.dfsek.terra.api.world.World;
+import net.jafama.FastMath;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+public class StructureBuffer implements Buffer {
+    private final Map<Vector3, Cell> bufferedItemMap = new LinkedHashMap<>();
+    private final Vector3 origin;
+    private boolean succeeded;
+
+    public StructureBuffer(Vector3 origin) {
+        this.origin = origin;
+    }
+
+    public void paste(Vector3 origin, World world) {
+        bufferedItemMap.forEach(((vector3, item) -> item.paste(origin.clone().add(vector3), world)));
+    }
+
+    public void paste(Vector3 origin, Chunk chunk) {
+        bufferedItemMap.forEach(((location, item) -> {
+            Vector3 current = origin.clone().add(location);
+            if(FastMath.floorDiv(current.getBlockX(), 16) != chunk.getX() || FastMath.floorDiv(current.getBlockZ(), 16) != chunk.getZ())
+                return;
+            item.paste(current, chunk.getWorld());
+        }));
+    }
+
+    @Override
+    public Buffer addItem(BufferedItem item, Vector3 location) {
+        bufferedItemMap.computeIfAbsent(location.clone(), l -> new Cell()).add(item);
+        return this;
+    }
+
+    @Override
+    public String getMark(Vector3 location) {
+        Cell cell = bufferedItemMap.get(location);
+        if(cell != null) {
+            return cell.getMark();
+        }
+        return null;
+    }
+
+    @Override
+    public Buffer setMark(String mark, Vector3 location) {
+        bufferedItemMap.computeIfAbsent(location.clone(), l -> new Cell()).setMark(mark);
+        return this;
+    }
+
+    public void setSucceeded(boolean succeeded) {
+        this.succeeded = succeeded;
+    }
+
+    public boolean succeeded() {
+        return succeeded;
+    }
+
+    @Override
+    public Vector3 getOrigin() {
+        return origin.clone();
+    }
+}

common/addons/api-terrascript/src/main/java/com/dfsek/terra/addons/terrascript/api/buffer/items/BufferedBlock.java

@@ -0,0 +1,38 @@
+package com.dfsek.terra.addons.terrascript.api.buffer.items;
+
+import com.dfsek.terra.api.TerraPlugin;
+import com.dfsek.terra.api.block.state.BlockState;
+import com.dfsek.terra.api.block.state.properties.base.Properties;
+import com.dfsek.terra.api.structure.buffer.BufferedItem;
+import com.dfsek.terra.api.vector.Vector3;
+import com.dfsek.terra.api.world.World;
+
+public class BufferedBlock implements BufferedItem {
+    private final BlockState data;
+    private final boolean overwrite;
+    private final TerraPlugin main;
+    private final boolean waterlog;
+
+    public BufferedBlock(BlockState data, boolean overwrite, TerraPlugin main, boolean waterlog) {
+        this.data = data;
+        this.overwrite = overwrite;
+        this.main = main;
+        this.waterlog = waterlog;
+    }
+
+    @Override
+    public void paste(Vector3 origin, World world) {
+        try {
+            BlockState current = world.getBlockData(origin);
+            if(overwrite || current.isAir()) {
+                if(waterlog && current.has(Properties.WATERLOGGED) && current.getBlockType().isWater()) {
+                    current.set(Properties.WATERLOGGED, true);
+                }
+                world.setBlockData(origin, data);
+            }
+        } catch(RuntimeException e) {
+            main.logger().severe("Failed to place block at location " + origin + ": " + e.getMessage());
+            main.getDebugLogger().stack(e);
+        }
+    }
+}

common/addons/api-terrascript/src/main/java/com/dfsek/terra/addons/terrascript/api/buffer/items/BufferedEntity.java

@@ -0,0 +1,26 @@
+package com.dfsek.terra.addons.terrascript.api.buffer.items;
+
+import com.dfsek.terra.api.TerraPlugin;
+import com.dfsek.terra.api.entity.Entity;
+import com.dfsek.terra.api.entity.EntityType;
+import com.dfsek.terra.api.event.events.world.generation.EntitySpawnEvent;
+import com.dfsek.terra.api.structure.buffer.BufferedItem;
+import com.dfsek.terra.api.vector.Vector3;
+import com.dfsek.terra.api.world.World;
+
+public class BufferedEntity implements BufferedItem {
+
+    private final EntityType type;
+    private final TerraPlugin main;
+
+    public BufferedEntity(EntityType type, TerraPlugin main) {
+        this.type = type;
+        this.main = main;
+    }
+
+    @Override
+    public void paste(Vector3 origin, World world) {
+        Entity entity = world.spawnEntity(origin.clone().add(0.5, 0, 0.5), type);
+        main.getEventManager().callEvent(new EntitySpawnEvent(entity.world().getConfig().getPack(), entity));
+    }
+}

common/addons/api-terrascript/src/main/java/com/dfsek/terra/addons/terrascript/api/buffer/items/BufferedLootApplication.java

@@ -1,14 +1,16 @@
-package com.dfsek.terra.api.structures.structure.buffer.items;
+package com.dfsek.terra.addons.terrascript.api.buffer.items;
 
+import com.dfsek.terra.addons.terrascript.api.StructureScript;
 import com.dfsek.terra.api.TerraPlugin;
+import com.dfsek.terra.api.block.entity.BlockEntity;
+import com.dfsek.terra.api.block.entity.Container;
 import com.dfsek.terra.api.event.events.world.generation.LootPopulateEvent;
-import com.dfsek.terra.api.math.vector.Location;
-import com.dfsek.terra.api.platform.block.Block;
-import com.dfsek.terra.api.platform.block.state.BlockState;
-import com.dfsek.terra.api.platform.block.state.Container;
-import com.dfsek.terra.api.structures.loot.LootTable;
-import com.dfsek.terra.api.structures.script.StructureScript;
-import com.dfsek.terra.api.util.FastRandom;
+import com.dfsek.terra.api.structure.LootTable;
+import com.dfsek.terra.api.structure.buffer.BufferedItem;
+import com.dfsek.terra.api.vector.Vector3;
+import com.dfsek.terra.api.world.World;
+
+import java.util.Random;
 
 public class BufferedLootApplication implements BufferedItem {
     private final LootTable table;
@@ -22,21 +24,20 @@ public class BufferedLootApplication implements BufferedItem {
     }
 
     @Override
-    public void paste(Location origin) {
+    public void paste(Vector3 origin, World world) {
         try {
-            Block block = origin.getBlock();
-            BlockState data = block.getState();
+            BlockEntity data = world.getBlockState(origin);
             if(!(data instanceof Container)) {
                 main.logger().severe("Failed to place loot at " + origin + "; block " + data + " is not container.");
                 return;
             }
             Container container = (Container) data;
 
-            LootPopulateEvent event = new LootPopulateEvent(block, container, table, block.getLocation().getWorld().getTerraGenerator().getConfigPack(), structure);
+            LootPopulateEvent event = new LootPopulateEvent(container, table, world.getConfig().getPack(), structure);
             main.getEventManager().callEvent(event);
             if(event.isCancelled()) return;
 
-            event.getTable().fillInventory(container.getInventory(), new FastRandom(origin.hashCode()));
+            event.getTable().fillInventory(container.getInventory(), new Random(origin.hashCode()));
             data.update(false);
         } catch(Exception e) {
             main.logger().warning("Could not apply loot at " + origin + ": " + e.getMessage());

common/addons/api-terrascript/src/main/java/com/dfsek/terra/addons/terrascript/api/buffer/items/BufferedPulledBlock.java

@@ -0,0 +1,26 @@
+package com.dfsek.terra.addons.terrascript.api.buffer.items;
+
+import com.dfsek.terra.api.block.state.BlockState;
+import com.dfsek.terra.api.structure.buffer.BufferedItem;
+import com.dfsek.terra.api.vector.Vector3;
+import com.dfsek.terra.api.world.World;
+
+public class BufferedPulledBlock implements BufferedItem {
+    private final BlockState data;
+
+    public BufferedPulledBlock(BlockState data) {
+        this.data = data;
+    }
+
+    @Override
+    public void paste(Vector3 origin, World world) {
+        Vector3 mutable = origin.clone();
+        while(mutable.getY() > world.getMinHeight()) {
+            if(!world.getBlockData(mutable).isAir()) {
+                world.setBlockData(mutable, data);
+                break;
+            }
+            mutable.subtract(0, 1, 0);
+        }
+    }
+}

common/addons/api-terrascript/src/main/java/com/dfsek/terra/addons/terrascript/api/buffer/items/BufferedStateManipulator.java

@@ -1,8 +1,10 @@
-package com.dfsek.terra.api.structures.structure.buffer.items;
+package com.dfsek.terra.addons.terrascript.api.buffer.items;
 
 import com.dfsek.terra.api.TerraPlugin;
-import com.dfsek.terra.api.math.vector.Location;
-import com.dfsek.terra.api.platform.block.state.BlockState;
+import com.dfsek.terra.api.block.entity.BlockEntity;
+import com.dfsek.terra.api.structure.buffer.BufferedItem;
+import com.dfsek.terra.api.vector.Vector3;
+import com.dfsek.terra.api.world.World;
 
 public class BufferedStateManipulator implements BufferedItem {
     private final TerraPlugin main;
@@ -14,9 +16,9 @@ public class BufferedStateManipulator implements BufferedItem {
     }
 
     @Override
-    public void paste(Location origin) {
+    public void paste(Vector3 origin, World world) {
         try {
-            BlockState state = origin.getBlock().getState();
+            BlockEntity state = world.getBlockState(origin);
             state.applyState(data);
             state.update(false);
         } catch(Exception e) {

common/addons/api-terrascript/src/main/java/com/dfsek/terra/addons/terrascript/api/exception/ParseException.java

@@ -1,6 +1,6 @@
-package com.dfsek.terra.api.structures.parser.exceptions;
+package com.dfsek.terra.addons.terrascript.api.exception;
 
-import com.dfsek.terra.api.structures.tokenizer.Position;
+import com.dfsek.terra.addons.terrascript.api.Position;
 
 public class ParseException extends Exception {
     private static final long serialVersionUID = 6744390543046766386L;

common/addons/api-terrascript/src/main/java/com/dfsek/terra/addons/terrascript/api/lang/ConstantExpression.java

@@ -1,9 +1,7 @@
-package com.dfsek.terra.api.structures.parser.lang.constants;
+package com.dfsek.terra.addons.terrascript.api.lang;
 
-import com.dfsek.terra.api.structures.parser.lang.ImplementationArguments;
-import com.dfsek.terra.api.structures.parser.lang.Returnable;
-import com.dfsek.terra.api.structures.parser.lang.variables.Variable;
-import com.dfsek.terra.api.structures.tokenizer.Position;
+import com.dfsek.terra.addons.terrascript.api.Position;
+import com.dfsek.terra.api.properties.Context;
 
 import java.util.Map;
 
@@ -17,7 +15,7 @@ public abstract class ConstantExpression<T> implements Returnable<T> {
     }
 
     @Override
-    public T apply(ImplementationArguments implementationArguments, Map<String, Variable<?>> variableMap) {
+    public T apply(Context context, Map<String, Variable<?>> variableMap) {
         return constant;
     }
 

common/addons/api-terrascript/src/main/java/com/dfsek/terra/addons/terrascript/api/lang/Item.java

@@ -0,0 +1,12 @@
+package com.dfsek.terra.addons.terrascript.api.lang;
+
+import com.dfsek.terra.addons.terrascript.api.Position;
+import com.dfsek.terra.api.properties.Context;
+
+import java.util.Map;
+
+public interface Item<T> {
+    T apply(Context context, Map<String, Variable<?>> variableMap);
+
+    Position getPosition();
+}

common/addons/api-terrascript/src/main/java/com/dfsek/terra/addons/terrascript/api/lang/Returnable.java

@@ -0,0 +1,43 @@
+package com.dfsek.terra.addons.terrascript.api.lang;
+
+import com.dfsek.terra.addons.terrascript.api.Position;
+import com.dfsek.terra.api.properties.Context;
+
+import java.util.Map;
+
+public interface Returnable<T> extends Item<T> {
+    ReturnType returnType();
+
+    enum ReturnType {
+        NUMBER(true), STRING(true), BOOLEAN(false), VOID(false), OBJECT(false);
+
+        private final boolean comparable;
+
+        ReturnType(boolean comparable) {
+            this.comparable = comparable;
+        }
+
+        public boolean isComparable() {
+            return comparable;
+        }
+    }
+
+    static <T> Returnable<T> constant(T value, ReturnType type, Position position) {
+        return new Returnable<T>() {
+            @Override
+            public ReturnType returnType() {
+                return type;
+            }
+
+            @Override
+            public T apply(Context context, Map<String, Variable<?>> variableMap) {
+                return value;
+            }
+
+            @Override
+            public Position getPosition() {
+                return position;
+            }
+        };
+    }
+}

common/addons/api-terrascript/src/main/java/com/dfsek/terra/addons/terrascript/api/lang/Variable.java

@@ -0,0 +1,13 @@
+package com.dfsek.terra.addons.terrascript.api.lang;
+
+import com.dfsek.terra.addons.terrascript.api.Position;
+
+public interface Variable<T> {
+    T getValue();
+
+    void setValue(T value);
+
+    Returnable.ReturnType getType();
+
+    Position getPosition();
+}

common/addons/biome-provider-image/README.md

@@ -0,0 +1,6 @@
+# biome-provider-image
+
+Implements and registers the `IMAGE` biome provider, a biome provider which generates
+biomes from an image, using the `color` attribute of biomes.
+
+This addon registers the provider type, and all associated config options.

common/addons/biome-provider-image/build.gradle.kts

@@ -0,0 +1,2 @@
+dependencies {
+}

common/addons/biome-provider-image/src/main/java/com/dfsek/terra/addons/biome/image/ImageBiomeProvider.java

@@ -1,8 +1,7 @@
-package com.dfsek.terra.api.world.biome.provider;
+package com.dfsek.terra.addons.biome.image;
 
-import com.dfsek.terra.api.registry.Registry;
 import com.dfsek.terra.api.world.biome.TerraBiome;
-import com.dfsek.terra.registry.OpenRegistry;
+import com.dfsek.terra.api.world.biome.generation.BiomeProvider;
 import net.jafama.FastMath;
 
 import java.awt.*;
@@ -11,7 +10,7 @@ import java.util.HashMap;
 import java.util.Map;
 import java.util.Set;
 
-public class ImageBiomeProvider implements BiomeProvider, BiomeProvider.BiomeProviderBuilder { // This provider does not need a seed, so it is its own builder.
+public class ImageBiomeProvider implements BiomeProvider {
     private final Map<Color, TerraBiome> colorBiomeMap = new HashMap<>();
     private final BufferedImage image;
     private final int resolution;
@@ -29,7 +28,7 @@ public class ImageBiomeProvider implements BiomeProvider, BiomeProvider.BiomePro
     }
 
     @Override
-    public TerraBiome getBiome(int x, int z) {
+    public TerraBiome getBiome(int x, int z, long seed) {
         x /= resolution;
         z /= resolution;
         Color color = align.getColor(image, x, z);
@@ -40,11 +39,6 @@ public class ImageBiomeProvider implements BiomeProvider, BiomeProvider.BiomePro
         }));
     }
 
-    @Override
-    public BiomeProvider build(long seed) {
-        return this;
-    }
-
     public enum Align {
         CENTER {
             @Override

common/addons/biome-provider-image/src/main/java/com/dfsek/terra/addons/biome/image/ImageBiomeProviderAddon.java

@@ -0,0 +1,40 @@
+package com.dfsek.terra.addons.biome.image;
+
+import com.dfsek.tectonic.loading.object.ObjectTemplate;
+import com.dfsek.terra.api.TerraPlugin;
+import com.dfsek.terra.api.addon.TerraAddon;
+import com.dfsek.terra.api.addon.annotations.Addon;
+import com.dfsek.terra.api.addon.annotations.Author;
+import com.dfsek.terra.api.addon.annotations.Version;
+import com.dfsek.terra.api.event.events.config.pack.ConfigPackPreLoadEvent;
+import com.dfsek.terra.api.event.functional.FunctionalEventHandler;
+import com.dfsek.terra.api.injection.annotations.Inject;
+import com.dfsek.terra.api.registry.CheckedRegistry;
+import com.dfsek.terra.api.util.reflection.TypeKey;
+import com.dfsek.terra.api.world.biome.TerraBiome;
+import com.dfsek.terra.api.world.biome.generation.BiomeProvider;
+
+import java.util.function.Supplier;
+
+@Addon("biome-provider-image")
+@Author("Terra")
+@Version("1.0.0")
+public class ImageBiomeProviderAddon extends TerraAddon {
+    public static final TypeKey<Supplier<ObjectTemplate<BiomeProvider>>> PROVIDER_REGISTRY_KEY = new TypeKey<>() {
+    };
+
+    @Inject
+    private TerraPlugin main;
+
+    @Override
+    public void initialize() {
+        main.getEventManager()
+                .getHandler(FunctionalEventHandler.class)
+                .register(this, ConfigPackPreLoadEvent.class)
+                .then(event -> {
+                    CheckedRegistry<Supplier<ObjectTemplate<BiomeProvider>>> providerRegistry = event.getPack().getOrCreateRegistry(PROVIDER_REGISTRY_KEY);
+                    providerRegistry.register("IMAGE", () -> new ImageProviderTemplate(event.getPack().getRegistry(TerraBiome.class)));
+                })
+                .failThrough();
+    }
+}

common/addons/biome-provider-image/src/main/java/com/dfsek/terra/addons/biome/image/ImageProviderTemplate.java

@@ -0,0 +1,33 @@
+package com.dfsek.terra.addons.biome.image;
+
+import com.dfsek.tectonic.annotations.Default;
+import com.dfsek.tectonic.annotations.Value;
+import com.dfsek.tectonic.loading.object.ObjectTemplate;
+import com.dfsek.terra.api.registry.Registry;
+import com.dfsek.terra.api.world.biome.TerraBiome;
+import com.dfsek.terra.api.world.biome.generation.BiomeProvider;
+
+import java.awt.image.BufferedImage;
+import java.util.HashSet;
+
+public class ImageProviderTemplate implements ObjectTemplate<BiomeProvider> {
+    private final Registry<TerraBiome> biomes;
+    @Value("image.name")
+    private BufferedImage image;
+
+    @Value("image.align")
+    private ImageBiomeProvider.Align align;
+
+    @Value("resolution")
+    @Default
+    private int resolution = 1;
+
+    public ImageProviderTemplate(Registry<TerraBiome> set) {
+        this.biomes = set;
+    }
+
+    @Override
+    public BiomeProvider get() {
+        return new ImageBiomeProvider(new HashSet<>(biomes.entries()), image, resolution, align);
+    }
+}

common/addons/biome-provider-pipeline/README.md

@@ -0,0 +1,7 @@
+# biome-provider-pipeline
+
+Implements the Biome Pipeline, a procedural biome provider that uses a series
+of "stages" to apply "mutations" to a 2D grid of biomes.
+
+
+This addon registers the `PIPELINE` biome provider type, and all associated configurations.

common/addons/biome-provider-pipeline/build.gradle.kts

@@ -0,0 +1,2 @@
+dependencies {
+}

common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomeHolderImpl.java

@@ -1,18 +1,19 @@
-package com.dfsek.terra.api.world.biome.pipeline;
+package com.dfsek.terra.addons.biome.pipeline;
 
-import com.dfsek.terra.api.math.vector.Vector2;
+import com.dfsek.terra.addons.biome.pipeline.api.BiomeExpander;
+import com.dfsek.terra.addons.biome.pipeline.api.BiomeHolder;
+import com.dfsek.terra.addons.biome.pipeline.api.BiomeMutator;
+import com.dfsek.terra.addons.biome.pipeline.source.BiomeSource;
+import com.dfsek.terra.api.vector.Vector2;
 import com.dfsek.terra.api.world.biome.TerraBiome;
-import com.dfsek.terra.api.world.biome.pipeline.expand.BiomeExpander;
-import com.dfsek.terra.api.world.biome.pipeline.mutator.BiomeMutator;
-import com.dfsek.terra.api.world.biome.pipeline.source.BiomeSource;
 
-public class TerraBiomeHolder implements BiomeHolder {
+public class BiomeHolderImpl implements BiomeHolder {
     private final Vector2 origin;
     private final int width;
-    private TerraBiome[][] biomes;
     private final int offset;
+    private TerraBiome[][] biomes;
 
-    public TerraBiomeHolder(int width, Vector2 origin) {
+    public BiomeHolderImpl(int width, Vector2 origin) {
         width += 4;
         this.width = width;
         biomes = new TerraBiome[width][width];
@@ -20,7 +21,7 @@ public class TerraBiomeHolder implements BiomeHolder {
         this.offset = 2;
     }
 
-    private TerraBiomeHolder(TerraBiome[][] biomes, Vector2 origin, int width, int offset) {
+    private BiomeHolderImpl(TerraBiome[][] biomes, Vector2 origin, int width, int offset) {
         this.biomes = biomes;
         this.origin = origin;
         this.width = width;
@@ -28,7 +29,7 @@ public class TerraBiomeHolder implements BiomeHolder {
     }
 
     @Override
-    public BiomeHolder expand(BiomeExpander expander) {
+    public BiomeHolder expand(BiomeExpander expander, long seed) {
         TerraBiome[][] old = biomes;
         int newWidth = width * 2 - 1;
 
@@ -38,31 +39,31 @@ public class TerraBiomeHolder implements BiomeHolder {
             for(int z = 0; z < width; z++) {
                 biomes[x * 2][z * 2] = old[x][z];
                 if(z != width - 1)
-                    biomes[x * 2][z * 2 + 1] = expander.getBetween(x + origin.getX(), z + 1 + origin.getZ(), old[x][z], old[x][z + 1]);
+                    biomes[x * 2][z * 2 + 1] = expander.getBetween(x + origin.getX(), z + 1 + origin.getZ(), seed, old[x][z], old[x][z + 1]);
                 if(x != width - 1)
-                    biomes[x * 2 + 1][z * 2] = expander.getBetween(x + 1 + origin.getX(), z + origin.getZ(), old[x][z], old[x + 1][z]);
+                    biomes[x * 2 + 1][z * 2] = expander.getBetween(x + 1 + origin.getX(), z + origin.getZ(), seed, old[x][z], old[x + 1][z]);
                 if(x != width - 1 && z != width - 1)
-                    biomes[x * 2 + 1][z * 2 + 1] = expander.getBetween(x + 1 + origin.getX(), z + 1 + origin.getZ(), old[x][z], old[x + 1][z + 1], old[x][z + 1], old[x + 1][z]);
+                    biomes[x * 2 + 1][z * 2 + 1] = expander.getBetween(x + 1 + origin.getX(), z + 1 + origin.getZ(), seed, old[x][z], old[x + 1][z + 1], old[x][z + 1], old[x + 1][z]);
             }
         }
-        return new TerraBiomeHolder(biomes, origin.setX(origin.getX() * 2 - 1).setZ(origin.getZ() * 2 - 1), newWidth, offset);
+        return new BiomeHolderImpl(biomes, origin.setX(origin.getX() * 2 - 1).setZ(origin.getZ() * 2 - 1), newWidth, offset);
     }
 
     @Override
-    public void mutate(BiomeMutator mutator) {
+    public void mutate(BiomeMutator mutator, long seed) {
         for(int x = 0; x < width; x++) {
             for(int z = 0; z < width; z++) {
                 BiomeMutator.ViewPoint viewPoint = new BiomeMutator.ViewPoint(this, x, z);
-                biomes[x][z] = mutator.mutate(viewPoint, x + origin.getX(), z + origin.getZ());
+                biomes[x][z] = mutator.mutate(viewPoint, x + origin.getX(), z + origin.getZ(), seed);
             }
         }
     }
 
     @Override
-    public void fill(BiomeSource source) {
+    public void fill(BiomeSource source, long seed) {
         for(int x = 0; x < width; x++) {
             for(int z = 0; z < width; z++) {
-                biomes[x][z] = source.getBiome(origin.getX() + x, origin.getZ() + z);
+                biomes[x][z] = source.getBiome(origin.getX() + x, origin.getZ() + z, seed);
             }
         }
     }

common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomePipeline.java

@@ -0,0 +1,65 @@
+package com.dfsek.terra.addons.biome.pipeline;
+
+import com.dfsek.terra.addons.biome.pipeline.api.BiomeHolder;
+import com.dfsek.terra.addons.biome.pipeline.api.Stage;
+import com.dfsek.terra.addons.biome.pipeline.source.BiomeSource;
+import com.dfsek.terra.api.vector.Vector2;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class BiomePipeline {
+    private final BiomeSource source;
+    private final List<Stage> stages;
+    private final int size;
+    private final int init;
+
+    private BiomePipeline(BiomeSource source, List<Stage> stages, int size, int init) {
+        this.source = source;
+        this.stages = stages;
+        this.size = size;
+        this.init = init;
+    }
+
+    /**
+     * Get biomes in a chunk
+     *
+     * @param x Chunk X coord
+     * @param z Chunk Z coord
+     * @return BiomeHolder containing biomes.
+     */
+    public BiomeHolder getBiomes(int x, int z, long seed) {
+        BiomeHolder holder = new BiomeHolderImpl(init, new Vector2(x * (init - 1), z * (init - 1)));
+        holder.fill(source, seed);
+        for(Stage stage : stages) holder = stage.apply(holder, seed);
+        return holder;
+    }
+
+    public int getSize() {
+        return size;
+    }
+
+    public static final class BiomePipelineBuilder {
+        private final int init;
+        List<Stage> stages = new ArrayList<>();
+        private int expand;
+
+        public BiomePipelineBuilder(int init) {
+            this.init = init;
+            expand = init;
+        }
+
+        public BiomePipeline build(BiomeSource source) {
+            for(Stage stage : stages) {
+                if(stage.isExpansion()) expand = expand * 2 - 1;
+            }
+
+            return new BiomePipeline(source, stages, expand, init);
+        }
+
+        public BiomePipelineBuilder addStage(Stage stage) {
+            stages.add(stage);
+            return this;
+        }
+    }
+}

common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomePipelineAddon.java

@@ -0,0 +1,67 @@
+package com.dfsek.terra.addons.biome.pipeline;
+
+import com.dfsek.tectonic.loading.object.ObjectTemplate;
+import com.dfsek.terra.addons.biome.pipeline.api.Stage;
+import com.dfsek.terra.addons.biome.pipeline.config.BiomePipelineTemplate;
+import com.dfsek.terra.addons.biome.pipeline.config.NoiseSourceTemplate;
+import com.dfsek.terra.addons.biome.pipeline.config.stage.expander.ExpanderStageTemplate;
+import com.dfsek.terra.addons.biome.pipeline.config.stage.mutator.BorderListMutatorTemplate;
+import com.dfsek.terra.addons.biome.pipeline.config.stage.mutator.BorderMutatorTemplate;
+import com.dfsek.terra.addons.biome.pipeline.config.stage.mutator.ReplaceListMutatorTemplate;
+import com.dfsek.terra.addons.biome.pipeline.config.stage.mutator.ReplaceMutatorTemplate;
+import com.dfsek.terra.addons.biome.pipeline.config.stage.mutator.SmoothMutatorTemplate;
+import com.dfsek.terra.addons.biome.pipeline.source.BiomeSource;
+import com.dfsek.terra.api.TerraPlugin;
+import com.dfsek.terra.api.addon.TerraAddon;
+import com.dfsek.terra.api.addon.annotations.Addon;
+import com.dfsek.terra.api.addon.annotations.Author;
+import com.dfsek.terra.api.addon.annotations.Version;
+import com.dfsek.terra.api.event.events.config.pack.ConfigPackPreLoadEvent;
+import com.dfsek.terra.api.event.functional.FunctionalEventHandler;
+import com.dfsek.terra.api.injection.annotations.Inject;
+import com.dfsek.terra.api.registry.CheckedRegistry;
+import com.dfsek.terra.api.util.reflection.TypeKey;
+import com.dfsek.terra.api.world.biome.generation.BiomeProvider;
+
+import java.util.function.Supplier;
+
+@Addon("biome-provider-pipeline")
+@Author("Terra")
+@Version("1.0.0")
+public class BiomePipelineAddon extends TerraAddon {
+
+    public static final TypeKey<Supplier<ObjectTemplate<BiomeSource>>> SOURCE_REGISTRY_KEY = new TypeKey<>() {
+    };
+
+    public static final TypeKey<Supplier<ObjectTemplate<Stage>>> STAGE_REGISTRY_KEY = new TypeKey<>() {
+    };
+    public static final TypeKey<Supplier<ObjectTemplate<BiomeProvider>>> PROVIDER_REGISTRY_KEY = new TypeKey<>() {
+    };
+    @Inject
+    private TerraPlugin main;
+
+    @Override
+    public void initialize() {
+        main.getEventManager()
+                .getHandler(FunctionalEventHandler.class)
+                .register(this, ConfigPackPreLoadEvent.class)
+                .then(event -> {
+                    CheckedRegistry<Supplier<ObjectTemplate<BiomeProvider>>> providerRegistry = event.getPack().getOrCreateRegistry(PROVIDER_REGISTRY_KEY);
+                    providerRegistry.register("PIPELINE", () -> new BiomePipelineTemplate(main));
+                })
+                .then(event -> {
+                    CheckedRegistry<Supplier<ObjectTemplate<BiomeSource>>> sourceRegistry = event.getPack().getOrCreateRegistry(SOURCE_REGISTRY_KEY);
+                    sourceRegistry.register("NOISE", NoiseSourceTemplate::new);
+                })
+                .then(event -> {
+                    CheckedRegistry<Supplier<ObjectTemplate<Stage>>> stageRegistry = event.getPack().getOrCreateRegistry(STAGE_REGISTRY_KEY);
+                    stageRegistry.register("FRACTAL_EXPAND", ExpanderStageTemplate::new);
+                    stageRegistry.register("SMOOTH", SmoothMutatorTemplate::new);
+                    stageRegistry.register("REPLACE", ReplaceMutatorTemplate::new);
+                    stageRegistry.register("REPLACE_LIST", ReplaceListMutatorTemplate::new);
+                    stageRegistry.register("BORDER", BorderMutatorTemplate::new);
+                    stageRegistry.register("BORDER_LIST", BorderListMutatorTemplate::new);
+                })
+                .failThrough();
+    }
+}

common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomePipelineProvider.java

@@ -0,0 +1,81 @@
+package com.dfsek.terra.addons.biome.pipeline;
+
+import com.dfsek.terra.addons.biome.pipeline.api.BiomeHolder;
+import com.dfsek.terra.api.TerraPlugin;
+import com.dfsek.terra.api.noise.NoiseSampler;
+import com.dfsek.terra.api.world.biome.TerraBiome;
+import com.dfsek.terra.api.world.biome.generation.BiomeProvider;
+import com.google.common.cache.CacheBuilder;
+import com.google.common.cache.CacheLoader;
+import com.google.common.cache.LoadingCache;
+import net.jafama.FastMath;
+import org.jetbrains.annotations.NotNull;
+
+public class BiomePipelineProvider implements BiomeProvider {
+    private final LoadingCache<SeededVector, BiomeHolder> holderCache;
+    private final BiomePipeline pipeline;
+    private final int resolution;
+    private final NoiseSampler mutator;
+    private final double noiseAmp;
+
+    public BiomePipelineProvider(BiomePipeline pipeline, TerraPlugin main, int resolution, NoiseSampler mutator, double noiseAmp) {
+        this.resolution = resolution;
+        this.mutator = mutator;
+        this.noiseAmp = noiseAmp;
+        holderCache = CacheBuilder.newBuilder()
+                .maximumSize(main == null ? 32 : main.getTerraConfig().getProviderCache())
+                .build(
+                        new CacheLoader<SeededVector, BiomeHolder>() {
+                            @Override
+                            public BiomeHolder load(@NotNull SeededVector key) {
+                                return pipeline.getBiomes(key.x, key.z, key.seed);
+                            }
+                        }
+                );
+        this.pipeline = pipeline;
+    }
+
+    @Override
+    public TerraBiome getBiome(int x, int z, long seed) {
+        x += mutator.getNoiseSeeded(seed + 1, x, z) * noiseAmp;
+        z += mutator.getNoiseSeeded(seed + 2, x, z) * noiseAmp;
+
+
+        x = FastMath.floorToInt(FastMath.floorDiv(x, resolution));
+
+        z = FastMath.floorToInt(FastMath.floorDiv(z, resolution));
+
+        int fdX = FastMath.floorDiv(x, pipeline.getSize());
+        int fdZ = FastMath.floorDiv(z, pipeline.getSize());
+        return holderCache.getUnchecked(new SeededVector(fdX, fdZ, seed)).getBiome(x - fdX * pipeline.getSize(), z - fdZ * pipeline.getSize());
+    }
+
+    private static final class SeededVector {
+        private final int x;
+        private final int z;
+        private final long seed;
+
+        private SeededVector(int x, int z, long seed) {
+            this.x = x;
+            this.z = z;
+            this.seed = seed;
+        }
+
+        @Override
+        public int hashCode() {
+            int result = 0;
+            result = 31 * result + ((int) (seed ^ (seed >>> 32)));
+            result = 31 * result + x;
+            result = 31 * result + z;
+            return result;
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+            if(!(obj instanceof SeededVector)) return false;
+            SeededVector that = (SeededVector) obj;
+
+            return this.seed == that.seed && this.x == that.x && this.z == that.z;
+        }
+    }
+}

common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/BiomeExpander.java

@@ -0,0 +1,7 @@
+package com.dfsek.terra.addons.biome.pipeline.api;
+
+import com.dfsek.terra.api.world.biome.TerraBiome;
+
+public interface BiomeExpander {
+    TerraBiome getBetween(double x, double z, long seed, TerraBiome... others);
+}

common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/BiomeHolder.java

@@ -0,0 +1,16 @@
+package com.dfsek.terra.addons.biome.pipeline.api;
+
+import com.dfsek.terra.addons.biome.pipeline.source.BiomeSource;
+import com.dfsek.terra.api.world.biome.TerraBiome;
+
+public interface BiomeHolder {
+    BiomeHolder expand(BiomeExpander expander, long seed);
+
+    void mutate(BiomeMutator mutator, long seed);
+
+    void fill(BiomeSource source, long seed);
+
+    TerraBiome getBiome(int x, int z);
+
+    TerraBiome getBiomeRaw(int x, int z);
+}

common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/BiomeMutator.java

@@ -1,10 +1,9 @@
-package com.dfsek.terra.api.world.biome.pipeline.mutator;
+package com.dfsek.terra.addons.biome.pipeline.api;
 
 import com.dfsek.terra.api.world.biome.TerraBiome;
-import com.dfsek.terra.api.world.biome.pipeline.BiomeHolder;
 
 public interface BiomeMutator {
-    TerraBiome mutate(ViewPoint viewPoint, double x, double z);
+    TerraBiome mutate(ViewPoint viewPoint, double x, double z, long seed);
 
     class ViewPoint {
         private final BiomeHolder biomes;

common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/api/Stage.java

@@ -0,0 +1,8 @@
+package com.dfsek.terra.addons.biome.pipeline.api;
+
+public interface Stage {
+    boolean isExpansion();
+
+    BiomeHolder apply(BiomeHolder in, long seed);
+
+}

common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/BiomePipelineTemplate.java

@@ -1,13 +1,14 @@
-package com.dfsek.terra.config.loaders.config.biome.templates.provider;
+package com.dfsek.terra.addons.biome.pipeline.config;
 
 import com.dfsek.tectonic.annotations.Default;
 import com.dfsek.tectonic.annotations.Value;
+import com.dfsek.terra.addons.biome.pipeline.BiomePipeline;
+import com.dfsek.terra.addons.biome.pipeline.BiomePipelineProvider;
+import com.dfsek.terra.addons.biome.pipeline.api.Stage;
+import com.dfsek.terra.addons.biome.pipeline.source.BiomeSource;
 import com.dfsek.terra.api.TerraPlugin;
-import com.dfsek.terra.api.util.seeded.SourceSeeded;
-import com.dfsek.terra.api.util.seeded.StageSeeded;
-import com.dfsek.terra.api.world.biome.pipeline.BiomePipeline;
-import com.dfsek.terra.api.world.biome.provider.BiomeProvider;
-import com.dfsek.terra.api.world.biome.provider.StandardBiomeProvider;
+import com.dfsek.terra.api.config.meta.Meta;
+import com.dfsek.terra.api.world.biome.generation.BiomeProvider;
 
 import java.util.List;
 
@@ -16,23 +17,23 @@ public class BiomePipelineTemplate extends BiomeProviderTemplate {
     private final TerraPlugin main;
     @Value("pipeline.initial-size")
     @Default
-    private int initialSize = 2;
+    private @Meta int initialSize = 2;
 
     @Value("pipeline.stages")
-    private List<StageSeeded> stages;
+    private @Meta List<@Meta Stage> stages;
 
     @Value("pipeline.source")
-    private SourceSeeded source;
+    private @Meta BiomeSource source;
 
     public BiomePipelineTemplate(TerraPlugin main) {
         this.main = main;
     }
 
     @Override
-    public BiomeProvider build(long seed) {
+    public BiomeProvider get() {
         BiomePipeline.BiomePipelineBuilder biomePipelineBuilder = new BiomePipeline.BiomePipelineBuilder(initialSize);
         stages.forEach(biomePipelineBuilder::addStage);
-        BiomePipeline pipeline = biomePipelineBuilder.build(source.apply(seed), seed);
-        return new StandardBiomeProvider(pipeline, main, resolution, blend.apply(seed), blendAmp, (int) seed);
+        BiomePipeline pipeline = biomePipelineBuilder.build(source);
+        return new BiomePipelineProvider(pipeline, main, resolution, blend, blendAmp);
     }
 }

common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/BiomeProviderLoader.java

@@ -0,0 +1,16 @@
+package com.dfsek.terra.addons.biome.pipeline.config;
+
+import com.dfsek.tectonic.exception.LoadException;
+import com.dfsek.tectonic.loading.ConfigLoader;
+import com.dfsek.tectonic.loading.TypeLoader;
+import com.dfsek.terra.addons.biome.pipeline.BiomePipelineProvider;
+import com.dfsek.terra.api.world.biome.generation.BiomeProvider;
+
+import java.lang.reflect.AnnotatedType;
+
+public class BiomeProviderLoader implements TypeLoader<BiomeProvider> {
+    @Override
+    public BiomeProvider load(AnnotatedType t, Object c, ConfigLoader loader) throws LoadException {
+        return loader.loadType(BiomePipelineProvider.class, c); // TODO: actually implement this lol
+    }
+}

common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/BiomeProviderTemplate.java

@@ -0,0 +1,20 @@
+package com.dfsek.terra.addons.biome.pipeline.config;
+
+import com.dfsek.tectonic.annotations.Default;
+import com.dfsek.tectonic.annotations.Value;
+import com.dfsek.tectonic.loading.object.ObjectTemplate;
+import com.dfsek.terra.api.config.meta.Meta;
+import com.dfsek.terra.api.noise.NoiseSampler;
+import com.dfsek.terra.api.world.biome.generation.BiomeProvider;
+
+public abstract class BiomeProviderTemplate implements ObjectTemplate<BiomeProvider> {
+    @Value("resolution")
+    @Default
+    protected @Meta int resolution = 1;
+    @Value("blend.noise")
+    @Default
+    protected @Meta NoiseSampler blend = NoiseSampler.zero();
+    @Value("blend.amplitude")
+    @Default
+    protected @Meta double blendAmp = 0d;
+}

common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/NoiseSourceTemplate.java

@@ -0,0 +1,22 @@
+package com.dfsek.terra.addons.biome.pipeline.config;
+
+import com.dfsek.tectonic.annotations.Value;
+import com.dfsek.terra.addons.biome.pipeline.source.BiomeSource;
+import com.dfsek.terra.addons.biome.pipeline.source.NoiseSource;
+import com.dfsek.terra.api.config.meta.Meta;
+import com.dfsek.terra.api.noise.NoiseSampler;
+import com.dfsek.terra.api.util.collection.ProbabilityCollection;
+import com.dfsek.terra.api.world.biome.TerraBiome;
+
+public class NoiseSourceTemplate extends SourceTemplate {
+    @Value("noise")
+    private @Meta NoiseSampler noise;
+
+    @Value("biomes")
+    private @Meta ProbabilityCollection<@Meta TerraBiome> biomes;
+
+    @Override
+    public BiomeSource get() {
+        return new NoiseSource(biomes, noise);
+    }
+}

common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/SourceTemplate.java

@@ -0,0 +1,8 @@
+package com.dfsek.terra.addons.biome.pipeline.config;
+
+import com.dfsek.tectonic.loading.object.ObjectTemplate;
+import com.dfsek.terra.addons.biome.pipeline.source.BiomeSource;
+
+public abstract class SourceTemplate implements ObjectTemplate<BiomeSource> {
+
+}

common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/stage/StageTemplate.java

@@ -0,0 +1,12 @@
+package com.dfsek.terra.addons.biome.pipeline.config.stage;
+
+import com.dfsek.tectonic.annotations.Value;
+import com.dfsek.tectonic.loading.object.ObjectTemplate;
+import com.dfsek.terra.addons.biome.pipeline.api.Stage;
+import com.dfsek.terra.api.config.meta.Meta;
+import com.dfsek.terra.api.noise.NoiseSampler;
+
+public abstract class StageTemplate implements ObjectTemplate<Stage> {
+    @Value("noise")
+    protected @Meta NoiseSampler noise;
+}

common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/stage/expander/ExpanderStageTemplate.java

@@ -0,0 +1,13 @@
+package com.dfsek.terra.addons.biome.pipeline.config.stage.expander;
+
+import com.dfsek.terra.addons.biome.pipeline.api.Stage;
+import com.dfsek.terra.addons.biome.pipeline.config.stage.StageTemplate;
+import com.dfsek.terra.addons.biome.pipeline.expand.FractalExpander;
+import com.dfsek.terra.addons.biome.pipeline.stages.ExpanderStage;
+
+public class ExpanderStageTemplate extends StageTemplate {
+    @Override
+    public Stage get() {
+        return new ExpanderStage(new FractalExpander(noise));
+    }
+}

common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/stage/mutator/BorderListMutatorTemplate.java

@@ -0,0 +1,33 @@
+package com.dfsek.terra.addons.biome.pipeline.config.stage.mutator;
+
+import com.dfsek.tectonic.annotations.Value;
+import com.dfsek.terra.addons.biome.pipeline.api.Stage;
+import com.dfsek.terra.addons.biome.pipeline.config.stage.StageTemplate;
+import com.dfsek.terra.addons.biome.pipeline.mutator.BorderListMutator;
+import com.dfsek.terra.addons.biome.pipeline.stages.MutatorStage;
+import com.dfsek.terra.api.config.meta.Meta;
+import com.dfsek.terra.api.util.collection.ProbabilityCollection;
+import com.dfsek.terra.api.world.biome.TerraBiome;
+
+import java.util.Map;
+
+@SuppressWarnings("unused")
+public class BorderListMutatorTemplate extends StageTemplate {
+    @Value("from")
+    private @Meta String from;
+
+    @Value("default-replace")
+    private @Meta String defaultReplace;
+
+    @Value("default-to")
+    private @Meta ProbabilityCollection<@Meta TerraBiome> defaultTo;
+
+    @Value("replace")
+    private @Meta Map<@Meta TerraBiome, @Meta ProbabilityCollection<@Meta TerraBiome>> replace;
+
+
+    @Override
+    public Stage get() {
+        return new MutatorStage(new BorderListMutator(replace, from, defaultReplace, noise, defaultTo));
+    }
+}

common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/stage/mutator/BorderMutatorTemplate.java

@@ -0,0 +1,27 @@
+package com.dfsek.terra.addons.biome.pipeline.config.stage.mutator;
+
+import com.dfsek.tectonic.annotations.Value;
+import com.dfsek.terra.addons.biome.pipeline.api.Stage;
+import com.dfsek.terra.addons.biome.pipeline.config.stage.StageTemplate;
+import com.dfsek.terra.addons.biome.pipeline.mutator.BorderMutator;
+import com.dfsek.terra.addons.biome.pipeline.stages.MutatorStage;
+import com.dfsek.terra.api.config.meta.Meta;
+import com.dfsek.terra.api.util.collection.ProbabilityCollection;
+import com.dfsek.terra.api.world.biome.TerraBiome;
+
+@SuppressWarnings("unused")
+public class BorderMutatorTemplate extends StageTemplate {
+    @Value("from")
+    private @Meta String from;
+
+    @Value("replace")
+    private @Meta String replace;
+
+    @Value("to")
+    private @Meta ProbabilityCollection<@Meta TerraBiome> to;
+
+    @Override
+    public Stage get() {
+        return new MutatorStage(new BorderMutator(from, replace, noise, to));
+    }
+}

common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/stage/mutator/ReplaceListMutatorTemplate.java

@@ -0,0 +1,29 @@
+package com.dfsek.terra.addons.biome.pipeline.config.stage.mutator;
+
+import com.dfsek.tectonic.annotations.Value;
+import com.dfsek.terra.addons.biome.pipeline.api.Stage;
+import com.dfsek.terra.addons.biome.pipeline.config.stage.StageTemplate;
+import com.dfsek.terra.addons.biome.pipeline.mutator.ReplaceListMutator;
+import com.dfsek.terra.addons.biome.pipeline.stages.MutatorStage;
+import com.dfsek.terra.api.config.meta.Meta;
+import com.dfsek.terra.api.util.collection.ProbabilityCollection;
+import com.dfsek.terra.api.world.biome.TerraBiome;
+
+import java.util.Map;
+
+@SuppressWarnings("unused")
+public class ReplaceListMutatorTemplate extends StageTemplate {
+    @Value("default-from")
+    private @Meta String defaultFrom;
+
+    @Value("default-to")
+    private @Meta ProbabilityCollection<@Meta TerraBiome> defaultTo;
+
+    @Value("to")
+    private @Meta Map<@Meta TerraBiome, @Meta ProbabilityCollection<@Meta TerraBiome>> replace;
+
+    @Override
+    public Stage get() {
+        return new MutatorStage(new ReplaceListMutator(replace, defaultFrom, defaultTo, noise));
+    }
+}

common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/stage/mutator/ReplaceMutatorTemplate.java

@@ -0,0 +1,24 @@
+package com.dfsek.terra.addons.biome.pipeline.config.stage.mutator;
+
+import com.dfsek.tectonic.annotations.Value;
+import com.dfsek.terra.addons.biome.pipeline.api.Stage;
+import com.dfsek.terra.addons.biome.pipeline.config.stage.StageTemplate;
+import com.dfsek.terra.addons.biome.pipeline.mutator.ReplaceMutator;
+import com.dfsek.terra.addons.biome.pipeline.stages.MutatorStage;
+import com.dfsek.terra.api.config.meta.Meta;
+import com.dfsek.terra.api.util.collection.ProbabilityCollection;
+import com.dfsek.terra.api.world.biome.TerraBiome;
+
+@SuppressWarnings("unused")
+public class ReplaceMutatorTemplate extends StageTemplate {
+    @Value("from")
+    private @Meta String from;
+
+    @Value("to")
+    private @Meta ProbabilityCollection<@Meta TerraBiome> to;
+
+    @Override
+    public Stage get() {
+        return new MutatorStage(new ReplaceMutator(from, to, noise));
+    }
+}

common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/config/stage/mutator/SmoothMutatorTemplate.java

@@ -0,0 +1,13 @@
+package com.dfsek.terra.addons.biome.pipeline.config.stage.mutator;
+
+import com.dfsek.terra.addons.biome.pipeline.api.Stage;
+import com.dfsek.terra.addons.biome.pipeline.config.stage.StageTemplate;
+import com.dfsek.terra.addons.biome.pipeline.mutator.SmoothMutator;
+import com.dfsek.terra.addons.biome.pipeline.stages.MutatorStage;
+
+public class SmoothMutatorTemplate extends StageTemplate {
+    @Override
+    public Stage get() {
+        return new MutatorStage(new SmoothMutator(noise));
+    }
+}

common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/expand/FractalExpander.java

@@ -0,0 +1,19 @@
+package com.dfsek.terra.addons.biome.pipeline.expand;
+
+import com.dfsek.terra.addons.biome.pipeline.api.BiomeExpander;
+import com.dfsek.terra.api.noise.NoiseSampler;
+import com.dfsek.terra.api.util.MathUtil;
+import com.dfsek.terra.api.world.biome.TerraBiome;
+
+public class FractalExpander implements BiomeExpander {
+    private final NoiseSampler sampler;
+
+    public FractalExpander(NoiseSampler sampler) {
+        this.sampler = sampler;
+    }
+
+    @Override
+    public TerraBiome getBetween(double x, double z, long seed, TerraBiome... others) {
+        return others[MathUtil.normalizeIndex(sampler.getNoiseSeeded(seed, x, z), others.length)];
+    }
+}

common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/mutator/BorderListMutator.java

@@ -1,7 +1,8 @@
-package com.dfsek.terra.api.world.biome.pipeline.mutator;
+package com.dfsek.terra.addons.biome.pipeline.mutator;
 
-import com.dfsek.terra.api.math.noise.NoiseSampler;
-import com.dfsek.terra.api.util.collections.ProbabilityCollection;
+import com.dfsek.terra.addons.biome.pipeline.api.BiomeMutator;
+import com.dfsek.terra.api.noise.NoiseSampler;
+import com.dfsek.terra.api.util.collection.ProbabilityCollection;
 import com.dfsek.terra.api.world.biome.TerraBiome;
 
 import java.util.Map;
@@ -22,7 +23,7 @@ public class BorderListMutator implements BiomeMutator {
     }
 
     @Override
-    public TerraBiome mutate(ViewPoint viewPoint, double x, double z) {
+    public TerraBiome mutate(ViewPoint viewPoint, double x, double z, long seed) {
         TerraBiome origin = viewPoint.getBiome(0, 0);
         if(origin.getTags().contains(defaultReplace)) {
             for(int xi = -1; xi <= 1; xi++) {
@@ -32,10 +33,10 @@ public class BorderListMutator implements BiomeMutator {
                     if(current == null) continue;
                     if(current.getTags().contains(border)) {
                         if(replace.containsKey(origin)) {
-                            TerraBiome biome = replace.get(origin).get(noiseSampler, x, z);
+                            TerraBiome biome = replace.get(origin).get(noiseSampler, x, z, seed);
                             return biome == null ? origin : biome;
                         }
-                        TerraBiome biome = replaceDefault.get(noiseSampler, x, z);
+                        TerraBiome biome = replaceDefault.get(noiseSampler, x, z, seed);
                         return biome == null ? origin : biome;
                     }
                 }

common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/mutator/BorderMutator.java

@@ -1,7 +1,8 @@
-package com.dfsek.terra.api.world.biome.pipeline.mutator;
+package com.dfsek.terra.addons.biome.pipeline.mutator;
 
-import com.dfsek.terra.api.math.noise.NoiseSampler;
-import com.dfsek.terra.api.util.collections.ProbabilityCollection;
+import com.dfsek.terra.addons.biome.pipeline.api.BiomeMutator;
+import com.dfsek.terra.api.noise.NoiseSampler;
+import com.dfsek.terra.api.util.collection.ProbabilityCollection;
 import com.dfsek.terra.api.world.biome.TerraBiome;
 
 public class BorderMutator implements BiomeMutator {
@@ -18,7 +19,7 @@ public class BorderMutator implements BiomeMutator {
     }
 
     @Override
-    public TerraBiome mutate(ViewPoint viewPoint, double x, double z) {
+    public TerraBiome mutate(ViewPoint viewPoint, double x, double z, long seed) {
         TerraBiome origin = viewPoint.getBiome(0, 0);
         if(origin.getTags().contains(replaceTag)) {
             for(int xi = -1; xi <= 1; xi++) {
@@ -27,7 +28,7 @@ public class BorderMutator implements BiomeMutator {
                     TerraBiome current = viewPoint.getBiome(xi, zi);
                     if(current == null) continue;
                     if(current.getTags().contains(border)) {
-                        TerraBiome biome = replace.get(noiseSampler, x, z);
+                        TerraBiome biome = replace.get(noiseSampler, x, z, seed);
                         return biome == null ? origin : biome;
                     }
                 }

common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/mutator/ReplaceListMutator.java

@@ -1,7 +1,8 @@
-package com.dfsek.terra.api.world.biome.pipeline.mutator;
+package com.dfsek.terra.addons.biome.pipeline.mutator;
 
-import com.dfsek.terra.api.math.noise.NoiseSampler;
-import com.dfsek.terra.api.util.collections.ProbabilityCollection;
+import com.dfsek.terra.addons.biome.pipeline.api.BiomeMutator;
+import com.dfsek.terra.api.noise.NoiseSampler;
+import com.dfsek.terra.api.util.collection.ProbabilityCollection;
 import com.dfsek.terra.api.world.biome.TerraBiome;
 
 import java.util.Map;
@@ -20,14 +21,14 @@ public class ReplaceListMutator implements BiomeMutator {
     }
 
     @Override
-    public TerraBiome mutate(ViewPoint viewPoint, double x, double z) {
+    public TerraBiome mutate(ViewPoint viewPoint, double x, double z, long seed) {
         TerraBiome center = viewPoint.getBiome(0, 0);
         if(replace.containsKey(center)) {
-            TerraBiome biome = replace.get(center).get(sampler, x, z);
+            TerraBiome biome = replace.get(center).get(sampler, x, z, seed);
             return biome == null ? viewPoint.getBiome(0, 0) : biome;
         }
         if(viewPoint.getBiome(0, 0).getTags().contains(defaultTag)) {
-            TerraBiome biome = replaceDefault.get(sampler, x, z);
+            TerraBiome biome = replaceDefault.get(sampler, x, z, seed);
             return biome == null ? viewPoint.getBiome(0, 0) : biome;
         }
         return center;

common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/mutator/ReplaceMutator.java

@@ -1,7 +1,8 @@
-package com.dfsek.terra.api.world.biome.pipeline.mutator;
+package com.dfsek.terra.addons.biome.pipeline.mutator;
 
-import com.dfsek.terra.api.math.noise.NoiseSampler;
-import com.dfsek.terra.api.util.collections.ProbabilityCollection;
+import com.dfsek.terra.addons.biome.pipeline.api.BiomeMutator;
+import com.dfsek.terra.api.noise.NoiseSampler;
+import com.dfsek.terra.api.util.collection.ProbabilityCollection;
 import com.dfsek.terra.api.world.biome.TerraBiome;
 
 public class ReplaceMutator implements BiomeMutator {
@@ -16,9 +17,9 @@ public class ReplaceMutator implements BiomeMutator {
     }
 
     @Override
-    public TerraBiome mutate(ViewPoint viewPoint, double x, double z) {
+    public TerraBiome mutate(ViewPoint viewPoint, double x, double z, long seed) {
         if(viewPoint.getBiome(0, 0).getTags().contains(replaceableTag)) {
-            TerraBiome biome = replace.get(sampler, x, z);
+            TerraBiome biome = replace.get(sampler, x, z, seed);
             return biome == null ? viewPoint.getBiome(0, 0) : biome;
         }
         return viewPoint.getBiome(0, 0);

common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/mutator/SmoothMutator.java

@@ -1,7 +1,8 @@
-package com.dfsek.terra.api.world.biome.pipeline.mutator;
+package com.dfsek.terra.addons.biome.pipeline.mutator;
 
-import com.dfsek.terra.api.math.MathUtil;
-import com.dfsek.terra.api.math.noise.NoiseSampler;
+import com.dfsek.terra.addons.biome.pipeline.api.BiomeMutator;
+import com.dfsek.terra.api.noise.NoiseSampler;
+import com.dfsek.terra.api.util.MathUtil;
 import com.dfsek.terra.api.world.biome.TerraBiome;
 
 import java.util.Objects;
@@ -15,7 +16,7 @@ public class SmoothMutator implements BiomeMutator {
     }
 
     @Override
-    public TerraBiome mutate(ViewPoint viewPoint, double x, double z) {
+    public TerraBiome mutate(ViewPoint viewPoint, double x, double z, long seed) {
         TerraBiome top = viewPoint.getBiome(1, 0);
         TerraBiome bottom = viewPoint.getBiome(-1, 0);
         TerraBiome left = viewPoint.getBiome(0, 1);
@@ -26,7 +27,7 @@ public class SmoothMutator implements BiomeMutator {
         boolean horiz = Objects.equals(left, right) && left != null;
 
         if(vert && horiz) {
-            return MathUtil.normalizeIndex(sampler.getNoise(x, z), 2) == 0 ? left : top;
+            return MathUtil.normalizeIndex(sampler.getNoiseSeeded(seed, x, z), 2) == 0 ? left : top;
         }
 
         if(vert) return top;

common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/source/BiomeSource.java

@@ -0,0 +1,7 @@
+package com.dfsek.terra.addons.biome.pipeline.source;
+
+import com.dfsek.terra.api.world.biome.TerraBiome;
+
+public interface BiomeSource {
+    TerraBiome getBiome(double x, double z, long seed);
+}

common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/source/NoiseSource.java

@@ -0,0 +1,20 @@
+package com.dfsek.terra.addons.biome.pipeline.source;
+
+import com.dfsek.terra.api.noise.NoiseSampler;
+import com.dfsek.terra.api.util.collection.ProbabilityCollection;
+import com.dfsek.terra.api.world.biome.TerraBiome;
+
+public class NoiseSource implements BiomeSource {
+    private final ProbabilityCollection<TerraBiome> biomes;
+    private final NoiseSampler sampler;
+
+    public NoiseSource(ProbabilityCollection<TerraBiome> biomes, NoiseSampler sampler) {
+        this.biomes = biomes;
+        this.sampler = sampler;
+    }
+
+    @Override
+    public TerraBiome getBiome(double x, double z, long seed) {
+        return biomes.get(sampler, x, z, seed);
+    }
+}

common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/stages/ExpanderStage.java

@@ -0,0 +1,27 @@
+package com.dfsek.terra.addons.biome.pipeline.stages;
+
+import com.dfsek.terra.addons.biome.pipeline.api.BiomeExpander;
+import com.dfsek.terra.addons.biome.pipeline.api.BiomeHolder;
+import com.dfsek.terra.addons.biome.pipeline.api.Stage;
+
+public class ExpanderStage implements Stage {
+    private final BiomeExpander expander;
+
+    public ExpanderStage(BiomeExpander expander) {
+        this.expander = expander;
+    }
+
+    @Override
+    public boolean isExpansion() {
+        return true;
+    }
+
+    @Override
+    public BiomeHolder apply(BiomeHolder in, long seed) {
+        return in.expand(expander, seed);
+    }
+
+    public enum Type {
+        FRACTAL
+    }
+}

common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/stages/MutatorStage.java

@@ -1,7 +1,8 @@
-package com.dfsek.terra.api.world.biome.pipeline.stages;
+package com.dfsek.terra.addons.biome.pipeline.stages;
 
-import com.dfsek.terra.api.world.biome.pipeline.BiomeHolder;
-import com.dfsek.terra.api.world.biome.pipeline.mutator.BiomeMutator;
+import com.dfsek.terra.addons.biome.pipeline.api.BiomeHolder;
+import com.dfsek.terra.addons.biome.pipeline.api.BiomeMutator;
+import com.dfsek.terra.addons.biome.pipeline.api.Stage;
 
 public class MutatorStage implements Stage {
     private final BiomeMutator mutator;
@@ -16,8 +17,8 @@ public class MutatorStage implements Stage {
     }
 
     @Override
-    public BiomeHolder apply(BiomeHolder in) {
-        in.mutate(mutator);
+    public BiomeHolder apply(BiomeHolder in, long seed) {
+        in.mutate(mutator, seed);
         return in;
     }
 

common/addons/biome-provider-single/README.md

@@ -0,0 +1,4 @@
+# biome-provider-single
+
+Registers and configures the `SINGLE` biome provider, a biome provider which
+accepts a single biome to generate continuously.

common/addons/biome-provider-single/build.gradle.kts

@@ -0,0 +1,2 @@
+dependencies {
+}

common/addons/biome-provider-single/src/main/java/com/dfsek/terra/addons/biome/single/SingleBiomeProvider.java

@@ -0,0 +1,17 @@
+package com.dfsek.terra.addons.biome.single;
+
+import com.dfsek.terra.api.world.biome.TerraBiome;
+import com.dfsek.terra.api.world.biome.generation.BiomeProvider;
+
+public class SingleBiomeProvider implements BiomeProvider {
+    private final TerraBiome biome;
+
+    public SingleBiomeProvider(TerraBiome biome) {
+        this.biome = biome;
+    }
+
+    @Override
+    public TerraBiome getBiome(int x, int z, long seed) {
+        return biome;
+    }
+}

common/addons/biome-provider-single/src/main/java/com/dfsek/terra/addons/biome/single/SingleBiomeProviderAddon.java

@@ -0,0 +1,39 @@
+package com.dfsek.terra.addons.biome.single;
+
+import com.dfsek.tectonic.loading.object.ObjectTemplate;
+import com.dfsek.terra.api.TerraPlugin;
+import com.dfsek.terra.api.addon.TerraAddon;
+import com.dfsek.terra.api.addon.annotations.Addon;
+import com.dfsek.terra.api.addon.annotations.Author;
+import com.dfsek.terra.api.addon.annotations.Version;
+import com.dfsek.terra.api.event.events.config.pack.ConfigPackPreLoadEvent;
+import com.dfsek.terra.api.event.functional.FunctionalEventHandler;
+import com.dfsek.terra.api.injection.annotations.Inject;
+import com.dfsek.terra.api.registry.CheckedRegistry;
+import com.dfsek.terra.api.util.reflection.TypeKey;
+import com.dfsek.terra.api.world.biome.generation.BiomeProvider;
+
+import java.util.function.Supplier;
+
+@Addon("biome-provider-single")
+@Author("Terra")
+@Version("1.0.0")
+public class SingleBiomeProviderAddon extends TerraAddon {
+    public static final TypeKey<Supplier<ObjectTemplate<BiomeProvider>>> PROVIDER_REGISTRY_KEY = new TypeKey<>() {
+    };
+
+    @Inject
+    private TerraPlugin main;
+
+    @Override
+    public void initialize() {
+        main.getEventManager()
+                .getHandler(FunctionalEventHandler.class)
+                .register(this, ConfigPackPreLoadEvent.class)
+                .then(event -> {
+                    CheckedRegistry<Supplier<ObjectTemplate<BiomeProvider>>> providerRegistry = event.getPack().getOrCreateRegistry(PROVIDER_REGISTRY_KEY);
+                    providerRegistry.register("SINGLE", SingleBiomeProviderTemplate::new);
+                })
+                .failThrough();
+    }
+}

common/addons/biome-provider-single/src/main/java/com/dfsek/terra/addons/biome/single/SingleBiomeProviderTemplate.java

@@ -0,0 +1,17 @@
+package com.dfsek.terra.addons.biome.single;
+
+import com.dfsek.tectonic.annotations.Value;
+import com.dfsek.tectonic.loading.object.ObjectTemplate;
+import com.dfsek.terra.api.config.meta.Meta;
+import com.dfsek.terra.api.world.biome.TerraBiome;
+import com.dfsek.terra.api.world.biome.generation.BiomeProvider;
+
+public class SingleBiomeProviderTemplate implements ObjectTemplate<BiomeProvider> {
+    @Value("biome")
+    private @Meta TerraBiome biome;
+
+    @Override
+    public BiomeProvider get() {
+        return new SingleBiomeProvider(biome);
+    }
+}

common/addons/chunk-generator-noise-3d/README.md

@@ -0,0 +1,4 @@
+# chunk-generator-noise-3d
+
+Registers the `NOISE_3D` chunk generator, a chunk generator which uses biomes'
+samplers in 3D to generate chunk data.

common/addons/chunk-generator-noise-3d/build.gradle.kts

@@ -0,0 +1,2 @@
+dependencies {
+}

common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/BiomePaletteTemplate.java

@@ -0,0 +1,30 @@
+package com.dfsek.terra.addons.chunkgenerator;
+
+import com.dfsek.tectonic.annotations.Default;
+import com.dfsek.tectonic.annotations.Value;
+import com.dfsek.tectonic.loading.object.ObjectTemplate;
+import com.dfsek.terra.addons.chunkgenerator.palette.PaletteHolder;
+import com.dfsek.terra.addons.chunkgenerator.palette.PaletteInfo;
+import com.dfsek.terra.addons.chunkgenerator.palette.SlantHolder;
+import com.dfsek.terra.api.config.meta.Meta;
+import com.dfsek.terra.api.world.generator.Palette;
+
+public class BiomePaletteTemplate implements ObjectTemplate<PaletteInfo> {
+    @Value("palette")
+    private @Meta PaletteHolder palette;
+
+    @Value("slant")
+    @Default
+    private @Meta SlantHolder slant = null;
+
+    @Value("ocean.level")
+    private @Meta int seaLevel;
+
+    @Value("ocean.palette")
+    private @Meta Palette oceanPalette;
+
+    @Override
+    public PaletteInfo get() {
+        return new PaletteInfo(palette, slant, oceanPalette, seaLevel);
+    }
+}

common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/NoiseChunkGenerator3DAddon.java

@@ -0,0 +1,50 @@
+package com.dfsek.terra.addons.chunkgenerator;
+
+import com.dfsek.terra.addons.chunkgenerator.generation.generators.NoiseChunkGenerator3D;
+import com.dfsek.terra.addons.chunkgenerator.palette.PaletteHolder;
+import com.dfsek.terra.addons.chunkgenerator.palette.PaletteHolderLoader;
+import com.dfsek.terra.addons.chunkgenerator.palette.SlantHolder;
+import com.dfsek.terra.addons.chunkgenerator.palette.SlantHolderLoader;
+import com.dfsek.terra.api.TerraPlugin;
+import com.dfsek.terra.api.addon.TerraAddon;
+import com.dfsek.terra.api.addon.annotations.Addon;
+import com.dfsek.terra.api.addon.annotations.Author;
+import com.dfsek.terra.api.addon.annotations.Version;
+import com.dfsek.terra.api.event.events.config.ConfigurationLoadEvent;
+import com.dfsek.terra.api.event.events.config.pack.ConfigPackPreLoadEvent;
+import com.dfsek.terra.api.event.functional.FunctionalEventHandler;
+import com.dfsek.terra.api.injection.annotations.Inject;
+import com.dfsek.terra.api.world.biome.TerraBiome;
+import com.dfsek.terra.api.world.generator.ChunkGeneratorProvider;
+
+@Addon("chunk-generator-noise-3d")
+@Author("Terra")
+@Version("1.0.0")
+public class NoiseChunkGenerator3DAddon extends TerraAddon {
+    @Inject
+    private TerraPlugin main;
+
+    @Override
+    public void initialize() {
+        main.getEventManager()
+                .getHandler(FunctionalEventHandler.class)
+                .register(this, ConfigPackPreLoadEvent.class)
+                .then(event -> {
+                    event.getPack().getOrCreateRegistry(ChunkGeneratorProvider.class).register("NOISE_3D", pack -> new NoiseChunkGenerator3D(pack, main));
+                    event.getPack()
+                            .applyLoader(SlantHolder.class, new SlantHolderLoader())
+                            .applyLoader(PaletteHolder.class, new PaletteHolderLoader());
+                })
+                .failThrough();
+
+        main.getEventManager()
+                .getHandler(FunctionalEventHandler.class)
+                .register(this, ConfigurationLoadEvent.class)
+                .then(event -> {
+                    if(event.is(TerraBiome.class)) {
+                        event.getLoadedObject(TerraBiome.class).getContext().put(event.load(new BiomePaletteTemplate()).get());
+                    }
+                })
+                .failThrough();
+    }
+}

common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/PaletteUtil.java

@@ -0,0 +1,22 @@
+package com.dfsek.terra.addons.chunkgenerator;
+
+import com.dfsek.terra.addons.chunkgenerator.palette.PaletteInfo;
+import com.dfsek.terra.addons.chunkgenerator.palette.SlantHolder;
+import com.dfsek.terra.api.util.MathUtil;
+import com.dfsek.terra.api.world.biome.GenerationSettings;
+import com.dfsek.terra.api.world.generator.Palette;
+import com.dfsek.terra.api.world.generator.Sampler;
+
+public final class PaletteUtil {
+    public static Palette getPalette(int x, int y, int z, GenerationSettings c, Sampler sampler, PaletteInfo paletteInfo) {
+        SlantHolder slant = paletteInfo.getSlantHolder();
+        if(slant != null) {
+            double slope = MathUtil.derivative(sampler, x, y, z);
+            if(slope > slant.getMinSlope()) {
+                return slant.getPalette(slope).getPalette(y);
+            }
+        }
+
+        return paletteInfo.getPaletteHolder().getPalette(y);
+    }
+}

common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/generators/NoiseChunkGenerator3D.java

@@ -0,0 +1,189 @@
+package com.dfsek.terra.addons.chunkgenerator.generation.generators;
+
+import com.dfsek.terra.addons.chunkgenerator.PaletteUtil;
+import com.dfsek.terra.addons.chunkgenerator.generation.math.samplers.Sampler3D;
+import com.dfsek.terra.addons.chunkgenerator.palette.PaletteInfo;
+import com.dfsek.terra.api.TerraPlugin;
+import com.dfsek.terra.api.block.state.BlockState;
+import com.dfsek.terra.api.block.state.properties.base.Properties;
+import com.dfsek.terra.api.block.state.properties.enums.Direction;
+import com.dfsek.terra.api.config.ConfigPack;
+import com.dfsek.terra.api.profiler.ProfileFrame;
+import com.dfsek.terra.api.vector.Vector3;
+import com.dfsek.terra.api.world.BiomeGrid;
+import com.dfsek.terra.api.world.World;
+import com.dfsek.terra.api.world.biome.GenerationSettings;
+import com.dfsek.terra.api.world.biome.TerraBiome;
+import com.dfsek.terra.api.world.biome.generation.BiomeProvider;
+import com.dfsek.terra.api.world.generator.ChunkData;
+import com.dfsek.terra.api.world.generator.ChunkGenerator;
+import com.dfsek.terra.api.world.generator.GenerationStage;
+import com.dfsek.terra.api.world.generator.Palette;
+import com.dfsek.terra.api.world.generator.Sampler;
+import net.jafama.FastMath;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+public class NoiseChunkGenerator3D implements ChunkGenerator {
+    private final ConfigPack configPack;
+    private final TerraPlugin main;
+    private final List<GenerationStage> generationStages = new ArrayList<>();
+
+    private final BlockState air;
+
+    public NoiseChunkGenerator3D(ConfigPack c, TerraPlugin main) {
+        this.configPack = c;
+        this.main = main;
+        this.air = main.getWorldHandle().air();
+        c.getStages().forEach(stage -> generationStages.add(stage.newInstance(c)));
+    }
+
+    @SuppressWarnings({"try"})
+    static void biomes(@NotNull World world, int chunkX, int chunkZ, @NotNull BiomeGrid biome, TerraPlugin main) {
+        try(ProfileFrame ignore = main.getProfiler().profile("biomes")) {
+            int xOrig = (chunkX << 4);
+            int zOrig = (chunkZ << 4);
+            long seed = world.getSeed();
+            BiomeProvider grid = world.getBiomeProvider();
+            for(int x = 0; x < 4; x++) {
+                for(int z = 0; z < 4; z++) {
+                    int cx = xOrig + (x << 2);
+                    int cz = zOrig + (z << 2);
+                    TerraBiome b = grid.getBiome(cx, cz, seed);
+
+                    biome.setBiome(cx, cz, b.getVanillaBiomes().get(b.getGenerator().getBiomeNoise(), cx, 0, cz, world.getSeed()));
+                }
+            }
+        }
+    }
+
+    @Override
+    public ConfigPack getConfigPack() {
+        return configPack;
+    }
+
+    @Override
+    public TerraPlugin getMain() {
+        return main;
+    }
+
+    @Override
+    @SuppressWarnings({"try"})
+    public ChunkData generateChunkData(@NotNull World world, Random random, int chunkX, int chunkZ, ChunkData chunk) {
+        try(ProfileFrame ignore = main.getProfiler().profile("chunk_base_3d")) {
+            BiomeProvider grid = world.getBiomeProvider();
+
+            int xOrig = (chunkX << 4);
+            int zOrig = (chunkZ << 4);
+
+            Sampler sampler = world.getConfig().getSamplerCache().getChunk(chunkX, chunkZ);
+
+            long seed = world.getSeed();
+
+            for(int x = 0; x < 16; x++) {
+                for(int z = 0; z < 16; z++) {
+                    int paletteLevel = 0;
+
+                    int cx = xOrig + x;
+                    int cz = zOrig + z;
+
+                    TerraBiome biome = grid.getBiome(cx, cz, seed);
+
+                    PaletteInfo paletteInfo = biome.getContext().get(PaletteInfo.class);
+
+                    if(paletteInfo == null) {
+                        main.logger().info("null palette: " + biome.getID());
+                    }
+
+                    GenerationSettings generationSettings = biome.getGenerator();
+
+                    int sea = paletteInfo.getSeaLevel();
+                    Palette seaPalette = paletteInfo.getOcean();
+
+                    boolean justSet = false;
+                    BlockState data = null;
+                    for(int y = world.getMaxHeight() - 1; y >= world.getMinHeight(); y--) {
+                        if(sampler.sample(x, y, z) > 0) {
+                            justSet = true;
+
+                            data = PaletteUtil.getPalette(x, y, z, generationSettings, sampler, paletteInfo).get(paletteLevel, cx, y, cz, seed);
+                            chunk.setBlock(x, y, z, data);
+
+                            paletteLevel++;
+                        } else if(y <= sea) {
+                            chunk.setBlock(x, y, z, seaPalette.get(sea - y, x + xOrig, y, z + zOrig, seed));
+
+                            justSet = false;
+                            paletteLevel = 0;
+                        } else {
+
+                            justSet = false;
+                            paletteLevel = 0;
+                        }
+                    }
+                }
+            }
+            return chunk;
+        }
+    }
+
+    private boolean placeStair(BlockState orig, ChunkData chunk, Vector3 block, double thresh, Sampler sampler, BlockState stairNew) {
+
+        if(sampler.sample(block.getBlockX() - 0.55, block.getY(), block.getZ()) > thresh) {
+            stairNew.set(Properties.DIRECTION, Direction.WEST);
+        } else if(sampler.sample(block.getBlockX(), block.getY(), block.getZ() - 0.55) > thresh) {
+            stairNew.set(Properties.DIRECTION, Direction.NORTH);
+        } else if(sampler.sample(block.getBlockX(), block.getY(), block.getZ() + 0.55) > thresh) {
+            stairNew.set(Properties.DIRECTION, Direction.SOUTH);
+        } else if(sampler.sample(block.getX() + 0.55, block.getY(), block.getZ()) > thresh) {
+            stairNew.set(Properties.DIRECTION, Direction.EAST);
+        } else stairNew = null;
+        if(stairNew != null) {
+            stairNew.setIfPresent(Properties.WATERLOGGED, orig.getBlockType().isWater());
+            chunk.setBlock(block.getBlockX(), block.getBlockY(), block.getBlockZ(), stairNew);
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public void generateBiomes(@NotNull World world, @NotNull Random random, int chunkX, int chunkZ, @NotNull BiomeGrid biome) {
+        biomes(world, chunkX, chunkZ, biome, main);
+    }
+
+    @Override
+    public Sampler createSampler(int chunkX, int chunkZ, BiomeProvider provider, World world, int elevationSmooth) {
+        return new Sampler3D(chunkX, chunkZ, provider, world, elevationSmooth);
+    }
+
+    @Override
+    public List<GenerationStage> getGenerationStages() {
+        return generationStages;
+    }
+
+    @Override
+    public BlockState getBlock(World world, int x, int y, int z) {
+        BiomeProvider provider = world.getBiomeProvider();
+        TerraBiome biome = provider.getBiome(x, z, world.getSeed());
+        Sampler sampler = world.getConfig().getSamplerCache().get(x, z);
+
+        PaletteInfo paletteInfo = biome.getContext().get(PaletteInfo.class);
+        Palette palette = PaletteUtil.getPalette(x, y, z, biome.getGenerator(), sampler, paletteInfo);
+        int fdX = FastMath.floorMod(x, 16);
+        int fdZ = FastMath.floorMod(z, 16);
+        double noise = sampler.sample(fdX, y, fdZ);
+        if(noise > 0) {
+            int level = 0;
+            for(int yi = world.getMaxHeight() - 1; yi > y; yi--) {
+                if(sampler.sample(fdX, yi, fdZ) > 0) level++;
+                else level = 0;
+            }
+            return palette.get(level, x, y, z, world.getSeed());
+        } else if(y <= paletteInfo.getSeaLevel()) {
+            return paletteInfo.getOcean().get(paletteInfo.getSeaLevel() - y, x, y, z, world.getSeed());
+        } else return air;
+    }
+}

common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/ChunkInterpolator2D.java

@@ -1,10 +1,11 @@
-package com.dfsek.terra.world.generation.math.interpolation;
+package com.dfsek.terra.addons.chunkgenerator.generation.math.interpolation;
 
-import com.dfsek.terra.api.math.vector.Vector3;
-import com.dfsek.terra.api.platform.world.World;
 import com.dfsek.terra.api.util.mutable.MutableInteger;
-import com.dfsek.terra.api.world.biome.Generator;
-import com.dfsek.terra.api.world.biome.provider.BiomeProvider;
+import com.dfsek.terra.api.vector.Vector3;
+import com.dfsek.terra.api.world.World;
+import com.dfsek.terra.api.world.biome.GenerationSettings;
+import com.dfsek.terra.api.world.biome.generation.BiomeProvider;
+import com.dfsek.terra.api.world.generator.ChunkInterpolator;
 import net.jafama.FastMath;
 
 import java.util.HashMap;
@@ -17,7 +18,7 @@ import java.util.function.BiFunction;
  */
 public class ChunkInterpolator2D implements ChunkInterpolator {
     private final Interpolator[][] interpGrid = new Interpolator[4][4];
-    private final BiFunction<Generator, Vector3, Double> noiseGetter;
+    private final BiFunction<GenerationSettings, Vector3, Double> noiseGetter;
 
     /**
      * Instantiates a 3D ChunkInterpolator3D at a pair of chunk coordinates.
@@ -26,24 +27,26 @@ public class ChunkInterpolator2D implements ChunkInterpolator {
      * @param chunkZ   Z coordinate of the chunk.
      * @param provider Biome Provider to use for biome fetching.
      */
-    public ChunkInterpolator2D(World w, int chunkX, int chunkZ, BiomeProvider provider, BiFunction<Generator, Vector3, Double> noiseGetter) {
+    public ChunkInterpolator2D(World w, int chunkX, int chunkZ, BiomeProvider provider, BiFunction<GenerationSettings, Vector3, Double> noiseGetter) {
         this.noiseGetter = noiseGetter;
         int xOrigin = chunkX << 4;
         int zOrigin = chunkZ << 4;
 
+        long seed = w.getSeed();
+
         double[][] noiseStorage = new double[5][5];
 
         for(int x = 0; x < 5; x++) {
             for(int z = 0; z < 5; z++) {
-                Generator generator = provider.getBiome(xOrigin + (x << 2), zOrigin + (z << 2)).getGenerator(w);
-                Map<Generator, MutableInteger> genMap = new HashMap<>();
+                GenerationSettings generationSettings = provider.getBiome(xOrigin + (x << 2), zOrigin + (z << 2), seed).getGenerator();
+                Map<GenerationSettings, MutableInteger> genMap = new HashMap<>();
 
-                int step = generator.getBlendStep();
-                int blend = generator.getBlendDistance();
+                int step = generationSettings.getBlendStep();
+                int blend = generationSettings.getBlendDistance();
 
                 for(int xi = -blend; xi <= blend; xi++) {
                     for(int zi = -blend; zi <= blend; zi++) {
-                        genMap.computeIfAbsent(provider.getBiome(xOrigin + (x << 2) + (xi * step), zOrigin + (z << 2) + (zi * step)).getGenerator(w), g -> new MutableInteger(0)).increment(); // Increment by 1
+                        genMap.computeIfAbsent(provider.getBiome(xOrigin + (x << 2) + (xi * step), zOrigin + (z << 2) + (zi * step), seed).getGenerator(), g -> new MutableInteger(0)).increment(); // Increment by 1
                     }
                 }
 
@@ -66,8 +69,8 @@ public class ChunkInterpolator2D implements ChunkInterpolator {
         return FastMath.max(FastMath.min(value, high), 0);
     }
 
-    public double computeNoise(Generator generator, double x, double y, double z) {
-        return noiseGetter.apply(generator, new Vector3(x, y, z));
+    public double computeNoise(GenerationSettings generationSettings, double x, double y, double z) {
+        return noiseGetter.apply(generationSettings, new Vector3(x, y, z));
     }
 
     /**

common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/ChunkInterpolator3D.java

@@ -1,10 +1,11 @@
-package com.dfsek.terra.world.generation.math.interpolation;
+package com.dfsek.terra.addons.chunkgenerator.generation.math.interpolation;
 
-import com.dfsek.terra.api.math.vector.Vector3;
-import com.dfsek.terra.api.platform.world.World;
 import com.dfsek.terra.api.util.mutable.MutableInteger;
-import com.dfsek.terra.api.world.biome.Generator;
-import com.dfsek.terra.api.world.biome.provider.BiomeProvider;
+import com.dfsek.terra.api.vector.Vector3;
+import com.dfsek.terra.api.world.World;
+import com.dfsek.terra.api.world.biome.GenerationSettings;
+import com.dfsek.terra.api.world.biome.generation.BiomeProvider;
+import com.dfsek.terra.api.world.generator.ChunkInterpolator;
 import net.jafama.FastMath;
 
 import java.util.HashMap;
@@ -17,7 +18,7 @@ import java.util.function.BiFunction;
  */
 public class ChunkInterpolator3D implements ChunkInterpolator {
     private final Interpolator3[][][] interpGrid;
-    private final BiFunction<Generator, Vector3, Double> noiseGetter;
+    private final BiFunction<GenerationSettings, Vector3, Double> noiseGetter;
 
     private final int min;
     private final int max;
@@ -29,7 +30,7 @@ public class ChunkInterpolator3D implements ChunkInterpolator {
      * @param chunkZ   Z coordinate of the chunk.
      * @param provider Biome Provider to use for biome fetching.
      */
-    public ChunkInterpolator3D(World w, int chunkX, int chunkZ, BiomeProvider provider, BiFunction<Generator, Vector3, Double> noiseGetter) {
+    public ChunkInterpolator3D(World w, int chunkX, int chunkZ, BiomeProvider provider, BiFunction<GenerationSettings, Vector3, Double> noiseGetter) {
         this.noiseGetter = noiseGetter;
         int xOrigin = chunkX << 4;
         int zOrigin = chunkZ << 4;
@@ -44,17 +45,19 @@ public class ChunkInterpolator3D implements ChunkInterpolator {
 
         double[][][] noiseStorage = new double[5][5][size + 1];
 
+        long seed = w.getSeed();
+
         for(int x = 0; x < 5; x++) {
             for(int z = 0; z < 5; z++) {
-                Generator generator = provider.getBiome(xOrigin + (x << 2), zOrigin + (z << 2)).getGenerator(w);
-                Map<Generator, MutableInteger> genMap = new HashMap<>();
+                GenerationSettings generationSettings = provider.getBiome(xOrigin + (x << 2), zOrigin + (z << 2), seed).getGenerator();
+                Map<GenerationSettings, MutableInteger> genMap = new HashMap<>();
 
-                int step = generator.getBlendStep();
-                int blend = generator.getBlendDistance();
+                int step = generationSettings.getBlendStep();
+                int blend = generationSettings.getBlendDistance();
 
                 for(int xi = -blend; xi <= blend; xi++) {
                     for(int zi = -blend; zi <= blend; zi++) {
-                        genMap.computeIfAbsent(provider.getBiome(xOrigin + (x << 2) + (xi * step), zOrigin + (z << 2) + (zi * step)).getGenerator(w), g -> new MutableInteger(0)).increment(); // Increment by 1
+                        genMap.computeIfAbsent(provider.getBiome(xOrigin + (x << 2) + (xi * step), zOrigin + (z << 2) + (zi * step), seed).getGenerator(), g -> new MutableInteger(0)).increment(); // Increment by 1
                     }
                 }
 
@@ -81,14 +84,14 @@ public class ChunkInterpolator3D implements ChunkInterpolator {
         }
     }
 
-    public double computeNoise(Generator generator, double x, double y, double z) {
-        return noiseGetter.apply(generator, new Vector3(x, y, z));
-    }
-
     private static int reRange(int value, int high) {
         return FastMath.max(FastMath.min(value, high), 0);
     }
 
+    public double computeNoise(GenerationSettings generationSettings, double x, double y, double z) {
+        return noiseGetter.apply(generationSettings, new Vector3(x, y, z));
+    }
+
     /**
      * Gets the noise at a pair of internal chunk coordinates.
      *

common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/ElevationInterpolator.java

@@ -1,9 +1,8 @@
-package com.dfsek.terra.world.generation.math.interpolation;
+package com.dfsek.terra.addons.chunkgenerator.generation.math.interpolation;
 
-import com.dfsek.terra.api.platform.world.World;
-import com.dfsek.terra.api.world.biome.Generator;
-import com.dfsek.terra.api.world.biome.provider.BiomeProvider;
-import com.dfsek.terra.world.generation.WorldGenerator;
+import com.dfsek.terra.api.world.World;
+import com.dfsek.terra.api.world.biome.GenerationSettings;
+import com.dfsek.terra.api.world.biome.generation.BiomeProvider;
 
 public class ElevationInterpolator {
     private final double[][] values = new double[18][18];
@@ -12,12 +11,14 @@ public class ElevationInterpolator {
         int xOrigin = chunkX << 4;
         int zOrigin = chunkZ << 4;
 
-        WorldGenerator[][] gens = new WorldGenerator[18 + 2 * smooth][18 + 2 * smooth];
+        long seed = world.getSeed();
+
+        GenerationSettings[][] gens = new GenerationSettings[18 + 2 * smooth][18 + 2 * smooth];
 
         // Precompute generators.
         for(int x = -1 - smooth; x <= 16 + smooth; x++) {
             for(int z = -1 - smooth; z <= 16 + smooth; z++) {
-                gens[x + 1 + smooth][z + 1 + smooth] = (WorldGenerator) provider.getBiome(xOrigin + x, zOrigin + z).getGenerator(world);
+                gens[x + 1 + smooth][z + 1 + smooth] = provider.getBiome(xOrigin + x, zOrigin + z, seed).getGenerator();
             }
         }
 
@@ -27,8 +28,8 @@ public class ElevationInterpolator {
                 double div = 0;
                 for(int xi = -smooth; xi <= smooth; xi++) {
                     for(int zi = -smooth; zi <= smooth; zi++) {
-                        Generator gen = gens[x + 1 + smooth + xi][z + 1 + smooth + zi];
-                        noise += gen.getElevationSampler().getNoise(xOrigin + x, zOrigin + z) * gen.getElevationWeight();
+                        GenerationSettings gen = gens[x + 1 + smooth + xi][z + 1 + smooth + zi];
+                        noise += gen.getElevationSampler().getNoiseSeeded(seed, xOrigin + x, zOrigin + z) * gen.getElevationWeight();
                         div += gen.getElevationWeight();
                     }
                 }

common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/Interpolator.java

@@ -1,4 +1,4 @@
-package com.dfsek.terra.world.generation.math.interpolation;
+package com.dfsek.terra.addons.chunkgenerator.generation.math.interpolation;
 
 /**
  * Class for bilinear interpolation of values arranged on a unit square.

common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/interpolation/Interpolator3.java

@@ -1,4 +1,4 @@
-package com.dfsek.terra.world.generation.math.interpolation;
+package com.dfsek.terra.addons.chunkgenerator.generation.math.interpolation;
 
 /**
  * Class for bilinear interpolation of values arranged on a unit square.

common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/samplers/Sampler3D.java

@@ -1,9 +1,10 @@
-package com.dfsek.terra.world.generation.math.samplers;
+package com.dfsek.terra.addons.chunkgenerator.generation.math.samplers;
 
-import com.dfsek.terra.api.platform.world.World;
-import com.dfsek.terra.api.world.biome.provider.BiomeProvider;
-import com.dfsek.terra.world.generation.math.interpolation.ChunkInterpolator3D;
-import com.dfsek.terra.world.generation.math.interpolation.ElevationInterpolator;
+import com.dfsek.terra.addons.chunkgenerator.generation.math.interpolation.ChunkInterpolator3D;
+import com.dfsek.terra.addons.chunkgenerator.generation.math.interpolation.ElevationInterpolator;
+import com.dfsek.terra.api.world.World;
+import com.dfsek.terra.api.world.biome.generation.BiomeProvider;
+import com.dfsek.terra.api.world.generator.Sampler;
 import net.jafama.FastMath;
 
 public class Sampler3D implements Sampler {
@@ -11,7 +12,7 @@ public class Sampler3D implements Sampler {
     private final ElevationInterpolator elevationInterpolator;
 
     public Sampler3D(int x, int z, BiomeProvider provider, World world, int elevationSmooth) {
-        this.interpolator = new ChunkInterpolator3D(world, x, z, provider, (generator, coord) -> generator.getBaseSampler().getNoise(coord));
+        this.interpolator = new ChunkInterpolator3D(world, x, z, provider, (generator, coord) -> generator.getBaseSampler().getNoiseSeeded(coord, world.getSeed()));
         this.elevationInterpolator = new ElevationInterpolator(world, x, z, provider, elevationSmooth);
     }
 

common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/PaletteHolder.java

@@ -1,18 +1,17 @@
-package com.dfsek.terra.api.world.palette.holder;
+package com.dfsek.terra.addons.chunkgenerator.palette;
 
-import com.dfsek.terra.api.platform.block.BlockData;
-import com.dfsek.terra.api.world.palette.Palette;
+import com.dfsek.terra.api.world.generator.Palette;
 
 public class PaletteHolder {
-    private final Palette<BlockData>[] palettes;
+    private final Palette[] palettes;
     private final int offset;
 
-    protected PaletteHolder(Palette<BlockData>[] palettes, int offset) {
+    protected PaletteHolder(Palette[] palettes, int offset) {
         this.palettes = palettes;
         this.offset = offset;
     }
 
-    public Palette<BlockData> getPalette(int y) {
+    public Palette getPalette(int y) {
         int index = y + offset;
         return index >= 0
                 ? index < palettes.length

common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/PaletteHolderBuilder.java

@@ -1,30 +1,28 @@
-package com.dfsek.terra.api.world.palette.holder;
+package com.dfsek.terra.addons.chunkgenerator.palette;
 
-import com.dfsek.terra.api.platform.block.BlockData;
-import com.dfsek.terra.api.world.palette.Palette;
+import com.dfsek.terra.api.world.generator.Palette;
 import net.jafama.FastMath;
 
 import java.util.Map;
 import java.util.TreeMap;
 
 public class PaletteHolderBuilder {
-    private final TreeMap<Integer, Palette<BlockData>> paletteMap = new TreeMap<>();
+    private final TreeMap<Integer, Palette> paletteMap = new TreeMap<>();
 
-    public PaletteHolderBuilder add(int y, Palette<BlockData> palette) {
+    public PaletteHolderBuilder add(int y, Palette palette) {
         paletteMap.put(y, palette);
         return this;
     }
 
-    @SuppressWarnings({"unchecked", "rawtypes", "RedundantSuppression"})
     public PaletteHolder build() {
 
         int min = FastMath.min(paletteMap.keySet().stream().min(Integer::compareTo).orElse(0), 0);
         int max = FastMath.max(paletteMap.keySet().stream().max(Integer::compareTo).orElse(255), 255);
 
-        Palette<BlockData>[] palettes = new Palette[paletteMap.lastKey() + 1 - min];
+        Palette[] palettes = new Palette[paletteMap.lastKey() + 1 - min];
         for(int y = min; y <= FastMath.max(paletteMap.lastKey(), max); y++) {
-            Palette<BlockData> d = null;
-            for(Map.Entry<Integer, Palette<BlockData>> e : paletteMap.entrySet()) {
+            Palette d = null;
+            for(Map.Entry<Integer, Palette> e : paletteMap.entrySet()) {
                 if(e.getKey() >= y) {
                     d = e.getValue();
                     break;

common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/PaletteHolderLoader.java

@@ -0,0 +1,25 @@
+package com.dfsek.terra.addons.chunkgenerator.palette;
+
+import com.dfsek.tectonic.exception.LoadException;
+import com.dfsek.tectonic.loading.ConfigLoader;
+import com.dfsek.tectonic.loading.TypeLoader;
+import com.dfsek.terra.api.world.generator.Palette;
+
+import java.lang.reflect.AnnotatedType;
+import java.util.List;
+import java.util.Map;
+
+public class PaletteHolderLoader implements TypeLoader<PaletteHolder> {
+    @SuppressWarnings("unchecked")
+    @Override
+    public PaletteHolder load(AnnotatedType type, Object o, ConfigLoader configLoader) throws LoadException {
+        List<Map<String, Integer>> palette = (List<Map<String, Integer>>) o;
+        PaletteHolderBuilder builder = new PaletteHolderBuilder();
+        for(Map<String, Integer> layer : palette) {
+            for(Map.Entry<String, Integer> entry : layer.entrySet()) {
+                builder.add(entry.getValue(), configLoader.loadType(Palette.class, entry.getKey()));
+            }
+        }
+        return builder.build();
+    }
+}

common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/PaletteInfo.java

@@ -0,0 +1,35 @@
+package com.dfsek.terra.addons.chunkgenerator.palette;
+
+import com.dfsek.terra.api.properties.Properties;
+import com.dfsek.terra.api.world.generator.Palette;
+
+public class PaletteInfo implements Properties {
+    private final PaletteHolder paletteHolder;
+    private final SlantHolder slantHolder;
+    private final Palette ocean;
+
+    private final int seaLevel;
+
+    public PaletteInfo(PaletteHolder paletteHolder, SlantHolder slantHolder, Palette ocean, int seaLevel) {
+        this.paletteHolder = paletteHolder;
+        this.slantHolder = slantHolder;
+        this.ocean = ocean;
+        this.seaLevel = seaLevel;
+    }
+
+    public Palette getOcean() {
+        return ocean;
+    }
+
+    public PaletteHolder getPaletteHolder() {
+        return paletteHolder;
+    }
+
+    public SlantHolder getSlantHolder() {
+        return slantHolder;
+    }
+
+    public int getSeaLevel() {
+        return seaLevel;
+    }
+}

common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/SlantHolder.java

@@ -0,0 +1,22 @@
+package com.dfsek.terra.addons.chunkgenerator.palette;
+
+
+import java.util.TreeMap;
+
+public class SlantHolder {
+    private final TreeMap<Double, PaletteHolder> layers;
+    private final double minSlope;
+
+    public SlantHolder(TreeMap<Double, PaletteHolder> layers, double minSlope) {
+        this.layers = layers;
+        this.minSlope = minSlope;
+    }
+
+    public PaletteHolder getPalette(double slope) {
+        return layers.floorEntry(slope).getValue();
+    }
+
+    public double getMinSlope() {
+        return minSlope;
+    }
+}

common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/SlantHolderLoader.java

@@ -0,0 +1,28 @@
+package com.dfsek.terra.addons.chunkgenerator.palette;
+
+import com.dfsek.tectonic.exception.LoadException;
+import com.dfsek.tectonic.loading.ConfigLoader;
+import com.dfsek.tectonic.loading.TypeLoader;
+
+import java.lang.reflect.AnnotatedType;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+
+@SuppressWarnings("unchecked")
+public class SlantHolderLoader implements TypeLoader<SlantHolder> {
+    @Override
+    public SlantHolder load(AnnotatedType type, Object o, ConfigLoader configLoader) throws LoadException {
+        List<Map<Object, Object>> layers = (List<Map<Object, Object>>) o;
+        TreeMap<Double, PaletteHolder> slantLayers = new TreeMap<>();
+        double minThreshold = Double.MAX_VALUE;
+
+        for(Map<Object, Object> layer : layers) {
+            double threshold = ((Number) layer.get("threshold")).doubleValue();
+            if(threshold < minThreshold) minThreshold = threshold;
+            slantLayers.put(threshold, configLoader.loadType(PaletteHolder.class, layer.get("palette")));
+        }
+
+        return new SlantHolder(slantLayers, minThreshold);
+    }
+}

common/addons/config-biome/README.md

@@ -0,0 +1,3 @@
+# config-biome
+
+Registers the default configuration for Terra Biomes, `BIOME`.

common/addons/config-biome/build.gradle.kts

@@ -0,0 +1,2 @@
+dependencies {
+}

common/addons/config-biome/src/main/java/com/dfsek/terra/addons/biome/BiomeAddon.java

@@ -0,0 +1,32 @@
+package com.dfsek.terra.addons.biome;
+
+import com.dfsek.terra.addons.biome.holder.PaletteHolder;
+import com.dfsek.terra.addons.biome.holder.PaletteHolderLoader;
+import com.dfsek.terra.api.TerraPlugin;
+import com.dfsek.terra.api.addon.TerraAddon;
+import com.dfsek.terra.api.addon.annotations.Addon;
+import com.dfsek.terra.api.addon.annotations.Author;
+import com.dfsek.terra.api.addon.annotations.Version;
+import com.dfsek.terra.api.event.events.config.pack.ConfigPackPreLoadEvent;
+import com.dfsek.terra.api.event.functional.FunctionalEventHandler;
+import com.dfsek.terra.api.injection.annotations.Inject;
+
+@Addon("config-biome")
+@Author("Terra")
+@Version("1.0.0")
+public class BiomeAddon extends TerraAddon {
+    @Inject
+    private TerraPlugin main;
+
+    @Override
+    public void initialize() {
+        main.getEventManager()
+                .getHandler(FunctionalEventHandler.class)
+                .register(this, ConfigPackPreLoadEvent.class)
+                .then(event -> {
+                    event.getPack().registerConfigType(new BiomeConfigType(event.getPack()), "BIOME", 5);
+                    event.getPack().applyLoader(PaletteHolder.class, new PaletteHolderLoader());
+                })
+                .failThrough();
+    }
+}