From 3743d06cb3c74b0e646d5b3f43e73007347209b4 Mon Sep 17 00:00:00 2001 From: Auxilor Date: Sun, 22 May 2022 19:55:19 +0100 Subject: [PATCH] More improvements and fixes --- .../reforges/display/ReforgesDisplay.kt | 50 +++++++---- .../com/willfp/reforges/gui/ReforgeGUI.kt | 33 ++++--- .../com/willfp/reforges/reforges/Reforge.kt | 2 +- .../willfp/reforges/reforges/ReforgeTarget.kt | 90 +++---------------- .../reforges/reforges/ReforgeTargets.kt | 77 ++++++++++++++++ .../reforges/util/ReforgeEnableListeners.kt | 11 +-- .../com/willfp/reforges/util/ReforgeUtils.kt | 12 +-- 7 files changed, 148 insertions(+), 127 deletions(-) create mode 100644 eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/reforges/ReforgeTargets.kt diff --git 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 index dbb4b40..024dd98 100644 --- 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) + } } } diff --git 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 index 3f2213c..cf21ea6 100644 --- 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() 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) { diff --git 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 index 31032bb..08d8085 100644 --- 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 = 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") diff --git 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 index 0961d8f..874f607 100644 --- 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 ) { @@ -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() - - 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 { - 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 { - return ImmutableSet.copyOf(registered.values) - } - } } diff --git 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 new file mode 100644 index 0000000..f11a789 --- /dev/null +++ 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() + + 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 { + 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 { + return ImmutableSet.copyOf(registered.values) + } +} \ No newline at end of file diff --git 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 index 73b42cf..b06de1e 100644 --- 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) diff --git 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 index bd6eebf..2a1d312 100644 --- 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.getRandomReforge( disallowed: Collection = emptyList() ): Reforge? { val applicable = mutableListOf() + 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() }