Refactored the network, discord and http

Author: emyfops

common/src/main/kotlin/com/lambda/command/commands/DiscordCommand.kt

@@ -24,6 +24,8 @@ import com.lambda.brigadier.execute
 import com.lambda.brigadier.required
 import com.lambda.command.LambdaCommand
 import com.lambda.module.modules.client.Discord
+import com.lambda.module.modules.client.Discord.rpc
+import com.lambda.threading.runConcurrent
 import com.lambda.util.extension.CommandBuilder
 
 object DiscordCommand : LambdaCommand(
@@ -39,5 +41,27 @@ object DiscordCommand : LambdaCommand(
                 }
             }
         }
+
+        required(literal("accept")) {
+            required(word("user")) { user ->
+                execute {
+                    runConcurrent { rpc.activityManager.acceptJoinRequest(user().value()) }
+                }
+            }
+        }
+
+        required(literal("refuse")) {
+            required(word("user")) { user ->
+                execute {
+                    runConcurrent { rpc.activityManager.refuseJoinRequest(user().value()) }
+                }
+            }
+        }
+
+        required(literal("create")) {
+            execute {
+                Discord.createParty()
+            }
+        }
     }
 }

common/src/main/kotlin/com/lambda/module/modules/client/Discord.kt

@@ -18,33 +18,30 @@
 package com.lambda.module.modules.client
 
 import com.lambda.Lambda
-import com.lambda.Lambda.LOG
 import com.lambda.context.SafeContext
+import com.lambda.event.EventFlow
 import com.lambda.event.events.ConnectionEvent
 import com.lambda.event.listener.UnsafeListener.Companion.listenUnsafeConcurrently
 import com.lambda.network.api.v1.models.Party
 import com.lambda.module.Module
-import com.lambda.module.modules.client.Network.discordAuth
-import com.lambda.module.modules.client.Network.isAuthenticated
-import com.lambda.module.modules.client.Network.rpc
-import com.lambda.module.modules.client.Network.apiAuth
+import com.lambda.module.modules.client.Network.updateToken
 import com.lambda.module.tag.ModuleTag
 import com.lambda.network.api.v1.endpoints.createParty
 import com.lambda.network.api.v1.endpoints.editParty
 import com.lambda.network.api.v1.endpoints.joinParty
 import com.lambda.network.api.v1.endpoints.leaveParty
+import com.lambda.network.api.v1.endpoints.linkDiscord
 import com.lambda.threading.runConcurrent
 import com.lambda.threading.runSafe
 import com.lambda.util.Communication
 import com.lambda.util.Communication.toast
+import com.lambda.util.Communication.warn
 import com.lambda.util.Nameable
-import com.lambda.util.StringUtils.capitalize
+import com.lambda.util.extension.dimensionName
 import dev.cbyrne.kdiscordipc.KDiscordIPC
 import dev.cbyrne.kdiscordipc.core.event.DiscordEvent
-import dev.cbyrne.kdiscordipc.core.event.impl.ActivityJoinEvent
-import dev.cbyrne.kdiscordipc.core.event.impl.ActivityJoinRequestEvent
-import dev.cbyrne.kdiscordipc.core.event.impl.ErrorEvent
 import dev.cbyrne.kdiscordipc.core.event.impl.ReadyEvent
+import dev.cbyrne.kdiscordipc.core.packet.inbound.impl.AuthenticatePacket
 import dev.cbyrne.kdiscordipc.data.activity.*
 import kotlinx.coroutines.delay
 import net.minecraft.entity.player.PlayerEntity
@@ -64,91 +61,134 @@ object Discord : Module(
     private val line1Right by setting("Line 1 Right", LineInfo.USERNAME) { page == Page.General }
     private val line2Left by setting("Line 2 Left", LineInfo.DIMENSION) { page == Page.General }
     private val line2Right by setting("Line 2 Right", LineInfo.FPS) { page == Page.General }
-    private val confirmCoordinates by setting("Show Coordinates", false, description = "Confirm display the player coordinates") { page == Page.General }
-    private val confirmServer by setting("Show Server IP", false, description = "Confirm display the server IP") { page == Page.General }
 
     /* Party settings */
-    private val enableParty by setting("Enable Party", true, description = "Allows you to create parties.") { page == Page.Party } // ToDo: Change this for create by default instead
+    private val createByDefault by setting("Create By Default", true, description = "Create parties on") { page == Page.Party }
     private val maxPlayers by setting("Max Players", 10, 2..20) { page == Page.Party }.onValueChange { _, _ -> if (player.isPartyOwner) edit() } // ToDo: Avoid spam requests
 
-    private var startup = System.currentTimeMillis()
-    private val dimensionRegex = Regex("""\b\w+_\w+\b""") // ToDo: Change this when combat is merged
+    val rpc = KDiscordIPC(Lambda.APP_ID, scope = EventFlow.lambdaScope)
 
-    private var ready: ReadyEvent? = null
-    private var currentParty: Party? = null
+    private var startup = System.currentTimeMillis()
 
-    private val isPartyInteractionAllowed: Boolean
-        get() = apiAuth != null && discordAuth != null
+    var discordAuth: AuthenticatePacket.Data? = null; private set
+    var currentParty: Party? = null; private set
 
     val PlayerEntity.isPartyOwner
         get() = uuid == currentParty?.leader?.uuid
 
     val PlayerEntity.isInParty
-        get() = currentParty?.players?.any { it.uuid == this.uuid }
+        get() = currentParty?.players?.any { it.uuid == uuid }
 
     init {
+        rpc.subscribe()
+
         listenUnsafeConcurrently<ConnectionEvent.Connect.Post> {
             // FixMe: We have to wait even though this is the last event until toSafe() != null
             //  because of timing
             delay(3000)
-            runSafe { connect() }
+            runSafe { handleLoop() }
         }
 
-        // TODO: Exponential backoff up to 25 seconds to avoid being rate limited by discord
-        onEnable { connect() }
-        onDisable { disconnect() }
+        onEnable { runConcurrent { startDiscord(); handleLoop() } }
+        onDisable { stopDiscord() }
     }
 
     fun createParty() {
-        if (!isPartyInteractionAllowed) return
+        if (discordAuth == null) return toast("Can not interact with the api (are you offline?)")
 
         val (party, error) = createParty(maxPlayers, true)
         if (error != null) toast("Failed to create a party: ${error.message}", Communication.LogLevel.WARN)
 
         currentParty = party
     }
 
-    // Join a party using the ID
+    /**
+     * Joins a new party with the invitation ID
+     */
     fun join(id: String) {
-        if (!isPartyInteractionAllowed) return
+        if (discordAuth == null) return toast("Can not interact with the api (are you offline?)")
 
         val (party, error) = joinParty(id)
         if (error != null) toast("Failed to join the party: ${error.message}", Communication.LogLevel.WARN)
 
         currentParty = party
     }
 
-    // Edit the current party if you are the owner
-    private fun edit() {
-        if (!isPartyInteractionAllowed) return
+    /**
+     * Triggers a party edit request if you are the owner
+     */
+    fun edit() {
+        if (discordAuth == null) return toast("Can not interact with the api (are you offline?)")
 
         val (party, error) = editParty(maxPlayers)
         if (error != null) toast("Failed to edit the party: ${error.message}", Communication.LogLevel.WARN)
 
         currentParty = party
     }
 
-    private fun SafeContext.connect() {
-        // FixMe: Race condition
-        runConcurrent { rpc.connect() } // ToDo: Duplicate rpc connection network and discord
-        runConcurrent { rpc.register() }
-        runConcurrent {
-            while (rpc.connected) {
-                update()
-                delay(delay)
-            }
+    /**
+     * Leaves the current party
+     */
+    fun leave() {
+        if (discordAuth == null || currentParty == null) return toast("Can not interact with the api (are you offline?)")
+
+        val (_, error) = leaveParty()
+        if (error != null) return toast("Failed to edit the party: ${error.message}", Communication.LogLevel.WARN)
+
+        currentParty = null
+    }
+
+    private suspend fun startDiscord() {
+        if (rpc.connected) return
+
+        rpc.subscribe()
+        runConcurrent { rpc.connect() } // TODO: Create a function that will wait until x seconds has passed or if the connection is successful
+        delay(1000)
+
+        val auth = rpc.applicationManager.authenticate()
+        val (authResp, error) = linkDiscord(discordToken = auth.accessToken)
+        if (error != null) {
+            warn(error.message.toString())
+            return toast("Failed to link the discord account to the minecraft auth")
         }
+
+        authResp?.let { updateToken(it) }
+        discordAuth = auth
+    }
+
+    private fun stopDiscord() {
+        if (!rpc.connected) return
+
+        rpc.disconnect()
     }
 
-    private fun disconnect() {
-        if (rpc.connected) {
-            LOG.info("Gracefully disconnecting from Discord RPC.")
-            leaveParty()
-            rpc.disconnect()
+    private fun KDiscordIPC.subscribe() {
+        // ToDO: Get party on join event
+        on<ReadyEvent> {
+            subscribe(DiscordEvent.VoiceChannelSelect)
+            subscribe(DiscordEvent.VoiceStateCreate)
+            subscribe(DiscordEvent.VoiceStateUpdate)
+            subscribe(DiscordEvent.VoiceStateDelete)
+            subscribe(DiscordEvent.VoiceSettingsUpdate)
+            subscribe(DiscordEvent.VoiceConnectionStatus)
+            subscribe(DiscordEvent.SpeakingStart)
+            subscribe(DiscordEvent.SpeakingStop)
+            subscribe(DiscordEvent.ActivityJoin)
+            subscribe(DiscordEvent.ActivityJoinRequest)
+            subscribe(DiscordEvent.OverlayUpdate)
+            // subscribe(DiscordEvent.ActivitySpectate) // Unsupported
         }
+    }
 
-        ready = null
-        currentParty = null
+    private suspend fun SafeContext.handleLoop() {
+        if (createByDefault) createParty(maxPlayers)
+
+        while (rpc.connected) {
+            update()
+            delay(delay)
+        }
+
+        leave()
     }
 
     private suspend fun SafeContext.update() {
@@ -161,7 +201,7 @@ object Discord : Module(
             largeImage("lambda", Lambda.VERSION)
             smallImage("https://mc-heads.net/avatar/${mc.gameProfile.id}/nohelm", mc.gameProfile.name)
 
-            if (isAuthenticated && party != null) {
+            if (party != null) {
                 party(party.id.toString(), party.players.size, party.settings.maxPlayers)
                 secrets(party.joinSecret)
             } else {
@@ -172,33 +212,6 @@ object Discord : Module(
         }
     }
 
-    private suspend fun KDiscordIPC.register() {
-        on<ReadyEvent> {
-            ready = this
-
-            // Party features
-            subscribe(DiscordEvent.ActivityJoinRequest)
-            subscribe(DiscordEvent.ActivityJoin)
-
-            if (enableParty) createParty()
-        }
-
-        // Event when someone would like to join your party
-        on<ActivityJoinRequestEvent> {
-            toast("The user ${data.userId} has invited you")
-            rpc.activityManager.acceptJoinRequest(data.userId)
-        }
-
-        // Event when someone joins your party
-        on<ActivityJoinEvent> {
-            LOG.info("Someone has joined")
-        }
-
-        on<ErrorEvent> {
-            LOG.error("Discord RPC error: ${data.message}")
-        }
-    }
-
     private enum class Page {
         General, Party
     }
@@ -215,19 +228,9 @@ object Discord : Module(
         USERNAME({ mc.session.username }),
         HEALTH({ "${mc.player?.health ?: 0} HP" }),
         HUNGER({ "${mc.player?.hungerManager?.foodLevel ?: 0} Hunger" }),
-        DIMENSION({
-            mc.world?.registryKey?.value?.path?.replace(dimensionRegex) {
-                it.value.split("_").joinToString(" ") { it.capitalize() }
-            } ?: "Unknown"
-        }),
-        COORDINATES({
-            if (confirmCoordinates) "Coords: ${mc.player?.blockPos?.toShortString()}"
-            else "[Redacted]"
-        }),
-        SERVER({
-            if (confirmServer) mc.currentServerEntry?.address ?: "Not Connected"
-            else "[Redacted]"
-        }),
+        DIMENSION({ dimensionName }),
+        COORDINATES({ "Coords: ${player.blockPos.toShortString()}" }),
+        SERVER({ mc.currentServerEntry?.address ?: "Not Connected" }),
         FPS({ "${mc.currentFps} FPS" });
     }
 }