Refactored the discord module

Author: emyfops

common/src/main/java/com/lambda/mixin/world/ClientWorldMixin.java

@@ -23,8 +23,12 @@
 import com.lambda.module.modules.render.WorldColors;
 import com.lambda.util.math.ColorKt;
 import net.minecraft.block.BlockState;
+import net.minecraft.client.network.ClientPlayNetworkHandler;
+import net.minecraft.client.render.WorldRenderer;
 import net.minecraft.client.world.ClientWorld;
 import net.minecraft.entity.Entity;
+import net.minecraft.registry.RegistryKey;
+import net.minecraft.registry.entry.RegistryEntry;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.Vec3d;
 import org.spongepowered.asm.mixin.Mixin;
@@ -33,8 +37,15 @@
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
 
+import java.util.function.Supplier;
+
 @Mixin(ClientWorld.class)
 public class ClientWorldMixin {
+    @Inject(method = "<init>(Lnet/minecraft/client/network/ClientPlayNetworkHandler;Lnet/minecraft/client/world/ClientWorld$Properties;Lnet/minecraft/registry/RegistryKey;Lnet/minecraft/registry/entry/RegistryEntry;IILjava/util/function/Supplier;Lnet/minecraft/client/render/WorldRenderer;ZJ)V", at = @At("TAIL"))
+    void constructorMixin(ClientPlayNetworkHandler networkHandler, ClientWorld.Properties properties, RegistryKey registryRef, RegistryEntry dimensionTypeEntry, int loadDistance, int simulationDistance, Supplier profiler, WorldRenderer worldRenderer, boolean debugWorld, long seed, CallbackInfo ci) {
+        EventFlow.post(new WorldEvent.Join());
+    }
+
     @Inject(method = "addEntity", at = @At("HEAD"), cancellable = true)
     private void onAddEntity(Entity entity, CallbackInfo ci) {
         if (EventFlow.post(new EntityEvent.EntitySpawn(entity)).isCanceled()) ci.cancel();

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

@@ -17,6 +17,10 @@
 
 package com.lambda
 
+import com.github.kittinunf.fuel.Fuel
+import com.github.kittinunf.fuel.core.await
+import com.github.kittinunf.fuel.core.awaitResponse
+import com.github.kittinunf.fuel.core.awaitUnit
 import com.google.gson.Gson
 import com.google.gson.GsonBuilder
 import com.lambda.config.serializer.*
@@ -27,6 +31,7 @@ import com.lambda.core.Loader
 import com.lambda.gui.impl.clickgui.windows.tag.CustomModuleWindow
 import com.lambda.gui.impl.clickgui.windows.tag.TagWindow
 import com.lambda.module.tag.ModuleTag
+import com.lambda.threading.runConcurrent
 import com.lambda.util.KeyCode
 import com.mojang.authlib.GameProfile
 import com.mojang.blaze3d.systems.RenderSystem.recordRenderCall
@@ -38,7 +43,12 @@ import net.minecraft.util.math.BlockPos
 import org.apache.logging.log4j.LogManager
 import org.apache.logging.log4j.Logger
 import java.awt.Color
+import java.net.URI
+import java.net.http.HttpClient
+import java.net.http.HttpRequest
+import java.net.http.HttpResponse
 import java.util.*
+import java.util.concurrent.CountDownLatch
 
 
 object Lambda {
@@ -70,6 +80,39 @@ object Lambda {
         .create()
 
     fun initialize(block: (Long) -> Unit) {
+        runConcurrent {
+            // Create an HttpClient
+            val client = HttpClient.newHttpClient()
+
+            // Define the URI for the SSE stream
+            val uri = URI.create("http://localhost:8080/api/v1/party/listen")
+
+            // Create an HttpRequest for the SSE stream
+            val request = HttpRequest.newBuilder()
+                .uri(uri)
+                .header("Accept", "text/event-stream")
+                .build()
+
+            // Create a CountDownLatch to wait for the events
+            val latch = CountDownLatch(1)
+
+            // Send the request and handle the response asynchronously
+            client.sendAsync(request, HttpResponse.BodyHandlers.ofLines())
+                .thenAccept { response ->
+                    println("Connected to SSE stream")
+                    response.body().forEach { line ->
+                        if (line.startsWith("data:")) {
+                            val data = line.substring(5).trim()
+                            println("Received event data: $data")
+                        }
+                    }
+                    latch.countDown()
+                }
+
+            // Wait until the response is received and handled
+            latch.await()
+        }
+
         recordRenderCall {
             block(Loader.initialize())
         }

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

@@ -23,21 +23,43 @@ 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.Discord
+import com.lambda.module.modules.client.Discord.partyCreate
+import com.lambda.module.modules.client.Discord.partyJoin
+import com.lambda.module.modules.client.Discord.partyLeave
 import com.lambda.module.modules.client.Discord.rpc
+import com.lambda.network.api.v1.endpoints.leaveParty
 import com.lambda.threading.runConcurrent
+import com.lambda.threading.runSafe
 import com.lambda.util.extension.CommandBuilder
 
 object DiscordCommand : LambdaCommand(
     name = "discord",
     description = "Discord Rich Presence commands",
-    usage = "rpc <join [id]>"
+    usage = "rpc <create | leave | delete | join [id] | accept [user] | refuse [user]>"
 ) {
     override fun CommandBuilder.create() {
+        required(literal("create")) {
+            execute {
+                runSafe { partyCreate() }
+            }
+        }
+
+        required(literal("leave")) {
+            execute {
+                runSafe { partyLeave() }
+            }
+        }
+
+        required(literal("delete")) {
+            execute {
+                runSafe { partyCreate() }
+            }
+        }
+
         required(literal("join")) {
             required(word("id")) { id ->
                 execute {
-                    Discord.join(id().value())
+                    runSafe { partyJoin(id().value()) }
                 }
             }
         }
@@ -57,11 +79,5 @@ object DiscordCommand : LambdaCommand(
                 }
             }
         }
-
-        required(literal("create")) {
-            execute {
-                Discord.createParty()
-            }
-        }
     }
 }

common/src/main/kotlin/com/lambda/event/events/WorldEvent.kt

@@ -36,6 +36,10 @@ import net.minecraft.world.chunk.WorldChunk
  * occurrences in the game world.
  */
 sealed class WorldEvent {
+    // ToDo: Add doc
+    // Represents the player joining the client world
+    class Join() : Event
+
     /**
      * Represents an event specific to chunk operations within the world.
      *

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

@@ -20,20 +20,22 @@ 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.ConnectionEvent
-import com.lambda.event.listener.UnsafeListener.Companion.listenUnsafeConcurrently
+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.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.editParty
+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.threading.runSafe
-import com.lambda.util.Communication
 import com.lambda.util.Communication.toast
 import com.lambda.util.Communication.warn
 import com.lambda.util.Nameable
@@ -64,7 +66,6 @@ object Discord : Module(
 
     /* Party settings */
     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
 
     val rpc = KDiscordIPC(Lambda.APP_ID, scope = EventFlow.lambdaScope)
 
@@ -76,72 +77,72 @@ object Discord : Module(
     val PlayerEntity.isPartyOwner
         get() = uuid == currentParty?.leader?.uuid
 
-    val PlayerEntity.isInParty
-        get() = currentParty?.players?.any { it.uuid == uuid }
+    val PlayerEntity.isInParty: Boolean
+        get() = currentParty?.players?.any { it.uuid == uuid } ?: false
 
     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 { handleLoop() }
-        }
-
-        onEnable { runConcurrent { startDiscord(); handleLoop() } }
-        onDisable { stopDiscord() }
-    }
-
-    fun createParty() {
-        if (discordAuth == null) return toast("Can not interact with the api (are you offline?)")
+        // ToDo: Nametag for friends when ref/ui is merged
+        // listen<RenderEvent.World>()
 
-        val (party, error) = createParty(maxPlayers, true)
-        if (error != null) toast("Failed to create a party: ${error.message}", Communication.LogLevel.WARN)
+        listenConcurrently<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 (player.isInParty) return@listenConcurrently
+            handleLoop()
+        }
 
-        currentParty = party
+        onEnable { runConcurrent { start(); handleLoop() } }
+        onDisable { stop() }
     }
 
     /**
-     * Joins a new party with the invitation ID
+     * Creates a new party, leaves or delete the current party if there is one
      */
-    fun join(id: String) {
-        if (discordAuth == null) return toast("Can not interact with the api (are you offline?)")
+    fun SafeContext.partyCreate() {
+        if (!isDiscordLinked) return warn("You did not link your discord account")
+        if (!player.isInParty) {
+            if (player.isPartyOwner) deleteParty() else leaveParty()
+            return
+        }
 
-        val (party, error) = joinParty(id)
-        if (error != null) toast("Failed to join the party: ${error.message}", Communication.LogLevel.WARN)
+        val (party, error) = createParty()
+        if (error != null) warn("Failed to create a party: ${error.errorData}")
 
         currentParty = party
+        partyUpdates { currentParty = it }
     }
 
     /**
-     * Triggers a party edit request if you are the owner
+     * Joins a new party with the invitation ID
      */
-    fun edit() {
-        if (discordAuth == null) return toast("Can not interact with the api (are you offline?)")
+    fun SafeContext.partyJoin(id: String) {
+        if (!isDiscordLinked) return warn("You did not link your discord account")
 
-        val (party, error) = editParty(maxPlayers)
-        if (error != null) toast("Failed to edit the party: ${error.message}", Communication.LogLevel.WARN)
+        val (party, error) = joinParty(id)
+        if (error != null) warn("Failed to join the party: ${error.errorData}")
 
         currentParty = party
+        partyUpdates { currentParty = it }
     }
 
     /**
      * Leaves the current party
      */
-    fun leave() {
-        if (discordAuth == null || currentParty == null) return toast("Can not interact with the api (are you offline?)")
+    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 toast("Failed to edit the party: ${error.message}", Communication.LogLevel.WARN)
+        if (error != null) return warn("Failed to leave the party: ${error.errorData}")
 
         currentParty = null
     }
 
-    private suspend fun startDiscord() {
+    private suspend fun start() {
         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)
 
@@ -152,18 +153,15 @@ object Discord : Module(
             return toast("Failed to link the discord account to the minecraft auth")
         }
 
-        authResp?.let { updateToken(it) }
+        updateToken(authResp)
         discordAuth = auth
     }
 
-    private fun stopDiscord() {
-        if (!rpc.connected) return
-
-        rpc.disconnect()
+    private fun stop() {
+        if (rpc.connected) rpc.disconnect()
     }
 
     private fun KDiscordIPC.subscribe() {
-        // ToDO: Get party on join event
         on<ReadyEvent> {
             subscribe(DiscordEvent.VoiceChannelSelect)
             subscribe(DiscordEvent.VoiceStateCreate)
@@ -181,14 +179,17 @@ object Discord : Module(
     }
 
     private suspend fun SafeContext.handleLoop() {
-        if (createByDefault) createParty(maxPlayers)
+        if (isDiscordLinked) {
+            if (createByDefault) createParty()
+            partyUpdates { currentParty = it }
+        }
 
         while (rpc.connected) {
             update()
             delay(delay)
         }
 
-        leave()
+        if (isDiscordLinked) leaveParty()
     }
 
     private suspend fun SafeContext.update() {
@@ -229,8 +230,6 @@ object Discord : Module(
         HEALTH({ "${mc.player?.health ?: 0} HP" }),
         HUNGER({ "${mc.player?.hungerManager?.foodLevel ?: 0} Hunger" }),
         DIMENSION({ dimensionName }),
-        COORDINATES({ "Coords: ${player.blockPos.toShortString()}" }),
-        SERVER({ mc.currentServerEntry?.address ?: "Not Connected" }),
         FPS({ "${mc.currentFps} FPS" });
     }
 }