Compatibility with Excellent Enchants V5 (#66)

build.gradle.kts

@@ -46,7 +46,8 @@ dependencies {
 
     // ExcellentEnchants
     compileOnly(files("libs/nightcore-2.7.3.jar"))
-    compileOnly(files("libs/ExcellentEnchants-4.3.1.jar"))
+    compileOnly(files("libs/ExcellentEnchants-5.0.0.jar"))
+    compileOnly(files("libs/ExcellentEnchants-4.3.1.jar")) // For legacy excellent enchants (can/should be stripped)
     compileOnly(files("libs/ExcellentEnchants 4.1.0-striped.jar")) // For legacy excellent enchants
 
     // Disenchantment

src/main/java/xyz/alexcrea/cuanvil/enchant/wrapped/CAEEPreV5Enchantment.java

@@ -12,15 +12,15 @@ import xyz.alexcrea.cuanvil.enchant.EnchantmentRarity;
 import java.util.Map;
 import java.util.Set;
 
-public class CAEEEnchantment extends CABukkitEnchantment implements AdditionalTestEnchantment {
+public class CAEEPreV5Enchantment extends CABukkitEnchantment implements AdditionalTestEnchantment {
 
     @NotNull CustomEnchantment eeenchantment;
     @NotNull Definition definition;
 
-    public CAEEEnchantment(@NotNull CustomEnchantment enchantment) {
+    public CAEEPreV5Enchantment(@NotNull CustomEnchantment enchantment) {
         super(enchantment.getBukkitEnchantment(), EnchantmentRarity.getRarity(enchantment.getDefinition().getAnvilCost()));
         this.eeenchantment = enchantment;
-        this.definition = enchantment.getDefinition();
+        this.definition = (Definition) enchantment.getDefinition();
 
     }
 

src/main/java/xyz/alexcrea/cuanvil/enchant/wrapped/CAEEV5Enchantment.java

@@ -0,0 +1,45 @@
+package xyz.alexcrea.cuanvil.enchant.wrapped;
+
+import org.bukkit.Material;
+import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
+import su.nightexpress.excellentenchants.api.enchantment.CustomEnchantment;
+import su.nightexpress.excellentenchants.api.wrapper.EnchantDefinition;
+import xyz.alexcrea.cuanvil.enchant.AdditionalTestEnchantment;
+import xyz.alexcrea.cuanvil.enchant.CAEnchantment;
+import xyz.alexcrea.cuanvil.enchant.EnchantmentRarity;
+
+import java.util.Map;
+import java.util.Set;
+
+public class CAEEV5Enchantment extends CABukkitEnchantment implements AdditionalTestEnchantment {
+
+    @NotNull CustomEnchantment eeenchantment;
+    @NotNull EnchantDefinition definition;
+
+    public CAEEV5Enchantment(@NotNull CustomEnchantment enchantment) {
+        super(enchantment.getBukkitEnchantment(), EnchantmentRarity.getRarity(enchantment.getDefinition().getAnvilCost()));
+        this.eeenchantment = enchantment;
+        this.definition = enchantment.getDefinition();
+
+    }
+
+    @Override
+    public boolean isEnchantConflict(@NotNull Map<CAEnchantment, Integer> enchantments, @NotNull Material itemMat) {
+        if (!definition.hasConflicts()) return false;
+
+        Set<String> conflicts = definition.getExclusiveSet();
+
+        for (CAEnchantment caEnchantment : enchantments.keySet()) {
+            if (conflicts.contains(caEnchantment.getName())) return true;
+        }
+
+        return false;
+    }
+
+    @Override
+    public boolean isItemConflict(@NotNull Map<CAEnchantment, Integer> enchantments, @NotNull Material itemMat, @NotNull ItemStack item) {
+        return false;
+    }
+
+}

src/main/kotlin/xyz/alexcrea/cuanvil/dependency/plugins/ExcellentEnchantsDependency.kt

@@ -7,55 +7,98 @@ import org.bukkit.event.inventory.InventoryClickEvent
 import org.bukkit.event.inventory.PrepareAnvilEvent
 import org.bukkit.inventory.ItemStack
 import org.bukkit.plugin.RegisteredListener
-import su.nightexpress.excellentenchants.enchantment.impl.universal.CurseOfFragilityEnchant
-import su.nightexpress.excellentenchants.enchantment.listener.AnvilListener
-import su.nightexpress.excellentenchants.enchantment.listener.EnchantAnvilListener
-import su.nightexpress.excellentenchants.registry.EnchantRegistry
 import xyz.alexcrea.cuanvil.api.EnchantmentApi
-import xyz.alexcrea.cuanvil.enchant.wrapped.CAEEEnchantment
+import xyz.alexcrea.cuanvil.enchant.wrapped.CAEEPreV5Enchantment
+import xyz.alexcrea.cuanvil.enchant.wrapped.CAEEV5Enchantment
 import xyz.alexcrea.cuanvil.enchant.wrapped.CALegacyEEEnchantment
 import java.lang.reflect.Method
+import su.nightexpress.excellentenchants.api.EnchantRegistry as V5EnchantRegistry
+import su.nightexpress.excellentenchants.enchantment.impl.universal.CurseOfFragilityEnchant as LegacyCurseOfFragilityEnchant
+import su.nightexpress.excellentenchants.manager.listener.AnvilListener as V5AnvilListener
+import su.nightexpress.excellentenchants.enchantment.listener.AnvilListener as PreV5AnvilListener
+import su.nightexpress.excellentenchants.enchantment.listener.EnchantAnvilListener as LegacyAnvilListener
+import su.nightexpress.excellentenchants.enchantment.registry.EnchantRegistry as LegacyEnchantRegistry
+import su.nightexpress.excellentenchants.registry.EnchantRegistry as PreV5EnchantRegistry
 
+// I don't like that I need to support older version. if I could just drop older support it would be sooo nice
 class ExcellentEnchantsDependency {
 
-    private val isModern: Boolean
+    enum class ListenerVersion(val classPath: String) {
+        V5("su.nightexpress.excellentenchants.manager.listener.AnvilListener"),
+        PRE_V5("su.nightexpress.excellentenchants.enchantment.listener.AnvilListener"),
+        LEGACY("su.nightexpress.excellentenchants.enchantment.listener.EnchantAnvilListener"),
+    }
+
+    private val listenerVersion: ListenerVersion?
+    private val isModernCurseOfFragility: Boolean
 
     init {
         CustomAnvil.instance.logger.info("Excellent Enchants Detected !")
 
-        var isModern = true;
+        var listenerVersion: ListenerVersion? = null
-        try {
+        for (value in ListenerVersion.entries) {
-            Class.forName("su.nightexpress.excellentenchants.enchantment.listener.AnvilListener")
+            try {
-        } catch (ignored: ClassNotFoundException) {
+                Class.forName(value.classPath)
-            isModern = false
+
+                listenerVersion = value
+                break
+            } catch (ignored: ClassNotFoundException) {
+            }
         }
 
-        this.isModern = isModern
+        if(listenerVersion == null){
+            CustomAnvil.instance.logger.severe("Found issue with listener of Excellent Enchants. compatiblity is broken. please contact CustomAnvil devs")
+        }
+
+        var isModernCurseOfFragility = true
+        try {
+            Class.forName("su.nightexpress.excellentenchants.enchantment.universal.CurseOfFragilityEnchant")
+        } catch (ignored: ClassNotFoundException) {
+            isModernCurseOfFragility = false
+        }
+
+        this.listenerVersion = listenerVersion
+        this.isModernCurseOfFragility = isModernCurseOfFragility
     }
 
     fun registerEnchantments() {
         CustomAnvil.instance.logger.info("Preparing Excellent Enchants compatibility...")
 
         // As excellent enchants is loaded before custom anvil and register enchantment to registry, we need to unregister old "vanilla" enchant.
-        if (this.isModern) {
+        when (listenerVersion) {
-            for (enchantment in EnchantRegistry.getRegistered()) {
+            ListenerVersion.V5 -> {
-                EnchantmentApi.unregisterEnchantment(enchantment.bukkitEnchantment.key)
+                for (enchantment in V5EnchantRegistry.getRegistered()) {
-                EnchantmentApi.registerEnchantment(CAEEEnchantment(enchantment))
+                    EnchantmentApi.unregisterEnchantment(enchantment.bukkitEnchantment.key)
+                    EnchantmentApi.registerEnchantment(CAEEV5Enchantment(enchantment))
+                }
             }
-        } else {
+
-            for (enchantment in su.nightexpress.excellentenchants.enchantment.registry.EnchantRegistry.getRegistered()) {
+            ListenerVersion.PRE_V5 -> {
-                EnchantmentApi.unregisterEnchantment(enchantment.enchantment.key)
+                for (enchantment in PreV5EnchantRegistry.getRegistered()) {
-                EnchantmentApi.registerEnchantment(CALegacyEEEnchantment(enchantment))
+                    EnchantmentApi.unregisterEnchantment(enchantment.bukkitEnchantment.key)
+                    EnchantmentApi.registerEnchantment(CAEEPreV5Enchantment(enchantment))
+                }
             }
+
+            ListenerVersion.LEGACY -> {
+                for (enchantment in LegacyEnchantRegistry.getRegistered()) {
+                    EnchantmentApi.unregisterEnchantment(enchantment.enchantment.key)
+                    EnchantmentApi.registerEnchantment(CALegacyEEEnchantment(enchantment))
+                }
+            }
+
+            null -> return
+
         }
 
         CustomAnvil.instance.logger.info("Excellent Enchants should now work as expected !")
     }
 
-    private var fragilityCurse: CurseOfFragilityEnchant? = null
+    private var legacyFragilityCurse: LegacyCurseOfFragilityEnchant? = null
 
-    private var modernAnvilListener: AnvilListener? = null
+    private var v5AnvilListener: V5AnvilListener? = null
-    private var legacyAnvilListener: EnchantAnvilListener? = null
+    private var preV5AnvilListener: PreV5AnvilListener? = null
+    private var legacyAnvilListener: LegacyAnvilListener? = null
     private lateinit var usedAnvilListener: Listener
 
     private lateinit var handleRechargeMethod: Method
@@ -67,21 +110,34 @@ class ExcellentEnchantsDependency {
         for (registeredListener in PrepareAnvilEvent.getHandlerList().registeredListeners) {
             val listener = registeredListener.listener
 
-            if (listener is CurseOfFragilityEnchant) {
+            if (!isModernCurseOfFragility) {
-                this.fragilityCurse = listener
+                if (listener is LegacyCurseOfFragilityEnchant) {
-                toUnregister.add(registeredListener)
+                    this.legacyFragilityCurse = listener
+                    toUnregister.add(registeredListener)
+                }
             }
 
-            if (this.isModern) {
+            when (listenerVersion) {
-                if (listener is AnvilListener) {
+                ListenerVersion.V5 -> {
-                    this.modernAnvilListener = listener;
+                    if (listener is V5AnvilListener) {
-                    toUnregister.add(registeredListener)
+                        this.v5AnvilListener = listener
+                        toUnregister.add(registeredListener)
+                    }
                 }
-            } else {
+                ListenerVersion.PRE_V5 -> {
-                if (listener is EnchantAnvilListener) {
+                    if (listener is PreV5AnvilListener) {
-                    this.legacyAnvilListener = listener;
+                        this.preV5AnvilListener = listener
-                    toUnregister.add(registeredListener)
+                        toUnregister.add(registeredListener)
+                    }
                 }
+                ListenerVersion.LEGACY -> {
+                    if (listener is LegacyAnvilListener) {
+                        this.legacyAnvilListener = listener
+                        toUnregister.add(registeredListener)
+                    }
+                }
+                null -> {
+                    }
             }
 
         }
@@ -90,10 +146,11 @@ class ExcellentEnchantsDependency {
             PrepareAnvilEvent.getHandlerList().unregister(listener)
         }
 
-        if (this.isModern) {
+        when (listenerVersion) {
-            this.usedAnvilListener = this.modernAnvilListener!!
+            ListenerVersion.V5 -> this.usedAnvilListener = v5AnvilListener!!
-        } else {
+            ListenerVersion.PRE_V5 -> this.usedAnvilListener = preV5AnvilListener!!
-            this.usedAnvilListener = this.legacyAnvilListener!!
+            ListenerVersion.LEGACY -> this.usedAnvilListener = legacyAnvilListener!!
+            null -> {}
         }
 
         // Unregister inventory click event
@@ -119,7 +176,9 @@ class ExcellentEnchantsDependency {
 
     fun testPrepareAnvil(event: PrepareAnvilEvent): Boolean {
         if (event.result != null) {
-            this.fragilityCurse?.onItemAnvil(event)
+            if (!isModernCurseOfFragility) {
+                this.legacyFragilityCurse?.onItemAnvil(event)
+            }
             if (event.result == null) return true
         }
 
@@ -138,10 +197,11 @@ class ExcellentEnchantsDependency {
 
     fun testAnvilResult(event: InventoryClickEvent): Any {
         if (event.inventory.getItem(2) != null) {
-            if (this.isModern) {
+            when (listenerVersion) {
-                this.modernAnvilListener!!.onClickAnvil(event)
+                ListenerVersion.V5 -> v5AnvilListener!!.onClickAnvil(event)
-            } else {
+                ListenerVersion.PRE_V5 -> preV5AnvilListener!!.onClickAnvil(event)
-                this.legacyAnvilListener!!.onClickAnvil(event)
+                ListenerVersion.LEGACY -> legacyAnvilListener!!.onClickAnvil(event)
+                null -> {}
             }
             return event.inventory.getItem(2) == null
         }