Merge branch 'main' of https://github.com/Polyfrost/PolyPlus

Author: Deftu

src/main/kotlin/org/polyfrost/polyplus/client/PolyPlusClient.kt

@@ -14,8 +14,10 @@ import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.launch
 import kotlinx.serialization.json.Json
 import org.apache.logging.log4j.LogManager
+import org.polyfrost.oneconfig.api.event.v1.EventManager
 import org.polyfrost.oneconfig.utils.v1.dsl.addDefaultCommand
 import org.polyfrost.polyplus.PolyPlusConstants
+import org.polyfrost.polyplus.client.cosmetics.ApplyCosmetics
 import org.polyfrost.polyplus.client.cosmetics.CosmeticManager
 import org.polyfrost.polyplus.client.discord.DiscordPresence
 import org.polyfrost.polyplus.client.network.http.PolyAuthorization
@@ -47,6 +49,13 @@ object PolyPlusClient {
 
     fun initialize() {
         PolyPlusConfig.preload()
+
+        listOf(
+            ApplyCosmetics
+        ).forEach {
+            EventManager.INSTANCE.register(it)
+        }
+
         DiscordPresence.initialize()
         PolyConnection.initialize {
             LOGGER.info("Connected to PolyPlus WebSocket server.")

src/main/kotlin/org/polyfrost/polyplus/client/cosmetics/ApplyCosmetics.kt

@@ -0,0 +1,65 @@
+package org.polyfrost.polyplus.client.cosmetics
+
+import dev.deftu.omnicore.api.client.player
+import net.minecraft.network.play.server.S38PacketPlayerListItem
+import net.minecraftforge.event.world.WorldEvent
+import org.apache.logging.log4j.LogManager
+import org.polyfrost.oneconfig.api.event.v1.events.PacketEvent
+import org.polyfrost.oneconfig.api.event.v1.invoke.impl.Subscribe
+import org.polyfrost.polyplus.client.network.http.PolyCosmetics
+import org.polyfrost.polyplus.client.network.websocket.ClientboundPacket
+import org.polyfrost.polyplus.client.network.websocket.PolyConnection
+import org.polyfrost.polyplus.client.network.websocket.ServerboundPacket
+import org.polyfrost.polyplus.events.WebSocketMessage
+import org.polyfrost.polyplus.utils.Batcher
+import java.time.Duration
+import java.util.UUID
+import kotlin.collections.component1
+import kotlin.collections.component2
+import kotlin.collections.iterator
+
+object ApplyCosmetics {
+    private val LOGGER = LogManager.getLogger()
+    private val BATCHER = Batcher(Duration.ofMillis(200), HashSet<String>()) { players ->
+        PolyConnection.sendPacket(ServerboundPacket.GetActiveCosmetics(players.toList()))
+    }
+
+    @Subscribe
+    fun onWorldLoad(event: WorldEvent.Load) {
+        PolyCosmetics.reset()
+    }
+
+    @Subscribe
+    fun onPlayerList(event: PacketEvent.Receive) {
+        // Not sure how to cleanly make this version agnostic atm.
+        val packet = try { event.getPacket<S38PacketPlayerListItem>() ?: return } catch (e: Exception) { return }
+        when (packet.action) {
+            S38PacketPlayerListItem.Action.ADD_PLAYER -> {
+                packet.entries.forEach {
+                    // mojang doesnt use uuidv2 so if it is, its a bot and wont have a cape.
+                    if (it.profile.id.version() != 2) BATCHER.add(it.profile.id.toString())
+                }
+            }
+
+            S38PacketPlayerListItem.Action.REMOVE_PLAYER -> {
+                for (entry in packet.entries) {
+                    PolyCosmetics.removeFromCache(entry.profile.id)
+                }
+            }
+
+            else -> return
+        }
+    }
+
+    @Subscribe
+    fun onRecieveCosmetics(event: WebSocketMessage) {
+        val cosmeticInfo = event.packet as? ClientboundPacket.CosmeticsInfo ?: return
+        // todo: have a map of type to valid ids? or ask ty to include type in the returned info. for now theyre all capes.
+        for ((uuid, active) in cosmeticInfo.all) {
+            active.forEach {
+                PolyCosmetics.cacheActive(UUID.fromString(uuid), "cape", it)
+                LOGGER.info("Cached cosmetic for player $uuid: cape -> $it")
+            }
+        }
+    }
+}

src/main/kotlin/org/polyfrost/polyplus/client/network/http/PolyCosmetics.kt

@@ -8,27 +8,22 @@ import kotlinx.coroutines.async
 import org.apache.logging.log4j.LogManager
 import org.polyfrost.polyplus.client.PolyPlusClient
 import org.polyfrost.polyplus.client.PolyPlusConfig
+import org.polyfrost.polyplus.client.network.http.responses.Cosmetic
 import org.polyfrost.polyplus.client.network.http.responses.CosmeticList
 import org.polyfrost.polyplus.client.network.http.responses.PlayerCosmetics
 import java.util.UUID
 
 object PolyCosmetics {
     private val LOGGER = LogManager.getLogger()
+    private var OWNED: List<Cosmetic> = emptyList()
     private val CACHE = HashMap<UUID, HashMap<String, Int>>()
 
     suspend fun updateOwned() {
-        val cosmetics = PolyPlusClient.HTTP
+        val playerCosmetics = PolyPlusClient.HTTP
             .getBodyAuthorized<PlayerCosmetics>("${PolyPlusConfig.apiUrl}/cosmetics/player")
             .onFailure { LOGGER.error("Failed to fetch owned cosmetics", it) }
             .getOrElse { return LOGGER.warn("Could not fetch owned cosmetics for player $playerUuid") }
-            .owned
-        for (cosmetic in cosmetics) {
-            CACHE[playerUuid] = CACHE.getOrPut(playerUuid) {
-                HashMap()
-            }.apply {
-                set(cosmetic.type, cosmetic.id)
-            }
-        }
+        OWNED = playerCosmetics.owned
     }
 
     fun getAll(): Deferred<Result<CosmeticList>> = PolyPlusClient.SCOPE.async {
@@ -42,10 +37,19 @@ object PolyCosmetics {
     }
 
     fun reset() {
+        LOGGER.info("Resetting cosmetics cache: Size before reset: ${CACHE.size}")
         CACHE.clear()
     }
 
     fun getFor(uuid: UUID): HashMap<String, Int>? {
         return CACHE[uuid]
     }
+
+    fun cacheActive(uuid: UUID, type: String, id: Int) {
+        CACHE.getOrPut(uuid) { HashMap() }[type] = id
+    }
+
+    fun removeFromCache(uuid: UUID) {
+        CACHE.remove(uuid)
+    }
 }

src/main/kotlin/org/polyfrost/polyplus/client/network/http/responses/ActiveCosmetics.kt

@@ -4,4 +4,4 @@ import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
 
 @Serializable
-data class PlayerCosmetics(val active: ActiveCosmetics, @SerialName("cosmetics") val owned: List<Cosmetic>)
+data class PlayerCosmetics(val active: HashMap<String, Int?>, @SerialName("cosmetics") val owned: List<Cosmetic>)

src/main/kotlin/org/polyfrost/polyplus/client/network/http/responses/PlayerCosmetics.kt

@@ -10,8 +10,13 @@ import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.launch
 import kotlinx.serialization.serializer
 import org.apache.logging.log4j.LogManager
+import org.polyfrost.oneconfig.api.event.v1.EventManager
 import org.polyfrost.polyplus.client.PolyPlusClient
 import org.polyfrost.polyplus.client.PolyPlusConfig
+import org.polyfrost.polyplus.client.cosmetics.CosmeticManager
+import org.polyfrost.polyplus.client.network.http.PolyCosmetics
+import org.polyfrost.polyplus.events.WebSocketMessage
+import java.util.UUID
 
 object PolyConnection {
     private val LOGGER = LogManager.getLogger()
@@ -99,12 +104,15 @@ object PolyConnection {
     }
 
     private fun process(scope: CoroutineScope, message: String) {
-        println("Received message: $message")
         val packet = PolyPlusClient.JSON.decodeFromString<ClientboundPacket>(message)
-        println("Decoded packet: $packet")
+        if (packet is ClientboundPacket.Error) {
+            LOGGER.error("Error packet received: ${packet.message}")
+        }
+
+        EventManager.INSTANCE.post(WebSocketMessage(packet))
     }
 
     private inline fun <reified T : ServerboundPacket> T.string(): String {
-        return PolyPlusClient.JSON.encodeToString(serializer(), this)
+        return PolyPlusClient.JSON.encodeToString(ServerboundPacket.serializer(), this)
     }
 }

src/main/kotlin/org/polyfrost/polyplus/client/network/websocket/PolyConnection.kt

@@ -0,0 +1,6 @@
+package org.polyfrost.polyplus.events
+
+import org.polyfrost.oneconfig.api.event.v1.events.Event
+import org.polyfrost.polyplus.client.network.websocket.ClientboundPacket
+
+class WebSocketMessage(val packet: ClientboundPacket) : Event

src/main/kotlin/org/polyfrost/polyplus/events/WebSocketMessage.kt

@@ -0,0 +1,31 @@
+package org.polyfrost.polyplus.utils
+
+import kotlinx.atomicfu.locks.ReentrantLock
+import kotlinx.atomicfu.locks.withLock
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.launch
+import org.polyfrost.polyplus.client.PolyPlusClient
+import java.time.Duration
+
+class Batcher<T, C: MutableCollection<T>>(val delay: Duration, val set: C, val onBatch: suspend CoroutineScope.(C) -> Unit) {
+    private val lock = ReentrantLock()
+    private var job: Job? = null
+
+    fun add(item: T) {
+        if (job == null) {
+            job = PolyPlusClient.SCOPE.launch {
+                kotlinx.coroutines.delay(delay.toMillis())
+                lock.withLock {
+                    onBatch(set)
+                    set.clear()
+                }
+                job = null
+            }
+        }
+
+        lock.withLock {
+            set.add(item)
+        }
+    }
+}