better registry controller

Author: emyfops

common/src/main/kotlin/com/lambda/core/registry/AgnosticRegistries.kt

@@ -0,0 +1,71 @@
+package com.lambda.core.registry
+
+import com.lambda.util.Communication.warn
+import jdk.internal.org.jline.keymap.KeyMap.key
+import net.minecraft.registry.Registry
+import net.minecraft.registry.RegistryKey
+import net.minecraft.registry.entry.RegistryEntry
+import net.minecraft.util.Identifier
+
+/**
+ * Controller for handling temporary registry holders.
+ * This is used to register entries into registries before they are actually loaded.
+ * It allows for environment-agnostic registry handling.
+ */
+object AgnosticRegistries {
+    private val registries = HashMap<
+            RegistryKey<out Registry<*>?>,
+            MutableList<RegistryHolder<*>>
+            >()
+
+    /**
+     * Registers a temporary registry holder.
+     * This should be called after the controller has dumped its registries.
+     * If not, the holder will not be dumped into its respective registry.
+     *
+     * @param registry The registry to register the holder for.
+     * @param id The identifier for the registry entry.
+     * @param value The value to register.
+     *
+     * @return The registry holder.
+     */
+    fun <T> register(registry: Registry<T>, id: Identifier, value: T): RegistryHolder<T> {
+        val holder = RegistryHolder(id, value)
+
+        registries.getOrPut(registry.key) { mutableListOf() }.add(holder)
+        return holder
+    }
+
+    /**
+     * Loads the temporary registry holders into the actual registry.
+     * This should be called after all registry holders have been created.
+     *
+     * @param registry The registry to dump into.
+     */
+    fun dump(registry: Registry<*>?) = dump(registry, wrapper = null)
+
+    /**
+     * Loads the temporary registry holders into the actual registry.
+     * This should be called after all registry holders have been created.
+     *
+     * @param registry The registry to dump into.
+     * @param wrapper The registry wrapper to use to determine how to register the entry.
+     */
+    fun dump(registry: Registry<*>?, wrapper: RegistryWrapper<*>?) {
+        val key = registry?.key ?: return warn("Tried to dump into a null registry.")
+
+        registries[key]?.forEach { it.handleRegister(wrapper ?: defaultWrapper(registry)) }
+        registries.remove(key)
+    }
+
+    /**
+     * Default registry wrapper for vanilla registries.
+     */
+    private fun defaultWrapper(registry: Registry<*>?): RegistryWrapper<*> {
+        return object : RegistryWrapper<Any> {
+            override fun <T> registerForHolder(id: Identifier?, value: T): RegistryEntry<T> {
+                return Registry.registerReference(registry as Registry<T>, id, value)
+            }
+        }
+    }
+}

common/src/main/kotlin/com/lambda/core/registry/RegistryController.kt

@@ -15,11 +15,11 @@ class RegistryHolder<T> internal constructor(
         with(holder) {
             checkNotNull(this) { "RegistryHolder not populated" }
 
-            return this.value()
+            return value()
         }
     }
 
     fun handleRegister(registry: RegistryWrapper<*>) {
-        this.holder = registry.registerForHolder(id, value)
+        holder = registry.registerForHolder(id, value)
     }
 }

common/src/main/kotlin/com/lambda/core/registry/RegistryHolder.kt

@@ -1,13 +1,13 @@
 package com.lambda.sound
 
 import com.lambda.core.Loadable
-import com.lambda.core.registry.RegistryController
+import com.lambda.core.registry.AgnosticRegistries
 import net.minecraft.registry.Registries
 
 object SoundRegistry : Loadable {
     override fun load(): String {
         LambdaSound.entries.forEach {
-            RegistryController.register(Registries.SOUND_EVENT, it.id, it.event)
+            AgnosticRegistries.register(Registries.SOUND_EVENT, it.id, it.event)
         }
 
         return "Loaded ${LambdaSound.entries.size} sounds"

common/src/main/kotlin/com/lambda/sound/SoundRegistry.kt

@@ -4,25 +4,15 @@ import com.lambda.Lambda
 import com.lambda.Lambda.LOG
 import com.lambda.Lambda.MOD_NAME
 import com.lambda.Lambda.VERSION
-import com.lambda.core.registry.RegistryController
-import com.lambda.core.registry.RegistryWrapper
+import com.lambda.core.registry.AgnosticRegistries
 import net.fabricmc.api.ClientModInitializer
 import net.minecraft.registry.Registries
-import net.minecraft.registry.Registry
-import net.minecraft.registry.entry.RegistryEntry
-import net.minecraft.util.Identifier
 
 object LambdaFabric : ClientModInitializer {
     override fun onInitializeClient() {
         Lambda.initialize()
         LOG.info("$MOD_NAME Fabric $VERSION initialized.")
 
-        Registries.REGISTRIES.forEach { registry ->
-            RegistryController.register(registry.key, object : RegistryWrapper<Any> {
-                override fun <T> registerForHolder(id: Identifier?, value: T): RegistryEntry<T> {
-                    return Registry.registerReference(registry as Registry<T>, id, value)
-                }
-            })
-        }
+        Registries.REGISTRIES.forEach(AgnosticRegistries::dump)
     }
 }

fabric/src/main/kotlin/com/lambda/fabric/LambdaFabric.kt

@@ -4,12 +4,8 @@ import com.lambda.Lambda
 import com.lambda.Lambda.LOG
 import com.lambda.Lambda.MOD_NAME
 import com.lambda.Lambda.VERSION
-import com.lambda.core.registry.RegistryController
-import com.lambda.core.registry.RegistryWrapper
+import com.lambda.core.registry.AgnosticRegistries
 import com.lambda.graphics.RenderMain
-import net.minecraft.registry.Registry
-import net.minecraft.registry.entry.RegistryEntry
-import net.minecraft.util.Identifier
 import net.minecraftforge.api.distmarker.Dist
 import net.minecraftforge.api.distmarker.OnlyIn
 import net.minecraftforge.client.event.RenderGuiEvent
@@ -30,14 +26,9 @@ object LambdaForge {
         LOG.info("$MOD_NAME Forge $VERSION initialized.")
     }
 
+    // Forge forces the user to user their event in order to interact with registries.
     @SubscribeEvent
-    fun onRegistrySetup(event: RegisterEvent) {
-        RegistryController.register(event.registryKey, object : RegistryWrapper<Any> {
-            override fun <T> registerForHolder(id: Identifier?, value: T): RegistryEntry<T> {
-                return Registry.registerReference(event.getVanillaRegistry(), id, value)
-            }
-        })
-    }
+    fun onRegistrySetup(event: RegisterEvent) = AgnosticRegistries.dump(event.getVanillaRegistry<Any>())
 
     // Most events here are hooked due to forge not caring about others
     // and directly patching the minecraft classes.