Look ma, no Bukkit API in the core package

2026-02-16 02:20:57 +00:00 · 2020-12-11 17:30:17 -07:00
parent 7ee1d2c391
commit 5bf699cba9
345 changed files with 1352 additions and 2642 deletions
--- a/platforms/bukkit/build.gradle.kts
+++ b/platforms/bukkit/build.gradle.kts
@@ -0,0 +1,64 @@
+plugins {
+    java
+    maven
+    idea
+    id("com.github.johnrengelman.shadow")
+}
+
+group = "com.dfsek.terra.bukkit"
+
+repositories {
+    mavenCentral()
+    maven { url = uri("https://hub.spigotmc.org/nexus/content/repositories/snapshots/") }
+    maven { url = uri("http://maven.enginehub.org/repo/") }
+    maven { url = uri("https://repo.codemc.org/repository/maven-public") }
+    maven { url = uri("https://papermc.io/repo/repository/maven-public/") }
+}
+
+dependencies {
+    testImplementation("org.junit.jupiter:junit-jupiter-api:5.7.0")
+    testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine:5.7.0")
+    implementation(project(":common"))
+    implementation("org.apache.commons:commons-rng-core:1.3")
+
+    compileOnly("org.spigotmc:spigot-api:1.16.2-R0.1-SNAPSHOT")
+    implementation("io.papermc:paperlib:1.0.5")
+
+    implementation("com.scireum:parsii:1.2.1")
+    implementation("com.dfsek:Tectonic:1.0.3")
+    implementation("net.jafama:jafama:2.3.2")
+
+    compileOnly("com.googlecode.json-simple:json-simple:1.1")
+
+    implementation("com.google.guava:guava:30.0-jre")
+    implementation("org.bstats:bstats-bukkit:1.7")
+
+    compileOnly("com.sk89q.worldedit:worldedit-bukkit:7.2.0-SNAPSHOT")
+
+    compileOnly("org.jetbrains:annotations:20.1.0")
+
+}
+
+tasks.withType<ProcessResources> {
+    include("**/*.yml")
+    filter<org.apache.tools.ant.filters.ReplaceTokens>(
+            "tokens" to mapOf(
+                    "VERSION" to project.version.toString()
+            )
+    )
+}
+
+tasks.named<com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar>("shadowJar") {
+
+    archiveClassifier.set("")
+    archiveBaseName.set("Terra")
+    setVersion(project.version)
+    relocate("org.apache.commons", "com.dfsek.terra.lib.commons")
+    relocate("org.bstats.bukkit", "com.dfsek.terra.lib.bstats")
+    relocate("parsii", "com.dfsek.terra.lib.parsii")
+    relocate("io.papermc.lib", "com.dfsek.terra.lib.paperlib")
+    relocate("net.jafama", "com.dfsek.terra.lib.jafama")
+    relocate("com.dfsek.tectonic", "com.dfsek.terra.lib.tectonic")
+    relocate("net.jafama", "com.dfsek.terra.lib.jafama")
+    minimize()
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/BukkitBiomeGrid.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/BukkitBiomeGrid.java
@@ -0,0 +1,40 @@
+package com.dfsek.terra.bukkit;
+
+import com.dfsek.terra.api.generic.world.Biome;
+import com.dfsek.terra.api.generic.world.BiomeGrid;
+import com.dfsek.terra.bukkit.world.BukkitBiome;
+import org.bukkit.generator.ChunkGenerator;
+import org.jetbrains.annotations.NotNull;
+
+public class BukkitBiomeGrid implements BiomeGrid {
+    private final ChunkGenerator.BiomeGrid delegate;
+
+    public BukkitBiomeGrid(ChunkGenerator.BiomeGrid biomeGrid) {
+        this.delegate = biomeGrid;
+    }
+
+    @Override
+    public ChunkGenerator.BiomeGrid getHandle() {
+        return delegate;
+    }
+
+    @Override
+    public @NotNull Biome getBiome(int x, int z) {
+        return new BukkitBiome(delegate.getBiome(x, z));
+    }
+
+    @Override
+    public @NotNull Biome getBiome(int x, int y, int z) {
+        return new BukkitBiome(delegate.getBiome(x, y, z));
+    }
+
+    @Override
+    public void setBiome(int x, int z, @NotNull Biome bio) {
+        delegate.setBiome(x, z, ((BukkitBiome) bio).getHandle());
+    }
+
+    @Override
+    public void setBiome(int x, int y, int z, @NotNull Biome bio) {
+        delegate.setBiome(x, y, z, ((BukkitBiome) bio).getHandle());
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/BukkitChunk.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/BukkitChunk.java
@@ -0,0 +1,39 @@
+package com.dfsek.terra.bukkit;
+
+import com.dfsek.terra.api.generic.world.Chunk;
+import com.dfsek.terra.api.generic.world.World;
+import com.dfsek.terra.api.generic.world.block.Block;
+import com.dfsek.terra.bukkit.world.block.BukkitBlock;
+
+public class BukkitChunk implements Chunk {
+    private final org.bukkit.Chunk delegate;
+
+    public BukkitChunk(org.bukkit.Chunk delegate) {
+        this.delegate = delegate;
+    }
+
+    @Override
+    public int getX() {
+        return delegate.getX();
+    }
+
+    @Override
+    public int getZ() {
+        return delegate.getZ();
+    }
+
+    @Override
+    public World getWorld() {
+        return new BukkitWorld(delegate.getWorld());
+    }
+
+    @Override
+    public Block getBlock(int x, int y, int z) {
+        return new BukkitBlock(delegate.getBlock(x, y, z));
+    }
+
+    @Override
+    public org.bukkit.Chunk getHandle() {
+        return delegate;
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/BukkitCommandSender.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/BukkitCommandSender.java
@@ -0,0 +1,22 @@
+package com.dfsek.terra.bukkit;
+
+import com.dfsek.terra.api.generic.CommandSender;
+import org.bukkit.ChatColor;
+
+public class BukkitCommandSender implements CommandSender {
+    private final org.bukkit.command.CommandSender delegate;
+
+    public BukkitCommandSender(org.bukkit.command.CommandSender delegate) {
+        this.delegate = delegate;
+    }
+
+    @Override
+    public void sendMessage(String message) {
+        delegate.sendMessage(ChatColor.translateAlternateColorCodes('&', message));
+    }
+
+    @Override
+    public org.bukkit.command.CommandSender getHandle() {
+        return delegate;
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/BukkitEntity.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/BukkitEntity.java
@@ -0,0 +1,16 @@
+package com.dfsek.terra.bukkit;
+
+import com.dfsek.terra.api.generic.Entity;
+
+public class BukkitEntity implements Entity {
+    private final org.bukkit.entity.Entity entity;
+
+    public BukkitEntity(org.bukkit.entity.Entity entity) {
+        this.entity = entity;
+    }
+
+    @Override
+    public org.bukkit.entity.Entity getHandle() {
+        return entity;
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/BukkitItemHandle.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/BukkitItemHandle.java
@@ -0,0 +1,13 @@
+package com.dfsek.terra.bukkit;
+
+import com.dfsek.terra.api.generic.inventory.ItemHandle;
+import com.dfsek.terra.api.generic.inventory.ItemStack;
+import com.dfsek.terra.api.generic.world.block.MaterialData;
+import com.dfsek.terra.bukkit.world.block.BukkitMaterialData;
+
+public class BukkitItemHandle implements ItemHandle {
+    @Override
+    public ItemStack newItemStack(MaterialData material, int amount) {
+        return new BukkitItemStack(new org.bukkit.inventory.ItemStack(((BukkitMaterialData) material).getHandle(), amount));
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/BukkitItemMeta.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/BukkitItemMeta.java
@@ -0,0 +1,16 @@
+package com.dfsek.terra.bukkit;
+
+import com.dfsek.terra.api.generic.inventory.item.ItemMeta;
+
+public class BukkitItemMeta implements ItemMeta {
+    private final org.bukkit.inventory.meta.ItemMeta delegate;
+
+    public BukkitItemMeta(org.bukkit.inventory.meta.ItemMeta delegate) {
+        this.delegate = delegate;
+    }
+
+    @Override
+    public org.bukkit.inventory.meta.ItemMeta getHandle() {
+        return delegate;
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/BukkitItemStack.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/BukkitItemStack.java
@@ -0,0 +1,56 @@
+package com.dfsek.terra.bukkit;
+
+import com.dfsek.terra.api.generic.inventory.ItemStack;
+import com.dfsek.terra.api.generic.inventory.item.ItemMeta;
+import com.dfsek.terra.api.generic.world.block.MaterialData;
+import com.dfsek.terra.bukkit.world.block.BukkitMaterialData;
+
+public class BukkitItemStack implements ItemStack {
+    protected org.bukkit.inventory.ItemStack delegate;
+
+    public BukkitItemStack(org.bukkit.inventory.ItemStack delegate) {
+        this.delegate = delegate;
+    }
+
+    @Override
+    public int getAmount() {
+        return delegate.getAmount();
+    }
+
+    @Override
+    public void setAmount(int i) {
+        delegate.setAmount(i);
+    }
+
+    @Override
+    public MaterialData getType() {
+        return new BukkitMaterialData(delegate.getType());
+    }
+
+    @Override
+    public ItemStack clone() {
+        BukkitItemStack clone;
+        try {
+            clone = (BukkitItemStack) super.clone();
+            clone.delegate = delegate.clone();
+        } catch(CloneNotSupportedException e) {
+            throw new Error(e);
+        }
+        return clone;
+    }
+
+    @Override
+    public ItemMeta getItemMeta() {
+        return new BukkitItemMeta(delegate.getItemMeta());
+    }
+
+    @Override
+    public void setItemMeta(ItemMeta meta) {
+        delegate.setItemMeta(((BukkitItemMeta) meta).getHandle());
+    }
+
+    @Override
+    public org.bukkit.inventory.ItemStack getHandle() {
+        return delegate;
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/BukkitPlayer.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/BukkitPlayer.java
@@ -0,0 +1,23 @@
+package com.dfsek.terra.bukkit;
+
+import com.dfsek.terra.api.Player;
+import com.dfsek.terra.api.generic.world.vector.Location;
+
+public class BukkitPlayer implements Player {
+    private final org.bukkit.entity.Player delegate;
+
+    public BukkitPlayer(org.bukkit.entity.Player delegate) {
+        this.delegate = delegate;
+    }
+
+    @Override
+    public org.bukkit.entity.Player getHandle() {
+        return delegate;
+    }
+
+    @Override
+    public Location getLocation() {
+        org.bukkit.Location bukkit = delegate.getLocation();
+        return new Location(new BukkitWorld(bukkit.getWorld()), bukkit.getX(), bukkit.getY(), bukkit.getZ());
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/BukkitTree.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/BukkitTree.java
@@ -0,0 +1,17 @@
+package com.dfsek.terra.bukkit;
+
+import com.dfsek.terra.api.generic.Tree;
+import org.bukkit.TreeType;
+
+public class BukkitTree implements Tree {
+    private final TreeType delegate;
+
+    public BukkitTree(TreeType delegate) {
+        this.delegate = delegate;
+    }
+
+    @Override
+    public TreeType getHandle() {
+        return delegate;
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/BukkitWorld.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/BukkitWorld.java
@@ -0,0 +1,97 @@
+package com.dfsek.terra.bukkit;
+
+import com.dfsek.terra.api.generic.Tree;
+import com.dfsek.terra.api.generic.generator.ChunkGenerator;
+import com.dfsek.terra.api.generic.world.Chunk;
+import com.dfsek.terra.api.generic.world.World;
+import com.dfsek.terra.api.generic.world.block.Block;
+import com.dfsek.terra.api.generic.world.vector.Location;
+import com.dfsek.terra.bukkit.generator.BukkitChunkGenerator;
+import com.dfsek.terra.bukkit.world.block.BukkitBlock;
+
+import java.io.File;
+import java.util.UUID;
+
+public class BukkitWorld implements World {
+    private final org.bukkit.World delegate;
+
+    public BukkitWorld(org.bukkit.World delegate) {
+        this.delegate = delegate;
+    }
+
+    @Override
+    public long getSeed() {
+        return delegate.getSeed();
+    }
+
+    @Override
+    public int getMaxHeight() {
+        return delegate.getMaxHeight();
+    }
+
+    @Override
+    public ChunkGenerator getGenerator() {
+        return new BukkitChunkGenerator(delegate.getGenerator());
+    }
+
+    @Override
+    public String getName() {
+        return delegate.getName();
+    }
+
+    @Override
+    public UUID getUID() {
+        return delegate.getUID();
+    }
+
+    @Override
+    public boolean isChunkGenerated(int x, int z) {
+        return delegate.isChunkGenerated(x, z);
+    }
+
+    @Override
+    public Chunk getChunkAt(int x, int z) {
+        return new BukkitChunk(delegate.getChunkAt(x, z));
+    }
+
+    @Override
+    public File getWorldFolder() {
+        return delegate.getWorldFolder();
+    }
+
+    @Override
+    public Block getBlockAt(int x, int y, int z) {
+        return new BukkitBlock(delegate.getBlockAt(x, y, z));
+    }
+
+    @Override
+    public Block getBlockAt(Location l) {
+        return new BukkitBlock(delegate.getBlockAt(l.getBlockX(), l.getBlockY(), l.getBlockZ()));
+    }
+
+    @Override
+    public boolean generateTree(Location l, Tree vanillaTreeType) {
+        return delegate.generateTree(new org.bukkit.Location(delegate, l.getX(), l.getY(), l.getZ()), ((BukkitTree) vanillaTreeType).getHandle());
+    }
+
+    @Override
+    public void spawn(Location l, Class<com.dfsek.terra.api.generic.Entity> entity, java.util.function.Consumer<com.dfsek.terra.api.generic.Entity> consumer) {
+    }
+
+    @Override
+    public org.bukkit.World getHandle() {
+        return delegate;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if(!(obj instanceof BukkitWorld)) return false;
+        BukkitWorld other = (BukkitWorld) obj;
+        return other.getHandle().equals(delegate);
+    }
+
+    @Override
+    public int hashCode() {
+        return delegate.hashCode();
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/BukkitWorldHandle.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/BukkitWorldHandle.java
@@ -0,0 +1,45 @@
+package com.dfsek.terra.bukkit;
+
+import com.dfsek.terra.api.generic.world.WorldHandle;
+import com.dfsek.terra.api.generic.world.block.Block;
+import com.dfsek.terra.api.generic.world.block.BlockData;
+import com.dfsek.terra.api.generic.world.block.MaterialData;
+import com.dfsek.terra.api.generic.world.block.data.Waterlogged;
+import com.dfsek.terra.bukkit.world.block.BukkitBlockData;
+import com.dfsek.terra.bukkit.world.block.BukkitMaterialData;
+import com.dfsek.terra.bukkit.world.block.data.BukkitStairs;
+import com.dfsek.terra.bukkit.world.block.data.BukkitWaterlogged;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.block.data.type.Stairs;
+
+public class BukkitWorldHandle implements WorldHandle {
+
+    @Override
+    public void setBlockData(Block block, BlockData data, boolean physics) {
+        block.setBlockData(data, physics);
+    }
+
+    @Override
+    public BlockData getBlockData(Block block) {
+        return block.getBlockData();
+    }
+
+    @Override
+    public MaterialData getType(Block block) {
+        return block.getType();
+    }
+
+    @Override
+    public BlockData createBlockData(String data) {
+        org.bukkit.block.data.BlockData bukkitData = Bukkit.createBlockData(data);
+        if(bukkitData instanceof Stairs) return new BukkitStairs(bukkitData);
+        if(bukkitData instanceof Waterlogged) return new BukkitWaterlogged(bukkitData);
+        return new BukkitBlockData(Bukkit.createBlockData(data));
+    }
+
+    @Override
+    public MaterialData createMaterialData(String data) {
+        return new BukkitMaterialData(Material.matchMaterial(data));
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/TerraBukkitPlugin.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/TerraBukkitPlugin.java
@@ -0,0 +1,172 @@
+package com.dfsek.terra.bukkit;
+
+import com.dfsek.tectonic.loading.TypeRegistry;
+import com.dfsek.terra.TerraWorld;
+import com.dfsek.terra.api.GenericLoaders;
+import com.dfsek.terra.api.gaea.lang.Language;
+import com.dfsek.terra.api.generic.TerraPlugin;
+import com.dfsek.terra.api.generic.inventory.ItemHandle;
+import com.dfsek.terra.api.generic.world.Biome;
+import com.dfsek.terra.api.generic.world.World;
+import com.dfsek.terra.api.generic.world.WorldHandle;
+import com.dfsek.terra.api.generic.world.block.BlockData;
+import com.dfsek.terra.api.generic.world.block.MaterialData;
+import com.dfsek.terra.bukkit.command.command.TerraCommand;
+import com.dfsek.terra.bukkit.command.command.structure.LocateCommand;
+import com.dfsek.terra.bukkit.generator.BukkitChunkGenerator;
+import com.dfsek.terra.bukkit.generator.BukkitChunkGeneratorWrapper;
+import com.dfsek.terra.bukkit.listeners.EventListener;
+import com.dfsek.terra.bukkit.listeners.SpigotListener;
+import com.dfsek.terra.bukkit.util.PaperUtil;
+import com.dfsek.terra.bukkit.world.BukkitBiome;
+import com.dfsek.terra.config.base.ConfigPack;
+import com.dfsek.terra.config.base.PluginConfig;
+import com.dfsek.terra.config.lang.LangUtil;
+import com.dfsek.terra.debug.Debug;
+import com.dfsek.terra.generation.TerraChunkGenerator;
+import com.dfsek.terra.registry.ConfigRegistry;
+import org.bstats.bukkit.Metrics;
+import org.bukkit.Bukkit;
+import org.bukkit.command.PluginCommand;
+import org.bukkit.entity.EntityType;
+import org.bukkit.generator.ChunkGenerator;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+
+
+public class TerraBukkitPlugin extends JavaPlugin implements TerraPlugin {
+    private final Map<String, TerraChunkGenerator> generatorMap = new HashMap<>();
+    private final Map<World, TerraWorld> worldMap = new HashMap<>();
+    private final Map<String, ConfigPack> worlds = new HashMap<>();
+    private final ConfigRegistry registry = new ConfigRegistry();
+    private final PluginConfig config = new PluginConfig();
+    private WorldHandle handle = new BukkitWorldHandle();
+    private final GenericLoaders genericLoaders = new GenericLoaders(this);
+
+
+    public void reload() {
+        Map<World, TerraWorld> newMap = new HashMap<>();
+        worldMap.forEach((world, tw) -> {
+            String packID = tw.getConfig().getTemplate().getID();
+            newMap.put(world, new TerraWorld(world, registry.get(packID), this));
+        });
+        worldMap.clear();
+        worldMap.putAll(newMap);
+    }
+
+    @Override
+    public ItemHandle getItemHandle() {
+        return null;
+    }
+
+    public void setHandle(WorldHandle handle) {
+        getLogger().warning("|-------------------------------------------------------|");
+        getLogger().warning("A third-party addon has injected a custom WorldHandle!");
+        getLogger().warning("If you encounter issues, try *without* the addon before");
+        getLogger().warning("reporting to Terra. Report issues with the addon to the");
+        getLogger().warning("addon's maintainers!");
+        getLogger().warning("|-------------------------------------------------------|");
+        this.handle = handle;
+    }
+
+    @Override
+    public void onDisable() {
+        TerraChunkGenerator.saveAll();
+    }
+
+    @Override
+    public void onEnable() {
+        Debug.setLogger(getLogger()); // Set debug logger.
+
+        saveDefaultConfig();
+
+        Metrics metrics = new Metrics(this, 9017); // Set up bStats.
+        metrics.addCustomChart(new Metrics.SingleLineChart("worlds", worldMap::size)); // World number chart.
+
+        config.load(this); // Load master config.yml
+        LangUtil.load(config.getLanguage(), this); // Load language.
+        Debug.setDebug(isDebug());
+
+        registry.loadAll(this); // Load all config packs.
+
+        PluginCommand c = Objects.requireNonNull(getCommand("terra"));
+        TerraCommand command = new TerraCommand(this); // Set up main Terra command.
+        c.setExecutor(command);
+        c.setTabCompleter(command);
+
+        LocateCommand locate = new LocateCommand(command, false);
+        PluginCommand locatePl = Objects.requireNonNull(getCommand("locate"));
+        locatePl.setExecutor(locate); // Override locate command. Once Paper accepts StructureLocateEvent this will be unneeded on Paper implementations.
+        locatePl.setTabCompleter(locate);
+
+
+        long save = config.getDataSaveInterval();
+        Bukkit.getScheduler().runTaskTimerAsynchronously(this, TerraChunkGenerator::saveAll, save, save); // Schedule population data saving
+
+        Bukkit.getPluginManager().registerEvents(new EventListener(this), this); // Register master event listener
+        Bukkit.getPluginManager().registerEvents(new SpigotListener(this), this); // Register Spigot event listener, once Paper accepts StructureLocateEvent PR Spigot and Paper events will be separate.
+
+        PaperUtil.checkPaper(this);
+    }
+
+    @Override
+    public @Nullable ChunkGenerator getDefaultWorldGenerator(@NotNull String worldName, @Nullable String id) {
+        return new BukkitChunkGeneratorWrapper(generatorMap.computeIfAbsent(worldName, name -> {
+            if(!registry.contains(id)) throw new IllegalArgumentException("No such config pack \"" + id + "\"");
+            worlds.put(worldName, registry.get(id));
+            return new TerraChunkGenerator(registry.get(id), this);
+        }));
+    }
+
+    @Override
+    public boolean isDebug() {
+        return config.isDebug();
+    }
+
+
+    @Override
+    public Language getLanguage() {
+        return LangUtil.getLanguage();
+    }
+
+    public ConfigRegistry getRegistry() {
+        return registry;
+    }
+
+    public TerraWorld getWorld(World w) {
+        if(!(w.getGenerator() instanceof BukkitChunkGenerator))
+            throw new IllegalArgumentException("Not a Terra world! " + w.getGenerator());
+        if(!worlds.containsKey(w.getName())) {
+            getLogger().warning("Unexpected world load detected: \"" + w.getName() + "\"");
+            return new TerraWorld(w, ((TerraChunkGenerator) w.getGenerator()).getConfigPack(), this);
+        }
+        return worldMap.computeIfAbsent(w, world -> new TerraWorld(w, worlds.get(w.getName()), this));
+    }
+
+    @NotNull
+    @Override
+    public PluginConfig getTerraConfig() {
+        return config;
+    }
+
+    @Override
+    public WorldHandle getWorldHandle() {
+        return handle;
+    }
+
+
+    @Override
+    public void register(TypeRegistry registry) {
+        registry
+                .registerLoader(BlockData.class, (t, o, l) -> handle.createBlockData((String) o))
+                .registerLoader(MaterialData.class, (t, o, l) -> handle.createMaterialData((String) o))
+                .registerLoader(Biome.class, (t, o, l) -> new BukkitBiome(org.bukkit.block.Biome.valueOf((String) o)))
+                .registerLoader(EntityType.class, (t, o, l) -> EntityType.valueOf((String) o));
+        genericLoaders.register(registry);
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/Command.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/Command.java
@@ -0,0 +1,112 @@
+package com.dfsek.terra.bukkit.command;
+
+import com.dfsek.terra.api.generic.TerraPlugin;
+import com.dfsek.terra.bukkit.BukkitCommandSender;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabCompleter;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Represents a command or subcommand, can be nested via getSubCommands.
+ */
+public abstract class Command implements CommandExecutor, TabCompleter {
+    private final TerraPlugin main;
+    public Command(TerraPlugin main) {
+        this.main = main;
+    }
+    public Command(Command parent) {
+        main = parent.getMain();
+    }
+
+    public TerraPlugin getMain() {
+        return main;
+    }
+
+    /**
+     * Gets the name of the command/subcommand
+     * @return Name of command
+     */
+    public abstract String getName();
+
+    /**
+     * Gets a list of subcommands
+     * @return List of subcommands
+     */
+    public abstract List<Command> getSubCommands();
+
+    /**
+     * Executes the given command, returning its success.
+     * <br>
+     * If false is returned, then the "usage" plugin.yml entry for this command
+     * (if defined) will be sent to the player.
+     *
+     * @param sender Source of the command
+     * @param command Command which was executed
+     * @param label Alias of the command which was used
+     * @param args Passed command arguments
+     * @return true if a valid command, otherwise false
+     */
+
+    public abstract boolean execute(@NotNull CommandSender sender, @NotNull org.bukkit.command.Command command, @NotNull String label, @NotNull String[] args);
+    /**
+     * Gets the number of arguments
+     * @return Number of arguments
+     */
+    public abstract int arguments();
+
+    /**
+     * Executes the given command, invoking subcommands if applicable and returning its success.
+     * <br>
+     * If false is returned, then the "usage" plugin.yml entry for this command
+     * (if defined) will be sent to the player.
+     *
+     * @param sender Source of the command
+     * @param command Command which was executed
+     * @param label Alias of the command which was used
+     * @param args Passed command arguments
+     * @return true if a valid command, otherwise false
+     */
+    @Override
+    public final boolean onCommand(@NotNull CommandSender sender, @NotNull org.bukkit.command.Command command, @NotNull String label, @NotNull String[] args) {
+        if(this instanceof DebugCommand && ! main.isDebug()) {
+            main.getLanguage().send("command.debug-only", new BukkitCommandSender(sender));
+            return true;
+        }
+        if(args.length > 0) {
+            for(Command c : getSubCommands()) {
+                if(c.getName().equals(args[0])) {
+                    return c.onCommand(sender, command, label, Arrays.stream(args, 1, args.length).toArray(String[]::new));
+                }
+            }
+            if(args.length != arguments()) {
+                main.getLanguage().send("command.invalid", new BukkitCommandSender(sender), String.valueOf(arguments()), String.valueOf(args.length));
+                return true;
+            }
+            return execute(sender, command, label, args);
+        }
+        if(args.length != arguments()) {
+            main.getLanguage().send("command.invalid", new BukkitCommandSender(sender), String.valueOf(arguments()), String.valueOf(args.length));
+            return true;
+        }
+        return execute(sender, command, label, new String[] {});
+    }
+
+    public abstract List<String> getTabCompletions(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args);
+
+    @Override
+    public final @Nullable List<String> onTabComplete(@NotNull CommandSender sender, org.bukkit.command.@NotNull Command command, @NotNull String alias, @NotNull String[] args) {
+        List<String> complete = new ArrayList<>();
+        if(args.length > 0) for(Command c : getSubCommands()) {
+            if(c.getName().startsWith(args[0])) complete.add(c.getName());
+            if(c.getName().equals(args[0])) return c.onTabComplete(sender, command, alias, Arrays.stream(args, 1, args.length).toArray(String[]::new));
+        }
+        complete.addAll(getTabCompletions(sender, alias, args));
+        return complete;
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/DebugCommand.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/DebugCommand.java
@@ -0,0 +1,8 @@
+package com.dfsek.terra.bukkit.command;
+
+/**
+ * Implementing this interface marks a command as debug-only.
+ * If a parent command implements this interface, all child commands will be considered debug commands, regardless of whether they implement DebugCommand as well.
+ */
+public interface DebugCommand {
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/PlayerCommand.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/PlayerCommand.java
@@ -0,0 +1,50 @@
+package com.dfsek.terra.bukkit.command;
+
+import com.dfsek.terra.bukkit.BukkitCommandSender;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * A command that may only be executed by a player. If executor is not a player, a message will be displayed and no action will be performed.
+ */
+public abstract class PlayerCommand extends Command {
+    public PlayerCommand(Command parent) {
+        super(parent);
+    }
+
+    /**
+     * Executes the given command, returning its success.
+     * <br>
+     * If false is returned, then the "usage" plugin.yml entry for this command
+     * (if defined) will be sent to the player.
+     *
+     * @param sender Source of the command
+     * @param command Command which was executed
+     * @param label Alias of the command which was used
+     * @param args Passed command arguments
+     * @return true if a valid command, otherwise false
+     */
+    @Override
+    public final boolean execute(@NotNull CommandSender sender, org.bukkit.command.@NotNull Command command, @NotNull String label, @NotNull String[] args) {
+        if(!(sender instanceof Player)) {
+            getMain().getLanguage().send("command.players-only", new BukkitCommandSender(sender));
+            return true;
+        }
+        Player p = (Player) sender;
+        return execute(p, command, label, args);
+    }
+    /**
+     * Executes the given command, returning its success.
+     * <br>
+     * If false is returned, then the "usage" plugin.yml entry for this command
+     * (if defined) will be sent to the player.
+     *
+     * @param sender Player that executed command
+     * @param command Command which was executed
+     * @param label Alias of the command which was used
+     * @param args Passed command arguments
+     * @return true if a valid command, otherwise false
+     */
+    public abstract boolean execute(@NotNull Player sender, org.bukkit.command.@NotNull Command command, @NotNull String label, @NotNull String[] args);
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/WorldCommand.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/WorldCommand.java
@@ -0,0 +1,53 @@
+package com.dfsek.terra.bukkit.command;
+
+import com.dfsek.terra.bukkit.BukkitCommandSender;
+import org.bukkit.World;
+import org.bukkit.entity.Player;
+import org.bukkit.generator.ChunkGenerator;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * A command that must be executed by a player, in a Terra world.
+ */
+public abstract class WorldCommand extends PlayerCommand {
+    public WorldCommand(Command parent) {
+        super(parent);
+    }
+
+    /**
+     * Executes the given command, returning its success.
+     * <br>
+     * If false is returned, then the "usage" plugin.yml entry for this command
+     * (if defined) will be sent to the player.
+     *
+     * @param sender Source of the command
+     * @param command Command which was executed
+     * @param label Alias of the command which was used
+     * @param args Passed command arguments
+     * @return true if a valid command, otherwise false
+     */
+    @Override
+    public boolean execute(@NotNull Player sender, org.bukkit.command.@NotNull Command command, @NotNull String label, @NotNull String[] args) {
+        if(sender.getWorld().getGenerator() instanceof ChunkGenerator) { // TODO: implementation
+            return execute(sender, command, label, args, sender.getWorld());
+        } else {
+            getMain().getLanguage().send("command.world", new BukkitCommandSender(sender));
+        }
+        return true;
+    }
+
+    /**
+     * Executes the given command, returning its success.
+     * <br>
+     * If false is returned, then the "usage" plugin.yml entry for this command
+     * (if defined) will be sent to the player.
+     *
+     * @param sender Player that executed command
+     * @param command Command which was executed
+     * @param label Alias of the command which was used
+     * @param args Passed command arguments
+     * @param world World in which command was executed
+     * @return true if a valid command, otherwise false
+     */
+    public abstract boolean execute(@NotNull Player sender, @NotNull org.bukkit.command.Command command, @NotNull String label, @NotNull String[] args, World world);
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/FixChunkCommand.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/FixChunkCommand.java
@@ -0,0 +1,43 @@
+package com.dfsek.terra.bukkit.command.command;
+
+import com.dfsek.terra.bukkit.command.WorldCommand;
+import org.bukkit.World;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collections;
+import java.util.List;
+
+public class FixChunkCommand extends WorldCommand {
+    public FixChunkCommand(com.dfsek.terra.bukkit.command.Command parent) {
+        super(parent);
+    }
+
+    @Override
+    public boolean execute(@NotNull Player player, @NotNull Command command, @NotNull String s, @NotNull String[] strings, World world) {
+        //TerraChunkGenerator.fixChunk(player.getLocation().getChunk());
+        return true;
+    }
+
+    @Override
+    public String getName() {
+        return "fixchunk";
+    }
+
+    @Override
+    public List<com.dfsek.terra.bukkit.command.Command> getSubCommands() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public int arguments() {
+        return 0;
+    }
+
+    @Override
+    public List<String> getTabCompletions(@NotNull CommandSender commandSender, @NotNull String s, @NotNull String[] strings) {
+        return Collections.emptyList();
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/OreCommand.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/OreCommand.java
@@ -0,0 +1,63 @@
+package com.dfsek.terra.bukkit.command.command;
+
+import com.dfsek.terra.bukkit.command.WorldCommand;
+import org.bukkit.World;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collections;
+import java.util.List;
+
+public class OreCommand extends WorldCommand {
+    public OreCommand(com.dfsek.terra.bukkit.command.Command parent) {
+        super(parent);
+    }
+
+    @Override
+    public boolean execute(@NotNull Player sender, @NotNull Command command, @NotNull String label, @NotNull String[] args, World w) {
+        /*
+        Block bl = sender.getTargetBlockExact(25);
+        if(args.length > 0) {
+            OreConfig ore = TerraWorld.getWorld(w).getConfig().getOre(args[0]);
+            if(ore == null) {
+                LangUtil.send("command.ore.invalid-ore", sender, args[0]);
+                return true;
+            }
+            if(bl == null) {
+                LangUtil.send("command.ore.out-of-range", sender);
+                return true;
+            }
+            Vector source = new Vector(FastMath.floorMod(bl.getX(), 16), bl.getY(), FastMath.floorMod(bl.getZ(), 16));
+            ore.doVein(source, bl.getChunk(), new FastRandom());
+        } else {
+            LangUtil.send("command.ore.main-menu", sender);
+        }
+        */
+        return true;
+
+
+        // TODO: implementation
+    }
+
+    @Override
+    public String getName() {
+        return "ore";
+    }
+
+    @Override
+    public List<com.dfsek.terra.bukkit.command.Command> getSubCommands() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public int arguments() {
+        return 1;
+    }
+
+    @Override
+    public List<String> getTabCompletions(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) {
+        return Collections.emptyList();
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/PacksCommand.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/PacksCommand.java
@@ -0,0 +1,57 @@
+package com.dfsek.terra.bukkit.command.command;
+
+import com.dfsek.terra.bukkit.BukkitCommandSender;
+import com.dfsek.terra.bukkit.command.Command;
+import com.dfsek.terra.config.base.ConfigPackTemplate;
+import com.dfsek.terra.config.lang.LangUtil;
+import com.dfsek.terra.registry.ConfigRegistry;
+import org.bukkit.command.CommandSender;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collections;
+import java.util.List;
+
+public class PacksCommand extends Command {
+    public PacksCommand(Command parent) {
+        super(parent);
+    }
+
+    @Override
+    public String getName() {
+        return "packs";
+    }
+
+    @Override
+    public List<Command> getSubCommands() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public boolean execute(@NotNull CommandSender commandSender, org.bukkit.command.@NotNull Command command, @NotNull String s, @NotNull String[] strings) {
+
+        ConfigRegistry registry = getMain().getRegistry();
+
+        if(registry.entries().size() == 0) {
+            LangUtil.send("command.packs.none", new BukkitCommandSender(commandSender));
+            return true;
+        }
+
+        LangUtil.send("command.packs.main", new BukkitCommandSender(commandSender));
+        registry.entries().forEach(entry -> {
+            ConfigPackTemplate template = entry.getTemplate();
+            LangUtil.send("command.packs.pack", new BukkitCommandSender(commandSender), template.getID(), template.getAuthor(), template.getVersion());
+        });
+
+        return true;
+    }
+
+    @Override
+    public int arguments() {
+        return 0;
+    }
+
+    @Override
+    public List<String> getTabCompletions(@NotNull CommandSender commandSender, @NotNull String s, @NotNull String[] strings) {
+        return Collections.emptyList();
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/ReloadCommand.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/ReloadCommand.java
@@ -0,0 +1,51 @@
+package com.dfsek.terra.bukkit.command.command;
+
+
+import com.dfsek.terra.bukkit.BukkitCommandSender;
+import com.dfsek.terra.bukkit.command.Command;
+import com.dfsek.terra.bukkit.command.DebugCommand;
+import com.dfsek.terra.config.lang.LangUtil;
+import org.bukkit.command.CommandSender;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collections;
+import java.util.List;
+
+public class ReloadCommand extends Command implements DebugCommand {
+    public ReloadCommand(Command parent) {
+        super(parent);
+    }
+
+    @Override
+    public String getName() {
+        return "reload";
+    }
+
+    @Override
+    public List<Command> getSubCommands() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public boolean execute(@NotNull CommandSender sender, org.bukkit.command.@NotNull Command command, @NotNull String label, @NotNull String[] args) {
+        getMain().getTerraConfig().load(getMain());
+        LangUtil.load(getMain().getTerraConfig().getLanguage(), getMain()); // Load language.
+        if(!getMain().getRegistry().loadAll(getMain())) {
+            LangUtil.send("command.reload-error", new BukkitCommandSender(sender));
+            return true;
+        }
+        getMain().reload();
+        LangUtil.send("command.reload", new BukkitCommandSender(sender));
+        return true;
+    }
+
+    @Override
+    public int arguments() {
+        return 0;
+    }
+
+    @Override
+    public List<String> getTabCompletions(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) {
+        return Collections.emptyList();
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/SaveDataCommand.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/SaveDataCommand.java
@@ -0,0 +1,46 @@
+package com.dfsek.terra.bukkit.command.command;
+
+import com.dfsek.terra.bukkit.BukkitCommandSender;
+import com.dfsek.terra.bukkit.command.Command;
+import com.dfsek.terra.bukkit.command.WorldCommand;
+import com.dfsek.terra.config.lang.LangUtil;
+import org.bukkit.World;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collections;
+import java.util.List;
+
+public class SaveDataCommand extends WorldCommand {
+    public SaveDataCommand(Command parent) {
+        super(parent);
+    }
+
+    @Override
+    public String getName() {
+        return "save-data";
+    }
+
+    @Override
+    public List<Command> getSubCommands() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public int arguments() {
+        return 0;
+    }
+
+    @Override
+    public List<String> getTabCompletions(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public boolean execute(@NotNull Player sender, org.bukkit.command.@NotNull Command command, @NotNull String label, @NotNull String[] args, World w) {
+        //TerraChunkGenerator.saveAll();
+        LangUtil.send("debug.data-save", new BukkitCommandSender(sender), w.getName());
+        return true;
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/TerraCommand.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/TerraCommand.java
@@ -0,0 +1,61 @@
+package com.dfsek.terra.bukkit.command.command;
+
+import com.dfsek.terra.api.generic.TerraPlugin;
+import com.dfsek.terra.bukkit.BukkitCommandSender;
+import com.dfsek.terra.bukkit.command.Command;
+import com.dfsek.terra.bukkit.command.command.biome.BiomeCommand;
+import com.dfsek.terra.bukkit.command.command.geometry.GeometryCommand;
+import com.dfsek.terra.bukkit.command.command.image.ImageCommand;
+import com.dfsek.terra.bukkit.command.command.profile.ProfileCommand;
+import com.dfsek.terra.bukkit.command.command.structure.StructureCommand;
+import com.dfsek.terra.config.lang.LangUtil;
+import org.bukkit.command.CommandSender;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+public class TerraCommand extends Command {
+    private final List<Command> commands = Arrays.asList(new ReloadCommand(this),
+            new BiomeCommand(this),
+            new OreCommand(this),
+            new ProfileCommand(this),
+            new SaveDataCommand(this),
+            new StructureCommand(this),
+            new ImageCommand(this),
+            new GeometryCommand(this),
+            new FixChunkCommand(this),
+            new VersionCommand(this),
+            new PacksCommand(this));
+
+    public TerraCommand(TerraPlugin main) {
+        super(main);
+    }
+
+    @Override
+    public String getName() {
+        return "com/dfsek/terra";
+    }
+
+    @Override
+    public List<Command> getSubCommands() {
+        return commands;
+    }
+
+    @Override
+    public boolean execute(@NotNull CommandSender sender, org.bukkit.command.@NotNull Command command, @NotNull String label, @NotNull String[] args) {
+        LangUtil.send("command.main-menu", new BukkitCommandSender(sender));
+        return true;
+    }
+
+    @Override
+    public int arguments() {
+        return 0;
+    }
+
+    @Override
+    public List<String> getTabCompletions(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) {
+        return Collections.emptyList();
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/VersionCommand.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/VersionCommand.java
@@ -0,0 +1,44 @@
+package com.dfsek.terra.bukkit.command.command;
+
+import com.dfsek.terra.bukkit.BukkitCommandSender;
+import com.dfsek.terra.bukkit.TerraBukkitPlugin;
+import com.dfsek.terra.bukkit.command.Command;
+import com.dfsek.terra.config.lang.LangUtil;
+import org.bukkit.command.CommandSender;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collections;
+import java.util.List;
+
+public class VersionCommand extends Command {
+    public VersionCommand(Command parent) {
+        super(parent);
+    }
+
+    @Override
+    public String getName() {
+        return "version";
+    }
+
+    @Override
+    public List<Command> getSubCommands() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public boolean execute(@NotNull CommandSender sender, org.bukkit.command.@NotNull Command command, @NotNull String label, @NotNull String[] args) {
+        String terraVersion = ((TerraBukkitPlugin) getMain()).getDescription().getVersion();
+        LangUtil.send("command.version", new BukkitCommandSender(sender), terraVersion);
+        return true;
+    }
+
+    @Override
+    public int arguments() {
+        return 0;
+    }
+
+    @Override
+    public List<String> getTabCompletions(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) {
+        return Collections.emptyList();
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/biome/BiomeCommand.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/biome/BiomeCommand.java
@@ -0,0 +1,49 @@
+package com.dfsek.terra.bukkit.command.command.biome;
+
+import com.dfsek.terra.bukkit.command.WorldCommand;
+import org.bukkit.World;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+public class BiomeCommand extends WorldCommand {
+    public BiomeCommand(com.dfsek.terra.bukkit.command.Command parent) {
+        super(parent);
+    }
+
+    @Override
+    public boolean execute(@NotNull Player sender, @NotNull Command command, @NotNull String label, @NotNull String[] args, World w) {
+        /*
+        TerraBiomeGrid grid = ((TerraBukkitPlugin) getMain()).getWorld(sender.getWorld()).getGrid();
+        UserDefinedBiome biome = (UserDefinedBiome) grid.getBiome(sender.getLocation(), GenerationPhase.POPULATE);
+        LangUtil.send("command.biome.in", sender, biome.getID());
+
+         */
+        return true;
+    }
+
+    @Override
+    public String getName() {
+        return "biome";
+    }
+
+    @Override
+    public List<com.dfsek.terra.bukkit.command.Command> getSubCommands() {
+        return Arrays.asList(new BiomeLocateCommand(this, true), new BiomeLocateCommand(this, false), new BiomeInfoCommand(this));
+    }
+
+    @Override
+    public int arguments() {
+        return 0;
+    }
+
+    @Override
+    public List<String> getTabCompletions(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) {
+        return Collections.emptyList();
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/biome/BiomeInfoCommand.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/biome/BiomeInfoCommand.java
@@ -0,0 +1,97 @@
+package com.dfsek.terra.bukkit.command.command.biome;
+
+import com.dfsek.terra.biome.UserDefinedBiome;
+import com.dfsek.terra.bukkit.BukkitCommandSender;
+import com.dfsek.terra.bukkit.BukkitWorld;
+import com.dfsek.terra.bukkit.command.WorldCommand;
+import com.dfsek.terra.carving.UserDefinedCarver;
+import com.dfsek.terra.config.base.ConfigPack;
+import com.dfsek.terra.config.lang.LangUtil;
+import com.dfsek.terra.config.templates.BiomeTemplate;
+import com.dfsek.terra.generation.items.TerraStructure;
+import org.bukkit.World;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+public class BiomeInfoCommand extends WorldCommand {
+    public BiomeInfoCommand(com.dfsek.terra.bukkit.command.Command parent) {
+        super(parent);
+    }
+
+    @Override
+    public boolean execute(@NotNull Player sender, @NotNull Command command, @NotNull String label, @NotNull String[] args, World world) {
+        String id = args[0];
+        ConfigPack cfg = getMain().getWorld(new BukkitWorld(world)).getConfig();
+        UserDefinedBiome b;
+        try {
+            b = cfg.getBiome(id);
+        } catch(IllegalArgumentException | NullPointerException e) {
+            LangUtil.send("command.biome.invalid", new BukkitCommandSender(sender), id);
+            return true;
+        }
+        sender.sendMessage("Biome info for \"" + b.getID() + "\".");
+        sender.sendMessage("Vanilla biome: " + b.getVanillaBiome());
+        sender.sendMessage("Eroded by: " + b.getErode().getConfig().getID());
+
+
+        BiomeTemplate bio = b.getConfig();
+
+        if(bio.getExtend() != null) sender.sendMessage("Extends: " + bio.getExtend());
+
+        List<TerraStructure> structureConfigs = bio.getStructures();
+
+        if(structureConfigs.size() == 0) sender.sendMessage("No Structures");
+        else {
+            sender.sendMessage("-------Structures-------");
+            for(TerraStructure c : structureConfigs) {
+                sender.sendMessage(" - " + c.getTemplate().getID());
+            }
+        }
+
+        Map<UserDefinedCarver, Integer> carverConfigs = bio.getCarvers();
+
+        if(structureConfigs.size() == 0) sender.sendMessage("No Carvers");
+        else {
+            sender.sendMessage("---------Carvers--------");
+            for(Map.Entry<UserDefinedCarver, Integer> entry : carverConfigs.entrySet()) {
+                sender.sendMessage(" - " + entry.getKey().getConfig().getID() + ": " + entry.getValue() + "%");
+            }
+        }
+
+        return true;
+    }
+
+    @Override
+    public String getName() {
+        return "info";
+    }
+
+    @Override
+    public List<com.dfsek.terra.bukkit.command.Command> getSubCommands() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public int arguments() {
+        return 1;
+    }
+
+    @Override
+    public List<String> getTabCompletions(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) {
+        /*
+        if(!(sender instanceof Player) || !(((Player) sender).getWorld().getGenerator() instanceof TerraChunkGenerator))
+            return Collections.emptyList();
+        List<String> ids = ((TerraBukkitPlugin) getMain()).getWorld(((Player) sender).getWorld()).getConfig().getBiomeIDs();
+        if(args.length == 1)
+            return ids.stream().filter(string -> string.toUpperCase().startsWith(args[0].toUpperCase())).collect(Collectors.toList());
+
+         */
+        return Collections.emptyList();
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/biome/BiomeLocateCommand.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/biome/BiomeLocateCommand.java
@@ -0,0 +1,84 @@
+package com.dfsek.terra.bukkit.command.command.biome;
+
+import com.dfsek.terra.bukkit.command.WorldCommand;
+import org.bukkit.World;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collections;
+import java.util.List;
+
+public class BiomeLocateCommand extends WorldCommand {
+    private final boolean tp;
+
+    public BiomeLocateCommand(com.dfsek.terra.bukkit.command.Command parent, boolean teleport) {
+        super(parent);
+        this.tp = teleport;
+    }
+
+    @SuppressWarnings("DuplicatedCode")
+    @Override
+    public boolean execute(@NotNull Player sender, @NotNull Command command, @NotNull String label, @NotNull String[] args, World world) {
+        /*
+        String id = args[0];
+        int maxRadius;
+        try {
+            maxRadius = Integer.parseInt(args[1]);
+        } catch(NumberFormatException e) {
+            LangUtil.send("command.biome.invalid-radius", sender, args[1]);
+            return true;
+        }
+        UserDefinedBiome b;
+        try {
+            b = ((TerraBukkitPlugin) getMain()).getWorld(world).getConfig().getBiome(id);
+        } catch(IllegalArgumentException | NullPointerException e) {
+            LangUtil.send("command.biome.invalid", sender, id);
+            return true;
+        }
+        Bukkit.getScheduler().runTaskAsynchronously(getMain(), new AsyncBiomeFinder(((TerraBukkitPlugin) getMain()).getWorld(world).getGrid(), b, sender.getLocation().clone().multiply((1D / ((TerraBukkitPlugin) getMain()).getTerraConfig().getBiomeSearchResolution())), 0, maxRadius, location -> {
+            if(location != null) {
+                ComponentBuilder cm = new ComponentBuilder(String.format("The nearest %s is at ", id.toLowerCase()))
+                        .append(String.format("[%d, ~, %d]", location.getBlockX(), location.getBlockZ()), ComponentBuilder.FormatRetention.NONE)
+                        .event(new ClickEvent(ClickEvent.Action.RUN_COMMAND, String.format("/minecraft:tp %s %d.0 %.2f %d.0", sender.getName(), location.getBlockX(), sender.getLocation().getY(), location.getBlockZ())))
+                        .event(new HoverEvent(HoverEvent.Action.SHOW_TEXT, new BaseComponent[] {new TextComponent("Click to teleport")}))
+                        .color(ChatColor.GREEN)
+                        .append(String.format(" (%.1f blocks away)", location.add(new Vector(0, sender.getLocation().getY(), 0)).distance(sender.getLocation().toVector())), ComponentBuilder.FormatRetention.NONE);
+                sender.spigot().sendMessage(cm.create());
+                // LangUtil.send("command.biome.biome-found", sender, String.valueOf(location.getBlockX()), String.valueOf(location.getBlockZ()));
+            } else LangUtil.send("command.biome.unable-to-locate", sender);
+        }, (TerraBukkitPlugin) getMain()));
+
+         */
+        return true;
+    }
+
+    @Override
+    public String getName() {
+        return tp ? "teleport" : "locate";
+    }
+
+    @Override
+    public List<com.dfsek.terra.bukkit.command.Command> getSubCommands() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public int arguments() {
+        return 2;
+    }
+
+    @Override
+    public List<String> getTabCompletions(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) {
+        /*
+        if(!(sender instanceof Player) || !(((Player) sender).getWorld().getGenerator() instanceof TerraChunkGenerator))
+            return Collections.emptyList();
+        List<String> ids = ((TerraBukkitPlugin) getMain()).getWorld(((Player) sender).getWorld()).getConfig().getBiomeIDs();
+        if(args.length == 1)
+            return ids.stream().filter(string -> string.toUpperCase().startsWith(args[0].toUpperCase())).collect(Collectors.toList());
+
+         */
+        return Collections.emptyList();
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/geometry/DeformedSphereCommand.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/geometry/DeformedSphereCommand.java
@@ -0,0 +1,77 @@
+package com.dfsek.terra.bukkit.command.command.geometry;
+
+import com.dfsek.terra.api.gaea.math.FastNoiseLite;
+import com.dfsek.terra.api.generic.world.vector.Vector3;
+import com.dfsek.terra.bukkit.BukkitCommandSender;
+import com.dfsek.terra.bukkit.BukkitPlayer;
+import com.dfsek.terra.bukkit.BukkitWorld;
+import com.dfsek.terra.bukkit.command.PlayerCommand;
+import com.dfsek.terra.config.lang.LangUtil;
+import com.dfsek.terra.procgen.voxel.DeformedSphere;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collections;
+import java.util.List;
+
+public class DeformedSphereCommand extends PlayerCommand {
+    public DeformedSphereCommand(com.dfsek.terra.bukkit.command.Command parent) {
+        super(parent);
+    }
+
+    @Override
+    public boolean execute(@NotNull Player sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) {
+        int radius;
+        try {
+            radius = Integer.parseInt(args[0]);
+        } catch(NumberFormatException e) {
+            LangUtil.send("command.geometry.deform.invalid-radius", new BukkitCommandSender(sender), args[0]);
+            return true;
+        }
+        double deform;
+        try {
+            deform = Double.parseDouble(args[1]);
+        } catch(NumberFormatException e) {
+            LangUtil.send("command.geometry.deform.invalid-deform", new BukkitCommandSender(sender), args[1]);
+            return true;
+        }
+
+        double freq;
+        try {
+            freq = Float.parseFloat(args[2]);
+        } catch(NumberFormatException e) {
+            LangUtil.send("command.geometry.deform.invalid-frequency", new BukkitCommandSender(sender), args[2]);
+            return true;
+        }
+        FastNoiseLite n = new FastNoiseLite((int) sender.getWorld().getSeed());
+        n.setNoiseType(FastNoiseLite.NoiseType.OpenSimplex2);
+        n.setFrequency(freq);
+        DeformedSphere sphere = new DeformedSphere(new BukkitPlayer(sender).getLocation().toVector(), radius, deform, n);
+        for(Vector3 v : sphere.getGeometry()) {
+            v.toLocation(new BukkitWorld(sender.getWorld())).getBlock().setBlockData(getMain().getWorldHandle().createBlockData("minecraft:stone"), false);
+        }
+        return true;
+    }
+
+    @Override
+    public String getName() {
+        return "deformedsphere";
+    }
+
+    @Override
+    public List<com.dfsek.terra.bukkit.command.Command> getSubCommands() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public int arguments() {
+        return 3;
+    }
+
+    @Override
+    public List<String> getTabCompletions(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) {
+        return Collections.emptyList();
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/geometry/GeometryCommand.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/geometry/GeometryCommand.java
@@ -0,0 +1,46 @@
+package com.dfsek.terra.bukkit.command.command.geometry;
+
+import com.dfsek.terra.bukkit.BukkitCommandSender;
+import com.dfsek.terra.bukkit.command.DebugCommand;
+import com.dfsek.terra.bukkit.command.PlayerCommand;
+import com.dfsek.terra.config.lang.LangUtil;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+public class GeometryCommand extends PlayerCommand implements DebugCommand {
+    public GeometryCommand(com.dfsek.terra.bukkit.command.Command parent) {
+        super(parent);
+    }
+
+    @Override
+    public boolean execute(@NotNull Player sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) {
+        LangUtil.send("command.geometry.main-menu", new BukkitCommandSender(sender));
+        return true;
+    }
+
+    @Override
+    public String getName() {
+        return "geometry";
+    }
+
+    @Override
+    public List<com.dfsek.terra.bukkit.command.Command> getSubCommands() {
+        return Arrays.asList(new SphereCommand(this), new TubeCommand(this), new DeformedSphereCommand(this));
+    }
+
+    @Override
+    public int arguments() {
+        return 0;
+    }
+
+    @Override
+    public List<String> getTabCompletions(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) {
+        return Collections.emptyList();
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/geometry/SphereCommand.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/geometry/SphereCommand.java
@@ -0,0 +1,58 @@
+package com.dfsek.terra.bukkit.command.command.geometry;
+
+import com.dfsek.terra.api.generic.world.vector.Vector3;
+import com.dfsek.terra.bukkit.BukkitCommandSender;
+import com.dfsek.terra.bukkit.BukkitPlayer;
+import com.dfsek.terra.bukkit.BukkitWorld;
+import com.dfsek.terra.bukkit.command.PlayerCommand;
+import com.dfsek.terra.config.lang.LangUtil;
+import com.dfsek.terra.procgen.voxel.Sphere;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collections;
+import java.util.List;
+
+public class SphereCommand extends PlayerCommand {
+    public SphereCommand(com.dfsek.terra.bukkit.command.Command parent) {
+        super(parent);
+    }
+
+    @Override
+    public boolean execute(@NotNull Player sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) {
+        int radius;
+        try {
+            radius = Integer.parseInt(args[0]);
+        } catch(NumberFormatException e) {
+            LangUtil.send("command.geometry.sphere.invalid-radius", new BukkitCommandSender(sender), args[0]);
+            return true;
+        }
+        Sphere sphere = new Sphere(new BukkitPlayer(sender).getLocation().toVector(), radius);
+        for(Vector3 v : sphere.getGeometry()) {
+            v.toLocation(new BukkitWorld(sender.getWorld())).getBlock().setBlockData(getMain().getWorldHandle().createBlockData("minecraft:stone"), false);
+        }
+        return true;
+    }
+
+    @Override
+    public String getName() {
+        return "sphere";
+    }
+
+    @Override
+    public List<com.dfsek.terra.bukkit.command.Command> getSubCommands() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public int arguments() {
+        return 1;
+    }
+
+    @Override
+    public List<String> getTabCompletions(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) {
+        return Collections.emptyList();
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/geometry/TubeCommand.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/geometry/TubeCommand.java
@@ -0,0 +1,62 @@
+package com.dfsek.terra.bukkit.command.command.geometry;
+
+import com.dfsek.terra.api.generic.world.vector.Vector3;
+import com.dfsek.terra.bukkit.BukkitCommandSender;
+import com.dfsek.terra.bukkit.BukkitWorld;
+import com.dfsek.terra.bukkit.command.PlayerCommand;
+import com.dfsek.terra.bukkit.structure.WorldEditUtil;
+import com.dfsek.terra.bukkit.util.BukkitConversions;
+import com.dfsek.terra.config.lang.LangUtil;
+import com.dfsek.terra.procgen.voxel.Tube;
+import org.bukkit.Location;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collections;
+import java.util.List;
+
+public class TubeCommand extends PlayerCommand {
+    public TubeCommand(com.dfsek.terra.bukkit.command.Command parent) {
+        super(parent);
+    }
+
+    @Override
+    public boolean execute(@NotNull Player sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) {
+        Location[] l = WorldEditUtil.getSelectionPositions(sender);
+        if(l == null) return true;
+        int radius;
+        try {
+            radius = Integer.parseInt(args[0]);
+        } catch(NumberFormatException e) {
+            LangUtil.send("command.geometry.tube.invalid-radius", new BukkitCommandSender(sender), args[0]);
+            return true;
+        }
+        Tube tube = new Tube(BukkitConversions.toTerraVector(l[0].toVector()), BukkitConversions.toTerraVector(l[1].toVector()), radius);
+        for(Vector3 v : tube.getGeometry()) {
+            v.toLocation(new BukkitWorld(sender.getWorld())).getBlock().setBlockData(getMain().getWorldHandle().createBlockData("minecraft:stone"), false);
+        }
+        return true;
+    }
+
+    @Override
+    public String getName() {
+        return "tube";
+    }
+
+    @Override
+    public List<com.dfsek.terra.bukkit.command.Command> getSubCommands() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public int arguments() {
+        return 1;
+    }
+
+    @Override
+    public List<String> getTabCompletions(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) {
+        return Collections.emptyList();
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/image/ImageCommand.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/image/ImageCommand.java
@@ -0,0 +1,47 @@
+package com.dfsek.terra.bukkit.command.command.image;
+
+import com.dfsek.terra.bukkit.BukkitCommandSender;
+import com.dfsek.terra.bukkit.command.WorldCommand;
+import com.dfsek.terra.bukkit.command.command.image.gui.GUICommand;
+import com.dfsek.terra.config.lang.LangUtil;
+import org.bukkit.World;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+public class ImageCommand extends WorldCommand {
+    public ImageCommand(com.dfsek.terra.bukkit.command.Command parent) {
+        super(parent);
+    }
+
+    @Override
+    public boolean execute(@NotNull Player sender, @NotNull Command command, @NotNull String label, @NotNull String[] args, World w) {
+        LangUtil.send("command.image.main-menu", new BukkitCommandSender(sender));
+        return true;
+    }
+
+    @Override
+    public String getName() {
+        return "image";
+    }
+
+    @Override
+    public List<com.dfsek.terra.bukkit.command.Command> getSubCommands() {
+        return Arrays.asList(new RenderCommand(this), new GUICommand(this));
+    }
+
+    @Override
+    public int arguments() {
+        return 1;
+    }
+
+    @Override
+    public List<String> getTabCompletions(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) {
+        return Collections.emptyList();
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/image/RenderCommand.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/image/RenderCommand.java
@@ -0,0 +1,61 @@
+package com.dfsek.terra.bukkit.command.command.image;
+
+import com.dfsek.terra.bukkit.command.WorldCommand;
+import org.bukkit.World;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collections;
+import java.util.List;
+
+public class RenderCommand extends WorldCommand {
+    public RenderCommand(com.dfsek.terra.bukkit.command.Command parent) {
+        super(parent);
+    }
+
+    @Override
+    public boolean execute(@NotNull Player sender, @NotNull Command command, @NotNull String label, @NotNull String[] args, World world) {
+        /*
+        try {
+            WorldImageGenerator g = new WorldImageGenerator(world, Integer.parseInt(args[0]), Integer.parseInt(args[1]), (TerraBukkitPlugin) getMain());
+            g.drawWorld(sender.getLocation().getBlockX(), sender.getLocation().getBlockZ());
+            File file = new File(getMain().getDataFolder() + File.separator + "export" + File.separator + "map" + File.separator + "map_" + System.currentTimeMillis() + ".png");
+            //noinspection ResultOfMethodCallIgnored
+            file.mkdirs();
+            //noinspection ResultOfMethodCallIgnored
+            file.createNewFile();
+            g.save(file);
+            LangUtil.send("command.image.render.save", sender, file.getAbsolutePath());
+            return true;
+        } catch(Exception e) {
+            e.printStackTrace();
+            LangUtil.send("command.image.render.error", sender);
+            return true;
+        }
+
+         */
+        return true;
+    }
+
+    @Override
+    public String getName() {
+        return "render";
+    }
+
+    @Override
+    public List<com.dfsek.terra.bukkit.command.Command> getSubCommands() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public int arguments() {
+        return 2;
+    }
+
+    @Override
+    public List<String> getTabCompletions(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) {
+        return Collections.emptyList();
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/image/gui/GUICommand.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/image/gui/GUICommand.java
@@ -0,0 +1,47 @@
+package com.dfsek.terra.bukkit.command.command.image.gui;
+
+import com.dfsek.terra.bukkit.BukkitCommandSender;
+import com.dfsek.terra.bukkit.command.DebugCommand;
+import com.dfsek.terra.bukkit.command.WorldCommand;
+import com.dfsek.terra.config.lang.LangUtil;
+import org.bukkit.World;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+public class GUICommand extends WorldCommand implements DebugCommand {
+    public GUICommand(com.dfsek.terra.bukkit.command.Command parent) {
+        super(parent);
+    }
+
+    @Override
+    public boolean execute(@NotNull Player sender, @NotNull Command command, @NotNull String label, @NotNull String[] args, World world) {
+        LangUtil.send("command.image.gui.main-menu", new BukkitCommandSender(sender));
+        return true;
+    }
+
+    @Override
+    public String getName() {
+        return "gui";
+    }
+
+    @Override
+    public List<com.dfsek.terra.bukkit.command.Command> getSubCommands() {
+        return Arrays.asList(new StepGUICommand(this), new RawGUICommand(this));
+    }
+
+    @Override
+    public int arguments() {
+        return 1;
+    }
+
+    @Override
+    public List<String> getTabCompletions(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) {
+        return Collections.emptyList();
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/image/gui/RawGUICommand.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/image/gui/RawGUICommand.java
@@ -0,0 +1,52 @@
+package com.dfsek.terra.bukkit.command.command.image.gui;
+
+import com.dfsek.terra.bukkit.command.WorldCommand;
+import org.bukkit.World;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collections;
+import java.util.List;
+
+public class RawGUICommand extends WorldCommand {
+    public RawGUICommand(com.dfsek.terra.bukkit.command.Command parent) {
+        super(parent);
+    }
+
+    @Override
+    public boolean execute(@NotNull Player sender, @NotNull Command command, @NotNull String label, @NotNull String[] args, World world) {
+       /*
+        if(!getMain().isDebug()) {
+            LangUtil.send("command.image.gui.debug", sender);
+            return true;
+        }
+        ImageLoader loader = ((TerraBukkitPlugin) getMain()).getWorld(world).getConfig().getTemplate().getImageLoader();
+        if(loader != null) loader.debug(false, sender.getWorld(), (TerraBukkitPlugin) getMain());
+        else ImageLoader.debugWorld(false, world, (TerraBukkitPlugin) getMain());
+
+        */
+        return true;
+    }
+
+    @Override
+    public String getName() {
+        return "raw";
+    }
+
+    @Override
+    public List<com.dfsek.terra.bukkit.command.Command> getSubCommands() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public int arguments() {
+        return 0;
+    }
+
+    @Override
+    public List<String> getTabCompletions(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) {
+        return Collections.emptyList();
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/image/gui/StepGUICommand.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/image/gui/StepGUICommand.java
@@ -0,0 +1,52 @@
+package com.dfsek.terra.bukkit.command.command.image.gui;
+
+import com.dfsek.terra.bukkit.command.WorldCommand;
+import org.bukkit.World;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collections;
+import java.util.List;
+
+public class StepGUICommand extends WorldCommand {
+    public StepGUICommand(com.dfsek.terra.bukkit.command.Command parent) {
+        super(parent);
+    }
+
+    @Override
+    public boolean execute(@NotNull Player sender, @NotNull Command command, @NotNull String label, @NotNull String[] args, World world) {
+        /*
+        if(!getMain().isDebug()) {
+            LangUtil.send("command.image.gui.debug", sender);
+            return true;
+        }
+        ImageLoader loader = ((TerraBukkitPlugin) getMain()).getWorld(world).getConfig().getTemplate().getImageLoader();
+        if(loader != null) loader.debug(true, sender.getWorld(), (TerraBukkitPlugin) getMain());
+        else ImageLoader.debugWorld(true, world, (TerraBukkitPlugin) getMain());
+
+         */
+        return true;
+    }
+
+    @Override
+    public String getName() {
+        return "step";
+    }
+
+    @Override
+    public List<com.dfsek.terra.bukkit.command.Command> getSubCommands() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public int arguments() {
+        return 0;
+    }
+
+    @Override
+    public List<String> getTabCompletions(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) {
+        return Collections.emptyList();
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/profile/ProfileCommand.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/profile/ProfileCommand.java
@@ -0,0 +1,46 @@
+package com.dfsek.terra.bukkit.command.command.profile;
+
+import com.dfsek.terra.bukkit.BukkitCommandSender;
+import com.dfsek.terra.bukkit.command.WorldCommand;
+import com.dfsek.terra.config.lang.LangUtil;
+import org.bukkit.World;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+public class ProfileCommand extends WorldCommand {
+    public ProfileCommand(com.dfsek.terra.bukkit.command.Command parent) {
+        super(parent);
+    }
+
+    @Override
+    public boolean execute(@NotNull Player sender, @NotNull Command command, @NotNull String label, @NotNull String[] args, World w) {
+        LangUtil.send("command.profile.main-menu", new BukkitCommandSender(sender));
+        return true;
+    }
+
+    @Override
+    public String getName() {
+        return "profile";
+    }
+
+    @Override
+    public List<com.dfsek.terra.bukkit.command.Command> getSubCommands() {
+        return Arrays.asList(new QueryCommand(this), new ResetCommand(this), new StartCommand(this), new StopCommand(this));
+    }
+
+    @Override
+    public int arguments() {
+        return 1;
+    }
+
+    @Override
+    public List<String> getTabCompletions(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) {
+        return Collections.emptyList();
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/profile/QueryCommand.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/profile/QueryCommand.java
@@ -0,0 +1,46 @@
+package com.dfsek.terra.bukkit.command.command.profile;
+
+import com.dfsek.terra.api.gaea.profiler.WorldProfiler;
+import com.dfsek.terra.bukkit.BukkitWorld;
+import com.dfsek.terra.bukkit.command.WorldCommand;
+import org.bukkit.World;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collections;
+import java.util.List;
+
+public class QueryCommand extends WorldCommand {
+    public QueryCommand(com.dfsek.terra.bukkit.command.Command parent) {
+        super(parent);
+    }
+
+    @Override
+    public boolean execute(@NotNull Player sender, @NotNull Command command, @NotNull String label, @NotNull String[] args, World world) {
+        WorldProfiler profile = getMain().getWorld(new BukkitWorld(world)).getProfiler();
+        sender.sendMessage(profile.getResultsFormatted());
+        return true;
+    }
+
+    @Override
+    public String getName() {
+        return "query";
+    }
+
+    @Override
+    public List<com.dfsek.terra.bukkit.command.Command> getSubCommands() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public int arguments() {
+        return 0;
+    }
+
+    @Override
+    public List<String> getTabCompletions(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) {
+        return Collections.emptyList();
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/profile/ResetCommand.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/profile/ResetCommand.java
@@ -0,0 +1,49 @@
+package com.dfsek.terra.bukkit.command.command.profile;
+
+import com.dfsek.terra.api.gaea.profiler.WorldProfiler;
+import com.dfsek.terra.bukkit.BukkitCommandSender;
+import com.dfsek.terra.bukkit.BukkitWorld;
+import com.dfsek.terra.bukkit.command.WorldCommand;
+import com.dfsek.terra.config.lang.LangUtil;
+import org.bukkit.World;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collections;
+import java.util.List;
+
+public class ResetCommand extends WorldCommand {
+    public ResetCommand(com.dfsek.terra.bukkit.command.Command parent) {
+        super(parent);
+    }
+
+    @Override
+    public boolean execute(@NotNull Player sender, @NotNull Command command, @NotNull String label, @NotNull String[] args, World world) {
+        WorldProfiler profile = getMain().getWorld(new BukkitWorld(world)).getProfiler();
+        profile.reset();
+        LangUtil.send("command.profile.reset", new BukkitCommandSender(sender));
+        return true;
+    }
+
+    @Override
+    public String getName() {
+        return "reset";
+    }
+
+    @Override
+    public List<com.dfsek.terra.bukkit.command.Command> getSubCommands() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public int arguments() {
+        return 0;
+    }
+
+    @Override
+    public List<String> getTabCompletions(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) {
+        return Collections.emptyList();
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/profile/StartCommand.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/profile/StartCommand.java
@@ -0,0 +1,49 @@
+package com.dfsek.terra.bukkit.command.command.profile;
+
+import com.dfsek.terra.api.gaea.profiler.WorldProfiler;
+import com.dfsek.terra.bukkit.BukkitCommandSender;
+import com.dfsek.terra.bukkit.BukkitWorld;
+import com.dfsek.terra.bukkit.command.WorldCommand;
+import com.dfsek.terra.config.lang.LangUtil;
+import org.bukkit.World;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collections;
+import java.util.List;
+
+public class StartCommand extends WorldCommand {
+    public StartCommand(com.dfsek.terra.bukkit.command.Command parent) {
+        super(parent);
+    }
+
+    @Override
+    public boolean execute(@NotNull Player sender, @NotNull Command command, @NotNull String label, @NotNull String[] args, World world) {
+        WorldProfiler profile = getMain().getWorld(new BukkitWorld(world)).getProfiler();
+        profile.setProfiling(true);
+        LangUtil.send("command.profile.start", new BukkitCommandSender(sender));
+        return true;
+    }
+
+    @Override
+    public String getName() {
+        return "start";
+    }
+
+    @Override
+    public List<com.dfsek.terra.bukkit.command.Command> getSubCommands() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public int arguments() {
+        return 0;
+    }
+
+    @Override
+    public List<String> getTabCompletions(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) {
+        return Collections.emptyList();
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/profile/StopCommand.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/profile/StopCommand.java
@@ -0,0 +1,49 @@
+package com.dfsek.terra.bukkit.command.command.profile;
+
+import com.dfsek.terra.api.gaea.profiler.WorldProfiler;
+import com.dfsek.terra.bukkit.BukkitCommandSender;
+import com.dfsek.terra.bukkit.BukkitWorld;
+import com.dfsek.terra.bukkit.command.WorldCommand;
+import com.dfsek.terra.config.lang.LangUtil;
+import org.bukkit.World;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collections;
+import java.util.List;
+
+public class StopCommand extends WorldCommand {
+    public StopCommand(com.dfsek.terra.bukkit.command.Command parent) {
+        super(parent);
+    }
+
+    @Override
+    public boolean execute(@NotNull Player sender, @NotNull Command command, @NotNull String label, @NotNull String[] args, World world) {
+        WorldProfiler profile = getMain().getWorld(new BukkitWorld(world)).getProfiler();
+        profile.setProfiling(false);
+        LangUtil.send("command.profile.stop", new BukkitCommandSender(sender));
+        return true;
+    }
+
+    @Override
+    public String getName() {
+        return "stop";
+    }
+
+    @Override
+    public List<com.dfsek.terra.bukkit.command.Command> getSubCommands() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public int arguments() {
+        return 0;
+    }
+
+    @Override
+    public List<String> getTabCompletions(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) {
+        return Collections.emptyList();
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/structure/ExportCommand.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/structure/ExportCommand.java
@@ -0,0 +1,68 @@
+package com.dfsek.terra.bukkit.command.command.structure;
+
+import com.dfsek.terra.bukkit.command.PlayerCommand;
+import com.dfsek.terra.bukkit.structure.WorldEditUtil;
+import org.bukkit.Location;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collections;
+import java.util.List;
+
+public class ExportCommand extends PlayerCommand {
+    public ExportCommand(com.dfsek.terra.bukkit.command.Command parent) {
+        super(parent);
+    }
+
+    @Override
+    public boolean execute(@NotNull Player sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) {
+        Location[] l = WorldEditUtil.getSelectionLocations(sender);
+        /*if(l == null) return true;
+
+        Location l1 = l[0];
+        Location l2 = l[1];
+        Structure structure;
+        try {
+            structure = new Structure(l1, l2, args[0]);
+        } catch(InitializationException e) {
+            sender.sendMessage(e.getMessage());
+            return true;
+        }
+        try {
+            File file = new File(getMain().getDataFolder() + File.separator + "export" + File.separator + "structures", args[0] + ".tstructure");
+            //noinspection ResultOfMethodCallIgnored
+            file.getParentFile().mkdirs();
+            //noinspection ResultOfMethodCallIgnored
+            file.createNewFile();
+            structure.save(file);
+            LangUtil.send("command.structure.export", sender, file.getAbsolutePath());
+        } catch(IOException e) {
+            e.printStackTrace();
+        }
+
+         */
+        return true;
+    }
+
+    @Override
+    public String getName() {
+        return "export";
+    }
+
+    @Override
+    public List<com.dfsek.terra.bukkit.command.Command> getSubCommands() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public int arguments() {
+        return 1;
+    }
+
+    @Override
+    public List<String> getTabCompletions(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) {
+        return Collections.emptyList();
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/structure/LocateCommand.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/structure/LocateCommand.java
@@ -0,0 +1,90 @@
+package com.dfsek.terra.bukkit.command.command.structure;
+
+import com.dfsek.terra.bukkit.BukkitCommandSender;
+import com.dfsek.terra.bukkit.command.WorldCommand;
+import com.dfsek.terra.config.lang.LangUtil;
+import org.bukkit.World;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collections;
+import java.util.List;
+
+public class LocateCommand extends WorldCommand {
+    private final boolean tp;
+
+    public LocateCommand(com.dfsek.terra.bukkit.command.Command parent, boolean tp) {
+        super(parent);
+        this.tp = tp;
+    }
+
+    @SuppressWarnings("DuplicatedCode")
+    @Override
+    public boolean execute(@NotNull Player sender, @NotNull Command command, @NotNull String label, @NotNull String[] args, World world) {
+        String id = args[0];
+        int maxRadius;
+
+        try {
+            maxRadius = Integer.parseInt(args[1]);
+        } catch(NumberFormatException e) {
+            LangUtil.send("command.structure.invalid-radius", new BukkitCommandSender(sender), args[1]);
+            return true;
+        }
+        /*
+        TerraStructure s;
+        try {
+            s = Objects.requireNonNull(((TerraBukkitPlugin) getMain()).getWorld(world).getConfig().getStructure(id));
+        } catch(IllegalArgumentException | NullPointerException e) {
+            LangUtil.send("command.structure.invalid", sender, id);
+            return true;
+        }
+        Bukkit.getScheduler().runTaskAsynchronously(getMain(), new AsyncStructureFinder(((TerraBukkitPlugin) getMain()).getWorld(world).getGrid(), s, sender.getLocation(), 0, maxRadius, (location) -> {
+            if(sender.isOnline()) {
+                if(location != null) {
+                    ComponentBuilder cm = new ComponentBuilder(String.format("The nearest %s is at ", id.toLowerCase()))
+                            .append(String.format("[%d, ~, %d]", location.getBlockX(), location.getBlockZ()), ComponentBuilder.FormatRetention.NONE)
+                            .event(new ClickEvent(ClickEvent.Action.RUN_COMMAND, String.format("/minecraft:tp %s %d.0 %.2f %d.0", sender.getName(), location.getBlockX(), sender.getLocation().getY(), location.getBlockZ())))
+                            .event(new HoverEvent(HoverEvent.Action.SHOW_TEXT, new BaseComponent[] {new TextComponent("Click to teleport")}))
+                            .color(ChatColor.GREEN)
+                            .append(String.format(" (%.1f blocks away)", location.add(new Vector(0, sender.getLocation().getY(), 0)).distance(sender.getLocation().toVector())), ComponentBuilder.FormatRetention.NONE);
+                    sender.spigot().sendMessage(cm.create());
+                } else
+                    sender.sendMessage("Unable to locate structure. ");
+            }
+        }, (TerraBukkitPlugin) getMain()));
+
+         */
+        return true;
+    }
+
+    @Override
+    public String getName() {
+        return tp ? "teleport" : "locate";
+    }
+
+    @Override
+    public List<com.dfsek.terra.bukkit.command.Command> getSubCommands() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public int arguments() {
+        return 2;
+    }
+
+    @Override
+    public List<String> getTabCompletions(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) {
+        /*
+        if(!(sender instanceof Player) || !(((Player) sender).getWorld().getGenerator() instanceof TerraChunkGenerator))
+            return Collections.emptyList();
+
+        List<String> ids = ((TerraBukkitPlugin) getMain()).getWorld(((Player) sender).getWorld()).getConfig().getStructureIDs();
+        if(args.length == 1)
+            return ids.stream().filter(string -> string.toUpperCase().startsWith(args[0].toUpperCase())).collect(Collectors.toList());
+
+         */
+        return Collections.emptyList();
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/structure/SpawnCommand.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/structure/SpawnCommand.java
@@ -0,0 +1,56 @@
+package com.dfsek.terra.bukkit.command.command.structure;
+
+import com.dfsek.terra.bukkit.command.DebugCommand;
+import com.dfsek.terra.bukkit.command.WorldCommand;
+import org.bukkit.Location;
+import org.bukkit.World;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collections;
+import java.util.List;
+
+public class SpawnCommand extends WorldCommand implements DebugCommand {
+    public SpawnCommand(com.dfsek.terra.bukkit.command.Command parent) {
+        super(parent);
+    }
+
+    @Override
+    public boolean execute(@NotNull Player sender, @NotNull Command command, @NotNull String label, @NotNull String[] args, World world) {
+        Location p = sender.getLocation();
+        int x = p.getBlockX();
+        int y = p.getBlockY();
+        int z = p.getBlockZ();
+        /*
+        boolean air = StructureSpawnRequirement.AIR.getInstance(world, (TerraBukkitPlugin) getMain()).matches(x, y, z);
+        boolean ground = StructureSpawnRequirement.LAND.getInstance(world, (TerraBukkitPlugin) getMain()).matches(x, y, z);
+        boolean sea = StructureSpawnRequirement.OCEAN.getInstance(world, (TerraBukkitPlugin) getMain()).matches(x, y, z);
+
+        sender.sendMessage("AIR: " + air + "\nLAND: " + ground + "\nOCEAN: " + sea);
+
+         */
+        return true;
+    }
+
+    @Override
+    public String getName() {
+        return "spawn";
+    }
+
+    @Override
+    public List<com.dfsek.terra.bukkit.command.Command> getSubCommands() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public int arguments() {
+        return 0;
+    }
+
+    @Override
+    public List<String> getTabCompletions(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) {
+        return Collections.emptyList();
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/structure/StructureCommand.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/structure/StructureCommand.java
@@ -0,0 +1,46 @@
+package com.dfsek.terra.bukkit.command.command.structure;
+
+import com.dfsek.terra.bukkit.BukkitCommandSender;
+import com.dfsek.terra.bukkit.command.PlayerCommand;
+import com.dfsek.terra.bukkit.command.command.structure.load.LoadCommand;
+import com.dfsek.terra.config.lang.LangUtil;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+public class StructureCommand extends PlayerCommand {
+    public StructureCommand(com.dfsek.terra.bukkit.command.Command parent) {
+        super(parent);
+    }
+
+    @Override
+    public boolean execute(@NotNull Player sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) {
+        LangUtil.send("command.structure.main-menu", new BukkitCommandSender(sender));
+        return true;
+    }
+
+    @Override
+    public String getName() {
+        return "structure";
+    }
+
+    @Override
+    public List<com.dfsek.terra.bukkit.command.Command> getSubCommands() {
+        return Arrays.asList(new ExportCommand(this), new LoadCommand(this), new LocateCommand(this, false), new LocateCommand(this, true), new SpawnCommand(this));
+    }
+
+    @Override
+    public int arguments() {
+        return 0;
+    }
+
+    @Override
+    public List<String> getTabCompletions(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) {
+        return Collections.emptyList();
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/structure/load/LoadCommand.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/structure/load/LoadCommand.java
@@ -0,0 +1,61 @@
+package com.dfsek.terra.bukkit.command.command.structure.load;
+
+import com.dfsek.terra.bukkit.command.DebugCommand;
+import com.dfsek.terra.bukkit.command.PlayerCommand;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.io.File;
+import java.io.FilenameFilter;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+public class LoadCommand extends PlayerCommand implements DebugCommand {
+    public LoadCommand(com.dfsek.terra.bukkit.command.Command parent) {
+        super(parent);
+    }
+
+    public List<String> getStructureNames() {
+        List<String> names = new ArrayList<>();
+        File structureDir = new File(getMain().getDataFolder() + File.separator + "export" + File.separator + "structures");
+        if(!structureDir.exists()) return Collections.emptyList();
+        Path structurePath = structureDir.toPath();
+
+        FilenameFilter filter = (dir, name) -> name.endsWith(".tstructure");
+        for(File f : structureDir.listFiles(filter)) {
+            String path = structurePath.relativize(f.toPath()).toString();
+            names.add(path.substring(0, path.length() - 11));
+        }
+        return names;
+    }
+
+    @Override
+    public boolean execute(@NotNull Player sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) {
+        return true;
+    }
+
+    @Override
+    public String getName() {
+        return "load";
+    }
+
+    @Override
+    public List<com.dfsek.terra.bukkit.command.Command> getSubCommands() {
+        return Arrays.asList(new LoadRawCommand(this), new LoadFullCommand(this, true), new LoadFullCommand(this, false));
+    }
+
+    @Override
+    public List<String> getTabCompletions(@NotNull CommandSender sender, @NotNull String alias, @NotNull String[] args) {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public int arguments() {
+        return 0;
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/structure/load/LoadFullCommand.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/structure/load/LoadFullCommand.java
@@ -0,0 +1,71 @@
+package com.dfsek.terra.bukkit.command.command.structure.load;
+
+import com.dfsek.terra.bukkit.command.DebugCommand;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class LoadFullCommand extends LoadCommand implements DebugCommand {
+    private final boolean chunk;
+
+    public LoadFullCommand(com.dfsek.terra.bukkit.command.Command parent, boolean chunk) {
+        super(parent);
+        this.chunk = chunk;
+    }
+
+    @Override
+    public boolean execute(@NotNull Player sender, @NotNull Command command, @NotNull String s, @NotNull String[] args) {
+        /*
+        try {
+            Rotation r;
+            try {
+                r = Rotation.fromDegrees(Integer.parseInt(args[1]));
+            } catch(NumberFormatException e) {
+                LangUtil.send("command.structure.invalid-rotation", sender, args[1]);
+                return true;
+            }
+            Structure struc = Structure.load(new File(getMain().getDataFolder() + File.separator + "export" + File.separator + "structures", args[0] + ".tstructure"));
+            if(chunk) struc.paste(sender.getLocation(), sender.getLocation().getChunk(), r, (TerraBukkitPlugin) getMain());
+            else struc.paste(sender.getLocation(), r, (TerraBukkitPlugin) getMain());
+            //sender.sendMessage(String.valueOf(struc.checkSpawns(sender.getLocation(), r)));
+        } catch(IOException e) {
+            e.printStackTrace();
+            LangUtil.send("command.structure.invalid", sender, args[0]);
+        }
+
+         */
+        return true;
+    }
+
+    @Override
+    public String getName() {
+        return chunk ? "chunk" : "full";
+    }
+
+    @Override
+    public List<com.dfsek.terra.bukkit.command.Command> getSubCommands() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public int arguments() {
+        return 2;
+    }
+
+    @Override
+    public List<String> getTabCompletions(@NotNull CommandSender commandSender, @NotNull String s, @NotNull String[] args) {
+        switch(args.length) {
+            case 1:
+                return getStructureNames().stream().filter(string -> string.toUpperCase().startsWith(args[0].toUpperCase())).collect(Collectors.toList());
+            case 2:
+                return Stream.of("0", "90", "180", "270").filter(string -> string.toUpperCase().startsWith(args[1].toUpperCase())).collect(Collectors.toList());
+        }
+        return Collections.emptyList();
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/structure/load/LoadRawCommand.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/command/command/structure/load/LoadRawCommand.java
@@ -0,0 +1,108 @@
+package com.dfsek.terra.bukkit.command.command.structure.load;
+
+import com.dfsek.terra.bukkit.command.DebugCommand;
+import org.bukkit.block.Sign;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class LoadRawCommand extends LoadCommand implements DebugCommand {
+    public LoadRawCommand(com.dfsek.terra.bukkit.command.Command parent) {
+        super(parent);
+    }
+
+    private static void setTerraSign(Sign sign, String data) {
+        sign.setLine(0, "[TERRA]");
+        if(data.length() > 16) {
+            sign.setLine(2, data.substring(0, 16));
+            sign.setLine(3, data.substring(16));
+        } else sign.setLine(2, data);
+    }
+
+    @Override
+    public boolean execute(@NotNull Player sender, @NotNull Command command, @NotNull String s, @NotNull String[] args) {
+        /*
+        try {
+            WorldHandle handle = ((TerraBukkitPlugin) getMain()).getWorldHandle();
+            Structure struc = Structure.load(new File(getMain().getDataFolder() + File.separator + "export" + File.separator + "structures", args[0] + ".tstructure"));
+            StructureInfo info = struc.getStructureInfo();
+            int centerX = info.getCenterX();
+            int centerZ = info.getCenterZ();
+            for(StructureContainedBlock[][] level0 : struc.getRawStructure()) {
+                for(StructureContainedBlock[] level1 : level0) {
+                    for(StructureContainedBlock block : level1) {
+                        Location bLocation = sender.getLocation().add(block.getX() - centerX, block.getY(), block.getZ() - centerZ);
+                        if(!block.getPull().equals(StructureContainedBlock.Pull.NONE)) {
+                            handle.setBlockData(bLocation.getBlock(), Material.OAK_SIGN.createBlockData(), false);
+                            Sign sign = (Sign) bLocation.getBlock().getState();
+                            sign.setLine(1, "[PULL=" + block.getPull() + "_" + block.getPullOffset() + "]");
+                            String data = block.getBlockData().getAsString(true);
+                            setTerraSign(sign, data);
+                            sign.update();
+                        } else if(!block.getRequirement().equals(StructureSpawnRequirement.BLANK)) {
+                            handle.setBlockData(bLocation.getBlock(), Material.OAK_SIGN.createBlockData(), false);
+                            Sign sign = (Sign) bLocation.getBlock().getState();
+                            sign.setLine(1, "[SPAWN=" + block.getRequirement() + "]");
+                            String data = block.getBlockData().getAsString(true);
+                            setTerraSign(sign, data);
+                            sign.update();
+                        } else {
+                            handle.setBlockData(bLocation.getBlock(), block.getBlockData(), false);
+                            if(block.getState() != null) {
+                                block.getState().getState(bLocation.getBlock().getState()).update(true, false);
+                            }
+                        }
+                    }
+                }
+            }
+
+            for(int y = 0; y < struc.getStructureInfo().getSizeY(); y++) {
+                StructureContainedBlock block = struc.getRawStructure()[centerX][centerZ][y];
+                if(block.getRequirement().equals(StructureSpawnRequirement.BLANK) && block.getPull().equals(StructureContainedBlock.Pull.NONE)) {
+                    Location bLocation = sender.getLocation().add(block.getX() - centerX, block.getY(), block.getZ() - centerZ);
+                    handle.setBlockData(bLocation.getBlock(), Material.OAK_SIGN.createBlockData(), false);
+                    Sign sign = (Sign) bLocation.getBlock().getState();
+                    sign.setLine(1, "[CENTER]");
+                    String data = block.getBlockData().getAsString(true);
+                    setTerraSign(sign, data);
+                    sign.update();
+                    break;
+                }
+            }
+        } catch(IOException e) {
+            e.printStackTrace();
+            LangUtil.send("command.structure.invalid", sender, args[0]);
+        }
+
+         */
+        return true;
+    }
+
+    @Override
+    public String getName() {
+        return "raw";
+    }
+
+    @Override
+    public List<com.dfsek.terra.bukkit.command.Command> getSubCommands() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public int arguments() {
+        return 1;
+    }
+
+    @Override
+    public List<String> getTabCompletions(@NotNull CommandSender commandSender, @NotNull String s, @NotNull String[] args) {
+        if(args.length == 1) {
+            return getStructureNames().stream().filter(string -> string.toUpperCase().startsWith(args[0].toUpperCase())).collect(Collectors.toList());
+        }
+        return Collections.emptyList();
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/generator/BukkitChunkGenerator.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/generator/BukkitChunkGenerator.java
@@ -0,0 +1,101 @@
+package com.dfsek.terra.bukkit.generator;
+
+import com.dfsek.terra.api.generic.generator.BlockPopulator;
+import com.dfsek.terra.api.generic.generator.TerraChunkGenerator;
+import com.dfsek.terra.api.generic.world.BiomeGrid;
+import com.dfsek.terra.api.generic.world.World;
+import com.dfsek.terra.api.generic.world.block.BlockData;
+import com.dfsek.terra.bukkit.BukkitBiomeGrid;
+import com.dfsek.terra.bukkit.BukkitWorld;
+import com.dfsek.terra.bukkit.world.block.BukkitBlockData;
+import org.bukkit.generator.ChunkGenerator;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+import java.util.Random;
+import java.util.stream.Collectors;
+
+public class BukkitChunkGenerator implements com.dfsek.terra.api.generic.generator.ChunkGenerator {
+    private final ChunkGenerator delegate;
+
+    public BukkitChunkGenerator(ChunkGenerator delegate) {
+        this.delegate = delegate;
+    }
+
+    @Override
+    public ChunkGenerator getHandle() {
+        return delegate;
+    }
+
+    @Override
+    public boolean isParallelCapable() {
+        return delegate.isParallelCapable();
+    }
+
+    @Override
+    public boolean shouldGenerateCaves() {
+        return delegate.shouldGenerateCaves();
+    }
+
+    @Override
+    public boolean shouldGenerateDecorations() {
+        return delegate.shouldGenerateDecorations();
+    }
+
+    @Override
+    public boolean shouldGenerateMobs() {
+        return delegate.shouldGenerateMobs();
+    }
+
+    @Override
+    public boolean shouldGenerateStructures() {
+        return delegate.shouldGenerateStructures();
+    }
+
+    @Override
+    public ChunkData generateChunkData(@NotNull World world, @NotNull Random random, int x, int z, @NotNull BiomeGrid biome) {
+        return new BukkitChunkData(delegate.generateChunkData(((BukkitWorld) world).getHandle(), random, x, z, ((BukkitBiomeGrid) biome).getHandle()));
+    }
+
+    @Override
+    public List<BlockPopulator> getDefaultPopulators(World world) {
+        return delegate.getDefaultPopulators(((BukkitWorld) world).getHandle()).stream().map(BukkitPopulator::new).collect(Collectors.toList());
+    }
+
+    @Override
+    public @Nullable TerraChunkGenerator getTerraGenerator() {
+        return delegate instanceof BukkitChunkGeneratorWrapper ? ((BukkitChunkGeneratorWrapper) delegate).getHandle() : null;
+    }
+
+    public static class BukkitChunkData implements ChunkData {
+
+        private final ChunkGenerator.ChunkData delegate;
+
+        public BukkitChunkData(ChunkGenerator.ChunkData delegate) {
+            this.delegate = delegate;
+        }
+
+        @Override
+        public ChunkGenerator.ChunkData getHandle() {
+            return delegate;
+        }
+
+        @Override
+        public int getMaxHeight() {
+            return delegate.getMaxHeight();
+        }
+
+
+        @Override
+        public void setBlock(int x, int y, int z, @NotNull BlockData blockData) {
+            delegate.setBlock(x, y, z, ((BukkitBlockData) blockData).getHandle());
+        }
+
+
+        @Override
+        public @NotNull BlockData getBlockData(int x, int y, int z) {
+            return new BukkitBlockData(delegate.getBlockData(x, y, z));
+        }
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/generator/BukkitChunkGeneratorWrapper.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/generator/BukkitChunkGeneratorWrapper.java
@@ -0,0 +1,64 @@
+package com.dfsek.terra.bukkit.generator;
+
+import com.dfsek.terra.api.generic.Handle;
+import com.dfsek.terra.api.generic.generator.TerraChunkGenerator;
+import com.dfsek.terra.bukkit.BukkitBiomeGrid;
+import com.dfsek.terra.bukkit.BukkitWorld;
+import org.bukkit.World;
+import org.bukkit.generator.BlockPopulator;
+import org.bukkit.generator.ChunkGenerator;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+import java.util.Random;
+import java.util.stream.Collectors;
+
+public class BukkitChunkGeneratorWrapper extends ChunkGenerator implements Handle {
+    private final TerraChunkGenerator delegate;
+
+    public BukkitChunkGeneratorWrapper(TerraChunkGenerator delegate) {
+        this.delegate = delegate;
+    }
+
+    @Override
+    public @NotNull ChunkData generateChunkData(@NotNull World world, @NotNull Random random, int x, int z, @NotNull BiomeGrid biome) {
+        BukkitWorld bukkitWorld = new BukkitWorld(world);
+
+        return (ChunkData) delegate.generateChunkData(bukkitWorld, random, x, z, new BukkitBiomeGrid(biome), new BukkitChunkGenerator.BukkitChunkData(createChunkData(world))).getHandle();
+    }
+
+    @Override
+    public @NotNull List<BlockPopulator> getDefaultPopulators(@NotNull World world) {
+        return delegate.getPopulators().stream().map(BukkitPopulatorWrapper::new).collect(Collectors.toList());
+    }
+
+    @Override
+    public boolean isParallelCapable() {
+        return delegate.isParallelCapable();
+    }
+
+    @Override
+    public boolean shouldGenerateCaves() {
+        return delegate.shouldGenerateCaves();
+    }
+
+    @Override
+    public boolean shouldGenerateDecorations() {
+        return delegate.shouldGenerateDecorations();
+    }
+
+    @Override
+    public boolean shouldGenerateMobs() {
+        return delegate.shouldGenerateMobs();
+    }
+
+    @Override
+    public boolean shouldGenerateStructures() {
+        return super.shouldGenerateStructures();
+    }
+
+    @Override
+    public TerraChunkGenerator getHandle() {
+        return delegate;
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/generator/BukkitPopulator.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/generator/BukkitPopulator.java
@@ -0,0 +1,27 @@
+package com.dfsek.terra.bukkit.generator;
+
+import com.dfsek.terra.api.generic.generator.BlockPopulator;
+import com.dfsek.terra.api.generic.world.Chunk;
+import com.dfsek.terra.api.generic.world.World;
+import com.dfsek.terra.bukkit.BukkitChunk;
+import com.dfsek.terra.bukkit.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;
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/generator/BukkitPopulatorWrapper.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/generator/BukkitPopulatorWrapper.java
@@ -0,0 +1,24 @@
+package com.dfsek.terra.bukkit.generator;
+
+import com.dfsek.terra.api.generic.generator.TerraBlockPopulator;
+import com.dfsek.terra.bukkit.BukkitChunk;
+import com.dfsek.terra.bukkit.BukkitWorld;
+import org.bukkit.Chunk;
+import org.bukkit.World;
+import org.bukkit.generator.BlockPopulator;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Random;
+
+public class BukkitPopulatorWrapper extends BlockPopulator {
+    private final TerraBlockPopulator delegate;
+
+    public BukkitPopulatorWrapper(TerraBlockPopulator delegate) {
+        this.delegate = delegate;
+    }
+
+    @Override
+    public void populate(@NotNull World world, @NotNull Random random, @NotNull Chunk source) {
+        delegate.populate(new BukkitWorld(world), random, new BukkitChunk(source));
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/listeners/EventListener.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/listeners/EventListener.java
@@ -0,0 +1,41 @@
+package com.dfsek.terra.bukkit.listeners;
+
+import com.dfsek.terra.api.generic.TerraPlugin;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.world.StructureGrowEvent;
+
+/**
+ * Listener for events on all implementations.
+ */
+public class EventListener implements Listener {
+    private final TerraPlugin main;
+
+    public EventListener(TerraPlugin main) {
+        this.main = main;
+    }
+
+    @EventHandler
+    public void onSaplingGrow(StructureGrowEvent e) {
+        /*
+        World bukkit = new BukkitWorld(e.getWorld());
+        if(!TerraWorld.isTerraWorld(bukkit)) return;
+        TerraWorld tw = main.getWorld(bukkit);
+        ConfigPack c = tw.getConfig();
+        if(c.getTemplate().isDisableSaplings()) return;
+        e.setCancelled(true);
+        Block block = e.getLocation().getBlock();
+        BlockData data = block.getBlockData();
+        block.setType(Material.AIR);
+        TreeRegistry registry = c.getTreeRegistry();
+        Tree tree = registry.get(TreeType.fromBukkit(e.getSpecies()).toString());
+        Debug.info("Overriding tree type: " + e.getSpecies());
+        if(tree instanceof TerraTree) {
+            if(!((TerraTree) tree).plantBlockCheck(e.getLocation().subtract(0, 1, 0), new FastRandom(), main)) {
+                block.setBlockData(data);
+            }
+        } else if(!tree.plant(e.getLocation().subtract(0, 1, 0), new FastRandom(), main)) block.setBlockData(data);
+
+         */
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/listeners/PaperListener.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/listeners/PaperListener.java
@@ -0,0 +1,11 @@
+package com.dfsek.terra.bukkit.listeners;
+
+import org.bukkit.event.Listener;
+
+/**
+ * Placeholder, will be used once Paper accepts StructureLocateEvent PR.
+ */
+public class PaperListener implements Listener {
+
+
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/listeners/SpigotListener.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/listeners/SpigotListener.java
@@ -0,0 +1,59 @@
+package com.dfsek.terra.bukkit.listeners;
+
+import com.dfsek.terra.api.generic.TerraPlugin;
+import org.bukkit.event.Listener;
+
+/**
+ * Listener to load on Spigot servers, contains Villager crash prevention and hacky ender eye redirection.
+ * <p>
+ * (This is currently loaded on all servers; once Paper accepts the StructureLocateEvent PR this will only be loaded on servers without
+ * StructureLocateEvent).
+ */
+public class SpigotListener implements Listener {
+    private final TerraPlugin main;
+
+    public SpigotListener(TerraPlugin main) {
+        this.main = main;
+    }
+    /*
+
+    @EventHandler(priority = EventPriority.NORMAL)
+    public void onEnderEye(EntitySpawnEvent e) {
+        Entity entity = e.getEntity();
+        if(e.getEntityType().equals(EntityType.ENDER_SIGNAL)) {
+            Debug.info("Detected Ender Signal...");
+            if(!TerraWorld.isTerraWorld(e.getEntity().getWorld())) return;
+            TerraWorld tw = main.getWorld(e.getEntity().getWorld());
+            EnderSignal signal = (EnderSignal) entity;
+            TerraStructure config = tw.getConfig().getStructureLocatable(StructureTypeEnum.STRONGHOLD);
+            if(config != null) {
+                Debug.info("Overriding Ender Signal...");
+                AsyncStructureFinder finder = new AsyncStructureFinder(tw.getGrid(), config, e.getLocation(), 0, 500, location -> {
+                    if(location != null) signal.setTargetLocation(location.toLocation(signal.getWorld()));
+                    Debug.info("Location: " + location);
+                }, main);
+                finder.run(); // Do this synchronously so eye doesn't change direction several ticks after spawning.
+            } else
+                main.getLogger().warning("No overrides are defined for Strongholds. Ender Signals will not work correctly.");
+        }
+    }
+
+    @EventHandler
+    public void onCartographerChange(VillagerAcquireTradeEvent e) {
+        if(!TerraWorld.isTerraWorld(e.getEntity().getWorld())) return;
+        if(!(e.getEntity() instanceof Villager)) return;
+        if(((Villager) e.getEntity()).getProfession().equals(Villager.Profession.CARTOGRAPHER))
+            e.setCancelled(true); // Cancel leveling if the villager is a Cartographer, to prevent crashing server.
+    }
+
+    @EventHandler
+    public void onCartographerLevel(VillagerCareerChangeEvent e) {
+        if(!TerraWorld.isTerraWorld(e.getEntity().getWorld())) return;
+        if(e.getProfession().equals(Villager.Profession.CARTOGRAPHER)) {
+            e.getEntity().setProfession(Villager.Profession.NITWIT); // Give villager new profession to prevent server crash.
+            e.setCancelled(true);
+        }
+    }
+
+     */
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/structure/RotationUtil.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/structure/RotationUtil.java
@@ -0,0 +1,298 @@
+package com.dfsek.terra.bukkit.structure;
+
+import com.dfsek.terra.api.generic.world.block.Axis;
+import com.dfsek.terra.api.generic.world.block.BlockData;
+import com.dfsek.terra.api.generic.world.block.BlockFace;
+import com.dfsek.terra.api.generic.world.block.data.Directional;
+import com.dfsek.terra.api.generic.world.block.data.MultipleFacing;
+import com.dfsek.terra.api.generic.world.block.data.Orientable;
+import com.dfsek.terra.api.generic.world.block.data.Rail;
+import com.dfsek.terra.api.generic.world.block.data.RedstoneWire;
+import com.dfsek.terra.api.generic.world.block.data.Rotatable;
+import com.dfsek.terra.api.generic.world.block.data.Wall;
+import com.dfsek.terra.api.generic.world.vector.Vector2;
+import com.dfsek.terra.structure.Rotation;
+import net.jafama.FastMath;
+
+import java.util.EnumMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+public final class RotationUtil {
+    /**
+     * Rotate and mirror a coordinate pair.
+     *
+     * @param orig Vector to rotate.
+     * @param r    Rotation
+     * @return Rotated coordinate pair
+     */
+    public static Vector2 getRotatedCoords(Vector2 orig, Rotation r) {
+        Vector2 copy = orig.clone();
+        switch(r) {
+            case CW_90:
+                copy.setX(orig.getZ()).setZ(-orig.getX());
+                break;
+            case CCW_90:
+                copy.setX(-orig.getZ()).setZ(orig.getX());
+                break;
+            case CW_180:
+                copy.multiply(-1);
+                break;
+        }
+        return copy;
+    }
+
+    /**
+     * Get the BlockFace with rotation and mirrors applied to it
+     *
+     * @param f BlockFace to apply rotation to
+     * @param r Rotation
+     * @return Rotated BlockFace
+     */
+    public static BlockFace getRotatedFace(BlockFace f, Rotation r) {
+        BlockFace n = f;
+        int rotateNum = r.getDegrees() / 90;
+        int rn = faceRotation(f);
+        if(rn >= 0) {
+            n = fromRotation(faceRotation(n) + 4 * rotateNum);
+        }
+        return n;
+    }
+
+    /**
+     * Get an integer representation of a BlockFace, to perform math on.
+     *
+     * @param f BlockFace to get integer for
+     * @return integer representation of BlockFace
+     */
+    public static int faceRotation(BlockFace f) {
+        switch(f) {
+            case NORTH:
+                return 0;
+            case NORTH_NORTH_EAST:
+                return 1;
+            case NORTH_EAST:
+                return 2;
+            case EAST_NORTH_EAST:
+                return 3;
+            case EAST:
+                return 4;
+            case EAST_SOUTH_EAST:
+                return 5;
+            case SOUTH_EAST:
+                return 6;
+            case SOUTH_SOUTH_EAST:
+                return 7;
+            case SOUTH:
+                return 8;
+            case SOUTH_SOUTH_WEST:
+                return 9;
+            case SOUTH_WEST:
+                return 10;
+            case WEST_SOUTH_WEST:
+                return 11;
+            case WEST:
+                return 12;
+            case WEST_NORTH_WEST:
+                return 13;
+            case NORTH_WEST:
+                return 14;
+            case NORTH_NORTH_WEST:
+                return 15;
+            default:
+                return -1;
+        }
+    }
+
+    /**
+     * Convert integer to BlockFace representation
+     *
+     * @param r integer to get BlockFace for
+     * @return BlockFace represented by integer.
+     */
+    public static BlockFace fromRotation(int r) {
+        switch(FastMath.floorMod(r, 16)) {
+            case 0:
+                return BlockFace.NORTH;
+            case 1:
+                return BlockFace.NORTH_NORTH_EAST;
+            case 2:
+                return BlockFace.NORTH_EAST;
+            case 3:
+                return BlockFace.EAST_NORTH_EAST;
+            case 4:
+                return BlockFace.EAST;
+            case 5:
+                return BlockFace.EAST_SOUTH_EAST;
+            case 6:
+                return BlockFace.SOUTH_EAST;
+            case 7:
+                return BlockFace.SOUTH_SOUTH_EAST;
+            case 8:
+                return BlockFace.SOUTH;
+            case 9:
+                return BlockFace.SOUTH_SOUTH_WEST;
+            case 10:
+                return BlockFace.SOUTH_WEST;
+            case 11:
+                return BlockFace.WEST_SOUTH_WEST;
+            case 12:
+                return BlockFace.WEST;
+            case 13:
+                return BlockFace.WEST_NORTH_WEST;
+            case 14:
+                return BlockFace.NORTH_WEST;
+            case 15:
+                return BlockFace.NORTH_NORTH_WEST;
+            default:
+                throw new IllegalArgumentException();
+        }
+    }
+
+    public static Axis getRotatedAxis(Axis orig, Rotation r) {
+        Axis other = orig;
+        final boolean shouldSwitch = r.equals(Rotation.CW_90) || r.equals(Rotation.CCW_90);
+        switch(orig) {
+            case X:
+                if(shouldSwitch) other = Axis.Z;
+                break;
+            case Z:
+                if(shouldSwitch) other = Axis.X;
+                break;
+        }
+        return other;
+    }
+
+    /**
+     * Method to rotate the incredibly obnoxious Rail.Shape enum
+     *
+     * @param orig Original shape
+     * @param r    Rotate
+     * @return Rotated/mirrored shape
+     */
+    @SuppressWarnings("fallthrough")
+    public static Rail.Shape getRotatedRail(Rail.Shape orig, Rotation r) {
+        switch(r) {
+            case CCW_90:
+                switch(orig) {
+                    case NORTH_WEST:
+                        return Rail.Shape.SOUTH_WEST;
+                    case NORTH_SOUTH:
+                        return Rail.Shape.EAST_WEST;
+                    case SOUTH_WEST:
+                        return Rail.Shape.SOUTH_EAST;
+                    case SOUTH_EAST:
+                        return Rail.Shape.NORTH_EAST;
+                    case EAST_WEST:
+                        return Rail.Shape.NORTH_SOUTH;
+                    case NORTH_EAST:
+                        return Rail.Shape.NORTH_WEST;
+                    case ASCENDING_EAST:
+                        return Rail.Shape.ASCENDING_NORTH;
+                    case ASCENDING_WEST:
+                        return Rail.Shape.ASCENDING_SOUTH;
+                    case ASCENDING_NORTH:
+                        return Rail.Shape.ASCENDING_WEST;
+                    case ASCENDING_SOUTH:
+                        return Rail.Shape.ASCENDING_EAST;
+                }
+            case CW_90:
+                switch(orig) {
+                    case NORTH_WEST:
+                        return Rail.Shape.NORTH_EAST;
+                    case NORTH_SOUTH:
+                        return Rail.Shape.EAST_WEST;
+                    case SOUTH_WEST:
+                        return Rail.Shape.NORTH_WEST;
+                    case SOUTH_EAST:
+                        return Rail.Shape.SOUTH_WEST;
+                    case EAST_WEST:
+                        return Rail.Shape.NORTH_SOUTH;
+                    case NORTH_EAST:
+                        return Rail.Shape.SOUTH_EAST;
+                    case ASCENDING_EAST:
+                        return Rail.Shape.ASCENDING_SOUTH;
+                    case ASCENDING_WEST:
+                        return Rail.Shape.ASCENDING_NORTH;
+                    case ASCENDING_NORTH:
+                        return Rail.Shape.ASCENDING_EAST;
+                    case ASCENDING_SOUTH:
+                        return Rail.Shape.ASCENDING_WEST;
+                }
+            case CW_180:
+                switch(orig) {
+                    case NORTH_WEST:
+                        return Rail.Shape.SOUTH_EAST;
+                    case NORTH_SOUTH:
+                        return Rail.Shape.NORTH_SOUTH;
+                    case SOUTH_WEST:
+                        return Rail.Shape.NORTH_EAST;
+                    case SOUTH_EAST:
+                        return Rail.Shape.NORTH_WEST;
+                    case EAST_WEST:
+                        return Rail.Shape.EAST_WEST;
+                    case NORTH_EAST:
+                        return Rail.Shape.SOUTH_WEST;
+                    case ASCENDING_EAST:
+                        return Rail.Shape.ASCENDING_WEST;
+                    case ASCENDING_WEST:
+                        return Rail.Shape.ASCENDING_EAST;
+                    case ASCENDING_NORTH:
+                        return Rail.Shape.ASCENDING_SOUTH;
+                    case ASCENDING_SOUTH:
+                        return Rail.Shape.ASCENDING_NORTH;
+                }
+        }
+        return orig;
+    }
+
+    private static final Set<BlockFace> CARDINALS = new HashSet<>();
+    static {
+        CARDINALS.add(BlockFace.NORTH);
+        CARDINALS.add(BlockFace.SOUTH);
+        CARDINALS.add(BlockFace.EAST);
+        CARDINALS.add(BlockFace.WEST);
+    }
+
+    public static void rotateBlockData(BlockData data, Rotation r) {
+        if(data instanceof Rotatable) {
+            BlockFace rt = getRotatedFace(((Rotatable) data).getRotation(), r);
+            ((Rotatable) data).setRotation(rt);
+        } else if(data instanceof Directional) {
+            BlockFace rt = getRotatedFace(((Directional) data).getFacing(), r);
+            ((Directional) data).setFacing(rt);
+        } else if(data instanceof MultipleFacing) {
+            MultipleFacing mfData = (MultipleFacing) data;
+            Map<BlockFace, Boolean> faces = new EnumMap<>(BlockFace.class);
+            for(BlockFace f : mfData.getAllowedFaces()) {
+                faces.put(f, mfData.hasFace(f));
+            }
+            for(Map.Entry<BlockFace, Boolean> face : faces.entrySet()) {
+                mfData.setFace(getRotatedFace(face.getKey(), r), face.getValue());
+            }
+        } else if(data instanceof Rail) {
+            Rail.Shape newShape = getRotatedRail(((Rail) data).getShape(), r);
+            ((Rail) data).setShape(newShape);
+        } else if(data instanceof Orientable) {
+            Axis newAxis = getRotatedAxis(((Orientable) data).getAxis(), r);
+            ((Orientable) data).setAxis(newAxis);
+        } else if(data instanceof RedstoneWire) {
+            Map<BlockFace, RedstoneWire.Connection> connections = new EnumMap<>(BlockFace.class);
+            RedstoneWire rData = (RedstoneWire) data;
+            for(BlockFace f : rData.getAllowedFaces()) {
+                connections.put(f, rData.getFace(f));
+            }
+            for(Map.Entry<BlockFace, RedstoneWire.Connection> e : connections.entrySet()) {
+                rData.setFace(getRotatedFace(e.getKey(), r), e.getValue());
+            }
+        } else if(data instanceof Wall) {
+            Wall wallData = (Wall) data;
+            Map<BlockFace, Wall.Height> faces = new EnumMap<>(BlockFace.class);
+            for(BlockFace b : CARDINALS) faces.put(b, wallData.getHeight(b));
+            for(Map.Entry<BlockFace, Wall.Height> face : faces.entrySet()) {
+                wallData.setHeight(getRotatedFace(face.getKey(), r), face.getValue());
+            }
+        }
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/structure/WorldEditNotFoundException.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/structure/WorldEditNotFoundException.java
@@ -0,0 +1,22 @@
+package com.dfsek.terra.bukkit.structure;
+
+public class WorldEditNotFoundException extends RuntimeException {
+    public WorldEditNotFoundException() {
+    }
+
+    public WorldEditNotFoundException(String message) {
+        super(message);
+    }
+
+    public WorldEditNotFoundException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    public WorldEditNotFoundException(Throwable cause) {
+        super(cause);
+    }
+
+    public WorldEditNotFoundException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
+        super(message, cause, enableSuppression, writableStackTrace);
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/structure/WorldEditUtil.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/structure/WorldEditUtil.java
@@ -0,0 +1,81 @@
+package com.dfsek.terra.bukkit.structure;
+
+import com.sk89q.worldedit.IncompleteRegionException;
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
+import com.sk89q.worldedit.bukkit.WorldEditPlugin;
+import com.sk89q.worldedit.math.BlockVector3;
+import com.sk89q.worldedit.regions.CuboidRegion;
+import com.sk89q.worldedit.regions.Region;
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.Plugin;
+import org.jetbrains.annotations.NotNull;
+
+public final class WorldEditUtil {
+    public static Location[] getSelectionLocations(Player sender) {
+        WorldEditPlugin we;
+        try {
+            we = WorldEditUtil.getWorldEdit();
+        } catch(WorldEditNotFoundException e) {
+            sender.sendMessage("WorldEdit is not installed! Please install WorldEdit before attempting to export structures.");
+            throw e;
+        }
+        Region selection;
+        try {
+            selection = we.getSession(sender).getSelection(BukkitAdapter.adapt(sender.getWorld()));
+        } catch(IncompleteRegionException | ClassCastException e) {
+            sender.sendMessage("Invalid/incomplete selection!");
+            return null;
+        }
+        if(selection == null) {
+            sender.sendMessage("Please make a selection before attempting to export!");
+            return null;
+        }
+        BlockVector3 min = selection.getMinimumPoint();
+        BlockVector3 max = selection.getMaximumPoint();
+        Location l1 = new Location(sender.getWorld(), min.getBlockX(), min.getBlockY(), min.getBlockZ());
+        Location l2 = new Location(sender.getWorld(), max.getBlockX(), max.getBlockY(), max.getBlockZ());
+        return new Location[] {l1, l2};
+    }
+
+    /**
+     * Gets an instance of the WorldEditPlugin class.
+     *
+     * @return The world edit plugin instance.
+     * @throws WorldEditNotFoundException Thrown when worldedit cannot be found.
+     */
+    @NotNull
+    public static WorldEditPlugin getWorldEdit() {
+        Plugin p = Bukkit.getServer().getPluginManager().getPlugin("WorldEdit");
+        if(p instanceof WorldEditPlugin) return (WorldEditPlugin) p;
+        Bukkit.getLogger().severe("[Terra] a command requiring WorldEdit was executed, but WorldEdit was not detected!");
+        throw new WorldEditNotFoundException("Could not find World Edit!");
+    }
+
+    public static Location[] getSelectionPositions(Player sender) {
+        WorldEditPlugin we;
+        try {
+            we = WorldEditUtil.getWorldEdit();
+        } catch(WorldEditNotFoundException e) {
+            sender.sendMessage("WorldEdit is not installed! Please install WorldEdit before attempting to export structures.");
+            throw e;
+        }
+        CuboidRegion selection;
+        try {
+            selection = (CuboidRegion) we.getSession(sender).getSelection(BukkitAdapter.adapt(sender.getWorld()));
+        } catch(IncompleteRegionException | ClassCastException e) {
+            sender.sendMessage("Invalid/incomplete selection!");
+            return null;
+        }
+        if(selection == null) {
+            sender.sendMessage("Please make a selection before attempting to export!");
+            return null;
+        }
+        BlockVector3 min = selection.getPos1();
+        BlockVector3 max = selection.getPos2();
+        Location l1 = new Location(sender.getWorld(), min.getBlockX(), min.getBlockY(), min.getBlockZ());
+        Location l2 = new Location(sender.getWorld(), max.getBlockX(), max.getBlockY(), max.getBlockZ());
+        return new Location[] {l1, l2};
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/util/BukkitConversions.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/util/BukkitConversions.java
@@ -0,0 +1,10 @@
+package com.dfsek.terra.bukkit.util;
+
+import com.dfsek.terra.api.generic.world.vector.Vector3;
+import org.bukkit.util.Vector;
+
+public final class BukkitConversions {
+    public static Vector3 toTerraVector(Vector bukkit) {
+        return new Vector3(bukkit.getX(), bukkit.getY(), bukkit.getZ());
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/util/PaperUtil.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/util/PaperUtil.java
@@ -0,0 +1,17 @@
+package com.dfsek.terra.bukkit.util;
+
+import io.papermc.lib.PaperLib;
+import org.bukkit.Bukkit;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import static io.papermc.lib.PaperLib.suggestPaper;
+
+public final class PaperUtil {
+    public static void checkPaper(JavaPlugin main) {
+        Bukkit.getScheduler().scheduleSyncDelayedTask(main, () -> {
+            if(!PaperLib.isPaper()) {
+                suggestPaper(main);
+            }
+        }, 100L);
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/world/BukkitBiome.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/world/BukkitBiome.java
@@ -0,0 +1,16 @@
+package com.dfsek.terra.bukkit.world;
+
+import com.dfsek.terra.api.generic.world.Biome;
+
+public class BukkitBiome implements Biome {
+    private final org.bukkit.block.Biome biome;
+
+    public BukkitBiome(org.bukkit.block.Biome biome) {
+        this.biome = biome;
+    }
+
+    @Override
+    public org.bukkit.block.Biome getHandle() {
+        return biome;
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/world/block/BukkitBlock.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/world/block/BukkitBlock.java
@@ -0,0 +1,77 @@
+package com.dfsek.terra.bukkit.world.block;
+
+import com.dfsek.terra.api.generic.world.block.Block;
+import com.dfsek.terra.api.generic.world.block.BlockData;
+import com.dfsek.terra.api.generic.world.block.BlockFace;
+import com.dfsek.terra.api.generic.world.block.MaterialData;
+import com.dfsek.terra.api.generic.world.vector.Location;
+import com.dfsek.terra.bukkit.BukkitWorld;
+import com.dfsek.terra.bukkit.world.block.data.TerraEnumAdapter;
+
+public class BukkitBlock implements Block {
+    private final org.bukkit.block.Block delegate;
+
+    public BukkitBlock(org.bukkit.block.Block delegate) {
+        this.delegate = delegate;
+    }
+
+    @Override
+    public void setBlockData(BlockData data, boolean physics) {
+        delegate.setBlockData(((BukkitBlockData) data).getHandle(), physics);
+    }
+
+    @Override
+    public BlockData getBlockData() {
+        return new BukkitBlockData(delegate.getBlockData());
+    }
+
+    @Override
+    public Block getRelative(BlockFace face) {
+        return new BukkitBlock(delegate.getRelative(TerraEnumAdapter.fromTerraBlockFace(face)));
+    }
+
+    @Override
+    public Block getRelative(BlockFace face, int len) {
+        return new BukkitBlock(delegate.getRelative(TerraEnumAdapter.fromTerraBlockFace(face), len));
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return delegate.isEmpty();
+    }
+
+    @Override
+    public Location getLocation() {
+        return new Location(new BukkitWorld(delegate.getWorld()), delegate.getX(), delegate.getY(), delegate.getZ());
+    }
+
+    @Override
+    public MaterialData getType() {
+        return new BukkitMaterialData(delegate.getType());
+    }
+
+    @Override
+    public int getX() {
+        return delegate.getX();
+    }
+
+    @Override
+    public int getZ() {
+        return delegate.getZ();
+    }
+
+    @Override
+    public int getY() {
+        return delegate.getY();
+    }
+
+    @Override
+    public boolean isPassable() {
+        return delegate.isPassable();
+    }
+
+    @Override
+    public Object getHandle() {
+        return delegate;
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/world/block/BukkitBlockData.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/world/block/BukkitBlockData.java
@@ -0,0 +1,37 @@
+package com.dfsek.terra.bukkit.world.block;
+
+import com.dfsek.terra.api.generic.world.block.BlockData;
+import com.dfsek.terra.api.generic.world.block.MaterialData;
+
+public class BukkitBlockData implements BlockData {
+    private final org.bukkit.block.data.BlockData delegate;
+
+    public BukkitBlockData(org.bukkit.block.data.BlockData delegate) {
+        this.delegate = delegate;
+    }
+
+
+    @Override
+    public org.bukkit.block.data.BlockData getHandle() {
+        return delegate;
+    }
+
+    @Override
+    public MaterialData getMaterial() {
+        return new BukkitMaterialData(delegate.getMaterial());
+    }
+
+    @Override
+    public boolean matches(MaterialData materialData) {
+        return delegate.getMaterial().equals(((BukkitMaterialData) materialData).getHandle());
+    }
+
+    @Override
+    public BukkitBlockData clone() {
+        try {
+            return (BukkitBlockData) super.clone();
+        } catch(CloneNotSupportedException e) {
+            throw new Error(e);
+        }
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/world/block/BukkitMaterialData.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/world/block/BukkitMaterialData.java
@@ -0,0 +1,56 @@
+package com.dfsek.terra.bukkit.world.block;
+
+import com.dfsek.terra.api.generic.world.block.BlockData;
+import com.dfsek.terra.api.generic.world.block.MaterialData;
+import org.bukkit.Material;
+
+public class BukkitMaterialData implements MaterialData {
+    private final Material delegate;
+
+    public BukkitMaterialData(Material delegate) {
+        this.delegate = delegate;
+    }
+
+    @Override
+    public boolean matches(MaterialData other) {
+        return ((BukkitMaterialData) other).getHandle().equals(delegate);
+    }
+
+    @Override
+    public boolean matches(BlockData other) {
+        return ((BukkitMaterialData) other.getMaterial()).getHandle().equals(delegate);
+    }
+
+    @Override
+    public boolean isSolid() {
+        return delegate.isSolid();
+    }
+
+    @Override
+    public boolean isAir() {
+        return delegate.isAir();
+    }
+
+    @Override
+    public double getMaxDurability() {
+        return delegate.getMaxDurability();
+    }
+
+    @Override
+    public Material getHandle() {
+        return delegate;
+    }
+
+    @Override
+    public int hashCode() {
+        return delegate.hashCode();
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if(!(obj instanceof BukkitMaterialData)) return false;
+        BukkitMaterialData other = (BukkitMaterialData) obj;
+
+        return other.getHandle().equals(this.delegate);
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/world/block/data/BukkitEnumAdapter.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/world/block/data/BukkitEnumAdapter.java
@@ -0,0 +1,82 @@
+package com.dfsek.terra.bukkit.world.block.data;
+
+
+import com.dfsek.terra.api.generic.world.block.BlockFace;
+import com.dfsek.terra.api.generic.world.block.data.Bisected;
+import com.dfsek.terra.api.generic.world.block.data.Stairs;
+
+public final class BukkitEnumAdapter {
+    public static Stairs.Shape fromBukkitStair(org.bukkit.block.data.type.Stairs.Shape shape) {
+        switch(shape) {
+            case STRAIGHT:
+                return Stairs.Shape.STRAIGHT;
+            case INNER_LEFT:
+                return Stairs.Shape.INNER_LEFT;
+            case OUTER_LEFT:
+                return Stairs.Shape.OUTER_LEFT;
+            case INNER_RIGHT:
+                return Stairs.Shape.INNER_RIGHT;
+            case OUTER_RIGHT:
+                return Stairs.Shape.OUTER_RIGHT;
+            default:
+                throw new IllegalStateException();
+        }
+    }
+
+    public static Bisected.Half fromBukkitHalf(org.bukkit.block.data.Bisected.Half half) {
+        switch(half) {
+            case BOTTOM:
+                return Bisected.Half.BOTTOM;
+            case TOP:
+                return Bisected.Half.TOP;
+            default:
+                throw new IllegalStateException();
+        }
+    }
+
+    public static BlockFace fromBukkitBlockFace(org.bukkit.block.BlockFace face) {
+        switch(face) {
+            case DOWN:
+                return BlockFace.DOWN;
+            case UP:
+                return BlockFace.UP;
+            case NORTH_WEST:
+                return BlockFace.NORTH_WEST;
+            case NORTH_EAST:
+                return BlockFace.NORTH_EAST;
+            case SOUTH_EAST:
+                return BlockFace.SOUTH_EAST;
+            case SOUTH_WEST:
+                return BlockFace.SOUTH_WEST;
+            case NORTH_NORTH_WEST:
+                return BlockFace.NORTH_NORTH_WEST;
+            case WEST_NORTH_WEST:
+                return BlockFace.WEST_NORTH_WEST;
+            case WEST_SOUTH_WEST:
+                return BlockFace.WEST_SOUTH_WEST;
+            case SOUTH_SOUTH_WEST:
+                return BlockFace.SOUTH_SOUTH_WEST;
+            case EAST_NORTH_EAST:
+                return BlockFace.EAST_NORTH_EAST;
+            case WEST:
+                return BlockFace.WEST;
+            case SOUTH:
+                return BlockFace.SOUTH;
+            case EAST:
+                return BlockFace.EAST;
+            case NORTH:
+                return BlockFace.NORTH;
+            case SELF:
+                return BlockFace.SELF;
+            case EAST_SOUTH_EAST:
+                return BlockFace.EAST_SOUTH_EAST;
+            case NORTH_NORTH_EAST:
+                return BlockFace.NORTH_NORTH_EAST;
+            case SOUTH_SOUTH_EAST:
+                return BlockFace.SOUTH_SOUTH_EAST;
+            default:
+                throw new IllegalStateException();
+        }
+    }
+
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/world/block/data/BukkitStairs.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/world/block/data/BukkitStairs.java
@@ -0,0 +1,55 @@
+package com.dfsek.terra.bukkit.world.block.data;
+
+import com.dfsek.terra.api.generic.world.block.BlockFace;
+import com.dfsek.terra.api.generic.world.block.data.Stairs;
+import com.dfsek.terra.bukkit.world.block.BukkitBlockData;
+import org.bukkit.block.data.BlockData;
+
+public class BukkitStairs extends BukkitBlockData implements Stairs {
+    private final org.bukkit.block.data.type.Stairs stairs;
+
+    public BukkitStairs(BlockData delegate) {
+        super(delegate);
+        this.stairs = (org.bukkit.block.data.type.Stairs) delegate;
+    }
+
+    @Override
+    public Shape getShape() {
+        return BukkitEnumAdapter.fromBukkitStair(stairs.getShape());
+    }
+
+    @Override
+    public void setShape(Shape shape) {
+        stairs.setShape(TerraEnumAdapter.fromTerraStair(shape));
+    }
+
+    @Override
+    public Half getHalf() {
+        return BukkitEnumAdapter.fromBukkitHalf(stairs.getHalf());
+    }
+
+    @Override
+    public void setHalf(Half half) {
+        stairs.setHalf(TerraEnumAdapter.fromTerraHalf(half));
+    }
+
+    @Override
+    public BlockFace getFacing() {
+        return BukkitEnumAdapter.fromBukkitBlockFace(stairs.getFacing());
+    }
+
+    @Override
+    public void setFacing(BlockFace facing) {
+        stairs.setFacing(TerraEnumAdapter.fromTerraBlockFace(facing));
+    }
+
+    @Override
+    public boolean isWaterlogged() {
+        return stairs.isWaterlogged();
+    }
+
+    @Override
+    public void setWaterlogged(boolean waterlogged) {
+        stairs.setWaterlogged(waterlogged);
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/world/block/data/BukkitWaterlogged.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/world/block/data/BukkitWaterlogged.java
@@ -0,0 +1,23 @@
+package com.dfsek.terra.bukkit.world.block.data;
+
+import com.dfsek.terra.api.generic.world.block.data.Waterlogged;
+import com.dfsek.terra.bukkit.world.block.BukkitBlockData;
+import org.bukkit.block.data.BlockData;
+
+public class BukkitWaterlogged extends BukkitBlockData implements Waterlogged {
+    private boolean waterlogged;
+
+    public BukkitWaterlogged(BlockData delegate) {
+        super(delegate);
+    }
+
+    @Override
+    public boolean isWaterlogged() {
+        return waterlogged;
+    }
+
+    @Override
+    public void setWaterlogged(boolean waterlogged) {
+        this.waterlogged = waterlogged;
+    }
+}
--- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/world/block/data/TerraEnumAdapter.java
+++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/world/block/data/TerraEnumAdapter.java
@@ -0,0 +1,81 @@
+package com.dfsek.terra.bukkit.world.block.data;
+
+
+import com.dfsek.terra.api.generic.world.block.BlockFace;
+import org.bukkit.block.data.Bisected;
+import org.bukkit.block.data.type.Stairs;
+
+public final class TerraEnumAdapter {
+    public static Stairs.Shape fromTerraStair(com.dfsek.terra.api.generic.world.block.data.Stairs.Shape shape) {
+        switch(shape) {
+            case STRAIGHT:
+                return Stairs.Shape.STRAIGHT;
+            case INNER_LEFT:
+                return Stairs.Shape.INNER_LEFT;
+            case OUTER_LEFT:
+                return Stairs.Shape.OUTER_LEFT;
+            case INNER_RIGHT:
+                return Stairs.Shape.INNER_RIGHT;
+            case OUTER_RIGHT:
+                return Stairs.Shape.OUTER_RIGHT;
+            default:
+                throw new IllegalStateException();
+        }
+    }
+
+    public static Bisected.Half fromTerraHalf(com.dfsek.terra.api.generic.world.block.data.Bisected.Half half) {
+        switch(half) {
+            case TOP:
+                return Bisected.Half.TOP;
+            case BOTTOM:
+                return Bisected.Half.BOTTOM;
+            default:
+                throw new IllegalStateException();
+        }
+    }
+
+    public static org.bukkit.block.BlockFace fromTerraBlockFace(BlockFace face) {
+        switch(face) {
+            case DOWN:
+                return org.bukkit.block.BlockFace.DOWN;
+            case UP:
+                return org.bukkit.block.BlockFace.UP;
+            case NORTH_WEST:
+                return org.bukkit.block.BlockFace.NORTH_WEST;
+            case NORTH_EAST:
+                return org.bukkit.block.BlockFace.NORTH_EAST;
+            case SOUTH_EAST:
+                return org.bukkit.block.BlockFace.SOUTH_EAST;
+            case SOUTH_WEST:
+                return org.bukkit.block.BlockFace.SOUTH_WEST;
+            case NORTH_NORTH_WEST:
+                return org.bukkit.block.BlockFace.NORTH_NORTH_WEST;
+            case WEST_NORTH_WEST:
+                return org.bukkit.block.BlockFace.WEST_NORTH_WEST;
+            case WEST_SOUTH_WEST:
+                return org.bukkit.block.BlockFace.WEST_SOUTH_WEST;
+            case SOUTH_SOUTH_WEST:
+                return org.bukkit.block.BlockFace.SOUTH_SOUTH_WEST;
+            case EAST_NORTH_EAST:
+                return org.bukkit.block.BlockFace.EAST_NORTH_EAST;
+            case WEST:
+                return org.bukkit.block.BlockFace.WEST;
+            case SOUTH:
+                return org.bukkit.block.BlockFace.SOUTH;
+            case EAST:
+                return org.bukkit.block.BlockFace.EAST;
+            case NORTH:
+                return org.bukkit.block.BlockFace.NORTH;
+            case SELF:
+                return org.bukkit.block.BlockFace.SELF;
+            case EAST_SOUTH_EAST:
+                return org.bukkit.block.BlockFace.EAST_SOUTH_EAST;
+            case NORTH_NORTH_EAST:
+                return org.bukkit.block.BlockFace.NORTH_NORTH_EAST;
+            case SOUTH_SOUTH_EAST:
+                return org.bukkit.block.BlockFace.SOUTH_SOUTH_EAST;
+            default:
+                throw new IllegalStateException();
+        }
+    }
+}
--- a/platforms/bukkit/src/main/resources/config.yml
+++ b/platforms/bukkit/src/main/resources/config.yml
@@ -0,0 +1,9 @@
+debug: false
+data-save: PT6M
+language: "en_us"
+fail-type: SHUTDOWN
+dump-default: true
+biome-search-resolution: 4
+cache-size: 384
+master-disable:
+  caves: false
--- a/platforms/bukkit/src/main/resources/lang/afr_sa.yml
+++ b/platforms/bukkit/src/main/resources/lang/afr_sa.yml
@@ -0,0 +1,117 @@
+enable:
+  - "As u van Terra hou, oorweeg dit om die projek op Patreon te ondersteun!"
+  - "U kry toegang tot eksperimentele funksies voordat dit vrygestel word!"
+  - "Ondersteun die projek hier: https://www.patreon.com/dfsek"
+disable:
+  - "Dankie dat u Terra gebruik!"
+command:
+  debug-only: "Hierdie opdrag moet gebruik word as die ontfoutmodus geaktiveer is!"
+  player-only: "Hierdie opdrag is slegs vir spelers!"
+  invalid: "Ongeldige opdrag.(verwag %1$s argumente, argumente gevind is %2$s)."
+  players-only: "Hierdie opdrag is slegs vir spelers."
+  world: "This command must be executed in a Terra world!"
+  reload: "Terra instel herlaai"
+  version: "Hierdie bediener gebruik die Terra-weergawe \"%s\""
+  main-menu:
+    - "--------------------Terra--------------------"
+    - "Herlaai    - Herlaai konfigurasiedata"
+    - "bioom      - Kry huidige bioom"
+    - "erts       - Genereer 'n ertsader op die plek waar u te staan kom (vir foutopsporing)"
+    - "stoor-data - Stoor bevolkingsdata"
+    - "struktuur  - Laai en stoor strukture"
+    - "profiel    - Profielopsies"
+    - "beeld      - Beeld / GUI-opsies"
+  biome:
+    biome-found: "Bioom geleë te (%1$s, %2$s)"
+    unable-to-locate: "Kan bioom nie opspoor nie."
+    invalid-radius: "Ongeldige radius: \"%s\""
+    invalid: "Ongeldige Biome-ID: \"%s\""
+    in: "Jy is in \"%s\""
+  ore:
+    main-menu:
+      - "---------------Terra/erts---------------"
+      - "Genereer 'n ertsader by die blok waarna u kyk."
+    out-of-range: "Blok buite bereik"
+    invalid-ore: "Kan nie Erts vind nie \"%s\""
+  geometry:
+    main-menu:
+      - "---------------Terra/meetkunde----------------"
+      - "Verskeie opsporingsopdragte vir voxel-meetkunde"
+      - "sfeer        - Genereer 'n sfeer"
+      - "vervorming   - Genereer 'n misvormde sfeer"
+      - "tube         - Genereer 'n tube"
+    deform:
+      invalid-radius: "Ongeldige radius: \"%s\""
+      invalid-deform: "Ongeldige vervorm: \"%s\""
+      invalid-frequency: "Ongeldige frekwensie: \"%s\""
+    sphere:
+      invalid-radius: "Ongeldige radius: \"%s\""
+    tube:
+      invalid-radius: "Ongeldige radius: \"%s\""
+  image:
+    main-menu:
+      - "---------------Terra/beeld---------------"
+      - "weergee - gee 'n beeld met 'n gegewe breedte en hoogte, wat later as 'n wêreld ingevoer kan word."
+      - "gui     - Open debug GUI (moet in config geaktiveer word)"
+    gui:
+      main-menu:
+        - "-------------Terra/beeld/gui-------------"
+        - "rou  - Open GUI met rou bioom-data"
+        - "stap - Gee data weer om die grense duideliker aan te dui"
+      debug: "Ontfoutmodus moet geaktiveer wees om die ontfout-GUI te gebruik! Die foutopsporing-GUI is NIE PRODUKSIEVEILIG NIE!"
+    render:
+      save: "Beeld gestoor as \"%s\""
+      error: "Vout ondervind terwel die prent besig was om te genereer!"
+  profile:
+    main-menu:
+      - "---------------Terra/profiel---------------"
+      - "begin   - Begin die profiel"
+      - "stop    - stop die profiel"
+      - "navraag - Haal profiele-data op"
+      - "reset   - Stel profieldata terug"
+    reset: "Profiler is teruggestel."
+    start: "Profiler het begin."
+    stop: "Profiler het opgehou."
+  structure:
+    main-menu:
+      - "---------------Terra/struktuur---------------"
+      - "uitvoer - voer u huidige WorldEdit-keuse uit as 'n Terra-struktuur."
+      - "laai - Laai 'n Terra-struktuur"
+    invalid-radius: "Ongeldig radius: \"%s\""
+    invalid-rotation: "Ongeldige rotasie: \"%s\""
+    invalid: "Ongeldig Struktuur ID: \"%s\""
+    export: "struktuur gestoor na \"%s\""
+world-config:
+  loading: "Laai wêreldkonfigurasiewaardes vir wêreld %s..."
+  not-found: "Konfigurasie vir wêreld \"%s\" nie gevind nie. Kopieer standaardinstelling."
+  using-image: "Laai wêreld vanaf prent."
+  error: "Kon nie konfigurasie vir wêreld laai nie %s"
+  done: "Wêreldlading voltooi. Tyd verloop: %sms"
+config-pack:
+  loaded: "Laai konfigurasie %1$s in %2$sms."
+config:
+  loaded: "Laai %1$s vanaf %2$s"
+  loaded-all: "%1$s %2$s(s) gelaai in %3$sms."
+  error:
+    invalid-failover: "Ongeldige failover-tipe: \"%s\""
+    duplicate: "Duplikaat-ID gevind in lêer: %s"
+    file:
+      - "Konfigurasiefout vir Terra-voorwerp. lêer: %1$s"
+      - "%2$s"
+      - "Stel dit reg voordat u verder gaan!"
+    generic:
+      - "Kon nie konfigurasies laai nie."
+      - "Rapporteer dit asseblief aan Terra."
+warning:
+  no-population: "Geen bevolkingstukke is gelaai nie. As dit die eerste keer is dat u u bediener met Terra begin, of as u 'n nuwe wêreld skep, is dit normaal."
+error:
+  severe-config: "N Ernstige konfigurasiefout het Terra verhoed om terrein op koördinate behoorlik te genereer by: %1$s, %2$s. Gaan u konfigurasie na vir foute. Enige konfiguratiefoute sal hierbo gerapporteer word."
+debug:
+  data-save: "Bevolkingsdata vir wêreld \"%s\" is gestoor"
+use-paper:
+  - "Dit lyk asof u Spigot/CraftBukkit gebruik."
+  - "terwel Terra &owel&r werk op Spigot, sal sommige funksies verlore gaan. (Terra is ongetoets op CraftBukkit; geen ondersteuning sal gegee word vir CraftBukkit)."
+  - "Skakel asseblief oor na Paper om die beste uit Terra te kry."
+  - "Plus bied Paper geweldige prestasieverbeterings ten opsigte van Spigot, en alle Spigot-inproppe moet met Paper werk!"
+  - "Gebruik Paper om die beste ervaring met Terra en al u inproppe te hê."
+  - "Lees meer op Paper se webwerf: https://papermc.io/"
--- a/platforms/bukkit/src/main/resources/lang/de_de.yml
+++ b/platforms/bukkit/src/main/resources/lang/de_de.yml
@@ -0,0 +1,117 @@
+enable:
+  - "Wenn dir Terra gefällt, denk bitte darüber nach, das Projekt auf Patreon zu unterstützen!"
+  - "Dadurch erhältsts du Zugriff auf experimentelle Funktionen!"
+  - "Unterstütze das Projekt hier: https://www.patreon.com/dfsek"
+disable:
+  - "Danke, dass du Terra benutzt!!"
+command:
+  debug-only: "Dieser Befehl kann nur im Debugmodus benutzt werden!"
+  player-only: "Dieser Befehl kann nur von Spielern benutzt werden!"
+  invalid: "Ungültiger Befehl. (Erwartet %1$s Argumente, fand %2$s)."
+  players-only: "Dieser Befehl kann nur von Spielern benutzt werden."
+  world: "Dieser Befehl muss in einer von Terra generierten Welt ausgeführt werden!"
+  reload: "Terra-Konfiguration wurde neu geladen."
+  version: "Dieser Server verwendet Terra \"%s\""
+  main-menu:
+    - "--------------------Terra--------------------"
+    - "reload    - Lädt die Konfiguration neu"
+    - "biome     - Zeigt dir das derzeitige Biom"
+    - "ore       - Erzader an derzeitiger Position erzeugen (zum Debuggen)"
+    - "save-data - Bevölkerungsdaten speichern"
+    - "structure - Laden/Exportieren von Strukturen"
+    - "profile   - Profiler-Optionen"
+    - "image     - Bild-/GUI-Optionen"
+  biome:
+    biome-found: "Biom gefunden bei: (%1$s, %2$s)"
+    unable-to-locate: "Biom konnte nicht gefunden werden!"
+    invalid-radius: "Ungültiger Radius: \"%s\""
+    invalid: "Ungültige Biom-ID: \"%s\""
+    in: "Du bist in: \"%s\""
+  ore:
+    main-menu:
+      - "---------------Terra/Erz---------------"
+      - "Generiert eine Erzader an dem Block, den du anguckst"
+    out-of-range: "Block außer Reichweite"
+    invalid-ore: "Kann Erz \"%s\" nicht finden"
+  geometry:
+    main-menu:
+      - "---------------Terra/Geometrie----------------"
+      - "Verschiedene Debugging-Befehle für die Voxelgeometrie"
+      - "sphere       - Generiert eine Kugel"
+      - "deformsphere - Generiert eine deformierte Kugel"
+      - "tube         - Generiert ein Rohr"
+    deform:
+      invalid-radius: "Ungültiger Radius: \"%s\""
+      invalid-deform: "Ungültiger Deformation: \"%s\""
+      invalid-frequency: "Ungültige Frequenz: \"%s\""
+    sphere:
+      invalid-radius: "Ungültiger Radius: \"%s\""
+    tube:
+      invalid-radius: "Ungültiger Radius: \"%s\""
+  image:
+    main-menu:
+      - "---------------Terra/Bilde---------------"
+      - "render - Rendert ein Bild mit einer bestimmten Breite und Höhe, das später als Welt importiert werden kann."
+      - "gui    - Debug-GUI öffnen (muss in der Konfiguration aktiviert sein)"
+    gui:
+      main-menu:
+        - "-------------Terra/image/gui-------------"
+        - "raw  - Öffnet eine GUI mit Biome-Rohdaten"
+        - "step - Daten erneut rendern, um Ränder deutlicher darzustellen"
+      debug: "Der Debug-Modus muss aktiviert sein, um die Debug-GUI verwenden zu können! Die Debug-GUI ist NICHT PRODUKTIONSSICHER!"
+    render:
+      save: "Bild gespeichert unter: \"%s\""
+      error: "Beim speichern ist ein Fehler aufgetreten!"
+  profile:
+    main-menu:
+      - "---------------Terra/Profiler---------------"
+      - "start - Startet den Profiler"
+      - "stop  - Stoppt den Profiler"
+      - "query - Profiler-Daten anzeigen"
+      - "reset - Profiler-Daten zurücksetzen"
+    reset: "Profiler-Daten wurden zurückgesetzt."
+    start: "Der Profiler wurde gestartet."
+    stop: "Der Profiler wurde gestoppt."
+  structure:
+    main-menu:
+      - "---------------Terra/Strukturen---------------"
+      - "export - Exportiert deine aktuelle WorldEdit-Auswahl als Terra-Struktur."
+      - "load   - Ladt eine Terra-Struktur."
+    invalid-radius: "Ungültiger Radius: \"%s\""
+    invalid-rotation: "Ungültige Rotation: \"%s\""
+    invalid: "Ungültige Strukturen-ID: \"%s\""
+    export: "Struktur unter \"%s\" gespeichert."
+world-config:
+  loading: "Lade Weltkonfigurationswerte für Welt %s..."
+  not-found: "Weltkonfigurationswerte für Welt \"%s\" nicht gefunden. Lade Standardwerte."
+  using-image: "Lade Welt von Bild."
+  error: "Konfiguration für Welt %s kann nicht geladen werden!"
+  done: "Laden der Welt abgeschlossen. Ladedauer: %sms"
+config-pack:
+  loaded: "Konfiguration %1$s wurde in %2$sms geladen."
+config:
+  loaded: "Erfolgreich %1$s aus Datei %2$s geladen"
+  loaded-all: "%1$s %2$s(s) in %3$sms geladen."
+  error:
+    invalid-failover: "IUngültiger Failover-Typ: \"%s\""
+    duplicate: "ID doppelt belegt in Datei: %s"
+    file:
+      - "Konfigurationsfehler in Terra-Objekt. Datei: %1$s"
+      - "%2$s"
+      - "Korrigier bitte diese(n) Fehler, bevor du fortfährst!"
+    generic:
+      - "Ein Fehler ist beim laden der Konfiguration aufegtreten."
+      - "Bitte melde diesen Fehler!"
+warning:
+  no-population: "Es wurden keine Bevölkerungs-Chunks geladen. Wenn du den Server zum ersten Mal mit Terra startest oder eine neue Welt erstellst, ist dies normal."
+error:
+  severe-config: "Ein schwerwiegender Konfigurationsfehler hat Terra daran gehindert, Gelände an folgenden Koordinaten ordnungsgemäß zu generieren: %1$s, %2$s. Bitte überprüfe die Konfiguration auf Fehler. Alle Konfigurationsfehler wurden oben gemeldet."
+debug:
+  data-save: "Bevölkerungsdaten für Welt \"%s\" gespeichert."
+use-paper:
+  - "Anscheinend benutzt du Spigot/CraftBukkit."
+  - "Terra funktioniert auf Spigot/CraftBukkit, aber einige Funktionen gehen verloren. (Terra wurde nicht auf Spigot/CraftBukkit getestet; Es gibt keine Hilfe für Spigot/CraftBukkit-Server)."
+  - "Um Terra optimal zu benutzen, wechsle bitte zu Paper."
+  - "Außerdem bietet Paper immense Leistungsverbesserungen gegenüber Spigot und CraftBukkit und (normalerweise) funktionieren alle Spigot/CraftBukkit Plugins auch auf Paper!"
+  - "Benutze Paper, um die beste Erfahrung mit Terra und allen anderen Plugins zu haben."
+  - "Finde mehr über Paper heraus: https://papermc.io"
--- a/platforms/bukkit/src/main/resources/lang/en_us.yml
+++ b/platforms/bukkit/src/main/resources/lang/en_us.yml
@@ -0,0 +1,122 @@
+enable:
+  - "If you like Terra, please consider supporting the project on Patreon!"
+  - "You'll gain access to experimental features before they are released!"
+  - "Support the project here: https://www.patreon.com/dfsek"
+disable:
+  - "Thank you for using Terra!"
+command:
+  debug-only: "This command must be used with debug mode enabled!"
+  player-only: "This command is for players only!"
+  invalid: "Invalid command. (Expected %1$s arguments, found %2$s)."
+  players-only: "Command is for players only."
+  world: "This command must be executed in a Terra world!"
+  reload: "Reloaded Terra config."
+  reload-error: "Errors occurred while reloading Terra configurations. See logs for more information."
+  version: "This server is running Terra version \"%1$s\", implementing Gaea version \"%2$s\""
+  main-menu:
+    - "--------------------Terra--------------------"
+    - "reload    - Reload configuration data"
+    - "biome     - Get current biome"
+    - "ore       - Generate an ore vein at the location you are facing (For debugging)"
+    - "save-data - Save population data"
+    - "structure - Load and export structures"
+    - "profile   - Profiler options"
+    - "image     - Image/GUI options"
+  biome:
+    biome-found: "Located biome at (%1$s, %2$s)"
+    unable-to-locate: "Unable to locate biome."
+    invalid-radius: "Invalid radius: \"%s\""
+    invalid: "Invalid Biome ID: \"%s\""
+    in: "You are in \"%s\""
+  packs:
+    main: "Currently installed config packs:"
+    pack: " - %1$s v%3$s by %2$s"
+    none: "No config packs are installed."
+  ore:
+    main-menu:
+      - "---------------Terra/ore---------------"
+      - "Generates a vein of ore at the block you are looking at."
+    out-of-range: "Block out of range"
+    invalid-ore: "Unable to find Ore \"%s\""
+  geometry:
+    main-menu:
+      - "---------------Terra/geometry----------------"
+      - "Various voxel geometry debugging commands"
+      - "sphere       - Generate a sphere"
+      - "deformsphere - Generate a deformed sphere"
+      - "tube         - Generate a tube"
+    deform:
+      invalid-radius: "Invalid radius: \"%s\""
+      invalid-deform: "Invalid deform: \"%s\""
+      invalid-frequency: "Invalid frequency: \"%s\""
+    sphere:
+      invalid-radius: "Invalid radius: \"%s\""
+    tube:
+      invalid-radius: "Invalid radius: \"%s\""
+  image:
+    main-menu:
+      - "---------------Terra/image---------------"
+      - "render - Render an image with a given width and height, that can later be imported as a world."
+      - "gui    - Open debug GUI (Must be enabled in config)"
+    gui:
+      main-menu:
+        - "-------------Terra/image/gui-------------"
+        - "raw  - Open GUI with raw Biome data"
+        - "step - Re-render data to show borders more clearly"
+      debug: "Debug mode must be enabled to use the debug GUI! The debug GUI is NOT PRODUCTION SAFE!"
+    render:
+      save: "Saved image as \"%s\""
+      error: "An error occurred while generating the image!"
+  profile:
+    main-menu:
+      - "---------------Terra/profile---------------"
+      - "start - Starts the profiler"
+      - "stop  - Stops the profiler"
+      - "query - Fetches profiler data"
+      - "reset - Resets profiler data"
+    reset: "Profiler has been reset."
+    start: "Profiler has started."
+    stop: "Profiler has stopped."
+  structure:
+    main-menu:
+      - "---------------Terra/structure---------------"
+      - "export - Export your current WorldEdit selection as a Terra structure."
+      - "load   - Load a Terra structure"
+    invalid-radius: "Invalid radius: \"%s\""
+    invalid-rotation: "Invalid rotation: \"%s\""
+    invalid: "Invalid Structure ID: \"%s\""
+    export: "Saved structure to \"%s\""
+world-config:
+  load: "Loading world configuration values for world \"%s\"..."
+  not-found: "Configuration for world \"%s\" not found. Copying default config."
+  using-image: "Loading world from image."
+  error: "Unable to load configuration for world %s"
+  done: "World load for world \"%1$s\" complete. Time elapsed: %2$sms"
+config-pack:
+  loaded: "Config pack %1$s v%4$s by %3$s loaded in %2$sms."
+config:
+  loaded: "Loaded %1$s from file %2$s"
+  loaded-all: "Loaded %1$s %2$s(s) in %3$sms."
+  error:
+    invalid-failover: "Invalid failover type: \"%s\""
+    duplicate: "Duplicate ID found in file: %s"
+    file:
+      - "Configuration error for Terra object. File: %1$s"
+      - "%2$s"
+      - "Correct this before proceeding!"
+    generic:
+      - "An error occurred while loading configurations."
+      - "Please report this to Terra."
+warning:
+  no-population: "No population chunks were loaded. If this is your first time starting your server with Terra, or if you are creating a new world, this is normal."
+error:
+  severe-config: "A severe configuration error has prevented Terra from properly generating terrain at coordinates: %1$s, %2$s. Please check your configuration for errors. Any config errors will have been reported above."
+debug:
+  data-save: "Saved population data for world \"%s\""
+use-paper:
+  - "You appear to be using Spigot/CraftBukkit."
+  - "While Terra &odoes&r work on Spigot, some functionality will be lost. (Terra is untested on CraftBukkit; no support will be given for CraftBukkit)."
+  - "To get the most out of Terra, please switch to Paper."
+  - "Plus, Paper offers immense performance improvements over Spigot, and all Spigot plugins should work with Paper!"
+  - "To have the best experience with Terra, and all your plugins, please use Paper."
+  - "Find out more on Paper's website: https://papermc.io/"
--- a/platforms/bukkit/src/main/resources/lang/es.yml
+++ b/platforms/bukkit/src/main/resources/lang/es.yml
@@ -0,0 +1,107 @@
+enable:
+  - "Si te gusta Terra, puedes considerar apoyar el proyecto en Patreon!"
+  - "Tendrás acceso anticipado a caracteristicas experimentales antes de que sean lanzadas oficialmente!"
+  - "Puedes apoyar el proyecto aquí: https://www.patreon.com/dfsek"
+disable:
+  - "Gracias por usar Terra!"
+command:
+  player-only: "Este comando solo puede ser usado por jugadores!"
+  terra-world: "Este comando solo puede ser usado en un mundo Terra!"
+  invalid: "Comando invalido. (Expected %1$s arguments, found %2$s)."
+  players-only: "Este comando solo puede ser usado por jugadores"
+  world: "Este comando puede ejecutarse solo en un mundo terra!"
+  reload: "La configuración Terra ha sido recargada."
+  main-menu:
+    - "--------------------Terra--------------------"
+    - "reload    - Recarga los datos de configuración del plugin."
+    - "biome     - Obtienes información del bioma actual"
+    - "ore       - Genera una mena de ore en el lugar que estes mirando.(For debugging)"
+    - "save-data - Guarda los datos actuales."
+    - "structure - Cargar o exportar estructuras."
+    - "profile   - Opciones de perfil."
+    - "image     - Opciones de imagen/GUI."
+  biome:
+    biome-found: "Bioma localizado en (%1$s, %2$s)"
+    unable-to-locate: "No se pudo localizar el bioma."
+    invalid-radius: "Radio invalido: \"%s\""
+    invalid: "ID del bioma invalido: \"%s\""
+    in: "Te encuentras en \"%s\""
+  ore:
+    main-menu:
+      - "---------------Terra/ore---------------"
+      - "Generas una mena de ore en el bloque que te encuentres mirando."
+    out-of-range: "Bloque fuera de rango."
+    invalid-ore: "No se pudo encontrar el Ore \"%s\""
+  geometry:
+    main-menu:
+      - "---------------Terra/geometry----------------"
+      - "Various voxel geometry debugging commands"
+      - "sphere       - Generas un sphere"
+      - "deformsphere - Generas un sphere deformado"
+      - "tube         - Generas un tube"
+    deform:
+      invalid-radius: "Radio invalido: \"%s\""
+      invalid-deform: "Deform invalido: \"%s\""
+      invalid-frequency: "Frequencia invalida: \"%s\""
+    sphere:
+      invalid-radius: "Radio invalido: \"%s\""
+    tube:
+      invalid-radius: "Radio invalido: \"%s\""
+  image:
+    main-menu:
+      - "---------------Terra/image---------------"
+      - "render - Renderiza una imagen con alto y ancho, y este después podrá ser importado como un mundo."
+      - "gui    - Abre el debug GUI.(Puede ser habilitado en la configuración)"
+    gui:
+      main-menu:
+        - "-------------Terra/image/gui-------------"
+        - "raw  - Abre el GUI con la configuración del bioma sin procesar."
+        - "step - Vuelve a renderizar la configuración para mostrar los límites más claro."
+      debug: "El modo debug puede habilitarse para usar el debug GUI! LA CREACIÓN DEL DEBUG GUI NO PODRÍA SER SEGURA!"
+    render:
+      save: "Guarda una imagen como \"%s\""
+      error: "Un error ha ocurrido mientras se generaba la imagen!"
+  profile:
+    main-menu:
+      - "---------------Terra/profile---------------"
+      - "start - Se incia la generación del Profiler."
+      - "stop  - Se detiene la generación del Profiler."
+      - "query - Fetches profiler data"
+      - "reset - Reinicia la configuración del Profiler."
+    reset: "El Profiler ha sido reiniciado."
+    start: "El Profiler se ha iniciado."
+    stop: "El Profiler se ha detenido."
+  structure:
+    main-menu:
+      - "---------------Terra/structure---------------"
+      - "export - Exporta tus estructuras de Worldedit como estructuras Terra."
+      - "load   - Carga una estructura Terra."
+    invalid-radius: "Radio invalido: \"%s\""
+    invalid: "ID de la estructura es invalida: \"%s\""
+    export: "Estructura guardada como \"%s\""
+world-config:
+  loading: "Carga los parametros de configuración para el mundo %s..."
+  not-found: "La configuración para el mundo \"%s\" no se puede encontrar. Copiando la configuración por defecto."
+  using-image: "Carga el mundo a partir de una imagen."
+  error: "No se pudo cargar la configuración para el mundo %s"
+  done: "el mundo se ha cargado completamente. Tiempo transcurrido: %sms"
+config-pack:
+  loaded: "Configuración %1$s fue cargada en %2$sms."
+config:
+  loaded: "Cargado en %1$s desde el archivo %2$s"
+  loaded-all: "Cargado en %1$s %2$s(s) en %3$sms."
+  error:
+    duplicate: "Una ID duplicada fué encontrado en el archivo: %s"
+    file:
+      - "Error de configuración para el objeto Terra. Archivo: %1$s"
+      - "%2$s"
+      - "Corrigelo antes de proseguir!"
+    generic:
+      - "Un error ha ocurrido mientras se cargaba las configuraciónes."
+      - "Es recomendable reportar esto a Terra."
+warning:
+  no-population: "No se cargaron fragmentos de población. Si es la primera vez que inicias tu servidor con Terra, esto es normal si estás creando un nuevo mundo."
+error:
+  severe-config: "Un grave error de configuración ha impedido que Terra genere correctamente el terreno en las coordenadas: %1$s, %2$s. Compruebe si hay errores en su configuración. Cualquier error de configuración se habrá informado anteriormente."
+debug:
+  data-save: "Datos de población guardados para el mundo \"%s\""
--- a/platforms/bukkit/src/main/resources/lang/ja_jp.yml
+++ b/platforms/bukkit/src/main/resources/lang/ja_jp.yml
@@ -0,0 +1,107 @@
+enable:
+  - "Terraを気に入っていただけたのであれば、Patreonでの支援をご検討ください！"
+  - "リリース前の実験的な機能を使うことができます！"
+  - "プロジェクトの支援はこちらから: https://www.patreon.com/dfsek"
+disable:
+  - "Terraをご利用いただきありがとうございます！"
+command:
+  player-only: "このコマンドはプレイヤー専用です！"
+  terra-world: "このコマンドはTerraのワールドで実行する必要があります!"
+  invalid: "無効なコマンド(期待される %1$s 引数、%2$s が見つかりました。)"
+  players-only: "コマンドはプレイヤー専用です。"
+  world: "このコマンドはTerraのワールドで実行する必要があります!"
+  reload: "Terraの設定を再読み込みしました。"
+  main-menu:
+    - "--------------------Terra--------------------"
+    - "reload    - 設定データを再読み込み"
+    - "biome     - 現在のバイオームを取得"
+    - "ore       - 向いている場所に鉱石を生成する(デバッグ用)"
+    - "save-data - データを保存"
+    - "structure - ストラクチャーのロード及びエクスポート"
+    - "profile   - プロファイラ オプション"
+    - "image     - 画像/GUI オプション"
+  biome:
+    biome-found: "バイオームの座標 (%1$s, %2$s)"
+    unable-to-locate: "バイオームが見つけられません。"
+    invalid-radius: "無効な半径: \"%s\""
+    invalid: "無効なバイオームID: \"%s\""
+    in: "あなたは \"%s\" にいます。"
+  ore:
+    main-menu:
+      - "---------------Terra/ore---------------"
+      - "見ているブロックに鉱石を生成します。"
+    out-of-range: "範囲外のブロック"
+    invalid-ore: "鉱石 \"%s\" が見つかりません。"
+  geometry:
+    main-menu:
+      - "---------------Terra/geometry----------------"
+      - "様々なボクセルジオメトリのデバッグコマンド"
+      - "sphere       - 球体を生成"
+      - "deformsphere - 変形した球体を生成"
+      - "tube         - チューブを生成"
+    deform:
+      invalid-radius: "無効な半径: \"%s\""
+      invalid-deform: "無効な変形: \"%s\""
+      invalid-frequency: "無効な周波数: \"%s\""
+    sphere:
+      invalid-radius: "無効な半径: \"%s\""
+    tube:
+      invalid-radius: "無効な半径: \"%s\""
+  image:
+    main-menu:
+      - "---------------Terra/image---------------"
+      - "render - 指定された幅と高さの画像をレンダリングします。"
+      - "gui    - デバッグGUIを開く(設定で有効にする必要があります)"
+    gui:
+      main-menu:
+        - "-------------Terra/image/gui-------------"
+        - "raw  - 生のBiomeデータを利用したGUIを開く"
+        - "step - 境界線をより明確に表示するためにデータを再レンダリング"
+      debug: "デバッグGUIを使用するには、デバッグモードを有効にする必要があります。デバッグGUIは安全ではありません！"
+    render:
+      save: "\"%s\" として画像を保存"
+      error: "画像生成中にエラーが発生しました！"
+  profile:
+    main-menu:
+      - "---------------Terra/profile---------------"
+      - "start - プロファイラを起動"
+      - "stop  - プロファイラを停止"
+      - "query - プロファイラデータを取得"
+      - "reset - プロファイラのデータをリセット"
+    reset: "プロファイラがリセットされました。"
+    start: "プロファイラが起動しました。"
+    stop: "プロファイラが停止しました。"
+  structure:
+    main-menu:
+      - "---------------Terra/structure---------------"
+      - "export - 現在のWorldEditの選択範囲をTerraストラクチャーとしてエクスポート"
+      - "load   - Terraストラクチャーを読み込む"
+    invalid-radius: "無効な半径: \"%s\""
+    invalid: "無効なストラクチャーID: \"%s\""
+    export: "\"%s\" にストラクチャーを保存"
+world-config:
+  loading: "ワールド %s のワールド設定を読込中..."
+  not-found: "ワールド \"%s\" の設定が見つかりませんでした。デフォルトの設定をコピーします。"
+  using-image: "画像からワールドを読み込みます。"
+  error: "ワールド %s の設定を読み込めませんでした"
+  done: "ワールドの読み込みが完了しました。経過時間: %sms"
+config-pack:
+  loaded: "%2$sms で設定 %1$s が読み込まれました。"
+config:
+  loaded: "ファイル %2$s から %1$s を読み込まれました。"
+  loaded-all: "%3$sms で %1$s %2$s で読み込まれました。"
+  error:
+    duplicate: "ファイルに重複したIDが見つかりました: %s"
+    file:
+      - "Terraオブジェクトに設定エラーがあります。ファイル: %1$s"
+      - "%2$s"
+      - "先に進む前にこれを修正してください！"
+    generic:
+      - "設定の読み込み中にエラーが発生しました。"
+      - "Terraに報告してください。"
+warning:
+  no-population: "チャンクが読み込まれませんでした。初めてTerraでサーバーを起動した場合、または新しいワールドを作成した場合、これは正常です。"
+error:
+  severe-config: "重大な設定エラーによりTerraが正しく地形を生成できません。座標: %1$s, %2$s エラーがないか設定をチェックしてください。設定エラーは上記で報告されています。"
+debug:
+  data-save: "ワールド \"%s\" のデータを保存"
--- a/platforms/bukkit/src/main/resources/lang/pl.yml
+++ b/platforms/bukkit/src/main/resources/lang/pl.yml
@@ -0,0 +1,117 @@
+enable:
+  - "Jezeli spodoba ci sie Terra, rozwaz wsparcie projektu na Patreon!"
+  - "Otrzymasz dostep do eksperymentalnych funkcji przed ich premiera!"
+  - "Wspieraj projekt na: https://www.patreon.com/dfsek"
+disable:
+  - "Dziekuje za korzystanie z Terra!"
+command:
+  debug-only: "Ta komenda musi byc uzyta z trybem debugowym wlaczonym!"
+  player-only: "Ta komenda jest tylko dla graczy!"
+  invalid: "Niepoprawna komenda. (Oczekiwane %1$s argumenty, znalezione %2$s)."
+  players-only: "Komenda jest tylko dla graczy."
+  world: "Ta komenda musi byc wpisana w swiecie Terra!"
+  reload: "Przeladowano plik konfiguracyjny Terra."
+  version: "Ten serwer korzysta z wersji Terra \"%s\""
+  main-menu:
+    - "--------------------Terra--------------------"
+    - "reload    - Przeladuj dane konfiguracyjne"
+    - "biome     - Otrzymaj informacje o obecnym biomie"
+    - "ore       - Wygeneruj zloze rud w strone w ktora patrzysz (Do debugowania)"
+    - "save-data - Zapisz dane"
+    - "structure - Zaladuj i wyeksportuj dane struktur"
+    - "profile   - Opcje profilera"
+    - "image     - Opcje obrazu/GUI"
+  biome:
+    biome-found: "Zlokalizowano biom na (%1$s, %2$s)"
+    unable-to-locate: "Nie moglismy zlokalizowac biomu."
+    invalid-radius: "Niepoprawny zakres: \"%s\""
+    invalid: "Niepoprawne Biome ID: \"%s\""
+    in: "Jestes na \"%s\""
+  ore:
+    main-menu:
+      - "---------------Terra/rudy---------------"
+      - "Generuje zloze rud w strone w ktora patrzysz."
+    out-of-range: "Blok spoza zakresu"
+    invalid-ore: "Niemoglismy znalezc Rudy \"%s\""
+  geometry:
+    main-menu:
+      - "---------------Terra/geometria----------------"
+      - "Zroznicowane komendy geometrii voxeli do debugowania"
+      - "sphere       - Generuje kule"
+      - "deformsphere - Generuje zdeformowana kul"
+      - "tube         - Generaje tube"
+    deform:
+      invalid-radius: "Niepoprawny zakres: \"%s\""
+      invalid-deform: "Niepoprawna deformacja: \"%s\""
+      invalid-frequency: "Niepoprawna czestotliwosc: \"%s\""
+    sphere:
+      invalid-radius: "Niepoprawny zakres: \"%s\""
+    tube:
+      invalid-radius: "Niepoprawny zakres: \"%s\""
+  image:
+    main-menu:
+      - "---------------Terra/obraz---------------"
+      - "render - Renderuje obraz o podanej szerokosci i wysokosci, moze byc potem zaimportowane jako swiat."
+      - "gui    - Otwiera GUI debugowania (Musi byc wlaczone w pliku konfiguracyjnym)"
+    gui:
+      main-menu:
+        - "-------------Terra/obraz/gui-------------"
+        - "raw  - Otwiera GUI z surowymi danymi Biomu"
+        - "step - Przerenderowuje dane aby pokazac granice bardziej przejrzyscie"
+      debug: "Tryb debugowania musi byc wlaczony aby debugowac za pomoca GUI! GUI debugowania NIE JEST STABILNE!"
+    render:
+      save: "Zapisano obraz jako \"%s\""
+      error: "Wystapil error podczas generowania obrazu!"
+  profile:
+    main-menu:
+      - "---------------Terra/profil---------------"
+      - "start - Rozpoczyna dzialanie profilera"
+      - "stop  - Zatrzymuje dzialanie profilera"
+      - "query - Wydobywa dane profilera"
+      - "reset - Resetuje dane profilera"
+    reset: "Profiler zostal zresetowany."
+    start: "Profiler zostal wlaczony."
+    stop: "Profiler zostal wylaczony."
+  structure:
+    main-menu:
+      - "---------------Terra/struktury---------------"
+      - "export - Wyeksportuj obecne zaznaczenie w WorldEdicie jako strukture Terra."
+      - "load   - Zaladuj strukture Terra"
+    invalid-radius: "Niepoprawny zakres: \"%s\""
+    invalid-rotation: "Niepoprawny zakres: \"%s\""
+    invalid: "Niepoprawne ID Struktury: \"%s\""
+    export: "Zapisano strukture jak \"%s\""
+world-config:
+  loading: "Ladowanie wartosci konfiguracji dla swiata %s..."
+  not-found: "Konfiguracja dla swiata \"%s\" nie zostala znaleziona. Kopiuje domyslny plik konfiguracyjny."
+  using-image: "Ladowania swiata z obrazu."
+  error: "Nie udalo sie zaladowac konfiguracji dla swiata %s"
+  done: "Ladowanie swiata gotowe. Wykonano to w: %sms"
+config-pack:
+  loaded: "Zaladowano plik konfiguracyjny %1$s w %2$sms."
+config:
+  loaded: "Zaladowano %1$s z pliku %2$s"
+  loaded-all: "Zaladowano %1$s %2$s(s) w %3$sms."
+  error:
+    invalid-failover: "Niepoprawny typ awaryjnego przelaczania: \"%s\""
+    duplicate: "Zduplikowano ID znalezione w pliku: %s"
+    file:
+      - "Blad konfiguracji w objekcie Terra. Plik: %1$s"
+      - "%2$s"
+      - "Popraw to przed rozpoczeciem!"
+    generic:
+      - "Wystapil blad podczas ladowania konfiguracji."
+      - "Prosze zglos to do Terra."
+warning:
+  no-population: "Chunki populacyjne nie zostaly zaladowane. Jezeli to jest pierwszy raz kiedy wlaczasz serwer z Terra, lub tworzysz nowy swiat, to jest normalne."
+error:
+  severe-config: "Powazne bledy konfiguracji zablokowaly generowanie terenu na koordynatach: %1$s, %2$s. Prosze sprawdz konfiguracyje w poszukiwaniu bledow. Wszelkie bledy konfiguracyjne zostaly zgloszone powyzej."
+debug:
+  data-save: "Zapisane dane dla swiata \"%s\""
+use-paper:
+  - "Wyglada na to ze dalej korzystasz z Spigot/CraftBukkit."
+  - "Terra &odziala&r na Spigotcie, niektore funkcje moga byc stracone. (Terra nie jest przetestowana na CraftBukkit; wiec nie wspieramy CraftBukkit)."
+  - "Aby wycisnac jak najwiecej z Terra, prosze przejdz na Paper."
+  - "Ponadto, Paper oferuje ulepszona wydajnosc wzgledem Spigota, a wszystkie pluginy z Spigota powinny dzialac na Paperze!"
+  - "Dla jak najlepszych doswiadczen z Terra, i wszystkimi twoimi pluginami, przejdz na Papera."
+  - "Dowiedz sie wiecej o Paperze na ich stronie: https://papermc.io/"
--- a/platforms/bukkit/src/main/resources/lang/zh_cn.yml
+++ b/platforms/bukkit/src/main/resources/lang/zh_cn.yml
@@ -0,0 +1,107 @@
+enable:
+  - "如果你喜欢Terra，请考虑在Patreon上支持该项目！"
+  - "你会在项目正式发布前获得实验性特性！"
+  - "前往该网址支持我们：https://www.patreon.com/dfsek"
+disable:
+  - "感谢使用Terra！"
+command:
+  player-only: "该指令只能由玩家使用！"
+  terra-world: "该指令只能在Terra世界内使用！"
+  invalid: "无效的指令。(应有%1$s项参数，现在只有%2$s项)。"
+  players-only: "指令只能由玩家使用。"
+  world: "该指令只能在Terra世界内使用！"
+  reload: "重载Terra配置。"
+  main-menu:
+    - "--------------------Terra--------------------"
+    - "reload    - 重载配置数据"
+    - "biome     - 查看所在群系"
+    - "ore       - 在你面朝的位置生成矿脉(用于调试)"
+    - "save-data - 保存数据"
+    - "structure - 加载和导出建筑"
+    - "profile   - 分析工具选项"
+    - "image     - 图像/GUI 选项"
+  biome:
+    biome-found: "群系位于(%1$s, %2$s)"
+    unable-to-locate: "无法定位群系。"
+    invalid-radius: "无效范围：\"%s\""
+    invalid: "无效的群系ID: \"%s\""
+    in: "你位于\"%s\""
+  ore:
+    main-menu:
+      - "---------------Terra/矿物---------------"
+      - "在你所视位置生成矿脉。"
+    out-of-range: "所视方块超出范围"
+    invalid-ore: "找不到矿物 \"%s\""
+  geometry:
+    main-menu:
+      - "---------------Terra/几何----------------"
+      - "各种几何调试指令"
+      - "sphere       - 生成球体"
+      - "deformsphere - 生成变形球体"
+      - "tube         - 生成管形"
+    deform:
+      invalid-radius: "无效范围：\"%s\""
+      invalid-deform: "无效变形：\"%s\""
+      invalid-frequency: "无效频率：\"%s\""
+    sphere:
+      invalid-radius: "无效范围：\"%s\""
+    tube:
+      invalid-radius: "无效范围：\"%s\""
+  image:
+    main-menu:
+      - "---------------Terra/图像---------------"
+      - "render - 根据给定宽度和高度渲染图像，以便于之后导入到世界内。"
+      - "gui    - 打开调试GUI (必须先在配置内启用)"
+    gui:
+      main-menu:
+        - "-------------Terra/图像/GUI-------------"
+        - "raw  - 打开纯群系数据的GUI"
+        - "step - 重渲染数据以更清晰地显示边界"
+      debug: "必须先启用调试模式才能使用GUI！调试GUI不适合在运行中的服务器里使用！"
+    render:
+      save: "已将图像保存为\"%s\""
+      error: "生成图像时出错！"
+  profile:
+    main-menu:
+      - "---------------Terra/分析---------------"
+      - "start - 启动分析工具"
+      - "stop  - 关闭分析工具"
+      - "query - 获取分析数据"
+      - "reset - 重置分析数据"
+    reset: "分析工具已重置。"
+    start: "分析工具已启动。"
+    stop: "分析工具已关闭。"
+  structure:
+    main-menu:
+      - "---------------Terra/建筑---------------"
+      - "export - 导出你当前的WorldEdit选区为Terra的建筑。"
+      - "load   - 加载Terra的建筑。"
+    invalid-radius: "无效范围：\"%s\""
+    invalid: "无效建筑ID：\"%s\""
+    export: "已将建筑保存为\"%s\""
+world-config:
+  loading: "正在加载世界%s配置数值……"
+  not-found: "找不到世界\"%s\"的配置。正应用默认配置。"
+  using-image: "加载图像中"
+  error: "无法加载世界%s的配置"
+  done: "加载世界完成。耗时：%sms"
+config-pack:
+  loaded: "已加载配置%1$s，耗时%2$sms。"
+config:
+  loaded: "已加载%1$s，源自文件%2$s"
+  loaded-all: "已加载%1$s %2$s(s)，耗时%3$sms。"
+  error:
+    duplicate: "该文件内的ID重复：%s"
+    file:
+      - "Terra目标的配置出错。文件：%1$s"
+      - "%2$s"
+      - "请先校正该配置！"
+    generic:
+      - "加载配置时出错。"
+      - "请汇报该错误。"
+warning:
+  no-population: "未加载区块。如果这是你第一次安装Terra后开服，或者你只是创建新世界，那么你看到这条消息很正常。"
+error:
+  severe-config: "严重配置错误，该错误阻止Terra正常生成位于该坐标的地形：%1$s, %2$s。请检查你的配置。任何配置错误都会显示在上面。"
+debug:
+  data-save: "已保存该世界的地形数据：\"%s\""
--- a/platforms/bukkit/src/main/resources/plugin.yml
+++ b/platforms/bukkit/src/main/resources/plugin.yml
@@ -0,0 +1,18 @@
+name: "Terra"
+main: "com.dfsek.terra.bukkit.TerraBukkitPlugin"
+version: "@VERSION@"
+load: "STARTUP"
+author: dfsek
+api-version: "1.16"
+description: "An insanely powerful free & open-source data-driven world generator."
+softdepend: [ "WorldEdit" ]
+commands:
+  terra:
+    description: "Terra base command"
+    usage: "/terra "
+    aliases: [ "te" ]
+    permission: "terra.command"
+  locate:
+    description: "Locate a Terra Structure"
+    usage: "/locate <STRUCTURE_ID> <radius>"
+    permission: "terra.locate"
--- a/platforms/bukkit/src/main/resources/world.yml
+++ b/platforms/bukkit/src/main/resources/world.yml
@@ -0,0 +1 @@
+
--- a/platforms/fabric/build.gradle.kts
+++ b/platforms/fabric/build.gradle.kts
@@ -0,0 +1,20 @@
+plugins {
+    java
+    maven
+    idea
+}
+
+group = "com.dfsek.terra.bukkit"
+
+repositories {
+    mavenCentral()
+    maven { url = uri("http://maven.enginehub.org/repo/") }
+    maven { url = uri("https://repo.codemc.org/repository/maven-public") }
+    maven { url = uri("https://papermc.io/repo/repository/maven-public/") }
+}
+
+dependencies {
+    testImplementation("org.junit.jupiter:junit-jupiter-api:5.7.0")
+    testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine:5.7.0")
+    implementation(project(":common"))
+}