feat: Minestom platform

buildSrc/src/main/kotlin/Versions.kt

@@ -81,4 +81,8 @@ object Versions {
     object Allay {
         const val api = "0114e0b290"
     }
+
+    object Minestom {
+        const val minestom = "187931e50b"
+    }
 }

common/api/src/main/java/com/dfsek/terra/api/block/BlockType.java

@@ -13,6 +13,9 @@
 
 /**
  * Represents a type of block
+ * <p>
+ * Important! You <b>need</b> to implement a proper equals() and hashCode() here in
+ * your platform implementation for surface decorations to show up
  */
 public interface BlockType extends Handle {
     /**

platforms/minestom/build.gradle.kts

@@ -0,0 +1,31 @@
+plugins {
+    application
+}
+
+val javaMainClass = "com.dfsek.terra.minestom.TerraMinestomExample"
+
+dependencies {
+    shadedApi(project(":common:implementation:base"))
+    shadedApi("com.github.ben-manes.caffeine", "caffeine", Versions.Libraries.caffeine)
+    shadedImplementation("com.google.guava", "guava", Versions.Libraries.Internal.guava)
+
+    implementation("net.minestom", "minestom-snapshots", Versions.Minestom.minestom)
+    implementation("org.slf4j", "slf4j-simple", Versions.Libraries.slf4j)
+}
+
+tasks.withType<Jar> {
+    entryCompression = ZipEntryCompression.STORED
+    manifest {
+        attributes(
+            "Main-Class" to javaMainClass,
+        )
+    }
+}
+
+application {
+    mainClass.set(javaMainClass)
+}
+
+tasks.getByName("run").setProperty("workingDir", file("./run"))
+
+addonDir(project.file("./run/terra/addons"), tasks.named("run").get())

platforms/minestom/src/main/java/com/dfsek/terra/minestom/MinestomAdapter.java

@@ -0,0 +1,17 @@
+package com.dfsek.terra.minestom;
+
+import com.dfsek.terra.api.util.vector.Vector3;
+
+import net.minestom.server.coordinate.Point;
+import net.minestom.server.coordinate.Pos;
+
+
+public class MinestomAdapter {
+    public static Vector3 adapt(Point point) {
+        return Vector3.of(point.x(), point.y(), point.z());
+    }
+
+    public static Pos adapt(Vector3 vector) {
+        return new Pos(vector.getX(), vector.getY(), vector.getZ());
+    }
+}

platforms/minestom/src/main/java/com/dfsek/terra/minestom/MinestomPlatform.java

@@ -0,0 +1,80 @@
+package com.dfsek.terra.minestom;
+
+import com.dfsek.tectonic.api.TypeRegistry;
+
+import com.dfsek.tectonic.api.loader.type.TypeLoader;
+
+import com.dfsek.terra.AbstractPlatform;
+import com.dfsek.terra.api.block.state.BlockState;
+import com.dfsek.terra.api.entity.EntityType;
+import com.dfsek.terra.api.event.events.platform.PlatformInitializationEvent;
+import com.dfsek.terra.api.handle.ItemHandle;
+import com.dfsek.terra.api.handle.WorldHandle;
+
+import com.dfsek.terra.api.world.biome.PlatformBiome;
+
+import com.dfsek.terra.minestom.biome.MinestomBiomeLoader;
+import com.dfsek.terra.minestom.entity.MinestomEntityType;
+import com.dfsek.terra.minestom.item.MinestomItemHandle;
+
+import com.dfsek.terra.minestom.world.MinestomWorldHandle;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.io.File;
+
+
+public final class MinestomPlatform extends AbstractPlatform {
+    private static MinestomPlatform INSTANCE = null;
+    private final MinestomWorldHandle worldHandle = new MinestomWorldHandle();
+    private final MinestomItemHandle itemHandle = new MinestomItemHandle();
+
+    private MinestomPlatform() {
+        load();
+        getEventManager().callEvent(new PlatformInitializationEvent());
+    }
+
+    @Override
+    public void register(TypeRegistry registry) {
+        super.register(registry);
+        registry
+            .registerLoader(PlatformBiome.class, new MinestomBiomeLoader())
+            .registerLoader(EntityType.class, (TypeLoader<EntityType>) (annotatedType, o, configLoader, depthTracker) -> new MinestomEntityType((String) o))
+            .registerLoader(BlockState.class, (TypeLoader<BlockState>) (annotatedType, o, configLoader, depthTracker) -> worldHandle.createBlockState((String) o));
+    }
+
+    @Override
+    public boolean reload() {
+        return false;
+    }
+
+    @Override
+    public @NotNull WorldHandle getWorldHandle() {
+        return worldHandle;
+    }
+
+    @Override
+    public @NotNull ItemHandle getItemHandle() {
+        return itemHandle;
+    }
+
+    @Override
+    public @NotNull String platformName() {
+        return "Minestom";
+    }
+
+    @Override
+    public @NotNull File getDataFolder() {
+        File file = new File("./terra/");
+        if(!file.exists()) file.mkdirs();
+        return file;
+    }
+
+
+    public static MinestomPlatform getInstance() {
+        if(INSTANCE == null) {
+            INSTANCE = new MinestomPlatform();
+        }
+        return INSTANCE;
+    }
+}

platforms/minestom/src/main/java/com/dfsek/terra/minestom/TerraMinestomExample.java

@@ -0,0 +1,158 @@
+package com.dfsek.terra.minestom;
+
+import com.dfsek.terra.minestom.api.filter.ChunkFilter;
+import com.dfsek.terra.minestom.api.filter.EvenChunkFilter;
+import com.dfsek.terra.minestom.api.filter.NoFeaturesFilter;
+import com.dfsek.terra.minestom.api.filter.NoTerrainFilter;
+import com.dfsek.terra.minestom.api.filter.SpecificChunkFilter;
+import com.dfsek.terra.minestom.api.filter.XFilter;
+import com.dfsek.terra.minestom.api.filter.ZFilter;
+import com.dfsek.terra.minestom.world.TerraMinestomWorld;
+import com.dfsek.terra.minestom.world.TerraMinestomWorldBuilder;
+
+import net.kyori.adventure.text.Component;
+import net.minestom.server.MinecraftServer;
+import net.minestom.server.command.builder.Command;
+import net.minestom.server.command.builder.arguments.ArgumentLiteral;
+import net.minestom.server.command.builder.arguments.number.ArgumentInteger;
+import net.minestom.server.coordinate.Pos;
+import net.minestom.server.entity.GameMode;
+import net.minestom.server.event.player.AsyncPlayerConfigurationEvent;
+import net.minestom.server.event.player.PlayerSpawnEvent;
+import net.minestom.server.instance.Instance;
+import net.minestom.server.instance.LightingChunk;
+import org.jetbrains.annotations.Nullable;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.time.Duration;
+import java.util.concurrent.atomic.AtomicInteger;
+
+
+public class TerraMinestomExample {
+    private static final Logger logger = LoggerFactory.getLogger(TerraMinestomExample.class);
+    private final MinecraftServer server = MinecraftServer.init();
+    private Instance instance;
+    private TerraMinestomWorld world;
+
+    public void createNewInstance() {
+        instance = MinecraftServer.getInstanceManager().createInstanceContainer();
+        instance.setChunkSupplier(LightingChunk::new);
+    }
+
+    public void attachTerra(ChunkFilter filter) {
+        world = TerraMinestomWorldBuilder.from(instance)
+            .defaultPack()
+//            .seed(0)
+            .filtered(filter)
+            .attach();
+    }
+
+    private void sendProgressBar(int current, int max) {
+        String left = "#".repeat((int) ((((float) current) / max) * 20));
+        String right = ".".repeat(20 - left.length());
+        int percent = (int) (((float) current) / max * 100);
+        String percentString = percent + "%";
+        percentString = " ".repeat(4 - percentString.length()) + percentString;
+        String message = percentString + " |" + left + right + "| " + current + "/" + max;
+        logger.info(message);
+    }
+
+    public void preloadWorldAndMeasure() {
+        int radius = 12;
+        int chunksLoading = (radius * 2 + 1) * (radius * 2 + 1);
+        AtomicInteger chunksLeft = new AtomicInteger(chunksLoading);
+
+        long start = System.nanoTime();
+        for(int x = -radius; x <= radius; x++) {
+            for(int z = -radius; z <= radius; z++) {
+                instance.loadChunk(x, z).thenAccept(chunk -> {
+                    int left = chunksLeft.decrementAndGet();
+                    if(left == 0) {
+                        long end = System.nanoTime();
+                        sendProgressBar(chunksLoading - left, chunksLoading);
+                        double chunksPerSecond = chunksLoading / ((end - start) / 1000000000.0);
+                        logger.info(
+                            "Preloaded {} chunks in world in {}ms. That's {} Chunks/s",
+                            chunksLoading,
+                            (end - start) / 1000000.0,
+                            chunksPerSecond
+                        );
+
+                        world.displayStats();
+                    } else if(left % 60 == 0) {
+                        sendProgressBar(chunksLoading - left, chunksLoading);
+                    }
+                });
+            }
+        }
+    }
+
+    public void addListeners() {
+        MinecraftServer.getGlobalEventHandler().addListener(AsyncPlayerConfigurationEvent.class, event -> {
+            event.setSpawningInstance(instance);
+            event.getPlayer().setRespawnPoint(new Pos(0.0, 100.0, 0.0));
+        });
+
+        MinecraftServer.getGlobalEventHandler().addListener(PlayerSpawnEvent.class, event -> {
+            event.getPlayer().setGameMode(GameMode.SPECTATOR);
+        });
+    }
+
+    public void addScheduler() {
+        MinecraftServer.getSchedulerManager().buildTask(() -> world.displayStats())
+            .repeat(Duration.ofSeconds(10))
+            .schedule();
+    }
+
+    public void addCommands() {
+        MinecraftServer.getCommandManager().register(new RegenerateCommand());
+    }
+
+    public void bind() {
+        logger.info("Starting server on port 25565");
+        server.start("localhost", 25565);
+    }
+
+    public static void main(String[] args) {
+        TerraMinestomExample example = new TerraMinestomExample();
+        example.createNewInstance();
+        example.attachTerra(null);
+        example.preloadWorldAndMeasure();
+        example.addScheduler();
+        example.addListeners();
+        example.addCommands();
+        example.bind();
+    }
+
+    public class RegenerateCommand extends Command {
+        public RegenerateCommand() {
+            super("regenerate");
+
+            ArgumentInteger cx = new ArgumentInteger("cx");
+            ArgumentInteger cz = new ArgumentInteger("cz");
+
+            setDefaultExecutor((sender, context) -> regenerate(null));
+            addSyntax((sender, context) -> regenerate(new NoFeaturesFilter()), new ArgumentLiteral("noFeatures"));
+            addSyntax((sender, context) -> regenerate(new NoTerrainFilter()), new ArgumentLiteral("noTerrain"));
+            addSyntax((sender, context) -> regenerate(new EvenChunkFilter()), new ArgumentLiteral("evenChunks"));
+            addSyntax((sender, context) -> regenerate(new SpecificChunkFilter(context.get(cx), context.get(cz))), new ArgumentLiteral("chunk"), cx, cz);
+            addSyntax((sender, context) -> regenerate(new XFilter(context.get(cx))), new ArgumentLiteral("x"), cx);
+            addSyntax((sender, context) -> regenerate(new ZFilter(context.get(cz))), new ArgumentLiteral("z"), cz);
+        }
+
+        private void regenerate(@Nullable ChunkFilter filter) {
+            if (filter == null) {
+                instance.sendMessage(Component.text("Regenerating world without filter "));
+            } else {
+                instance.sendMessage(Component.text("Regenerating world with filter " + filter.getClass().getSimpleName()));
+            }
+            createNewInstance();
+            attachTerra(filter);
+            preloadWorldAndMeasure();
+            MinecraftServer.getConnectionManager().getOnlinePlayers().forEach(player ->
+                player.setInstance(instance, new Pos(0, 100, 0))
+            );
+        }
+    }
+}

platforms/minestom/src/main/java/com/dfsek/terra/minestom/api/BlockEntityFactory.java

@@ -0,0 +1,16 @@
+package com.dfsek.terra.minestom.api;
+
+import com.dfsek.terra.api.block.entity.BlockEntity;
+
+import net.minestom.server.coordinate.BlockVec;
+import org.jetbrains.annotations.Nullable;
+
+
+/**
+ * Represents a factory interface for creating instances of BlockEntity
+ * at a specified BlockVec position. This is not implemented directly because
+ * Minestom does not define a way to build block entities out of the box.
+ */
+public interface BlockEntityFactory {
+    @Nullable BlockEntity createBlockEntity(BlockVec position);
+}

platforms/minestom/src/main/java/com/dfsek/terra/minestom/api/EntityFactory.java

@@ -0,0 +1,13 @@
+package com.dfsek.terra.minestom.api;
+
+
+import net.minestom.server.entity.Entity;
+import net.minestom.server.entity.EntityType;
+
+
+/**
+ * Allows adding AI to generated entities using custom entity types
+ */
+public interface EntityFactory {
+    Entity createEntity(EntityType type);
+}

platforms/minestom/src/main/java/com/dfsek/terra/minestom/api/filter/ChunkFilter.java

@@ -0,0 +1,12 @@
+package com.dfsek.terra.minestom.api.filter;
+
+/**
+ * This interface defines a filter for determining whether terrain and features
+ * should be placed during chunk generation. Implementations of this interface
+ * can apply custom logic to selectively control terrain and feature placement
+ * in specific chunks for debugging purposes.
+ */
+public interface ChunkFilter {
+    boolean shouldPlaceTerrain(int x, int z);
+    boolean shouldPlaceFeatures(int x, int z);
+}

platforms/minestom/src/main/java/com/dfsek/terra/minestom/api/filter/EvenChunkFilter.java

@@ -0,0 +1,13 @@
+package com.dfsek.terra.minestom.api.filter;
+
+public class EvenChunkFilter implements ChunkFilter {
+    @Override
+    public boolean shouldPlaceTerrain(int x, int z) {
+        return x % 2 == 0 && z % 2 == 0;
+    }
+
+    @Override
+    public boolean shouldPlaceFeatures(int x, int z) {
+        return x % 2 == 0 && z % 2 == 0;
+    }
+}

platforms/minestom/src/main/java/com/dfsek/terra/minestom/api/filter/NoFeaturesFilter.java

@@ -0,0 +1,13 @@
+package com.dfsek.terra.minestom.api.filter;
+
+public class NoFeaturesFilter implements ChunkFilter {
+    @Override
+    public boolean shouldPlaceTerrain(int x, int z) {
+        return true;
+    }
+
+    @Override
+    public boolean shouldPlaceFeatures(int x, int z) {
+        return false;
+    }
+}

platforms/minestom/src/main/java/com/dfsek/terra/minestom/api/filter/NoTerrainFilter.java

@@ -0,0 +1,13 @@
+package com.dfsek.terra.minestom.api.filter;
+
+public class NoTerrainFilter implements ChunkFilter {
+    @Override
+    public boolean shouldPlaceTerrain(int x, int z) {
+        return false;
+    }
+
+    @Override
+    public boolean shouldPlaceFeatures(int x, int z) {
+        return true;
+    }
+}