Discord and Network refactor

Author: emyfops

build.gradle.kts

@@ -85,6 +85,12 @@ subprojects {
 
     if (path == ":common") return@subprojects
 
+    loom.runs {
+        all {
+            property("lambda.dev", "youtu.be/RYnFIRc0k6E")
+        }
+    }
+
     tasks {
         register<Exec>("renderDoc") {
             val javaHome = Jvm.current().javaHome
@@ -144,7 +150,7 @@ allprojects {
     tasks {
         compileKotlin {
             compilerOptions {
-                jvmTarget.set(JvmTarget.JVM_17)
+                jvmTarget = JvmTarget.JVM_17
             }
         }
     }

common/src/main/kotlin/com/lambda/Lambda.kt

@@ -52,6 +52,8 @@ object Lambda {
     @JvmStatic
     val mc: MinecraftClient by lazy { MinecraftClient.getInstance() }
 
+    val isDebug = System.getProperty("lambda.dev") != null
+
     val gson: Gson = GsonBuilder()
         .setPrettyPrinting()
         .registerTypeAdapter(ModuleTag::class.java, ModuleTagSerializer)

…om/lambda/command/commands/RpcCommand.kt …ambda/command/commands/DiscordCommand.ktcommon/src/main/kotlin/com/lambda/command/commands/RpcCommand.kt renamed to common/src/main/kotlin/com/lambda/command/commands/DiscordCommand.kt common/src/main/kotlin/com/lambda/command/commands/RpcCommand.kt renamed to common/src/main/kotlin/com/lambda/command/commands/DiscordCommand.kt

@@ -23,19 +23,19 @@ import com.lambda.brigadier.argument.word
 import com.lambda.brigadier.execute
 import com.lambda.brigadier.required
 import com.lambda.command.LambdaCommand
-import com.lambda.module.modules.client.DiscordRPC
+import com.lambda.module.modules.client.Discord
 import com.lambda.util.extension.CommandBuilder
 
-object RpcCommand : LambdaCommand(
-    name = "rpc",
-    description = "Discord Rich Presence commands.",
-    usage = "rpc <join [id] | accept>"
+object DiscordCommand : LambdaCommand(
+    name = "discord",
+    description = "Discord Rich Presence commands",
+    usage = "rpc <join [id]>"
 ) {
     override fun CommandBuilder.create() {
         required(literal("join")) {
             required(word("id")) { id ->
                 execute {
-                    DiscordRPC.join(id().value())
+                    Discord.join(id().value())
                 }
             }
         }

common/src/main/kotlin/com/lambda/event/listener/SafeListener.kt

@@ -132,8 +132,8 @@ class SafeListener<T : Event>(
 
         /**
          * This function registers a new [SafeListener] for a generic [Event] type [T].
-         * The [transform] is executed on the same thread where the [Event] was dispatched.
-         * The [transform] will only be executed when the context satisfies certain safety conditions.
+         * The [predicate] is executed on the same thread where the [Event] was dispatched.
+         * The [predicate] will only be executed when the context satisfies certain safety conditions.
          * These conditions are met when none of the following [SafeContext] properties are null:
          * - [SafeContext.world]
          * - [SafeContext.player]
@@ -142,7 +142,7 @@ class SafeListener<T : Event>(
          *
          * This typically occurs when the user is in-game.
          *
-         * After the [transform] is executed once, the [SafeListener] will be automatically unsubscribed.
+         * After the [predicate] is executed once, the [SafeListener] will be automatically unsubscribed.
          *
          * Usage:
          * ```kotlin
@@ -156,24 +156,20 @@ class SafeListener<T : Event>(
          * @param T The type of the event to listen for. This should be a subclass of Event.
          * @param priority The priority of the listener. Listeners with higher priority will be executed first. The Default value is 0.
          * @param alwaysListen If true, the listener will be executed even if it is muted. The Default value is false.
-         * @param transform The function used to transform the event into a value.
          * @return The newly created and registered [SafeListener].
          */
-        inline fun <reified T : Event, reified E> Any.listenOnce(
+        inline fun <reified T : Event> Any.listenOnce(
             priority: Int = 0,
             alwaysListen: Boolean = false,
             noinline predicate: SafeContext.(T) -> Boolean = { true },
-            noinline transform: SafeContext.(T) -> E? = { null },
-        ): ReadWriteProperty<Any?, E?> {
-            val pointer = Pointer<E>()
+        ): ReadWriteProperty<Any?, T?> {
+            val pointer = Pointer<T>()
 
             val destroyable by selfReference<SafeListener<T>> {
                 SafeListener(priority, this@listenOnce, alwaysListen) { event ->
-                    pointer.value = transform(event)
+                    pointer.value = event
 
-                    if (predicate(event) &&
-                        pointer.value != null
-                    ) {
+                    if (predicate(event)) {
                         val self by this@selfReference
                         EventFlow.syncListeners.unsubscribe(self)
                     }

common/src/main/kotlin/com/lambda/event/listener/UnsafeListener.kt

@@ -21,8 +21,11 @@ import com.lambda.context.SafeContext
 import com.lambda.event.Event
 import com.lambda.event.EventFlow
 import com.lambda.event.Muteable
+import com.lambda.threading.runConcurrent
 import com.lambda.util.Pointer
 import com.lambda.util.selfReference
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.Dispatchers
 import kotlin.properties.ReadOnlyProperty
 import kotlin.properties.ReadWriteProperty
 import kotlin.reflect.KProperty
@@ -136,24 +139,20 @@ class UnsafeListener<T : Event>(
          * @param T The type of the event to listen for. This should be a subclass of Event.
          * @param priority The priority of the listener. Listeners with higher priority will be executed first.
          * @param alwaysListen If true, the listener will be executed even if it is muted.
-         * @param transform The function used to transform the event into a value.
          * @return The newly created and registered [UnsafeListener].
          */
-        inline fun <reified T : Event, reified E> Any.listenOnceUnsafe(
+        inline fun <reified T : Event> Any.listenOnceUnsafe(
             priority: Int = 0,
             alwaysListen: Boolean = false,
-            noinline transform: (T) -> E? = { null },
-            noinline predicate: (T) -> Boolean = { true },
-        ): ReadWriteProperty<Any?, E?> {
-            val pointer = Pointer<E>()
+            noinline function: (T) -> Boolean = { true },
+        ): ReadWriteProperty<Any?, T?> {
+            val pointer = Pointer<T>()
 
             val destroyable by selfReference<UnsafeListener<T>> {
                 UnsafeListener(priority, this@listenOnceUnsafe, alwaysListen) { event ->
-                    pointer.value = transform(event)
+                    pointer.value = event
 
-                    if (predicate(event) &&
-                        pointer.value != null
-                    ) {
+                    if (function(event)) {
                         val self by this@selfReference
                         EventFlow.syncListeners.unsubscribe(self)
                     }
@@ -194,10 +193,13 @@ class UnsafeListener<T : Event>(
         inline fun <reified T : Event> Any.listenUnsafeConcurrently(
             priority: Int = 0,
             alwaysListen: Boolean = false,
-            noinline function: (T) -> Unit = {},
+            scheduler: CoroutineDispatcher = Dispatchers.Default,
+            noinline function: suspend (T) -> Unit = {},
         ): UnsafeListener<T> {
             val listener = UnsafeListener<T>(priority, this, alwaysListen) { event ->
-                function(event)
+                runConcurrent(scheduler) {
+                    function(event)
+                }
             }
 
             EventFlow.concurrentListeners.subscribe<T>(listener)