Begin Sponge implementation

platforms/sponge/src/main/java/com/dfsek/terra/sponge/TerraSpongePlugin.java

@@ -9,26 +9,55 @@ import com.dfsek.terra.api.generic.world.World;
 import com.dfsek.terra.api.generic.world.WorldHandle;
 import com.dfsek.terra.config.base.PluginConfig;
 import com.dfsek.terra.registry.ConfigRegistry;
+import com.dfsek.terra.sponge.world.SpongeWorldHandle;
+import com.google.inject.Inject;
+import org.spongepowered.api.GameRegistry;
+import org.spongepowered.api.config.ConfigDir;
+import org.spongepowered.api.event.Listener;
+import org.spongepowered.api.event.game.state.GameStartedServerEvent;
 import org.spongepowered.api.plugin.Plugin;
 
-import javax.inject.Inject;
 import java.io.File;
 import java.util.logging.Logger;
 
 @Plugin(id = "terra", name = "Terra", version = "@VERSION", description = "Terra world generator")
 public class TerraSpongePlugin implements TerraPlugin {
 
+    private final ConfigRegistry registry = new ConfigRegistry();
+
+    private final WorldHandle worldHandle = new SpongeWorldHandle(this);
+
     @Inject
     private Logger logger;
+    private boolean enabled = false;
+
+    @Inject
+    @ConfigDir(sharedRoot = false)
+    private File configDir;
+
+    @Inject
+    private GameRegistry gameRegistry;
+
+    public GameRegistry getGameRegistry() {
+        return gameRegistry;
+    }
+
+    @Listener
+    public void serverStart(GameStartedServerEvent event) {
+        logger.info("Hello Sponge!");
+        logger.info("Config dir is: " + configDir);
+        registry.loadAll(this);
+        enabled = true;
+    }
 
     @Override
     public WorldHandle getWorldHandle() {
-        return null;
+        return worldHandle;
     }
 
     @Override
     public boolean isEnabled() {
-        return false;
+        return enabled;
     }
 
     @Override
@@ -48,7 +77,7 @@ public class TerraSpongePlugin implements TerraPlugin {
 
     @Override
     public File getDataFolder() {
-        return null;
+        return configDir;
     }
 
     @Override

platforms/sponge/src/main/java/com/dfsek/terra/sponge/mixin/BlockStateParserMixin.java

@@ -0,0 +1,4 @@
+package com.dfsek.terra.sponge.mixin;
+
+public class BlockStateParserMixin {
+}

platforms/sponge/src/main/java/com/dfsek/terra/sponge/world/SpongeChunk.java

@@ -0,0 +1,38 @@
+package com.dfsek.terra.sponge.world;
+
+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;
+
+public class SpongeChunk implements Chunk {
+    private final org.spongepowered.api.world.Chunk delegate;
+
+    public SpongeChunk(org.spongepowered.api.world.Chunk delegate) {
+        this.delegate = delegate;
+    }
+
+    @Override
+    public int getX() {
+        return delegate.getPosition().getX();
+    }
+
+    @Override
+    public int getZ() {
+        return delegate.getPosition().getZ();
+    }
+
+    @Override
+    public World getWorld() {
+        return new SpongeWorld(delegate.getWorld());
+    }
+
+    @Override
+    public Block getBlock(int x, int y, int z) {
+        return null;
+    }
+
+    @Override
+    public org.spongepowered.api.world.Chunk getHandle() {
+        return delegate;
+    }
+}

platforms/sponge/src/main/java/com/dfsek/terra/sponge/world/SpongeWorld.java

@@ -0,0 +1,87 @@
+package com.dfsek.terra.sponge.world;
+
+import com.dfsek.terra.api.generic.Entity;
+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.sponge.world.generator.SpongeChunkGenerator;
+
+import java.io.File;
+import java.util.UUID;
+import java.util.function.Consumer;
+
+public class SpongeWorld implements World {
+    private final org.spongepowered.api.world.World delegate;
+
+    public SpongeWorld(org.spongepowered.api.world.World delegate) {
+        this.delegate = delegate;
+    }
+
+    @Override
+    public long getSeed() {
+        return delegate.getProperties().getSeed();
+    }
+
+    @Override
+    public int getMaxHeight() {
+        return 255;
+    }
+
+    @Override
+    public ChunkGenerator getGenerator() {
+        return new SpongeChunkGenerator(delegate.getWorldGenerator());
+    }
+
+    @Override
+    public String getName() {
+        return delegate.getName();
+    }
+
+    @Override
+    public UUID getUID() {
+        return delegate.getUniqueId();
+    }
+
+    @Override
+    public boolean isChunkGenerated(int x, int z) {
+        return delegate.loadChunk(x, 0, z, false).isPresent(); // TODO: better implementation
+    }
+
+    @Override
+    public Chunk getChunkAt(int x, int z) {
+        return null;
+    }
+
+    @Override
+    public File getWorldFolder() {
+        return null;
+    }
+
+    @Override
+    public Block getBlockAt(int x, int y, int z) {
+        return null;
+    }
+
+    @Override
+    public Block getBlockAt(Location l) {
+        return null;
+    }
+
+    @Override
+    public boolean generateTree(Location l, Tree vanillaTreeType) {
+        return false;
+    }
+
+    @Override
+    public void spawn(Location location, Class<Entity> entity, Consumer<Entity> consumer) {
+
+    }
+
+    @Override
+    public Object getHandle() {
+        return null;
+    }
+}

platforms/sponge/src/main/java/com/dfsek/terra/sponge/world/SpongeWorldHandle.java

@@ -0,0 +1,47 @@
+package com.dfsek.terra.sponge.world;
+
+import com.dfsek.terra.api.generic.Tree;
+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.sponge.TerraSpongePlugin;
+import com.dfsek.terra.sponge.world.block.SpongeBlockData;
+
+public class SpongeWorldHandle implements WorldHandle {
+    private final TerraSpongePlugin main;
+
+    public SpongeWorldHandle(TerraSpongePlugin main) {
+        this.main = main;
+    }
+
+    @Override
+    public void setBlockData(Block block, BlockData data, boolean physics) {
+
+    }
+
+    @Override
+    public BlockData getBlockData(Block block) {
+        return null;
+    }
+
+    @Override
+    public MaterialData getType(Block block) {
+        return null;
+    }
+
+    @Override
+    public BlockData createBlockData(String data) {
+        return new SpongeBlockData(null);
+    }
+
+    @Override
+    public MaterialData createMaterialData(String data) {
+        return createBlockData(data).getMaterial();
+    }
+
+    @Override
+    public Tree getTree(String id) {
+        return null;
+    }
+}

platforms/sponge/src/main/java/com/dfsek/terra/sponge/world/block/SpongeBlock.java

@@ -0,0 +1,77 @@
+package com.dfsek.terra.sponge.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.sponge.world.SpongeWorld;
+import org.spongepowered.api.world.World;
+
+public class SpongeBlock implements Block {
+    private final org.spongepowered.api.world.Location<World> delegate;
+
+    public SpongeBlock(org.spongepowered.api.world.Location<World> delegate) {
+        this.delegate = delegate;
+    }
+
+    @Override
+    public void setBlockData(BlockData data, boolean physics) {
+        delegate.setBlock(((SpongeBlockData) data).getHandle());
+    }
+
+    @Override
+    public BlockData getBlockData() {
+        return new SpongeBlockData(delegate.getBlock());
+    }
+
+    @Override
+    public Block getRelative(BlockFace face) {
+        return new SpongeBlock(delegate.copy().add(face.getModX(), face.getModY(), face.getModZ()));
+    }
+
+    @Override
+    public Block getRelative(BlockFace face, int len) {
+        return new SpongeBlock(delegate.copy().add(face.getModX() * len, face.getModY() * len, face.getModZ() * len));
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return delegate.hasBlock();
+    }
+
+    @Override
+    public Location getLocation() {
+        return new Location(new SpongeWorld(delegate.getExtent()), delegate.getX(), delegate.getY(), delegate.getZ());
+    }
+
+    @Override
+    public MaterialData getType() {
+        return new SpongeMaterialData(delegate.getBlockType());
+    }
+
+    @Override
+    public int getX() {
+        return delegate.getBlockX();
+    }
+
+    @Override
+    public int getZ() {
+        return delegate.getBlockZ();
+    }
+
+    @Override
+    public int getY() {
+        return delegate.getBlockY();
+    }
+
+    @Override
+    public boolean isPassable() {
+        return false;
+    }
+
+    @Override
+    public org.spongepowered.api.world.Location<World> getHandle() {
+        return delegate;
+    }
+}

platforms/sponge/src/main/java/com/dfsek/terra/sponge/world/block/SpongeBlockData.java

@@ -0,0 +1,37 @@
+package com.dfsek.terra.sponge.world.block;
+
+import com.dfsek.terra.api.generic.world.block.BlockData;
+import com.dfsek.terra.api.generic.world.block.MaterialData;
+import org.spongepowered.api.block.BlockState;
+
+public class SpongeBlockData implements BlockData {
+    private final BlockState delegate;
+
+    public SpongeBlockData(BlockState delegate) {
+        this.delegate = delegate;
+    }
+
+    @Override
+    public MaterialData getMaterial() {
+        return new SpongeMaterialData(delegate.getType());
+    }
+
+    @Override
+    public boolean matches(MaterialData materialData) {
+        return ((SpongeMaterialData) materialData).getHandle().equals(delegate.getType());
+    }
+
+    @Override
+    public BlockData clone() {
+        try {
+            return (BlockData) super.clone();
+        } catch(CloneNotSupportedException e) {
+            throw new Error(e);
+        }
+    }
+
+    @Override
+    public BlockState getHandle() {
+        return delegate;
+    }
+}

platforms/sponge/src/main/java/com/dfsek/terra/sponge/world/block/SpongeMaterialData.java

@@ -0,0 +1,48 @@
+package com.dfsek.terra.sponge.world.block;
+
+import com.dfsek.terra.api.generic.world.block.BlockData;
+import com.dfsek.terra.api.generic.world.block.MaterialData;
+import org.spongepowered.api.block.BlockType;
+
+public class SpongeMaterialData implements MaterialData {
+    private final BlockType delegate;
+
+    public SpongeMaterialData(BlockType delegate) {
+        this.delegate = delegate;
+    }
+
+    @Override
+    public boolean matches(MaterialData other) {
+        return delegate.equals(((SpongeMaterialData) other).getHandle());
+    }
+
+    @Override
+    public boolean matches(BlockData other) {
+        return false;
+    }
+
+    @Override
+    public boolean isSolid() {
+        return false;
+    }
+
+    @Override
+    public boolean isAir() {
+        return false;
+    }
+
+    @Override
+    public double getMaxDurability() {
+        return 0;
+    }
+
+    @Override
+    public BlockData createBlockData() {
+        return null;
+    }
+
+    @Override
+    public BlockType getHandle() {
+        return delegate;
+    }
+}

platforms/sponge/src/main/java/com/dfsek/terra/sponge/world/generator/SpongeChunkGenerator.java

@@ -0,0 +1,66 @@
+package com.dfsek.terra.sponge.world.generator;
+
+import com.dfsek.terra.api.generic.generator.BlockPopulator;
+import com.dfsek.terra.api.generic.generator.ChunkGenerator;
+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 org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.spongepowered.api.world.gen.WorldGenerator;
+
+import java.util.List;
+import java.util.Random;
+
+public class SpongeChunkGenerator implements ChunkGenerator {
+    private final WorldGenerator delegate;
+
+    public SpongeChunkGenerator(WorldGenerator delegate) {
+        this.delegate = delegate;
+    }
+
+    @Override
+    public boolean isParallelCapable() {
+        return false;
+    }
+
+    @Override
+    public boolean shouldGenerateCaves() {
+        return false;
+    }
+
+    @Override
+    public boolean shouldGenerateDecorations() {
+        return false;
+    }
+
+    @Override
+    public boolean shouldGenerateMobs() {
+        return false;
+    }
+
+    @Override
+    public boolean shouldGenerateStructures() {
+        return false;
+    }
+
+    @Override
+    public ChunkData generateChunkData(@NotNull World world, @NotNull Random random, int x, int z, @NotNull BiomeGrid biome) {
+        return null;
+    }
+
+    @Override
+    public List<BlockPopulator> getDefaultPopulators(World world) {
+        return null;
+    }
+
+    @Override
+    public @Nullable TerraChunkGenerator getTerraGenerator() {
+        return null;
+    }
+
+    @Override
+    public WorldGenerator getHandle() {
+        return delegate;
+    }
+}