feat!: Non-functional update cobalt

Moonflower-Mods · Sep 27, 2024 · 486dc14 · 486dc14
1 parent 797bf8c
commit 486dc14
Show file tree

Hide file tree

Showing 41 changed files with 574 additions and 475 deletions.
diff --git a/allium/src/main/java/dev/hugeblank/allium/Allium.java b/allium/src/main/java/dev/hugeblank/allium/Allium.java
@@ -16,6 +16,7 @@
 import dev.hugeblank.allium.util.FileHelper;
 import dev.hugeblank.allium.util.Mappings;
 import dev.hugeblank.allium.util.YarnLoader;
+import net.fabricmc.api.EnvType;
 import net.fabricmc.api.ModInitializer;
 import net.fabricmc.loader.api.FabricLoader;
 import net.fabricmc.loader.api.ModContainer;
@@ -62,6 +63,13 @@ public void onInitialize() {
                     initializer.getEntrypoint().onInitialize();
                     mods.add(initializer.getProvider());
                 });
+        if (FabricLoader.getInstance().getEnvironmentType() == EnvType.CLIENT) {
+            FabricLoader.getInstance().getEntrypointContainers(ID+"-client", AlliumExtension.class)
+                    .forEach((initializer) -> {
+                        initializer.getEntrypoint().onInitialize();
+                        mods.add(initializer.getProvider());
+                    });
+        }
         list(mods, "Initialized Extensions: ", (builder, mod) -> builder.append(mod.getMetadata().getId()));
 
         Set<Script> scripts = new HashSet<>();

diff --git a/allium/src/main/java/dev/hugeblank/allium/api/WrappedLuaLibrary.java b/allium/src/main/java/dev/hugeblank/allium/api/WrappedLuaLibrary.java
@@ -4,9 +4,7 @@
 import dev.hugeblank.allium.loader.type.UserdataFactory;
 import dev.hugeblank.allium.loader.type.annotation.LuaWrapped;
 import me.basiqueevangelist.enhancedreflection.api.EClass;
-import org.squiddev.cobalt.LuaState;
-import org.squiddev.cobalt.LuaTable;
-import org.squiddev.cobalt.LuaValue;
+import org.squiddev.cobalt.*;
 import org.squiddev.cobalt.function.LibFunction;
 
 /**
@@ -16,7 +14,7 @@
  */
 public interface WrappedLuaLibrary {
 
-    default LuaValue add(LuaState state, LuaTable globals) {
+    default LuaValue add(LuaState state, LuaTable globals) throws LuaError {
         LuaValue lib = UserdataFactory.of(EClass.fromJava(getClass())).createBound(this);
 
         LuaWrapped wrapped = getClass().getAnnotation(LuaWrapped.class);

diff --git a/allium/src/main/java/dev/hugeblank/allium/loader/EnvironmentManager.java b/allium/src/main/java/dev/hugeblank/allium/loader/EnvironmentManager.java
@@ -8,8 +8,7 @@
 import org.squiddev.cobalt.*;
 import org.squiddev.cobalt.function.LibFunction;
 import org.squiddev.cobalt.function.VarArgFunction;
-import org.squiddev.cobalt.lib.Bit32Lib;
-import org.squiddev.cobalt.lib.CoreLibraries;
+import org.squiddev.cobalt.lib.*;
 
 import java.util.HashSet;
 import java.util.Set;
@@ -24,23 +23,40 @@ public class EnvironmentManager {
         this.state = new LuaState();
     }
 
-    protected LuaTable createEnvironment(Script script) {
-        LuaTable globals = CoreLibraries.debugGlobals(state);
-        Bit32Lib.add(state, globals);
+    protected void createEnvironment(Script script) {
+        LuaTable globals = state.globals();
+        BaseLib.add(globals);
+        try {
+            TableLib.add(state, globals);
+            StringLib.add(state, globals);
+            CoroutineLib.add(state, globals);
+            MathLib.add(state, globals);
+            Utf8Lib.add(state, globals);
+            Bit32Lib.add(state, globals);
+
+            LibFunction.setGlobalLibrary(state, globals, "script",
+                    TypeCoercions.toLuaValue(script, EClass.fromJava(Script.class))
+            );
+        } catch (LuaError error) {
+            script.getLogger().error("Error loading library:", error);
+        }
 
-        LibFunction.setGlobalLibrary(state, globals, "script",
-                TypeCoercions.toLuaValue(script, EClass.fromJava(Script.class))
-        );
         globals.rawset( "print", new PrintMethod(script) );
         globals.rawset( "_HOST", ValueFactory.valueOf(Allium.ID + "_" + Allium.VERSION) );
 
-        INITIALIZERS.forEach(initializer -> initializer.init(script).add(state, globals));
-        LIBRARIES.forEach(library -> library.add(state, globals));
-
+        INITIALIZERS.forEach(initializer -> loadLibrary(script, state, globals, initializer.init(script)));
+        LIBRARIES.forEach(library -> loadLibrary(script, state, globals, library));
+    }
 
-        return globals;
+    private static void loadLibrary(Script script, LuaState state, LuaTable globals, WrappedLuaLibrary adder) {
+        try {
+            adder.add(state, globals);
+        } catch (LuaError error) {
+            script.getLogger().error("Error loading library:", error);
+        }
     }
 
+
     public static void registerLibrary(LibraryInitializer initializer) {
         INITIALIZERS.add(initializer);
     }

diff --git a/allium/src/main/java/dev/hugeblank/allium/loader/PackageLib.java b/allium/src/main/java/dev/hugeblank/allium/loader/PackageLib.java
@@ -6,6 +6,7 @@
 import dev.hugeblank.allium.loader.type.annotation.LuaWrapped;
 import dev.hugeblank.allium.util.JavaHelpers;
 import org.squiddev.cobalt.*;
+import org.squiddev.cobalt.debug.DebugFrame;
 import org.squiddev.cobalt.function.*;
 
 import java.io.IOException;
@@ -31,31 +32,31 @@ public PackageLib(Script script) {
         // When writing a loader in Java, anywhere where a module value can't be determined `nil` should be returned.
         loaders = ValueFactory.listOf(
                 // Loader to check if module has a loader provided by preload table
-                RegisteredFunction.of("preload_loader", this::preloadLoader).create(),
+                RegisteredFunction.ofS("preload_loader", this::preloadLoader).create(),
                 // Loader to check the path internal to the script
-                RegisteredFunction.ofV("path_loader", this::pathLoader).create(),
+                RegisteredFunction.ofS("path_loader", this::pathLoader).create(),
                 // Loader to check the path assuming the first value in the path is a script ID
-                RegisteredFunction.ofV("external_script_loader", this::externScriptLoader).create(),
+                RegisteredFunction.ofS("external_script_loader", this::externScriptLoader).create(),
                 // Loader to check the class files
                 RegisteredFunction.of("java_loader", this::javaLoader).create()
 
         );
     }
 
     @Override
-    public LuaValue add(LuaState state, LuaTable globals) {
-        globals.rawset("require", RegisteredFunction.ofV("require", this::require).create());
+    public LuaValue add(LuaState state, LuaTable globals) throws LuaError {
+        globals.rawset("require", RegisteredFunction.ofS("require", this::require).create());
         return WrappedLuaLibrary.super.add(state, globals);
     }
 
-    public LuaValue preloadLoader(LuaState state, LuaValue arg) throws LuaError, UnwindThrowable {
-        if (preload.rawget(arg).isFunction()){
-            return preload.rawget(arg).checkFunction().call(state, arg);
+    public Varargs preloadLoader(LuaState state, DebugFrame frame, Varargs args) throws LuaError, UnwindThrowable {
+        if (preload.rawget(args.arg(1)) instanceof LuaFunction function){
+            return Dispatch.call(state, function);
         }
         return Constants.NIL;
     }
 
-    private Varargs pathLoader(LuaState state, Varargs args) throws LuaError, UnwindThrowable {
+    private Varargs pathLoader(LuaState state, DebugFrame frame, Varargs args) throws LuaError, UnwindThrowable {
         String modStr = args.arg(1).checkString();
         Entrypoint entrypoint = script.getManifest().entrypoints();
         for (Path path : getPathsFromModule(script, modStr)) {
@@ -69,7 +70,7 @@ private Varargs pathLoader(LuaState state, Varargs args) throws LuaError, Unwind
         return loadFromPaths(state, script, modStr);
     }
 
-    private Varargs externScriptLoader(LuaState state, Varargs args) throws LuaError, UnwindThrowable {
+    private Varargs externScriptLoader(LuaState state, DebugFrame frame, Varargs args) throws LuaError, UnwindThrowable {
         String[] path = args.arg(1).checkString().split("\\.");
         Script candidate = Script.getFromID(path[0]);
         if (candidate != null) {
@@ -142,14 +143,13 @@ private List<Path> getPathsFromModule(Script script, String modStr) {
         return pathList;
     }
 
-    private Varargs require(LuaState state, Varargs args) throws LuaError, UnwindThrowable {
+    private Varargs require(LuaState state, DebugFrame frame, Varargs args) throws LuaError, UnwindThrowable {
         LuaString mod = args.arg(1).checkLuaString();
         if (!loaded.rawget(mod).isNil()) return loaded.rawget(mod);
         for (int i = 1; i <= loaders.length(); i++) {
             LuaValue loader = loaders.rawget(i);
-            if (loader.isFunction()) {
-                LuaFunction f = loader.checkFunction();
-                Varargs contents = f.call(state, mod);
+            if (loader instanceof LuaFunction f) {
+                Varargs contents = Dispatch.call(state, f, mod);
                 if (contents != Constants.NIL) {
                     loaded.rawset(mod, contents.arg(1));
                     return contents;

diff --git a/allium/src/main/java/dev/hugeblank/allium/loader/Script.java b/allium/src/main/java/dev/hugeblank/allium/loader/Script.java
@@ -10,6 +10,7 @@
 import org.squiddev.cobalt.LuaValue;
 import org.squiddev.cobalt.UnwindThrowable;
 import org.squiddev.cobalt.compiler.CompileException;
+import org.squiddev.cobalt.function.Dispatch;
 import org.squiddev.cobalt.function.LuaFunction;
 
 import java.io.FileNotFoundException;
@@ -148,7 +149,7 @@ public LuaValue loadLibrary(LuaState state, Path mod) throws UnwindThrowable, Lu
         // Ensure the modules parent path is the root path, and that the module exists before loading
         try {
             LuaFunction loadValue = getExecutor().load(Files.newInputStream(mod), mod.getFileName().toString());
-            return loadValue.call(state);
+            return Dispatch.call(state, loadValue);
         } catch (FileNotFoundException e) {
             // This should never happen, but if it does, boy do I want to know.
             Allium.LOGGER.warn("File claimed to exist but threw a not found exception...", e);

diff --git a/allium/src/main/java/dev/hugeblank/allium/loader/ScriptExecutor.java b/allium/src/main/java/dev/hugeblank/allium/loader/ScriptExecutor.java
@@ -11,11 +11,10 @@
 
 public class ScriptExecutor extends EnvironmentManager {
     protected final Script script;
-    protected final LuaTable globals;
 
     public ScriptExecutor(Script script) {
         this.script = script;
-        this.globals = createEnvironment(script);
+        createEnvironment(script);
     }
 
     public LuaState getState() {
@@ -56,12 +55,13 @@ public Varargs reload(InputStream dynamic) throws LuaError, CompileException, IO
         return null;
     }
 
-    public LuaFunction load(InputStream stream, String name) throws CompileException, IOException {
+    public LuaFunction load(InputStream stream, String name) throws CompileException, IOException, LuaError {
+        // TODO: Replacing using globals here with an empty table. Does it work?
         return LoadState.load(
                 state,
                 stream,
                 name,
-                this.globals
+                state.globals()
         );
     }
 

diff --git a/allium/src/main/java/dev/hugeblank/allium/loader/type/AlliumUserdata.java b/allium/src/main/java/dev/hugeblank/allium/loader/type/AlliumUserdata.java
@@ -0,0 +1,44 @@
+package dev.hugeblank.allium.loader.type;
+
+import me.basiqueevangelist.enhancedreflection.api.EClass;
+import org.squiddev.cobalt.LuaTable;
+import org.squiddev.cobalt.LuaUserdata;
+
+public class AlliumUserdata<T> extends LuaUserdata {
+    private final EClass<T> clazz;
+
+    AlliumUserdata(Object obj, LuaTable metatable, EClass<T> clazz) {
+        super(obj, metatable);
+        this.clazz = clazz;
+    }
+
+    AlliumUserdata(Object obj, LuaTable metatable, Class<T> clazz) {
+        this(obj, metatable, EClass.fromJava(clazz));
+    }
+
+    public EClass<T> instanceClass() {
+        return clazz;
+    }
+
+
+    public boolean instanceOf(Class<?> test) {
+        return clazz.isAssignableFrom(test);
+    }
+
+    public boolean instanceOf(EClass<?> test) {
+        return clazz.isAssignableFrom(test);
+    }
+
+    public <U> U toUserdata(EClass<U> test) {
+        return toUserdata(test.raw());
+    }
+
+    public <U> U toUserdata(Class<U> test) {
+        return test.cast(instance);
+    }
+
+    @Override
+    public T toUserdata() {
+        return clazz.cast(instance);
+    }
+}