Feat: Adding some Item Components

engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemCustomModelDataComponent.kt

@@ -0,0 +1,47 @@
+package com.typewritermc.engine.paper.utils.item.components
+
+import com.typewritermc.core.books.pages.Colors
+import com.typewritermc.core.extension.annotations.AlgebraicTypeInfo
+import com.typewritermc.core.extension.annotations.Default
+import com.typewritermc.core.extension.annotations.InnerMin
+import com.typewritermc.core.extension.annotations.Min
+import com.typewritermc.core.interaction.InteractionContext
+import com.typewritermc.engine.paper.entry.entries.ConstVar
+import com.typewritermc.engine.paper.entry.entries.Var
+import com.typewritermc.engine.paper.entry.entries.get
+import org.bukkit.entity.Player
+import org.bukkit.inventory.ItemStack
+
+@Suppress("UnstableApiUsage")
+@AlgebraicTypeInfo("custom_model_data", Colors.GREEN, "fa6-solid:shapes")
+class ItemCustomModelDataComponent(
+    @InnerMin(Min(0))
+    @Default("0")
+
+    val customModelData: Var<Int> = ConstVar(0),
+) : ItemComponent {
+    override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack) {
+        item.editMeta { meta ->
+            val modelData = customModelData.get(player, interactionContext) ?: return@editMeta
+            val expectedFloats = if (modelData == 0) emptyList() else listOf(modelData.toFloat())
+            val component = meta.customModelDataComponent
+            if (component.floats == expectedFloats) return@editMeta
+            component.floats = expectedFloats
+            meta.setCustomModelDataComponent(component)
+        }
+    }
+
+    override fun matches(player: Player?, interactionContext: InteractionContext?, item: ItemStack): Boolean {
+        val expectedModelData = customModelData.get(player, interactionContext) ?: return false
+        val actualComponent = item.itemMeta?.customModelDataComponent
+        val actualFloats = actualComponent?.floats ?: emptyList()
+
+        val expectedFloats = if (expectedModelData == 0) {
+            emptyList()
+        } else {
+            listOf(expectedModelData.toFloat())
+        }
+
+        return actualFloats == expectedFloats
+    }
+}

engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemJukeboxPlayableComponent.kt

@@ -0,0 +1,43 @@
+package com.typewritermc.engine.paper.utils.item.components
+
+import com.typewritermc.core.books.pages.Colors
+import com.typewritermc.core.extension.annotations.AlgebraicTypeInfo
+import com.typewritermc.core.interaction.InteractionContext
+import com.typewritermc.engine.paper.entry.entries.ConstVar
+import com.typewritermc.engine.paper.entry.entries.Var
+import com.typewritermc.engine.paper.entry.entries.get
+import com.typewritermc.engine.paper.utils.Sound
+import org.bukkit.entity.Player
+import org.bukkit.inventory.ItemStack
+
+@Suppress("UnstableApiUsage")
+@AlgebraicTypeInfo("jukebox_playable", Colors.RED, "fa6-solid:music")
+class ItemJukeboxPlayableComponent(
+    val sound: Var<Sound> = ConstVar(Sound.EMPTY)
+) : ItemComponent {
+    override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack) {
+        item.editMeta { meta ->
+            val resolvedSound = sound.get(player, interactionContext)
+            if (resolvedSound == null || resolvedSound == Sound.EMPTY) {
+                meta.setJukeboxPlayable(null)
+                return@editMeta
+            }
+
+            val soundKey = resolvedSound.soundId.namespacedKey ?: return@editMeta
+            val jukeboxComponent = meta.jukeboxPlayable
+            jukeboxComponent.songKey = soundKey
+            meta.setJukeboxPlayable(jukeboxComponent)
+        }
+    }
+
+    override fun matches(player: Player?, interactionContext: InteractionContext?, item: ItemStack): Boolean {
+        val expectedSound = sound.get(player, interactionContext)
+        val actualComponent = item.itemMeta?.jukeboxPlayable
+
+        if (expectedSound == null || expectedSound == Sound.EMPTY) {
+            return actualComponent == null
+        }
+
+        return actualComponent?.songKey == expectedSound.soundId.namespacedKey
+    }
+}

engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemPDCComponent.kt

@@ -0,0 +1,63 @@
+package com.typewritermc.engine.paper.utils.item.components
+
+import com.typewritermc.core.books.pages.Colors
+import com.typewritermc.core.extension.annotations.AlgebraicTypeInfo
+import com.typewritermc.core.extension.annotations.Default
+import com.typewritermc.core.interaction.InteractionContext
+import com.typewritermc.engine.paper.entry.entries.ConstVar
+import com.typewritermc.engine.paper.entry.entries.Var
+import com.typewritermc.engine.paper.entry.entries.get
+import org.bukkit.NamespacedKey
+import org.bukkit.entity.Player
+import org.bukkit.inventory.ItemStack
+import org.bukkit.persistence.PersistentDataType
+
+@AlgebraicTypeInfo("persistent_data_container", Colors.PURPLE, "fa6-solid:database")
+class ItemPDCComponent(
+    @Default("\"typewriter\"")
+    val namespace: Var<String> = ConstVar("typewriter"),
+    @Default("\"custom_data\"")
+    val key: Var<String> = ConstVar("custom_data"),
+    @Default("\"\"")
+    val value: Var<String> = ConstVar(""),
+) : ItemComponent {
+
+    override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack) {
+        item.editMeta { meta ->
+            val ns = namespace.get(player, interactionContext)?.trim()?.takeIf { it.isNotEmpty() } ?: return@editMeta
+            val k = key.get(player, interactionContext)?.trim()?.takeIf { it.isNotEmpty() } ?: return@editMeta
+            val v = value.get(player, interactionContext)?.trim() ?: return@editMeta
+
+            val namespacedKey = try {
+                NamespacedKey(ns, k)
+            } catch (_: IllegalArgumentException) {
+                return@editMeta
+            }
+
+            if (v.isBlank()) {
+                meta.persistentDataContainer.remove(namespacedKey)
+            } else {
+                meta.persistentDataContainer.set(namespacedKey, PersistentDataType.STRING, v)
+            }
+        }
+    }
+
+    override fun matches(player: Player?, interactionContext: InteractionContext?, item: ItemStack): Boolean {
+        val ns = namespace.get(player, interactionContext)?.trim()?.takeIf { it.isNotEmpty() } ?: return false
+        val k = key.get(player, interactionContext)?.trim()?.takeIf { it.isNotEmpty() } ?: return false
+        val expected = value.get(player, interactionContext)?.trim() ?: return false
+
+        val namespacedKey = try {
+            NamespacedKey(ns, k)
+        } catch (_: IllegalArgumentException) {
+            return false
+        }
+        val actualValue = item.itemMeta?.persistentDataContainer?.get(namespacedKey, PersistentDataType.STRING)
+
+        return if (expected.isBlank()) {
+            actualValue.isNullOrBlank()
+        } else {
+            actualValue == expected
+        }
+    }
+}

engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemTooltipStyleComponent.kt

@@ -0,0 +1,39 @@
+package com.typewritermc.engine.paper.utils.item.components
+
+import com.typewritermc.core.books.pages.Colors
+import com.typewritermc.core.extension.annotations.AlgebraicTypeInfo
+import com.typewritermc.core.extension.annotations.Default
+import com.typewritermc.core.interaction.InteractionContext
+import com.typewritermc.engine.paper.entry.entries.ConstVar
+import com.typewritermc.engine.paper.entry.entries.Var
+import com.typewritermc.engine.paper.entry.entries.get
+import org.bukkit.NamespacedKey
+import org.bukkit.entity.Player
+import org.bukkit.inventory.ItemStack
+
+@AlgebraicTypeInfo("tooltip_style", Colors.CYAN, "fa6-solid:palette")
+class ItemTooltipStyleComponent(
+    @Default("\"minecraft\"")
+    val namespace: Var<String> = ConstVar("minecraft"),
+    @Default("\"default\"")
+    val key: Var<String> = ConstVar("default"),
+) : ItemComponent {
+    override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack) {
+        item.editMeta { meta ->
+            val namespaceValue = namespace.get(player, interactionContext) ?: return@editMeta
+            val keyValue = key.get(player, interactionContext) ?: return@editMeta
+            val namespacedKey = NamespacedKey(namespaceValue, keyValue)
+            if (meta.tooltipStyle == namespacedKey) return@editMeta
+            meta.tooltipStyle = namespacedKey
+        }
+    }
+
+
+    override fun matches(player: Player?, interactionContext: InteractionContext?, item: ItemStack): Boolean {
+        val expectedNamespace = namespace.get(player, interactionContext) ?: return false
+        val expectedKey = key.get(player, interactionContext) ?: return false
+        val actualStyle = item.itemMeta?.tooltipStyle
+        val expectedNamespacedKey = NamespacedKey(expectedNamespace, expectedKey)
+        return actualStyle == expectedNamespacedKey
+    }
+}