Parked the party feature locally

Author: emyfops

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

@@ -20,140 +20,57 @@ package com.lambda.module.modules.client
 import com.lambda.Lambda
 import com.lambda.context.SafeContext
 import com.lambda.event.EventFlow
-import com.lambda.event.events.RenderEvent
 import com.lambda.event.events.WorldEvent
-import com.lambda.event.listener.SafeListener.Companion.listen
-import com.lambda.event.listener.SafeListener.Companion.listenConcurrently
-import com.lambda.network.api.v1.models.Party
+import com.lambda.event.listener.SafeListener.Companion.listenOnce
 import com.lambda.module.Module
-import com.lambda.module.modules.client.Network.isDiscordLinked
 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.deleteParty
-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.network.api.v1.endpoints.partyUpdates
 import com.lambda.threading.runConcurrent
-import com.lambda.util.Communication.toast
 import com.lambda.util.Communication.warn
 import com.lambda.util.Nameable
 import com.lambda.util.extension.dimensionName
+import com.lambda.util.extension.worldName
 import dev.cbyrne.kdiscordipc.KDiscordIPC
-import dev.cbyrne.kdiscordipc.core.event.DiscordEvent
-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
 
 object Discord : Module(
     name = "Discord",
     description = "Discord Rich Presence configuration",
     defaultTags = setOf(ModuleTag.CLIENT),
-//    enabledByDefault = true, // ToDo: Bring this back on beta release
+	//enabledByDefault = true, // ToDo: Bring this back on beta release
 ) {
-    private val page by setting("Page", Page.General)
-
-    /* General settings */
-    private val delay by setting("Update Delay", 15000L, 15000L..30000L, 100L, unit = "ms") { page == Page.General }
-    private val showTime by setting("Show Time", true, description = "Show how long you have been playing for.") { page == Page.General }
-    private val line1Left by setting("Line 1 Left", LineInfo.WORLD) { page == Page.General }
-    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 }
-
-    /* Party settings */
-    private val createByDefault by setting("Create By Default", true, description = "Create parties on") { page == Page.Party }
+    private val delay       by setting("Update Delay", 5000L, 5000L..30000L, 100L, unit = "ms")
+    private val showTime    by setting("Show Time", true, description = "Show how long you have been playing for.")
+    private val line1Left   by setting("Line 1 Left", LineInfo.WORLD)
+    private val line1Right  by setting("Line 1 Right", LineInfo.USERNAME)
+    private val line2Left   by setting("Line 2 Left", LineInfo.DIMENSION)
+    private val line2Right  by setting("Line 2 Right", LineInfo.FPS)
 
     val rpc = KDiscordIPC(Lambda.APP_ID, scope = EventFlow.lambdaScope)
 
     private var startup = System.currentTimeMillis()
 
     var discordAuth: AuthenticatePacket.Data? = null; private set
-    var currentParty: Party? = null; private set
-
-    val PlayerEntity.isPartyOwner
-        get() = uuid == currentParty?.leader?.uuid
-
-    val PlayerEntity.isInParty: Boolean
-        get() = currentParty?.players?.any { it.uuid == uuid } ?: false
 
     init {
-        rpc.subscribe()
-
-        // ToDo: Nametag for friends when ref/ui is merged
-        // listen<RenderEvent.World>()
-
-        listenConcurrently<WorldEvent.Join> {
+        listenOnce<WorldEvent.Join> {
             // If the player is in a party and this most likely means that the `onEnable`
             // block ran and is already handling the activity
-            if (rpc.connected && player.isInParty) return@listenConcurrently
-
-            start()
-            handleLoop()
-            stop()
-        }
+            if (rpc.connected) return@listenOnce false
 
-        onDisable { stop() }
-        onEnable { runConcurrent { start(); handleLoop() } }
-    }
+            runConcurrent {
+                start()
+                handleLoop()
+            }
 
-    /**
-     * Creates a new party, leaves or delete the current party if there is one
-     */
-    fun SafeContext.partyCreate() {
-        if (!isDiscordLinked) return warn("You did not link your discord account")
-        if (player.isInParty) {
-            if (player.isPartyOwner) deleteParty() else leaveParty()
+            return@listenOnce true
         }
 
-        val (party, error) = createParty()
-        if (error != null) return warn("Failed to create a party: ${error.exception}")
-
-        currentParty = party
-        partyUpdates { currentParty = it }
-    }
-
-    /**
-     * Joins a new party with the invitation ID
-     */
-    fun SafeContext.partyJoin(id: String) {
-        if (!isDiscordLinked) return warn("You did not link your discord account")
-
-        val (party, error) = joinParty(id)
-        if (error != null) return warn("Failed to join the party: ${error.errorData}")
-
-        currentParty = party
-        partyUpdates { currentParty = it }
-    }
-
-    /**
-     * Leaves the current party
-     */
-    fun SafeContext.partyLeave() {
-        if (!isDiscordLinked) return warn("You did not link your discord account")
-        if (!player.isInParty) return warn("You are not in a party")
-
-        val (_, error) = leaveParty()
-        if (error != null) return warn("Failed to leave the party: ${error.errorData}")
-
-        currentParty = null
-    }
-
-    /**
-     * Deletes the current party
-     */
-    fun SafeContext.partyDelete() {
-        if (!isDiscordLinked) return warn("You did not link your discord account")
-        if (!player.isInParty) return warn("You are not in a party")
-
-        val (_, error) = deleteParty()
-        if (error != null) return warn("Failed to delete the party: ${error.exception}")
-
-        currentParty = null
-
+        onEnable { runConcurrent { start(); handleLoop() } }
+	    onDisable { stop() }
     }
 
     private suspend fun start() {
@@ -164,10 +81,7 @@ object Discord : Module(
 
         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")
-        }
+        if (error != null) return warn("Failed to link the discord account to the minecraft auth")
 
         updateToken(authResp)
         discordAuth = auth
@@ -177,71 +91,29 @@ object Discord : Module(
         if (rpc.connected) rpc.disconnect()
     }
 
-    private fun KDiscordIPC.subscribe() {
-        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
-        }
-    }
-
     private suspend fun SafeContext.handleLoop() {
-        if (isDiscordLinked) {
-            if (createByDefault) createParty()
-            partyUpdates { currentParty = it }
-        }
-
         while (rpc.connected) {
             update()
             delay(delay)
         }
-
-        if (isDiscordLinked) leaveParty()
     }
 
     private suspend fun SafeContext.update() {
-        val party = currentParty
-
         rpc.activityManager.setActivity {
             details = "${line1Left.value(this@update)} | ${line1Right.value(this@update)}".take(128)
             state = "${line2Left.value(this@update)} | ${line2Right.value(this@update)}".take(128)
 
             largeImage("lambda", Lambda.VERSION)
             smallImage("https://mc-heads.net/avatar/${mc.gameProfile.id}/nohelm", mc.gameProfile.name)
-
-            if (party != null) {
-                party(party.id.toString(), party.players.size, 20) // Placeholder while
-                secrets(party.joinSecret)
-            } else {
-                button("Download", "https://github.com/lambda-client/lambda")
-            }
+            button("Download", "https://github.com/lambda-client/lambda")
 
             if (showTime) timestamps(startup)
         }
     }
 
-    private enum class Page {
-        General, Party
-    }
-
     private enum class LineInfo(val value: SafeContext.() -> String) : Nameable {
         VERSION({ Lambda.VERSION }),
-        WORLD({
-            when {
-                mc.currentServerEntry != null -> "Multiplayer"
-                mc.isIntegratedServerRunning -> "Singleplayer"
-                else -> "Main Menu"
-            }
-        }),
+        WORLD({ worldName }),
         USERNAME({ mc.session.username }),
         HEALTH({ "${mc.player?.health ?: 0} HP" }),
         HUNGER({ "${mc.player?.hungerManager?.foodLevel ?: 0} Hunger" }),