Rename for Emy

Author: Avanatiker

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

@@ -192,7 +192,7 @@ class UnsafeListener<T : Event>(
          * @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 [UnsafeListener].
          */
-        inline fun <reified T : Event> Any.listenUnsafeConcurrently(
+        inline fun <reified T : Event> Any.listenConcurrentlyUnsafe(
             priority: Int = 0,
             alwaysListen: Boolean = false,
             scheduler: CoroutineDispatcher = Dispatchers.Default,

src/main/kotlin/com/lambda/module/modules/network/PacketLogger.kt

@@ -17,13 +17,12 @@
 
 package com.lambda.module.modules.network
 
-import com.google.gson.JsonPrimitive
 import com.lambda.Lambda
 import com.lambda.Lambda.mc
 import com.lambda.event.events.PacketEvent
 import com.lambda.event.events.TickEvent
 import com.lambda.event.listener.UnsafeListener.Companion.listenUnsafe
-import com.lambda.event.listener.UnsafeListener.Companion.listenUnsafeConcurrently
+import com.lambda.event.listener.UnsafeListener.Companion.listenConcurrentlyUnsafe
 import com.lambda.module.Module
 import com.lambda.module.tag.ModuleTag
 import com.lambda.threading.runIO
@@ -188,20 +187,20 @@ object PacketLogger : Module(
             it.packet.logSent()
         }
 
-        listenUnsafeConcurrently<PacketEvent.Receive.Pre> {
+        listenConcurrentlyUnsafe<PacketEvent.Receive.Pre> {
             if (!logConcurrent
                 || !scope.shouldLog(it.packet)
                 || !networkSide.shouldLog(NetworkSide.Server)
-            ) return@listenUnsafeConcurrently
+            ) return@listenConcurrentlyUnsafe
 
             it.packet.logReceived()
         }
 
-        listenUnsafeConcurrently<PacketEvent.Send.Pre> {
+        listenConcurrentlyUnsafe<PacketEvent.Send.Pre> {
             if (!logConcurrent
                 || !scope.shouldLog(it.packet)
                 || !networkSide.shouldLog(NetworkSide.Client)
-            ) return@listenUnsafeConcurrently
+            ) return@listenConcurrentlyUnsafe
 
             it.packet.logSent()
         }

src/main/kotlin/com/lambda/network/LambdaAPI.kt

@@ -25,7 +25,7 @@ import com.lambda.event.events.ClientEvent
 import com.lambda.event.events.ConnectionEvent
 import com.lambda.event.events.ConnectionEvent.Connect.Login.EncryptionResponse
 import com.lambda.event.listener.UnsafeListener.Companion.listenUnsafe
-import com.lambda.event.listener.UnsafeListener.Companion.listenUnsafeConcurrently
+import com.lambda.event.listener.UnsafeListener.Companion.listenConcurrentlyUnsafe
 import com.lambda.network.NetworkManager.updateToken
 import com.lambda.network.api.v1.endpoints.login
 import com.lambda.util.StringUtils.hash
@@ -58,7 +58,7 @@ object LambdaAPI : Configurable(LambdaConfig) {
     private var hash: String? = null
 
     init {
-        listenUnsafeConcurrently<ClientEvent.Startup> { authenticate() }
+        listenConcurrentlyUnsafe<ClientEvent.Startup> { authenticate() }
 
         listenUnsafe<EncryptionResponse> { event ->
             if (event.secretKey.isDestroyed) return@listenUnsafe
@@ -70,14 +70,14 @@ object LambdaAPI : Configurable(LambdaConfig) {
             hash = BigInteger(computed).toString(16)
         }
 
-        listenUnsafeConcurrently<ConnectionEvent.Connect.Post> {
+        listenConcurrentlyUnsafe<ConnectionEvent.Connect.Post> {
             // FixMe: If the player have the properties but are invalid this doesn't work
-            if (NetworkManager.isValid || mc.gameProfile.isOffline) return@listenUnsafeConcurrently
+            if (NetworkManager.isValid || mc.gameProfile.isOffline) return@listenConcurrentlyUnsafe
 
             // If we log in right as the client responds to the encryption request, we start
             // a race condition where the game server haven't acknowledged the packets
             // and posted to the sessionserver api
-            login(mc.session.username, hash ?: return@listenUnsafeConcurrently)
+            login(mc.session.username, hash ?: return@listenConcurrentlyUnsafe)
                 .onSuccess { updateToken(it) }
                 .onFailure { LOG.warn(it) }
         }