Apply biomes to minestom instances

buildSrc/src/main/kotlin/Versions.kt

@@ -87,6 +87,6 @@ object Versions {
     }
 
     object Minestom {
-        const val minestom = "fb895cb899"
+        const val minestom = "1_21_5-4d91778331"
     }
 }

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

@@ -6,6 +6,7 @@
 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.PlayerDisconnectEvent;
 import net.minestom.server.event.player.PlayerSpawnEvent;
 import net.minestom.server.instance.Instance;
 import net.minestom.server.instance.LightingChunk;
@@ -16,23 +17,24 @@
 import java.util.concurrent.atomic.AtomicInteger;
 
 import com.dfsek.terra.minestom.world.TerraMinestomWorld;
-import com.dfsek.terra.minestom.world.TerraMinestomWorldBuilder;
 
 
 public class TerraMinestomExample {
     private static final Logger logger = LoggerFactory.getLogger(TerraMinestomExample.class);
     private final MinecraftServer server = MinecraftServer.init();
     private Instance instance;
     private TerraMinestomWorld world;
+    private final TerraMinestomPlatform platform = new TerraMinestomPlatform();
 
     public void createNewInstance() {
         instance = MinecraftServer.getInstanceManager().createInstanceContainer();
         instance.setChunkSupplier(LightingChunk::new);
     }
 
     public void attachTerra() {
-        world = TerraMinestomWorldBuilder.from(instance)
+        world = platform.worldBuilder(instance)
             .defaultPack()
+            .doFineGrainedBiomes(false)
             .attach();
     }
 
@@ -121,12 +123,16 @@ public RegenerateCommand() {
 
         private void regenerate() {
             instance.sendMessage(Component.text("Regenerating world"));
+            Instance oldInstance = instance;
+            platform.reload();
             createNewInstance();
             attachTerra();
             preloadWorldAndMeasure();
             MinecraftServer.getConnectionManager().getOnlinePlayers().forEach(player ->
                 player.setInstance(instance, new Pos(0, 100, 0))
             );
+
+            MinecraftServer.getInstanceManager().unregisterInstance(oldInstance);
         }
     }
 }

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

@@ -2,48 +2,78 @@
 
 import com.dfsek.tectonic.api.TypeRegistry;
 import com.dfsek.tectonic.api.loader.type.TypeLoader;
+
 import com.dfsek.terra.AbstractPlatform;
+import com.dfsek.terra.api.addon.BaseAddon;
 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.addon.MinestomAddon;
+import com.dfsek.terra.minestom.config.BiomeAdditionsSoundTemplate;
+import com.dfsek.terra.minestom.config.BiomeParticleConfigTemplate;
 import com.dfsek.terra.minestom.biome.MinestomBiomeLoader;
+import com.dfsek.terra.minestom.config.KeyLoader;
+import com.dfsek.terra.minestom.config.BiomeMoodSoundTemplate;
+import com.dfsek.terra.minestom.config.RGBLikeLoader;
+import com.dfsek.terra.minestom.config.SoundEventTemplate;
 import com.dfsek.terra.minestom.entity.MinestomEntityType;
 import com.dfsek.terra.minestom.item.MinestomItemHandle;
 import com.dfsek.terra.minestom.world.MinestomChunkGeneratorWrapper;
 import com.dfsek.terra.minestom.world.MinestomWorldHandle;
-import com.dfsek.terra.registry.master.ConfigRegistry.PackLoadFailuresException;
 
+import com.dfsek.terra.minestom.api.TerraMinestomWorldBuilder;
+
+import net.kyori.adventure.key.Key;
+import net.kyori.adventure.util.RGBLike;
 import net.minestom.server.MinecraftServer;
+import net.minestom.server.instance.Instance;
+import net.minestom.server.sound.SoundEvent;
+import net.minestom.server.world.biome.BiomeEffects;
 import org.jetbrains.annotations.NotNull;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.io.File;
-import java.io.IOException;
-
-
-
-public final class MinestomPlatform extends AbstractPlatform {
-    private static final Logger LOGGER = LoggerFactory.getLogger(MinestomPlatform.class);
-    private static MinestomPlatform INSTANCE = null;
-    private final MinestomWorldHandle worldHandle = new MinestomWorldHandle();
-    private final MinestomItemHandle itemHandle = new MinestomItemHandle();
-
-    private MinestomPlatform() {
+import java.util.ArrayList;
+import java.util.List;
+
+
+public final class TerraMinestomPlatform extends AbstractPlatform {
+    private static final Logger LOGGER = LoggerFactory.getLogger(TerraMinestomPlatform.class);
+    private final WorldHandle worldHandle;
+    private final ItemHandle itemHandle;
+    private final TypeLoader<PlatformBiome> biomeTypeLoader;
+    private final ArrayList<BaseAddon> platformAddons = new ArrayList<>(List.of(new MinestomAddon(this)));
+
+    public TerraMinestomPlatform(WorldHandle worldHandle, ItemHandle itemHandle, TypeLoader<PlatformBiome> biomeTypeLoader, BaseAddon... extraAddons) {
+        this.worldHandle = worldHandle;
+        this.itemHandle = itemHandle;
+        this.biomeTypeLoader = biomeTypeLoader;
+        this.platformAddons.addAll(List.of(extraAddons));
         load();
         getEventManager().callEvent(new PlatformInitializationEvent());
     }
 
+    public TerraMinestomPlatform() {
+        this(new MinestomWorldHandle(), new MinestomItemHandle(), new MinestomBiomeLoader());
+    }
+
     @Override
     public void register(TypeRegistry registry) {
         super.register(registry);
         registry
-            .registerLoader(PlatformBiome.class, new MinestomBiomeLoader())
+            .registerLoader(PlatformBiome.class, biomeTypeLoader)
+            .registerLoader(RGBLike.class, new RGBLikeLoader())
+            .registerLoader(Key.class, new KeyLoader())
             .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));
+            .registerLoader(BlockState.class, (TypeLoader<BlockState>) (annotatedType, o, configLoader, depthTracker) -> worldHandle.createBlockState((String) o))
+            .registerLoader(BiomeEffects.Particle.class, BiomeParticleConfigTemplate::new)
+            .registerLoader(BiomeEffects.MoodSound.class, BiomeMoodSoundTemplate::new)
+            .registerLoader(BiomeEffects.AdditionsSound.class, BiomeAdditionsSoundTemplate::new)
+            .registerLoader(SoundEvent.class, SoundEventTemplate::new);
     }
 
     @Override
@@ -82,16 +112,22 @@ public boolean reload() {
     @Override
     public @NotNull File getDataFolder() {
         String pathName = System.getProperty("terra.datafolder");
-        if (pathName == null) pathName = "./terra/";
+        if(pathName == null) pathName = "./terra/";
         File file = new File(pathName);
         if(!file.exists()) file.mkdirs();
         return file;
     }
 
-    public static MinestomPlatform getInstance() {
-        if(INSTANCE == null) {
-            INSTANCE = new MinestomPlatform();
-        }
-        return INSTANCE;
+    @Override
+    protected Iterable<BaseAddon> platformAddon() {
+        return platformAddons;
+    }
+
+    public TerraMinestomWorldBuilder worldBuilder(Instance instance) {
+        return new TerraMinestomWorldBuilder(this, instance);
+    }
+
+    public TerraMinestomWorldBuilder worldBuilder() {
+        return new TerraMinestomWorldBuilder(this, MinecraftServer.getInstanceManager().createInstanceContainer());
     }
 }

platforms/minestom/src/main/java/com/dfsek/terra/minestom/addon/MinestomAddon.java

@@ -0,0 +1,47 @@
+package com.dfsek.terra.minestom.addon;
+
+import ca.solostudios.strata.Versions;
+import ca.solostudios.strata.version.Version;
+
+import com.dfsek.terra.api.addon.BaseAddon;
+
+import com.dfsek.terra.api.event.events.config.ConfigurationLoadEvent;
+import com.dfsek.terra.api.event.functional.FunctionalEventHandler;
+import com.dfsek.terra.api.world.biome.Biome;
+
+import com.dfsek.terra.minestom.TerraMinestomPlatform;
+
+import com.dfsek.terra.minestom.config.VanillaBiomeProperties;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+
+public class MinestomAddon implements BaseAddon {
+    private static final Version VERSION = Versions.getVersion(1, 0, 0);
+    private static final Logger logger = LoggerFactory.getLogger(MinestomAddon.class);
+    private final TerraMinestomPlatform minestomPlatform;
+
+    public MinestomAddon(TerraMinestomPlatform minestomPlatform) {
+        this.minestomPlatform = minestomPlatform;
+    }
+
+    @Override
+    public void initialize() {
+        minestomPlatform.getEventManager()
+            .getHandler(FunctionalEventHandler.class)
+            .register(this, ConfigurationLoadEvent.class)
+            .then(event -> {
+                if(event.is(Biome.class)) {
+                    event.getLoadedObject(Biome.class).getContext().put(event.load(new VanillaBiomeProperties()));
+                }
+            })
+            .global();
+    }
+
+    @Override
+    public Version getVersion() { return VERSION; }
+
+    @Override
+    public String getID() { return "terra-minestom"; }
+}

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

@@ -0,0 +1,15 @@
+package com.dfsek.terra.minestom.api;
+
+import com.dfsek.terra.api.config.ConfigPack;
+import com.dfsek.terra.api.world.biome.Biome;
+import com.dfsek.terra.minestom.biome.UserDefinedBiome;
+
+
+/**
+ * BiomeFactory serves as a contract for creating custom user-defined biomes in Terra.
+ * Implementations of this interface are responsible for defining the logic to convert
+ * configured biomes and source biome data into instances of UserDefinedBiome.
+ */
+public interface BiomeFactory {
+    UserDefinedBiome create(ConfigPack pack, Biome source);
+}

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

@@ -8,8 +8,8 @@
 
 /**
  * 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.
+ * at a specified BlockVec position. For more fine-grained control, users
+ * may supply their own version of this interface.
  */
 public interface BlockEntityFactory {
     @Nullable BlockEntity createBlockEntity(BlockVec position);

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

@@ -0,0 +1,91 @@
+package com.dfsek.terra.minestom.api;
+
+import com.dfsek.terra.api.config.ConfigPack;
+
+import com.dfsek.terra.api.registry.CheckedRegistry;
+
+import com.dfsek.terra.minestom.TerraMinestomPlatform;
+import com.dfsek.terra.minestom.biome.MinestomUserDefinedBiomeFactory;
+import com.dfsek.terra.minestom.block.DefaultBlockEntityFactory;
+import com.dfsek.terra.minestom.entity.DefaultEntityFactory;
+
+import com.dfsek.terra.minestom.world.TerraMinestomWorld;
+import net.minestom.server.instance.Instance;
+
+import java.util.Random;
+import java.util.function.Function;
+
+
+public class TerraMinestomWorldBuilder {
+    private final TerraMinestomPlatform platform;
+    private final Instance instance;
+    private ConfigPack pack;
+    private long seed = new Random().nextLong();
+    private EntityFactory entityFactory = new DefaultEntityFactory();
+    private BlockEntityFactory blockEntityFactory;
+    private BiomeFactory biomeFactory = new MinestomUserDefinedBiomeFactory();
+    private boolean doFineGrainedBiomes = true;
+
+    public TerraMinestomWorldBuilder(TerraMinestomPlatform platform, Instance instance) {
+        this.platform = platform;
+        this.instance = instance;
+        this.blockEntityFactory = new DefaultBlockEntityFactory(instance);
+    }
+
+    public TerraMinestomWorldBuilder pack(ConfigPack pack) {
+        this.pack = pack;
+        return this;
+    }
+
+    public TerraMinestomWorldBuilder packById(String id) {
+        this.pack = platform.getConfigRegistry().getByID(id).orElseThrow();
+
+        return this;
+    }
+
+    public TerraMinestomWorldBuilder findPack(Function<CheckedRegistry<ConfigPack>, ConfigPack> fn) {
+        this.pack = fn.apply(platform.getConfigRegistry());
+        return this;
+    }
+
+    public TerraMinestomWorldBuilder defaultPack() {
+        return this.packById("OVERWORLD");
+    }
+
+    public TerraMinestomWorldBuilder seed(long seed) {
+        this.seed = seed;
+        return this;
+    }
+
+    public TerraMinestomWorldBuilder entityFactory(EntityFactory factory) {
+        this.entityFactory = factory;
+        return this;
+    }
+
+    public TerraMinestomWorldBuilder blockEntityFactory(BlockEntityFactory factory) {
+        this.blockEntityFactory = factory;
+        return this;
+    }
+
+    public TerraMinestomWorldBuilder biomeFactory(BiomeFactory factory) {
+        this.biomeFactory = factory;
+        return this;
+    }
+
+    /**
+     * Due to a current bug with the minestom biome encoder, sometimes, the client gets kicked when decoding a chunk
+     * packet with more than one biome. Until this is fixed in minestom, one can disable fine-grained biomes to prevent
+     * this issue.
+     *
+     * @deprecated Scheduled for removal once Minestom rolls out a fix
+     */
+    @Deprecated
+    public TerraMinestomWorldBuilder doFineGrainedBiomes(boolean doFineGrainedBiomes) {
+        this.doFineGrainedBiomes = doFineGrainedBiomes;
+        return this;
+    }
+
+    public TerraMinestomWorld attach() {
+        return new TerraMinestomWorld(platform, instance, pack, seed, entityFactory, blockEntityFactory, biomeFactory, doFineGrainedBiomes);
+    }
+}

platforms/minestom/src/main/java/com/dfsek/terra/minestom/biome/MinestomBiome.java

@@ -2,16 +2,17 @@
 
 import com.dfsek.terra.api.world.biome.PlatformBiome;
 
+import net.minestom.server.registry.DynamicRegistry;
 import net.minestom.server.world.biome.Biome;
 
 
 public class MinestomBiome implements PlatformBiome {
-    private final Biome biome;
+    private final DynamicRegistry.Key<Biome> biome;
 
-    public MinestomBiome(Biome biome) { this.biome = biome; }
+    public MinestomBiome(DynamicRegistry.Key<Biome> biome) { this.biome = biome; }
 
     @Override
-    public Biome getHandle() {
+    public DynamicRegistry.Key<Biome> getHandle() {
         return biome;
     }
 }

platforms/minestom/src/main/java/com/dfsek/terra/minestom/biome/MinestomBiomeLoader.java

@@ -11,6 +11,7 @@
 import net.minestom.server.MinecraftServer;
 import net.minestom.server.registry.DynamicRegistry;
 import net.minestom.server.world.biome.Biome;
+import org.intellij.lang.annotations.Subst;
 import org.jetbrains.annotations.NotNull;
 
 import java.lang.reflect.AnnotatedType;
@@ -21,6 +22,7 @@ public class MinestomBiomeLoader implements TypeLoader<PlatformBiome> {
     @Override
     public PlatformBiome load(@NotNull AnnotatedType annotatedType, @NotNull Object o, @NotNull ConfigLoader configLoader,
                               DepthTracker depthTracker) throws LoadException {
+        @Subst("name:value")
         String id = (String) o;
         Key key = Key.key(id);
         Biome biome = biomeRegistry.get(key);