Enchantment scripts back-support

dist/pom.xml

@@ -161,10 +161,6 @@
                                     <pattern>org.objectweb</pattern>
                                     <shadedPattern>com.denizenscript.shaded.org.objectweb</shadedPattern>
                                 </relocation>
-                                <relocation>
-                                    <pattern>org.apache</pattern>
-                                    <shadedPattern>com.denizenscript.shaded.org.apache</shadedPattern>
-                                </relocation>
                                 <relocation>
                                     <pattern>net.kyori.option</pattern>
                                     <shadedPattern>com.denizenscript.shaded.net.kyori.option</shadedPattern>

plugin/src/main/java/com/denizenscript/denizen/nms/interfaces/EnchantmentHelper.java

@@ -1,9 +1,27 @@
 package com.denizenscript.denizen.nms.interfaces;
 
+import com.denizenscript.denizen.Denizen;
 import com.denizenscript.denizen.scripts.containers.core.EnchantmentScriptContainer;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
 import org.bukkit.enchantments.Enchantment;
 import org.bukkit.entity.Entity;
+import org.bukkit.entity.HumanEntity;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.EntityDamageByEntityEvent;
 import org.bukkit.event.entity.EntityDamageEvent;
+import org.bukkit.event.inventory.InventoryEvent;
+import org.bukkit.event.inventory.PrepareAnvilEvent;
+import org.bukkit.event.inventory.PrepareGrindstoneEvent;
+import org.bukkit.inventory.EntityEquipment;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+
+import java.util.Map;
 
 public class EnchantmentHelper {
 
@@ -46,4 +64,128 @@ public float getDamageBonus(Enchantment enchantment, int level, String type) {
     public int getDamageProtection(Enchantment enchantment, int level, EntityDamageEvent.DamageCause type, Entity attacker) {
         throw new UnsupportedOperationException();
     }
+
+    public boolean eventsRegistered = false;
+
+    public void verifyEventsRegistered() {
+        if (eventsRegistered) {
+            return;
+        }
+        Bukkit.getPluginManager().registerEvents(new EnchantmentBackSupportEvents(), Denizen.getInstance());
+        eventsRegistered = true;
+    }
+
+    static class EnchantmentBackSupportEvents implements Listener {
+
+        @EventHandler
+        public void on(PrepareGrindstoneEvent event) {
+            for (ItemStack input : event.getInventory().getContents()) {
+                if (trySendingInventoryUpdate(input, event)) {
+                    break;
+                }
+            }
+        }
+
+        @EventHandler
+        public void on(PrepareAnvilEvent event) {
+            trySendingInventoryUpdate(event.getResult(), event);
+        }
+
+        public static boolean trySendingInventoryUpdate(ItemStack item, InventoryEvent event) {
+            if (item == null || item.getType() == Material.AIR) {
+                return false;
+            }
+            ItemMeta itemMeta = item.getItemMeta();
+            if (itemMeta == null || !itemMeta.hasEnchants()) {
+                return false;
+            }
+            for (Enchantment enchantment : itemMeta.getEnchants().keySet()) {
+                if (EnchantmentScriptContainer.getScriptFromEnchantment(enchantment) != null) {
+                    Bukkit.getScheduler().runTaskLater(Denizen.getInstance(), () -> {
+                        for (HumanEntity viewer : event.getViewers()) {
+                            if (viewer instanceof Player player) {
+                                player.updateInventory();
+                            }
+                        }
+                    }, 1);
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        @EventHandler(priority = EventPriority.MONITOR)
+        public void on(EntityDamageByEntityEvent event) {
+            if (event.getDamager() instanceof LivingEntity attacker && attacker.getEquipment() != null) {
+                EntityEquipment equipment = attacker.getEquipment();
+                processEnchantmentScripts(equipment.getItemInMainHand(), event, EnchantmentScriptContainer::doPostAttack);
+                processEnchantmentScripts(equipment.getItemInOffHand(), event, EnchantmentScriptContainer::doPostAttack);
+            }
+            if (event.getEntity() instanceof LivingEntity attacked && attacked.getEquipment() != null) {
+                EntityEquipment equipment = attacked.getEquipment();
+                processEnchantmentScripts(equipment.getItemInMainHand(), event, EnchantmentScriptContainer::doPostHurt);
+                processEnchantmentScripts(equipment.getItemInOffHand(), event, EnchantmentScriptContainer::doPostHurt);
+                processEnchantmentScripts(equipment.getHelmet(), event, EnchantmentScriptContainer::doPostHurt);
+                processEnchantmentScripts(equipment.getChestplate(), event, EnchantmentScriptContainer::doPostHurt);
+                processEnchantmentScripts(equipment.getLeggings(), event, EnchantmentScriptContainer::doPostHurt);
+                processEnchantmentScripts(equipment.getBoots(), event, EnchantmentScriptContainer::doPostHurt);
+            }
+        }
+
+        @FunctionalInterface
+        public interface EnchantmentSubScriptRunner {
+            void runSubScript(EnchantmentScriptContainer enchantmentScript, Entity attacker, Entity victim, int level);
+        }
+
+        public static void processEnchantmentScripts(ItemStack item, EntityDamageByEntityEvent event, EnchantmentSubScriptRunner subScriptRunner) {
+            if (item == null || item.getType() == Material.AIR) {
+                return;
+            }
+            ItemMeta itemMeta = item.getItemMeta();
+            if (itemMeta == null || !itemMeta.hasEnchants()) {
+                return;
+            }
+            for (Map.Entry<Enchantment, Integer> entry : itemMeta.getEnchants().entrySet()) {
+                EnchantmentScriptContainer enchantmentScript = EnchantmentScriptContainer.getScriptFromEnchantment(entry.getKey());
+                if (enchantmentScript != null) {
+                    subScriptRunner.runSubScript(enchantmentScript, event.getDamager(), event.getEntity(), entry.getValue());
+                }
+            }
+        }
+    }
+
+    public enum Rarity {
+        COMMON(10, 1),
+        UNCOMMON(5, 2),
+        RARE(2, 4),
+        VERY_RARE(1, 8);
+
+        final int weight, anvilCost;
+
+        Rarity(int weight, int anvilCost) {
+            this.weight = weight;
+            this.anvilCost = anvilCost;
+        }
+
+        public int getWeight() {
+            return weight;
+        }
+
+        public int getAnvilCost() {
+            return anvilCost;
+        }
+
+        public static Rarity fromWeight(int weight) {
+            int smallestDistance = Integer.MAX_VALUE;
+            Rarity closest = null;
+            for (Rarity rarity : Rarity.values()) {
+                int distance = Math.abs(weight - rarity.getWeight());
+                if (distance < smallestDistance) {
+                    smallestDistance = distance;
+                    closest = rarity;
+                }
+            }
+            return closest;
+        }
+    }
 }

plugin/src/main/java/com/denizenscript/denizen/scripts/containers/ContainerRegistry.java

@@ -1,5 +1,7 @@
 package com.denizenscript.denizen.scripts.containers;
 
+import com.denizenscript.denizen.nms.NMSHandler;
+import com.denizenscript.denizen.nms.NMSVersion;
 import com.denizenscript.denizen.scripts.containers.core.*;
 import com.denizenscript.denizen.utilities.depends.Depends;
 import com.denizenscript.denizencore.scripts.ScriptRegistry;
@@ -13,7 +15,9 @@ public static void registerMainContainers() {
         if (Depends.vault != null) {
             ScriptRegistry._registerType("economy", EconomyScriptContainer.class);
         }
-        ScriptRegistry._registerType("enchantment", EnchantmentScriptContainer.class);
+        if (NMSHandler.getVersion().isAtMost(NMSVersion.v1_19) || Depends.denizenEnchantmentFix != null) {
+            ScriptRegistry._registerType("enchantment", EnchantmentScriptContainer.class);
+        }
         ScriptRegistry._registerType("entity", EntityScriptContainer.class);
         ScriptRegistry._registerType("format", FormatScriptContainer.class);
         ScriptRegistry._registerType("interact", InteractScriptContainer.class);

plugin/src/main/java/com/denizenscript/denizen/scripts/containers/core/EnchantmentScriptContainer.java

@@ -1,11 +1,13 @@
 package com.denizenscript.denizen.scripts.containers.core;
 
+import com.denizenscript.denizen.Denizen;
 import com.denizenscript.denizen.nms.NMSHandler;
+import com.denizenscript.denizen.nms.NMSVersion;
 import com.denizenscript.denizen.objects.EntityTag;
 import com.denizenscript.denizen.objects.ItemTag;
 import com.denizenscript.denizen.tags.BukkitTagContext;
+import com.denizenscript.denizen.utilities.BukkitImplDeprecations;
 import com.denizenscript.denizen.utilities.FormattedTextHelper;
-import com.denizenscript.denizencore.utilities.debugging.Debug;
 import com.denizenscript.denizen.utilities.implementation.BukkitScriptEntryData;
 import com.denizenscript.denizencore.objects.core.ElementTag;
 import com.denizenscript.denizencore.objects.core.ScriptTag;
@@ -18,15 +20,19 @@
 import com.denizenscript.denizencore.utilities.AsciiMatcher;
 import com.denizenscript.denizencore.utilities.CoreUtilities;
 import com.denizenscript.denizencore.utilities.YamlConfiguration;
+import com.denizenscript.denizencore.utilities.debugging.Debug;
 import net.md_5.bungee.api.ChatColor;
 import net.md_5.bungee.api.chat.BaseComponent;
 import org.bukkit.Bukkit;
+import org.bukkit.NamespacedKey;
 import org.bukkit.enchantments.Enchantment;
 import org.bukkit.entity.Entity;
 import org.bukkit.inventory.ItemStack;
 
 import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
 
 public class EnchantmentScriptContainer extends ScriptContainer {
 
@@ -172,12 +178,21 @@ public class EnchantmentScriptContainer extends ScriptContainer {
     // -->
     public static AsciiMatcher descriptionCharsAllowed = new AsciiMatcher(AsciiMatcher.LETTERS_LOWER + "_");
 
-    public static HashMap<String, EnchantmentReference> registeredEnchantmentContainers = new HashMap<>();
+    public static Map<String, EnchantmentReference> registeredEnchantmentContainers = new ConcurrentHashMap<>();
 
     public static class EnchantmentReference {
         public EnchantmentScriptContainer script;
     }
 
+    public static EnchantmentScriptContainer getScriptFromEnchantment(Enchantment enchantment) {
+        NamespacedKey key = enchantment.getKey();
+        if (!key.getNamespace().equals("denizen")) {
+            return null;
+        }
+        EnchantmentReference reference = registeredEnchantmentContainers.get(key.getKey());
+        return reference != null ? reference.script : null;
+    }
+
     public EnchantmentScriptContainer(YamlConfiguration configurationSection, String scriptContainerName) {
         super(configurationSection, scriptContainerName);
         canRunScripts = false;
@@ -215,6 +230,9 @@ public EnchantmentScriptContainer(YamlConfiguration configurationSection, String
                 enchantment = old.enchantment;
             }
         }
+        if (NMSHandler.getVersion().isAtLeast(NMSVersion.v1_20)) {
+            BukkitImplDeprecations.enchantmentScriptContainers.warn(this);
+        }
     }
 
     public int minLevel, maxLevel;
@@ -335,7 +353,7 @@ public void doPostAttack(Entity attacker, Entity victim, int level) {
         runSubScript("after attack", attacker, victim, attacker, level);
     }
 
-    public void doPostHurt(Entity victim, Entity attacker, int level) {
+    public void doPostHurt(Entity attacker, Entity victim, int level) {
         runSubScript("after hurt", attacker, victim, victim, level);
     }
 
@@ -360,4 +378,8 @@ public int getMaxCost(int level) {
         maxCosts.put(level, cost);
         return cost;
     }
+
+    public NamespacedKey getKey() {
+        return new NamespacedKey(Denizen.getInstance(), id);
+    }
 }

plugin/src/main/java/com/denizenscript/denizen/utilities/BukkitImplDeprecations.java

@@ -355,6 +355,9 @@ public class BukkitImplDeprecations {
     // Bump once 1.21 is the minimum supported version (as that is where boat types were split)
     public static Warning gettingBoatType = new SlowWarning("gettingBoatType", "Getting boat wood types is deprecated, as separate boat types are separate entity types now: should check the entity type.");
 
+    // Added 2025/06/28
+    public static Warning enchantmentScriptContainers = new SlowWarning("enchantmentScriptContainers", "Enchantment script containers are deprecated due to extensive internal changes. We recommend utilizing datapacks (which also make the enchantments show up on the client like vanilla ones), see https://misode.github.io/enchantment.");
+
     // Added 2025/07/11
     public static Warning assignmentOptionalPrefixArgs = new SlowWarning("assignmentOptionalPrefixArgs", "Deprecated usage of optional prefixes 'script' or 'to' in favor of just using proper prefixes (refer to documentation).");
 

plugin/src/main/java/com/denizenscript/denizen/utilities/depends/Depends.java

@@ -20,11 +20,13 @@ public class Depends {
     public static Permission permissions = null;
     public static Chat chat = null;
     public static Plugin vault = null;
+    public static Plugin denizenEnchantmentFix = null;
 
     public static void initialize() {
         setupBungee();
         setupVault();
         setupCitizens();
+        setupEnchantmentFix();
     }
 
     public static void setupVault() {
@@ -99,4 +101,13 @@ public static boolean setupCitizens() {
         }
         return citizens != null;
     }
+
+    public static boolean setupEnchantmentFix() {
+        Plugin plugin = Bukkit.getServer().getPluginManager().getPlugin("DenizenEnchantmentFix");
+        if (plugin == null || !plugin.isEnabled()) {
+            return false;
+        }
+        denizenEnchantmentFix = plugin;
+        return true;
+    }
 }

v1_17/src/main/java/com/denizenscript/denizen/nms/v1_17/helpers/EnchantmentHelperImpl.java

@@ -104,7 +104,7 @@ public void doPostAttack(LivingEntity attacker, Entity victim, int level) {
                 }
                 @Override
                 public void doPostHurt(LivingEntity victim, Entity attacker, int level) {
-                    script.script.doPostHurt(victim.getBukkitEntity(), attacker.getBukkitEntity(), level);
+                    script.script.doPostHurt(attacker.getBukkitEntity(), victim.getBukkitEntity(), level);
                 }
                 @Override
                 public boolean isTreasureOnly() {

v1_18/src/main/java/com/denizenscript/denizen/nms/v1_18/helpers/EnchantmentHelperImpl.java

@@ -108,7 +108,7 @@ public void doPostAttack(LivingEntity attacker, Entity victim, int level) {
                 }
                 @Override
                 public void doPostHurt(LivingEntity victim, Entity attacker, int level) {
-                    script.script.doPostHurt(victim.getBukkitEntity(), attacker.getBukkitEntity(), level);
+                    script.script.doPostHurt(attacker.getBukkitEntity(), victim.getBukkitEntity(), level);
                 }
                 @Override
                 public boolean isTreasureOnly() {

v1_19/src/main/java/com/denizenscript/denizen/nms/v1_19/helpers/EnchantmentHelperImpl.java

@@ -110,7 +110,7 @@ public void doPostAttack(LivingEntity attacker, Entity victim, int level) {
                 }
                 @Override
                 public void doPostHurt(LivingEntity victim, Entity attacker, int level) {
-                    script.script.doPostHurt(victim.getBukkitEntity(), attacker.getBukkitEntity(), level);
+                    script.script.doPostHurt(attacker.getBukkitEntity(), victim.getBukkitEntity(), level);
                 }
                 @Override
                 public boolean isTreasureOnly() {