Fix: Plugins not executed correctly

Author: emyfops

common/build.gradle.kts

@@ -24,6 +24,7 @@ dependencies {
 
     // Add Kotlin
     implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:$kotlinxCoroutinesVersion")
+    implementation(kotlin("reflect"))
 
     // Baritone
     modImplementation("baritone-api:baritone-api:1.10.2")

common/src/main/kotlin/com/lambda/core/Loader.kt

@@ -14,14 +14,14 @@ import kotlin.system.measureTimeMillis
 
 object Loader {
     private val loadables = listOf(
-        PluginRegistry,
         ModuleRegistry,
         CommandManager,
         RotationManager,
         PlayerPacketManager,
         LambdaFont.Loader,
         GuiConfigurable,
         FriendManager,
+        PluginRegistry, // The plugins must absolutely be loaded last
     )
 
     fun initialize() {

common/src/main/kotlin/com/lambda/plugin/JarClassLoader.kt

@@ -0,0 +1,36 @@
+package com.lambda.plugin
+
+import java.util.jar.JarFile
+
+class JarClassLoader(
+    private val jarFile: JarFile,
+    parent: ClassLoader,
+) : ClassLoader(parent) {
+    private val classes = mutableMapOf<String, ByteArray>()
+    private val resources = mutableMapOf<String, ByteArray>()
+
+    init {
+        jarFile.entries().asSequence().forEach { entry ->
+            if (entry.isDirectory) return@forEach
+
+            val bytes = jarFile.getInputStream(entry).use { it.readBytes() }
+            if (entry.name.endsWith(".class")) {
+                classes[
+                    entry.name.removeSuffix(".class")
+                        .replace('/', '.')
+                ] = bytes
+            } else {
+                resources[entry.name] = bytes
+            }
+        }
+    }
+
+    public override fun findClass(name: String): Class<*> {
+        val clazz = classes[name] ?: throw ClassNotFoundException(name)
+        return defineClass(name, clazz, 0, clazz.size)
+    }
+
+    fun close() {
+        jarFile.close()
+    }
+}

common/src/main/kotlin/com/lambda/plugin/PluginRegistry.kt

@@ -1,30 +1,34 @@
 package com.lambda.plugin
 
-import com.lambda.Lambda
 import com.lambda.Lambda.LOG
 import com.lambda.core.Loadable
-import com.lambda.plugin.api.Plugin
-import com.lambda.util.Communication.warn
 import com.lambda.util.FolderRegister.createIfNotExists
 import com.lambda.util.FolderRegister.listRecursive
 import com.lambda.util.FolderRegister.plugins
 import java.io.File
-import java.net.URLClassLoader
 import java.util.jar.JarFile
 
 object PluginRegistry : Loadable {
     private fun loadPlugin(file: File) {
-        val loader = URLClassLoader(arrayOf(file.toURI().toURL()))
-        val manifest = JarFile(file).manifest
-        val mainClass = manifest.mainAttributes.getValue("Main-Class")
+        if (!file.name.endsWith(".jar")) return
+        if (file.length() == 0L) return LOG.error("The plugin $file is empty")
 
-        val clazz = loader.loadClass(mainClass)
-        val isObject = clazz.declaredFields.any { it.name == "INSTANCE" }
-        val instance = if (isObject) clazz.getDeclaredField("INSTANCE").get(null)
-        else clazz.getDeclaredConstructor().newInstance()
+        val jar = JarFile(file)
+        val loader = JarClassLoader(jar, this::class.java.classLoader)
+        val mainClass = jar.manifest.mainAttributes.getValue("Main-Class")
+            ?: return LOG.error("The plugin $jar does not have a main class")
 
-        if (instance is Plugin) instance.load()
-        else LOG.warn("Plugin $file is not a valid plugin")
+        val clazz = loader.findClass(mainClass)
+        val instance =
+            clazz.declaredFields.firstOrNull { it.name == "INSTANCE" }?.get(null) ?: clazz.constructors.firstOrNull()
+                ?.newInstance()
+            ?: return LOG.error("The plugin $jar does not have an object instance or a public constructor")
+
+        val loadMethod =
+            clazz.methods.find { it.name == "load" } ?: return LOG.warn("The plugin $jar does not have a load method")
+
+        loadMethod.invoke(instance)
+        loader.close()
     }
 
     override fun load(): String {

common/src/main/kotlin/com/lambda/util/FolderRegister.kt

@@ -11,9 +11,12 @@ import java.net.InetSocketAddress
 /**
  * The [FolderRegister] object is responsible for managing the directory structure of the application.
  *
- * @property minecraft The root directory of the Minecraft client. It is retrieved using the [Platform.getGameFolder] function of the Architectury API.
+ * @property minecraft The root directory of the Minecraft client.
  * @property lambda The directory for the Lambda client, located within the Minecraft directory.
  * @property config The directory for storing configuration files, located within the Lambda directory.
+ * @property packetLogs The directory for storing packet logs, located within the Lambda directory.
+ * @property replay The directory for storing replay files, located within the Lambda directory.
+ * @property plugins The directory for storing plugin files, located within the Lambda directory.
  */
 object FolderRegister {
     val minecraft: File = mc.runDirectory