From c008a17a271f18128d596d7d1355c9ffee47dd7d Mon Sep 17 00:00:00 2001 From: Auxilor Date: Sun, 22 May 2022 19:21:31 +0100 Subject: [PATCH] Various rewrites, refinements, and improvements --- .../willfp/reforges/commands/CommandApply.kt | 6 +- .../willfp/reforges/commands/CommandOpen.kt | 5 +- .../reforges/commands/CommandReforge.kt | 7 +- .../reforges/display/ReforgesDisplay.kt | 56 ++- .../com/willfp/reforges/gui/ReforgeGUI.kt | 122 ++++-- .../com/willfp/reforges/reforges/Reforge.kt | 15 +- .../reforges/util/ReforgeArgParser.kt | 8 +- .../willfp/reforges/util/AntiPlaceListener.kt | 2 +- .../reforges/util/DiscoverRecipeListener.kt | 28 +- .../com/willfp/reforges/util/ReforgeLookup.kt | 5 +- .../com/willfp/reforges/util/ReforgeUtils.kt | 360 +++++------------- 11 files changed, 239 insertions(+), 375 deletions(-) diff --git a/eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/commands/CommandApply.kt b/eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/commands/CommandApply.kt index b0002e5..c1179f2 100644 --- a/eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/commands/CommandApply.kt +++ b/eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/commands/CommandApply.kt @@ -3,7 +3,7 @@ package com.willfp.reforges.commands import com.willfp.eco.core.EcoPlugin import com.willfp.eco.core.command.impl.Subcommand import com.willfp.reforges.reforges.Reforges -import com.willfp.reforges.util.ReforgeUtils +import com.willfp.reforges.util.reforge import org.bukkit.Bukkit import org.bukkit.command.CommandSender import org.bukkit.entity.Player @@ -27,7 +27,7 @@ class CommandApply( if (sender is Player) { val item = sender.inventory.itemInMainHand - ReforgeUtils.setReforge(item, reforge) + item.reforge = reforge sender.sendMessage( plugin.langYml.getMessage("applied-reforge") .replace("%reforge%", reforge.name) @@ -45,7 +45,7 @@ class CommandApply( return } - ReforgeUtils.setReforge(player.inventory.itemInMainHand, reforge) + player.inventory.itemInMainHand.reforge = reforge sender.sendMessage( plugin.langYml.getMessage("applied-reforge") .replace("%reforge%", reforge.name) diff --git a/eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/commands/CommandOpen.kt b/eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/commands/CommandOpen.kt index e196719..f388989 100644 --- a/eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/commands/CommandOpen.kt +++ b/eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/commands/CommandOpen.kt @@ -2,7 +2,7 @@ package com.willfp.reforges.commands import com.willfp.eco.core.EcoPlugin import com.willfp.eco.core.command.impl.PluginCommand -import com.willfp.reforges.gui.ReforgeGUI.menu +import com.willfp.reforges.gui.ReforgeGUI import org.bukkit.Bukkit import org.bukkit.Sound import org.bukkit.command.CommandSender @@ -29,7 +29,8 @@ class CommandOpen( plugin.configYml.getDouble("gui.open-sound.pitch").toFloat() ) } - menu.open(player) + + ReforgeGUI.open(player) } override fun tabComplete(sender: CommandSender, args: List): List { diff --git a/eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/commands/CommandReforge.kt b/eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/commands/CommandReforge.kt index 59fee3b..e3b4c8b 100644 --- a/eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/commands/CommandReforge.kt +++ b/eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/commands/CommandReforge.kt @@ -2,7 +2,7 @@ package com.willfp.reforges.commands import com.willfp.eco.core.EcoPlugin import com.willfp.eco.core.command.impl.PluginCommand -import com.willfp.reforges.gui.ReforgeGUI.menu +import com.willfp.reforges.gui.ReforgeGUI import org.bukkit.Sound import org.bukkit.command.CommandSender import org.bukkit.entity.Player @@ -20,6 +20,7 @@ class CommandReforge( plugin.configYml.getDouble("gui.open-sound.pitch").toFloat() ) } - menu.open(player) + + ReforgeGUI.open(player) } -} \ No newline at end of file +} 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 64ad4f4..dbb4b40 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,32 +6,18 @@ 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.reforges.ReforgesPlugin import com.willfp.reforges.reforges.ReforgeTarget -import com.willfp.reforges.util.ReforgeUtils +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 net.kyori.adventure.text.format.TextDecoration -import net.kyori.adventure.text.serializer.gson.GsonComponentSerializer 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) { - /** - * Deprecated - */ - @Deprecated("Use PDC components!") - private val replacement = TextReplacementConfig.builder() - .match("§w(.+)§w") - .replacement("") - .build() - - private val originalComponentKey = plugin.namespacedKeyFactory.create("real_name") - private val serializer = GsonComponentSerializer.gson() - override fun display( itemStack: ItemStack, player: Player?, @@ -41,7 +27,7 @@ class ReforgesDisplay(private val plugin: ReforgesPlugin) : DisplayModule(plugin val fast = itemStack.fast() - val stone = ReforgeUtils.getReforgeStone(fast.persistentDataContainer) + val stone = fast.persistentDataContainer.reforgeStone if (target.isEmpty() && stone == null) { return @@ -51,7 +37,7 @@ class ReforgesDisplay(private val plugin: ReforgesPlugin) : DisplayModule(plugin val lore = fastItemStack.lore - val reforge = ReforgeUtils.getReforge(fast.persistentDataContainer) + val reforge = fast.persistentDataContainer.reforge if (reforge == null && stone == null && target != null) { if (plugin.configYml.getBool("reforge.show-reforgable")) { @@ -103,18 +89,11 @@ class ReforgesDisplay(private val plugin: ReforgesPlugin) : DisplayModule(plugin lore.addAll(addLore) } if (plugin.configYml.getBool("reforge.display-in-name")) { - val displayName = fastItemStack.displayNameComponent.replaceText(replacement) + val displayName = fastItemStack.displayNameComponent - val newName = StringUtils.toComponent("${reforge.name} ") - .decoration(TextDecoration.ITALIC, false).append(displayName) + val newName = reforge.namePrefixComponent.append(displayName) fastItemStack.setDisplayName(newName) - - fastItemStack.persistentDataContainer.set( - originalComponentKey, - PersistentDataType.STRING, - serializer.serialize(displayName) - ) } @@ -132,15 +111,24 @@ class ReforgesDisplay(private val plugin: ReforgesPlugin) : DisplayModule(plugin } override fun revert(itemStack: ItemStack) { - ReforgeTarget.getForItem(itemStack) ?: return + val reforge = itemStack.reforge ?: return + ReforgeTarget.getForItem(itemStack).ifEmpty { return } val fis = FastItemStack.wrap(itemStack) - if (plugin.configYml.getBool("reforge.display-in-name")) { - val originalName = - fis.persistentDataContainer.get(originalComponentKey, PersistentDataType.STRING) ?: return - fis.persistentDataContainer.remove(originalComponentKey) - fis.setDisplayName(serializer.deserialize(originalName).replaceText(replacement)) + if (!plugin.configYml.getBool("reforge.display-in-name")) { + return } + + val name = fis.displayNameComponent + + name.replaceText( + TextReplacementConfig.builder() + .matchLiteral("${reforge.name} ") + .replacement(Component.empty()) + .build() + ) + + fis.setDisplayName(name) } } 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 ea1f4ef..3f2213c 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,8 +17,12 @@ 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.util.MetadatedReforgeStatus import com.willfp.reforges.util.ReforgeStatus -import com.willfp.reforges.util.ReforgeUtils +import com.willfp.reforges.util.getRandomReforge +import com.willfp.reforges.util.reforge +import com.willfp.reforges.util.reforgeStone +import com.willfp.reforges.util.timesReforged import org.bukkit.Material import org.bukkit.Sound import org.bukkit.entity.Player @@ -30,6 +34,34 @@ import kotlin.math.pow object ReforgeGUI { private lateinit var menu: Menu + private fun Menu.getReforgeStatus(player: Player): MetadatedReforgeStatus { + val captive = this.getCaptiveItems(player) + val item = captive.getOrNull(0) + val stone = captive.getOrNull(1) + + val targets = mutableListOf() + + var cost = 0.0 + val status = if (item == null || item.type == Material.AIR) { + ReforgeStatus.NO_ITEM + } else { + targets.addAll(ReforgeTarget.getForItem(item)) + if (targets.isEmpty()) { + ReforgeStatus.INVALID_ITEM + } else { + val reforgeStone = stone.reforgeStone + if (reforgeStone != null && reforgeStone.canBeAppliedTo(item)) { + cost = reforgeStone.stonePrice.toDouble() + ReforgeStatus.ALLOW_STONE + } else { + ReforgeStatus.ALLOW + } + } + } + + return MetadatedReforgeStatus(status, cost) + } + @JvmStatic fun open(player: Player) { menu.open(player) @@ -40,11 +72,12 @@ object ReforgeGUI { fun update(plugin: EcoPlugin) { val activatorSlot = slot(ItemStack(Material.ANVIL)) { setModifier { player, menu, _ -> - val (status, specialCost) = ReforgeUtils.getStatus(menu.getCaptiveItems(player)) + val (status, specialCost) = menu.getReforgeStatus(player) val cost = when { status == ReforgeStatus.ALLOW || (status == ReforgeStatus.ALLOW_STONE && specialCost < 0) -> { - val amountOfReforges = ReforgeUtils.getReforges(menu.getCaptiveItems(player)[0]) + val amountOfReforges = menu.getCaptiveItems(player)[0].timesReforged + plugin.configYml.getDouble("reforge.cost") * plugin.configYml.getDouble("reforge.cost-exponent").pow(amountOfReforges) * PriceMultipliers.getForPlayer(player).multiplier @@ -58,7 +91,7 @@ object ReforgeGUI { var xpCost = plugin.configYml.getInt("reforge.xp-cost") if (status == ReforgeStatus.ALLOW) { val item = menu.getCaptiveItems(player)[0] - val reforges = ReforgeUtils.getReforges(item) + val reforges = item.timesReforged xpCost *= PriceMultipliers.getForPlayer(player).multiplier.toInt() xpCost *= plugin.configYml.getDouble("reforge.cost-exponent").pow(reforges.toDouble()).toInt() } @@ -72,7 +105,7 @@ object ReforgeGUI { .replace("%xpcost%", NumberUtils.format(xpCost.toDouble())) .replace( "%stone%", - ReforgeUtils.getReforgeStone(menu.getCaptiveItems(player)[1])?.name ?: "" + menu.getCaptiveItems(player)[1].reforgeStone?.name ?: "" ) } } @@ -82,17 +115,18 @@ object ReforgeGUI { val player = event.whoClicked as Player val captive = menu.getCaptiveItems(player) - val toReforge = captive.getOrNull(0) ?: return@onLeftClick - val existingReforge = ReforgeUtils.getReforge(toReforge) - val target = ReforgeTarget.getForItem(toReforge) + val item = captive.getOrNull(0) ?: return@onLeftClick + val currentReforge = item.reforge + val targets = ReforgeTarget.getForItem(item) var reforge: Reforge? = null var usedStone = false + // Scan for reforge stone if (menu.getCaptiveItems(player).size == 2) { - val stone = ReforgeUtils.getReforgeStone(menu.getCaptiveItems(player)[1]) + val stone = menu.getCaptiveItems(player)[1].reforgeStone if (stone != null) { - if (stone.targets.any { it.matches(toReforge) }) { + if (stone.canBeAppliedTo(item)) { reforge = stone usedStone = true } @@ -100,11 +134,11 @@ object ReforgeGUI { } if (reforge == null) { - val existing: MutableList = ArrayList() - if (existingReforge != null) { - existing.add(existingReforge) + val disallowed = mutableListOf() + if (currentReforge != null) { + disallowed.add(currentReforge) } - reforge = ReforgeUtils.getRandomReforge(target, existing) + reforge = targets.getRandomReforge(disallowed = disallowed) } if (reforge == null) { @@ -113,9 +147,10 @@ object ReforgeGUI { var cost = 0.0 + val reforges = item.timesReforged + if (EconomyManager.hasRegistrations()) { cost = plugin.configYml.getDouble("reforge.cost") - val reforges = ReforgeUtils.getReforges(toReforge) cost *= plugin.configYml.getDouble("reforge.cost-exponent").pow(reforges.toDouble()) if (reforge.requiresStone && reforge.stonePrice != -1) { cost = reforge.stonePrice.toDouble() @@ -136,8 +171,9 @@ object ReforgeGUI { return@onLeftClick } } + var xpCost = plugin.configYml.getInt("reforge.xp-cost") - val reforges = ReforgeUtils.getReforges(toReforge) + xpCost *= plugin.configYml.getDouble("reforge.cost-exponent").pow(reforges.toDouble()).toInt() xpCost *= PriceMultipliers.getForPlayer(player).multiplier.toInt() if (player.level < xpCost) { @@ -158,9 +194,12 @@ object ReforgeGUI { EconomyManager.removeMoney(player, cost) } player.level = player.level - xpCost + player.sendMessage(plugin.langYml.getMessage("applied-reforge").replace("%reforge%", reforge.name)) - ReforgeUtils.incrementReforges(toReforge) - ReforgeUtils.setReforge(toReforge, reforge) + + item.timesReforged++ + item.reforge = reforge + if (usedStone) { val stone = menu.getCaptiveItems(player)[1] stone.itemMeta = null @@ -175,6 +214,7 @@ object ReforgeGUI { ) } } + if (plugin.configYml.getBool("gui.sound.enabled")) { player.playSound( player.location, @@ -194,35 +234,33 @@ object ReforgeGUI { menu = menu(plugin.configYml.getInt("gui.rows")) { setTitle(plugin.langYml.getFormattedString("menu.title")) setMask(FillerMask(MaskItems(*maskItems), *maskPattern)) - modfiy { builder -> - val slot = Slot.builder( - ItemStackBuilder(Material.BLACK_STAINED_GLASS_PANE) - .setDisplayName("&r") - .build() - ).apply { - setModifier { player, menu, _ -> - val status = ReforgeUtils.getStatus( - menu.getCaptiveItems(player) - ).status - if (status == ReforgeStatus.ALLOW || status == ReforgeStatus.ALLOW_STONE) { - Items.lookup(plugin.configYml.getString("gui.show-allowed.allow-material")).item - } else { - Items.lookup(plugin.configYml.getString("gui.show-allowed.deny-material")).item - } - } - }.build() + val slot = slot( + ItemStackBuilder(Material.BLACK_STAINED_GLASS_PANE) + .setDisplayName("&r") + .build() + ) { + setModifier { player, menu, _ -> + val status = menu.getReforgeStatus(player).status - val allowedPattern = plugin.configYml.getStrings("gui.show-allowed.pattern") - for (i in 1..allowedPattern.size) { - val row = allowedPattern[i - 1] - for (j in 1..9) { - if (row[j - 1] != '0') { - builder.setSlot(i, j, slot) - } + if (status == ReforgeStatus.ALLOW || status == ReforgeStatus.ALLOW_STONE) { + Items.lookup(plugin.configYml.getString("gui.show-allowed.allow-material")).item + } else { + Items.lookup(plugin.configYml.getString("gui.show-allowed.deny-material")).item } } } + + val allowedPattern = plugin.configYml.getStrings("gui.show-allowed.pattern") + for (i in 1..allowedPattern.size) { + val row = allowedPattern[i - 1] + for (j in 1..9) { + if (row[j - 1] != '0') { + setSlot(i, j, slot) + } + } + } + setSlot( plugin.configYml.getInt("gui.item-slot.row"), plugin.configYml.getInt("gui.item-slot.column"), 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 b7f1f1f..31032bb 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 @@ -6,11 +6,13 @@ import com.willfp.eco.core.items.CustomItem import com.willfp.eco.core.items.Items import com.willfp.eco.core.items.builder.ItemStackBuilder import com.willfp.eco.core.recipe.Recipes +import com.willfp.eco.util.StringUtils import com.willfp.libreforge.Holder import com.willfp.libreforge.conditions.Conditions import com.willfp.libreforge.effects.Effects import com.willfp.reforges.ReforgesPlugin -import com.willfp.reforges.util.ReforgeUtils +import com.willfp.reforges.util.reforgeStone +import net.kyori.adventure.text.format.TextDecoration import org.bukkit.inventory.ItemStack import java.util.* @@ -23,6 +25,8 @@ class Reforge( val name = config.getFormattedString("name") + val namePrefixComponent = StringUtils.toComponent("$name ").decoration(TextDecoration.ITALIC, false) + val description: List = config.getFormattedStrings("description") val targets = config.getStrings("targets").mapNotNull { ReforgeTarget.getByName(it) }.toSet() @@ -50,14 +54,13 @@ class Reforge( init { Reforges.addNewReforge(this) - ReforgeUtils.setReforgeStone(stone, this) - + stone.reforgeStone = this Display.display(stone) if (config.getBool("stone.enabled")) { CustomItem( plugin.namespacedKeyFactory.create("stone_" + this.id), - { test -> ReforgeUtils.getReforgeStone(test) == this }, + { test -> test.reforgeStone == this }, stone ).register() @@ -72,6 +75,10 @@ class Reforge( } } + fun canBeAppliedTo(item: ItemStack?): Boolean { + return targets.any { target -> target.items.any { it.matches(item) } } + } + override fun equals(other: Any?): Boolean { if (this === other) { return true diff --git a/eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/reforges/util/ReforgeArgParser.kt b/eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/reforges/util/ReforgeArgParser.kt index f545a08..e4a1e91 100644 --- a/eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/reforges/util/ReforgeArgParser.kt +++ b/eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/reforges/util/ReforgeArgParser.kt @@ -3,7 +3,7 @@ package com.willfp.reforges.reforges.util import com.willfp.eco.core.items.args.LookupArgParser import com.willfp.reforges.reforges.Reforge import com.willfp.reforges.reforges.Reforges -import com.willfp.reforges.util.ReforgeUtils +import com.willfp.reforges.util.reforge import org.bukkit.inventory.ItemStack import org.bukkit.inventory.meta.ItemMeta import java.util.function.Predicate @@ -27,16 +27,16 @@ class ReforgeArgParser : LookupArgParser { reforge ?: return null - ReforgeUtils.setReforge(meta, reforge) + meta.reforge = reforge return Predicate { test -> val testMeta = test.itemMeta ?: return@Predicate false - reforge == ReforgeUtils.getReforge(testMeta) + reforge == testMeta.reforge } } override fun serializeBack(meta: ItemMeta): String? { - val reforge = ReforgeUtils.getReforge(meta) ?: return null + val reforge = meta.reforge ?: return null return "reforge:${reforge.id}" } diff --git a/eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/util/AntiPlaceListener.kt b/eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/util/AntiPlaceListener.kt index 0fcf639..9e946d5 100644 --- a/eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/util/AntiPlaceListener.kt +++ b/eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/util/AntiPlaceListener.kt @@ -7,7 +7,7 @@ import org.bukkit.event.block.BlockPlaceEvent class AntiPlaceListener : Listener { @EventHandler fun onBlockPlace(event: BlockPlaceEvent) { - if (ReforgeUtils.getReforgeStone(event.itemInHand) != null) { + if (event.itemInHand.reforgeStone != null) { event.isCancelled = true event.setBuild(false) } diff --git a/eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/util/DiscoverRecipeListener.kt b/eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/util/DiscoverRecipeListener.kt index 82cae96..f7bbbdd 100644 --- a/eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/util/DiscoverRecipeListener.kt +++ b/eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/util/DiscoverRecipeListener.kt @@ -2,29 +2,23 @@ package com.willfp.reforges.util import com.willfp.eco.core.EcoPlugin import org.bukkit.Bukkit +import org.bukkit.Keyed import org.bukkit.event.EventHandler import org.bukkit.event.Listener import org.bukkit.event.player.PlayerJoinEvent import org.bukkit.inventory.Recipe -import org.bukkit.inventory.ShapedRecipe -class DiscoverRecipeListener( - private val plugin: EcoPlugin -) : Listener { +class DiscoverRecipeListener(private val plugin: EcoPlugin) : Listener { @EventHandler fun onJoin(event: PlayerJoinEvent) { - val player = event.player - if (plugin.configYml.getBool("discover-recipes")) { - Bukkit.getServer().recipeIterator().forEachRemaining { recipe: Recipe -> - if (recipe is ShapedRecipe) { - val key = recipe.key - if (key.namespace == "reforges") { - if (!key.key.contains("displayed")) { - player.discoverRecipe(key) - } - } - } - } + if (!plugin.configYml.getBool("discover-recipes")) { + return } + mutableListOf() + .apply { Bukkit.getServer().recipeIterator().forEachRemaining(this::add) } + .filterIsInstance().map { it.key } + .filter { it.namespace == plugin.name.lowercase() } + .filter { !it.key.contains("displayed") } + .forEach { event.player.discoverRecipe(it) } } -} \ No newline at end of file +} diff --git a/eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/util/ReforgeLookup.kt b/eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/util/ReforgeLookup.kt index 8aee329..4ddfb02 100644 --- a/eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/util/ReforgeLookup.kt +++ b/eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/util/ReforgeLookup.kt @@ -4,7 +4,6 @@ import com.github.benmanes.caffeine.cache.Caffeine import com.willfp.reforges.ReforgesPlugin import com.willfp.reforges.reforges.Reforge import com.willfp.reforges.reforges.ReforgeTarget -import com.willfp.reforges.util.ReforgeUtils.getReforge import org.bukkit.entity.Player import org.bukkit.inventory.ItemStack import java.util.concurrent.TimeUnit @@ -50,7 +49,7 @@ object ReforgeLookup { val found = mutableListOf() for ((itemStack, slot) in provide(player)) { - val reforge = getReforge(itemStack) ?: continue + val reforge = itemStack.reforge ?: continue if (slot != ReforgeTarget.Slot.ANY) { if (!reforge.targets.map { it.slot }.contains(slot)) { continue @@ -104,4 +103,4 @@ object ReforgeLookup { items } } -} \ No newline at end of file +} 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 6ed5d97..bd6eebf 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 @@ -1,283 +1,119 @@ package com.willfp.reforges.util -import com.willfp.eco.core.fast.FastItemStack -import com.willfp.eco.core.items.TestableItem +import com.willfp.eco.core.fast.fast import com.willfp.reforges.ReforgesPlugin import com.willfp.reforges.reforges.Reforge -import com.willfp.reforges.reforges.Reforges.getByKey -import com.willfp.reforges.reforges.Reforges.values import com.willfp.reforges.reforges.ReforgeTarget -import com.willfp.reforges.reforges.util.MetadatedReforgeStatus -import org.bukkit.Material +import com.willfp.reforges.reforges.Reforges import org.bukkit.inventory.ItemStack import org.bukkit.inventory.meta.ItemMeta import org.bukkit.persistence.PersistentDataContainer import org.bukkit.persistence.PersistentDataType -object ReforgeUtils { - private val PLUGIN = ReforgesPlugin.instance +private val plugin = ReforgesPlugin.instance +private val reforgeKey = plugin.namespacedKeyFactory.create("reforge") +private val reforgeAmountKey = plugin.namespacedKeyFactory.create("reforge_amount") +private val reforgeStoneKey = plugin.namespacedKeyFactory.create("reforge_stone") - /** - * The key for storing reforges. - */ - private val REFORGE_KEY = PLUGIN.namespacedKeyFactory.create("reforge") - - /** - * The key for storing reforge amounts. - */ - private val REFORGE_AMOUNT = PLUGIN.namespacedKeyFactory.create("reforge_amount") - - /** - * The key for storing reforge stones. - */ - private val REFORGE_STONE_KEY = PLUGIN.namespacedKeyFactory.create("reforge_stone") - - /** - * Get a random reforge for a target. - * - * @param targets The targets. - */ - fun getRandomReforge(targets: Collection): Reforge? { - return getRandomReforge(targets, emptyList()) +var ItemStack?.reforge: Reforge? + get() { + this ?: return null + return this.fast().persistentDataContainer.reforge + } + set(value) { + this ?: return + this.fast().persistentDataContainer.reforge = value } - /** - * Get a random reforge for a target. - * - * @param targets The targets. - * @param disallowed The disallowed reforges. - */ - @JvmStatic - fun getRandomReforge( - targets: Collection, - disallowed: Collection - ): Reforge? { - val applicable = mutableListOf() - for (reforge in values()) { - for (target in targets) { - if (reforge.targets.contains(target) && !reforge.requiresStone) { - applicable.add(reforge) - } - } +var ItemMeta?.reforge: Reforge? + get() { + this ?: return null + return this.persistentDataContainer.reforge + } + set(value) { + this ?: return + this.persistentDataContainer.reforge = value + } + +var PersistentDataContainer?.reforge: Reforge? + get() { + this ?: return null + + if (!this.has(reforgeKey, PersistentDataType.STRING)) { + return null } - applicable.shuffle() - applicable.removeAll(disallowed) - return if (applicable.isEmpty()) { - null - } else applicable[0] + val active = this.get(reforgeKey, PersistentDataType.STRING) + return Reforges.getByKey(active) } - - fun getStatus(captive: List): MetadatedReforgeStatus { - val toReforge = if (captive.isEmpty()) null else captive[0] - val stone = if (captive.size == 2) captive[1] else null - var status: ReforgeStatus? = null - val target: MutableList = ArrayList() - if (toReforge == null || toReforge.type == Material.AIR) { - status = ReforgeStatus.NO_ITEM + set(value) { + this ?: return + if (value == null) { + this.remove(reforgeKey) } else { - target.addAll(ReforgeTarget.getForItem(toReforge)) - if (target.isEmpty()) { - status = ReforgeStatus.INVALID_ITEM + this.set(reforgeKey, PersistentDataType.STRING, value.id) + } + } + +var ItemStack?.reforgeStone: Reforge? + get() { + this ?: return null + return this.fast().persistentDataContainer.reforgeStone + } + set(value) { + this ?: return + this.fast().persistentDataContainer.reforgeStone = value + } + +var ItemMeta?.reforgeStone: Reforge? + get() { + this ?: return null + return this.persistentDataContainer.reforgeStone + } + set(value) { + this ?: return + this.persistentDataContainer.reforgeStone = value + } + +var PersistentDataContainer?.reforgeStone: Reforge? + get() { + this ?: return null + + if (!this.has(reforgeStoneKey, PersistentDataType.STRING)) { + return null + } + + val active = this.get(reforgeStoneKey, PersistentDataType.STRING) + return Reforges.getByKey(active) + } + set(value) { + this ?: return + if (value == null) { + this.remove(reforgeStoneKey) + } else { + this.set(reforgeStoneKey, PersistentDataType.STRING, value.id) + } + } + +var ItemStack.timesReforged: Int + get() = this.fast().persistentDataContainer.get(reforgeAmountKey, PersistentDataType.INTEGER) ?: 0 + set(value) = this.fast().persistentDataContainer.set(reforgeAmountKey, PersistentDataType.INTEGER, value) + +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 (target.isNotEmpty()) { - status = ReforgeStatus.ALLOW - } - var cost = 0.0 - if (status == ReforgeStatus.ALLOW) { - val reforgeStone = getReforgeStone(stone) - if (reforgeStone != null && reforgeStone.targets.stream() - .anyMatch { reforgeTarget: ReforgeTarget -> - reforgeTarget.items.stream() - .anyMatch { item: TestableItem -> item.matches(toReforge) } - } - ) { - cost = reforgeStone.stonePrice.toDouble() - status = ReforgeStatus.ALLOW_STONE - } - } - return MetadatedReforgeStatus(status!!, cost) } + applicable.shuffle() - /** - * Get reforge on an item. - * - * @param item The item to query. - * @return The found reforge, or null. - */ - fun getReforge(item: ItemStack?): Reforge? { - if (item == null) { - return null - } - val container = FastItemStack.wrap(item).persistentDataContainer - return getReforge(container) - } - - /** - * Get reforge on an item. - * - * @param meta The item to query. - * @return The found reforge, or null. - */ - fun getReforge(meta: ItemMeta?): Reforge? { - if (meta == null) { - return null - } - val container = meta.persistentDataContainer - if (!container.has(REFORGE_KEY, PersistentDataType.STRING)) { - return null - } - val active = container.get(REFORGE_KEY, PersistentDataType.STRING) - return getByKey(active) - } - - /** - * Get reforge on an item. - * - * @param container The item to query. - * @return The found reforge, or null. - */ - fun getReforge(container: PersistentDataContainer?): Reforge? { - if (container == null) { - return null - } - if (!container.has(REFORGE_KEY, PersistentDataType.STRING)) { - return null - } - val active = container.get(REFORGE_KEY, PersistentDataType.STRING) - return getByKey(active) - } - - /** - * Set reforge on an item. - * - * @param item The item. - * @param reforge The reforge. - */ - fun setReforge( - item: ItemStack, - reforge: Reforge - ) { - if (item.itemMeta == null) { - return - } - val meta = item.itemMeta - setReforge(meta, reforge) - item.itemMeta = meta - } - - /** - * Set reforge on an item. - * - * @param meta The meta. - * @param reforge The reforge. - */ - fun setReforge( - meta: ItemMeta, - reforge: Reforge - ) { - val container = meta.persistentDataContainer - container.set(REFORGE_KEY, PersistentDataType.STRING, reforge.id) - } - - /** - * Get reforge stone on an item. - * - * @param item The item to query. - * @return The found reforge, or null. - */ - fun getReforgeStone(item: ItemStack?): Reforge? { - if (item == null) { - return null - } - val container = FastItemStack.wrap(item).persistentDataContainer - return getReforgeStone(container) - } - - /** - * Get reforge stone on an item. - * - * @param meta The item to query. - * @return The found reforge, or null. - */ - fun getReforgeStone(meta: ItemMeta?): Reforge? { - if (meta == null) { - return null - } - val container = meta.persistentDataContainer - if (!container.has(REFORGE_STONE_KEY, PersistentDataType.STRING)) { - return null - } - val active = container.get(REFORGE_STONE_KEY, PersistentDataType.STRING) - return getByKey(active) - } - - /** - * Get reforge stone on an item. - * - * @param container The item to query. - * @return The found reforge, or null. - */ - fun getReforgeStone(container: PersistentDataContainer?): Reforge? { - if (container == null) { - return null - } - if (!container.has(REFORGE_STONE_KEY, PersistentDataType.STRING)) { - return null - } - val active = container.get(REFORGE_STONE_KEY, PersistentDataType.STRING) - return getByKey(active) - } - - /** - * Set an item to be a reforge stone. - * - * @param item The item. - * @param reforge The reforge. - */ - fun setReforgeStone( - item: ItemStack, - reforge: Reforge - ) { - if (item.itemMeta == null) { - return - } - val meta = item.itemMeta - val container = meta.persistentDataContainer - container.set(REFORGE_STONE_KEY, PersistentDataType.STRING, reforge.id) - item.itemMeta = meta - } - - /** - * Get the amount of reforges done to an item. - * - * @param item The item. - */ - @JvmStatic - fun getReforges(item: ItemStack): Int { - val meta = item.itemMeta ?: return 0 - val container = meta.persistentDataContainer - if (!container.has(REFORGE_AMOUNT, PersistentDataType.INTEGER)) { - container.set(REFORGE_AMOUNT, PersistentDataType.INTEGER, 0) - item.itemMeta = meta - } - val amount = container.get(REFORGE_AMOUNT, PersistentDataType.INTEGER) - return amount ?: 0 - } - - /** - * Get the amount of reforges done to an item. - * - * @param item The item. - */ - @JvmStatic - fun incrementReforges(item: ItemStack) { - val meta = item.itemMeta ?: return - var amount = getReforges(item) - amount++ - val container = meta.persistentDataContainer - container.set(REFORGE_AMOUNT, PersistentDataType.INTEGER, amount) - item.itemMeta = meta - } -} \ No newline at end of file + applicable.removeAll(disallowed) + return if (applicable.isEmpty()) { + null + } else applicable[0] +}