More improvements and fixes

2026-01-03 22:26:33 +00:00 · 2022-05-22 19:55:19 +01:00
parent c008a17a27
commit 3743d06cb3
7 changed files with 148 additions and 127 deletions
--- a/eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/display/ReforgesDisplay.kt
+++ b/eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/display/ReforgesDisplay.kt
@@ -6,30 +6,33 @@ import com.willfp.eco.core.display.DisplayPriority
 import com.willfp.eco.core.fast.FastItemStack
 import com.willfp.eco.core.fast.fast
 import com.willfp.eco.util.SkullUtils
+import com.willfp.eco.util.StringUtils
+import com.willfp.eco.util.toJSON
 import com.willfp.reforges.ReforgesPlugin
-import com.willfp.reforges.reforges.ReforgeTarget
+import com.willfp.reforges.reforges.ReforgeTargets
 import com.willfp.reforges.util.reforge
 import com.willfp.reforges.util.reforgeStone
-import net.kyori.adventure.text.Component
-import net.kyori.adventure.text.TextReplacementConfig
 import org.bukkit.entity.Player
 import org.bukkit.inventory.ItemStack
 import org.bukkit.inventory.meta.SkullMeta
+import org.bukkit.persistence.PersistentDataType

@Suppress("DEPRECATION")
 class ReforgesDisplay(private val plugin: ReforgesPlugin) : DisplayModule(plugin, DisplayPriority.HIGH) {
+    private val tempKey = plugin.namespacedKeyFactory.create("temp")
+
    override fun display(
        itemStack: ItemStack,
        player: Player?,
        vararg args: Any
    ) {
-        val target = ReforgeTarget.getForItem(itemStack)
+        val targets = ReforgeTargets.getForItem(itemStack)

        val fast = itemStack.fast()

        val stone = fast.persistentDataContainer.reforgeStone

-        if (target.isEmpty() && stone == null) {
+        if (targets.isEmpty() && stone == null) {
            return
        }

@@ -39,7 +42,7 @@ class ReforgesDisplay(private val plugin: ReforgesPlugin) : DisplayModule(plugin

        val reforge = fast.persistentDataContainer.reforge

-        if (reforge == null && stone == null && target != null) {
+        if (reforge == null && stone == null) {
            if (plugin.configYml.getBool("reforge.show-reforgable")) {
                if (player != null && plugin.configYml.getBool("reforge.no-reforgable-in-gui")) {
                    val inventory = player.openInventory.topInventory
@@ -91,9 +94,17 @@ class ReforgesDisplay(private val plugin: ReforgesPlugin) : DisplayModule(plugin
            if (plugin.configYml.getBool("reforge.display-in-name")) {
                val displayName = fastItemStack.displayNameComponent

-                val newName = reforge.namePrefixComponent.append(displayName)
+                if (!fastItemStack.displayName.contains(reforge.name)) {
+                    fastItemStack.persistentDataContainer.set(
+                        tempKey,
+                        PersistentDataType.STRING,
+                        displayName.toJSON()
+                    )

-                fastItemStack.setDisplayName(newName)
+                    val newName = reforge.namePrefixComponent.append(displayName)
+
+                    fastItemStack.setDisplayName(newName)
+                }
            }


@@ -111,8 +122,7 @@ class ReforgesDisplay(private val plugin: ReforgesPlugin) : DisplayModule(plugin
    }

    override fun revert(itemStack: ItemStack) {
-        val reforge = itemStack.reforge ?: return
-        ReforgeTarget.getForItem(itemStack).ifEmpty { return }
+        itemStack.reforge ?: return

        val fis = FastItemStack.wrap(itemStack)

@@ -120,15 +130,17 @@ class ReforgesDisplay(private val plugin: ReforgesPlugin) : DisplayModule(plugin
            return
        }

-        val name = fis.displayNameComponent
+        if (fis.persistentDataContainer.has(tempKey, PersistentDataType.STRING)) {
+            fis.setDisplayName(
+                StringUtils.jsonToComponent(
+                    fis.persistentDataContainer.get(
+                        tempKey,
+                        PersistentDataType.STRING
+                    )
+                )
+            )

-        name.replaceText(
-            TextReplacementConfig.builder()
-                .matchLiteral("${reforge.name} ")
-                .replacement(Component.empty())
-                .build()
-        )
-
-        fis.setDisplayName(name)
+            fis.persistentDataContainer.remove(tempKey)
+        }
    }
 }
--- a/eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/gui/ReforgeGUI.kt
+++ b/eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/gui/ReforgeGUI.kt
@@ -17,6 +17,7 @@ import com.willfp.eco.util.NumberUtils
 import com.willfp.reforges.reforges.PriceMultipliers
 import com.willfp.reforges.reforges.Reforge
 import com.willfp.reforges.reforges.ReforgeTarget
+import com.willfp.reforges.reforges.ReforgeTargets
 import com.willfp.reforges.reforges.util.MetadatedReforgeStatus
 import com.willfp.reforges.util.ReforgeStatus
 import com.willfp.reforges.util.getRandomReforge
@@ -45,7 +46,7 @@ object ReforgeGUI {
        val status = if (item == null || item.type == Material.AIR) {
            ReforgeStatus.NO_ITEM
        } else {
-            targets.addAll(ReforgeTarget.getForItem(item))
+            targets.addAll(ReforgeTargets.getForItem(item))
            if (targets.isEmpty()) {
                ReforgeStatus.INVALID_ITEM
            } else {
@@ -71,7 +72,7 @@ object ReforgeGUI {
    @ConfigUpdater
    fun update(plugin: EcoPlugin) {
        val activatorSlot = slot(ItemStack(Material.ANVIL)) {
-            setModifier { player, menu, _ ->
+            setUpdater { player, menu, _ ->
                val (status, specialCost) = menu.getReforgeStatus(player)

                val cost = when {
@@ -105,7 +106,7 @@ object ReforgeGUI {
                            .replace("%xpcost%", NumberUtils.format(xpCost.toDouble()))
                            .replace(
                                "%stone%",
-                                menu.getCaptiveItems(player)[1].reforgeStone?.name ?: ""
+                                menu.getCaptiveItems(player).getOrNull(1).reforgeStone?.name ?: ""
                            )
                    }
                }
@@ -117,28 +118,24 @@ object ReforgeGUI {

                val item = captive.getOrNull(0) ?: return@onLeftClick
                val currentReforge = item.reforge
-                val targets = ReforgeTarget.getForItem(item)

-                var reforge: Reforge? = null
+                val targets = ReforgeTargets.getForItem(item)
+
+
                var usedStone = false

-                // Scan for reforge stone
-                if (menu.getCaptiveItems(player).size == 2) {
-                    val stone = menu.getCaptiveItems(player)[1].reforgeStone
-                    if (stone != null) {
-                        if (stone.canBeAppliedTo(item)) {
-                            reforge = stone
-                            usedStone = true
-                        }
-                    }
-                }
+                val stoneInMenu = menu.getCaptiveItems(player).getOrNull(1).reforgeStone

-                if (reforge == null) {
+                val reforge = if (stoneInMenu != null && stoneInMenu.canBeAppliedTo(item)) {
+                    usedStone = true
+                    stoneInMenu
+                } else {
                    val disallowed = mutableListOf<Reforge>()
                    if (currentReforge != null) {
                        disallowed.add(currentReforge)
                    }
-                    reforge = targets.getRandomReforge(disallowed = disallowed)
+
+                    targets.getRandomReforge(disallowed = disallowed)
                }

                if (reforge == null) {
@@ -240,7 +237,7 @@ object ReforgeGUI {
                    .setDisplayName("&r")
                    .build()
            ) {
-                setModifier { player, menu, _ ->
+                setUpdater { player, menu, _ ->
                    val status = menu.getReforgeStatus(player).status

                    if (status == ReforgeStatus.ALLOW || status == ReforgeStatus.ALLOW_STONE) {
--- a/eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/reforges/Reforge.kt
+++ b/eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/reforges/Reforge.kt
@@ -29,7 +29,7 @@ class Reforge(

    val description: List<String> = config.getFormattedStrings("description")

-    val targets = config.getStrings("targets").mapNotNull { ReforgeTarget.getByName(it) }.toSet()
+    val targets = config.getStrings("targets").mapNotNull { ReforgeTargets.getByName(it) }.toSet()

    override val effects = config.getSubsections("effects").mapNotNull {
        Effects.compile(it, "Reforge ID $id")
--- a/eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/reforges/ReforgeTarget.kt
+++ b/eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/reforges/ReforgeTarget.kt
@@ -1,15 +1,12 @@
 package com.willfp.reforges.reforges

-import com.google.common.collect.ImmutableSet
-import com.willfp.eco.core.config.updating.ConfigUpdater
 import com.willfp.eco.core.items.TestableItem
 import com.willfp.eco.core.recipe.parts.EmptyTestableItem
-import com.willfp.reforges.ReforgesPlugin
-import com.willfp.reforges.ReforgesPlugin.Companion.instance
 import org.bukkit.inventory.ItemStack
+import java.util.*

 class ReforgeTarget(
-    val name: String,
+    val id: String,
    val slot: Slot,
    val items: MutableSet<TestableItem>
 ) {
@@ -26,80 +23,21 @@ class ReforgeTarget(
        return false
    }

+    override fun equals(other: Any?): Boolean {
+        if (other !is ReforgeTarget) {
+            return false
+        }
+
+        return this.id == other.id
+    }
+
+    override fun hashCode(): Int {
+        return Objects.hash(this.id)
+    }
+
    enum class Slot {
        HANDS,
        ARMOR,
        ANY
    }
-
-    companion object {
-        private val registered = mutableMapOf<String, ReforgeTarget>()
-
-        val ALL = ReforgeTarget("all", Slot.ANY, HashSet())
-
-        init {
-            registered["all"] = ALL
-            update(instance)
-        }
-
-        /**
-         * Get ReforgeTarget matching name.
-         *
-         * @param name The name to search for.
-         * @return The matching ReforgeTarget, or null if not found.
-         */
-        @JvmStatic
-        fun getByName(name: String): ReforgeTarget? {
-            return registered[name]
-        }
-
-        /**
-         * Get target from item.
-         *
-         * @param item The item.
-         * @return The target.
-         */
-        @JvmStatic
-        fun getForItem(item: ItemStack): List<ReforgeTarget> {
-            return registered.values
-                .filter { !it.name.equals("all", ignoreCase = true) }
-                .filter { it.matches(item) }
-        }
-
-        /**
-         * Update all targets.
-         *
-         * @param plugin Instance of Reforges.
-         */
-        @ConfigUpdater
-        @JvmStatic
-        fun update(plugin: ReforgesPlugin) {
-            ALL.items.clear()
-            for (id in ArrayList(registered.keys)) {
-                if (id.equals("all", ignoreCase = true)) {
-                    continue
-                }
-                registered.remove(id)
-            }
-            for (id in plugin.targetYml.targets) {
-                val target = ReforgeTarget(
-                    id,
-                    plugin.targetYml.getSlot(id),
-                    plugin.targetYml.getTargetItems(id).toMutableSet()
-                )
-                registered[id] = target
-                ALL.items.addAll(target.items)
-            }
-        }
-
-        /**
-         * Get all targets.
-         *
-         * @return A set of all targets.
-         */
-        @JvmStatic
-        fun values(): Set<ReforgeTarget> {
-            return ImmutableSet.copyOf(registered.values)
-        }
-    }
 }
--- a/eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/reforges/ReforgeTargets.kt
+++ b/eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/reforges/ReforgeTargets.kt
@@ -0,0 +1,77 @@
+package com.willfp.reforges.reforges
+
+import com.google.common.collect.ImmutableSet
+import com.willfp.eco.core.config.updating.ConfigUpdater
+import com.willfp.reforges.ReforgesPlugin
+import org.bukkit.inventory.ItemStack
+
+object ReforgeTargets {
+    private val registered = mutableMapOf<String, ReforgeTarget>()
+
+    val ALL = ReforgeTarget("all", ReforgeTarget.Slot.ANY, HashSet())
+
+    init {
+        registered["all"] = ALL
+        update(ReforgesPlugin.instance)
+    }
+
+    /**
+     * Get ReforgeTarget matching name.
+     *
+     * @param name The name to search for.
+     * @return The matching ReforgeTarget, or null if not found.
+     */
+    @JvmStatic
+    fun getByName(name: String): ReforgeTarget? {
+        return registered[name]
+    }
+
+    /**
+     * Get target from item.
+     *
+     * @param item The item.
+     * @return The target.
+     */
+    @JvmStatic
+    fun getForItem(item: ItemStack): List<ReforgeTarget> {
+        return registered.values
+            .filter { !it.id.equals("all", ignoreCase = true) }
+            .filter { it.matches(item) }
+    }
+
+    /**
+     * Update all targets.
+     *
+     * @param plugin Instance of Reforges.
+     */
+    @ConfigUpdater
+    @JvmStatic
+    fun update(plugin: ReforgesPlugin) {
+        ALL.items.clear()
+        for (id in ArrayList(registered.keys)) {
+            if (id.equals("all", ignoreCase = true)) {
+                continue
+            }
+            registered.remove(id)
+        }
+        for (id in plugin.targetYml.targets) {
+            val target = ReforgeTarget(
+                id,
+                plugin.targetYml.getSlot(id),
+                plugin.targetYml.getTargetItems(id).toMutableSet()
+            )
+            registered[id] = target
+            ALL.items.addAll(target.items)
+        }
+    }
+
+    /**
+     * Get all targets.
+     *
+     * @return A set of all targets.
+     */
+    @JvmStatic
+    fun values(): Set<ReforgeTarget> {
+        return ImmutableSet.copyOf(registered.values)
+    }
+}
--- a/eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/util/ReforgeEnableListeners.kt
+++ b/eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/util/ReforgeEnableListeners.kt
@@ -3,8 +3,8 @@ package com.willfp.reforges.util
 import com.willfp.eco.core.EcoPlugin
 import com.willfp.eco.core.events.ArmorChangeEvent
 import com.willfp.libreforge.updateEffects
+import com.willfp.reforges.reforges.ReforgeTargets
 import com.willfp.reforges.reforges.Reforges.values
-import com.willfp.reforges.reforges.ReforgeTarget
 import com.willfp.reforges.util.ReforgeLookup.clearCache
 import org.bukkit.entity.Player
 import org.bukkit.event.EventHandler
@@ -16,6 +16,7 @@ import org.bukkit.event.player.PlayerItemHeldEvent
 import org.bukkit.event.player.PlayerJoinEvent
 import org.bukkit.event.player.PlayerQuitEvent

+@Suppress("UNUSED", "UNUSED_PARAMETER")
 class ReforgeEnableListeners(private val plugin: EcoPlugin) : Listener {
    @EventHandler
    fun onItemPickup(event: EntityPickupItemEvent) {
@@ -23,7 +24,7 @@ class ReforgeEnableListeners(private val plugin: EcoPlugin) : Listener {
            return
        }
        val player = event.entity as Player
-        if (!ReforgeTarget.ALL.matches(event.item.itemStack)) {
+        if (!ReforgeTargets.ALL.matches(event.item.itemStack)) {
            return
        }
        refreshPlayer(player)
@@ -39,15 +40,15 @@ class ReforgeEnableListeners(private val plugin: EcoPlugin) : Listener {
        refresh()
        val player = event.player
        for (value in values()) {
-            for ((effect1) in value.effects) {
-                effect1.disableForPlayer(player)
+            for ((effect) in value.effects) {
+                effect.disableForPlayer(player)
            }
        }
    }

    @EventHandler
    fun onInventoryDrop(event: PlayerDropItemEvent) {
-        if (!ReforgeTarget.ALL.matches(event.itemDrop.itemStack)) {
+        if (!ReforgeTargets.ALL.matches(event.itemDrop.itemStack)) {
            return
        }
        refreshPlayer(event.player)
--- a/eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/util/ReforgeUtils.kt
+++ b/eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/util/ReforgeUtils.kt
@@ -103,17 +103,13 @@ fun Collection<ReforgeTarget>.getRandomReforge(
    disallowed: Collection<Reforge> = emptyList()
 ): Reforge? {
    val applicable = mutableListOf<Reforge>()
+
    for (reforge in Reforges.values()) {
-        for (target in this) {
-            if (reforge.targets.contains(target) && !reforge.requiresStone) {
-                applicable.add(reforge)
-            }
+        if (reforge.targets.intersect(this.toSet()).isNotEmpty() && !reforge.requiresStone) {
+            applicable.add(reforge)
        }
    }
-    applicable.shuffle()

    applicable.removeAll(disallowed)
-    return if (applicable.isEmpty()) {
-        null
-    } else applicable[0]
+    return applicable.randomOrNull()
 }