Fixed TargetYml#getSlot

Update custom item register ID

build.gradle.kts

@@ -2,7 +2,7 @@ plugins {
     java
     `java-library`
     `maven-publish`
-    kotlin("jvm") version "1.7.10"
+    kotlin("jvm") version "1.9.20"
     id("com.github.johnrengelman.shadow") version "8.0.0"
     id("com.willfp.libreforge-gradle-plugin") version "1.0.0"
 }
@@ -39,7 +39,7 @@ allprojects {
     dependencies {
         compileOnly("com.willfp:eco:6.56.0")
         compileOnly("org.jetbrains:annotations:23.0.0")
-        compileOnly("org.jetbrains.kotlin:kotlin-stdlib:1.7.10")
+        compileOnly("org.jetbrains.kotlin:kotlin-stdlib:1.9.20")
     }
 
     java {

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/ReforgesPlugin.kt

@@ -2,24 +2,21 @@ package com.willfp.reforges
 
 import com.willfp.eco.core.command.impl.PluginCommand
 import com.willfp.eco.core.display.DisplayModule
-import com.willfp.eco.core.integrations.IntegrationLoader
 import com.willfp.eco.core.items.Items
 import com.willfp.libreforge.conditions.Conditions
 import com.willfp.libreforge.loader.LibreforgePlugin
 import com.willfp.libreforge.loader.configs.ConfigCategory
 import com.willfp.libreforge.registerHolderProvider
-import com.willfp.libreforge.registerPlayerRefreshFunction
 import com.willfp.reforges.commands.CommandReforge
 import com.willfp.reforges.commands.CommandReforges
 import com.willfp.reforges.config.TargetYml
 import com.willfp.reforges.display.ReforgesDisplay
-import com.willfp.reforges.integrations.talismans.TalismansIntegration
 import com.willfp.reforges.libreforge.ConditionHasReforge
+import com.willfp.reforges.reforges.ReforgeFinder
 import com.willfp.reforges.reforges.Reforges
 import com.willfp.reforges.reforges.util.ReforgeArgParser
 import com.willfp.reforges.util.AntiPlaceListener
 import com.willfp.reforges.util.DiscoverRecipeListener
-import com.willfp.reforges.util.ReforgeLookup
 import org.bukkit.event.Listener
 
 class ReforgesPlugin : LibreforgePlugin() {
@@ -41,8 +38,7 @@ class ReforgesPlugin : LibreforgePlugin() {
 
         Items.registerArgParser(ReforgeArgParser)
 
-        registerHolderProvider { ReforgeLookup.provideReforges(it) }
+        registerHolderProvider(ReforgeFinder.toHolderProvider())
-        registerPlayerRefreshFunction { ReforgeLookup.clearCache(it) }
     }
 
     override fun loadListeners(): List<Listener> {
@@ -63,12 +59,6 @@ class ReforgesPlugin : LibreforgePlugin() {
         return ReforgesDisplay(this)
     }
 
-    override fun loadIntegrationLoaders(): List<IntegrationLoader> {
-        return listOf(
-            IntegrationLoader("Talismans") { TalismansIntegration.registerProvider() }
-        )
-    }
-
     companion object {
         /**
          * Instance of Reforges.

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/commands/CommandApply.kt

@@ -28,6 +28,7 @@ class CommandApply(
         if (sender is Player) {
             val item = sender.inventory.itemInMainHand
             item.reforge = reforge
+            reforge.runOnReforgeEffects(sender, item)
             sender.sendMessage(
                 plugin.langYml.getMessage("applied-reforge")
                     .replace("%reforge%", reforge.name)
@@ -45,7 +46,10 @@ class CommandApply(
                 return
             }
 
-            player.inventory.itemInMainHand.reforge = reforge
+            val item = player.inventory.itemInMainHand
+
+            item.reforge = reforge
+            reforge.runOnReforgeEffects(player, item)
             sender.sendMessage(
                 plugin.langYml.getMessage("applied-reforge")
                     .replace("%reforge%", reforge.name)

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/config/TargetYml.kt

@@ -5,8 +5,10 @@ import com.willfp.eco.core.config.ConfigType
 import com.willfp.eco.core.config.StaticBaseConfig
 import com.willfp.eco.core.items.Items
 import com.willfp.eco.core.items.TestableItem
-import com.willfp.reforges.reforges.ReforgeTarget
+import com.willfp.libreforge.slot.SlotType
-import java.util.*
+import com.willfp.libreforge.slot.SlotTypes
+import com.willfp.libreforge.slot.impl.SlotTypeAny
+import java.util.Locale
 import java.util.function.Consumer
 
 class TargetYml(plugin: EcoPlugin) : StaticBaseConfig("target", plugin, ConfigType.YAML) {
@@ -32,12 +34,12 @@ class TargetYml(plugin: EcoPlugin) : StaticBaseConfig("target", plugin, ConfigTy
     }
 
     /**
-     * Get all materials from a target name.
+     * Get a [SlotType] for the target.
      *
      * @param target The name of the target.
-     * @return All materials.
+     * @return The [SlotType].
      */
-    fun getSlot(target: String): ReforgeTarget.Slot {
+    fun getSlot(target: String): SlotType {
-        return ReforgeTarget.Slot.valueOf(this.getString("$target.slot").uppercase(Locale.getDefault()))
+        return SlotTypes[this.getString("$target.slot")] ?: SlotTypeAny
     }
 }

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/display/ReforgesDisplay.kt

@@ -6,6 +6,7 @@ import com.willfp.eco.core.display.DisplayPriority
 import com.willfp.eco.core.display.DisplayProperties
 import com.willfp.eco.core.fast.FastItemStack
 import com.willfp.eco.core.fast.fast
+import com.willfp.eco.core.placeholder.context.placeholderContext
 import com.willfp.eco.util.SkullUtils
 import com.willfp.eco.util.StringUtils
 import com.willfp.eco.util.formatEco
@@ -47,12 +48,15 @@ class ReforgesDisplay(private val plugin: ReforgesPlugin) : DisplayModule(plugin
 
         val reforge = fast.persistentDataContainer.reforge
 
+        val context = placeholderContext(
+            player = player,
+            item = itemStack
+        )
+
         if (reforge == null && stone == null) {
             if (plugin.configYml.getBool("reforge.show-reforgable")) {
-                if (plugin.configYml.getBool("reforge.no-reforgable-in-gui")) {
+                if (props.inGui) {
-                    if (props.inGui) {
+                    return
-                        return
-                    }
                 }
 
                 val addLore: MutableList<String> = ArrayList()
@@ -91,10 +95,11 @@ class ReforgesDisplay(private val plugin: ReforgesPlugin) : DisplayModule(plugin
                 for (string in plugin.configYml.getFormattedStrings("reforge.reforged-prefix")) {
                     addLore.add(Display.PREFIX + string.replace("%reforge%", reforge.name))
                 }
-                addLore.addAll(reforge.description)
+                addLore.addAll(reforge.description.formatEco(context))
                 addLore.replaceAll { "${Display.PREFIX}$it" }
                 lore.addAll(addLore)
             }
+
             if (plugin.configYml.getBool("reforge.display-in-name")) {
                 val displayName = fastItemStack.displayNameComponent
 
@@ -115,7 +120,7 @@ class ReforgesDisplay(private val plugin: ReforgesPlugin) : DisplayModule(plugin
             if (player != null) {
                 val provided = ItemProvidedHolder(reforge, itemStack)
 
-                val lines = reforge.conditions.getNotMetLines(player, provided).map { Display.PREFIX + it }
+                val lines = provided.getNotMetLines(player).map { Display.PREFIX + it }
 
                 if (lines.isNotEmpty()) {
                     lore.add(Display.PREFIX)

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/gui/ReforgeGUI.kt

@@ -150,6 +150,8 @@ private class ActivatorSlot(
             item.timesReforged++
             item.reforge = reforge
 
+            reforge.runOnReforgeEffects(player, item)
+
             if (usedStone) {
                 val stone = reforgeStone[player]
                 stone?.amount = stone?.amount?.minus(1) ?: 0

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/integrations/talismans/TalismansIntegration.kt

@@ -1,25 +0,0 @@
-package com.willfp.reforges.integrations.talismans
-
-import com.willfp.eco.core.integrations.Integration
-import com.willfp.reforges.reforges.ReforgeTarget
-import com.willfp.reforges.util.ReforgeLookup
-import com.willfp.talismans.talismans.util.TalismanChecks
-import org.bukkit.inventory.ItemStack
-
-object TalismansIntegration : Integration {
-    @JvmStatic
-    fun registerProvider() {
-        ReforgeLookup.registerProvider { player ->
-            val provided = mutableMapOf<ItemStack?, ReforgeTarget.Slot?>()
-            for (itemStack in TalismanChecks.getTalismanItemsOnPlayer(player)) {
-                provided[itemStack] = ReforgeTarget.Slot.ANY
-            }
-
-            provided
-        }
-    }
-
-    override fun getPluginName(): String {
-        return "Talismans"
-    }
-}

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/libreforge/ConditionHasReforge.kt

@@ -2,11 +2,15 @@ package com.willfp.reforges.libreforge
 
 import com.willfp.eco.core.config.interfaces.Config
 import com.willfp.eco.util.containsIgnoreCase
+import com.willfp.libreforge.Dispatcher
 import com.willfp.libreforge.NoCompileData
+import com.willfp.libreforge.ProvidedHolder
 import com.willfp.libreforge.arguments
 import com.willfp.libreforge.conditions.Condition
+import com.willfp.libreforge.get
+import com.willfp.libreforge.getHoldersOfType
+import com.willfp.libreforge.toDispatcher
 import com.willfp.reforges.reforges.Reforge
-import com.willfp.reforges.util.ReforgeLookup
 import org.bukkit.entity.Player
 
 object ConditionHasReforge : Condition<NoCompileData>("has_reforge") {
@@ -14,10 +18,15 @@ object ConditionHasReforge : Condition<NoCompileData>("has_reforge") {
         require("reforge", "You must specify the reforge!")
     }
 
-    override fun isMet(player: Player, config: Config, compileData: NoCompileData): Boolean {
+    override fun isMet(
-        return ReforgeLookup.provideReforges(player)
+        dispatcher: Dispatcher<*>,
-            .map { it.holder }
+        config: Config,
-            .filterIsInstance<Reforge>()
+        holder: ProvidedHolder,
+        compileData: NoCompileData
+    ): Boolean {
+        val player = dispatcher.get<Player>() ?: return false
+
+        return player.toDispatcher().getHoldersOfType<Reforge>()
             .map { it.id.key }
             .containsIgnoreCase(config.getString("reforge"))
     }

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/reforges/Reforge.kt

@@ -11,12 +11,16 @@ import com.willfp.eco.core.recipe.Recipes
 import com.willfp.eco.core.registry.Registrable
 import com.willfp.eco.util.StringUtils
 import com.willfp.libreforge.Holder
+import com.willfp.libreforge.ItemProvidedHolder
 import com.willfp.libreforge.ViolationContext
 import com.willfp.libreforge.conditions.Conditions
 import com.willfp.libreforge.effects.Effects
+import com.willfp.libreforge.toDispatcher
+import com.willfp.libreforge.triggers.TriggerData
 import com.willfp.reforges.ReforgesPlugin
 import com.willfp.reforges.util.reforgeStone
 import net.kyori.adventure.text.format.TextDecoration
+import org.bukkit.entity.Player
 import org.bukkit.inventory.ItemStack
 import java.util.Objects
 
@@ -30,7 +34,7 @@ class Reforge(
 
     val namePrefixComponent = StringUtils.toComponent("$name ").decoration(TextDecoration.ITALIC, false)
 
-    val description: List<String> = config.getFormattedStrings("description")
+    val description: List<String> = config.getStrings("description")
 
     val targets = config.getStrings("targets").mapNotNull { ReforgeTargets.getByName(it) }.toSet()
 
@@ -73,12 +77,17 @@ class Reforge(
         }
     } else null
 
+    private val onReforgeEffects = Effects.compileChain(
+        config.getSubsections("on-reforge-effects"),
+        ViolationContext(plugin, "Reforge $id").with("on-reforge-effects")
+    )
+
     init {
         stone.reforgeStone = this
 
         if (config.getBool("stone.enabled")) {
             CustomItem(
-                plugin.namespacedKeyFactory.create("stone_" + this.id),
+                plugin.namespacedKeyFactory.create("stone_" + this.id.key),
                 { test -> test.reforgeStone == this },
                 stone
             ).register()
@@ -98,6 +107,16 @@ class Reforge(
         return targets.any { target -> target.items.any { it.matches(item) } }
     }
 
+    fun runOnReforgeEffects(player: Player, item: ItemStack) {
+        onReforgeEffects?.trigger(
+            player.toDispatcher(),
+            TriggerData(
+                player = player,
+                item = item
+            )
+        )
+    }
+
     override fun getID(): String {
         return this.id.key
     }

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/reforges/ReforgeFinder.kt

@@ -0,0 +1,16 @@
+package com.willfp.reforges.reforges
+
+import com.willfp.libreforge.slot.ItemHolderFinder
+import com.willfp.libreforge.slot.SlotType
+import com.willfp.reforges.util.reforge
+import org.bukkit.inventory.ItemStack
+
+object ReforgeFinder : ItemHolderFinder<Reforge>() {
+    override fun find(item: ItemStack): List<Reforge> {
+        return listOfNotNull(item.reforge)
+    }
+
+    override fun isValidInSlot(holder: Reforge, slot: SlotType): Boolean {
+        return slot in holder.targets.map { it.slot }.toSet()
+    }
+}

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/reforges/ReforgeTarget.kt

@@ -2,12 +2,13 @@ package com.willfp.reforges.reforges
 
 import com.willfp.eco.core.items.TestableItem
 import com.willfp.eco.core.recipe.parts.EmptyTestableItem
+import com.willfp.libreforge.slot.SlotType
 import org.bukkit.inventory.ItemStack
-import java.util.*
+import java.util.Objects
 
 class ReforgeTarget(
     val id: String,
-    val slot: Slot,
+    val slot: SlotType,
     val items: MutableSet<TestableItem>
 ) {
     init {
@@ -34,10 +35,4 @@ class ReforgeTarget(
     override fun hashCode(): Int {
         return Objects.hash(this.id)
     }
-
-    enum class Slot {
-        HANDS,
-        ARMOR,
-        ANY
-    }
 }

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/reforges/ReforgeTargets.kt

@@ -2,13 +2,14 @@ package com.willfp.reforges.reforges
 
 import com.google.common.collect.ImmutableSet
 import com.willfp.eco.core.config.updating.ConfigUpdater
+import com.willfp.libreforge.slot.impl.SlotTypeAny
 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())
+    val ALL = ReforgeTarget("all", SlotTypeAny, HashSet())
 
     init {
         registered["all"] = ALL

eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/util/ReforgeLookup.kt

@@ -1,107 +0,0 @@
-package com.willfp.reforges.util
-
-import com.github.benmanes.caffeine.cache.Caffeine
-import com.willfp.libreforge.ItemProvidedHolder
-import com.willfp.reforges.ReforgesPlugin
-import com.willfp.reforges.reforges.ReforgeTarget
-import org.bukkit.entity.Player
-import org.bukkit.inventory.ItemStack
-import java.util.concurrent.TimeUnit
-
-typealias SlotProvider = (Player) -> Map<ItemStack?, ReforgeTarget.Slot?>
-
-object ReforgeLookup {
-    private val plugin = ReforgesPlugin.instance
-    private val slotProviders = mutableSetOf<(Player) -> Map<ItemStack, ReforgeTarget.Slot>>()
-
-    private val itemCache = Caffeine.newBuilder()
-        .expireAfterWrite(2, TimeUnit.SECONDS)
-        .build<Player, Map<ItemStack, ReforgeTarget.Slot>>()
-
-    private val reforgeCache = Caffeine.newBuilder()
-        .expireAfterWrite(2, TimeUnit.SECONDS)
-        .build<Player, Collection<ItemProvidedHolder>>()
-
-    @JvmStatic
-    fun registerProvider(provider: SlotProvider) {
-        slotProviders.add {
-            val found = mutableMapOf<ItemStack, ReforgeTarget.Slot>()
-            for ((item, slot) in provider(it)) {
-                if (item != null && slot != null) {
-                    found[item] = slot
-                }
-            }
-            found
-        }
-    }
-
-    private fun provide(player: Player): Map<ItemStack, ReforgeTarget.Slot> {
-        return itemCache.get(player) {
-            val found = mutableMapOf<ItemStack, ReforgeTarget.Slot>()
-            for (provider in slotProviders) {
-                found.putAll(provider(player))
-            }
-
-            found
-        }
-    }
-
-    fun provideReforges(player: Player): List<ItemProvidedHolder> {
-        return reforgeCache.get(player) {
-            val found = mutableListOf<ItemProvidedHolder>()
-
-            for ((itemStack, slot) in provide(player)) {
-                val reforge = itemStack.reforge ?: continue
-                if (slot != ReforgeTarget.Slot.ANY) {
-                    if (!reforge.targets.map { it.slot }.contains(slot)) {
-                        continue
-                    }
-                }
-                found.add(
-                    ItemProvidedHolder(
-                        reforge,
-                        itemStack
-                    )
-                )
-            }
-
-            found
-        }.toList()
-    }
-
-    fun clearCache(player: Player) {
-        itemCache.invalidate(player)
-        reforgeCache.invalidate(player)
-    }
-
-    init {
-        registerProvider {
-            mapOf(
-                Pair(
-                    it.inventory.itemInMainHand,
-                    ReforgeTarget.Slot.HANDS
-                )
-            )
-        }
-
-        if (!plugin.configYml.getBool("no-offhand")) {
-            registerProvider {
-                mapOf(
-                    Pair(
-                        it.inventory.itemInOffHand,
-                        ReforgeTarget.Slot.HANDS
-                    )
-                )
-            }
-        }
-
-
-        registerProvider {
-            val items = mutableMapOf<ItemStack?, ReforgeTarget.Slot?>()
-            for (stack in it.inventory.armorContents) {
-                items[stack] = ReforgeTarget.Slot.ARMOR
-            }
-            items
-        }
-    }
-}

eco-core/core-plugin/src/main/resources/config.yml

@@ -146,12 +146,11 @@ reforge:
   reforgable-suffix:
     - ""
     - "&8This item can be reforged!"
-  no-reforgable-in-gui: true # Not perfect, won't work 100% of the time
-  # due to how GUIs are handled differently in different plugins, but should help.
 
   display-in-lore: true
   display-in-name: true
 
+  # The lore to display if an item is reforged, above the reforge description
   reforged-prefix:
     - ""
     - "%reforge%"

eco-core/core-plugin/src/main/resources/paper-plugin.yml

@@ -1,58 +0,0 @@
-name: ${pluginName}
-version: ${version}
-main: com.willfp.reforges.ReforgesPlugin
-api-version: 1.19
-
-dependencies:
-  - name: eco
-    required: true
-    bootstrap: false
-
-  - name: libreforge
-    required: false
-    bootstrap: false
-
-  - name: Talismans
-    required: false
-    bootstrap: false
-
-load-after:
-  - name: eco
-    bootstrap: false
-
-
-permissions:
-  reforges.*:
-    description: All reforges permissions
-    default: op
-    children:
-      reforges.command.*: true
-  reforges.command.*:
-    description: All commands
-    default: op
-    children:
-      reforges.command.reload: true
-      reforges.command.reforges: true
-      reforges.command.reforge: true
-      reforges.command.give: true
-      reforges.command.apply: true
-      reforges.command.open: true
-
-  reforges.command.reload:
-    description: Allows reloading the config
-    default: op
-  reforges.command.reforges:
-    description: Allows the user of /reforges.
-    default: true
-  reforges.command.reforge:
-    description: Allows the user of /reforge.
-    default: true
-  reforges.command.give:
-    description: Allows the user of /reforges give.
-    default: op
-  reforges.command.open:
-    description: Allows the user of /reforges open.
-    default: op
-  reforges.command.apply:
-    description: Allows the user of /reforges apply.
-    default: op

eco-core/core-plugin/src/main/resources/plugin.yml

@@ -8,7 +8,6 @@ depend:
   - eco
 softdepend:
   - libreforge
-  - Talismans
 
 commands:
   reforges:

eco-core/core-plugin/src/main/resources/reforges/_example.yml

@@ -54,3 +54,6 @@ effects:
 
 # The conditions required to use the reforge
 conditions: [ ]
+
+# Effects to run when the reforge is applied to an item.
+on-reforge-effects: [ ]

eco-core/core-plugin/src/main/resources/target.yml

@@ -1,11 +1,10 @@
 #
 # A target consists of items and a slot.
-# The slot is either hands, armor, or any.
-# Hands means the reforge will activate on hands, armor
-# means it will only work on armor, and any
-# means it will activate whenever its on the player.
 #
 
+# The options for slot are mainhand, offhand, hands, helmet, chestplate,
+# leggings, boots, armor, any, a number from 0-40 (to specify an exact slot),
+# or a list of slots like "9, 10, 11, mainhand"
 
 pickaxe:
   slot: hands

gradle.properties

@@ -1,5 +1,5 @@
 #libreforge-updater
-#Thu Aug 10 19:59:51 BST 2023
+#Tue Jan 16 13:28:38 GMT 2024
 kotlin.code.style=official
-libreforge-version=4.28.0
+libreforge-version=4.55.1
-version=6.27.0
+version=6.54.2