Merge branch 'main' of https://github.com/Polyfrost/PolyPlus into refactor/clean-up

Author: Deftu

src/main/kotlin/org/polyfrost/polyplus/network/plus/cache/CachedCosmetic.kt

@@ -0,0 +1,20 @@
+package org.polyfrost.polyplus.network.plus.cache
+
+import net.minecraft.client.renderer.texture.DynamicTexture
+import net.minecraft.util.ResourceLocation
+import org.polyfrost.oneconfig.utils.v1.dsl.mc
+import java.awt.image.BufferedImage
+
+sealed class CachedCosmetic {
+    class Cape(image: BufferedImage) : CachedCosmetic() {
+        val resource: ResourceLocation? = mc.textureManager.getDynamicTextureLocation("polyplus/cape", DynamicTexture(image))
+    }
+    object InvalidType : CachedCosmetic()
+
+    fun asResource(): ResourceLocation? {
+        return when (this) {
+            is Cape -> resource
+            is InvalidType -> null
+        }
+    }
+}

src/main/kotlin/org/polyfrost/polyplus/network/plus/cache/CosmeticCache.kt

@@ -0,0 +1,71 @@
+package org.polyfrost.polyplus.network.plus.cache
+
+import io.ktor.client.request.get
+import io.ktor.client.statement.bodyAsBytes
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.Deferred
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.async
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import net.minecraft.util.ResourceLocation
+import org.polyfrost.oneconfig.utils.v1.dsl.mc
+import org.polyfrost.polyplus.PolyPlus
+import org.polyfrost.polyplus.network.plus.Cosmetics.players
+import org.polyfrost.polyplus.network.plus.cache.CachedCosmetic
+import org.polyfrost.polyplus.network.plus.responses.Cosmetic
+import org.polyfrost.polyplus.utils.HashManager
+import java.io.File
+import java.io.FileOutputStream
+import java.util.UUID
+import javax.imageio.ImageIO
+import kotlin.uuid.Uuid
+
+object CosmeticCache {
+    val cache = HashMap<String, HashMap<Int, CachedCosmetic>>()
+    val hashManager = HashManager("${DIRECTORY}hashes.txt")
+    const val DIRECTORY = "./polyplus/cosmetics/"
+
+    suspend fun put(cosmetics: List<Cosmetic>) = withContext(Dispatchers.IO) {
+        hashManager.awaitHashes()
+        try {
+            val directory = File(DIRECTORY)
+            if (!directory.exists()) directory.mkdirs()
+            for (cosmetic in cosmetics) {
+                val cosmeticName = "${cosmetic.type}_${cosmetic.id}"
+                val file = File("${DIRECTORY}$cosmeticName")
+
+                val cached = !hashManager.updateHash(cosmeticName, cosmetic.hash) && !file.createNewFile()
+
+                val cosmeticStream = if (cached) file.inputStream() else {
+                    val bytes = PolyPlus.client.get(cosmetic.url).bodyAsBytes()
+                    val outputStream = FileOutputStream(file)
+                    bytes.inputStream().use { input ->
+                        outputStream.use { output ->
+                            input.copyTo(output)
+                        }
+                    }
+
+                    bytes.inputStream()
+                }
+
+                mc.addScheduledTask { // we need a thread with opengl context to create textures
+                    cache.getOrPut(cosmetic.type) { HashMap() }[cosmetic.id] = when (cosmetic.type) {
+                        "cape" -> CachedCosmetic.Cape(ImageIO.read(cosmeticStream))
+                        else -> CachedCosmetic.InvalidType
+                    }
+                }
+            }
+            hashManager.saveHashes()
+        } catch (e: Exception) {
+            PolyPlus.logger.warning("Failed to cache cosmetics: ${e.message}")
+        }
+    }
+
+    @JvmStatic
+    fun getCosmetic(Uuid: UUID, type: String): ResourceLocation? {
+        val id = players[Uuid]?.get(type) ?: return null
+        return cache[type]?.get(id)?.asResource().also { if (it == null) println("no cached cosmetic with type $type for id $id") }
+    }
+
+}

src/main/kotlin/org/polyfrost/polyplus/network/plus/responses/WebSocketPacket.kt

@@ -0,0 +1,40 @@
+package org.polyfrost.polyplus.network.plus.responses
+
+import kotlinx.serialization.ExperimentalSerializationApi
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.json.JsonClassDiscriminator
+
+@OptIn(ExperimentalSerializationApi::class)
+object WebSocketPacket {
+    object ClientBound {
+        @Serializable
+        @JsonClassDiscriminator("type")
+        sealed class FallibleResponse {
+            @Serializable
+            @SerialName("Error")
+            data class Error(
+                @SerialName("error_code") val code: String,
+                @SerialName("message") val message: String
+            ) : FallibleResponse()
+
+            @Serializable
+            @SerialName("CosmeticsInfo")
+            data class CosmeticsInfo(
+                @SerialName("cosmetics") val cosmetics: HashMap<String, List<Int>>
+            ) : FallibleResponse()
+        }
+    }
+
+    object ServerBound {
+        @Serializable
+        @JsonClassDiscriminator("type")
+        sealed class Packet {
+            @Serializable
+            @SerialName("GetActiveCosmetics")
+            data class GetActiveCosmetics(
+                @SerialName("players") val players: List<String>
+            ) : Packet()
+        }
+    }
+}

src/main/kotlin/org/polyfrost/polyplus/utils/PlayerUtils.kt

@@ -0,0 +1,14 @@
+package org.polyfrost.polyplus.utils
+
+import dev.deftu.omnicore.api.client.client
+import java.util.UUID
+
+object PlayerUtils {
+    //#if MC >= 1.20.4
+    //$$ val uuid: UUID = client.uuid
+    //#else
+    val uuid: UUID = client.session.profile.id
+    //#endif
+
+
+}