Merge remote-tracking branch 'origin/feature/packetmine-rewrite' into feature/packetmine-rewrite

Author: beanbag44

common/src/main/kotlin/com/lambda/event/Subscriber.kt

@@ -39,6 +39,14 @@ class Subscriber : ConcurrentHashMap<KClass<out Event>, ConcurrentSkipListSet<Li
     inline fun <reified T : Event> subscribe(listener: Listener<T>) =
         getOrPut(T::class) { defaultListenerSet }.add(listener)
 
+    /**
+     * Allows a [Listener] to start receiving a specific type of [Event]'s [KClass implementation](KC).
+     *
+     * This should only be used in cases where the type of the event is erased.
+     */
+    fun <T : Event> subscribe(kClass: KClass<out T>, listener: Listener<T>) =
+        getOrPut(kClass) { defaultListenerSet }.add(listener)
+
     /** Allows a [Subscriber] to start receiving all [Event]s of another [Subscriber]. */
     infix fun subscribe(subscriber: Subscriber) {
         subscriber.forEach { (eventType, listeners) ->
@@ -56,6 +64,7 @@ class Subscriber : ConcurrentHashMap<KClass<out Event>, ConcurrentSkipListSet<Li
 
     /**
      * Unsubscribes all listeners associated with the current instance (the caller object).
+     *
      * This method iterates over all values in the `Subscriber`'s map and removes listeners
      * whose `owner` property matches the caller object.
      *

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

@@ -30,6 +30,7 @@ import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.Dispatchers
 import kotlin.properties.ReadOnlyProperty
 import kotlin.properties.ReadWriteProperty
+import kotlin.reflect.KClass
 import kotlin.reflect.KProperty
 
 
@@ -130,6 +131,51 @@ class SafeListener<T : Event>(
             return listener
         }
 
+        /**
+         * This function registers a new [SafeListener] for a generic [Event] type [T] with the given [KClass] instance to circumvent type erasure.
+         * The [function] is executed on the same thread where the [Event] was dispatched.
+         * The [function] 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]
+         * - [SafeContext.interaction]
+         * - [SafeContext.connection]
+         *
+         * This typically occurs when the user is in-game.
+         *
+         * Usage:
+         * ```kotlin
+         * listen(MyEvent::class) { event ->
+         *     player.sendMessage("Event received: $event")
+         * }
+         *
+         * listen(MyEvent::class, priority = 1) { event ->
+         *     player.sendMessage("Event received before the previous listener: $event")
+         * }
+         * ```
+         *
+         * @param kClass The KClass instance of covariant type [T] used to circumvent type erasure.
+         * @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 function The function to be executed when the event is posted. This function should take a SafeContext and an event of type T as parameters.
+         * @return The newly created and registered [SafeListener].
+         */
+        fun <T : Event> Any.listen(
+            kClass: KClass<out T>,
+            priority: Int = 0,
+            alwaysListen: Boolean = false,
+            function: SafeContext.(T) -> Unit = {},
+        ): SafeListener<T> {
+            val listener = SafeListener<T>(priority, this, alwaysListen) { event ->
+                runGameScheduled { function(event) }
+            }
+
+            EventFlow.syncListeners.subscribe(kClass, listener)
+
+            return listener
+        }
+
         /**
          * This function registers a new [SafeListener] for a generic [Event] type [T].
          * The [predicate] is executed on the same thread where the [Event] was dispatched.
@@ -176,7 +222,7 @@ class SafeListener<T : Event>(
                 }
             }
 
-            EventFlow.syncListeners.subscribe<T>(destroyable)
+            EventFlow.syncListeners.subscribe(destroyable)
 
             return pointer
         }
@@ -218,7 +264,7 @@ class SafeListener<T : Event>(
                 }
             }
 
-            EventFlow.concurrentListeners.subscribe<T>(listener)
+            EventFlow.concurrentListeners.subscribe(listener)
 
             return listener
         }

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

@@ -113,7 +113,7 @@ class UnsafeListener<T : Event>(
                 function(event)
             }
 
-            EventFlow.syncListeners.subscribe<T>(listener)
+            EventFlow.syncListeners.subscribe(listener)
 
             return listener
         }
@@ -159,7 +159,7 @@ class UnsafeListener<T : Event>(
                 }
             }
 
-            EventFlow.syncListeners.subscribe<T>(destroyable)
+            EventFlow.syncListeners.subscribe(destroyable)
 
             return pointer
         }
@@ -202,9 +202,12 @@ class UnsafeListener<T : Event>(
                 }
             }
 
-            EventFlow.concurrentListeners.subscribe<T>(listener)
+            EventFlow.concurrentListeners.subscribe(listener)
 
             return listener
         }
     }
+
+    override fun toString() =
+        "SafeListener(priority=$priority, owner=${owner::class.simpleName}, alwaysListen=$alwaysListen)"
 }

common/src/main/kotlin/com/lambda/interaction/request/RequestHandler.kt

@@ -24,6 +24,7 @@ import com.lambda.event.events.TickEvent
 import com.lambda.event.listener.SafeListener.Companion.listen
 import com.lambda.interaction.request.ManagerUtils.accumulatedManagerPriority
 import com.lambda.threading.runSafe
+import kotlin.reflect.KClass
 
 /**
  * This class handles requests, offering specific opening times, and an option to queue a request for the
@@ -57,25 +58,7 @@ abstract class RequestHandler<R : Request>(
     var activeThisTick = false; protected set
 
     override fun load(): String {
-        openStages.forEach {
-            when (it) {
-                is TickEvent.Pre -> openRequestsFor(it)
-                is TickEvent.Post -> openRequestsFor(it)
-                is TickEvent.Network.Pre -> openRequestsFor(it)
-                is TickEvent.Network.Post -> openRequestsFor(it)
-                is TickEvent.Input.Pre -> openRequestsFor(it)
-                is TickEvent.Input.Post -> openRequestsFor(it)
-                is TickEvent.WorldRender.Pre -> openRequestsFor(it)
-                is TickEvent.WorldRender.Post -> openRequestsFor(it)
-                is TickEvent.Sound.Pre -> openRequestsFor(it)
-                is TickEvent.Sound.Post -> openRequestsFor(it)
-                is TickEvent.Render.Pre -> openRequestsFor(it)
-                is TickEvent.Render.Post -> openRequestsFor(it)
-                is TickEvent.Player.Pre -> openRequestsFor(it)
-                is TickEvent.Player.Post -> openRequestsFor(it)
-                else -> throw IllegalArgumentException("Event '$it' is not allowed for requests")
-            }
-        }
+        openStages.forEach { openRequestsFor(it::class, it) }
 
         listen<TickEvent.Post>(Int.MIN_VALUE) {
             activeThisTick = false
@@ -87,8 +70,8 @@ abstract class RequestHandler<R : Request>(
     /**
      * opens the handler for requests for the duration of the given event
      */
-    private inline fun <reified T : Event> openRequestsFor(stage: T) {
-        listen<T>(priority = Int.MAX_VALUE - (accumulatedManagerPriority - stagePriority)) {
+    private inline fun <reified T : Event> openRequestsFor(instance: KClass<out T>, stage: T) {
+        listen(instance, priority = Int.MAX_VALUE - (accumulatedManagerPriority - stagePriority)) {
             tickStage = stage
             queuedRequest?.let { request ->
                 handleRequest(request)
@@ -99,7 +82,8 @@ abstract class RequestHandler<R : Request>(
             onOpen?.invoke(this)
             preEvent()
         }
-        listen<T>(priority = Int.MIN_VALUE + stagePriority) {
+
+        listen(instance, priority = Int.MIN_VALUE + stagePriority) {
             onClose?.invoke(this)
             acceptingRequests = false
         }