From 6e7d52c8210caf0e7fe4c1732b1ab9fb80eda226 Mon Sep 17 00:00:00 2001 From: Chaosgh Date: Sun, 24 Aug 2025 22:09:09 +0200 Subject: [PATCH 01/13] added some item components --- .../ItemCustomModelDataComponent.kt | 49 +++++++++++++++++ .../ItemJukeboxPlayableComponent.kt | 35 ++++++++++++ .../utils/item/components/ItemPDCComponent.kt | 53 +++++++++++++++++++ .../components/ItemTooltipStyleComponent.kt | 36 +++++++++++++ 4 files changed, 173 insertions(+) create mode 100644 engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemCustomModelDataComponent.kt create mode 100644 engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemJukeboxPlayableComponent.kt create mode 100644 engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemPDCComponent.kt create mode 100644 engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemTooltipStyleComponent.kt diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemCustomModelDataComponent.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemCustomModelDataComponent.kt new file mode 100644 index 0000000000..687ebcfd29 --- /dev/null +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemCustomModelDataComponent.kt @@ -0,0 +1,49 @@ +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 = ConstVar(0), +) : ItemComponent { + override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack) { + item.editMeta { meta -> + val modelData = customModelData.get(player) ?: return@editMeta + val modelDataComponent = meta.customModelDataComponent + + if (modelData == 0) { + modelDataComponent.floats = emptyList() + } else { + modelDataComponent.floats = listOf(modelData.toFloat()) + } + meta.setCustomModelDataComponent(modelDataComponent) + } + } + + override fun matches(player: Player?, interactionContext: InteractionContext?, item: ItemStack): Boolean { + val expectedModelData = customModelData.get(player) ?: 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 + } +} \ No newline at end of file diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemJukeboxPlayableComponent.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemJukeboxPlayableComponent.kt new file mode 100644 index 0000000000..0ed6f53f3a --- /dev/null +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemJukeboxPlayableComponent.kt @@ -0,0 +1,35 @@ +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 = ConstVar(Sound.EMPTY) +) : ItemComponent { + override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack) { + item.editMeta { meta -> + val soundKey = sound.get(player, interactionContext)?.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 expectedSoundKey = sound.get(player, interactionContext)?.soundId?.namespacedKey ?: return false + val actualComponent = item.itemMeta?.jukeboxPlayable + return actualComponent?.songKey == expectedSoundKey + } +} \ No newline at end of file diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemPDCComponent.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemPDCComponent.kt new file mode 100644 index 0000000000..bdc7fb1ced --- /dev/null +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemPDCComponent.kt @@ -0,0 +1,53 @@ +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("\"minecraft\"") + val namespace: Var = ConstVar("typewriter"), + @Default("\"custom_data\"") + val key: Var = ConstVar("custom_data"), + val value: Var = ConstVar(""), +) : ItemComponent { + override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack) { + item.editMeta { meta -> + val namespaceValue = namespace.get(player) ?: return@editMeta + val keyValue = key.get(player) ?: return@editMeta + val valueValue = value.get(player) ?: return@editMeta + + val namespacedKey = NamespacedKey(namespaceValue, keyValue) + + if (valueValue.isEmpty()) { + meta.persistentDataContainer.remove(namespacedKey) + } else { + meta.persistentDataContainer.set(namespacedKey, PersistentDataType.STRING, valueValue) + } + } + } + + override fun matches(player: Player?, interactionContext: InteractionContext?, item: ItemStack): Boolean { + val expectedNamespace = namespace.get(player) ?: return false + val expectedKey = key.get(player) ?: return false + val expectedValue = value.get(player) ?: return false + + val namespacedKey = NamespacedKey(expectedNamespace, expectedKey) + val actualValue = item.itemMeta?.persistentDataContainer?.get(namespacedKey, PersistentDataType.STRING) + + return if (expectedValue.isEmpty()) { + actualValue == null + } else { + actualValue == expectedValue + } + } +} \ No newline at end of file diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemTooltipStyleComponent.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemTooltipStyleComponent.kt new file mode 100644 index 0000000000..cfd1d11366 --- /dev/null +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemTooltipStyleComponent.kt @@ -0,0 +1,36 @@ +package com.typewritermc.engine.paper.utils.item.components + +import com.typewritermc.core.books.pages.Colors +import com.typewritermc.core.extension.annotations.* +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 = ConstVar("minecraft"), + @Default("\"default\"") + val key: Var = ConstVar("default"), +): ItemComponent { + override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack) { + item.editMeta { meta -> + val namespaceValue = namespace.get(player) ?: return@editMeta + val keyValue = key.get(player) ?: return@editMeta + val namespacedKey = NamespacedKey(namespaceValue, keyValue) + meta.tooltipStyle = namespacedKey + } + } + + override fun matches(player: Player?, interactionContext: InteractionContext?, item: ItemStack): Boolean { + val expectedNamespace = namespace.get(player) ?: return false + val expectedKey = key.get(player) ?: return false + val actualStyle = item.itemMeta?.tooltipStyle + val expectedNamespacedKey = NamespacedKey(expectedNamespace, expectedKey) + return actualStyle == expectedNamespacedKey + } +} \ No newline at end of file From 88893dbe395918de4ce4ee28b77edbb6b874b8ed Mon Sep 17 00:00:00 2001 From: Chaosgh Date: Sun, 24 Aug 2025 22:11:25 +0200 Subject: [PATCH 02/13] added some item components --- .../utils/item/components/ItemCustomModelDataComponent.kt | 1 + .../utils/item/components/ItemJukeboxPlayableComponent.kt | 1 - .../engine/paper/utils/item/components/ItemPDCComponent.kt | 1 + .../utils/item/components/ItemTooltipStyleComponent.kt | 6 ++++-- 4 files changed, 6 insertions(+), 3 deletions(-) diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemCustomModelDataComponent.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemCustomModelDataComponent.kt index 687ebcfd29..90de80de86 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemCustomModelDataComponent.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemCustomModelDataComponent.kt @@ -17,6 +17,7 @@ import org.bukkit.inventory.ItemStack class ItemCustomModelDataComponent( @InnerMin(Min(0)) @Default("0") + val customModelData: Var = ConstVar(0), ) : ItemComponent { override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack) { diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemJukeboxPlayableComponent.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemJukeboxPlayableComponent.kt index 0ed6f53f3a..2bdf2b97f0 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemJukeboxPlayableComponent.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemJukeboxPlayableComponent.kt @@ -22,7 +22,6 @@ class ItemJukeboxPlayableComponent( val jukeboxComponent = meta.jukeboxPlayable jukeboxComponent.songKey = soundKey - meta.setJukeboxPlayable(jukeboxComponent) } } diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemPDCComponent.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemPDCComponent.kt index bdc7fb1ced..6052063b4c 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemPDCComponent.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemPDCComponent.kt @@ -20,6 +20,7 @@ class ItemPDCComponent( val key: Var = ConstVar("custom_data"), val value: Var = ConstVar(""), ) : ItemComponent { + override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack) { item.editMeta { meta -> val namespaceValue = namespace.get(player) ?: return@editMeta diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemTooltipStyleComponent.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemTooltipStyleComponent.kt index cfd1d11366..a2728c4288 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemTooltipStyleComponent.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemTooltipStyleComponent.kt @@ -1,7 +1,8 @@ package com.typewritermc.engine.paper.utils.item.components import com.typewritermc.core.books.pages.Colors -import com.typewritermc.core.extension.annotations.* +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 @@ -16,7 +17,7 @@ class ItemTooltipStyleComponent( val namespace: Var = ConstVar("minecraft"), @Default("\"default\"") val key: Var = ConstVar("default"), -): ItemComponent { +) : ItemComponent { override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack) { item.editMeta { meta -> val namespaceValue = namespace.get(player) ?: return@editMeta @@ -26,6 +27,7 @@ class ItemTooltipStyleComponent( } } + override fun matches(player: Player?, interactionContext: InteractionContext?, item: ItemStack): Boolean { val expectedNamespace = namespace.get(player) ?: return false val expectedKey = key.get(player) ?: return false From 22b5a40111a026d8fb742721e2b380a976fe80f3 Mon Sep 17 00:00:00 2001 From: Chaosgh Date: Sun, 24 Aug 2025 22:34:57 +0200 Subject: [PATCH 03/13] fixed default mismatch --- .../engine/paper/utils/item/components/ItemPDCComponent.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemPDCComponent.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemPDCComponent.kt index 6052063b4c..b9860d7703 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemPDCComponent.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemPDCComponent.kt @@ -14,7 +14,7 @@ import org.bukkit.persistence.PersistentDataType @AlgebraicTypeInfo("persistent_data_container", Colors.PURPLE, "fa6-solid:database") class ItemPDCComponent( - @Default("\"minecraft\"") + @Default("\"typewriter\"") val namespace: Var = ConstVar("typewriter"), @Default("\"custom_data\"") val key: Var = ConstVar("custom_data"), From 9ef42b24fe976f31cdfaedcaf0ad523d83b2d0da Mon Sep 17 00:00:00 2001 From: Chaosgh Date: Sun, 24 Aug 2025 22:51:05 +0200 Subject: [PATCH 04/13] refactor ItemComponents Add InteractionContext for parity and added blank/empty checks. --- .../components/ItemCustomModelDataComponent.kt | 17 +++++++---------- .../components/ItemJukeboxPlayableComponent.kt | 17 +++++++++++++---- .../utils/item/components/ItemPDCComponent.kt | 16 ++++++++-------- .../components/ItemTooltipStyleComponent.kt | 9 +++++---- 4 files changed, 33 insertions(+), 26 deletions(-) diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemCustomModelDataComponent.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemCustomModelDataComponent.kt index 90de80de86..e47a6afb4a 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemCustomModelDataComponent.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemCustomModelDataComponent.kt @@ -22,20 +22,17 @@ class ItemCustomModelDataComponent( ) : ItemComponent { override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack) { item.editMeta { meta -> - val modelData = customModelData.get(player) ?: return@editMeta - val modelDataComponent = meta.customModelDataComponent - - if (modelData == 0) { - modelDataComponent.floats = emptyList() - } else { - modelDataComponent.floats = listOf(modelData.toFloat()) - } - meta.setCustomModelDataComponent(modelDataComponent) + 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) ?: return false + val expectedModelData = customModelData.get(player, interactionContext) ?: return false val actualComponent = item.itemMeta?.customModelDataComponent val actualFloats = actualComponent?.floats ?: emptyList() diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemJukeboxPlayableComponent.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemJukeboxPlayableComponent.kt index 2bdf2b97f0..afa14e8303 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemJukeboxPlayableComponent.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemJukeboxPlayableComponent.kt @@ -17,18 +17,27 @@ class ItemJukeboxPlayableComponent( ) : ItemComponent { override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack) { item.editMeta { meta -> - val soundKey = sound.get(player, interactionContext)?.soundId?.namespacedKey ?: return@editMeta + 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 expectedSoundKey = sound.get(player, interactionContext)?.soundId?.namespacedKey ?: return false + val expectedSound = sound.get(player, interactionContext) val actualComponent = item.itemMeta?.jukeboxPlayable - return actualComponent?.songKey == expectedSoundKey + + if (expectedSound == null || expectedSound == Sound.EMPTY) { + return actualComponent == null + } + + return actualComponent?.songKey == expectedSound.soundId.namespacedKey } } \ No newline at end of file diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemPDCComponent.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemPDCComponent.kt index b9860d7703..e866be871b 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemPDCComponent.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemPDCComponent.kt @@ -23,13 +23,13 @@ class ItemPDCComponent( override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack) { item.editMeta { meta -> - val namespaceValue = namespace.get(player) ?: return@editMeta - val keyValue = key.get(player) ?: return@editMeta - val valueValue = value.get(player) ?: return@editMeta + val namespaceValue = namespace.get(player, interactionContext) ?: return@editMeta + val keyValue = key.get(player, interactionContext) ?: return@editMeta + val valueValue = value.get(player, interactionContext) ?: return@editMeta val namespacedKey = NamespacedKey(namespaceValue, keyValue) - if (valueValue.isEmpty()) { + if (valueValue.isBlank()) { meta.persistentDataContainer.remove(namespacedKey) } else { meta.persistentDataContainer.set(namespacedKey, PersistentDataType.STRING, valueValue) @@ -38,14 +38,14 @@ class ItemPDCComponent( } override fun matches(player: Player?, interactionContext: InteractionContext?, item: ItemStack): Boolean { - val expectedNamespace = namespace.get(player) ?: return false - val expectedKey = key.get(player) ?: return false - val expectedValue = value.get(player) ?: return false + val expectedNamespace = namespace.get(player, interactionContext) ?: return false + val expectedKey = key.get(player, interactionContext) ?: return false + val expectedValue = value.get(player, interactionContext) ?: return false val namespacedKey = NamespacedKey(expectedNamespace, expectedKey) val actualValue = item.itemMeta?.persistentDataContainer?.get(namespacedKey, PersistentDataType.STRING) - return if (expectedValue.isEmpty()) { + return if (expectedValue.isBlank()) { actualValue == null } else { actualValue == expectedValue diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemTooltipStyleComponent.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemTooltipStyleComponent.kt index a2728c4288..ee01970e46 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemTooltipStyleComponent.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemTooltipStyleComponent.kt @@ -20,17 +20,18 @@ class ItemTooltipStyleComponent( ) : ItemComponent { override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack) { item.editMeta { meta -> - val namespaceValue = namespace.get(player) ?: return@editMeta - val keyValue = key.get(player) ?: return@editMeta + 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) ?: return false - val expectedKey = key.get(player) ?: return false + 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 From 0add0396c821f81aa1867b47eda1710b08b80f33 Mon Sep 17 00:00:00 2001 From: Chaosgh Date: Sun, 24 Aug 2025 23:05:00 +0200 Subject: [PATCH 05/13] Better handeling of invalide namespaces in ItemPDCComponent (for example white spaces or illegal chars) --- .../utils/item/components/ItemPDCComponent.kt | 39 ++++++++++++------- 1 file changed, 24 insertions(+), 15 deletions(-) diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemPDCComponent.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemPDCComponent.kt index e866be871b..dfb9d3796e 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemPDCComponent.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemPDCComponent.kt @@ -18,37 +18,46 @@ class ItemPDCComponent( val namespace: Var = ConstVar("typewriter"), @Default("\"custom_data\"") val key: Var = ConstVar("custom_data"), + @Default("\"\"") val value: Var = ConstVar(""), ) : 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 valueValue = value.get(player, interactionContext) ?: return@editMeta - - val namespacedKey = NamespacedKey(namespaceValue, keyValue) + 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 (valueValue.isBlank()) { + if (v.isBlank()) { meta.persistentDataContainer.remove(namespacedKey) } else { - meta.persistentDataContainer.set(namespacedKey, PersistentDataType.STRING, valueValue) + meta.persistentDataContainer.set(namespacedKey, PersistentDataType.STRING, v) } } } 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 expectedValue = value.get(player, interactionContext) ?: return false - - val namespacedKey = NamespacedKey(expectedNamespace, expectedKey) + 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 (expectedValue.isBlank()) { - actualValue == null + return if (expected.isBlank()) { + actualValue.isNullOrBlank() } else { - actualValue == expectedValue + actualValue == expected } } } \ No newline at end of file From feedee3067f3da83d75cf9f97bd058b9c323ba1d Mon Sep 17 00:00:00 2001 From: Chaosgh Date: Wed, 27 Aug 2025 18:11:00 +0200 Subject: [PATCH 06/13] Small fix in `ItemNameComponent`: `effectiveName()` is only available since 1.21.4. --- .../item/components/ItemCustomModelDataComponent.kt | 2 -- .../paper/utils/item/components/ItemNameComponent.kt | 12 ++++++++++-- 2 files changed, 10 insertions(+), 4 deletions(-) diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemCustomModelDataComponent.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemCustomModelDataComponent.kt index e47a6afb4a..da24f448ea 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemCustomModelDataComponent.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemCustomModelDataComponent.kt @@ -17,7 +17,6 @@ import org.bukkit.inventory.ItemStack class ItemCustomModelDataComponent( @InnerMin(Min(0)) @Default("0") - val customModelData: Var = ConstVar(0), ) : ItemComponent { override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack) { @@ -30,7 +29,6 @@ class ItemCustomModelDataComponent( 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 diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemNameComponent.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemNameComponent.kt index ab58090429..4d6ba8b33a 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemNameComponent.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemNameComponent.kt @@ -1,5 +1,6 @@ package com.typewritermc.engine.paper.utils.item.components +import com.github.retrooper.packetevents.manager.server.ServerVersion import com.typewritermc.core.books.pages.Colors import com.typewritermc.core.extension.annotations.AlgebraicTypeInfo import com.typewritermc.core.extension.annotations.Colored @@ -11,6 +12,7 @@ import com.typewritermc.engine.paper.entry.entries.get import com.typewritermc.engine.paper.extensions.placeholderapi.parsePlaceholders import com.typewritermc.engine.paper.utils.asMini import com.typewritermc.engine.paper.utils.plainText +import com.typewritermc.engine.paper.utils.serverVersion import com.typewritermc.engine.paper.utils.stripped import org.bukkit.entity.Player import org.bukkit.inventory.ItemStack @@ -30,6 +32,12 @@ class ItemNameComponent( override fun matches(player: Player?, interactionContext: InteractionContext?, item: ItemStack): Boolean { val name = name.get(player) ?: return false - return item.effectiveName().plainText() == name.parsePlaceholders(player).stripped() + + + return if (serverVersion.isNewerThan(ServerVersion.V_1_21_3)) { + item.effectiveName().plainText() == name.parsePlaceholders(player).stripped() + } else { + item.displayName().plainText() == name.parsePlaceholders(player).stripped() + } } -} \ No newline at end of file +} From 8bc85150f3ed3bf5efa3ff44e383ab7beb150316 Mon Sep 17 00:00:00 2001 From: Chaosgh Date: Thu, 4 Sep 2025 21:01:11 +0200 Subject: [PATCH 07/13] - Data types were added to 'pdc' and 'CustomModelDataType'. - Changed all namespace keys to a single string for user-friendliness. - Added an item model component. --- .../ItemCustomModelDataComponent.kt | 33 +++-------- .../item/components/ItemModelComponent.kt | 47 ++++++++++++++++ .../utils/item/components/ItemPDCComponent.kt | 55 +++++-------------- .../components/ItemTooltipStyleComponent.kt | 45 +++++++++------ .../BooleansCustomModelData.kt | 35 ++++++++++++ .../ColorsCustomModelData.kt | 39 +++++++++++++ .../CustomModelDataType.kt | 10 ++++ .../FloatsCustomModelData.kt | 35 ++++++++++++ .../LegacyCustomModelData.kt | 19 +++++++ .../StringsCustomModelData.kt | 35 ++++++++++++ .../components/pdcTypes/BooleanPdcData.kt | 23 ++++++++ .../components/pdcTypes/ByteArrayPdcData.kt | 37 +++++++++++++ .../item/components/pdcTypes/BytePdcData.kt | 23 ++++++++ .../item/components/pdcTypes/DoublePdcData.kt | 23 ++++++++ .../components/pdcTypes/IntArrayPdcData.kt | 37 +++++++++++++ .../item/components/pdcTypes/IntPdcData.kt | 23 ++++++++ .../components/pdcTypes/LongArrayPdcData.kt | 37 +++++++++++++ .../item/components/pdcTypes/LongPdcData.kt | 23 ++++++++ .../item/components/pdcTypes/PdcDataType.kt | 11 ++++ .../item/components/pdcTypes/ShortPdcData.kt | 23 ++++++++ .../item/components/pdcTypes/StringPdcData.kt | 31 +++++++++++ 21 files changed, 561 insertions(+), 83 deletions(-) create mode 100644 engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemModelComponent.kt create mode 100644 engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/BooleansCustomModelData.kt create mode 100644 engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/ColorsCustomModelData.kt create mode 100644 engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/CustomModelDataType.kt create mode 100644 engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/FloatsCustomModelData.kt create mode 100644 engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/LegacyCustomModelData.kt create mode 100644 engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/StringsCustomModelData.kt create mode 100644 engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/BooleanPdcData.kt create mode 100644 engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/ByteArrayPdcData.kt create mode 100644 engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/BytePdcData.kt create mode 100644 engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/DoublePdcData.kt create mode 100644 engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/IntArrayPdcData.kt create mode 100644 engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/IntPdcData.kt create mode 100644 engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/LongArrayPdcData.kt create mode 100644 engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/LongPdcData.kt create mode 100644 engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/PdcDataType.kt create mode 100644 engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/ShortPdcData.kt create mode 100644 engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/StringPdcData.kt diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemCustomModelDataComponent.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemCustomModelDataComponent.kt index da24f448ea..3630129377 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemCustomModelDataComponent.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemCustomModelDataComponent.kt @@ -2,44 +2,25 @@ 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 com.typewritermc.engine.paper.utils.item.components.customModelDataTypes.CustomModelDataType +import com.typewritermc.engine.paper.utils.item.components.customModelDataTypes.LegacyCustomModelData 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 = ConstVar(0), + val customModelData: Var = ConstVar(LegacyCustomModelData(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) - } + customModelData.get(player, interactionContext)?.apply(player, interactionContext, item) } - 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 + override fun matches(player: Player?, interactionContext: InteractionContext?, item: ItemStack): Boolean { + val modelData = customModelData.get(player, interactionContext) ?: return false + return modelData.matches(player, interactionContext, item) } } \ No newline at end of file diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemModelComponent.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemModelComponent.kt new file mode 100644 index 0000000000..187d5c1228 --- /dev/null +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemModelComponent.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.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("item_model", Colors.BLUE, "fa6-solid:layer-group") +class ItemModelComponent( + val modelKey: Var = ConstVar("") +) : ItemComponent { + + override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack) { + item.editMeta { meta -> + val raw = modelKey.get(player, interactionContext)?.trim().orEmpty() + if (raw.isEmpty()) { + meta.itemModel = null + return@editMeta + } + + val key = NamespacedKey.fromString(raw) + if (key == null) { + meta.itemModel = null + return@editMeta + } + + meta.itemModel = key + } + } + + override fun matches(player: Player?, interactionContext: InteractionContext?, item: ItemStack): Boolean { + val expectedRaw = modelKey.get(player, interactionContext)?.trim().orEmpty() + val actual = item.itemMeta?.itemModel + + if (expectedRaw.isEmpty()) { + return actual == null + } + + val expected = NamespacedKey.fromString(expectedRaw) ?: return actual == null + return actual == expected + } +} diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemPDCComponent.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemPDCComponent.kt index dfb9d3796e..ee2f489fcc 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemPDCComponent.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemPDCComponent.kt @@ -2,62 +2,37 @@ 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 com.typewritermc.engine.paper.utils.item.components.pdcTypes.PdcDataType +import com.typewritermc.engine.paper.utils.item.components.pdcTypes.StringPdcData 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 = ConstVar("typewriter"), - @Default("\"custom_data\"") - val key: Var = ConstVar("custom_data"), - @Default("\"\"") - val value: Var = ConstVar(""), + + val dataKey: Var = ConstVar("typewriter:custom_data"), + val data: Var = ConstVar(StringPdcData("")), ) : 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 - } + val raw = dataKey.get(player, interactionContext)?.trim().orEmpty() + if (raw.isEmpty()) return - if (v.isBlank()) { - meta.persistentDataContainer.remove(namespacedKey) - } else { - meta.persistentDataContainer.set(namespacedKey, PersistentDataType.STRING, v) - } - } + val namespacedKey = NamespacedKey.fromString(raw) ?: return + data.get(player, interactionContext)?.apply(player, interactionContext, item, namespacedKey) } 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) + val raw = dataKey.get(player, interactionContext)?.trim().orEmpty() + if (raw.isEmpty()) return false - return if (expected.isBlank()) { - actualValue.isNullOrBlank() - } else { - actualValue == expected - } + val namespacedKey = NamespacedKey.fromString(raw) ?: return false + val pdcData = data.get(player, interactionContext) ?: return false + return pdcData.matches(player, interactionContext, item, namespacedKey) } -} \ No newline at end of file +} diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemTooltipStyleComponent.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemTooltipStyleComponent.kt index ee01970e46..f29318d028 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemTooltipStyleComponent.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemTooltipStyleComponent.kt @@ -2,7 +2,6 @@ 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 @@ -13,27 +12,39 @@ import org.bukkit.inventory.ItemStack @AlgebraicTypeInfo("tooltip_style", Colors.CYAN, "fa6-solid:palette") class ItemTooltipStyleComponent( - @Default("\"minecraft\"") - val namespace: Var = ConstVar("minecraft"), - @Default("\"default\"") - val key: Var = ConstVar("default"), + + val styleKey: Var = ConstVar("minecraft:diamond"), ) : 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 + val raw = styleKey.get(player, interactionContext)?.trim().orEmpty() + if (raw.isEmpty()) { + meta.tooltipStyle = null + return@editMeta + } + + val key = NamespacedKey.fromString(raw) + if (key == null) { + meta.tooltipStyle = null + return@editMeta + } + + if (meta.tooltipStyle != key) { + meta.tooltipStyle = key + } } } - 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 + val raw = styleKey.get(player, interactionContext)?.trim().orEmpty() + val actual = item.itemMeta?.tooltipStyle + + if (raw.isEmpty()) { + return actual == null + } + + val expected = NamespacedKey.fromString(raw) ?: return actual == null + return actual == expected } -} \ No newline at end of file +} diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/BooleansCustomModelData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/BooleansCustomModelData.kt new file mode 100644 index 0000000000..105ad853df --- /dev/null +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/BooleansCustomModelData.kt @@ -0,0 +1,35 @@ +package com.typewritermc.engine.paper.utils.item.components.customModelDataTypes + +import com.typewritermc.core.books.pages.Colors +import com.typewritermc.core.extension.annotations.AlgebraicTypeInfo +import com.typewritermc.core.interaction.InteractionContext +import com.github.retrooper.packetevents.manager.server.ServerVersion +import com.typewritermc.engine.paper.logger +import com.typewritermc.engine.paper.utils.serverVersion +import org.bukkit.entity.Player +import org.bukkit.inventory.ItemStack + +@AlgebraicTypeInfo("boolean_array", Colors.GREEN, "fa6-solid:shapes") +data class BooleansCustomModelData(val value: List) : CustomModelDataType { + override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack) { + if (!serverVersion.isNewerThan(ServerVersion.V_1_21_3)) { + logger.warning("${this::class.simpleName} is only supported in versions higher than 1.21.3") + return + } + item.editMeta { meta -> + val component = meta.customModelDataComponent + if (component.flags == value) return@editMeta + component.flags = value + meta.setCustomModelDataComponent(component) + } + } + + override fun matches(player: Player?, interactionContext: InteractionContext?, item: ItemStack): Boolean { + if (!serverVersion.isNewerThan(ServerVersion.V_1_21_3)) { + logger.warning("${this::class.simpleName} is only supported in versions higher than 1.21.3") + return false + } + val meta = item.itemMeta ?: return false + return meta.customModelDataComponent.flags == value + } +} \ No newline at end of file diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/ColorsCustomModelData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/ColorsCustomModelData.kt new file mode 100644 index 0000000000..6972c4a5c7 --- /dev/null +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/ColorsCustomModelData.kt @@ -0,0 +1,39 @@ +package com.typewritermc.engine.paper.utils.item.components.customModelDataTypes + +import com.github.retrooper.packetevents.manager.server.ServerVersion +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.logger +import com.typewritermc.engine.paper.utils.Color +import com.typewritermc.engine.paper.utils.serverVersion +import org.bukkit.entity.Player +import org.bukkit.inventory.ItemStack + +@AlgebraicTypeInfo("color_array", Colors.GREEN, "fa6-solid:shapes") +data class ColorsCustomModelData(val value: List) : CustomModelDataType { + override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack) { + if (!serverVersion.isNewerThan(ServerVersion.V_1_21_3)) { + logger.warning("${this::class.simpleName} is only supported in versions higher than 1.21.3") + return + } + item.editMeta { meta -> + val component = meta.customModelDataComponent + val bukkitColors = value.map { it.toBukkitColor() } + + if (component.colors == bukkitColors) return@editMeta + component.colors = bukkitColors + meta.setCustomModelDataComponent(component) + } + } + + override fun matches(player: Player?, interactionContext: InteractionContext?, item: ItemStack): Boolean { + if (!serverVersion.isNewerThan(ServerVersion.V_1_21_3)) { + logger.warning("${this::class.simpleName} is only supported in versions higher than 1.21.3") + return false + } + val meta = item.itemMeta ?: return false + val bukkitColors = value.map { it.toBukkitColor() } + return meta.customModelDataComponent.colors == bukkitColors + } +} diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/CustomModelDataType.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/CustomModelDataType.kt new file mode 100644 index 0000000000..2ce6e8f695 --- /dev/null +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/CustomModelDataType.kt @@ -0,0 +1,10 @@ +package com.typewritermc.engine.paper.utils.item.components.customModelDataTypes + +import com.typewritermc.core.interaction.InteractionContext +import org.bukkit.entity.Player +import org.bukkit.inventory.ItemStack + +sealed interface CustomModelDataType { + fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack) + fun matches(player: Player?, interactionContext: InteractionContext?, item: ItemStack): Boolean +} \ No newline at end of file diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/FloatsCustomModelData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/FloatsCustomModelData.kt new file mode 100644 index 0000000000..f70c323bf6 --- /dev/null +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/FloatsCustomModelData.kt @@ -0,0 +1,35 @@ +package com.typewritermc.engine.paper.utils.item.components.customModelDataTypes + +import com.typewritermc.core.books.pages.Colors +import com.typewritermc.core.extension.annotations.AlgebraicTypeInfo +import com.typewritermc.core.interaction.InteractionContext +import com.github.retrooper.packetevents.manager.server.ServerVersion +import com.typewritermc.engine.paper.logger +import com.typewritermc.engine.paper.utils.serverVersion +import org.bukkit.entity.Player +import org.bukkit.inventory.ItemStack + +@AlgebraicTypeInfo("float_array", Colors.GREEN, "fa6-solid:shapes") +data class FloatsCustomModelData(val value: List) : CustomModelDataType { + override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack) { + if (!serverVersion.isNewerThan(ServerVersion.V_1_21_3)) { + logger.warning("${this::class.simpleName} is only supported in versions higher than 1.21.3") + return + } + item.editMeta { meta -> + val component = meta.customModelDataComponent + if (component.floats == value) return@editMeta + component.floats = value + meta.setCustomModelDataComponent(component) + } + } + + override fun matches(player: Player?, interactionContext: InteractionContext?, item: ItemStack): Boolean { + if (!serverVersion.isNewerThan(ServerVersion.V_1_21_3)) { + logger.warning("${this::class.simpleName} is only supported in versions higher than 1.21.3") + return false + } + val meta = item.itemMeta ?: return false + return meta.customModelDataComponent.floats == value + } +} \ No newline at end of file diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/LegacyCustomModelData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/LegacyCustomModelData.kt new file mode 100644 index 0000000000..28d77c98c2 --- /dev/null +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/LegacyCustomModelData.kt @@ -0,0 +1,19 @@ +package com.typewritermc.engine.paper.utils.item.components.customModelDataTypes + +import com.typewritermc.core.books.pages.Colors +import com.typewritermc.core.extension.annotations.AlgebraicTypeInfo +import com.typewritermc.core.interaction.InteractionContext +import org.bukkit.entity.Player +import org.bukkit.inventory.ItemStack + +@AlgebraicTypeInfo("legacy_int", Colors.GREEN, "fa6-solid:shapes") +data class LegacyCustomModelData(val value: Int) : CustomModelDataType { + override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack) { + item.editMeta { meta -> meta.setCustomModelData(value) } + } + + override fun matches(player: Player?, interactionContext: InteractionContext?, item: ItemStack): Boolean { + val meta = item.itemMeta ?: return false + return meta.hasCustomModelData() && meta.customModelData == value + } +} \ No newline at end of file diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/StringsCustomModelData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/StringsCustomModelData.kt new file mode 100644 index 0000000000..01891c4958 --- /dev/null +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/StringsCustomModelData.kt @@ -0,0 +1,35 @@ +package com.typewritermc.engine.paper.utils.item.components.customModelDataTypes + +import com.typewritermc.core.books.pages.Colors +import com.typewritermc.core.extension.annotations.AlgebraicTypeInfo +import com.typewritermc.core.interaction.InteractionContext +import com.github.retrooper.packetevents.manager.server.ServerVersion +import com.typewritermc.engine.paper.logger +import com.typewritermc.engine.paper.utils.serverVersion +import org.bukkit.entity.Player +import org.bukkit.inventory.ItemStack + +@AlgebraicTypeInfo("string_array", Colors.GREEN, "fa6-solid:shapes") +data class StringsCustomModelData(val value: List) : CustomModelDataType { + override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack) { + if (!serverVersion.isNewerThan(ServerVersion.V_1_21_3)) { + logger.warning("${this::class.simpleName} is only supported in versions higher than 1.21.3") + return + } + item.editMeta { meta -> + val component = meta.customModelDataComponent + if (component.strings == value) return@editMeta + component.strings = value + meta.setCustomModelDataComponent(component) + } + } + + override fun matches(player: Player?, interactionContext: InteractionContext?, item: ItemStack): Boolean { + if (!serverVersion.isNewerThan(ServerVersion.V_1_21_3)) { + logger.warning("${this::class.simpleName} is only supported in versions higher than 1.21.3") + return false + } + val meta = item.itemMeta ?: return false + return meta.customModelDataComponent.strings == value + } +} \ No newline at end of file diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/BooleanPdcData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/BooleanPdcData.kt new file mode 100644 index 0000000000..f99c3d4cc9 --- /dev/null +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/BooleanPdcData.kt @@ -0,0 +1,23 @@ +package com.typewritermc.engine.paper.utils.item.components.pdcTypes + +import com.typewritermc.core.books.pages.Colors +import com.typewritermc.core.extension.annotations.AlgebraicTypeInfo +import com.typewritermc.core.interaction.InteractionContext +import org.bukkit.NamespacedKey +import org.bukkit.entity.Player +import org.bukkit.inventory.ItemStack +import org.bukkit.persistence.PersistentDataType + +@AlgebraicTypeInfo("boolean", Colors.PURPLE, "fa6-solid:database") +data class BooleanPdcData(val value: Boolean) : PdcDataType { + override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack, key: NamespacedKey) { + item.editMeta { meta -> + meta.persistentDataContainer.set(key, PersistentDataType.BOOLEAN, value) + } + } + + override fun matches(player: Player?, interactionContext: InteractionContext?, item: ItemStack, key: NamespacedKey): Boolean { + val container = item.itemMeta?.persistentDataContainer ?: return false + return container.get(key, PersistentDataType.BOOLEAN) == value + } +} \ No newline at end of file diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/ByteArrayPdcData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/ByteArrayPdcData.kt new file mode 100644 index 0000000000..9d34b304fc --- /dev/null +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/ByteArrayPdcData.kt @@ -0,0 +1,37 @@ +package com.typewritermc.engine.paper.utils.item.components.pdcTypes + +import com.typewritermc.core.books.pages.Colors +import com.typewritermc.core.extension.annotations.AlgebraicTypeInfo +import com.typewritermc.core.interaction.InteractionContext +import org.bukkit.NamespacedKey +import org.bukkit.entity.Player +import org.bukkit.inventory.ItemStack +import org.bukkit.persistence.PersistentDataType + +@AlgebraicTypeInfo("byte_array", Colors.PURPLE, "fa6-solid:database") +data class ByteArrayPdcData(val value: ByteArray) : PdcDataType { + override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack, key: NamespacedKey) { + item.editMeta { meta -> + meta.persistentDataContainer.set(key, PersistentDataType.BYTE_ARRAY, value) + } + } + + override fun matches(player: Player?, interactionContext: InteractionContext?, item: ItemStack, key: NamespacedKey): Boolean { + val container = item.itemMeta?.persistentDataContainer ?: return false + val actual = container.get(key, PersistentDataType.BYTE_ARRAY) ?: return false + return actual.contentEquals(value) + } + + override fun equals(other: Any?): Boolean { + if (this === other) return true + if (javaClass != other?.javaClass) return false + + other as ByteArrayPdcData + + return value.contentEquals(other.value) + } + + override fun hashCode(): Int { + return value.contentHashCode() + } +} \ No newline at end of file diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/BytePdcData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/BytePdcData.kt new file mode 100644 index 0000000000..4d82c9003c --- /dev/null +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/BytePdcData.kt @@ -0,0 +1,23 @@ +package com.typewritermc.engine.paper.utils.item.components.pdcTypes + +import com.typewritermc.core.books.pages.Colors +import com.typewritermc.core.extension.annotations.AlgebraicTypeInfo +import com.typewritermc.core.interaction.InteractionContext +import org.bukkit.NamespacedKey +import org.bukkit.entity.Player +import org.bukkit.inventory.ItemStack +import org.bukkit.persistence.PersistentDataType + +@AlgebraicTypeInfo("byte", Colors.PURPLE, "fa6-solid:database") +data class BytePdcData(val value: Byte) : PdcDataType { + override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack, key: NamespacedKey) { + item.editMeta { meta -> + meta.persistentDataContainer.set(key, PersistentDataType.BYTE, value) + } + } + + override fun matches(player: Player?, interactionContext: InteractionContext?, item: ItemStack, key: NamespacedKey): Boolean { + val container = item.itemMeta?.persistentDataContainer ?: return false + return container.get(key, PersistentDataType.BYTE) == value + } +} \ No newline at end of file diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/DoublePdcData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/DoublePdcData.kt new file mode 100644 index 0000000000..ed74f37a7d --- /dev/null +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/DoublePdcData.kt @@ -0,0 +1,23 @@ +package com.typewritermc.engine.paper.utils.item.components.pdcTypes + +import com.typewritermc.core.books.pages.Colors +import com.typewritermc.core.extension.annotations.AlgebraicTypeInfo +import com.typewritermc.core.interaction.InteractionContext +import org.bukkit.NamespacedKey +import org.bukkit.entity.Player +import org.bukkit.inventory.ItemStack +import org.bukkit.persistence.PersistentDataType + +@AlgebraicTypeInfo("double", Colors.PURPLE, "fa6-solid:database") +data class DoublePdcData(val value: Double) : PdcDataType { + override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack, key: NamespacedKey) { + item.editMeta { meta -> + meta.persistentDataContainer.set(key, PersistentDataType.DOUBLE, value) + } + } + + override fun matches(player: Player?, interactionContext: InteractionContext?, item: ItemStack, key: NamespacedKey): Boolean { + val container = item.itemMeta?.persistentDataContainer ?: return false + return container.get(key, PersistentDataType.DOUBLE) == value + } +} \ No newline at end of file diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/IntArrayPdcData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/IntArrayPdcData.kt new file mode 100644 index 0000000000..4809b4925e --- /dev/null +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/IntArrayPdcData.kt @@ -0,0 +1,37 @@ +package com.typewritermc.engine.paper.utils.item.components.pdcTypes + +import com.typewritermc.core.books.pages.Colors +import com.typewritermc.core.extension.annotations.AlgebraicTypeInfo +import com.typewritermc.core.interaction.InteractionContext +import org.bukkit.NamespacedKey +import org.bukkit.entity.Player +import org.bukkit.inventory.ItemStack +import org.bukkit.persistence.PersistentDataType + +@AlgebraicTypeInfo("int_array", Colors.PURPLE, "fa6-solid:database") +data class IntArrayPdcData(val value: IntArray) : PdcDataType { + override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack, key: NamespacedKey) { + item.editMeta { meta -> + meta.persistentDataContainer.set(key, PersistentDataType.INTEGER_ARRAY, value) + } + } + + override fun matches(player: Player?, interactionContext: InteractionContext?, item: ItemStack, key: NamespacedKey): Boolean { + val container = item.itemMeta?.persistentDataContainer ?: return false + val actual = container.get(key, PersistentDataType.INTEGER_ARRAY) ?: return false + return actual.contentEquals(value) + } + + override fun equals(other: Any?): Boolean { + if (this === other) return true + if (javaClass != other?.javaClass) return false + + other as IntArrayPdcData + + return value.contentEquals(other.value) + } + + override fun hashCode(): Int { + return value.contentHashCode() + } +} \ No newline at end of file diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/IntPdcData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/IntPdcData.kt new file mode 100644 index 0000000000..468e0d08c9 --- /dev/null +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/IntPdcData.kt @@ -0,0 +1,23 @@ +package com.typewritermc.engine.paper.utils.item.components.pdcTypes + +import com.typewritermc.core.books.pages.Colors +import com.typewritermc.core.extension.annotations.AlgebraicTypeInfo +import com.typewritermc.core.interaction.InteractionContext +import org.bukkit.NamespacedKey +import org.bukkit.entity.Player +import org.bukkit.inventory.ItemStack +import org.bukkit.persistence.PersistentDataType + +@AlgebraicTypeInfo("int", Colors.PURPLE, "fa6-solid:database") +data class IntPdcData(val value: Int) : PdcDataType { + override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack, key: NamespacedKey) { + item.editMeta { meta -> + meta.persistentDataContainer.set(key, PersistentDataType.INTEGER, value) + } + } + + override fun matches(player: Player?, interactionContext: InteractionContext?, item: ItemStack, key: NamespacedKey): Boolean { + val container = item.itemMeta?.persistentDataContainer ?: return false + return container.get(key, PersistentDataType.INTEGER) == value + } +} \ No newline at end of file diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/LongArrayPdcData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/LongArrayPdcData.kt new file mode 100644 index 0000000000..e7126447b9 --- /dev/null +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/LongArrayPdcData.kt @@ -0,0 +1,37 @@ +package com.typewritermc.engine.paper.utils.item.components.pdcTypes + +import com.typewritermc.core.books.pages.Colors +import com.typewritermc.core.extension.annotations.AlgebraicTypeInfo +import com.typewritermc.core.interaction.InteractionContext +import org.bukkit.NamespacedKey +import org.bukkit.entity.Player +import org.bukkit.inventory.ItemStack +import org.bukkit.persistence.PersistentDataType + +@AlgebraicTypeInfo("long_array", Colors.PURPLE, "fa6-solid:database") +data class LongArrayPdcData(val value: LongArray) : PdcDataType { + override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack, key: NamespacedKey) { + item.editMeta { meta -> + meta.persistentDataContainer.set(key, PersistentDataType.LONG_ARRAY, value) + } + } + + override fun matches(player: Player?, interactionContext: InteractionContext?, item: ItemStack, key: NamespacedKey): Boolean { + val container = item.itemMeta?.persistentDataContainer ?: return false + val actual = container.get(key, PersistentDataType.LONG_ARRAY) ?: return false + return actual.contentEquals(value) + } + + override fun equals(other: Any?): Boolean { + if (this === other) return true + if (javaClass != other?.javaClass) return false + + other as LongArrayPdcData + + return value.contentEquals(other.value) + } + + override fun hashCode(): Int { + return value.contentHashCode() + } +} \ No newline at end of file diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/LongPdcData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/LongPdcData.kt new file mode 100644 index 0000000000..9e1bfc1fc6 --- /dev/null +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/LongPdcData.kt @@ -0,0 +1,23 @@ +package com.typewritermc.engine.paper.utils.item.components.pdcTypes + +import com.typewritermc.core.books.pages.Colors +import com.typewritermc.core.extension.annotations.AlgebraicTypeInfo +import com.typewritermc.core.interaction.InteractionContext +import org.bukkit.NamespacedKey +import org.bukkit.entity.Player +import org.bukkit.inventory.ItemStack +import org.bukkit.persistence.PersistentDataType + +@AlgebraicTypeInfo("long", Colors.PURPLE, "fa6-solid:database") +data class LongPdcData(val value: Long) : PdcDataType { + override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack, key: NamespacedKey) { + item.editMeta { meta -> + meta.persistentDataContainer.set(key, PersistentDataType.LONG, value) + } + } + + override fun matches(player: Player?, interactionContext: InteractionContext?, item: ItemStack, key: NamespacedKey): Boolean { + val container = item.itemMeta?.persistentDataContainer ?: return false + return container.get(key, PersistentDataType.LONG) == value + } +} \ No newline at end of file diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/PdcDataType.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/PdcDataType.kt new file mode 100644 index 0000000000..c72d469654 --- /dev/null +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/PdcDataType.kt @@ -0,0 +1,11 @@ +package com.typewritermc.engine.paper.utils.item.components.pdcTypes + +import com.typewritermc.core.interaction.InteractionContext +import org.bukkit.NamespacedKey +import org.bukkit.entity.Player +import org.bukkit.inventory.ItemStack + +sealed interface PdcDataType { + fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack, key: NamespacedKey) + fun matches(player: Player?, interactionContext: InteractionContext?, item: ItemStack, key: NamespacedKey): Boolean +} \ No newline at end of file diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/ShortPdcData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/ShortPdcData.kt new file mode 100644 index 0000000000..ec2ca944d9 --- /dev/null +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/ShortPdcData.kt @@ -0,0 +1,23 @@ +package com.typewritermc.engine.paper.utils.item.components.pdcTypes + +import com.typewritermc.core.books.pages.Colors +import com.typewritermc.core.extension.annotations.AlgebraicTypeInfo +import com.typewritermc.core.interaction.InteractionContext +import org.bukkit.NamespacedKey +import org.bukkit.entity.Player +import org.bukkit.inventory.ItemStack +import org.bukkit.persistence.PersistentDataType + +@AlgebraicTypeInfo("short", Colors.PURPLE, "fa6-solid:database") +data class ShortPdcData(val value: Short) : PdcDataType { + override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack, key: NamespacedKey) { + item.editMeta { meta -> + meta.persistentDataContainer.set(key, PersistentDataType.SHORT, value) + } + } + + override fun matches(player: Player?, interactionContext: InteractionContext?, item: ItemStack, key: NamespacedKey): Boolean { + val container = item.itemMeta?.persistentDataContainer ?: return false + return container.get(key, PersistentDataType.SHORT) == value + } +} \ No newline at end of file diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/StringPdcData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/StringPdcData.kt new file mode 100644 index 0000000000..4c5f65a8e0 --- /dev/null +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/StringPdcData.kt @@ -0,0 +1,31 @@ +package com.typewritermc.engine.paper.utils.item.components.pdcTypes + +import com.typewritermc.core.books.pages.Colors +import com.typewritermc.core.extension.annotations.AlgebraicTypeInfo +import com.typewritermc.core.interaction.InteractionContext +import org.bukkit.NamespacedKey +import org.bukkit.entity.Player +import org.bukkit.inventory.ItemStack +import org.bukkit.persistence.PersistentDataType + +@AlgebraicTypeInfo("persistent_data_string", Colors.PURPLE, "fa6-solid:database") +data class StringPdcData(val value: String) : PdcDataType { + override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack, key: NamespacedKey) { + item.editMeta { meta -> + if (value.isBlank()) { + meta.persistentDataContainer.remove(key) + } else { + meta.persistentDataContainer.set(key, PersistentDataType.STRING, value) + } + } + } + + override fun matches(player: Player?, interactionContext: InteractionContext?, item: ItemStack, key: NamespacedKey): Boolean { + val actual = item.itemMeta?.persistentDataContainer?.get(key, PersistentDataType.STRING) + return if (value.isBlank()) { + actual.isNullOrBlank() + } else { + actual == value + } + } +} \ No newline at end of file From 99077b600725a9c1993137c2ba810fc095d6fc69 Mon Sep 17 00:00:00 2001 From: Chaosgh Date: Thu, 4 Sep 2025 21:01:27 +0200 Subject: [PATCH 08/13] - Data types were added to 'pdc' and 'CustomModelDataType'. - Changed all namespace keys to a single string for user-friendliness. - Added an item model component. --- .../item/components/pdcTypes/FloatPdcData.kt | 23 +++++++++++++++++++ 1 file changed, 23 insertions(+) create mode 100644 engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/FloatPdcData.kt diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/FloatPdcData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/FloatPdcData.kt new file mode 100644 index 0000000000..e15fb33037 --- /dev/null +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/FloatPdcData.kt @@ -0,0 +1,23 @@ +package com.typewritermc.engine.paper.utils.item.components.pdcTypes + +import com.typewritermc.core.books.pages.Colors +import com.typewritermc.core.extension.annotations.AlgebraicTypeInfo +import com.typewritermc.core.interaction.InteractionContext +import org.bukkit.NamespacedKey +import org.bukkit.entity.Player +import org.bukkit.inventory.ItemStack +import org.bukkit.persistence.PersistentDataType + +@AlgebraicTypeInfo("float", Colors.PURPLE, "fa6-solid:database") +data class FloatPdcData(val value: Float) : PdcDataType { + override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack, key: NamespacedKey) { + item.editMeta { meta -> + meta.persistentDataContainer.set(key, PersistentDataType.FLOAT, value) + } + } + + override fun matches(player: Player?, interactionContext: InteractionContext?, item: ItemStack, key: NamespacedKey): Boolean { + val container = item.itemMeta?.persistentDataContainer ?: return false + return container.get(key, PersistentDataType.FLOAT) == value + } +} \ No newline at end of file From 8478c5cb0ec5666e7c6677654aaa121511227d45 Mon Sep 17 00:00:00 2001 From: Chaosgh Date: Thu, 4 Sep 2025 21:49:02 +0200 Subject: [PATCH 09/13] small fixes to stay compatible with the typewriter panel --- .../item/components/ItemAmountComponent.kt | 7 ++-- .../BooleansCustomModelData.kt | 7 ++-- .../ColorsCustomModelData.kt | 6 +++- .../FloatsCustomModelData.kt | 8 +++-- .../LegacyCustomModelData.kt | 6 +++- .../StringsCustomModelData.kt | 8 +++-- .../components/pdcTypes/BooleanPdcData.kt | 13 +++++-- .../components/pdcTypes/ByteArrayPdcData.kt | 33 +++++++++++------ .../item/components/pdcTypes/BytePdcData.kt | 32 ++++++++++++++--- .../item/components/pdcTypes/DoublePdcData.kt | 13 +++++-- .../item/components/pdcTypes/FloatPdcData.kt | 13 +++++-- .../components/pdcTypes/IntArrayPdcData.kt | 29 +++++++++------ .../item/components/pdcTypes/IntPdcData.kt | 13 +++++-- .../components/pdcTypes/LongArrayPdcData.kt | 34 ++++++++++++------ .../item/components/pdcTypes/LongPdcData.kt | 36 ++++++++++++++++--- .../item/components/pdcTypes/ShortPdcData.kt | 36 ++++++++++++++++--- .../item/components/pdcTypes/StringPdcData.kt | 13 +++++-- 17 files changed, 241 insertions(+), 66 deletions(-) diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemAmountComponent.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemAmountComponent.kt index a403b87887..0741b28afd 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemAmountComponent.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemAmountComponent.kt @@ -1,7 +1,10 @@ package com.typewritermc.engine.paper.utils.item.components import com.typewritermc.core.books.pages.Colors -import com.typewritermc.core.extension.annotations.* +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 @@ -14,7 +17,7 @@ class ItemAmountComponent( @InnerMin(Min(0)) @Default("1") val amount: Var = ConstVar(1), -): ItemComponent { +) : ItemComponent { override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack) { item.amount = amount.get(player, interactionContext) ?: 1 } diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/BooleansCustomModelData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/BooleansCustomModelData.kt index 105ad853df..8e346265d8 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/BooleansCustomModelData.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/BooleansCustomModelData.kt @@ -1,16 +1,19 @@ package com.typewritermc.engine.paper.utils.item.components.customModelDataTypes +import com.github.retrooper.packetevents.manager.server.ServerVersion import com.typewritermc.core.books.pages.Colors import com.typewritermc.core.extension.annotations.AlgebraicTypeInfo import com.typewritermc.core.interaction.InteractionContext -import com.github.retrooper.packetevents.manager.server.ServerVersion import com.typewritermc.engine.paper.logger import com.typewritermc.engine.paper.utils.serverVersion import org.bukkit.entity.Player import org.bukkit.inventory.ItemStack @AlgebraicTypeInfo("boolean_array", Colors.GREEN, "fa6-solid:shapes") -data class BooleansCustomModelData(val value: List) : CustomModelDataType { +data class BooleansCustomModelData( + val value: List = emptyList() + +) : CustomModelDataType { override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack) { if (!serverVersion.isNewerThan(ServerVersion.V_1_21_3)) { logger.warning("${this::class.simpleName} is only supported in versions higher than 1.21.3") diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/ColorsCustomModelData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/ColorsCustomModelData.kt index 6972c4a5c7..1124608722 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/ColorsCustomModelData.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/ColorsCustomModelData.kt @@ -11,7 +11,11 @@ import org.bukkit.entity.Player import org.bukkit.inventory.ItemStack @AlgebraicTypeInfo("color_array", Colors.GREEN, "fa6-solid:shapes") -data class ColorsCustomModelData(val value: List) : CustomModelDataType { +data class ColorsCustomModelData( + + val value: List = emptyList() + +) : CustomModelDataType { override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack) { if (!serverVersion.isNewerThan(ServerVersion.V_1_21_3)) { logger.warning("${this::class.simpleName} is only supported in versions higher than 1.21.3") diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/FloatsCustomModelData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/FloatsCustomModelData.kt index f70c323bf6..a66e2c01c8 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/FloatsCustomModelData.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/FloatsCustomModelData.kt @@ -1,16 +1,20 @@ package com.typewritermc.engine.paper.utils.item.components.customModelDataTypes +import com.github.retrooper.packetevents.manager.server.ServerVersion import com.typewritermc.core.books.pages.Colors import com.typewritermc.core.extension.annotations.AlgebraicTypeInfo import com.typewritermc.core.interaction.InteractionContext -import com.github.retrooper.packetevents.manager.server.ServerVersion import com.typewritermc.engine.paper.logger import com.typewritermc.engine.paper.utils.serverVersion import org.bukkit.entity.Player import org.bukkit.inventory.ItemStack @AlgebraicTypeInfo("float_array", Colors.GREEN, "fa6-solid:shapes") -data class FloatsCustomModelData(val value: List) : CustomModelDataType { +data class FloatsCustomModelData( + + val value: List = emptyList() + +) : CustomModelDataType { override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack) { if (!serverVersion.isNewerThan(ServerVersion.V_1_21_3)) { logger.warning("${this::class.simpleName} is only supported in versions higher than 1.21.3") diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/LegacyCustomModelData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/LegacyCustomModelData.kt index 28d77c98c2..43cba47e08 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/LegacyCustomModelData.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/LegacyCustomModelData.kt @@ -7,7 +7,11 @@ import org.bukkit.entity.Player import org.bukkit.inventory.ItemStack @AlgebraicTypeInfo("legacy_int", Colors.GREEN, "fa6-solid:shapes") -data class LegacyCustomModelData(val value: Int) : CustomModelDataType { +data class LegacyCustomModelData( + + val value: Int = 0 + +) : CustomModelDataType { override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack) { item.editMeta { meta -> meta.setCustomModelData(value) } } diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/StringsCustomModelData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/StringsCustomModelData.kt index 01891c4958..6be510b1e0 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/StringsCustomModelData.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/StringsCustomModelData.kt @@ -1,16 +1,20 @@ package com.typewritermc.engine.paper.utils.item.components.customModelDataTypes +import com.github.retrooper.packetevents.manager.server.ServerVersion import com.typewritermc.core.books.pages.Colors import com.typewritermc.core.extension.annotations.AlgebraicTypeInfo import com.typewritermc.core.interaction.InteractionContext -import com.github.retrooper.packetevents.manager.server.ServerVersion import com.typewritermc.engine.paper.logger import com.typewritermc.engine.paper.utils.serverVersion import org.bukkit.entity.Player import org.bukkit.inventory.ItemStack @AlgebraicTypeInfo("string_array", Colors.GREEN, "fa6-solid:shapes") -data class StringsCustomModelData(val value: List) : CustomModelDataType { +data class StringsCustomModelData( + + val value: List = emptyList() + +) : CustomModelDataType { override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack) { if (!serverVersion.isNewerThan(ServerVersion.V_1_21_3)) { logger.warning("${this::class.simpleName} is only supported in versions higher than 1.21.3") diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/BooleanPdcData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/BooleanPdcData.kt index f99c3d4cc9..24f6158b7a 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/BooleanPdcData.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/BooleanPdcData.kt @@ -9,14 +9,23 @@ import org.bukkit.inventory.ItemStack import org.bukkit.persistence.PersistentDataType @AlgebraicTypeInfo("boolean", Colors.PURPLE, "fa6-solid:database") -data class BooleanPdcData(val value: Boolean) : PdcDataType { +data class BooleanPdcData( + + val value: Boolean = false + +) : PdcDataType { override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack, key: NamespacedKey) { item.editMeta { meta -> meta.persistentDataContainer.set(key, PersistentDataType.BOOLEAN, value) } } - override fun matches(player: Player?, interactionContext: InteractionContext?, item: ItemStack, key: NamespacedKey): Boolean { + override fun matches( + player: Player?, + interactionContext: InteractionContext?, + item: ItemStack, + key: NamespacedKey + ): Boolean { val container = item.itemMeta?.persistentDataContainer ?: return false return container.get(key, PersistentDataType.BOOLEAN) == value } diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/ByteArrayPdcData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/ByteArrayPdcData.kt index 9d34b304fc..178e2f56ce 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/ByteArrayPdcData.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/ByteArrayPdcData.kt @@ -2,6 +2,8 @@ package com.typewritermc.engine.paper.utils.item.components.pdcTypes import com.typewritermc.core.books.pages.Colors import com.typewritermc.core.extension.annotations.AlgebraicTypeInfo +import com.typewritermc.core.extension.annotations.InnerMax +import com.typewritermc.core.extension.annotations.Max import com.typewritermc.core.interaction.InteractionContext import org.bukkit.NamespacedKey import org.bukkit.entity.Player @@ -9,17 +11,31 @@ import org.bukkit.inventory.ItemStack import org.bukkit.persistence.PersistentDataType @AlgebraicTypeInfo("byte_array", Colors.PURPLE, "fa6-solid:database") -data class ByteArrayPdcData(val value: ByteArray) : PdcDataType { +data class ByteArrayPdcData( + + @InnerMax(Max(255)) + val value: List = emptyList() + +) : PdcDataType { + + private fun toByteArray(): ByteArray = + value.map { it.toByte() }.toByteArray() + override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack, key: NamespacedKey) { item.editMeta { meta -> - meta.persistentDataContainer.set(key, PersistentDataType.BYTE_ARRAY, value) + meta.persistentDataContainer.set(key, PersistentDataType.BYTE_ARRAY, toByteArray()) } } - override fun matches(player: Player?, interactionContext: InteractionContext?, item: ItemStack, key: NamespacedKey): Boolean { + override fun matches( + player: Player?, + interactionContext: InteractionContext?, + item: ItemStack, + key: NamespacedKey + ): Boolean { val container = item.itemMeta?.persistentDataContainer ?: return false val actual = container.get(key, PersistentDataType.BYTE_ARRAY) ?: return false - return actual.contentEquals(value) + return actual.contentEquals(toByteArray()) } override fun equals(other: Any?): Boolean { @@ -27,11 +43,8 @@ data class ByteArrayPdcData(val value: ByteArray) : PdcDataType { if (javaClass != other?.javaClass) return false other as ByteArrayPdcData - - return value.contentEquals(other.value) + return value == other.value } - override fun hashCode(): Int { - return value.contentHashCode() - } -} \ No newline at end of file + override fun hashCode(): Int = value.hashCode() +} diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/BytePdcData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/BytePdcData.kt index 4d82c9003c..aa07814251 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/BytePdcData.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/BytePdcData.kt @@ -2,6 +2,7 @@ package com.typewritermc.engine.paper.utils.item.components.pdcTypes import com.typewritermc.core.books.pages.Colors import com.typewritermc.core.extension.annotations.AlgebraicTypeInfo +import com.typewritermc.core.extension.annotations.Max import com.typewritermc.core.interaction.InteractionContext import org.bukkit.NamespacedKey import org.bukkit.entity.Player @@ -9,15 +10,36 @@ import org.bukkit.inventory.ItemStack import org.bukkit.persistence.PersistentDataType @AlgebraicTypeInfo("byte", Colors.PURPLE, "fa6-solid:database") -data class BytePdcData(val value: Byte) : PdcDataType { +data class BytePdcData( + @Max(255) + val value: Int = 0 +) : PdcDataType { + + private fun asByte(): Byte = value.toByte() + override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack, key: NamespacedKey) { item.editMeta { meta -> - meta.persistentDataContainer.set(key, PersistentDataType.BYTE, value) + meta.persistentDataContainer.set(key, PersistentDataType.BYTE, asByte()) } } - override fun matches(player: Player?, interactionContext: InteractionContext?, item: ItemStack, key: NamespacedKey): Boolean { + override fun matches( + player: Player?, + interactionContext: InteractionContext?, + item: ItemStack, + key: NamespacedKey + ): Boolean { val container = item.itemMeta?.persistentDataContainer ?: return false - return container.get(key, PersistentDataType.BYTE) == value + return container.get(key, PersistentDataType.BYTE) == asByte() + } + + override fun equals(other: Any?): Boolean { + if (this === other) return true + if (javaClass != other?.javaClass) return false + + other as BytePdcData + return value == other.value } -} \ No newline at end of file + + override fun hashCode(): Int = value +} diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/DoublePdcData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/DoublePdcData.kt index ed74f37a7d..2296ad3e00 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/DoublePdcData.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/DoublePdcData.kt @@ -9,14 +9,23 @@ import org.bukkit.inventory.ItemStack import org.bukkit.persistence.PersistentDataType @AlgebraicTypeInfo("double", Colors.PURPLE, "fa6-solid:database") -data class DoublePdcData(val value: Double) : PdcDataType { +data class DoublePdcData( + + val value: Double = 0.0 + +) : PdcDataType { override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack, key: NamespacedKey) { item.editMeta { meta -> meta.persistentDataContainer.set(key, PersistentDataType.DOUBLE, value) } } - override fun matches(player: Player?, interactionContext: InteractionContext?, item: ItemStack, key: NamespacedKey): Boolean { + override fun matches( + player: Player?, + interactionContext: InteractionContext?, + item: ItemStack, + key: NamespacedKey + ): Boolean { val container = item.itemMeta?.persistentDataContainer ?: return false return container.get(key, PersistentDataType.DOUBLE) == value } diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/FloatPdcData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/FloatPdcData.kt index e15fb33037..f7dfa0e61c 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/FloatPdcData.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/FloatPdcData.kt @@ -9,14 +9,23 @@ import org.bukkit.inventory.ItemStack import org.bukkit.persistence.PersistentDataType @AlgebraicTypeInfo("float", Colors.PURPLE, "fa6-solid:database") -data class FloatPdcData(val value: Float) : PdcDataType { +data class FloatPdcData( + + val value: Float = 0f + +) : PdcDataType { override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack, key: NamespacedKey) { item.editMeta { meta -> meta.persistentDataContainer.set(key, PersistentDataType.FLOAT, value) } } - override fun matches(player: Player?, interactionContext: InteractionContext?, item: ItemStack, key: NamespacedKey): Boolean { + override fun matches( + player: Player?, + interactionContext: InteractionContext?, + item: ItemStack, + key: NamespacedKey + ): Boolean { val container = item.itemMeta?.persistentDataContainer ?: return false return container.get(key, PersistentDataType.FLOAT) == value } diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/IntArrayPdcData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/IntArrayPdcData.kt index 4809b4925e..ea2d7113a8 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/IntArrayPdcData.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/IntArrayPdcData.kt @@ -9,17 +9,29 @@ import org.bukkit.inventory.ItemStack import org.bukkit.persistence.PersistentDataType @AlgebraicTypeInfo("int_array", Colors.PURPLE, "fa6-solid:database") -data class IntArrayPdcData(val value: IntArray) : PdcDataType { +data class IntArrayPdcData( + + val value: List = emptyList() + +) : PdcDataType { + + private fun toIntArray(): IntArray = value.toIntArray() + override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack, key: NamespacedKey) { item.editMeta { meta -> - meta.persistentDataContainer.set(key, PersistentDataType.INTEGER_ARRAY, value) + meta.persistentDataContainer.set(key, PersistentDataType.INTEGER_ARRAY, toIntArray()) } } - override fun matches(player: Player?, interactionContext: InteractionContext?, item: ItemStack, key: NamespacedKey): Boolean { + override fun matches( + player: Player?, + interactionContext: InteractionContext?, + item: ItemStack, + key: NamespacedKey + ): Boolean { val container = item.itemMeta?.persistentDataContainer ?: return false val actual = container.get(key, PersistentDataType.INTEGER_ARRAY) ?: return false - return actual.contentEquals(value) + return actual.contentEquals(toIntArray()) } override fun equals(other: Any?): Boolean { @@ -27,11 +39,8 @@ data class IntArrayPdcData(val value: IntArray) : PdcDataType { if (javaClass != other?.javaClass) return false other as IntArrayPdcData - - return value.contentEquals(other.value) + return value == other.value } - override fun hashCode(): Int { - return value.contentHashCode() - } -} \ No newline at end of file + override fun hashCode(): Int = value.hashCode() +} diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/IntPdcData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/IntPdcData.kt index 468e0d08c9..ed9ec816de 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/IntPdcData.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/IntPdcData.kt @@ -9,14 +9,23 @@ import org.bukkit.inventory.ItemStack import org.bukkit.persistence.PersistentDataType @AlgebraicTypeInfo("int", Colors.PURPLE, "fa6-solid:database") -data class IntPdcData(val value: Int) : PdcDataType { +data class IntPdcData( + + val value: Int = 0 + +) : PdcDataType { override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack, key: NamespacedKey) { item.editMeta { meta -> meta.persistentDataContainer.set(key, PersistentDataType.INTEGER, value) } } - override fun matches(player: Player?, interactionContext: InteractionContext?, item: ItemStack, key: NamespacedKey): Boolean { + override fun matches( + player: Player?, + interactionContext: InteractionContext?, + item: ItemStack, + key: NamespacedKey + ): Boolean { val container = item.itemMeta?.persistentDataContainer ?: return false return container.get(key, PersistentDataType.INTEGER) == value } diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/LongArrayPdcData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/LongArrayPdcData.kt index e7126447b9..e1feb2f856 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/LongArrayPdcData.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/LongArrayPdcData.kt @@ -1,7 +1,7 @@ package com.typewritermc.engine.paper.utils.item.components.pdcTypes import com.typewritermc.core.books.pages.Colors -import com.typewritermc.core.extension.annotations.AlgebraicTypeInfo +import com.typewritermc.core.extension.annotations.* import com.typewritermc.core.interaction.InteractionContext import org.bukkit.NamespacedKey import org.bukkit.entity.Player @@ -9,17 +9,32 @@ import org.bukkit.inventory.ItemStack import org.bukkit.persistence.PersistentDataType @AlgebraicTypeInfo("long_array", Colors.PURPLE, "fa6-solid:database") -data class LongArrayPdcData(val value: LongArray) : PdcDataType { +data class LongArrayPdcData( + + @InnerMin(Min(Long.MIN_VALUE.toInt())) + @InnerMax(Max(Long.MAX_VALUE.toInt())) + val value: List = emptyList() + +) : PdcDataType { + + private fun toLongArray(): LongArray = + value.map { it.toLong() }.toLongArray() + override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack, key: NamespacedKey) { item.editMeta { meta -> - meta.persistentDataContainer.set(key, PersistentDataType.LONG_ARRAY, value) + meta.persistentDataContainer.set(key, PersistentDataType.LONG_ARRAY, toLongArray()) } } - override fun matches(player: Player?, interactionContext: InteractionContext?, item: ItemStack, key: NamespacedKey): Boolean { + override fun matches( + player: Player?, + interactionContext: InteractionContext?, + item: ItemStack, + key: NamespacedKey + ): Boolean { val container = item.itemMeta?.persistentDataContainer ?: return false val actual = container.get(key, PersistentDataType.LONG_ARRAY) ?: return false - return actual.contentEquals(value) + return actual.contentEquals(toLongArray()) } override fun equals(other: Any?): Boolean { @@ -27,11 +42,8 @@ data class LongArrayPdcData(val value: LongArray) : PdcDataType { if (javaClass != other?.javaClass) return false other as LongArrayPdcData - - return value.contentEquals(other.value) + return value == other.value } - override fun hashCode(): Int { - return value.contentHashCode() - } -} \ No newline at end of file + override fun hashCode(): Int = value.hashCode() +} diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/LongPdcData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/LongPdcData.kt index 9e1bfc1fc6..b6f4490663 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/LongPdcData.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/LongPdcData.kt @@ -2,6 +2,8 @@ package com.typewritermc.engine.paper.utils.item.components.pdcTypes import com.typewritermc.core.books.pages.Colors import com.typewritermc.core.extension.annotations.AlgebraicTypeInfo +import com.typewritermc.core.extension.annotations.Max +import com.typewritermc.core.extension.annotations.Min import com.typewritermc.core.interaction.InteractionContext import org.bukkit.NamespacedKey import org.bukkit.entity.Player @@ -9,15 +11,39 @@ import org.bukkit.inventory.ItemStack import org.bukkit.persistence.PersistentDataType @AlgebraicTypeInfo("long", Colors.PURPLE, "fa6-solid:database") -data class LongPdcData(val value: Long) : PdcDataType { +data class LongPdcData( + + @Min(Int.MIN_VALUE) + @Max(Int.MAX_VALUE) + val value: Int = 0 + +) : PdcDataType { + + private fun asLong(): Long = value.toLong() + override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack, key: NamespacedKey) { item.editMeta { meta -> - meta.persistentDataContainer.set(key, PersistentDataType.LONG, value) + meta.persistentDataContainer.set(key, PersistentDataType.LONG, asLong()) } } - override fun matches(player: Player?, interactionContext: InteractionContext?, item: ItemStack, key: NamespacedKey): Boolean { + override fun matches( + player: Player?, + interactionContext: InteractionContext?, + item: ItemStack, + key: NamespacedKey + ): Boolean { val container = item.itemMeta?.persistentDataContainer ?: return false - return container.get(key, PersistentDataType.LONG) == value + return container.get(key, PersistentDataType.LONG) == asLong() } -} \ No newline at end of file + + override fun equals(other: Any?): Boolean { + if (this === other) return true + if (javaClass != other?.javaClass) return false + + other as LongPdcData + return value == other.value + } + + override fun hashCode(): Int = value +} diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/ShortPdcData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/ShortPdcData.kt index ec2ca944d9..165a5af07e 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/ShortPdcData.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/ShortPdcData.kt @@ -2,6 +2,8 @@ package com.typewritermc.engine.paper.utils.item.components.pdcTypes import com.typewritermc.core.books.pages.Colors import com.typewritermc.core.extension.annotations.AlgebraicTypeInfo +import com.typewritermc.core.extension.annotations.Max +import com.typewritermc.core.extension.annotations.Min import com.typewritermc.core.interaction.InteractionContext import org.bukkit.NamespacedKey import org.bukkit.entity.Player @@ -9,15 +11,39 @@ import org.bukkit.inventory.ItemStack import org.bukkit.persistence.PersistentDataType @AlgebraicTypeInfo("short", Colors.PURPLE, "fa6-solid:database") -data class ShortPdcData(val value: Short) : PdcDataType { +data class ShortPdcData( + + @Min(Short.MIN_VALUE.toInt()) + @Max(Short.MAX_VALUE.toInt()) + val value: Int = 0 + +) : PdcDataType { + + private fun asShort(): Short = value.toShort() + override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack, key: NamespacedKey) { item.editMeta { meta -> - meta.persistentDataContainer.set(key, PersistentDataType.SHORT, value) + meta.persistentDataContainer.set(key, PersistentDataType.SHORT, asShort()) } } - override fun matches(player: Player?, interactionContext: InteractionContext?, item: ItemStack, key: NamespacedKey): Boolean { + override fun matches( + player: Player?, + interactionContext: InteractionContext?, + item: ItemStack, + key: NamespacedKey + ): Boolean { val container = item.itemMeta?.persistentDataContainer ?: return false - return container.get(key, PersistentDataType.SHORT) == value + return container.get(key, PersistentDataType.SHORT) == asShort() } -} \ No newline at end of file + + override fun equals(other: Any?): Boolean { + if (this === other) return true + if (javaClass != other?.javaClass) return false + + other as ShortPdcData + return value == other.value + } + + override fun hashCode(): Int = value +} diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/StringPdcData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/StringPdcData.kt index 4c5f65a8e0..396fc265b9 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/StringPdcData.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/StringPdcData.kt @@ -9,7 +9,11 @@ import org.bukkit.inventory.ItemStack import org.bukkit.persistence.PersistentDataType @AlgebraicTypeInfo("persistent_data_string", Colors.PURPLE, "fa6-solid:database") -data class StringPdcData(val value: String) : PdcDataType { +data class StringPdcData( + + val value: String = "" + +) : PdcDataType { override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack, key: NamespacedKey) { item.editMeta { meta -> if (value.isBlank()) { @@ -20,7 +24,12 @@ data class StringPdcData(val value: String) : PdcDataType { } } - override fun matches(player: Player?, interactionContext: InteractionContext?, item: ItemStack, key: NamespacedKey): Boolean { + override fun matches( + player: Player?, + interactionContext: InteractionContext?, + item: ItemStack, + key: NamespacedKey + ): Boolean { val actual = item.itemMeta?.persistentDataContainer?.get(key, PersistentDataType.STRING) return if (value.isBlank()) { actual.isNullOrBlank() From 5c88045389e3aacc8b7b83cedf7e8ae06fe9bd0c Mon Sep 17 00:00:00 2001 From: Chaosgh Date: Fri, 5 Sep 2025 13:31:48 +0200 Subject: [PATCH 10/13] - different unsupported message to make it clearer - now just uses pure shorts and longs --- .../BooleansCustomModelData.kt | 8 +++---- .../ColorsCustomModelData.kt | 8 +++---- .../FloatsCustomModelData.kt | 8 +++---- .../StringsCustomModelData.kt | 8 +++---- .../components/pdcTypes/ByteArrayPdcData.kt | 4 +++- .../item/components/pdcTypes/BytePdcData.kt | 3 ++- .../components/pdcTypes/LongArrayPdcData.kt | 13 +++++++---- .../item/components/pdcTypes/LongPdcData.kt | 23 ++++++++++--------- .../item/components/pdcTypes/ShortPdcData.kt | 23 ++++++++++--------- 9 files changed, 53 insertions(+), 45 deletions(-) diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/BooleansCustomModelData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/BooleansCustomModelData.kt index 8e346265d8..42aa5b07e9 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/BooleansCustomModelData.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/BooleansCustomModelData.kt @@ -15,8 +15,8 @@ data class BooleansCustomModelData( ) : CustomModelDataType { override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack) { - if (!serverVersion.isNewerThan(ServerVersion.V_1_21_3)) { - logger.warning("${this::class.simpleName} is only supported in versions higher than 1.21.3") + if (!serverVersion.isNewerThanOrEquals(ServerVersion.V_1_21_4)) { + logger.warning("${this::class.simpleName} is only supported in versions 1.21.4 and above") return } item.editMeta { meta -> @@ -28,8 +28,8 @@ data class BooleansCustomModelData( } override fun matches(player: Player?, interactionContext: InteractionContext?, item: ItemStack): Boolean { - if (!serverVersion.isNewerThan(ServerVersion.V_1_21_3)) { - logger.warning("${this::class.simpleName} is only supported in versions higher than 1.21.3") + if (!serverVersion.isNewerThanOrEquals(ServerVersion.V_1_21_4)) { + logger.warning("${this::class.simpleName} is only supported in versions 1.21.4 and above") return false } val meta = item.itemMeta ?: return false diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/ColorsCustomModelData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/ColorsCustomModelData.kt index 1124608722..d066b778a9 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/ColorsCustomModelData.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/ColorsCustomModelData.kt @@ -17,8 +17,8 @@ data class ColorsCustomModelData( ) : CustomModelDataType { override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack) { - if (!serverVersion.isNewerThan(ServerVersion.V_1_21_3)) { - logger.warning("${this::class.simpleName} is only supported in versions higher than 1.21.3") + if (!serverVersion.isNewerThanOrEquals(ServerVersion.V_1_21_4)) { + logger.warning("${this::class.simpleName} is only supported in versions 1.21.4 and above") return } item.editMeta { meta -> @@ -32,8 +32,8 @@ data class ColorsCustomModelData( } override fun matches(player: Player?, interactionContext: InteractionContext?, item: ItemStack): Boolean { - if (!serverVersion.isNewerThan(ServerVersion.V_1_21_3)) { - logger.warning("${this::class.simpleName} is only supported in versions higher than 1.21.3") + if (!serverVersion.isNewerThanOrEquals(ServerVersion.V_1_21_4)) { + logger.warning("${this::class.simpleName} is only supported in versions 1.21.4 and above") return false } val meta = item.itemMeta ?: return false diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/FloatsCustomModelData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/FloatsCustomModelData.kt index a66e2c01c8..27e540cb61 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/FloatsCustomModelData.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/FloatsCustomModelData.kt @@ -16,8 +16,8 @@ data class FloatsCustomModelData( ) : CustomModelDataType { override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack) { - if (!serverVersion.isNewerThan(ServerVersion.V_1_21_3)) { - logger.warning("${this::class.simpleName} is only supported in versions higher than 1.21.3") + if (!serverVersion.isNewerThanOrEquals(ServerVersion.V_1_21_4)) { + logger.warning("${this::class.simpleName} is only supported in versions 1.21.4 and above") return } item.editMeta { meta -> @@ -29,8 +29,8 @@ data class FloatsCustomModelData( } override fun matches(player: Player?, interactionContext: InteractionContext?, item: ItemStack): Boolean { - if (!serverVersion.isNewerThan(ServerVersion.V_1_21_3)) { - logger.warning("${this::class.simpleName} is only supported in versions higher than 1.21.3") + if (!serverVersion.isNewerThanOrEquals(ServerVersion.V_1_21_4)) { + logger.warning("${this::class.simpleName} is only supported in versions 1.21.4 and above") return false } val meta = item.itemMeta ?: return false diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/StringsCustomModelData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/StringsCustomModelData.kt index 6be510b1e0..b86f7f6823 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/StringsCustomModelData.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/StringsCustomModelData.kt @@ -16,8 +16,8 @@ data class StringsCustomModelData( ) : CustomModelDataType { override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack) { - if (!serverVersion.isNewerThan(ServerVersion.V_1_21_3)) { - logger.warning("${this::class.simpleName} is only supported in versions higher than 1.21.3") + if (!serverVersion.isNewerThanOrEquals(ServerVersion.V_1_21_4)) { + logger.warning("${this::class.simpleName} is only supported in versions 1.21.4 and above") return } item.editMeta { meta -> @@ -29,8 +29,8 @@ data class StringsCustomModelData( } override fun matches(player: Player?, interactionContext: InteractionContext?, item: ItemStack): Boolean { - if (!serverVersion.isNewerThan(ServerVersion.V_1_21_3)) { - logger.warning("${this::class.simpleName} is only supported in versions higher than 1.21.3") + if (!serverVersion.isNewerThanOrEquals(ServerVersion.V_1_21_4)) { + logger.warning("${this::class.simpleName} is only supported in versions 1.21.4 and above") return false } val meta = item.itemMeta ?: return false diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/ByteArrayPdcData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/ByteArrayPdcData.kt index 178e2f56ce..02b87084e2 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/ByteArrayPdcData.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/ByteArrayPdcData.kt @@ -3,7 +3,9 @@ package com.typewritermc.engine.paper.utils.item.components.pdcTypes import com.typewritermc.core.books.pages.Colors import com.typewritermc.core.extension.annotations.AlgebraicTypeInfo import com.typewritermc.core.extension.annotations.InnerMax +import com.typewritermc.core.extension.annotations.InnerMin import com.typewritermc.core.extension.annotations.Max +import com.typewritermc.core.extension.annotations.Min import com.typewritermc.core.interaction.InteractionContext import org.bukkit.NamespacedKey import org.bukkit.entity.Player @@ -13,7 +15,7 @@ import org.bukkit.persistence.PersistentDataType @AlgebraicTypeInfo("byte_array", Colors.PURPLE, "fa6-solid:database") data class ByteArrayPdcData( - @InnerMax(Max(255)) + @InnerMin(Min(0))@InnerMax(Max(255)) val value: List = emptyList() ) : PdcDataType { diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/BytePdcData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/BytePdcData.kt index aa07814251..ce31167a32 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/BytePdcData.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/BytePdcData.kt @@ -3,6 +3,7 @@ package com.typewritermc.engine.paper.utils.item.components.pdcTypes import com.typewritermc.core.books.pages.Colors import com.typewritermc.core.extension.annotations.AlgebraicTypeInfo import com.typewritermc.core.extension.annotations.Max +import com.typewritermc.core.extension.annotations.Min import com.typewritermc.core.interaction.InteractionContext import org.bukkit.NamespacedKey import org.bukkit.entity.Player @@ -11,7 +12,7 @@ import org.bukkit.persistence.PersistentDataType @AlgebraicTypeInfo("byte", Colors.PURPLE, "fa6-solid:database") data class BytePdcData( - @Max(255) + @Min(0) @Max(255) val value: Int = 0 ) : PdcDataType { diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/LongArrayPdcData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/LongArrayPdcData.kt index e1feb2f856..040e02c352 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/LongArrayPdcData.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/LongArrayPdcData.kt @@ -11,16 +11,19 @@ import org.bukkit.persistence.PersistentDataType @AlgebraicTypeInfo("long_array", Colors.PURPLE, "fa6-solid:database") data class LongArrayPdcData( - @InnerMin(Min(Long.MIN_VALUE.toInt())) - @InnerMax(Max(Long.MAX_VALUE.toInt())) - val value: List = emptyList() + val value: List = emptyList() ) : PdcDataType { private fun toLongArray(): LongArray = - value.map { it.toLong() }.toLongArray() + value.toLongArray() - override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack, key: NamespacedKey) { + override fun apply( + player: Player?, + interactionContext: InteractionContext?, + item: ItemStack, + key: NamespacedKey + ) { item.editMeta { meta -> meta.persistentDataContainer.set(key, PersistentDataType.LONG_ARRAY, toLongArray()) } diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/LongPdcData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/LongPdcData.kt index b6f4490663..95e4233b7c 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/LongPdcData.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/LongPdcData.kt @@ -2,8 +2,7 @@ package com.typewritermc.engine.paper.utils.item.components.pdcTypes import com.typewritermc.core.books.pages.Colors import com.typewritermc.core.extension.annotations.AlgebraicTypeInfo -import com.typewritermc.core.extension.annotations.Max -import com.typewritermc.core.extension.annotations.Min + import com.typewritermc.core.interaction.InteractionContext import org.bukkit.NamespacedKey import org.bukkit.entity.Player @@ -13,17 +12,19 @@ import org.bukkit.persistence.PersistentDataType @AlgebraicTypeInfo("long", Colors.PURPLE, "fa6-solid:database") data class LongPdcData( - @Min(Int.MIN_VALUE) - @Max(Int.MAX_VALUE) - val value: Int = 0 -) : PdcDataType { + val value: Long = 0L - private fun asLong(): Long = value.toLong() +) : PdcDataType { - override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack, key: NamespacedKey) { + override fun apply( + player: Player?, + interactionContext: InteractionContext?, + item: ItemStack, + key: NamespacedKey + ) { item.editMeta { meta -> - meta.persistentDataContainer.set(key, PersistentDataType.LONG, asLong()) + meta.persistentDataContainer.set(key, PersistentDataType.LONG, value) } } @@ -34,7 +35,7 @@ data class LongPdcData( key: NamespacedKey ): Boolean { val container = item.itemMeta?.persistentDataContainer ?: return false - return container.get(key, PersistentDataType.LONG) == asLong() + return container.get(key, PersistentDataType.LONG) == value } override fun equals(other: Any?): Boolean { @@ -45,5 +46,5 @@ data class LongPdcData( return value == other.value } - override fun hashCode(): Int = value + override fun hashCode(): Int = value.hashCode() } diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/ShortPdcData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/ShortPdcData.kt index 165a5af07e..a35de19d1f 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/ShortPdcData.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/ShortPdcData.kt @@ -2,8 +2,7 @@ package com.typewritermc.engine.paper.utils.item.components.pdcTypes import com.typewritermc.core.books.pages.Colors import com.typewritermc.core.extension.annotations.AlgebraicTypeInfo -import com.typewritermc.core.extension.annotations.Max -import com.typewritermc.core.extension.annotations.Min + import com.typewritermc.core.interaction.InteractionContext import org.bukkit.NamespacedKey import org.bukkit.entity.Player @@ -13,17 +12,19 @@ import org.bukkit.persistence.PersistentDataType @AlgebraicTypeInfo("short", Colors.PURPLE, "fa6-solid:database") data class ShortPdcData( - @Min(Short.MIN_VALUE.toInt()) - @Max(Short.MAX_VALUE.toInt()) - val value: Int = 0 -) : PdcDataType { + val value: Short = 0 - private fun asShort(): Short = value.toShort() +) : PdcDataType { - override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack, key: NamespacedKey) { + override fun apply( + player: Player?, + interactionContext: InteractionContext?, + item: ItemStack, + key: NamespacedKey + ) { item.editMeta { meta -> - meta.persistentDataContainer.set(key, PersistentDataType.SHORT, asShort()) + meta.persistentDataContainer.set(key, PersistentDataType.SHORT, value) } } @@ -34,7 +35,7 @@ data class ShortPdcData( key: NamespacedKey ): Boolean { val container = item.itemMeta?.persistentDataContainer ?: return false - return container.get(key, PersistentDataType.SHORT) == asShort() + return container.get(key, PersistentDataType.SHORT) == value } override fun equals(other: Any?): Boolean { @@ -45,5 +46,5 @@ data class ShortPdcData( return value == other.value } - override fun hashCode(): Int = value + override fun hashCode(): Int = value.hashCode() } From 9518b063d0373d4b1d6727a982bdf924849e097c Mon Sep 17 00:00:00 2001 From: Chaosgh Date: Fri, 5 Sep 2025 13:58:52 +0200 Subject: [PATCH 11/13] small cleanups --- .../ColorsCustomModelData.kt | 2 -- .../FloatsCustomModelData.kt | 2 -- .../LegacyCustomModelData.kt | 2 -- .../StringsCustomModelData.kt | 2 -- .../components/pdcTypes/BooleanPdcData.kt | 2 -- .../components/pdcTypes/ByteArrayPdcData.kt | 11 ------- .../item/components/pdcTypes/BytePdcData.kt | 9 ------ .../item/components/pdcTypes/DoublePdcData.kt | 2 -- .../item/components/pdcTypes/FloatPdcData.kt | 2 -- .../components/pdcTypes/IntArrayPdcData.kt | 11 ------- .../item/components/pdcTypes/IntPdcData.kt | 2 -- .../components/pdcTypes/LongArrayPdcData.kt | 32 +++++++++---------- .../item/components/pdcTypes/LongPdcData.kt | 20 +++--------- .../item/components/pdcTypes/ShortPdcData.kt | 11 +------ .../item/components/pdcTypes/StringPdcData.kt | 2 -- 15 files changed, 21 insertions(+), 91 deletions(-) diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/ColorsCustomModelData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/ColorsCustomModelData.kt index d066b778a9..0544dc8791 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/ColorsCustomModelData.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/ColorsCustomModelData.kt @@ -12,9 +12,7 @@ import org.bukkit.inventory.ItemStack @AlgebraicTypeInfo("color_array", Colors.GREEN, "fa6-solid:shapes") data class ColorsCustomModelData( - val value: List = emptyList() - ) : CustomModelDataType { override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack) { if (!serverVersion.isNewerThanOrEquals(ServerVersion.V_1_21_4)) { diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/FloatsCustomModelData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/FloatsCustomModelData.kt index 27e540cb61..8bcf25161f 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/FloatsCustomModelData.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/FloatsCustomModelData.kt @@ -11,9 +11,7 @@ import org.bukkit.inventory.ItemStack @AlgebraicTypeInfo("float_array", Colors.GREEN, "fa6-solid:shapes") data class FloatsCustomModelData( - val value: List = emptyList() - ) : CustomModelDataType { override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack) { if (!serverVersion.isNewerThanOrEquals(ServerVersion.V_1_21_4)) { diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/LegacyCustomModelData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/LegacyCustomModelData.kt index 43cba47e08..da19628fb8 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/LegacyCustomModelData.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/LegacyCustomModelData.kt @@ -8,9 +8,7 @@ import org.bukkit.inventory.ItemStack @AlgebraicTypeInfo("legacy_int", Colors.GREEN, "fa6-solid:shapes") data class LegacyCustomModelData( - val value: Int = 0 - ) : CustomModelDataType { override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack) { item.editMeta { meta -> meta.setCustomModelData(value) } diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/StringsCustomModelData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/StringsCustomModelData.kt index b86f7f6823..4945201e76 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/StringsCustomModelData.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/customModelDataTypes/StringsCustomModelData.kt @@ -11,9 +11,7 @@ import org.bukkit.inventory.ItemStack @AlgebraicTypeInfo("string_array", Colors.GREEN, "fa6-solid:shapes") data class StringsCustomModelData( - val value: List = emptyList() - ) : CustomModelDataType { override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack) { if (!serverVersion.isNewerThanOrEquals(ServerVersion.V_1_21_4)) { diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/BooleanPdcData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/BooleanPdcData.kt index 24f6158b7a..af7005c6de 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/BooleanPdcData.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/BooleanPdcData.kt @@ -10,9 +10,7 @@ import org.bukkit.persistence.PersistentDataType @AlgebraicTypeInfo("boolean", Colors.PURPLE, "fa6-solid:database") data class BooleanPdcData( - val value: Boolean = false - ) : PdcDataType { override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack, key: NamespacedKey) { item.editMeta { meta -> diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/ByteArrayPdcData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/ByteArrayPdcData.kt index 02b87084e2..69ecc77722 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/ByteArrayPdcData.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/ByteArrayPdcData.kt @@ -14,10 +14,8 @@ import org.bukkit.persistence.PersistentDataType @AlgebraicTypeInfo("byte_array", Colors.PURPLE, "fa6-solid:database") data class ByteArrayPdcData( - @InnerMin(Min(0))@InnerMax(Max(255)) val value: List = emptyList() - ) : PdcDataType { private fun toByteArray(): ByteArray = @@ -40,13 +38,4 @@ data class ByteArrayPdcData( return actual.contentEquals(toByteArray()) } - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (javaClass != other?.javaClass) return false - - other as ByteArrayPdcData - return value == other.value - } - - override fun hashCode(): Int = value.hashCode() } diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/BytePdcData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/BytePdcData.kt index ce31167a32..208db6a3d0 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/BytePdcData.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/BytePdcData.kt @@ -34,13 +34,4 @@ data class BytePdcData( return container.get(key, PersistentDataType.BYTE) == asByte() } - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (javaClass != other?.javaClass) return false - - other as BytePdcData - return value == other.value - } - - override fun hashCode(): Int = value } diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/DoublePdcData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/DoublePdcData.kt index 2296ad3e00..cb1c2c7a4f 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/DoublePdcData.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/DoublePdcData.kt @@ -10,9 +10,7 @@ import org.bukkit.persistence.PersistentDataType @AlgebraicTypeInfo("double", Colors.PURPLE, "fa6-solid:database") data class DoublePdcData( - val value: Double = 0.0 - ) : PdcDataType { override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack, key: NamespacedKey) { item.editMeta { meta -> diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/FloatPdcData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/FloatPdcData.kt index f7dfa0e61c..94ba378e33 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/FloatPdcData.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/FloatPdcData.kt @@ -10,9 +10,7 @@ import org.bukkit.persistence.PersistentDataType @AlgebraicTypeInfo("float", Colors.PURPLE, "fa6-solid:database") data class FloatPdcData( - val value: Float = 0f - ) : PdcDataType { override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack, key: NamespacedKey) { item.editMeta { meta -> diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/IntArrayPdcData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/IntArrayPdcData.kt index ea2d7113a8..98fa9cf228 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/IntArrayPdcData.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/IntArrayPdcData.kt @@ -10,9 +10,7 @@ import org.bukkit.persistence.PersistentDataType @AlgebraicTypeInfo("int_array", Colors.PURPLE, "fa6-solid:database") data class IntArrayPdcData( - val value: List = emptyList() - ) : PdcDataType { private fun toIntArray(): IntArray = value.toIntArray() @@ -34,13 +32,4 @@ data class IntArrayPdcData( return actual.contentEquals(toIntArray()) } - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (javaClass != other?.javaClass) return false - - other as IntArrayPdcData - return value == other.value - } - - override fun hashCode(): Int = value.hashCode() } diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/IntPdcData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/IntPdcData.kt index ed9ec816de..c207a51a19 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/IntPdcData.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/IntPdcData.kt @@ -10,9 +10,7 @@ import org.bukkit.persistence.PersistentDataType @AlgebraicTypeInfo("int", Colors.PURPLE, "fa6-solid:database") data class IntPdcData( - val value: Int = 0 - ) : PdcDataType { override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack, key: NamespacedKey) { item.editMeta { meta -> diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/LongArrayPdcData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/LongArrayPdcData.kt index 040e02c352..186bb881b1 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/LongArrayPdcData.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/LongArrayPdcData.kt @@ -1,7 +1,7 @@ package com.typewritermc.engine.paper.utils.item.components.pdcTypes import com.typewritermc.core.books.pages.Colors -import com.typewritermc.core.extension.annotations.* +import com.typewritermc.core.extension.annotations.AlgebraicTypeInfo import com.typewritermc.core.interaction.InteractionContext import org.bukkit.NamespacedKey import org.bukkit.entity.Player @@ -10,9 +10,7 @@ import org.bukkit.persistence.PersistentDataType @AlgebraicTypeInfo("long_array", Colors.PURPLE, "fa6-solid:database") data class LongArrayPdcData( - val value: List = emptyList() - ) : PdcDataType { private fun toLongArray(): LongArray = @@ -25,7 +23,12 @@ data class LongArrayPdcData( key: NamespacedKey ) { item.editMeta { meta -> - meta.persistentDataContainer.set(key, PersistentDataType.LONG_ARRAY, toLongArray()) + val container = meta.persistentDataContainer + if (value.isEmpty()) { + container.remove(key) + } else { + container.set(key, PersistentDataType.LONG_ARRAY, toLongArray()) + } } } @@ -35,18 +38,13 @@ data class LongArrayPdcData( item: ItemStack, key: NamespacedKey ): Boolean { - val container = item.itemMeta?.persistentDataContainer ?: return false - val actual = container.get(key, PersistentDataType.LONG_ARRAY) ?: return false - return actual.contentEquals(toLongArray()) - } - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (javaClass != other?.javaClass) return false - - other as LongArrayPdcData - return value == other.value + val expected = toLongArray() + val container = item.itemMeta?.persistentDataContainer + ?: return expected.isEmpty() + val actual = container.get(key, PersistentDataType.LONG_ARRAY) + return when { + actual == null -> expected.isEmpty() + else -> actual.contentEquals(expected) + } } - - override fun hashCode(): Int = value.hashCode() } diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/LongPdcData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/LongPdcData.kt index 95e4233b7c..72ef012df6 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/LongPdcData.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/LongPdcData.kt @@ -2,7 +2,6 @@ package com.typewritermc.engine.paper.utils.item.components.pdcTypes import com.typewritermc.core.books.pages.Colors import com.typewritermc.core.extension.annotations.AlgebraicTypeInfo - import com.typewritermc.core.interaction.InteractionContext import org.bukkit.NamespacedKey import org.bukkit.entity.Player @@ -11,12 +10,10 @@ import org.bukkit.persistence.PersistentDataType @AlgebraicTypeInfo("long", Colors.PURPLE, "fa6-solid:database") data class LongPdcData( - - val value: Long = 0L - ) : PdcDataType { + override fun apply( player: Player?, interactionContext: InteractionContext?, @@ -24,7 +21,10 @@ data class LongPdcData( key: NamespacedKey ) { item.editMeta { meta -> - meta.persistentDataContainer.set(key, PersistentDataType.LONG, value) + val pdc = meta.persistentDataContainer + if (pdc.get(key, PersistentDataType.LONG) != value) { + pdc.set(key, PersistentDataType.LONG, value) + } } } @@ -37,14 +37,4 @@ data class LongPdcData( val container = item.itemMeta?.persistentDataContainer ?: return false return container.get(key, PersistentDataType.LONG) == value } - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (javaClass != other?.javaClass) return false - - other as LongPdcData - return value == other.value - } - - override fun hashCode(): Int = value.hashCode() } diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/ShortPdcData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/ShortPdcData.kt index a35de19d1f..2215ce567a 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/ShortPdcData.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/ShortPdcData.kt @@ -11,10 +11,7 @@ import org.bukkit.persistence.PersistentDataType @AlgebraicTypeInfo("short", Colors.PURPLE, "fa6-solid:database") data class ShortPdcData( - - val value: Short = 0 - ) : PdcDataType { override fun apply( @@ -38,13 +35,7 @@ data class ShortPdcData( return container.get(key, PersistentDataType.SHORT) == value } - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (javaClass != other?.javaClass) return false - other as ShortPdcData - return value == other.value - } - override fun hashCode(): Int = value.hashCode() + } diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/StringPdcData.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/StringPdcData.kt index 396fc265b9..c64fcddedf 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/StringPdcData.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/pdcTypes/StringPdcData.kt @@ -10,9 +10,7 @@ import org.bukkit.persistence.PersistentDataType @AlgebraicTypeInfo("persistent_data_string", Colors.PURPLE, "fa6-solid:database") data class StringPdcData( - val value: String = "" - ) : PdcDataType { override fun apply(player: Player?, interactionContext: InteractionContext?, item: ItemStack, key: NamespacedKey) { item.editMeta { meta -> From 6e2eef966998ce2b011ddd17f6315d88db4c5a48 Mon Sep 17 00:00:00 2001 From: julie Date: Fri, 19 Sep 2025 21:00:05 +0200 Subject: [PATCH 12/13] small cleanups like gabber told me --- .../engine/paper/utils/item/components/ItemPDCComponent.kt | 1 - .../paper/utils/item/components/ItemTooltipStyleComponent.kt | 1 - 2 files changed, 2 deletions(-) diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemPDCComponent.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemPDCComponent.kt index ee2f489fcc..02dc660b37 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemPDCComponent.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemPDCComponent.kt @@ -14,7 +14,6 @@ import org.bukkit.inventory.ItemStack @AlgebraicTypeInfo("persistent_data_container", Colors.PURPLE, "fa6-solid:database") class ItemPDCComponent( - val dataKey: Var = ConstVar("typewriter:custom_data"), val data: Var = ConstVar(StringPdcData("")), ) : ItemComponent { diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemTooltipStyleComponent.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemTooltipStyleComponent.kt index f29318d028..44b4a8f98d 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemTooltipStyleComponent.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemTooltipStyleComponent.kt @@ -12,7 +12,6 @@ import org.bukkit.inventory.ItemStack @AlgebraicTypeInfo("tooltip_style", Colors.CYAN, "fa6-solid:palette") class ItemTooltipStyleComponent( - val styleKey: Var = ConstVar("minecraft:diamond"), ) : ItemComponent { From 0f61b85073043e7b92210b4fa0acf40b50e03875 Mon Sep 17 00:00:00 2001 From: julie Date: Fri, 19 Sep 2025 21:00:15 +0200 Subject: [PATCH 13/13] small cleanups like gabber told me --- .../engine/paper/utils/item/components/ItemNameComponent.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemNameComponent.kt b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemNameComponent.kt index 4d6ba8b33a..e6729ac6f5 100644 --- a/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemNameComponent.kt +++ b/engine/engine-paper/src/main/kotlin/com/typewritermc/engine/paper/utils/item/components/ItemNameComponent.kt @@ -34,7 +34,7 @@ class ItemNameComponent( val name = name.get(player) ?: return false - return if (serverVersion.isNewerThan(ServerVersion.V_1_21_3)) { + return if (serverVersion.isNewerThanOrEquals(ServerVersion.V_1_21_4)) { item.effectiveName().plainText() == name.parsePlaceholders(player).stripped() } else { item.displayName().plainText() == name.parsePlaceholders(player).stripped()