fix: mineskin

Author: InvalidJoker

build.gradle.kts

@@ -32,6 +32,8 @@ dependencies {
 
     api("cc.modlabs:KlassicX:2025.4.22.1239")
 
+    api("com.squareup.okhttp3:okhttp:4.12.0")
+
     testImplementation("io.kotest:kotest-runner-junit5:$koTestVersion")
     testImplementation("io.mockk:mockk:${mockkVersion}")
     testImplementation("com.google.code.gson:gson:2.11.0")

src/main/kotlin/cc/modlabs/kpaper/extensions/InventoryExtensions.kt

@@ -15,11 +15,12 @@ import org.bukkit.entity.Player
 import org.bukkit.inventory.Inventory
 import org.bukkit.inventory.InventoryHolder
 import org.bukkit.inventory.ItemStack
+import org.bukkit.inventory.PlayerInventory
 import org.bukkit.inventory.meta.ItemMeta
 import org.bukkit.persistence.PersistentDataType
+import org.jetbrains.annotations.ApiStatus.Experimental
 import java.util.UUID
 
-
 /**
  * Each gridIndex is a 3x3 grid inside the inventory
  * There are a total of 6 grids
@@ -333,4 +334,90 @@ fun Item.ownedBy(uuid: UUID, time: Long = 20 * 10L): Item {
         owner = null
     }
     return this
+}
+
+fun canItemFitInInventory(inventory: Inventory, itemToAdd: ItemStack): Boolean {
+    // Clone the item to avoid modifying the original
+    val itemToCheck = itemToAdd.clone()
+
+    if (itemToCheck.amount <= 0) {
+        return true // Empty stack always fits
+    }
+
+    // First pass: try to stack with existing similar items
+    for (i in 0 until inventory.size) {
+        val slot = inventory.getItem(i)
+
+        // Check if the slot has an item that can be stacked with our item
+        if (slot != null && slot.isSimilar(itemToCheck)) {
+            val maxStackSize = slot.type.maxStackSize
+            val availableSpace = maxStackSize - slot.amount
+
+            if (availableSpace > 0) {
+                itemToCheck.amount -= availableSpace
+
+                if (itemToCheck.amount <= 0) {
+                    return true // Item fits completely
+                }
+            }
+        }
+    }
+
+    // Second pass: check for empty slots
+    var remainingAmount = itemToCheck.amount
+    val maxStackSize = itemToCheck.type.maxStackSize
+
+    for (i in 0 until inventory.size) {
+        val slot = inventory.getItem(i)
+
+        if (slot == null) {
+            // This is an empty slot
+            remainingAmount -= maxStackSize
+
+            if (remainingAmount <= 0) {
+                return true // Item fits completely using empty slots
+            }
+        }
+    }
+
+    return false // Cannot fit the item
+}
+
+/**
+ * Alternative version that simulates adding the item to the inventory by creating a clone,
+ * useful when you need to know exactly how the item will be distributed.
+ *
+ * @param inventory The Bukkit/PaperMC inventory to check
+ * @param itemToAdd The ItemStack that needs to be added to the inventory
+ * @return Boolean indicating whether the item can fit into the inventory
+ */
+@Experimental
+fun canItemFitInInventorySimulated(inventory: PlayerInventory, itemToAdd: ItemStack): Boolean {
+    // Clone the inventory to avoid modifying the original
+    val tempInventory = inventory.holder?.server?.createInventory(null, inventory.size)
+        ?: return false
+
+    // Copy all items to the temporary inventory
+    for (i in 0 until inventory.size) {
+        val item = inventory.getItem(i)
+        if (item != null) {
+            tempInventory.setItem(i, item.clone())
+        }
+    }
+
+    // Try to add the item to the temporary inventory
+    val leftover = tempInventory.addItem(itemToAdd.clone())
+
+    // If there are no leftover items, it means everything fit
+    return leftover.isEmpty()
+}
+
+/**
+ * Extension function for PlayerInventory that checks if an ItemStack can fit
+ *
+ * @param itemToAdd The ItemStack to check
+ * @return Boolean indicating whether the item fits
+ */
+fun PlayerInventory.canFit(itemToAdd: ItemStack): Boolean {
+    return canItemFitInInventory(this, itemToAdd)
 }

src/main/kotlin/cc/modlabs/kpaper/extensions/PlayerExtensions.kt

@@ -121,4 +121,8 @@ val Player.connection: ServerGamePacketListenerImpl
 
 fun Player.actionBar(text: String) {
     sendActionBar(text(text))
+}
+
+fun broadcastActionbar(component: Component) {
+    Bukkit.getOnlinePlayers().forEach { it.sendActionBar(component) }
 }

src/main/kotlin/cc/modlabs/kpaper/inventory/ItemBuilder.kt

@@ -4,11 +4,11 @@ package cc.modlabs.kpaper.inventory
 
 import cc.modlabs.kpaper.coroutines.taskRunLater
 import cc.modlabs.kpaper.inventory._internal.ItemClickListener
-import cc.modlabs.kpaper.inventory.mineskin.MineSkinResponse
+import cc.modlabs.kpaper.inventory.mineskin.MineSkinFetcher
 import cc.modlabs.kpaper.inventory.mineskin.MinecraftSkin
 import cc.modlabs.kpaper.inventory.mineskin.SKIN
-import cc.modlabs.kpaper.inventory.mineskin.SkinTexture
 import cc.modlabs.kpaper.inventory.mineskin.Textures
+import cc.modlabs.kpaper.inventory.mineskin.models.texture.MineSkinResponse
 import com.destroystokyo.paper.profile.ProfileProperty
 import com.google.gson.Gson
 import dev.fruxz.ascend.extension.forceCastOrNull
@@ -31,10 +31,8 @@ import org.bukkit.inventory.meta.Damageable
 import org.bukkit.inventory.meta.ItemMeta
 import org.bukkit.inventory.meta.SkullMeta
 import org.bukkit.persistence.PersistentDataType
-import java.net.URL
 import java.util.*
 import java.util.concurrent.TimeUnit
-import kotlin.text.take
 
 
 /**
@@ -331,27 +329,13 @@ class ItemBuilder(material: Material, count: Int = 1, dsl: ItemBuilder.() -> Uni
      * @return An ItemBuilder object representing the player's skin texture.
      */
     fun textureFromMineSkin(mineSkinUUID: String): ItemBuilder {
-        if (textureCache.containsKey(mineSkinUUID)) {
-            return textureFromSkinTexture(textureCache[mineSkinUUID]!!)
-        }
+        val fetcher = MineSkinFetcher.fetchSkinSignature(mineSkinUUID)
 
-        val target = URL("https://api.mineskin.org/get/uuid/$mineSkinUUID")
-        val connection = target.openConnection()
-        connection.setRequestProperty("User-Agent", "KPaper/1.0")
-        val inputStream = connection.getInputStream()
-        val scanner = Scanner(inputStream)
-        val response = StringBuilder()
-        while (scanner.hasNextLine()) {
-            response.append(scanner.nextLine())
+        if (fetcher == null) {
+            throw IllegalArgumentException("Invalid MineSkin UUID: $mineSkinUUID")
         }
-        scanner.close()
-        val json = response.toString()
-        val mineSkinResponse = Gson().fromJson(json, MineSkinResponse::class.java)
-        val skinTexture = SkinTexture.fromMineSkinResponse(mineSkinResponse)
-
-        textureCache[mineSkinUUID] = skinTexture
 
-        return textureFromSkinTexture(skinTexture)
+        return textureFromSkinTexture(fetcher)
     }
 
     /**
@@ -360,13 +344,13 @@ class ItemBuilder(material: Material, count: Int = 1, dsl: ItemBuilder.() -> Uni
      * @param skinTexture The SkinTexture object containing the UUID, name, and texture information.
      * @return An ItemBuilder instance with the custom texture applied.
      */
-    private fun textureFromSkinTexture(skinTexture: SkinTexture): ItemBuilder {
-        val skinProfile = Bukkit.createProfile(skinTexture.uuid, skinTexture.name)
+    private fun textureFromSkinTexture(skinTexture: MineSkinResponse): ItemBuilder {
+        val skinProfile = Bukkit.createProfile(UUID.randomUUID(), skinTexture.name)
         skinProfile.setProperty(
             ProfileProperty(
                 "textures",
-                skinTexture.texture.value,
-                skinTexture.texture.signature
+                skinTexture.texture.data.value,
+                skinTexture.texture.data.signature
             )
         )
         val skullMeta = itemStack.itemMeta as SkullMeta
@@ -716,9 +700,7 @@ class ItemBuilder(material: Material, count: Int = 1, dsl: ItemBuilder.() -> Uni
      * It provides utility methods for creating `ItemBuilder` instances from `ItemStack` objects.
      */
     companion object {
-            val textureCache = mutableMapOf<String, SkinTexture>()
-
-            val invalidMaterials = arrayListOf(
+        val invalidMaterials = arrayListOf(
             Material.AIR,
             Material.CAVE_AIR,
             Material.VOID_AIR,

src/main/kotlin/cc/modlabs/kpaper/inventory/mineskin/MineSkinFetcher.kt

@@ -0,0 +1,43 @@
+package cc.modlabs.kpaper.inventory.mineskin
+
+import cc.modlabs.klassicx.tools.Environment
+import cc.modlabs.kpaper.inventory.mineskin.models.texture.MineSkinResponse
+import cc.modlabs.kpaper.inventory.mineskin.models.texture.MineSkinSingleSkinResponse
+import com.google.gson.Gson
+import okhttp3.OkHttpClient
+import okhttp3.Request
+
+object MineSkinFetcher {
+
+    private val client = OkHttpClient()
+
+    private val apiKey = Environment.getString("MINESKIN_API_KEY")
+
+    private val gson = Gson()
+
+    private val skinCache = mutableMapOf<String, MineSkinResponse>()
+
+    fun fetchSkinSignature(skin: String): MineSkinResponse? {
+        if (skinCache.containsKey(skin)) {
+            return skinCache[skin]
+        }
+
+        val request = Request.Builder()
+            .url("https://api.mineskin.org/v2/skins/$skin")
+            .addHeader("Accept", "application/json")
+            .addHeader("User-Agent", "MineSkin-User-Agent")
+            .addHeader("Authorization", "Bearer $apiKey")
+            .build()
+        val response = client.newCall(request).execute()
+        val sR = gson.fromJson(response.body!!.string(), MineSkinSingleSkinResponse::class.java)
+        if (sR.skin == null) {
+            return null
+        }
+
+        skinCache[skin] = sR.skin
+
+        return sR.skin
+    }
+
+
+}

src/main/kotlin/cc/modlabs/kpaper/inventory/mineskin/MineSkinResponse.kt

@@ -0,0 +1,10 @@
+package cc.modlabs.kpaper.inventory.mineskin.models
+
+data class MineSkinBaseResponse(
+    val success: Boolean,
+    val skins: List<MineSkinRawSkinResponse>,
+    val pagination: MineSkinPagination,
+    val warnings: List<MineSkinWarning>,
+    val messages: List<Any>,
+    val links: MineSkinLinks,
+)