refactor(minestom): replace static singleton access to platform with dependency injection for better modularity

Renamed `MinestomPlatform` to `TerraMinestomPlatform` and updated `TerraMinestomWorldBuilder` to utilize the platform instance directly. Simplified world builder initialization and improved code clarity.

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

@@ -31,7 +31,8 @@ public class TerraMinestomExample {
     }
 
     public void attachTerra() {
-        world = TerraMinestomWorldBuilder.from(instance)
+        TerraMinestomPlatform platform = new TerraMinestomPlatform();
+        world = platform.worldBuilder(instance)
             .defaultPack()
             .attach();
     }

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

@@ -2,6 +2,7 @@ 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;
@@ -14,34 +15,41 @@ 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.world.TerraMinestomWorldBuilder;
 
 import net.minestom.server.MinecraftServer;
+import net.minestom.server.instance.Instance;
 import org.jetbrains.annotations.NotNull;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.io.File;
-import java.io.IOException;
 
 
+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;
 
-public final class MinestomPlatform extends AbstractPlatform {
+    public TerraMinestomPlatform(WorldHandle worldHandle, ItemHandle itemHandle, TypeLoader<PlatformBiome> biomeTypeLoader) {
-    private static final Logger LOGGER = LoggerFactory.getLogger(MinestomPlatform.class);
+        this.worldHandle = worldHandle;
-    private static MinestomPlatform INSTANCE = null;
+        this.itemHandle = itemHandle;
-    private final MinestomWorldHandle worldHandle = new MinestomWorldHandle();
+        this.biomeTypeLoader = biomeTypeLoader;
-    private final MinestomItemHandle itemHandle = new MinestomItemHandle();
-
-    private MinestomPlatform() {
         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(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));
     }
@@ -88,10 +96,11 @@ public final class MinestomPlatform extends AbstractPlatform {
         return file;
     }
 
-    public static MinestomPlatform getInstance() {
+    public TerraMinestomWorldBuilder worldBuilder(Instance instance) {
-        if(INSTANCE == null) {
+        return new TerraMinestomWorldBuilder(this, instance);
-            INSTANCE = new MinestomPlatform();
     }
-        return INSTANCE;
+
+    public TerraMinestomWorldBuilder worldBuilder() {
+        return new TerraMinestomWorldBuilder(this, MinecraftServer.getInstanceManager().createInstanceContainer());
     }
 }

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

@@ -4,7 +4,7 @@ import com.dfsek.terra.api.config.ConfigPack;
 
 import com.dfsek.terra.api.registry.CheckedRegistry;
 
-import com.dfsek.terra.minestom.MinestomPlatform;
+import com.dfsek.terra.minestom.TerraMinestomPlatform;
 import com.dfsek.terra.minestom.api.BlockEntityFactory;
 import com.dfsek.terra.minestom.api.EntityFactory;
 import com.dfsek.terra.minestom.block.DefaultBlockEntityFactory;
@@ -18,20 +18,16 @@ 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 = new DefaultBlockEntityFactory();
 
-    private TerraMinestomWorldBuilder(Instance instance) { this.instance = instance; }
+    public TerraMinestomWorldBuilder(TerraMinestomPlatform platform, Instance instance) {
-
+        this.platform = platform;
-    public static TerraMinestomWorldBuilder from(Instance instance) {
+        this.instance = instance;
-        return new TerraMinestomWorldBuilder(instance);
-    }
-
-    public static TerraMinestomWorldBuilder builder() {
-        return new TerraMinestomWorldBuilder(MinecraftServer.getInstanceManager().createInstanceContainer());
     }
 
     public TerraMinestomWorldBuilder pack(ConfigPack pack) {
@@ -40,13 +36,13 @@ public class TerraMinestomWorldBuilder {
     }
 
     public TerraMinestomWorldBuilder packById(String id) {
-        this.pack = MinestomPlatform.getInstance().getConfigRegistry().getByID(id).orElseThrow();
+        this.pack = platform.getConfigRegistry().getByID(id).orElseThrow();
 
         return this;
     }
 
     public TerraMinestomWorldBuilder findPack(Function<CheckedRegistry<ConfigPack>, ConfigPack> fn) {
-        this.pack = fn.apply(MinestomPlatform.getInstance().getConfigRegistry());
+        this.pack = fn.apply(platform.getConfigRegistry());
         return this;
     }