v1.6.13 (#42)

Make some legacy version of excellent enchantment work with custom anvil

build.gradle.kts

@@ -16,7 +16,7 @@ plugins {
 }
 
 group = "xyz.alexcrea"
-version = "1.6.12"
+version = "1.6.13"
 
 repositories {
     // EcoEnchants
@@ -43,6 +43,7 @@ dependencies {
     // ExcellentEnchants
     compileOnly(files("libs/nightcore-2.6.4.jar"))
     compileOnly(files("libs/ExcellentEnchants-4.2.2.jar"))
+    compileOnly(files("libs/ExcellentEnchants 4.1.0-striped.jar"))
 
     // Disenchantment
     compileOnly("cz.kominekjan:Disenchantment:v5.4.0")

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

@@ -26,12 +26,12 @@ public class CAEEEnchantment extends CABukkitEnchantment implements AdditionalTe
 
     @Override
     public boolean isEnchantConflict(@NotNull Map<CAEnchantment, Integer> enchantments, @NotNull Material itemMat) {
-        if(!definition.hasConflicts()) return false;
+        if (!definition.hasConflicts()) return false;
 
         Set<String> conflicts = definition.getConflicts();
 
         for (CAEnchantment caEnchantment : enchantments.keySet()) {
-            if(conflicts.contains(caEnchantment.getName())) return true;
+            if (conflicts.contains(caEnchantment.getName())) return true;
         }
 
         return false;
@@ -39,7 +39,7 @@ public class CAEEEnchantment extends CABukkitEnchantment implements AdditionalTe
 
     @Override
     public boolean isItemConflict(@NotNull Map<CAEnchantment, Integer> enchantments, @NotNull Material itemMat, @NotNull ItemStack item) {
-        if(Material.ENCHANTED_BOOK.equals(itemMat)) return false;
+        if (Material.ENCHANTED_BOOK.equals(itemMat)) return false;
 
         return !definition.getSupportedItems().is(item);
     }

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

@@ -0,0 +1,43 @@
+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.EnchantmentData;
+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 CALegacyEEEnchantment extends CABukkitEnchantment implements AdditionalTestEnchantment {
+
+    @NotNull EnchantmentData eeenchantment;
+
+    public CALegacyEEEnchantment(@NotNull EnchantmentData enchantment) {
+        super(enchantment.getEnchantment(), EnchantmentRarity.getRarity(enchantment.getAnvilCost()));
+        this.eeenchantment = enchantment;
+
+    }
+
+    @Override
+    public boolean isEnchantConflict(@NotNull Map<CAEnchantment, Integer> enchantments, @NotNull Material itemMat) {
+        if (!eeenchantment.hasConflicts()) return false;
+
+        Set<String> conflicts = eeenchantment.getConflicts();
+
+        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) {
+        if (Material.ENCHANTED_BOOK.equals(itemMat)) return false;
+
+        return !eeenchantment.getSupportedItems().is(item);
+    }
+}

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

@@ -2,29 +2,51 @@ package xyz.alexcrea.cuanvil.dependency
 
 import io.delilaheve.CustomAnvil
 import org.bukkit.Material
+import org.bukkit.event.Listener
 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.CALegacyEEEnchantment
 import java.lang.reflect.Method
 
 class ExcellentEnchantsDependency {
 
+    private val isModern: Boolean
+
     init {
         CustomAnvil.instance.logger.info("Excellent Enchants Detected !")
+
+        var isModern = true;
+        try {
+            Class.forName("su.nightexpress.excellentenchants.enchantment.listener.AnvilListener")
+        } catch (ignored: ClassNotFoundException) {
+            isModern = false
+        }
+
+        this.isModern = isModern
     }
 
     fun registerEnchantments() {
         CustomAnvil.instance.logger.info("Preparing Excellent Enchants compatibility...")
 
-        for (enchantment in EnchantRegistry.getRegistered()) {
+        // As excellent enchants is loaded before custom anvil and register enchantment to registry, we need to unregister old "vanilla" enchant.
-            EnchantmentApi.unregisterEnchantment(enchantment.bukkitEnchantment.key) // As excellent enchants is loaded before custom anvil and register enchantment to registry, we need to unregister old "vanilla" enchant.
+        if (this.isModern) {
-            EnchantmentApi.registerEnchantment(CAEEEnchantment(enchantment))
+            for (enchantment in EnchantRegistry.getRegistered()) {
+                EnchantmentApi.unregisterEnchantment(enchantment.bukkitEnchantment.key)
+                EnchantmentApi.registerEnchantment(CAEEEnchantment(enchantment))
+            }
+        } else {
+            for (enchantment in su.nightexpress.excellentenchants.enchantment.registry.EnchantRegistry.getRegistered()) {
+                EnchantmentApi.unregisterEnchantment(enchantment.enchantment.key)
+                EnchantmentApi.registerEnchantment(CALegacyEEEnchantment(enchantment))
+            }
         }
 
         CustomAnvil.instance.logger.info("Excellent Enchants should now work as expected !")
@@ -32,7 +54,10 @@ class ExcellentEnchantsDependency {
 
     private lateinit var fragilityCurse: CurseOfFragilityEnchant
 
-    private lateinit var anvilListener: AnvilListener
+    private var modernAnvilListener: AnvilListener? = null
+    private var legacyAnvilListener: EnchantAnvilListener? = null
+    private lateinit var usedAnvilListener: Listener
+
     private lateinit var handleRechargeMethod: Method
     private lateinit var handleCombineMethod: Method
 
@@ -42,70 +67,90 @@ class ExcellentEnchantsDependency {
         for (registeredListener in PrepareAnvilEvent.getHandlerList().registeredListeners) {
             val listener = registeredListener.listener
 
-            if(listener is CurseOfFragilityEnchant){
+            if (listener is CurseOfFragilityEnchant) {
                 this.fragilityCurse = listener
                 toUnregister.add(registeredListener)
             }
 
-            if(listener is AnvilListener){
+            if (this.isModern) {
-                this.anvilListener = listener;
+                if (listener is AnvilListener) {
-                toUnregister.add(registeredListener)
+                    this.modernAnvilListener = listener;
+                    toUnregister.add(registeredListener)
+                }
+            } else {
+                if (listener is EnchantAnvilListener) {
+                    this.legacyAnvilListener = listener;
+                    toUnregister.add(registeredListener)
+                }
             }
 
         }
 
         for (listener in toUnregister) {
             PrepareAnvilEvent.getHandlerList().unregister(listener)
+        }
 
+        if (this.isModern) {
+            this.usedAnvilListener = this.modernAnvilListener!!
+        } else {
+            this.usedAnvilListener = this.legacyAnvilListener!!
         }
 
         // Unregister inventory click event
-        InventoryClickEvent.getHandlerList().unregister(this.anvilListener)
+        InventoryClickEvent.getHandlerList().unregister(this.usedAnvilListener)
 
         findAnvilFunctions()
     }
 
     private fun findAnvilFunctions() {
-        this.handleRechargeMethod = AnvilListener::class.java.getDeclaredMethod("handleRecharge",
+        this.handleRechargeMethod = this.usedAnvilListener.javaClass.getDeclaredMethod(
-            PrepareAnvilEvent::class.java, ItemStack::class.java, ItemStack::class.java)
+            "handleRecharge",
+            PrepareAnvilEvent::class.java, ItemStack::class.java, ItemStack::class.java
+        )
         this.handleRechargeMethod.setAccessible(true)
 
-        this.handleCombineMethod = AnvilListener::class.java.getDeclaredMethod("handleCombine",
+        this.handleCombineMethod = this.usedAnvilListener.javaClass.getDeclaredMethod(
-            PrepareAnvilEvent::class.java, ItemStack::class.java, ItemStack::class.java, ItemStack::class.java)
+            "handleCombine",
+            PrepareAnvilEvent::class.java, ItemStack::class.java, ItemStack::class.java, ItemStack::class.java
+        )
         this.handleCombineMethod.setAccessible(true)
 
     }
 
     fun testPrepareAnvil(event: PrepareAnvilEvent): Boolean {
-        if(event.result != null){
+        if (event.result != null) {
             this.fragilityCurse.onItemAnvil(event)
-            if(event.result == null) return true
+            if (event.result == null) return true
         }
 
         val first: ItemStack = treatInput(event.inventory.getItem(0))
         val second: ItemStack = treatInput(event.inventory.getItem(1))
 
-        return handleRechargeMethod.invoke(this.anvilListener, event, first, second) as Boolean
+        return handleRechargeMethod.invoke(this.usedAnvilListener, event, first, second) as Boolean
     }
 
     fun treatAnvilResult(event: PrepareAnvilEvent, result: ItemStack) {
         val first: ItemStack = treatInput(event.inventory.getItem(0))
         val second: ItemStack = treatInput(event.inventory.getItem(1))
 
-        handleCombineMethod.invoke(this.anvilListener, event, first, second, result)
+        handleCombineMethod.invoke(this.usedAnvilListener, event, first, second, result)
     }
 
     fun testAnvilResult(event: InventoryClickEvent): Any {
-        if(event.inventory.getItem(2) != null){
+        if (event.inventory.getItem(2) != null) {
-            this.anvilListener.onClickAnvil(event)
+            if (this.isModern) {
+                this.modernAnvilListener!!.onClickAnvil(event)
+            } else {
+                this.legacyAnvilListener!!.onClickAnvil(event)
+            }
             return event.inventory.getItem(2) == null
         }
 
         return false;
     }
 
-    fun treatInput(item: ItemStack?): ItemStack {
+    private fun treatInput(item: ItemStack?): ItemStack {
-        if(item == null) return ItemStack(Material.AIR)
+        if (item == null) return ItemStack(Material.AIR)
         return item
     }