implement MinestomBiomeGrid

fix buildscripts
sort of working Minestom implementation
2026-05-21 09:10:48 +00:00 · 2021-04-03 18:30:03 -07:00 · 2021-04-03 16:59:46 -07:00 · 2021-04-03 16:51:55 -07:00 · 2021-04-01 15:14:14 -07:00 · 2021-04-01 15:03:48 -07:00
106 changed files with 1852 additions and 947 deletions
@@ -1,6 +1,6 @@
 import com.dfsek.terra.getGitHash

-val versionObj = Version("5", "0", "0", true)
+val versionObj = Version("5", "1", "2", true)

 allprojects {
    version = versionObj
@@ -18,4 +18,4 @@ class Version(val major: String, val minor: String, val revision: String, val pr
        else //Only use git hash if it's a prerelease.
            "$major.$minor.$revision-BETA+${getGitHash()}"
    }
-}
+}
@@ -30,7 +30,7 @@ fun Project.configureCommon() {
 }

 fun Project.getGitHash(): String {
-    val stdout = java.io.ByteArrayOutputStream()
+    val stdout = ByteArrayOutputStream()
    exec {
        commandLine = mutableListOf("git", "rev-parse", "--short", "HEAD")
        standardOutput = stdout
@@ -14,13 +14,9 @@ fun Project.configureDistribution() {
    apply(plugin = "java-library")
    apply(plugin = "com.github.johnrengelman.shadow")

-
-//    configurations.create("shaded")
-
    configurations {
        val shaded = create("shaded")
        getByName("compile").extendsFrom(shaded)
-//        shaded.extendsFrom(getByName("compile"))
        val shadedApi = create("shadedApi")
        shaded.extendsFrom(shadedApi)
        getByName("api").extendsFrom(shadedApi)
@@ -29,11 +25,8 @@ fun Project.configureDistribution() {
        getByName("implementation").extendsFrom(shadedImplementation)
    }

-//    tasks.withType<JavaCompile> {
-//        classpath +=
-//    }
-
    val downloadDefaultPacks = tasks.create("downloadDefaultPacks") {
+        group = "terra"
        doFirst {
            file("${buildDir}/resources/main/packs/").deleteRecursively()

@@ -160,7 +160,6 @@ public class TerraCommandManager implements CommandManager {
                if(field.isAnnotationPresent(SwitchTarget.class)) {
                    SwitchTarget switchTarget = field.getAnnotation(SwitchTarget.class);
                    if(!holder.switches.containsValue(switchTarget.value())) {
-                        System.out.println(holder.switches);
                        throw new MalformedCommandException("Switch Target specifies nonexistent switch \"" + switchTarget.value() + "\"");
                    }

@@ -0,0 +1,20 @@
+package com.dfsek.terra.api.event.events;
+
+import com.dfsek.terra.api.util.mutable.MutableBoolean;
+
+/**
+ * Abstract class containing basic {@link Cancellable} implementation.
+ */
+public abstract class AbstractCancellable implements Cancellable {
+    private final MutableBoolean cancelled = new MutableBoolean(false);
+
+    @Override
+    public boolean isCancelled() {
+        return cancelled.get();
+    }
+
+    @Override
+    public void setCancelled(boolean cancelled) {
+        this.cancelled.set(cancelled);
+    }
+}
@@ -1,6 +1,5 @@
 package com.dfsek.terra.api.event.events.world;

-import com.dfsek.terra.api.event.events.Event;
 import com.dfsek.terra.api.event.events.PackEvent;
 import com.dfsek.terra.config.pack.ConfigPack;
 import com.dfsek.terra.config.pack.WorldConfig;
@@ -9,18 +8,24 @@ import com.dfsek.terra.world.TerraWorld;
 /**
 * Called upon initialization of a TerraWorld.
 */
-public class TerraWorldLoadEvent implements Event {
+public class TerraWorldLoadEvent implements PackEvent {
    private final TerraWorld world;
+    private final ConfigPack pack;

-    public TerraWorldLoadEvent(TerraWorld world) {
+    public TerraWorldLoadEvent(TerraWorld world, ConfigPack pack) {
        this.world = world;
+        this.pack = pack;
    }

    public TerraWorld getWorld() {
        return world;
    }

-    public WorldConfig getPack() {
+    public ConfigPack getPack() {
+        return pack;
+    }
+
+    public WorldConfig getWorldConfig() {
        return world.getConfig();
    }
 }
@@ -0,0 +1,45 @@
+package com.dfsek.terra.api.event.events.world.generation;
+
+import com.dfsek.terra.api.event.events.PackEvent;
+import com.dfsek.terra.api.math.vector.Location;
+import com.dfsek.terra.api.platform.entity.Entity;
+import com.dfsek.terra.api.structures.structure.buffer.items.BufferedEntity;
+import com.dfsek.terra.config.pack.ConfigPack;
+
+/**
+ * Called when an entity is spawned via {@link BufferedEntity}.
+ */
+public class EntitySpawnEvent implements PackEvent {
+    private final ConfigPack pack;
+    private final Entity entity;
+    private final Location location;
+
+    public EntitySpawnEvent(ConfigPack pack, Entity entity, Location location) {
+        this.pack = pack;
+        this.entity = entity;
+        this.location = location;
+    }
+
+    @Override
+    public ConfigPack getPack() {
+        return pack;
+    }
+
+    /**
+     * Get the entity that triggered the event.
+     *
+     * @return The entity.
+     */
+    public Entity getEntity() {
+        return entity;
+    }
+
+    /**
+     * Get the location of the entity.
+     *
+     * @return Location of the entity.
+     */
+    public Location getLocation() {
+        return location;
+    }
+}
@@ -0,0 +1,80 @@
+package com.dfsek.terra.api.event.events.world.generation;
+
+import com.dfsek.terra.api.event.events.AbstractCancellable;
+import com.dfsek.terra.api.event.events.Cancellable;
+import com.dfsek.terra.api.event.events.PackEvent;
+import com.dfsek.terra.api.platform.block.Block;
+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.structures.structure.buffer.items.BufferedLootApplication;
+import com.dfsek.terra.config.pack.ConfigPack;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Called when loot is populated via {@link BufferedLootApplication}.
+ */
+public class LootPopulateEvent extends AbstractCancellable implements PackEvent, Cancellable {
+    private final Block block;
+    private final Container container;
+    private LootTable table;
+    private final ConfigPack pack;
+    private final StructureScript script;
+
+    public LootPopulateEvent(Block block, Container container, LootTable table, ConfigPack pack, StructureScript script) {
+        this.block = block;
+        this.container = container;
+        this.table = table;
+        this.pack = pack;
+        this.script = script;
+    }
+
+    @Override
+    public ConfigPack getPack() {
+        return pack;
+    }
+
+    /**
+     * Get the block containing the tile entity loot is applied to.
+     *
+     * @return Block at which loot is applied.
+     */
+    public Block getBlock() {
+        return block;
+    }
+
+    /**
+     * Get the {@link Container} representing the inventory.
+     *
+     * @return Inventory recieving loot.
+     */
+    public Container getContainer() {
+        return container;
+    }
+
+    /**
+     * Get the loot table to be populated.
+     * @return Loot table.
+     */
+    public LootTable getTable() {
+        return table;
+    }
+
+    /**
+     * Set the loot table to be populated.
+     *
+     * @param table New loot table.
+     */
+    public void setTable(@NotNull LootTable table) {
+        this.table = table;
+    }
+
+    /**
+     * Get the script used to generate the structure.
+     *
+     * @return Structure script.
+     */
+    public StructureScript getStructureScript() {
+        return script;
+    }
+}
@@ -36,7 +36,7 @@ public class NoiseFunction2 implements NoiseFunction {
            super(cacheSize);
        }

-        public double get(NoiseSampler noise, double x, double z) {
+        public synchronized double get(NoiseSampler noise, double x, double z) {
            double xx = x >= 0 ? x * 2 : x * -2 - 1;
            double zz = z >= 0 ? z * 2 : z * -2 - 1;
            double key = (xx >= zz) ? (xx * xx + xx + zz) : (zz * zz + xx);
@@ -6,4 +6,6 @@ public interface BlockType extends Handle {
    BlockData getDefaultData();

    boolean isSolid();
+
+    boolean isWater();
 }
@@ -1,4 +1,4 @@
-package com.dfsek.terra.api.world.tree;
+package com.dfsek.terra.api.platform.world;


 import com.dfsek.terra.api.math.vector.Location;
@@ -21,6 +21,7 @@ import com.dfsek.terra.api.structures.script.builders.RecursionsFunctionBuilder;
 import com.dfsek.terra.api.structures.script.builders.SetMarkFunctionBuilder;
 import com.dfsek.terra.api.structures.script.builders.StateFunctionBuilder;
 import com.dfsek.terra.api.structures.script.builders.StructureFunctionBuilder;
+import com.dfsek.terra.api.structures.script.builders.UnaryBooleanFunctionBuilder;
 import com.dfsek.terra.api.structures.script.builders.UnaryNumberFunctionBuilder;
 import com.dfsek.terra.api.structures.script.builders.UnaryStringFunctionBuilder;
 import com.dfsek.terra.api.structures.script.builders.ZeroArgFunctionBuilder;
@@ -58,7 +59,8 @@ public class StructureScript {

        functionRegistry.forEach(parser::registerFunction); // Register registry functions.

-        parser.registerFunction("block", new BlockFunctionBuilder(main))
+        parser.registerFunction("block", new BlockFunctionBuilder(main, false))
+                .registerFunction("dynamicBlock", new BlockFunctionBuilder(main, true))
                .registerFunction("check", new CheckFunctionBuilder(main))
                .registerFunction("structure", new StructureFunctionBuilder(registry, main))
                .registerFunction("randomInt", new RandomFunctionBuilder())
@@ -66,11 +68,12 @@ public class StructureScript {
                .registerFunction("setMark", new SetMarkFunctionBuilder())
                .registerFunction("getMark", new GetMarkFunctionBuilder())
                .registerFunction("pull", new PullFunctionBuilder(main))
-                .registerFunction("loot", new LootFunctionBuilder(main, lootRegistry))
+                .registerFunction("loot", new LootFunctionBuilder(main, lootRegistry, this))
                .registerFunction("entity", new EntityFunctionBuilder(main))
                .registerFunction("getBiome", new BiomeFunctionBuilder(main))
                .registerFunction("getBlock", new CheckBlockFunctionBuilder())
                .registerFunction("state", new StateFunctionBuilder(main))
+                .registerFunction("setWaterlog", new UnaryBooleanFunctionBuilder((waterlog, args) -> args.setWaterlog(waterlog)))
                .registerFunction("originX", new ZeroArgFunctionBuilder<Number>(arguments -> arguments.getBuffer().getOrigin().getX(), Returnable.ReturnType.NUMBER))
                .registerFunction("originY", new ZeroArgFunctionBuilder<Number>(arguments -> arguments.getBuffer().getOrigin().getY(), Returnable.ReturnType.NUMBER))
                .registerFunction("originZ", new ZeroArgFunctionBuilder<Number>(arguments -> arguments.getBuffer().getOrigin().getZ(), Returnable.ReturnType.NUMBER))
@@ -146,7 +149,7 @@ public class StructureScript {

    private boolean applyBlock(TerraImplementationArguments arguments) {
        try {
-            return !block.apply(arguments).getLevel().equals(Block.ReturnLevel.FAIL);
+            return block.apply(arguments).getLevel() != Block.ReturnLevel.FAIL;
        } catch(RuntimeException e) {
            main.logger().severe("Failed to generate structure at " + arguments.getBuffer().getOrigin() + ": " + e.getMessage());
            main.getDebugLogger().stack(e);
@@ -11,6 +11,7 @@ public class TerraImplementationArguments implements ImplementationArguments {
    private final Rotation rotation;
    private final Random random;
    private final int recursions;
+    private boolean waterlog = false;

    public TerraImplementationArguments(Buffer buffer, Rotation rotation, Random random, int recursions) {
        this.buffer = buffer;
@@ -34,4 +35,12 @@ public class TerraImplementationArguments implements ImplementationArguments {
    public Rotation getRotation() {
        return rotation;
    }
+
+    public boolean isWaterlog() {
+        return waterlog;
+    }
+
+    public void setWaterlog(boolean waterlog) {
+        this.waterlog = waterlog;
+    }
 }
@@ -5,24 +5,30 @@ import com.dfsek.terra.api.structures.parser.exceptions.ParseException;
 import com.dfsek.terra.api.structures.parser.lang.Returnable;
 import com.dfsek.terra.api.structures.parser.lang.constants.BooleanConstant;
 import com.dfsek.terra.api.structures.parser.lang.functions.FunctionBuilder;
+import com.dfsek.terra.api.structures.script.functions.AbstractBlockFunction;
 import com.dfsek.terra.api.structures.script.functions.BlockFunction;
+import com.dfsek.terra.api.structures.script.functions.DynamicBlockFunction;
 import com.dfsek.terra.api.structures.tokenizer.Position;

 import java.util.List;

-public class BlockFunctionBuilder implements FunctionBuilder<BlockFunction> {
+public class BlockFunctionBuilder implements FunctionBuilder<AbstractBlockFunction> {
    private final TerraPlugin main;
+    private final boolean dynamic;

-    public BlockFunctionBuilder(TerraPlugin main) {
+    public BlockFunctionBuilder(TerraPlugin main, boolean dynamic) {
        this.main = main;
+        this.dynamic = dynamic;
    }

    @SuppressWarnings("unchecked")
    @Override
-    public BlockFunction build(List<Returnable<?>> argumentList, Position position) throws ParseException {
+    public AbstractBlockFunction build(List<Returnable<?>> argumentList, Position position) throws ParseException {
        if(argumentList.size() < 4) throw new ParseException("Expected data", position);
        Returnable<Boolean> booleanReturnable = new BooleanConstant(true, position);
        if(argumentList.size() == 5) booleanReturnable = (Returnable<Boolean>) argumentList.get(4);
+        if(dynamic)
+            return new DynamicBlockFunction((Returnable<Number>) argumentList.get(0), (Returnable<Number>) argumentList.get(1), (Returnable<Number>) argumentList.get(2), (Returnable<String>) argumentList.get(3), booleanReturnable, main, position);
        return new BlockFunction((Returnable<Number>) argumentList.get(0), (Returnable<Number>) argumentList.get(1), (Returnable<Number>) argumentList.get(2), (Returnable<String>) argumentList.get(3), booleanReturnable, main, position);
    }

@@ -3,6 +3,7 @@ package com.dfsek.terra.api.structures.script.builders;
 import com.dfsek.terra.api.TerraPlugin;
 import com.dfsek.terra.api.structures.parser.lang.Returnable;
 import com.dfsek.terra.api.structures.parser.lang.functions.FunctionBuilder;
+import com.dfsek.terra.api.structures.script.StructureScript;
 import com.dfsek.terra.api.structures.script.functions.LootFunction;
 import com.dfsek.terra.api.structures.tokenizer.Position;
 import com.dfsek.terra.registry.config.LootRegistry;
@@ -12,16 +13,18 @@ import java.util.List;
 public class LootFunctionBuilder implements FunctionBuilder<LootFunction> {
    private final TerraPlugin main;
    private final LootRegistry registry;
+    private final StructureScript script;

-    public LootFunctionBuilder(TerraPlugin main, LootRegistry registry) {
+    public LootFunctionBuilder(TerraPlugin main, LootRegistry registry, StructureScript script) {
        this.main = main;
        this.registry = registry;
+        this.script = script;
    }

    @SuppressWarnings("unchecked")
    @Override
    public LootFunction build(List<Returnable<?>> argumentList, Position position) {
-        return new LootFunction(registry, (Returnable<Number>) argumentList.get(0), (Returnable<Number>) argumentList.get(1), (Returnable<Number>) argumentList.get(2), (Returnable<String>) argumentList.get(3), main, position);
+        return new LootFunction(registry, (Returnable<Number>) argumentList.get(0), (Returnable<Number>) argumentList.get(1), (Returnable<Number>) argumentList.get(2), (Returnable<String>) argumentList.get(3), main, position, script);
    }

    @Override
@@ -0,0 +1,55 @@
+package com.dfsek.terra.api.structures.script.builders;
+
+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.functions.Function;
+import com.dfsek.terra.api.structures.parser.lang.functions.FunctionBuilder;
+import com.dfsek.terra.api.structures.parser.lang.variables.Variable;
+import com.dfsek.terra.api.structures.script.TerraImplementationArguments;
+import com.dfsek.terra.api.structures.tokenizer.Position;
+
+import java.util.List;
+import java.util.Map;
+import java.util.function.BiConsumer;
+
+public class UnaryBooleanFunctionBuilder implements FunctionBuilder<Function<Void>> {
+
+    private final BiConsumer<Boolean, TerraImplementationArguments> function;
+
+    public UnaryBooleanFunctionBuilder(BiConsumer<Boolean, TerraImplementationArguments> function) {
+        this.function = function;
+    }
+
+    @Override
+    public Function<Void> build(List<Returnable<?>> argumentList, Position position) {
+        return new Function<Void>() {
+            @Override
+            public ReturnType returnType() {
+                return ReturnType.VOID;
+            }
+
+            @SuppressWarnings("unchecked")
+            @Override
+            public Void apply(ImplementationArguments implementationArguments, Map<String, Variable<?>> variableMap) {
+                function.accept(((Returnable<Boolean>) argumentList.get(0)).apply(implementationArguments, variableMap), (TerraImplementationArguments) implementationArguments);
+                return null;
+            }
+
+            @Override
+            public Position getPosition() {
+                return position;
+            }
+        };
+    }
+
+    @Override
+    public int argNumber() {
+        return 1;
+    }
+
+    @Override
+    public Returnable.ReturnType getArgument(int position) {
+        if(position == 0) return Returnable.ReturnType.BOOLEAN;
+        return null;
+    }
+}
@@ -0,0 +1,54 @@
+package com.dfsek.terra.api.structures.script.functions;
+
+import com.dfsek.terra.api.TerraPlugin;
+import com.dfsek.terra.api.math.vector.Vector2;
+import com.dfsek.terra.api.math.vector.Vector3;
+import com.dfsek.terra.api.platform.block.BlockData;
+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.functions.Function;
+import com.dfsek.terra.api.structures.parser.lang.variables.Variable;
+import com.dfsek.terra.api.structures.script.TerraImplementationArguments;
+import com.dfsek.terra.api.structures.structure.RotationUtil;
+import com.dfsek.terra.api.structures.structure.buffer.items.BufferedBlock;
+import com.dfsek.terra.api.structures.tokenizer.Position;
+import net.jafama.FastMath;
+
+import java.util.Map;
+
+public abstract class AbstractBlockFunction implements Function<Void> {
+    protected final Returnable<Number> x, y, z;
+    protected final Returnable<String> blockData;
+    protected final TerraPlugin main;
+    private final Returnable<Boolean> overwrite;
+    private final Position position;
+
+    protected AbstractBlockFunction(Returnable<Number> x, Returnable<Number> y, Returnable<Number> z, Returnable<String> blockData, Returnable<Boolean> overwrite, TerraPlugin main, Position position) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.blockData = blockData;
+        this.overwrite = overwrite;
+        this.main = main;
+        this.position = position;
+    }
+
+    void setBlock(ImplementationArguments implementationArguments, Map<String, Variable<?>> variableMap, TerraImplementationArguments arguments, BlockData rot) {
+        Vector2 xz = new Vector2(x.apply(implementationArguments, variableMap).doubleValue(), z.apply(implementationArguments, variableMap).doubleValue());
+
+        RotationUtil.rotateVector(xz, arguments.getRotation());
+
+        RotationUtil.rotateBlockData(rot, arguments.getRotation().inverse());
+        arguments.getBuffer().addItem(new BufferedBlock(rot, overwrite.apply(implementationArguments, variableMap), main, arguments.isWaterlog()), new Vector3(FastMath.roundToInt(xz.getX()), y.apply(implementationArguments, variableMap).doubleValue(), FastMath.roundToInt(xz.getZ())).toLocation(arguments.getBuffer().getOrigin().getWorld()));
+    }
+
+    @Override
+    public Position getPosition() {
+        return position;
+    }
+
+    @Override
+    public ReturnType returnType() {
+        return ReturnType.VOID;
+    }
+}
@@ -1,67 +1,36 @@
 package com.dfsek.terra.api.structures.script.functions;

 import com.dfsek.terra.api.TerraPlugin;
-import com.dfsek.terra.api.math.vector.Vector2;
-import com.dfsek.terra.api.math.vector.Vector3;
 import com.dfsek.terra.api.platform.block.BlockData;
 import com.dfsek.terra.api.structures.parser.exceptions.ParseException;
 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.constants.ConstantExpression;
-import com.dfsek.terra.api.structures.parser.lang.functions.Function;
 import com.dfsek.terra.api.structures.parser.lang.variables.Variable;
 import com.dfsek.terra.api.structures.script.TerraImplementationArguments;
-import com.dfsek.terra.api.structures.structure.RotationUtil;
-import com.dfsek.terra.api.structures.structure.buffer.items.BufferedBlock;
 import com.dfsek.terra.api.structures.tokenizer.Position;
-import net.jafama.FastMath;

 import java.util.Map;

-public class BlockFunction implements Function<Void> {
+public class BlockFunction extends AbstractBlockFunction {
    private final BlockData data;
-    private final Returnable<Number> x, y, z;
-    private final Position position;
-    private final Returnable<Boolean> overwrite;
-    private final TerraPlugin main;

    public BlockFunction(Returnable<Number> x, Returnable<Number> y, Returnable<Number> z, Returnable<String> data, Returnable<Boolean> overwrite, TerraPlugin main, Position position) throws ParseException {
-        this.position = position;
-        this.main = main;
-        if(!(data instanceof ConstantExpression)) throw new ParseException("Block data must be constant", data.getPosition());
+        super(x, y, z, data, overwrite, main, position);

+        if(!(data instanceof ConstantExpression)) throw new ParseException("Block data must be constant", data.getPosition());
        try {
            this.data = main.getWorldHandle().createBlockData(((ConstantExpression<String>) data).getConstant());
        } catch(IllegalArgumentException e) {
            throw new ParseException("Could not parse block data", data.getPosition(), e);
        }
-        this.x = x;
-        this.y = y;
-        this.z = z;
-        this.overwrite = overwrite;
    }

    @Override
    public Void apply(ImplementationArguments implementationArguments, Map<String, Variable<?>> variableMap) {
        TerraImplementationArguments arguments = (TerraImplementationArguments) implementationArguments;
        BlockData rot = data.clone();
-
-        Vector2 xz = new Vector2(x.apply(implementationArguments, variableMap).doubleValue(), z.apply(implementationArguments, variableMap).doubleValue());
-
-        RotationUtil.rotateVector(xz, arguments.getRotation());
-
-        RotationUtil.rotateBlockData(rot, arguments.getRotation().inverse());
-        arguments.getBuffer().addItem(new BufferedBlock(rot, overwrite.apply(implementationArguments, variableMap), main), new Vector3(FastMath.roundToInt(xz.getX()), y.apply(implementationArguments, variableMap).doubleValue(), FastMath.roundToInt(xz.getZ())).toLocation(arguments.getBuffer().getOrigin().getWorld()));
+        setBlock(implementationArguments, variableMap, arguments, rot);
        return null;
    }
-
-    @Override
-    public Position getPosition() {
-        return position;
-    }
-
-    @Override
-    public ReturnType returnType() {
-        return ReturnType.VOID;
-    }
 }
@@ -0,0 +1,31 @@
+package com.dfsek.terra.api.structures.script.functions;
+
+import com.dfsek.terra.api.TerraPlugin;
+import com.dfsek.terra.api.platform.block.BlockData;
+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.script.TerraImplementationArguments;
+import com.dfsek.terra.api.structures.tokenizer.Position;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class DynamicBlockFunction extends AbstractBlockFunction {
+    private final Map<String, BlockData> data = new HashMap<>();
+    private final Position position;
+
+
+    public DynamicBlockFunction(Returnable<Number> x, Returnable<Number> y, Returnable<Number> z, Returnable<String> data, Returnable<Boolean> overwrite, TerraPlugin main, Position position) {
+        super(x, y, z, data, overwrite, main, position);
+        this.position = position;
+    }
+
+    @Override
+    public Void apply(ImplementationArguments implementationArguments, Map<String, Variable<?>> variableMap) {
+        TerraImplementationArguments arguments = (TerraImplementationArguments) implementationArguments;
+        BlockData rot = data.computeIfAbsent(blockData.apply(implementationArguments, variableMap), main.getWorldHandle()::createBlockData).clone();
+        setBlock(implementationArguments, variableMap, arguments, rot);
+        return null;
+    }
+}
@@ -21,9 +21,11 @@ public class EntityFunction implements Function<Void> {
    private final EntityType data;
    private final Returnable<Number> x, y, z;
    private final Position position;
+    private final TerraPlugin main;

    public EntityFunction(Returnable<Number> x, Returnable<Number> y, Returnable<Number> z, Returnable<String> data, TerraPlugin main, Position position) throws ParseException {
        this.position = position;
+        this.main = main;
        if(!(data instanceof ConstantExpression)) throw new ParseException("Entity data must be constant", data.getPosition());

        this.data = main.getWorldHandle().getEntity(((ConstantExpression<String>) data).getConstant());
@@ -39,7 +41,7 @@ public class EntityFunction implements Function<Void> {

        RotationUtil.rotateVector(xz, arguments.getRotation());

-        arguments.getBuffer().addItem(new BufferedEntity(data), new Vector3(xz.getX(), y.apply(implementationArguments, variableMap).doubleValue(), xz.getZ()).toLocation(arguments.getBuffer().getOrigin().getWorld()));
+        arguments.getBuffer().addItem(new BufferedEntity(data, main), new Vector3(xz.getX(), y.apply(implementationArguments, variableMap).doubleValue(), xz.getZ()).toLocation(arguments.getBuffer().getOrigin().getWorld()));
        return null;
    }

@@ -8,6 +8,7 @@ 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.functions.Function;
 import com.dfsek.terra.api.structures.parser.lang.variables.Variable;
+import com.dfsek.terra.api.structures.script.StructureScript;
 import com.dfsek.terra.api.structures.script.TerraImplementationArguments;
 import com.dfsek.terra.api.structures.structure.RotationUtil;
 import com.dfsek.terra.api.structures.structure.buffer.items.BufferedLootApplication;
@@ -23,8 +24,9 @@ public class LootFunction implements Function<Void> {
    private final Returnable<Number> x, y, z;
    private final Position position;
    private final TerraPlugin main;
+    private final StructureScript script;

-    public LootFunction(LootRegistry registry, Returnable<Number> x, Returnable<Number> y, Returnable<Number> z, Returnable<String> data, TerraPlugin main, Position position) {
+    public LootFunction(LootRegistry registry, Returnable<Number> x, Returnable<Number> y, Returnable<Number> z, Returnable<String> data, TerraPlugin main, Position position, StructureScript script) {
        this.registry = registry;
        this.position = position;
        this.data = data;
@@ -32,6 +34,7 @@ public class LootFunction implements Function<Void> {
        this.y = y;
        this.z = z;
        this.main = main;
+        this.script = script;
    }

    @Override
@@ -49,7 +52,7 @@ public class LootFunction implements Function<Void> {
            return null;
        }

-        arguments.getBuffer().addItem(new BufferedLootApplication(table, main), new Vector3(FastMath.roundToInt(xz.getX()), y.apply(implementationArguments, variableMap).intValue(), FastMath.roundToInt(xz.getZ())).toLocation(arguments.getBuffer().getOrigin().getWorld()));
+        arguments.getBuffer().addItem(new BufferedLootApplication(table, main, script), new Vector3(FastMath.roundToInt(xz.getX()), y.apply(implementationArguments, variableMap).intValue(), FastMath.roundToInt(xz.getZ())).toLocation(arguments.getBuffer().getOrigin().getWorld()));
        return null;
    }

@@ -4,23 +4,30 @@ import com.dfsek.terra.api.TerraPlugin;
 import com.dfsek.terra.api.math.vector.Location;
 import com.dfsek.terra.api.platform.block.Block;
 import com.dfsek.terra.api.platform.block.BlockData;
+import com.dfsek.terra.api.platform.block.data.Waterlogged;

 public class BufferedBlock implements BufferedItem {
    private final BlockData data;
    private final boolean overwrite;
    private final TerraPlugin main;
+    private final boolean waterlog;

-    public BufferedBlock(BlockData data, boolean overwrite, TerraPlugin main) {
+    public BufferedBlock(BlockData data, boolean overwrite, TerraPlugin main, boolean waterlog) {
        this.data = data;
        this.overwrite = overwrite;
        this.main = main;
+        this.waterlog = waterlog;
    }

    @Override
    public void paste(Location origin) {
        Block block = origin.getBlock();
        try {
-            if(overwrite || block.isEmpty()) block.setBlockData(data, false);
+            if(overwrite || block.isEmpty()) {
+                if(waterlog && data instanceof Waterlogged && block.getBlockData().getBlockType().isWater())
+                    ((Waterlogged) data).setWaterlogged(true);
+                block.setBlockData(data, false);
+            }
        } catch(RuntimeException e) {
            main.logger().severe("Failed to place block at location " + origin + ": " + e.getMessage());
            main.getDebugLogger().stack(e);
@@ -1,18 +1,24 @@
 package com.dfsek.terra.api.structures.structure.buffer.items;

+import com.dfsek.terra.api.TerraPlugin;
+import com.dfsek.terra.api.event.events.world.generation.EntitySpawnEvent;
 import com.dfsek.terra.api.math.vector.Location;
+import com.dfsek.terra.api.platform.entity.Entity;
 import com.dfsek.terra.api.platform.entity.EntityType;

 public class BufferedEntity implements BufferedItem {

    private final EntityType type;
+    private final TerraPlugin main;

-    public BufferedEntity(EntityType type) {
+    public BufferedEntity(EntityType type, TerraPlugin main) {
        this.type = type;
+        this.main = main;
    }

    @Override
    public void paste(Location origin) {
-        origin.clone().add(0.5, 0, 0.5).getWorld().spawnEntity(origin, type);
+        Entity entity = origin.clone().add(0.5, 0, 0.5).getWorld().spawnEntity(origin, type);
+        main.getEventManager().callEvent(new EntitySpawnEvent(main.getWorld(entity.getWorld()).getGenerator().getConfigPack(), entity, entity.getLocation()));
    }
 }
@@ -1,31 +1,42 @@
 package com.dfsek.terra.api.structures.structure.buffer.items;

 import com.dfsek.terra.api.TerraPlugin;
+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;

 public class BufferedLootApplication implements BufferedItem {
    private final LootTable table;
    private final TerraPlugin main;
+    private final StructureScript structure;

-    public BufferedLootApplication(LootTable table, TerraPlugin main) {
+    public BufferedLootApplication(LootTable table, TerraPlugin main, StructureScript structure) {
        this.table = table;
        this.main = main;
+        this.structure = structure;
    }

    @Override
    public void paste(Location origin) {
        try {
-            BlockState data = origin.getBlock().getState();
+            Block block = origin.getBlock();
+            BlockState data = block.getState();
            if(!(data instanceof Container)) {
                main.logger().severe("Failed to place loot at " + origin + "; block " + data + " is not container.");
                return;
            }
            Container container = (Container) data;
-            table.fillInventory(container.getInventory(), new FastRandom(origin.hashCode()));
+
+            LootPopulateEvent event = new LootPopulateEvent(block, container, table, main.getWorld(block.getLocation().getWorld()).getGenerator().getConfigPack(), structure);
+            main.getEventManager().callEvent(event);
+            if(event.isCancelled()) return;
+
+            event.getTable().fillInventory(container.getInventory(), new FastRandom(origin.hashCode()));
            data.update(false);
        } catch(Exception e) {
            main.logger().warning("Could not apply loot at " + origin + ": " + e.getMessage());
@@ -5,6 +5,14 @@ import org.jetbrains.annotations.NotNull;
 public class MutableBoolean implements MutablePrimitive<Boolean> {
    private boolean value;

+    public MutableBoolean() {
+        this.value = false;
+    }
+
+    public MutableBoolean(boolean value) {
+        this.value = value;
+    }
+
    @Override
    public Boolean get() {
        return value;
@@ -0,0 +1,7 @@
+package com.dfsek.terra.api.world.generation;
+
+/**
+ * Marker interface that marks a feature as "chunkified" (only modifying one chunk at a time)
+ */
+public interface Chunkified {
+}
@@ -1,8 +0,0 @@
-package com.dfsek.terra.api.world.generation;
-
-/**
- * The phase of terrain generation. Used for modifying values based on the phase of generation.
- */
-public enum GenerationPhase {
-    BASE, POPULATE, GENERATION_POPULATE, PALETTE_APPLY, POST_GEN
-}
@@ -6,10 +6,10 @@ import com.dfsek.terra.api.platform.world.World;
 import com.dfsek.terra.api.platform.world.generator.ChunkData;
 import com.dfsek.terra.api.world.biome.provider.BiomeProvider;
 import com.dfsek.terra.config.pack.ConfigPack;
-import com.dfsek.terra.world.generation.math.SamplerCache;
 import com.dfsek.terra.world.generation.math.samplers.Sampler;
 import org.jetbrains.annotations.NotNull;

+import java.util.List;
 import java.util.Random;

 public interface TerraChunkGenerator {
@@ -32,4 +32,6 @@ public interface TerraChunkGenerator {
    TerraPlugin getMain();

    Sampler createSampler(int chunkX, int chunkZ, BiomeProvider provider, World world, int elevationSmooth);
+
+    List<TerraBlockPopulator> getPopulators();
 }
@@ -1,32 +0,0 @@
-package com.dfsek.terra.api.world.tree.fractal;
-
-import com.dfsek.terra.api.math.vector.Location;
-import com.dfsek.terra.api.platform.entity.Entity;
-
-import java.util.function.Consumer;
-
-
-public class EntitySpawnHolder {
-    private final Location l;
-    private final Class<? extends Entity> e;
-    private final Consumer<Entity> c;
-
-    public EntitySpawnHolder(Location l, Class<? extends Entity> e, Consumer<Entity> c) {
-        this.l = l;
-        this.e = e;
-        this.c = c;
-    }
-
-    @SuppressWarnings("rawtypes")
-    public Class getEntity() {
-        return e;
-    }
-
-    public Consumer<Entity> getConsumer() {
-        return c;
-    }
-
-    public Location getLocation() {
-        return l;
-    }
-}
@@ -1,48 +0,0 @@
-package com.dfsek.terra.api.world.tree.fractal;
-
-import com.dfsek.terra.api.TerraPlugin;
-import com.dfsek.terra.api.math.vector.Location;
-import com.dfsek.terra.api.platform.block.BlockData;
-import com.dfsek.terra.api.platform.entity.Entity;
-import com.dfsek.terra.api.platform.entity.EntityType;
-import com.dfsek.terra.api.util.collections.MaterialSet;
-
-import java.util.Random;
-import java.util.function.Consumer;
-
-
-public abstract class FractalTree {
-    protected final TerraPlugin main;
-
-    public abstract MaterialSet getSpawnable();
-
-    /**
-     * Instantiates a TreeGrower at an origin location.
-     */
-    public FractalTree(TerraPlugin plugin) {
-        this.main = plugin;
-    }
-
-    /**
-     * Sets a block in the tree's storage map to a material.
-     *
-     * @param l - The location to set.
-     * @param m - The material to which it will be set.
-     */
-    public void setBlock(Location l, BlockData m) {
-        l.getBlock().setBlockData(m, false);
-    }
-
-    public TerraPlugin getMain() {
-        return main;
-    }
-
-    /**
-     * Grows the tree in memory. Intended to be invoked from an async thread.
-     */
-    public abstract void grow(Location origin, Random random);
-
-    public void spawnEntity(Location spawn, EntityType type, Consumer<Entity> consumer) {
-        consumer.accept(spawn.getWorld().spawnEntity(spawn, type));
-    }
-}
@@ -1,68 +0,0 @@
-package com.dfsek.terra.api.world.tree.fractal;
-
-import com.dfsek.terra.api.math.vector.Location;
-import com.dfsek.terra.api.math.vector.Vector3;
-import com.dfsek.terra.api.platform.block.BlockData;
-import com.dfsek.terra.api.util.collections.ProbabilityCollection;
-
-import java.util.Random;
-
-public class TreeGeometry {
-    private final FractalTree tree;
-
-    public TreeGeometry(FractalTree tree) {
-        this.tree = tree;
-    }
-
-    public static Vector3 getPerpendicular(Vector3 v) {
-        return v.getZ() < v.getX() ? new Vector3(v.getY(), -v.getX(), 0) : new Vector3(0, -v.getZ(), v.getY());
-    }
-
-    public FractalTree getTree() {
-        return tree;
-    }
-
-    public void generateSphere(Location l, BlockData m, int radius, boolean overwrite, Random r) {
-        generateSphere(l, new ProbabilityCollection<BlockData>().add(m, 1), radius, overwrite, r);
-    }
-
-    public void generateCylinder(Location l, BlockData m, int radius, int height, boolean overwrite, Random r) {
-        generateCylinder(l, new ProbabilityCollection<BlockData>().add(m, 1), radius, height, overwrite, r);
-    }
-
-    public void generateSphere(Location l, ProbabilityCollection<BlockData> m, int radius, boolean overwrite, Random r) {
-        for(int x = -radius; x <= radius; x++) {
-            for(int y = -radius; y <= radius; y++) {
-                for(int z = -radius; z <= radius; z++) {
-                    Vector3 position = l.toVector().clone().add(new Vector3(x, y, z));
-                    if(l.toVector().distance(position) <= radius + 0.5 && (overwrite || position.toLocation(l.getWorld()).getBlock().isEmpty()))
-                        tree.setBlock(position.toLocation(l.getWorld()), m.get(r));
-                }
-            }
-        }
-    }
-
-    public void generateSponge(Location l, ProbabilityCollection<BlockData> m, int radius, boolean overwrite, int sponginess, Random r) {
-        for(int x = -radius; x <= radius; x++) {
-            for(int y = -radius; y <= radius; y++) {
-                for(int z = -radius; z <= radius; z++) {
-                    Vector3 position = l.toVector().clone().add(new Vector3(x, y, z));
-                    if(r.nextInt(100) < sponginess && l.toVector().distance(position) <= radius + 0.5 && (overwrite || position.toLocation(l.getWorld()).getBlock().isEmpty()))
-                        tree.setBlock(position.toLocation(l.getWorld()), m.get(r));
-                }
-            }
-        }
-    }
-
-    public void generateCylinder(Location l, ProbabilityCollection<BlockData> m, int radius, int height, boolean overwrite, Random r) {
-        for(int x = -radius; x <= radius; x++) {
-            for(int y = 0; y <= height; y++) {
-                for(int z = -radius; z <= radius; z++) {
-                    Vector3 position = l.toVector().clone().add(new Vector3(x, 0, z));
-                    if(l.toVector().distance(position) <= radius + 0.5 && (overwrite || position.toLocation(l.getWorld()).getBlock().isEmpty()))
-                        tree.setBlock(position.toLocation(l.getWorld()), m.get(r));
-                }
-            }
-        }
-    }
-}
@@ -1,35 +0,0 @@
-package com.dfsek.terra.api.world.tree.fractal.trees;
-
-import com.dfsek.terra.api.TerraPlugin;
-import com.dfsek.terra.api.math.vector.Location;
-import com.dfsek.terra.api.platform.block.BlockData;
-import com.dfsek.terra.api.util.collections.MaterialSet;
-import com.dfsek.terra.api.world.tree.fractal.FractalTree;
-
-import java.util.Random;
-
-public class Cactus extends FractalTree {
-    @Override
-    public MaterialSet getSpawnable() {
-        return MaterialSet.get(main.getWorldHandle().createBlockData("minecraft:sand"),
-                main.getWorldHandle().createBlockData("minecraft:red_sand"));
-    }
-
-
-    /**
-     * Instantiates a TreeGrower at an origin location.
-     */
-    public Cactus(TerraPlugin main) {
-        super(main);
-    }
-
-    /**
-     * Grows the tree in memory. Intended to be invoked from an async thread.
-     */
-    @Override
-    public void grow(Location origin, Random random) {
-        BlockData cactus = getMain().getWorldHandle().createBlockData("minecraft:cactus");
-        int h = random.nextInt(4) + 1;
-        for(int i = 0; i < h; i++) setBlock(origin.clone().add(0, i, 0), cactus);
-    }
-}
@@ -1,57 +0,0 @@
-package com.dfsek.terra.api.world.tree.fractal.trees;
-
-import com.dfsek.terra.api.TerraPlugin;
-import com.dfsek.terra.api.math.vector.Location;
-import com.dfsek.terra.api.math.vector.Vector3;
-import com.dfsek.terra.api.platform.block.BlockData;
-import com.dfsek.terra.api.platform.handle.WorldHandle;
-import com.dfsek.terra.api.util.collections.MaterialSet;
-import com.dfsek.terra.api.util.collections.ProbabilityCollection;
-import com.dfsek.terra.api.world.tree.fractal.FractalTree;
-import com.dfsek.terra.api.world.tree.fractal.TreeGeometry;
-
-import java.util.Random;
-
-
-public class IceSpike extends FractalTree {
-    private final TreeGeometry geo;
-    private final ProbabilityCollection<BlockData> ice;
-
-    @Override
-    public MaterialSet getSpawnable() {
-        return MaterialSet.get(main.getWorldHandle().createBlockData("minecraft:stone"),
-                main.getWorldHandle().createBlockData("minecraft:gravel"),
-                main.getWorldHandle().createBlockData("minecraft:snow_block"),
-                main.getWorldHandle().createBlockData("minecraft:grass_block"));
-    }
-
-    /**
-     * Instantiates a TreeGrower at an origin location.
-     */
-    public IceSpike(TerraPlugin main) {
-        super(main);
-        geo = new TreeGeometry(this);
-        WorldHandle handle = main.getWorldHandle();
-        ice = new ProbabilityCollection<BlockData>().add(handle.createBlockData("minecraft:packed_ice"), 95).add(handle.createBlockData("minecraft:blue_ice"), 5);
-    }
-
-    private double getOffset(Random r) {
-        return (r.nextDouble() - 0.5D);
-    }
-
-    /**
-     * Grows the tree in memory. Intended to be invoked from an async thread.
-     */
-    @Override
-    public void grow(Location origin, Random random) {
-        Vector3 direction = new Vector3(getOffset(random), 0, getOffset(random));
-        Location l1 = origin.clone();
-        int h = random.nextInt(16) + 8;
-        for(int i = 0; i < h; i++) {
-            geo.generateSponge(l1.clone().add(0, i, 0).add(direction.clone().multiply(i)), ice, (int) ((1 - ((double) i / h)) * 2 + 1), true, 80, random);
-        }
-        for(int i = 0; i < h / 3; i++) {
-            setBlock(l1.clone().add(0, h + i, 0).add(direction.clone().multiply(h + i)), ice.get(random));
-        }
-    }
-}
@@ -1,66 +0,0 @@
-package com.dfsek.terra.api.world.tree.fractal.trees;
-
-import com.dfsek.terra.api.TerraPlugin;
-import com.dfsek.terra.api.math.vector.Location;
-import com.dfsek.terra.api.math.vector.Vector3;
-import com.dfsek.terra.api.platform.block.BlockData;
-import com.dfsek.terra.api.util.collections.MaterialSet;
-import com.dfsek.terra.api.world.tree.fractal.FractalTree;
-import com.dfsek.terra.api.world.tree.fractal.TreeGeometry;
-import net.jafama.FastMath;
-
-import java.util.Random;
-
-
-public class OakTree extends FractalTree {
-    private final TreeGeometry geo;
-
-    @Override
-    public MaterialSet getSpawnable() {
-        return MaterialSet.get(main.getWorldHandle().createBlockData("minecraft:podzol"),
-                main.getWorldHandle().createBlockData("minecraft:grass_block"));
-    }
-
-    /**
-     * Instantiates a TreeGrower at an origin location.
-     */
-    public OakTree(TerraPlugin main) {
-        super(main);
-        geo = new TreeGeometry(this);
-    }
-
-    /**
-     * Grows the tree in memory. Intended to be invoked from an async thread.
-     */
-    @Override
-    public void grow(Location origin, Random random) {
-        growBranch(origin.clone(), new Vector3(random.nextInt(5) - 2, random.nextInt(4) + 6, random.nextInt(5) - 2), 2, 0, random);
-    }
-
-    private void growBranch(Location l1, Vector3 diff, double d1, int recursions, Random r) {
-        BlockData wood = getMain().getWorldHandle().createBlockData("minecraft:oak_wood");
-        BlockData leaves = getMain().getWorldHandle().createBlockData("minecraft:oak_leaves");
-        if(recursions > 1) {
-            geo.generateSphere(l1, leaves, 1 + r.nextInt(2) + (3 - recursions), false, r);
-            if(recursions > 2) return;
-        }
-        if(diff.getY() < 0) diff.rotateAroundAxis(TreeGeometry.getPerpendicular(diff.clone()).normalize(), FastMath.PI);
-        int d = (int) diff.length();
-        for(int i = 0; i < d; i++) {
-            geo.generateSphere(l1.clone().add(diff.clone().multiply((double) i / d)), wood, FastMath.max((int) d1, 0), true, r);
-        }
-        double runningAngle = (double) 45 / (recursions + 1);
-        growBranch(l1.clone().add(diff), diff.clone().multiply(0.75).rotateAroundX(FastMath.toRadians(runningAngle + getNoise(r))).rotateAroundZ(FastMath.toRadians(getNoise(r))),
-                d1 - 1, recursions + 1, r);
-        growBranch(l1.clone().add(diff), diff.clone().multiply(0.75).rotateAroundX(FastMath.toRadians(-runningAngle + getNoise(r))).rotateAroundZ(FastMath.toRadians(getNoise(r))),
-                d1 - 1, recursions + 1, r);
-        growBranch(l1.clone().add(diff), diff.clone().multiply(0.75).rotateAroundZ(FastMath.toRadians(runningAngle + getNoise(r))).rotateAroundX(FastMath.toRadians(getNoise(r))),
-                d1 - 1, recursions + 1, r);
-        growBranch(l1.clone().add(diff), diff.clone().multiply(0.75).rotateAroundZ(FastMath.toRadians(-runningAngle + getNoise(r))).rotateAroundX(FastMath.toRadians(getNoise(r))),
-                d1 - 1, recursions + 1, r);
-    }
-
-    private int getNoise(Random r) {
-        return r.nextInt(60) - 30;
-    }
-}
@@ -1,56 +0,0 @@
-package com.dfsek.terra.api.world.tree.fractal.trees;
-
-import com.dfsek.terra.api.TerraPlugin;
-import com.dfsek.terra.api.math.vector.Location;
-import com.dfsek.terra.api.platform.block.BlockData;
-import com.dfsek.terra.api.util.collections.MaterialSet;
-import com.dfsek.terra.api.world.tree.fractal.FractalTree;
-
-import java.util.Random;
-
-public class ShatteredPillar extends FractalTree {
-
-    @Override
-    public MaterialSet getSpawnable() {
-        return MaterialSet.get(main.getWorldHandle().createBlockData("minecraft:end_stone"));
-    }
-
-    /**
-     * Instantiates a TreeGrower at an origin location.
-     */
-    public ShatteredPillar(TerraPlugin main) {
-        super(main);
-    }
-
-    /**
-     * Grows the tree in memory. Intended to be invoked from an async thread.
-     * @param origin
-     * @param random
-     */
-    @Override
-    public void grow(Location origin, Random random) {
-        BlockData obsidian = getMain().getWorldHandle().createBlockData("minecraft:obsidian");
-        int h = random.nextInt(5) + 8;
-        int max = h;
-        for(int i = -h; i < h; i++) setBlock(origin.clone().add(0, i, 0), obsidian);
-        h = h + (random.nextBoolean() ? random.nextInt(3) + 1 : -(random.nextInt(3) + 1));
-        int[] crystalLoc = new int[] {0, 0};
-        if(h > max) {
-            max = h;
-            crystalLoc = new int[] {1, 0};
-        }
-        for(int i = -h; i < h; i++) setBlock(origin.clone().add(1, i, 0), obsidian);
-        h = h + (random.nextBoolean() ? random.nextInt(3) + 1 : -(random.nextInt(3) + 1));
-        if(h > max) {
-            max = h;
-            crystalLoc = new int[] {0, 1};
-        }
-        for(int i = -h; i < h; i++) setBlock(origin.clone().add(0, i, 1), obsidian);
-        h = h + (random.nextBoolean() ? random.nextInt(3) + 1 : -(random.nextInt(3) + 1));
-        if(h > max) {
-            max = h;
-            crystalLoc = new int[] {1, 1};
-        }
-        for(int i = -h; i < h; i++) setBlock(origin.clone().add(1, i, 1), obsidian);
-    }
-}
@@ -1,75 +0,0 @@
-package com.dfsek.terra.api.world.tree.fractal.trees;
-
-import com.dfsek.terra.api.TerraPlugin;
-import com.dfsek.terra.api.math.vector.Location;
-import com.dfsek.terra.api.math.vector.Vector3;
-import com.dfsek.terra.api.platform.block.BlockData;
-import com.dfsek.terra.api.platform.handle.WorldHandle;
-import com.dfsek.terra.api.util.collections.MaterialSet;
-import com.dfsek.terra.api.util.collections.ProbabilityCollection;
-import com.dfsek.terra.api.world.tree.fractal.FractalTree;
-import com.dfsek.terra.api.world.tree.fractal.TreeGeometry;
-import net.jafama.FastMath;
-
-import java.util.Random;
-
-public class ShatteredTree extends FractalTree {
-    private final TreeGeometry geo;
-    private final ProbabilityCollection<BlockData> bark;
-    private final ProbabilityCollection<BlockData> leaves;
-
-    @Override
-    public MaterialSet getSpawnable() {
-        return MaterialSet.get(main.getWorldHandle().createBlockData("minecraft:end_stone"));
-    }
-
-    /**
-     * Instantiates a TreeGrower at an origin location.
-     */
-    public ShatteredTree(TerraPlugin main) {
-        super(main);
-        geo = new TreeGeometry(this);
-        WorldHandle handle = main.getWorldHandle();
-
-        bark = new ProbabilityCollection<BlockData>()
-                .add(handle.createBlockData("minecraft:obsidian"), 1)
-                .add(handle.createBlockData("minecraft:black_concrete"), 1);
-        leaves = new ProbabilityCollection<BlockData>()
-                .add(handle.createBlockData("minecraft:purple_stained_glass"), 1)
-                .add(handle.createBlockData("minecraft:magenta_stained_glass"), 1);
-    }
-
-    /**
-     * Grows the tree in memory. Intended to be invoked from an async thread.
-     */
-    @Override
-    public void grow(Location origin, Random random) {
-        growBranch(origin.clone(), new Vector3(random.nextInt(5) - 2, random.nextInt(4) + 6, random.nextInt(5) - 2), 1, 0, random);
-
-    }
-
-    private void growBranch(Location l1, Vector3 diff, double d1, int recursions, Random r) {
-        if(recursions > 2) {
-            geo.generateSphere(l1, leaves, 1 + r.nextInt(2), false, r);
-            return;
-        }
-        if(diff.getY() < 0) diff.rotateAroundAxis(TreeGeometry.getPerpendicular(diff.clone()).normalize(), FastMath.PI);
-        int d = (int) diff.length();
-        for(int i = 0; i < d; i++) {
-            geo.generateSphere(l1.clone().add(diff.clone().multiply((double) i / d)), bark, FastMath.max((int) d1, 0), true, r);
-        }
-        double runningAngle = (double) 45 / (recursions + 1);
-        growBranch(l1.clone().add(diff), diff.clone().multiply(0.9).rotateAroundX(FastMath.toRadians(runningAngle + getNoise(r))).rotateAroundZ(FastMath.toRadians(getNoise(r))),
-                d1 - 1, recursions + 1, r);
-        growBranch(l1.clone().add(diff), diff.clone().multiply(0.9).rotateAroundX(FastMath.toRadians(-runningAngle + getNoise(r))).rotateAroundZ(FastMath.toRadians(getNoise(r))),
-                d1 - 1, recursions + 1, r);
-        growBranch(l1.clone().add(diff), diff.clone().multiply(0.9).rotateAroundZ(FastMath.toRadians(runningAngle + getNoise(r))).rotateAroundX(FastMath.toRadians(getNoise(r))),
-                d1 - 1, recursions + 1, r);
-        growBranch(l1.clone().add(diff), diff.clone().multiply(0.9).rotateAroundZ(FastMath.toRadians(-runningAngle + getNoise(r))).rotateAroundX(FastMath.toRadians(getNoise(r))),
-                d1 - 1, recursions + 1, r);
-    }
-
-    private int getNoise(Random r) {
-        return r.nextInt(90) - 45;
-    }
-}
@@ -1,36 +0,0 @@
-package com.dfsek.terra.api.world.tree.fractal.trees;
-
-import com.dfsek.terra.api.TerraPlugin;
-import com.dfsek.terra.api.math.vector.Location;
-import com.dfsek.terra.api.platform.block.BlockData;
-import com.dfsek.terra.api.util.collections.MaterialSet;
-import com.dfsek.terra.api.world.tree.fractal.FractalTree;
-
-import java.util.Random;
-
-public class SmallShatteredPillar extends FractalTree {
-
-    @Override
-    public MaterialSet getSpawnable() {
-        return MaterialSet.get(main.getWorldHandle().createBlockData("minecraft:end_stone"));
-    }
-
-    /**
-     * Instantiates a TreeGrower at an origin location.
-     */
-    public SmallShatteredPillar(TerraPlugin main) {
-        super(main);
-    }
-
-    /**
-     * Grows the tree in memory. Intended to be invoked from an async thread.
-     * @param origin
-     * @param random
-     */
-    @Override
-    public void grow(Location origin, Random random) {
-        int h = random.nextInt(5) + 5;
-        BlockData obsidian = getMain().getWorldHandle().createBlockData("minecraft:obsidian");
-        for(int i = -h; i < h; i++) setBlock(origin.clone().add(0, i, 0), obsidian);
-    }
-}
@@ -1,75 +0,0 @@
-package com.dfsek.terra.api.world.tree.fractal.trees;
-
-import com.dfsek.terra.api.TerraPlugin;
-import com.dfsek.terra.api.math.vector.Location;
-import com.dfsek.terra.api.math.vector.Vector3;
-import com.dfsek.terra.api.platform.block.BlockData;
-import com.dfsek.terra.api.platform.handle.WorldHandle;
-import com.dfsek.terra.api.util.collections.MaterialSet;
-import com.dfsek.terra.api.util.collections.ProbabilityCollection;
-import com.dfsek.terra.api.world.tree.fractal.FractalTree;
-import com.dfsek.terra.api.world.tree.fractal.TreeGeometry;
-import net.jafama.FastMath;
-
-import java.util.Random;
-
-public class SmallShatteredTree extends FractalTree {
-    private final TreeGeometry geo;
-    private final ProbabilityCollection<BlockData> bark;
-    private final ProbabilityCollection<BlockData> leaves;
-
-    @Override
-    public MaterialSet getSpawnable() {
-        return MaterialSet.get(main.getWorldHandle().createBlockData("minecraft:end_stone"));
-    }
-
-    /**
-     * Instantiates a TreeGrower at an origin location.
-     */
-    public SmallShatteredTree(TerraPlugin main) {
-        super(main);
-        geo = new TreeGeometry(this);
-
-        WorldHandle handle = main.getWorldHandle();
-        bark = new ProbabilityCollection<BlockData>()
-                .add(handle.createBlockData("minecraft:obsidian"), 1)
-                .add(handle.createBlockData("minecraft:black_concrete"), 1);
-        leaves = new ProbabilityCollection<BlockData>()
-                .add(handle.createBlockData("minecraft:purple_stained_glass"), 1)
-                .add(handle.createBlockData("minecraft:magenta_stained_glass"), 1);
-    }
-
-    /**
-     * Grows the tree in memory. Intended to be invoked from an async thread.
-     */
-    @Override
-    public void grow(Location origin, Random random) {
-        growBranch(origin.clone(), new Vector3(random.nextInt(5) - 2, random.nextInt(3) + 4, random.nextInt(5) - 2), 1.5, 0, random);
-
-    }
-
-    private void growBranch(Location l1, Vector3 diff, double d1, int recursions, Random r) {
-        if(recursions > 2) {
-            geo.generateSphere(l1, leaves, 1 + r.nextInt(2) + (3 - recursions), false, r);
-            return;
-        }
-        if(diff.getY() < 0) diff.rotateAroundAxis(TreeGeometry.getPerpendicular(diff.clone()).normalize(), FastMath.PI);
-        int d = (int) diff.length();
-        for(int i = 0; i < d; i++) {
-            geo.generateSphere(l1.clone().add(diff.clone().multiply((double) i / d)), bark, FastMath.max((int) d1, 0), true, r);
-        }
-        double runningAngle = (double) 45 / (recursions + 1);
-        growBranch(l1.clone().add(diff), diff.clone().multiply(0.7).rotateAroundX(FastMath.toRadians(runningAngle + getNoise(r))).rotateAroundZ(FastMath.toRadians(getNoise(r))),
-                d1 - 1, recursions + 1, r);
-        growBranch(l1.clone().add(diff), diff.clone().multiply(0.7).rotateAroundX(FastMath.toRadians(-runningAngle + getNoise(r))).rotateAroundZ(FastMath.toRadians(getNoise(r))),
-                d1 - 1, recursions + 1, r);
-        growBranch(l1.clone().add(diff), diff.clone().multiply(0.7).rotateAroundZ(FastMath.toRadians(runningAngle + getNoise(r))).rotateAroundX(FastMath.toRadians(getNoise(r))),
-                d1 - 1, recursions + 1, r);
-        growBranch(l1.clone().add(diff), diff.clone().multiply(0.7).rotateAroundZ(FastMath.toRadians(-runningAngle + getNoise(r))).rotateAroundX(FastMath.toRadians(getNoise(r))),
-                d1 - 1, recursions + 1, r);
-    }
-
-    private int getNoise(Random r) {
-        return r.nextInt(90) - 45;
-    }
-}
@@ -1,53 +0,0 @@
-package com.dfsek.terra.api.world.tree.fractal.trees;
-
-import com.dfsek.terra.api.TerraPlugin;
-import com.dfsek.terra.api.math.vector.Location;
-import com.dfsek.terra.api.math.vector.Vector3;
-import com.dfsek.terra.api.platform.block.BlockData;
-import com.dfsek.terra.api.util.collections.MaterialSet;
-import com.dfsek.terra.api.world.tree.fractal.FractalTree;
-import com.dfsek.terra.api.world.tree.fractal.TreeGeometry;
-import net.jafama.FastMath;
-
-import java.util.Random;
-
-public class SpruceTree extends FractalTree {
-    private final TreeGeometry geo;
-
-    @Override
-    public MaterialSet getSpawnable() {
-        return MaterialSet.get(main.getWorldHandle().createBlockData("minecraft:podzol"),
-                main.getWorldHandle().createBlockData("minecraft:grass_block"));
-    }
-
-    /**
-     * Instantiates a TreeGrower at an origin location.
-     */
-    public SpruceTree(TerraPlugin main) {
-        super(main);
-        geo = new TreeGeometry(this);
-    }
-
-    /**
-     * Grows the tree in memory. Intended to be invoked from an async thread.
-     */
-    @Override
-    public void grow(Location origin, Random random) {
-        growTrunk(origin.clone(), new Vector3(0, 16 + random.nextInt(5), 0), random);
-    }
-
-    private void growTrunk(Location l1, Vector3 diff, Random r) {
-        if(diff.getY() < 0) diff.rotateAroundAxis(TreeGeometry.getPerpendicular(diff.clone()).normalize(), FastMath.PI);
-        int d = (int) diff.length();
-        int rad = 7;
-        BlockData wood = getMain().getWorldHandle().createBlockData("minecraft:spruce_wood");
-        BlockData leaves = getMain().getWorldHandle().createBlockData("minecraft:spruce_leave");
-        for(int i = 0; i < d; i++) {
-            geo.generateSphere(l1.clone().add(diff.clone().multiply((double) i / d)), wood, (int) ((i > d * 0.65) ? 0.5 : 1.5), true, r);
-            if(i > 3)
-                geo.generateCylinder(l1.clone().add(diff.clone().multiply((double) i / d)), leaves, (int) (((6 - (i % 4))) * (1.25 - ((double) i / d))), 1, false, r);
-        }
-        setBlock(l1.clone().add(diff), leaves);
-        setBlock(l1.clone().add(diff).add(0, 1, 0), leaves);
-    }
-}
@@ -63,8 +63,6 @@ public class StructureLoadCommand implements CommandTemplate {

    @Override
    public void execute(CommandSender sender) {
-        System.out.println(rotation);
-
        Player player = (Player) sender;

        long t = System.nanoTime();
@@ -4,7 +4,10 @@ import com.dfsek.terra.api.platform.world.Biome;
 import com.dfsek.terra.api.util.collections.ProbabilityCollection;
 import com.dfsek.terra.api.util.seeded.SeededBuilder;
 import com.dfsek.terra.api.world.biome.TerraBiome;
+import com.dfsek.terra.config.templates.BiomeTemplate;

 public interface BiomeBuilder extends SeededBuilder<TerraBiome> {
    ProbabilityCollection<Biome> getVanillaBiomes();
+
+    BiomeTemplate getTemplate();
 }
@@ -66,4 +66,9 @@ public class UserDefinedBiomeBuilder implements BiomeBuilder {
    public ProbabilityCollection<Biome> getVanillaBiomes() {
        return template.getVanilla();
    }
+
+    @Override
+    public BiomeTemplate getTemplate() {
+        return template;
+    }
 }
@@ -1,7 +1,7 @@
 package com.dfsek.terra.config.factories;

 import com.dfsek.terra.api.TerraPlugin;
-import com.dfsek.terra.api.world.tree.Tree;
+import com.dfsek.terra.api.platform.world.Tree;
 import com.dfsek.terra.config.templates.TreeTemplate;
 import com.dfsek.terra.world.population.items.tree.TerraTree;

@@ -1,11 +1,11 @@
 package com.dfsek.terra.config.loaders;

 import com.dfsek.terra.api.platform.block.BlockData;
+import com.dfsek.terra.api.platform.world.Tree;
 import com.dfsek.terra.api.util.collections.ProbabilityCollection;
 import com.dfsek.terra.api.world.biome.TerraBiome;
 import com.dfsek.terra.api.world.flora.Flora;
 import com.dfsek.terra.api.world.palette.Palette;
-import com.dfsek.terra.api.world.tree.Tree;

 import java.lang.reflect.Type;
 import java.util.Map;
@@ -5,9 +5,9 @@ import com.dfsek.tectonic.loading.ConfigLoader;
 import com.dfsek.tectonic.loading.TypeLoader;
 import com.dfsek.terra.api.math.Range;
 import com.dfsek.terra.api.math.noise.samplers.noise.random.WhiteNoiseSampler;
+import com.dfsek.terra.api.platform.world.Tree;
 import com.dfsek.terra.api.util.collections.ProbabilityCollection;
 import com.dfsek.terra.api.util.seeded.NoiseSeeded;
-import com.dfsek.terra.api.world.tree.Tree;
 import com.dfsek.terra.config.loaders.Types;
 import com.dfsek.terra.world.population.items.tree.TreeLayer;

@@ -65,7 +65,6 @@ public class ExpressionFunctionTemplate extends SamplerTemplate<ExpressionFuncti
        Map<String, Function> noiseFunctionMap = new HashMap<>();

        for(Map.Entry<String, FunctionTemplate> entry : expressions.entrySet()) {
-            System.out.println(entry);
            noiseFunctionMap.put(entry.getKey(), UserDefinedFunction.newInstance(entry.getValue(), new Parser(), new Scope()));
        }

@@ -12,6 +12,7 @@ import com.dfsek.terra.api.TerraPlugin;
 import com.dfsek.terra.api.event.events.config.ConfigPackPostLoadEvent;
 import com.dfsek.terra.api.event.events.config.ConfigPackPreLoadEvent;
 import com.dfsek.terra.api.platform.block.BlockData;
+import com.dfsek.terra.api.platform.world.Tree;
 import com.dfsek.terra.api.registry.CheckedRegistry;
 import com.dfsek.terra.api.structures.loot.LootTable;
 import com.dfsek.terra.api.structures.parser.lang.functions.FunctionBuilder;
@@ -20,7 +21,6 @@ import com.dfsek.terra.api.util.seeded.NoiseSeeded;
 import com.dfsek.terra.api.world.biome.provider.BiomeProvider;
 import com.dfsek.terra.api.world.flora.Flora;
 import com.dfsek.terra.api.world.palette.Palette;
-import com.dfsek.terra.api.world.tree.Tree;
 import com.dfsek.terra.carving.UserDefinedCarver;
 import com.dfsek.terra.config.builder.BiomeBuilder;
 import com.dfsek.terra.config.dummy.DummyWorld;
@@ -120,7 +120,7 @@ public class ConfigPack implements LoaderRegistrar {
            long l = System.nanoTime();
            floraRegistry = new FloraRegistry(main);
            paletteRegistry = new PaletteRegistry(main);
-            treeRegistry = new TreeRegistry(main);
+            treeRegistry = new TreeRegistry();
            register(abstractConfigLoader);
            register(selfLoader);

@@ -156,7 +156,7 @@ public class ConfigPack implements LoaderRegistrar {
            long l = System.nanoTime();
            floraRegistry = new FloraRegistry(main);
            paletteRegistry = new PaletteRegistry(main);
-            treeRegistry = new TreeRegistry(main);
+            treeRegistry = new TreeRegistry();
            register(abstractConfigLoader);
            register(selfLoader);

@@ -73,6 +73,46 @@ public class ConfigPackTemplate implements ConfigTemplate {
    @Default
    private String version = "0.1.0";

+    @Value("disable.carvers")
+    @Default
+    private boolean disableCarvers = false;
+
+    @Value("disable.structures")
+    @Default
+    private boolean disableStructures = false;
+
+    @Value("disable.ores")
+    @Default
+    private boolean disableOres = false;
+
+    @Value("disable.trees")
+    @Default
+    private boolean disableTrees = false;
+
+    @Value("disable.flora")
+    @Default
+    private boolean disableFlora = false;
+
+    public boolean disableCarvers() {
+        return disableCarvers;
+    }
+
+    public boolean disableFlora() {
+        return disableFlora;
+    }
+
+    public boolean disableOres() {
+        return disableOres;
+    }
+
+    public boolean disableStructures() {
+        return disableStructures;
+    }
+
+    public boolean disableTrees() {
+        return disableTrees;
+    }
+
    public LinkedHashMap<String, FunctionTemplate> getFunctions() {
        return functions;
    }
@@ -1,19 +1,15 @@
 package com.dfsek.terra.config.pack;

-import com.dfsek.tectonic.loading.object.ObjectTemplate;
 import com.dfsek.terra.api.TerraPlugin;
 import com.dfsek.terra.api.platform.block.BlockData;
-import com.dfsek.terra.api.platform.world.World;
+import com.dfsek.terra.api.platform.world.Tree;
 import com.dfsek.terra.api.registry.LockedRegistry;
 import com.dfsek.terra.api.structures.loot.LootTable;
-import com.dfsek.terra.api.structures.parser.lang.functions.FunctionBuilder;
 import com.dfsek.terra.api.structures.script.StructureScript;
-import com.dfsek.terra.api.util.seeded.NoiseSeeded;
 import com.dfsek.terra.api.world.biome.TerraBiome;
 import com.dfsek.terra.api.world.biome.provider.BiomeProvider;
 import com.dfsek.terra.api.world.flora.Flora;
 import com.dfsek.terra.api.world.palette.Palette;
-import com.dfsek.terra.api.world.tree.Tree;
 import com.dfsek.terra.carving.UserDefinedCarver;
 import com.dfsek.terra.registry.OpenRegistry;
 import com.dfsek.terra.world.TerraWorld;
@@ -22,7 +18,6 @@ import com.dfsek.terra.world.population.items.TerraStructure;
 import com.dfsek.terra.world.population.items.ores.Ore;

 import java.util.Set;
-import java.util.function.Supplier;

 public class WorldConfig {
    private final LockedRegistry<StructureScript> scriptRegistry;
@@ -190,10 +190,19 @@ public class BiomeTemplate extends AbstractableTemplate implements ValidatedConf
    @Default
    private Map<UserDefinedCarver, Integer> carvers = new HashMap<>();

+    @Value("colors")
+    @Abstractable
+    @Default
+    private Map<String, Integer> colors = new HashMap<>(); // Plain ol' map, so platforms can decide what to do with colors (if anything).
+
    public Set<String> getTags() {
        return tags;
    }

+    public Map<String, Integer> getColors() {
+        return colors;
+    }
+
    public Map<UserDefinedCarver, Integer> getCarvers() {
        return carvers;
    }
@@ -1,77 +1,11 @@
 package com.dfsek.terra.registry.config;

-import com.dfsek.terra.api.TerraPlugin;
-import com.dfsek.terra.api.math.vector.Location;
-import com.dfsek.terra.api.platform.block.BlockFace;
-import com.dfsek.terra.api.util.collections.MaterialSet;
-import com.dfsek.terra.api.world.tree.Tree;
-import com.dfsek.terra.api.world.tree.fractal.FractalTree;
-import com.dfsek.terra.api.world.tree.fractal.trees.Cactus;
-import com.dfsek.terra.api.world.tree.fractal.trees.IceSpike;
-import com.dfsek.terra.api.world.tree.fractal.trees.OakTree;
-import com.dfsek.terra.api.world.tree.fractal.trees.ShatteredPillar;
-import com.dfsek.terra.api.world.tree.fractal.trees.ShatteredTree;
-import com.dfsek.terra.api.world.tree.fractal.trees.SmallShatteredPillar;
-import com.dfsek.terra.api.world.tree.fractal.trees.SmallShatteredTree;
-import com.dfsek.terra.api.world.tree.fractal.trees.SpruceTree;
+import com.dfsek.terra.api.platform.world.Tree;
 import com.dfsek.terra.registry.OpenRegistry;

-import java.lang.reflect.Constructor;
-import java.lang.reflect.InvocationTargetException;
-import java.util.Random;
-
 public class TreeRegistry extends OpenRegistry<Tree> {
-    private final TerraPlugin main;
-
-    public TreeRegistry(TerraPlugin main) {
-        this.main = main;
-        tryAdd("CACTUS", Cactus.class);
-        tryAdd("GIANT_OAK", OakTree.class);
-        tryAdd("GIANT_SPRUCE", SpruceTree.class);
-        tryAdd("LARGE_SHATTERED_PILLAR", ShatteredPillar.class);
-        tryAdd("SHATTERED_LARGE", ShatteredTree.class);
-        tryAdd("SHATTERED_SMALL", SmallShatteredTree.class);
-        tryAdd("SMALL_SHATTERED_PILLAR", SmallShatteredPillar.class);
-        tryAdd("ICE_SPIKE", IceSpike.class);
-    }
-
-    private void tryAdd(String id, Class<? extends FractalTree> value) {
-        try {
-            add(id, new FractalTreeHolder(value));
-        } catch(Exception e) {
-            main.logger().warning("Unable to load tree " + id + ": " + e.getMessage());
-        }
-    }
-
    @Override
    public boolean add(String identifier, Tree value) {
        return super.add(identifier, value);
    }
-
-    private final class FractalTreeHolder implements Tree {
-        private final FractalTree tree;
-
-        private FractalTreeHolder(Class<? extends FractalTree> clazz) throws NoSuchMethodException {
-            Constructor<? extends FractalTree> constructor = clazz.getConstructor(TerraPlugin.class);
-            try {
-                tree = constructor.newInstance(main);
-            } catch(InstantiationException | IllegalAccessException | InvocationTargetException e) {
-                e.printStackTrace();
-                throw new IllegalArgumentException("Unable to load tree: " + clazz);
-            }
-        }
-
-        @Override
-        public boolean plant(Location l, Random r) {
-            if(!getSpawnable().contains(l.getBlock().getType())) return false;
-            if(!l.getBlock().getRelative(BlockFace.UP).isEmpty()) return false;
-            tree.grow(l.add(0, 1, 0), r);
-            return true;
-        }
-
-        @Override
-        public MaterialSet getSpawnable() {
-            return tree.getSpawnable();
-        }
-    }
 }
@@ -33,7 +33,7 @@ public class TerraWorld {
        this.provider = config.getProvider();
        profiler = new WorldProfiler(w);
        air = main.getWorldHandle().createBlockData("minecraft:air");
-        main.getEventManager().callEvent(new TerraWorldLoadEvent(this));
+        main.getEventManager().callEvent(new TerraWorldLoadEvent(this, c));
        safe = true;
    }

@@ -10,6 +10,7 @@ import com.dfsek.terra.api.util.world.PaletteUtil;
 import com.dfsek.terra.api.world.biome.TerraBiome;
 import com.dfsek.terra.api.world.biome.UserDefinedBiome;
 import com.dfsek.terra.api.world.biome.provider.BiomeProvider;
+import com.dfsek.terra.api.world.generation.TerraBlockPopulator;
 import com.dfsek.terra.api.world.generation.TerraChunkGenerator;
 import com.dfsek.terra.api.world.palette.Palette;
 import com.dfsek.terra.config.pack.ConfigPack;
@@ -21,9 +22,15 @@ import com.dfsek.terra.world.carving.NoiseCarver;
 import com.dfsek.terra.world.generation.math.SamplerCache;
 import com.dfsek.terra.world.generation.math.samplers.Sampler;
 import com.dfsek.terra.world.generation.math.samplers.Sampler2D;
+import com.dfsek.terra.world.population.CavePopulator;
+import com.dfsek.terra.world.population.OrePopulator;
+import com.dfsek.terra.world.population.StructurePopulator;
+import com.dfsek.terra.world.population.TreePopulator;
 import net.jafama.FastMath;
 import org.jetbrains.annotations.NotNull;

+import java.util.ArrayList;
+import java.util.List;
 import java.util.Random;

 public class DefaultChunkGenerator2D implements TerraChunkGenerator {
@@ -31,12 +38,18 @@ public class DefaultChunkGenerator2D implements TerraChunkGenerator {
    private final TerraPlugin main;

    private final Carver carver;
+    private final List<TerraBlockPopulator> blockPopulators = new ArrayList<>();

    private final SamplerCache cache;

    public DefaultChunkGenerator2D(ConfigPack c, TerraPlugin main, SamplerCache cache) {
        this.configPack = c;
        this.main = main;
+        blockPopulators.add(new CavePopulator(main));
+        blockPopulators.add(new StructurePopulator(main));
+        blockPopulators.add(new OrePopulator(main));
+        blockPopulators.add(new TreePopulator(main));
+        blockPopulators.add(new TreePopulator(main));
        carver = new NoiseCarver(new Range(0, 255), main.getWorldHandle().createBlockData("minecraft:air"), main);
        this.cache = cache;
    }
@@ -125,4 +138,9 @@ public class DefaultChunkGenerator2D implements TerraChunkGenerator {
    public Sampler createSampler(int chunkX, int chunkZ, BiomeProvider provider, World world, int elevationSmooth) {
        return new Sampler2D(chunkX, chunkZ, provider, world, elevationSmooth);
    }
+
+    @Override
+    public List<TerraBlockPopulator> getPopulators() {
+        return blockPopulators;
+    }
 }
@@ -17,6 +17,7 @@ import com.dfsek.terra.api.util.world.PaletteUtil;
 import com.dfsek.terra.api.world.biome.TerraBiome;
 import com.dfsek.terra.api.world.biome.UserDefinedBiome;
 import com.dfsek.terra.api.world.biome.provider.BiomeProvider;
+import com.dfsek.terra.api.world.generation.TerraBlockPopulator;
 import com.dfsek.terra.api.world.generation.TerraChunkGenerator;
 import com.dfsek.terra.api.world.palette.Palette;
 import com.dfsek.terra.api.world.palette.SinglePalette;
@@ -28,8 +29,15 @@ import com.dfsek.terra.world.TerraWorld;
 import com.dfsek.terra.world.carving.NoiseCarver;
 import com.dfsek.terra.world.generation.math.samplers.Sampler;
 import com.dfsek.terra.world.generation.math.samplers.Sampler3D;
+import com.dfsek.terra.world.population.CavePopulator;
+import com.dfsek.terra.world.population.FloraPopulator;
+import com.dfsek.terra.world.population.OrePopulator;
+import com.dfsek.terra.world.population.StructurePopulator;
+import com.dfsek.terra.world.population.TreePopulator;
 import org.jetbrains.annotations.NotNull;

+import java.util.ArrayList;
+import java.util.List;
 import java.util.Map;
 import java.util.Random;

@@ -38,14 +46,21 @@ public class DefaultChunkGenerator3D implements TerraChunkGenerator {
    private final TerraPlugin main;
    private final BlockType water;
    private final SinglePalette<BlockData> blank;
+    private final List<TerraBlockPopulator> blockPopulators = new ArrayList<>();

    private final Carver carver;


-
    public DefaultChunkGenerator3D(ConfigPack c, TerraPlugin main) {
        this.configPack = c;
        this.main = main;
+
+        blockPopulators.add(new CavePopulator(main));
+        blockPopulators.add(new StructurePopulator(main));
+        blockPopulators.add(new OrePopulator(main));
+        blockPopulators.add(new TreePopulator(main));
+        blockPopulators.add(new FloraPopulator(main));
+
        carver = new NoiseCarver(new Range(0, 255), main.getWorldHandle().createBlockData("minecraft:air"), main);
        water = main.getWorldHandle().createBlockData("minecraft:water").getBlockType();
        blank = new SinglePalette<>(main.getWorldHandle().createBlockData("minecraft:air"));
@@ -236,4 +251,9 @@ public class DefaultChunkGenerator3D implements TerraChunkGenerator {
    public Sampler createSampler(int chunkX, int chunkZ, BiomeProvider provider, World world, int elevationSmooth) {
        return new Sampler3D(chunkX, chunkZ, provider, world, elevationSmooth);
    }
+
+    @Override
+    public List<TerraBlockPopulator> getPopulators() {
+        return blockPopulators;
+    }
 }
@@ -2,7 +2,6 @@ package com.dfsek.terra.world.generation.math;

 import com.dfsek.terra.api.TerraPlugin;
 import com.dfsek.terra.api.math.MathUtil;
-import com.dfsek.terra.api.platform.world.World;
 import com.dfsek.terra.world.TerraWorld;
 import com.dfsek.terra.world.generation.math.samplers.Sampler;
 import com.google.common.cache.CacheBuilder;
@@ -11,10 +10,6 @@ import com.google.common.cache.LoadingCache;
 import net.jafama.FastMath;
 import org.jetbrains.annotations.NotNull;

-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Map;
-
 public class SamplerCache {
    private final LoadingCache<Long, Sampler> cache;

@@ -9,6 +9,7 @@ import com.dfsek.terra.api.platform.handle.WorldHandle;
 import com.dfsek.terra.api.platform.world.Chunk;
 import com.dfsek.terra.api.platform.world.World;
 import com.dfsek.terra.api.util.world.PopulationUtil;
+import com.dfsek.terra.api.world.generation.Chunkified;
 import com.dfsek.terra.api.world.generation.TerraBlockPopulator;
 import com.dfsek.terra.carving.UserDefinedCarver;
 import com.dfsek.terra.config.pack.WorldConfig;
@@ -23,7 +24,7 @@ import java.util.Map;
 import java.util.Random;
 import java.util.Set;

-public class CavePopulator implements TerraBlockPopulator {
+public class CavePopulator implements TerraBlockPopulator, Chunkified {
    private static final Map<BlockType, BlockData> shiftStorage = new HashMap<>(); // Persist BlockData created for shifts, to avoid re-calculating each time.
    private final TerraPlugin main;

@@ -41,6 +42,7 @@ public class CavePopulator implements TerraBlockPopulator {
            Random random = PopulationUtil.getRandom(chunk);
            if(!tw.isSafe()) return;
            WorldConfig config = tw.getConfig();
+            if(config.getTemplate().disableCarvers()) return;

            for(UserDefinedCarver c : config.getCarvers()) {
                CarverTemplate template = c.getConfig();
@@ -33,6 +33,8 @@ public class FloraPopulator implements TerraBlockPopulator {
    public void populate(@NotNull World world, @NotNull Chunk chunk) {
        TerraWorld tw = main.getWorld(world);
        try(ProfileFuture ignored = tw.getProfiler().measure("FloraTime")) {
+            if(tw.getConfig().getTemplate().disableCarvers()) return;
+
            if(!tw.isSafe()) return;
            BiomeProvider provider = tw.getBiomeProvider();
            Map<Vector2, List<FloraLayer>> layers = new HashMap<>();
@@ -28,6 +28,8 @@ public class OrePopulator implements TerraBlockPopulator {
    public void populate(@NotNull World world, @NotNull Chunk chunk) {
        TerraWorld tw = main.getWorld(world);
        try(ProfileFuture ignored = tw.getProfiler().measure("OreTime")) {
+            if(tw.getConfig().getTemplate().disableCarvers()) return;
+
            if(!tw.isSafe()) return;
            for(int cx = -1; cx <= 1; cx++) {
                for(int cz = -1; cz <= 1; cz++) {
@@ -9,6 +9,7 @@ import com.dfsek.terra.api.structures.structure.Rotation;
 import com.dfsek.terra.api.util.FastRandom;
 import com.dfsek.terra.api.world.biome.UserDefinedBiome;
 import com.dfsek.terra.api.world.biome.provider.BiomeProvider;
+import com.dfsek.terra.api.world.generation.Chunkified;
 import com.dfsek.terra.api.world.generation.TerraBlockPopulator;
 import com.dfsek.terra.config.pack.ConfigPack;
 import com.dfsek.terra.config.pack.WorldConfig;
@@ -20,7 +21,7 @@ import org.jetbrains.annotations.NotNull;

 import java.util.Random;

-public class StructurePopulator implements TerraBlockPopulator {
+public class StructurePopulator implements TerraBlockPopulator, Chunkified {
    private final TerraPlugin main;

    public StructurePopulator(TerraPlugin main) {
@@ -32,6 +33,8 @@ public class StructurePopulator implements TerraBlockPopulator {
    public void populate(@NotNull World world, @NotNull Chunk chunk) {
        TerraWorld tw = main.getWorld(world);
        try(ProfileFuture ignored = tw.getProfiler().measure("StructureTime")) {
+            if(tw.getConfig().getTemplate().disableCarvers()) return;
+
            int cx = (chunk.getX() << 4);
            int cz = (chunk.getZ() << 4);
            if(!tw.isSafe()) return;
@@ -33,6 +33,8 @@ public class TreePopulator implements TerraBlockPopulator {
    public void populate(@NotNull World world, @NotNull Chunk chunk) {
        TerraWorld tw = main.getWorld(world);
        try(ProfileFuture ignored = tw.getProfiler().measure("TreeTime")) {
+            if(tw.getConfig().getTemplate().disableCarvers()) return;
+
            if(!tw.isSafe()) return;
            BiomeProvider provider = tw.getBiomeProvider();
            Random random = PopulationUtil.getRandom(chunk);
@@ -21,6 +21,12 @@ public class FloraLayer extends PlaceableLayer<Flora> {
    @Override
    public void place(Chunk chunk, Vector2 coords) {
        Flora item = layer.get(noise, (chunk.getX() << 4) + coords.getX(), (chunk.getZ() << 4) + coords.getZ());
-        item.getValidSpawnsAt(chunk, (int) coords.getX(), (int) coords.getZ(), level).forEach(block -> item.plant(block.getLocation()));
+        item.getValidSpawnsAt(chunk, (int) coords.getX(), (int) coords.getZ(), level).forEach(block -> {
+            try {
+                item.plant(block.getLocation());
+            } catch(Exception e) {
+                e.printStackTrace();
+            }
+        });
    }
 }
@@ -9,7 +9,6 @@ import com.dfsek.terra.api.platform.block.BlockFace;
 import com.dfsek.terra.api.platform.block.data.Directional;
 import com.dfsek.terra.api.platform.block.data.MultipleFacing;
 import com.dfsek.terra.api.platform.block.data.Rotatable;
-import com.dfsek.terra.api.platform.handle.WorldHandle;
 import com.dfsek.terra.api.platform.world.Chunk;
 import com.dfsek.terra.api.util.FastRandom;
 import com.dfsek.terra.api.util.GlueList;
@@ -94,7 +93,6 @@ public class TerraFlora implements Flora {

    @Override
    public boolean plant(Location location) {
-        WorldHandle handle = main.getWorldHandle();

        boolean doRotation = testRotation.size() > 0;
        int size = floraPalette.getSize();
@@ -1,11 +1,11 @@
 package com.dfsek.terra.world.population.items.tree;

 import com.dfsek.terra.api.math.vector.Location;
+import com.dfsek.terra.api.platform.world.Tree;
 import com.dfsek.terra.api.structures.script.StructureScript;
 import com.dfsek.terra.api.structures.structure.Rotation;
 import com.dfsek.terra.api.util.collections.MaterialSet;
 import com.dfsek.terra.api.util.collections.ProbabilityCollection;
-import com.dfsek.terra.api.world.tree.Tree;

 import java.util.Random;

@@ -6,9 +6,9 @@ import com.dfsek.terra.api.math.vector.Vector2;
 import com.dfsek.terra.api.platform.block.Block;
 import com.dfsek.terra.api.platform.block.BlockFace;
 import com.dfsek.terra.api.platform.world.Chunk;
+import com.dfsek.terra.api.platform.world.Tree;
 import com.dfsek.terra.api.util.collections.ProbabilityCollection;
 import com.dfsek.terra.api.util.world.PopulationUtil;
-import com.dfsek.terra.api.world.tree.Tree;
 import com.dfsek.terra.world.population.items.PlaceableLayer;

 public class TreeLayer extends PlaceableLayer<Tree> {
@@ -39,6 +39,7 @@ import com.dfsek.terra.config.loaders.config.biome.templates.provider.SingleBiom
 import com.dfsek.terra.config.loaders.config.sampler.NoiseSamplerBuilderLoader;
 import com.dfsek.terra.config.pack.ConfigPack;
 import com.dfsek.terra.config.templates.AbstractableTemplate;
+import com.dfsek.terra.config.templates.BiomeTemplate;
 import com.dfsek.terra.registry.config.BiomeRegistry;
 import com.dfsek.terra.registry.config.NoiseRegistry;
 import com.dfsek.terra.world.TerraWorld;
@@ -306,6 +307,11 @@ public class DistributionTest {
            return null;
        }

+        @Override
+        public BiomeTemplate getTemplate() {
+            return null;
+        }
+
        @Override
        public Generator getGenerator(World w) {
            return null;
@@ -93,7 +93,7 @@ public class CommandTest {
            arguments = {
                    @Argument(value = "arg0"),
                    @Argument(value = "arg1", argumentParser = IntegerArgumentParser.class),
-                    @Argument(value = "arg2", required = false, argumentParser = DoubleArgumentParser.class)
+                    @Argument(value = "arg2", required = false, argumentParser = DoubleArgumentParser.class, defaultValue = "0")
            }
    )
    public static final class DemoCommand implements CommandTemplate {
@@ -15,6 +15,13 @@ configureCommon()

 group = "com.dfsek.terra.bukkit"

+val mcVersion = "1.16.5"
+val testDir = "target/server/"
+val testMem = "3G"
+
+val paperURL = "https://papermc.io/api/v1/paper/%version%/latest/download/"
+val purpurURL = "https://ci.pl3x.net/job/Purpur/lastSuccessfulBuild/artifact/final/purpurclip.jar"
+
 repositories {
    mavenCentral()
    maven { url = uri("http://maven.enginehub.org/repo/") }
@@ -35,73 +42,160 @@ dependencies {
    "shadedImplementation"("com.google.guava:guava:30.0-jre")
 }

-val testDir = "target/server/"
+val aikarsFlags = listOf("-XX:+UseG1GC", "-XX:+ParallelRefProcEnabled", "-XX:MaxGCPauseMillis=200",
+        "-XX:+UnlockExperimentalVMOptions", "-XX:+DisableExplicitGC", "-XX:+AlwaysPreTouch",
+        "-XX:G1NewSizePercent=30", "-XX:G1MaxNewSizePercent=40", "-XX:G1HeapRegionSize=8M",
+        "-XX:G1ReservePercent=20", "-XX:G1HeapWastePercent=5", "-XX:G1MixedGCCountTarget=4",
+        "-XX:InitiatingHeapOccupancyPercent=15", "-XX:G1MixedGCLiveThresholdPercent=90",
+        "-XX:G1RSetUpdatingPauseTimePercent=5", "-XX:SurvivorRatio=32", "-XX:+PerfDisableSharedMem",
+        "-XX:MaxTenuringThreshold=1", "-Dusing.aikars.flags=https://mcflags.emc.gs",
+        "-Daikars.new.flags=true", "-DIReallyKnowWhatIAmDoingISwear")

-val setupServer = tasks.create("setupServer") {
-    dependsOn("shadowJar")
-    doFirst {
-        // clean
-        file("${testDir}/").deleteRecursively()
-        file("${testDir}/plugins").mkdirs()
+fun downloadPaperclip(url: String, dir: String) {
+    val clip = URL(url.replace("%version%", mcVersion))
+    val clipReadableByteChannel = Channels.newChannel(clip.openStream())
+    val clipFile = file("$testDir/$dir/paperclip.jar")
+    val clipOutputStream = clipFile.outputStream()
+    val clipFileChannel = clipOutputStream.channel
+    clipFileChannel.transferFrom(clipReadableByteChannel, 0, Long.MAX_VALUE)
+}

-        // Downloading latest paper jar.
-        val paperUrl = URL("https://papermc.io/api/v1/paper/1.16.4/latest/download")
-        val paperReadableByteChannel = Channels.newChannel(paperUrl.openStream())
-        val paperFile = file("${testDir}/paper.jar")
-        val paperFileOutputStream = paperFile.outputStream()
-        val paperFileChannel = paperFileOutputStream.channel
-        paperFileChannel.transferFrom(paperReadableByteChannel, 0, Long.MAX_VALUE)
-
-        // Cloning test setup.
-        gitClone("https://github.com/PolyhedralDev/WorldGenTestServer")
-        // Copying plugins
-        Files.move(Paths.get("WorldGenTestServer/plugins"),
-                Paths.get("$testDir/plugins"),
-                StandardCopyOption.REPLACE_EXISTING)
-        // Copying config
-        val serverText = URL("https://raw.githubusercontent.com/PolyhedralDev/WorldGenTestServer/master/server.properties").readText()
-        file("${testDir}/server.properties").writeText(serverText)
-        val bukkitText = URL("https://raw.githubusercontent.com/PolyhedralDev/WorldGenTestServer/master/bukkit.yml").readText()
-        file("${testDir}/bukkit.yml").writeText(bukkitText.replace("\${world}", "world").replace("\${gen}", "Terra:DEFAULT"))
-
-        File("${testDir}/eula.txt").writeText("eula=true")
-
-        // clean up
-        file("WorldGenTestServer").deleteRecursively()
+fun copyTerra(dir: String) {
+    file("$testDir/$dir").walk().forEach {
+        if(it.name.startsWith("Terra-") && it.name.endsWith(".jar")) it.delete() // Delete old Terra jar(s)
+    }
+    copy {
+        from("$buildDir/libs/Terra-bukkit-$version-shaded.jar")
+        into("$testDir/$dir/plugins/")
    }
 }

-val testWithPaper = task<JavaExec>(name = "testWithPaper") {
+fun installServer(dir: String) {
+    // clean
+    file("$testDir/$dir").deleteRecursively()
+    file("$testDir/$dir/plugins").mkdirs()
+    // Cloning test setup.
+    gitClone("https://github.com/PolyhedralDev/WorldGenTestServer")
+    // Copying plugins
+    Files.move(Paths.get("WorldGenTestServer/plugins"),
+            Paths.get("$testDir/$dir/plugins"),
+            StandardCopyOption.REPLACE_EXISTING)
+    // Copying config
+    val serverText = URL("https://raw.githubusercontent.com/PolyhedralDev/WorldGenTestServer/master/server.properties").readText()
+    file("$testDir/$dir/server.properties").writeText(serverText)
+    val bukkitText = URL("https://raw.githubusercontent.com/PolyhedralDev/WorldGenTestServer/master/bukkit.yml").readText()
+    file("$testDir/$dir/bukkit.yml").writeText(bukkitText.replace("\${world}", "world").replace("\${gen}", "Terra:DEFAULT"))
+
+    println("By proceeding, you are agreeing to the Minecraft EULA: https://account.mojang.com/documents/minecraft_eula")
+    file("$testDir/$dir/eula.txt").writeText("eula=true")
+
+    // clean up
+    file("WorldGenTestServer").deleteRecursively()
+}
+
+fun deleteFolder(folder: File) {
+    if(folder.exists()) folder.deleteRecursively()
+}
+
+fun deleteFile(file: File) {
+    if(file.exists()) file.delete()
+}
+
+tasks.create("cleanWorlds") {
+    group = "bukkit"
+    doFirst {
+        deleteFolder(file("$testDir/paper/world"))
+        deleteFolder(file("$testDir/paper/world_nether"))
+        deleteFolder(file("$testDir/paper/world_the_end"))
+
+        deleteFolder(file("$testDir/purpur/world"))
+        deleteFolder(file("$testDir/purpur/world_nether"))
+        deleteFolder(file("$testDir/purpur/world_the_end"))
+    }
+}
+
+tasks.create("updatePaper") {
+    group = "bukkit"
+    doFirst {
+        deleteFile(file("$testDir/paper/paperclip.jar"))
+        downloadPaperclip(paperURL, "paper")
+    }
+}
+
+tasks.create("updatePurpur") {
+    group = "bukkit"
+    doFirst {
+        deleteFile(file("$testDir/paper/paperclip.jar"))
+        downloadPaperclip(purpurURL, "purpur")
+    }
+}
+
+tasks.create("installPaper") {
+    group = "bukkit"
+    dependsOn("shadowJar")
+    doFirst {
+        installServer("paper")
+        // Downloading latest paper jar.
+        downloadPaperclip(paperURL, "paper")
+    }
+}
+
+tasks.create("installPurpur") {
+    group = "bukkit"
+    dependsOn("shadowJar")
+    doFirst {
+        installServer("purpur")
+        // Downloading latest paper jar.
+        downloadPaperclip(purpurURL, "purpur")
+    }
+}
+
+task<JavaExec>(name = "runPaper") {
+    group = "bukkit"
    standardInput = System.`in`
    dependsOn("shadowJar")
    // Copy Terra into dir
    doFirst {
-        copy {
-            from("${buildDir}/libs/Terra-bukkit-${version}-shaded.jar")
-            into("${testDir}/plugins/")
-        }
+        copyTerra("paper")
    }

    main = "io.papermc.paperclip.Paperclip"
-    jvmArgs = listOf("-XX:+UseG1GC", "-XX:+ParallelRefProcEnabled", "-XX:MaxGCPauseMillis=200",
-            "-XX:+UnlockExperimentalVMOptions", "-XX:+DisableExplicitGC", "-XX:+AlwaysPreTouch",
-            "-XX:G1NewSizePercent=30", "-XX:G1MaxNewSizePercent=40", "-XX:G1HeapRegionSize=8M",
-            "-XX:G1ReservePercent=20", "-XX:G1HeapWastePercent=5", "-XX:G1MixedGCCountTarget=4",
-            "-XX:InitiatingHeapOccupancyPercent=15", "-XX:G1MixedGCLiveThresholdPercent=90",
-            "-XX:G1RSetUpdatingPauseTimePercent=5", "-XX:SurvivorRatio=32", "-XX:+PerfDisableSharedMem",
-            "-XX:MaxTenuringThreshold=1", "-Dusing.aikars.flags=https://mcflags.emc.gs",
-            "-Daikars.new.flags=true", "-DIReallyKnowWhatIAmDoingISwear")
-    maxHeapSize = "4G"
-    minHeapSize = "4G"
+    jvmArgs = aikarsFlags
+    maxHeapSize = testMem
+    minHeapSize = testMem
    //args = listOf("nogui")
-    workingDir = file("${testDir}/")
-    classpath = files("${testDir}/paper.jar")
+    workingDir = file("$testDir/paper")
+    classpath = files("$testDir/paper/paperclip.jar")
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_11
+    targetCompatibility = JavaVersion.VERSION_1_8
+}
+
+task<JavaExec>(name = "runPurpur") {
+    group = "bukkit"
+    standardInput = System.`in`
+    dependsOn("shadowJar")
+    // Copy Terra into dir
+    doFirst {
+        copyTerra("purpur")
+    }
+
+    main = "io.papermc.paperclip.Paperclip"
+    jvmArgs = aikarsFlags
+    maxHeapSize = testMem
+    minHeapSize = testMem
+    //args = listOf("nogui")
+    workingDir = file("$testDir/purpur")
+    classpath = files("$testDir/purpur/paperclip.jar")
 }

 tasks.named<ShadowJar>("shadowJar") {
    relocate("org.bstats.bukkit", "com.dfsek.terra.lib.bstats")
    relocate("io.papermc.lib", "com.dfsek.terra.lib.paperlib")
 }
+
 publishing {
    publications {
        create<MavenPublication>("mavenJava") {
@@ -112,7 +206,6 @@ publishing {

    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
@@ -23,6 +23,8 @@ import org.jetbrains.annotations.NotNull;

 import java.io.FileNotFoundException;
 import java.io.IOException;
+import java.util.Arrays;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.LinkedList;
 import java.util.List;
@@ -40,20 +42,13 @@ public class BukkitChunkGeneratorWrapper extends ChunkGenerator implements Gener

    private final TerraPlugin main;

-    private final List<TerraBlockPopulator> populators = new LinkedList<>();
-
    private boolean needsLoad = true;

    public BukkitChunkGeneratorWrapper(TerraChunkGenerator delegate) {
        this.delegate = delegate;
        this.main = delegate.getMain();
-        popMan = new PopulationManager(main);
-        popMan.attach(new OrePopulator(main));
-        popMan.attach(new TreePopulator(main));
-        popMan.attach(new FloraPopulator(main));
-        populators.add(new CavePopulator(main));
-        populators.add(new StructurePopulator(main));
-        populators.add(popMan);
+        this.popMan = new PopulationManager(delegate, main);
+
    }


@@ -96,7 +91,7 @@ public class BukkitChunkGeneratorWrapper extends ChunkGenerator implements Gener

    @Override
    public @NotNull List<BlockPopulator> getDefaultPopulators(@NotNull World world) {
-        return populators.stream().map(BukkitPopulatorWrapper::new).collect(Collectors.toList());
+        return Arrays.asList(popMan, new BukkitPopulatorWrapper(delegate));
    }

    @Override
@@ -1,27 +0,0 @@
-package com.dfsek.terra.bukkit.generator;
-
-import com.dfsek.terra.api.platform.world.Chunk;
-import com.dfsek.terra.api.platform.world.World;
-import com.dfsek.terra.api.platform.world.generator.BlockPopulator;
-import com.dfsek.terra.bukkit.world.BukkitChunk;
-import com.dfsek.terra.bukkit.world.BukkitWorld;
-
-import java.util.Random;
-
-public class BukkitPopulator implements BlockPopulator {
-    private final org.bukkit.generator.BlockPopulator handle;
-
-    public BukkitPopulator(org.bukkit.generator.BlockPopulator handle) {
-        this.handle = handle;
-    }
-
-    @Override
-    public void populate(World world, Random random, Chunk chunk) {
-        handle.populate(((BukkitWorld) world).getHandle(), random, ((BukkitChunk) chunk).getHandle());
-    }
-
-    @Override
-    public org.bukkit.generator.BlockPopulator getHandle() {
-        return handle;
-    }
-}
@@ -1,6 +1,8 @@
 package com.dfsek.terra.bukkit.generator;

+import com.dfsek.terra.api.world.generation.Chunkified;
 import com.dfsek.terra.api.world.generation.TerraBlockPopulator;
+import com.dfsek.terra.api.world.generation.TerraChunkGenerator;
 import com.dfsek.terra.bukkit.world.BukkitAdapter;
 import org.bukkit.Chunk;
 import org.bukkit.World;
@@ -10,14 +12,18 @@ import org.jetbrains.annotations.NotNull;
 import java.util.Random;

 public class BukkitPopulatorWrapper extends BlockPopulator {
-    private final TerraBlockPopulator delegate;
+    private final TerraChunkGenerator delegate;

-    public BukkitPopulatorWrapper(TerraBlockPopulator delegate) {
+    public BukkitPopulatorWrapper(TerraChunkGenerator delegate) {
        this.delegate = delegate;
    }

    @Override
    public void populate(@NotNull World world, @NotNull Random random, @NotNull Chunk source) {
-        delegate.populate(BukkitAdapter.adapt(world), BukkitAdapter.adapt(source));
+        delegate.getPopulators().forEach(populator -> {
+            if(populator instanceof Chunkified) {
+                populator.populate(BukkitAdapter.adapt(world), BukkitAdapter.adapt(source));
+            }
+        });
    }
 }
@@ -2,13 +2,12 @@ package com.dfsek.terra.bukkit.listeners;

 import com.dfsek.terra.api.TerraPlugin;
 import com.dfsek.terra.api.math.vector.Location;
+import com.dfsek.terra.api.platform.world.Tree;
 import com.dfsek.terra.api.platform.world.World;
 import com.dfsek.terra.api.transform.MapTransform;
 import com.dfsek.terra.api.transform.Transformer;
 import com.dfsek.terra.api.util.FastRandom;
-import com.dfsek.terra.api.world.tree.Tree;
 import com.dfsek.terra.bukkit.world.BukkitAdapter;
-import com.dfsek.terra.config.pack.ConfigPack;
 import com.dfsek.terra.config.pack.WorldConfig;
 import com.dfsek.terra.world.TerraWorld;
 import org.bukkit.Material;
@@ -4,54 +4,35 @@ import com.dfsek.terra.api.TerraPlugin;
 import com.dfsek.terra.api.platform.world.Chunk;
 import com.dfsek.terra.api.platform.world.World;
 import com.dfsek.terra.api.util.FastRandom;
-import com.dfsek.terra.api.util.GlueList;
+import com.dfsek.terra.api.world.generation.Chunkified;
 import com.dfsek.terra.api.world.generation.TerraBlockPopulator;
+import com.dfsek.terra.api.world.generation.TerraChunkGenerator;
 import com.dfsek.terra.bukkit.TerraBukkitPlugin;
+import com.dfsek.terra.bukkit.world.BukkitAdapter;
 import com.dfsek.terra.profiler.ProfileFuture;
 import com.dfsek.terra.profiler.WorldProfiler;
+import org.bukkit.generator.BlockPopulator;
 import org.jetbrains.annotations.NotNull;

 import java.io.File;
 import java.io.IOException;
 import java.util.HashSet;
-import java.util.List;
 import java.util.Random;

 /**
 * Cursed management class for the horrors of Bukkit population
 */
-public class PopulationManager implements TerraBlockPopulator {
-    private final List<TerraBlockPopulator> attachedPopulators = new GlueList<>();
+public class PopulationManager extends BlockPopulator {
+    private final TerraChunkGenerator generator;
    private final HashSet<ChunkCoordinate> needsPop = new HashSet<>();
    private final TerraPlugin main;
    private WorldProfiler profiler;

-    public PopulationManager(TerraPlugin main) {
+    public PopulationManager(TerraChunkGenerator generator, TerraPlugin main) {
+        this.generator = generator;
        this.main = main;
    }

-    public void attach(TerraBlockPopulator populator) {
-        this.attachedPopulators.add(populator);
-    }
-
-    @Override
-    @SuppressWarnings("try")
-    public void populate(@NotNull World world, @NotNull Chunk chunk) {
-        try(ProfileFuture ignored = measure()) {
-            needsPop.add(new ChunkCoordinate(chunk));
-            int x = chunk.getX();
-            int z = chunk.getZ();
-            if(((TerraBukkitPlugin) main).isEnabled()) {
-                for(int xi = -1; xi <= 1; xi++) {
-                    for(int zi = -1; zi <= 1; zi++) {
-                        if(xi == 0 && zi == 0) continue;
-                        if(world.isChunkGenerated(xi + x, zi + z)) checkNeighbors(xi + x, zi + z, world);
-                    }
-                }
-            }
-        }
-    }
-
    private ProfileFuture measure() {
        if(profiler != null) return profiler.measure("PopulationManagerTime");
        return null;
@@ -87,10 +68,30 @@ public class PopulationManager implements TerraBlockPopulator {
            long zRand = (random.nextLong() / 2L << 1L) + 1L;
            random.setSeed((long) x * xRand + (long) z * zRand ^ w.getSeed());
            Chunk currentChunk = w.getChunkAt(x, z);
-            for(TerraBlockPopulator r : attachedPopulators) {
-                r.populate(w, currentChunk);
-            }
+            generator.getPopulators().forEach(populator -> {
+                if(!(populator instanceof Chunkified)) {
+                    populator.populate(w, currentChunk);
+                }
+            });
            needsPop.remove(c);
        }
    }
+
+    @Override
+    public void populate(org.bukkit.@NotNull World world, @NotNull Random random, org.bukkit.@NotNull Chunk source) {
+        try(ProfileFuture ignored = measure()) {
+            Chunk chunk = BukkitAdapter.adapt(source);
+            needsPop.add(new ChunkCoordinate(chunk));
+            int x = chunk.getX();
+            int z = chunk.getZ();
+            if(((TerraBukkitPlugin) main).isEnabled()) {
+                for(int xi = -1; xi <= 1; xi++) {
+                    for(int zi = -1; zi <= 1; zi++) {
+                        if(xi == 0 && zi == 0) continue;
+                        if(world.isChunkGenerated(xi + x, zi + z)) checkNeighbors(xi + x, zi + z, BukkitAdapter.adapt(world));
+                    }
+                }
+            }
+        }
+    }
 }
@@ -3,8 +3,8 @@ package com.dfsek.terra.bukkit.world;
 import com.dfsek.terra.api.TerraPlugin;
 import com.dfsek.terra.api.math.vector.Location;
 import com.dfsek.terra.api.platform.handle.WorldHandle;
+import com.dfsek.terra.api.platform.world.Tree;
 import com.dfsek.terra.api.util.collections.MaterialSet;
-import com.dfsek.terra.api.world.tree.Tree;
 import org.bukkit.TreeType;

 import java.util.Random;
@@ -29,6 +29,11 @@ public class BukkitBlockTypeAndItem implements BlockType, Item {
        return delegate.isSolid();
    }

+    @Override
+    public boolean isWater() {
+        return delegate == Material.WATER;
+    }
+
    @Override
    public ItemStack newItemStack(int amount) {
        return BukkitAdapter.adapt(new org.bukkit.inventory.ItemStack(delegate, amount));
@@ -1,11 +1,13 @@
 import com.dfsek.terra.configureCommon
 import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
+import com.modrinth.minotaur.TaskModrinthUpload
 import net.fabricmc.loom.LoomGradleExtension
 import net.fabricmc.loom.task.RemapJarTask

 plugins {
    `java-library`
    id("fabric-loom").version("0.6-SNAPSHOT")
+    id("com.modrinth.minotaur").version("1.1.0")
 }

 configureCommon()
@@ -15,6 +17,11 @@ tasks.named<ShadowJar>("shadowJar") {
    relocate("org.yaml", "com.dfsek.terra.lib.yaml")
 }

+java {
+    sourceCompatibility = JavaVersion.VERSION_11
+    targetCompatibility = JavaVersion.VERSION_1_8
+}
+
 group = "com.dfsek.terra.fabric"

 dependencies {
@@ -39,7 +46,8 @@ configure<LoomGradleExtension> {
    accessWidener("src/main/resources/terra.accesswidener")
 }

-tasks.register<RemapJarTask>("remapShadedJar") {
+val remapped = tasks.register<RemapJarTask>("remapShadedJar") {
+    group = "fabric"
    val shadowJar = tasks.getByName<ShadowJar>("shadowJar")
    dependsOn(shadowJar)
    input.set(shadowJar.archiveFile)
@@ -47,3 +55,17 @@ tasks.register<RemapJarTask>("remapShadedJar") {
    addNestedDependencies.set(true)
    remapAccessWidener.set(true)
 }
+
+
+tasks.register<TaskModrinthUpload>("publishModrinth") {
+    dependsOn("remapShadedJar")
+    group = "fabric"
+    token = System.getenv("MODRINTH_SECRET")
+    projectId = "FIlZB9L0"
+    versionNumber = project.version.toString()
+    uploadFile = remapped.get().archiveFile.get().asFile
+    releaseType = "beta"
+    addGameVersion("1.16.4")
+    addGameVersion("1.16.5")
+    addLoader("fabric")
+}
@@ -20,6 +20,7 @@ import com.dfsek.terra.api.platform.CommandSender;
 import com.dfsek.terra.api.platform.block.BlockData;
 import com.dfsek.terra.api.platform.handle.ItemHandle;
 import com.dfsek.terra.api.platform.handle.WorldHandle;
+import com.dfsek.terra.api.platform.world.Tree;
 import com.dfsek.terra.api.platform.world.World;
 import com.dfsek.terra.api.registry.CheckedRegistry;
 import com.dfsek.terra.api.registry.LockedRegistry;
@@ -27,7 +28,6 @@ import com.dfsek.terra.api.transform.NotNullValidator;
 import com.dfsek.terra.api.transform.Transformer;
 import com.dfsek.terra.api.util.logging.DebugLogger;
 import com.dfsek.terra.api.util.logging.Logger;
-import com.dfsek.terra.api.world.tree.Tree;
 import com.dfsek.terra.commands.CommandUtil;
 import com.dfsek.terra.config.GenericLoaders;
 import com.dfsek.terra.config.PluginConfig;
@@ -35,6 +35,7 @@ import com.dfsek.terra.config.builder.BiomeBuilder;
 import com.dfsek.terra.config.lang.LangUtil;
 import com.dfsek.terra.config.lang.Language;
 import com.dfsek.terra.config.pack.ConfigPack;
+import com.dfsek.terra.config.templates.BiomeTemplate;
 import com.dfsek.terra.fabric.inventory.FabricItemHandle;
 import com.dfsek.terra.fabric.mixin.GeneratorTypeAccessor;
 import com.dfsek.terra.fabric.world.FabricAdapter;
@@ -150,7 +151,6 @@ public class TerraFabricPlugin implements TerraPlugin, ModInitializer {

    @Override
    public TerraWorld getWorld(World world) {
-        if(worldMap.size() > 1) System.out.println(worldMap.size());
        return worldMap.computeIfAbsent(world.getSeed(), w -> {
            logger.info("Loading world " + w);
            return new TerraWorld(world, ((FabricChunkGeneratorWrapper) ((FabricChunkGenerator) world.getGenerator()).getHandle()).getPack(), this);
@@ -246,6 +246,9 @@ public class TerraFabricPlugin implements TerraPlugin, ModInitializer {
        DefaultBiomeFeatures.addFarmAnimals(spawnSettings);
        DefaultBiomeFeatures.addMonsters(spawnSettings, 95, 5, 100);

+        BiomeTemplate template = biome.getTemplate();
+        Map<String, Integer> colors = template.getColors();
+
        Biome vanilla = ((FabricBiome) new ArrayList<>(biome.getVanillaBiomes().getContents()).get(0)).getHandle();

        GenerationSettings.Builder generationSettings = new GenerationSettings.Builder();
@@ -254,28 +257,37 @@ public class TerraFabricPlugin implements TerraPlugin, ModInitializer {


        BiomeEffects.Builder effects = new BiomeEffects.Builder()
-                .waterColor(vanilla.getEffects().waterColor)
-                .waterFogColor(vanilla.getEffects().waterFogColor)
-                .fogColor(vanilla.getEffects().fogColor)
-                .skyColor(vanilla.getEffects().skyColor)
+                .waterColor(colors.getOrDefault("water", vanilla.getEffects().waterColor))
+                .waterFogColor(colors.getOrDefault("water-fog", vanilla.getEffects().waterFogColor))
+                .fogColor(colors.getOrDefault("fog", vanilla.getEffects().fogColor))
+                .skyColor(colors.getOrDefault("sky", vanilla.getEffects().skyColor))
                .grassColorModifier(vanilla.getEffects().grassColorModifier);
-        vanilla.getEffects().grassColor.ifPresent(effects::grassColor);
-        vanilla.getEffects().foliageColor.ifPresent(effects::foliageColor);

-        return (new Biome.Builder())
+        if(colors.containsKey("grass")) {
+            effects.grassColor(colors.get("grass"));
+        } else {
+            vanilla.getEffects().grassColor.ifPresent(effects::grassColor);
+        }
+        vanilla.getEffects().foliageColor.ifPresent(effects::foliageColor);
+        if(colors.containsKey("foliage")) {
+            effects.foliageColor(colors.get("foliage"));
+        } else {
+            vanilla.getEffects().foliageColor.ifPresent(effects::foliageColor);
+        }
+
+        return new Biome.Builder()
                .precipitation(vanilla.getPrecipitation())
                .category(vanilla.getCategory())
                .depth(vanilla.getDepth())
                .scale(vanilla.getScale())
                .temperature(vanilla.getTemperature())
                .downfall(vanilla.getDownfall())
-                .effects(vanilla.getEffects()) // TODO: configurable
+                .effects(effects.build())
                .spawnSettings(spawnSettings.build())
                .generationSettings(generationSettings.build())
                .build();
    }

-    @SuppressWarnings("unchecked")
    @Override
    public void onInitialize() {
        instance = this;
@@ -327,10 +339,8 @@ public class TerraFabricPlugin implements TerraPlugin, ModInitializer {

        CommandRegistrationCallback.EVENT.register((dispatcher, dedicated) -> {
                    int max = manager.getMaxArgumentDepth();
-                    System.out.println("MAX:" + max);
                    RequiredArgumentBuilder<ServerCommandSource, String> arg = argument("arg" + (max - 1), StringArgumentType.word());
                    for(int i = 0; i < max; i++) {
-                        System.out.println("arg " + i);
                        RequiredArgumentBuilder<ServerCommandSource, String> next = argument("arg" + (max - i - 1), StringArgumentType.word());

                        arg = next.then(assemble(arg, manager));
@@ -1,8 +1,8 @@
 package com.dfsek.terra.fabric.world;

 import com.dfsek.terra.api.math.vector.Location;
+import com.dfsek.terra.api.platform.world.Tree;
 import com.dfsek.terra.api.util.collections.MaterialSet;
-import com.dfsek.terra.api.world.tree.Tree;
 import com.dfsek.terra.fabric.TerraFabricPlugin;
 import com.dfsek.terra.fabric.world.generator.FabricChunkGenerator;
 import com.dfsek.terra.fabric.world.handles.world.FabricWorldAccess;
@@ -4,6 +4,7 @@ import com.dfsek.terra.api.platform.block.BlockData;
 import com.dfsek.terra.api.platform.block.BlockType;
 import com.dfsek.terra.fabric.world.FabricAdapter;
 import net.minecraft.block.Block;
+import net.minecraft.block.Blocks;

 public class FabricBlockType implements BlockType {
    private final Block delegate;
@@ -27,6 +28,11 @@ public class FabricBlockType implements BlockType {
        return delegate.getDefaultState().isOpaque();
    }

+    @Override
+    public boolean isWater() {
+        return delegate == Blocks.WATER;
+    }
+
    @Override
    public int hashCode() {
        return delegate.hashCode();
@@ -27,11 +27,7 @@ public class PopulatorFeature extends Feature<DefaultFeatureConfig> {
        FabricChunkGeneratorWrapper gen = (FabricChunkGeneratorWrapper) chunkGenerator;
        FabricChunkWorldAccess chunk = new FabricChunkWorldAccess(world, pos.getX() >> 4, pos.getZ() >> 4);
        FabricWorld world1 = new FabricWorld(world.toServerWorld(), new FabricChunkGenerator(chunkGenerator));
-        gen.getCavePopulator().populate(new FabricWorldAccess(world), chunk);
-        gen.getStructurePopulator().populate(new FabricWorldAccess(world), chunk);
-        gen.getOrePopulator().populate(world1, chunk);
-        gen.getTreePopulator().populate(world1, chunk);
-        gen.getFloraPopulator().populate(world1, chunk);
+        gen.getHandle().getPopulators().forEach(populator -> populator.populate(world1, chunk));
        return true;
    }
 }
@@ -50,32 +50,6 @@ public class FabricChunkGeneratorWrapper extends ChunkGenerator implements Gener
        return pack;
    }

-    private final FloraPopulator floraPopulator = new FloraPopulator(TerraFabricPlugin.getInstance());
-    private final OrePopulator orePopulator = new OrePopulator(TerraFabricPlugin.getInstance());
-    private final TreePopulator treePopulator = new TreePopulator(TerraFabricPlugin.getInstance());
-    private final StructurePopulator structurePopulator = new StructurePopulator(TerraFabricPlugin.getInstance());
-    private final CavePopulator cavePopulator = new CavePopulator(TerraFabricPlugin.getInstance());
-
-    public TreePopulator getTreePopulator() {
-        return treePopulator;
-    }
-
-    public OrePopulator getOrePopulator() {
-        return orePopulator;
-    }
-
-    public FloraPopulator getFloraPopulator() {
-        return floraPopulator;
-    }
-
-    public StructurePopulator getStructurePopulator() {
-        return structurePopulator;
-    }
-
-    public CavePopulator getCavePopulator() {
-        return cavePopulator;
-    }
-
    public FabricChunkGeneratorWrapper(TerraBiomeSource biomeSource, long seed, ConfigPack configPack) {
        super(biomeSource, new StructuresConfig(false));
        this.pack = configPack;
@@ -124,6 +98,8 @@ public class FabricChunkGeneratorWrapper extends ChunkGenerator implements Gener

    }

+
+
    @Override
    public boolean isStrongholdStartingChunk(ChunkPos chunkPos) {
        return false;
@@ -0,0 +1,44 @@
+import com.dfsek.terra.configureCommon
+
+plugins {
+    java
+}
+
+group = "com.dfsek.terra.minestom"
+
+configureCommon()
+
+repositories {
+    mavenCentral()
+    maven { url = uri("https://repo.spongepowered.org/maven") }
+    maven { url = uri("https://repo.velocitypowered.com/snapshots/") }
+    maven { url = uri("https://libraries.minecraft.net") }
+    maven { url = uri("https://jitpack.io") }
+    maven { url = uri("https://repo.codemc.org/repository/maven-public") }
+}
+
+dependencies {
+    testCompile("junit", "junit", "4.12")
+
+    "shadedImplementation"("com.googlecode.json-simple:json-simple:1.1.1")
+
+    "shadedImplementation"("org.apache.logging.log4j:log4j-core:2.14.1")
+    "shadedImplementation"("org.apache.logging.log4j:log4j-api:2.14.1")
+
+    "shadedImplementation"("com.github.Minestom:Minestom:4cf66fde08")
+    "shadedApi"(project(":common"))
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_11
+    targetCompatibility = JavaVersion.VERSION_11
+}
+
+tasks.jar {
+    manifest {
+        attributes(
+                "Main-Class" to "com.dfsek.terra.minestom.MinestomEntry",
+                "Multi-Release" to "true"
+        )
+    }
+}
@@ -0,0 +1,10 @@
+package com.dfsek.terra.minestom;
+
+import com.dfsek.terra.api.platform.block.Block;
+import com.dfsek.terra.minestom.world.MinestomBlock;
+
+public final class MinestomAdapter {
+    public static net.minestom.server.instance.block.Block adapt(Block block) {
+        return ((MinestomBlock) block).getHandle();
+    }
+}
@@ -0,0 +1,47 @@
+package com.dfsek.terra.minestom;
+
+
+import com.dfsek.terra.minestom.commands.TeleportCommand;
+import com.dfsek.terra.minestom.generator.MinestomChunkGeneratorWrapper;
+import com.dfsek.terra.world.generation.generators.DefaultChunkGenerator3D;
+import net.minestom.server.MinecraftServer;
+import net.minestom.server.entity.GameMode;
+import net.minestom.server.entity.Player;
+import net.minestom.server.event.GlobalEventHandler;
+import net.minestom.server.event.player.PlayerLoginEvent;
+import net.minestom.server.event.player.PlayerSpawnEvent;
+import net.minestom.server.instance.InstanceContainer;
+import net.minestom.server.instance.InstanceManager;
+import net.minestom.server.utils.Position;
+
+public final class MinestomEntry {
+    public static void main(String... args) {
+        MinecraftServer server = MinecraftServer.init();
+
+        InstanceManager instanceManager = MinecraftServer.getInstanceManager();
+
+        InstanceContainer container = instanceManager.createInstanceContainer();
+
+        TerraMinestomPlugin plugin = new TerraMinestomPlugin();
+
+        DefaultChunkGenerator3D chunkGenerator3D = new DefaultChunkGenerator3D(plugin.getConfigRegistry().get("DEFAULT"), plugin);
+
+        container.setChunkGenerator(new MinestomChunkGeneratorWrapper(chunkGenerator3D, container));
+
+        MinecraftServer.getBiomeManager().unmodifiableCollection().forEach(biome -> System.out.println(biome.getId() + ": " + biome.toNbt()));
+
+        GlobalEventHandler globalEventHandler = MinecraftServer.getGlobalEventHandler();
+        globalEventHandler.addEventCallback(PlayerLoginEvent.class, event -> {
+            Player player = event.getPlayer();
+            event.setSpawningInstance(container);
+            player.setRespawnPoint(new Position(0, 64, 0));
+        });
+
+        MinecraftServer.getCommandManager().register(new TeleportCommand());
+
+
+        globalEventHandler.addEventCallback(PlayerSpawnEvent.class, event -> event.getPlayer().setGameMode(GameMode.SPECTATOR));
+
+        server.start("0.0.0.0", 25565);
+    }
+}
@@ -0,0 +1,25 @@
+package com.dfsek.terra.minestom;
+
+import com.dfsek.terra.api.platform.handle.ItemHandle;
+import com.dfsek.terra.api.platform.inventory.Item;
+import com.dfsek.terra.api.platform.inventory.item.Enchantment;
+
+import java.util.Collections;
+import java.util.Set;
+
+public class MinestomItemHandle implements ItemHandle {
+    @Override
+    public Item createItem(String data) {
+        return null;
+    }
+
+    @Override
+    public Enchantment getEnchantment(String id) {
+        return null;
+    }
+
+    @Override
+    public Set<Enchantment> getEnchantments() {
+        return Collections.emptySet();
+    }
+}
@@ -0,0 +1,193 @@
+package com.dfsek.terra.minestom;
+
+import com.dfsek.tectonic.loading.TypeRegistry;
+import com.dfsek.terra.api.TerraPlugin;
+import com.dfsek.terra.api.addons.TerraAddon;
+import com.dfsek.terra.api.addons.annotations.Addon;
+import com.dfsek.terra.api.addons.annotations.Author;
+import com.dfsek.terra.api.addons.annotations.Version;
+import com.dfsek.terra.api.event.EventListener;
+import com.dfsek.terra.api.event.EventManager;
+import com.dfsek.terra.api.event.TerraEventManager;
+import com.dfsek.terra.api.event.annotations.Global;
+import com.dfsek.terra.api.event.events.config.ConfigPackPreLoadEvent;
+import com.dfsek.terra.api.platform.block.BlockData;
+import com.dfsek.terra.api.platform.handle.ItemHandle;
+import com.dfsek.terra.api.platform.handle.WorldHandle;
+import com.dfsek.terra.api.platform.world.Biome;
+import com.dfsek.terra.api.platform.world.Tree;
+import com.dfsek.terra.api.platform.world.World;
+import com.dfsek.terra.api.registry.CheckedRegistry;
+import com.dfsek.terra.api.registry.LockedRegistry;
+import com.dfsek.terra.api.util.logging.DebugLogger;
+import com.dfsek.terra.api.util.logging.Logger;
+import com.dfsek.terra.config.GenericLoaders;
+import com.dfsek.terra.config.PluginConfig;
+import com.dfsek.terra.config.lang.LangUtil;
+import com.dfsek.terra.config.lang.Language;
+import com.dfsek.terra.config.pack.ConfigPack;
+import com.dfsek.terra.minestom.world.MinestomBiome;
+import com.dfsek.terra.minestom.world.MinestomChunkAccess;
+import com.dfsek.terra.minestom.world.MinestomTree;
+import com.dfsek.terra.minestom.world.MinestomWorld;
+import com.dfsek.terra.minestom.world.MinestomWorldHandle;
+import com.dfsek.terra.registry.master.AddonRegistry;
+import com.dfsek.terra.registry.master.ConfigRegistry;
+import com.dfsek.terra.world.TerraWorld;
+import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
+import net.minestom.server.instance.Instance;
+import org.apache.logging.log4j.LogManager;
+
+import java.io.File;
+import java.util.Map;
+
+public class TerraMinestomPlugin implements TerraPlugin {
+    private final org.apache.logging.log4j.Logger logger = LogManager.getLogger();
+    private final MinestomWorldHandle worldHandle = new MinestomWorldHandle();
+    private final PluginConfig config = new PluginConfig();
+    private final EventManager eventManager = new TerraEventManager(this);
+    private final ConfigRegistry configRegistry = new ConfigRegistry();
+    private final AddonRegistry addonRegistry = new AddonRegistry(new MinestomPlugin(this), this);
+    private final GenericLoaders genericLoaders = new GenericLoaders(this);
+    private final MinestomItemHandle itemHandle = new MinestomItemHandle();
+    private final Map<Instance, TerraWorld> instanceTerraWorldMap = new Object2ObjectOpenHashMap<>();
+
+    public TerraMinestomPlugin() {
+        if(!getDataFolder().exists()) {
+            getDataFolder().mkdirs();
+        }
+        LangUtil.load(config.getLanguage(), this);
+        configRegistry.loadAll(this);
+        addonRegistry.loadAll();
+    }
+
+    @Override
+    public void register(TypeRegistry registry) {
+        registry
+                .registerLoader(BlockData.class, (t, o, l) -> worldHandle.createBlockData((String) o))
+                .registerLoader(Biome.class, (t, o, l) -> new MinestomBiome(net.minestom.server.world.biomes.Biome.PLAINS));
+        genericLoaders.register(registry);
+    }
+
+    @Override
+    public WorldHandle getWorldHandle() {
+        return worldHandle;
+    }
+
+    @Override
+    public TerraWorld getWorld(World world) {
+        if(world instanceof MinestomWorld) {
+            return instanceTerraWorldMap.computeIfAbsent(((MinestomWorld) world).getHandle(), instance -> new TerraWorld(new MinestomWorld(instance), configRegistry.get("DEFAULT"), this));
+        } else {
+            return instanceTerraWorldMap.computeIfAbsent(((MinestomWorld) ((MinestomChunkAccess) world).getWorld()).getHandle(), instance -> new TerraWorld(new MinestomWorld(instance), configRegistry.get("DEFAULT"), this));
+        }
+    }
+
+    @Override
+    public Logger logger() {
+        return new Logger() {
+            @Override
+            public void info(String message) {
+                System.out.println(message);
+            }
+
+            @Override
+            public void warning(String message) {
+                System.out.println(message);
+            }
+
+            @Override
+            public void severe(String message) {
+                System.err.println(message);
+            }
+        };
+    }
+
+    @Override
+    public PluginConfig getTerraConfig() {
+        return config;
+    }
+
+    @Override
+    public File getDataFolder() {
+        return new File("Terra");
+    }
+
+    @Override
+    public boolean isDebug() {
+        return true;
+    }
+
+    @Override
+    public Language getLanguage() {
+        return LangUtil.getLanguage();
+    }
+
+    @Override
+    public CheckedRegistry<ConfigPack> getConfigRegistry() {
+        return new CheckedRegistry<>(configRegistry);
+    }
+
+    @Override
+    public LockedRegistry<TerraAddon> getAddons() {
+        return new LockedRegistry<>(addonRegistry);
+    }
+
+    @Override
+    public boolean reload() {
+        return true;
+    }
+
+    @Override
+    public ItemHandle getItemHandle() {
+        return itemHandle;
+    }
+
+    @Override
+    public void saveDefaultConfig() {
+
+    }
+
+    @Override
+    public String platformName() {
+        return "Minestom";
+    }
+
+    @Override
+    public DebugLogger getDebugLogger() {
+        return new DebugLogger(logger());
+    }
+
+    @Override
+    public EventManager getEventManager() {
+        return eventManager;
+    }
+
+    @Addon("Terra-Minestom")
+    @Author("Terra")
+    @Version("1.0.0")
+    private static final class MinestomPlugin extends TerraAddon implements EventListener {
+        private final TerraPlugin main;
+
+        private MinestomPlugin(TerraPlugin main) {
+            this.main = main;
+        }
+
+        @Override
+        public void initialize() {
+            main.getEventManager().registerListener(this, this);
+        }
+
+        @Global
+        public void registerTrees(ConfigPackPreLoadEvent event) {
+            CheckedRegistry<Tree> treeCheckedRegistry = event.getPack().getTreeRegistry();
+
+            treeCheckedRegistry.addUnchecked("BIRCH", new MinestomTree());
+            treeCheckedRegistry.addUnchecked("JUNGLE_BUSH", new MinestomTree());
+            treeCheckedRegistry.addUnchecked("SWAMP_OAK", new MinestomTree());
+            treeCheckedRegistry.addUnchecked("JUNGLE_COCOA", new MinestomTree());
+            treeCheckedRegistry.addUnchecked("RED_MUSHROOM", new MinestomTree());
+            treeCheckedRegistry.addUnchecked("BROWN_MUSHROOM", new MinestomTree());
+        }
+    }
+}
@@ -0,0 +1,19 @@
+package com.dfsek.terra.minestom.commands;
+
+import net.minestom.server.command.builder.Command;
+import net.minestom.server.command.builder.arguments.Argument;
+import net.minestom.server.command.builder.arguments.ArgumentType;
+import net.minestom.server.entity.Entity;
+import net.minestom.server.utils.Position;
+
+public class TeleportCommand extends Command {
+    public TeleportCommand() {
+        super("teleport", "tp");
+
+        Argument<Double> x = ArgumentType.Double("x");
+        Argument<Double> y = ArgumentType.Double("y");
+        Argument<Double> z = ArgumentType.Double("z");
+
+        addSyntax((sender, context) -> ((Entity) sender).teleport(new Position(context.get(x), context.get(y), context.get(z))), x, y, z);
+    }
+}
@@ -0,0 +1,31 @@
+package com.dfsek.terra.minestom.commands;
+
+import com.dfsek.terra.api.TerraPlugin;
+import com.dfsek.terra.api.command.CommandManager;
+import com.dfsek.terra.api.command.TerraCommandManager;
+import com.dfsek.terra.api.command.exception.CommandException;
+import net.minestom.server.command.builder.Command;
+import net.minestom.server.command.builder.arguments.ArgumentStringArray;
+import net.minestom.server.command.builder.arguments.ArgumentType;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class TerraCommand extends Command {
+    public TerraCommand(TerraPlugin main) {
+        super("terra", "te");
+
+        CommandManager manager = new TerraCommandManager(main);
+
+        ArgumentStringArray argument = ArgumentType.StringArray("args");
+
+        addSyntax(((sender, context) -> {
+            List<String> args = Arrays.asList(context.get(argument));
+            try {
+                manager.execute(args.remove(0), null, args);
+            } catch(CommandException e) {
+                e.printStackTrace();
+            }
+        }), argument);
+    }
+}
@@ -0,0 +1,16 @@
+package com.dfsek.terra.minestom.generator;
+
+import com.dfsek.terra.api.platform.world.generator.ChunkGenerator;
+
+public class MinestomChunkGenerator implements ChunkGenerator {
+    private final net.minestom.server.instance.ChunkGenerator delegate;
+
+    public MinestomChunkGenerator(net.minestom.server.instance.ChunkGenerator delegate) {
+        this.delegate = delegate;
+    }
+
+    @Override
+    public net.minestom.server.instance.ChunkGenerator getHandle() {
+        return delegate;
+    }
+}
@@ -0,0 +1,52 @@
+package com.dfsek.terra.minestom.generator;
+
+import com.dfsek.terra.api.platform.world.generator.GeneratorWrapper;
+import com.dfsek.terra.api.util.FastRandom;
+import com.dfsek.terra.api.world.generation.TerraChunkGenerator;
+import com.dfsek.terra.minestom.world.MinestomBiomeGrid;
+import com.dfsek.terra.minestom.world.MinestomBlockPopulatorWrapper;
+import com.dfsek.terra.minestom.world.MinestomChunkData;
+import com.dfsek.terra.minestom.world.MinestomWorld;
+import com.dfsek.terra.world.generation.generators.DefaultChunkGenerator3D;
+import net.minestom.server.instance.ChunkGenerator;
+import net.minestom.server.instance.ChunkPopulator;
+import net.minestom.server.instance.Instance;
+import net.minestom.server.instance.batch.ChunkBatch;
+import net.minestom.server.world.biomes.Biome;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class MinestomChunkGeneratorWrapper implements GeneratorWrapper, ChunkGenerator {
+    private final DefaultChunkGenerator3D chunkGenerator3D;
+    private final Instance instance;
+    private final List<ChunkPopulator> populators = new ArrayList<>();
+
+    public MinestomChunkGeneratorWrapper(DefaultChunkGenerator3D chunkGenerator3D, Instance instance) {
+        this.chunkGenerator3D = chunkGenerator3D;
+        this.instance = instance;
+        chunkGenerator3D.getPopulators().forEach(terraBlockPopulator -> populators.add(new MinestomBlockPopulatorWrapper(terraBlockPopulator, instance)));
+    }
+
+    @Override
+    public TerraChunkGenerator getHandle() {
+        return chunkGenerator3D;
+    }
+
+    @Override
+    public void generateChunkData(@NotNull ChunkBatch batch, int chunkX, int chunkZ) {
+        chunkGenerator3D.generateChunkData(new MinestomWorld(instance), new FastRandom(), chunkX, chunkZ, new MinestomChunkData(batch));
+    }
+
+    @Override
+    public void fillBiomes(@NotNull Biome[] biomes, int chunkX, int chunkZ) {
+        chunkGenerator3D.generateBiomes(new MinestomWorld(instance), new FastRandom(), chunkX, chunkZ, new MinestomBiomeGrid(biomes, chunkX, chunkZ));
+    }
+
+    @Override
+    public @Nullable List<ChunkPopulator> getPopulators() {
+        return populators;
+    }
+}
@@ -0,0 +1,16 @@
+package com.dfsek.terra.minestom.world;
+
+import com.dfsek.terra.api.platform.world.Biome;
+
+public class MinestomBiome implements Biome {
+    private final net.minestom.server.world.biomes.Biome delegate;
+
+    public MinestomBiome(net.minestom.server.world.biomes.Biome delegate) {
+        this.delegate = delegate;
+    }
+
+    @Override
+    public net.minestom.server.world.biomes.Biome getHandle() {
+        return delegate;
+    }
+}
@@ -0,0 +1,52 @@
+package com.dfsek.terra.minestom.world;
+
+import com.dfsek.terra.api.platform.world.Biome;
+import com.dfsek.terra.api.platform.world.BiomeGrid;
+import org.jetbrains.annotations.NotNull;
+
+public class MinestomBiomeGrid implements BiomeGrid {
+    private final net.minestom.server.world.biomes.Biome[] biomes;
+    private final int chunkX;
+    private final int chunkZ;
+
+    public MinestomBiomeGrid(net.minestom.server.world.biomes.Biome[] biomes, int chunkX, int chunkZ) {
+        this.biomes = biomes;
+        this.chunkX = chunkX;
+        this.chunkZ = chunkZ;
+    }
+
+    @Override
+    public Object getHandle() {
+        return null;
+    }
+
+    @Override
+    public @NotNull Biome getBiome(int x, int z) {
+        return getBiome(x, 0, z);
+    }
+
+    @Override
+    public @NotNull Biome getBiome(int x, int y, int z) {
+        x -= (chunkX << 4);
+        z -= (chunkZ << 4);
+        x >>= 2;
+        y >>= 2;
+        z >>= 2;
+        return new MinestomBiome(biomes[(x << 8) + (y << 2) + z]);
+    }
+
+    @Override
+    public void setBiome(int x, int z, @NotNull Biome bio) {
+        for(int y = 0; y < 64; y++) setBiome(x, y << 2, z, bio);
+    }
+
+    @Override
+    public void setBiome(int x, int y, int z, @NotNull Biome bio) {
+        x -= (chunkX << 4);
+        z -= (chunkZ << 4);
+        x >>= 2;
+        y >>= 2;
+        z >>= 2;
+        biomes[(x << 8) + (y << 2) + z] = ((MinestomBiome) bio).getHandle();
+    }
+}
@@ -0,0 +1,82 @@
+package com.dfsek.terra.minestom.world;
+
+import com.dfsek.terra.api.math.vector.Location;
+import com.dfsek.terra.api.platform.block.Block;
+import com.dfsek.terra.api.platform.block.BlockData;
+import com.dfsek.terra.api.platform.block.BlockFace;
+import com.dfsek.terra.api.platform.block.state.BlockState;
+import com.dfsek.terra.api.util.generic.either.Either;
+import net.minestom.server.utils.BlockPosition;
+
+public class MinestomBlock implements Block {
+    private final net.minestom.server.instance.block.Block delegate;
+    private final BlockPosition position;
+    private final Either<MinestomChunkAccess, MinestomWorld> world;
+
+    public MinestomBlock(net.minestom.server.instance.block.Block delegate, BlockPosition position, Either<MinestomChunkAccess, MinestomWorld> world) {
+        this.delegate = delegate;
+        this.position = position;
+        this.world = world;
+    }
+
+    @Override
+    public net.minestom.server.instance.block.Block getHandle() {
+        return delegate;
+    }
+
+    @Override
+    public void setBlockData(BlockData data, boolean physics) {
+        world.ifLeft(chunk -> chunk.getHandle().setBlock(position.getX() - (chunk.getX() << 4), position.getY(), position.getZ() - (chunk.getZ() << 4), ((MinestomBlockData) data).getHandle()));
+        world.ifRight(world -> {
+            //world.getHandle().setBlock(position.getX(), position.getY(), position.getZ(), delegate);
+        });
+    }
+
+    @Override
+    public BlockData getBlockData() {
+        return new MinestomBlockData(delegate);
+    }
+
+    @Override
+    public BlockState getState() {
+        return null;
+    }
+
+    @Override
+    public Block getRelative(BlockFace face, int len) {
+        BlockPosition newLoc = position.clone().add(face.getModX(), face.getModY(), face.getModZ());
+        if(world.hasLeft()) return world.getLeft().get().getBlock(newLoc.getX(), newLoc.getY(), newLoc.getZ());
+        else return world.getRight().get().getBlockAt(newLoc.getX(), newLoc.getY(), newLoc.getZ());
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return delegate.isAir();
+    }
+
+    @Override
+    public Location getLocation() {
+        if(world.hasLeft()) return new Location(world.getLeft().get().getWorld(), position.getX(), position.getY(), position.getZ());
+        return new Location(world.getRight().get(), position.getX(), position.getY(), position.getZ());
+    }
+
+    @Override
+    public int getX() {
+        return position.getX();
+    }
+
+    @Override
+    public int getZ() {
+        return position.getZ();
+    }
+
+    @Override
+    public int getY() {
+        return position.getY();
+    }
+
+    @Override
+    public boolean isPassable() {
+        return !delegate.isSolid();
+    }
+}
@@ -0,0 +1,81 @@
+package com.dfsek.terra.minestom.world;
+
+import com.dfsek.terra.api.platform.block.BlockData;
+import com.dfsek.terra.api.platform.block.BlockType;
+import net.minestom.server.instance.block.Block;
+
+public class MinestomBlockData implements BlockData, BlockType {
+    private final Block delegate;
+
+    public MinestomBlockData(Block delegate) {
+        if(delegate == null) throw new NullPointerException("Delegate must not be null");
+        this.delegate = delegate;
+    }
+
+    @Override
+    public Block getHandle() {
+        return delegate;
+    }
+
+    @Override
+    public BlockType getBlockType() {
+        return this;
+    }
+
+    @Override
+    public boolean matches(BlockData other) {
+        return delegate == ((MinestomBlockData) other).delegate;
+    }
+
+    @Override
+    public BlockData clone() {
+        BlockData clone;
+        try {
+            clone = (BlockData) super.clone();
+        } catch(CloneNotSupportedException e) {
+            throw new Error(e);
+        }
+        return clone;
+    }
+
+    @Override
+    public String getAsString() {
+        return delegate.getName();
+    }
+
+    @Override
+    public boolean isAir() {
+        return delegate.isAir();
+    }
+
+    @Override
+    public boolean isStructureVoid() {
+        return delegate == Block.STRUCTURE_VOID;
+    }
+
+    @Override
+    public BlockData getDefaultData() {
+        return this;
+    }
+
+    @Override
+    public boolean isSolid() {
+        return delegate.isSolid();
+    }
+
+    @Override
+    public boolean isWater() {
+        return delegate == Block.WATER;
+    }
+
+    @Override
+    public int hashCode() {
+        return delegate.hashCode();
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if(!(obj instanceof MinestomBlockData)) return false;
+        return ((MinestomBlockData) obj).delegate == delegate;
+    }
+}
@@ -0,0 +1,24 @@
+package com.dfsek.terra.minestom.world;
+
+import com.dfsek.terra.api.platform.world.World;
+import com.dfsek.terra.api.world.generation.TerraBlockPopulator;
+import net.minestom.server.instance.Chunk;
+import net.minestom.server.instance.ChunkPopulator;
+import net.minestom.server.instance.Instance;
+import net.minestom.server.instance.batch.ChunkBatch;
+
+public class MinestomBlockPopulatorWrapper implements ChunkPopulator {
+    private final TerraBlockPopulator populator;
+    private final Instance world;
+
+    public MinestomBlockPopulatorWrapper(TerraBlockPopulator populator, Instance world) {
+        this.populator = populator;
+        this.world = world;
+    }
+
+    @Override
+    public void populateChunk(ChunkBatch batch, Chunk chunk) {
+        World minestom = new MinestomChunkWorld(batch, chunk, world);
+        populator.populate(minestom, new MinestomChunk(chunk, batch, new MinestomWorld(world)));
+    }
+}
@@ -0,0 +1,57 @@
+package com.dfsek.terra.minestom.world;
+
+import com.dfsek.terra.api.platform.block.Block;
+import com.dfsek.terra.api.platform.block.BlockData;
+import com.dfsek.terra.api.platform.world.Chunk;
+import com.dfsek.terra.api.platform.world.World;
+import com.dfsek.terra.api.util.generic.either.Either;
+import net.minestom.server.instance.batch.ChunkBatch;
+import net.minestom.server.utils.BlockPosition;
+import org.jetbrains.annotations.NotNull;
+
+public class MinestomChunk implements Chunk, MinestomChunkAccess {
+    private final net.minestom.server.instance.Chunk chunk;
+    private final ChunkBatch batch;
+    private final MinestomWorld world;
+
+    public MinestomChunk(net.minestom.server.instance.Chunk chunk, ChunkBatch batch, MinestomWorld world) {
+        this.chunk = chunk;
+        this.batch = batch;
+        this.world = world;
+    }
+
+    @Override
+    public ChunkBatch getHandle() {
+        return batch;
+    }
+
+    @Override
+    public int getX() {
+        return chunk.getChunkX();
+    }
+
+    @Override
+    public int getZ() {
+        return chunk.getChunkZ();
+    }
+
+    @Override
+    public World getWorld() {
+        return new MinestomChunkWorld(batch, chunk, world.getHandle());
+    }
+
+    @Override
+    public Block getBlock(int x, int y, int z) {
+        return new MinestomBlock(net.minestom.server.instance.block.Block.fromStateId(chunk.getBlockStateId(x, y, z)), new BlockPosition((getX() << 4) + x, y, (getZ() << 4) + z), Either.left(this));
+    }
+
+    @Override
+    public void setBlock(int x, int y, int z, @NotNull BlockData blockData) {
+        batch.setBlock(x, y, z, ((MinestomBlockData) blockData).getHandle());
+    }
+
+    @Override
+    public @NotNull BlockData getBlockData(int x, int y, int z) {
+        return getBlock(x, y, z).getBlockData();
+    }
+}
@@ -0,0 +1,17 @@
+package com.dfsek.terra.minestom.world;
+
+import com.dfsek.terra.api.platform.block.Block;
+import com.dfsek.terra.api.platform.world.World;
+import net.minestom.server.instance.batch.ChunkBatch;
+
+public interface MinestomChunkAccess {
+    ChunkBatch getHandle();
+
+    int getX();
+
+    int getZ();
+
+    Block getBlock(int x, int y, int z);
+
+    World getWorld();
+}
@@ -0,0 +1,43 @@
+package com.dfsek.terra.minestom.world;
+
+import com.dfsek.terra.api.platform.block.BlockData;
+import com.dfsek.terra.api.platform.world.generator.ChunkData;
+import it.unimi.dsi.fastutil.longs.Long2ObjectOpenHashMap;
+import net.minestom.server.instance.batch.ChunkBatch;
+import net.minestom.server.instance.block.Block;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Map;
+
+public class MinestomChunkData implements ChunkData {
+    private static final BlockData AIR = new MinestomBlockData(Block.AIR);
+    private final ChunkBatch batch;
+    private final Map<Long, MinestomBlockData> dataMap = new Long2ObjectOpenHashMap<>();
+
+    public MinestomChunkData(ChunkBatch batch) {
+        this.batch = batch;
+    }
+
+    @Override
+    public Object getHandle() {
+        return batch;
+    }
+
+    @Override
+    public void setBlock(int x, int y, int z, @NotNull BlockData blockData) {
+        MinestomBlockData d = ((MinestomBlockData) blockData);
+        dataMap.put(((long) y << 12) + ((long) x << 4) + y, d);
+        batch.setBlock(x, y, z, d.getHandle());
+    }
+
+    @Override
+    public @NotNull BlockData getBlockData(int x, int y, int z) {
+        BlockData data = dataMap.get(((long) y << 12) + ((long) x << 4) + y);
+        return data == null ? AIR : data;
+    }
+
+    @Override
+    public int getMaxHeight() {
+        return 255;
+    }
+}
@@ -0,0 +1,109 @@
+package com.dfsek.terra.minestom.world;
+
+import com.dfsek.terra.api.math.vector.Location;
+import com.dfsek.terra.api.platform.block.Block;
+import com.dfsek.terra.api.platform.entity.Entity;
+import com.dfsek.terra.api.platform.entity.EntityType;
+import com.dfsek.terra.api.platform.world.Chunk;
+import com.dfsek.terra.api.platform.world.World;
+import com.dfsek.terra.api.platform.world.generator.ChunkGenerator;
+import com.dfsek.terra.api.util.generic.either.Either;
+import com.dfsek.terra.minestom.generator.MinestomChunkGenerator;
+import net.minestom.server.instance.Instance;
+import net.minestom.server.instance.batch.ChunkBatch;
+import net.minestom.server.utils.BlockPosition;
+
+import java.io.File;
+import java.util.UUID;
+
+public class MinestomChunkWorld implements World, MinestomChunkAccess {
+    private final ChunkBatch batch;
+    private final net.minestom.server.instance.Chunk chunk;
+    private final Instance world;
+
+    public MinestomChunkWorld(ChunkBatch batch, net.minestom.server.instance.Chunk chunk, Instance world) {
+        this.batch = batch;
+        this.chunk = chunk;
+        this.world = world;
+    }
+
+    @Override
+    public ChunkBatch getHandle() {
+        return batch;
+    }
+
+    @Override
+    public int getX() {
+        return chunk.getChunkX();
+    }
+
+    @Override
+    public int getZ() {
+        return chunk.getChunkZ();
+    }
+
+    @Override
+    public Block getBlock(int x, int y, int z) {
+        return new MinestomBlock(net.minestom.server.instance.block.Block.fromStateId(chunk.getBlockStateId(x, y, z)), new BlockPosition((chunk.getChunkX() << 4) + x, y, (chunk.getChunkZ() << 4) + z), Either.left(this));
+    }
+
+    @Override
+    public World getWorld() {
+        return new MinestomWorld(world);
+    }
+
+    @Override
+    public long getSeed() {
+        return 0;
+    }
+
+    @Override
+    public int getMaxHeight() {
+        return 255;
+    }
+
+    @Override
+    public ChunkGenerator getGenerator() {
+        return new MinestomChunkGenerator(world.getChunkGenerator());
+    }
+
+    @Override
+    public String getName() {
+        return null;
+    }
+
+    @Override
+    public UUID getUID() {
+        return world.getUniqueId();
+    }
+
+    @Override
+    public boolean isChunkGenerated(int x, int z) {
+        return false;
+    }
+
+    @Override
+    public Chunk getChunkAt(int x, int z) {
+        return null;
+    }
+
+    @Override
+    public File getWorldFolder() {
+        return null;
+    }
+
+    @Override
+    public Block getBlockAt(int x, int y, int z) {
+        return new MinestomBlock(net.minestom.server.instance.block.Block.fromStateId(chunk.getBlockStateId(x - (getX() << 4), y, z - (getZ() << 4))), new BlockPosition(x, y, z), Either.left(this));
+    }
+
+    @Override
+    public Entity spawnEntity(Location location, EntityType entityType) {
+        return null;
+    }
+
+    @Override
+    public int getMinHeight() {
+        return 0;
+    }
+}
@@ -0,0 +1,19 @@
+package com.dfsek.terra.minestom.world;
+
+import com.dfsek.terra.api.math.vector.Location;
+import com.dfsek.terra.api.platform.world.Tree;
+import com.dfsek.terra.api.util.collections.MaterialSet;
+
+import java.util.Random;
+
+public class MinestomTree implements Tree {
+    @Override
+    public boolean plant(Location l, Random r) {
+        return true;
+    }
+
+    @Override
+    public MaterialSet getSpawnable() {
+        return MaterialSet.empty();
+    }
+}
@@ -0,0 +1,84 @@
+package com.dfsek.terra.minestom.world;
+
+import com.dfsek.terra.api.math.vector.Location;
+import com.dfsek.terra.api.platform.block.Block;
+import com.dfsek.terra.api.platform.entity.Entity;
+import com.dfsek.terra.api.platform.entity.EntityType;
+import com.dfsek.terra.api.platform.world.Chunk;
+import com.dfsek.terra.api.platform.world.World;
+import com.dfsek.terra.api.platform.world.generator.ChunkGenerator;
+import com.dfsek.terra.api.util.generic.either.Either;
+import com.dfsek.terra.minestom.generator.MinestomChunkGenerator;
+import net.minestom.server.instance.Instance;
+import net.minestom.server.utils.BlockPosition;
+
+import java.io.File;
+import java.util.UUID;
+
+public class MinestomWorld implements World {
+    private final Instance instance;
+
+    public MinestomWorld(Instance instance) {
+        this.instance = instance;
+    }
+
+    @Override
+    public Instance getHandle() {
+        return instance;
+    }
+
+    @Override
+    public long getSeed() {
+        return 2403;
+    }
+
+    @Override
+    public int getMaxHeight() {
+        return 255;
+    }
+
+    @Override
+    public ChunkGenerator getGenerator() {
+        return new MinestomChunkGenerator(instance.getChunkGenerator());
+    }
+
+    @Override
+    public String getName() {
+        return null;
+    }
+
+    @Override
+    public UUID getUID() {
+        return instance.getUniqueId();
+    }
+
+    @Override
+    public boolean isChunkGenerated(int x, int z) {
+        return false;
+    }
+
+    @Override
+    public Chunk getChunkAt(int x, int z) {
+        return null; //instance.getChunk(x, z);
+    }
+
+    @Override
+    public File getWorldFolder() {
+        return null;
+    }
+
+    @Override
+    public Block getBlockAt(int x, int y, int z) {
+        return new MinestomBlock(instance.getBlock(x, y, z), new BlockPosition(x, y, z), Either.right(this));
+    }
+
+    @Override
+    public Entity spawnEntity(Location location, EntityType entityType) {
+        return null;
+    }
+
+    @Override
+    public int getMinHeight() {
+        return 0;
+    }
+}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
dfsek	952c3cf086	implement MinestomBiomeGrid	2021-04-03 18:30:03 -07:00
dfsek	468bee27ab	fix buildscripts	2021-04-03 16:59:46 -07:00
dfsek	c3d99eb6d9	sort of working Minestom implementation	2021-04-03 16:51:55 -07:00
dfsek	8a933609ee	Merge pull request #107 from PolyhedralDev/ver/5.1.2 5.1.2 LootPopulateEvent patch	2021-04-01 15:14:14 -07:00
dfsek	ba4a50e234	add getStructureScript method to LootPopulateEvent	2021-04-01 15:03:48 -07:00
dfsek	f8e8ce8bc2	Bump version	2021-03-31 20:50:17 -07:00
dfsek	0013d4e682	Merge pull request #106 from PolyhedralDev/ver/5.1.2 Add LootPopulateEvent and EntitySpawnEvent	2021-03-31 20:49:44 -07:00
dfsek	9a97f1178d	release modrinth to beta channel	2021-03-31 08:34:17 -07:00
dfsek	e6a551d84d	add getter/setter for loot table in LootPopulateEvent	2021-03-30 09:23:21 -07:00
dfsek	92921430d8	add EntitySpawnEvent	2021-03-30 00:27:16 -07:00
dfsek	20c905aae4	add LootPopulateEvent	2021-03-30 00:19:32 -07:00
dfsek	ec0730ef73	test commit so version is different B)	2021-03-29 21:14:34 -07:00
dfsek	e4576b3405	Add modrinth publish task	2021-03-29 21:09:36 -07:00
dfsek	c5800970a8	i totally didnt forget to bump version	2021-03-29 16:39:10 -07:00
dfsek	8f88b1c156	Merge pull request #101 from PolyhedralDev/ver/5.1.1 API to add populators, Buildscript improvements	2021-03-29 16:26:59 -07:00
dfsek	1360994a67	Add options to disable default populators	2021-03-29 11:56:16 -07:00
dfsek	e00b28d27e	remove sysout	2021-03-29 10:07:25 -07:00
dfsek	c5ff5c101d	custom biome color configuration	2021-03-29 09:52:54 -07:00
dfsek	b1a1001c49	clean up buildscripts	2021-03-26 08:50:58 -07:00
dfsek	77d5162e73	add API for addons to register populators	2021-03-23 11:40:22 -07:00
dfsek	2e8cd54ac2	Merge pull request #96 from PolyhedralDev/ver/5.1.0 Address several issues	2021-03-17 10:53:32 -07:00
dfsek	28222c074e	bump version	2021-03-16 22:29:13 -07:00
dfsek	1b70766a17	remove legacy fractal trees (will be available in an addon)	2021-03-16 21:49:08 -07:00
dfsek	cda2d4688c	implement DynamicBlockFunction	2021-03-16 21:20:02 -07:00
dfsek	5028582198	add smart waterlog	2021-03-16 21:04:56 -07:00
dfsek	5458564cfa	fix CommandTest issues	2021-03-16 11:06:58 -07:00
dfsek	7f11373f75	Merge pull request #80 from PolyhedralDev/ver/5.0.0 Addon loader, fleshed out addon API, and Fabric finalization	2021-03-16 10:45:42 -07:00