Enable gem extraction of skills

This also adds a 'source' piece of info to the applied skills on items so we can differentiate between gem skills and "base" skills

Author: Travja

src/main/java/studio/magemonkey/divinity/hooks/external/FabledHook.java

@@ -253,9 +253,9 @@ public void run() {
                     if (item == null) continue;
 
                     AbilityGenerator.updateNamespace(item);
-                    for (Map.Entry<String, Integer> entry : AbilityGenerator.getAbilities(item).entrySet()) {
+                    for (Map.Entry<String, AbilityGenerator.AbilityInfo> entry : AbilityGenerator.getAbilities(item).entrySet()) {
                         String id    = entry.getKey();
-                        int    level = entry.getValue();
+                        int    level = entry.getValue().getLevel();
                         if (!skills.containsKey(id) || level > skills.get(id)) {
                             skills.put(id, level);
                         }

src/main/java/studio/magemonkey/divinity/modules/list/gems/GemManager.java

@@ -79,6 +79,21 @@ public ItemStack insertSocket(@NotNull ItemStack item, @NotNull ItemStack src) {
         return item;
     }
 
+    @Override
+    @NotNull
+    public List<ItemStack> extractSocket(@NotNull ItemStack target, @NotNull String socketId, int index) {
+        List<ItemStack> items = super.extractSocket(target, socketId, index);
+        Gem             gem   = this.getModuleItem(target);
+
+        if (gem == null) return items;
+
+        ItemStack result   = items.get(0);
+        int       gemLevel = ItemStats.getLevel(target);
+        gem.removeAbilities(result, gemLevel);
+
+        return items;
+    }
+
     // -------------------------------------------------------------------- //
     // CLASSES
 
@@ -128,38 +143,73 @@ private void loadAbilities(@NotNull ConfigurationSection section, int lvl) {
             }
         }
 
-        public void applyAbilities(ItemStack item, int level) {
+        private void applyAbilities(ItemStack item, int level) {
             List<AbilityGenerator.Ability> abilities =
                     this.abilitiesByLevel.computeIfAbsent(level, k -> new ArrayList<>());
             if (abilities.isEmpty()) return;
 
             // Start off with our old abilities and then apply the new ones on top
-            Map<String, Integer>           itemAbilities = AbilityGenerator.getAbilities(item);
-            List<AbilityGenerator.Ability> abilitiesList = new ArrayList<>();
+            Map<String, AbilityGenerator.AbilityInfo> itemAbilities = AbilityGenerator.getAbilities(item);
+            List<AbilityGenerator.Ability>            abilitiesList = new ArrayList<>();
             // Only add any abilities that aren't already on the item
             for (AbilityGenerator.Ability ability : abilities) {
                 if (ability == null) continue;
 
                 String abilityId = ability.getId();
                 if (!itemAbilities.containsKey(abilityId)) {
-                    itemAbilities.put(ability.getId(), ability.getRndLevel());
+                    itemAbilities.put(ability.getId(),
+                            new AbilityGenerator.AbilityInfo(ability.getId(), ability.getRndLevel(), "gem"));
                     abilitiesList.add(ability);
                 }
             }
 
             // Apply the new abilities to the item
             int      i            = 0;
             String[] abilityArray = new String[itemAbilities.size()];
-            for (Map.Entry<String, Integer> entry : itemAbilities.entrySet()) {
-                abilityArray[i] = entry.getKey() + ":" + entry.getValue();
+            for (Map.Entry<String, AbilityGenerator.AbilityInfo> entry : itemAbilities.entrySet()) {
+                abilityArray[i] = entry.getKey() + ":" + entry.getValue() + ":" + entry.getValue().getSource();
+                i++;
+            }
+            DataUT.setData(item, AbilityGenerator.ABILITY_KEY, abilityArray);
+            updateItemLore(item, itemAbilities, abilitiesList);
+        }
+
+        /**
+         * Removes the abilities from the item that are associated with the gem at the given level.
+         *
+         * @param item  The item to remove the abilities from.
+         * @param level The level of the gem.
+         */
+        private void removeAbilities(ItemStack item, int level) {
+            List<AbilityGenerator.Ability> abilities = this.abilitiesByLevel.get(level);
+            if (abilities == null) return;
+
+            Map<String, AbilityGenerator.AbilityInfo> itemAbilities = AbilityGenerator.getAbilities(item);
+            if (itemAbilities.isEmpty()) return;
+
+            List<AbilityGenerator.Ability> abilitiesList = new ArrayList<>();
+            for (AbilityGenerator.Ability ability : abilities) {
+                if (ability == null) continue;
+
+                String abilityId = ability.getId();
+                if (itemAbilities.containsKey(abilityId) && itemAbilities.get(abilityId).getSource().equals("gem")) {
+                    itemAbilities.remove(abilityId);
+                }
+            }
+
+            int      i            = 0;
+            String[] abilityArray = new String[itemAbilities.size()];
+            for (Map.Entry<String, AbilityGenerator.AbilityInfo> entry : itemAbilities.entrySet()) {
+                abilityArray[i] =
+                        entry.getKey() + ":" + entry.getValue().getLevel() + ":" + entry.getValue().getSource();
                 i++;
             }
             DataUT.setData(item, AbilityGenerator.ABILITY_KEY, abilityArray);
             updateItemLore(item, itemAbilities, abilitiesList);
         }
 
         private void updateItemLore(ItemStack item,
-                                    Map<String, Integer> itemAbilities,
+                                    Map<String, AbilityGenerator.AbilityInfo> itemAbilities,
                                     List<AbilityGenerator.Ability> abilitiesList) {
             ItemGeneratorManager.GeneratorItem genItem = Divinity.getInstance().getModuleCache().getTierManager()
                     .getModuleItem(item);

src/main/java/studio/magemonkey/divinity/modules/list/itemgenerator/generators/AbilityGenerator.java

@@ -1,5 +1,8 @@
 package studio.magemonkey.divinity.modules.list.itemgenerator.generators;
 
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
 import org.bukkit.NamespacedKey;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.inventory.meta.ItemMeta;
@@ -155,16 +158,16 @@ public void generate(@NotNull ItemStack item, int itemLevel) {
         int      i            = 0;
         String[] abilityArray = new String[abilityAdd.size()];
         for (Map.Entry<AbilityGenerator.Ability, Integer> entry : abilityAdd.entrySet()) {
-            abilityArray[i] = entry.getKey().getId() + ':' + entry.getValue();
+            abilityArray[i] = entry.getKey().getId() + ':' + entry.getValue() + ":item";
             i++;
         }
         DataUT.setData(item, ABILITY_KEY, abilityArray);
 
         updateLore(item);
     }
 
-    public static Map<String, Integer> getAbilities(ItemStack item) {
-        Map<String, Integer> map = new HashMap<>();
+    public static Map<String, AbilityInfo> getAbilities(ItemStack item) {
+        Map<String, AbilityInfo> map = new HashMap<>();
         if (item == null) {
             return map;
         }
@@ -173,20 +176,31 @@ public static Map<String, Integer> getAbilities(ItemStack item) {
             return map;
         }
         for (String stringAbility : stringAbilities) {
-            int i = stringAbility.lastIndexOf(':');
-            int level;
+            AbilityInfo info  = new AbilityInfo();
+            String[]    split = stringAbility.split(":");
+            if (split.length < 2) {
+                continue;
+            }
+
+            info.setId(split[0]);
+
             try {
-                level = Integer.parseInt(stringAbility.substring(i + 1));
+                info.setLevel(Integer.parseInt(split[1]));
             } catch (NumberFormatException e) {
                 continue;
             }
-            map.put(stringAbility.substring(0, i), level);
+
+            if (split.length > 2) {
+                info.setSource(split[2]);
+            }
+
+            map.put(info.getId(), info);
         }
         return map;
     }
 
     public void updateLore(ItemStack item) {
-        Map<String, Integer> abilities = getAbilities(item);
+        Map<String, AbilityInfo> abilities = getAbilities(item);
         if (abilities.isEmpty()) return;
 
         List<Ability> abilityList = this.abilities.keySet().stream()
@@ -196,7 +210,7 @@ public void updateLore(ItemStack item) {
         updateLore(item, abilities, abilityList);
     }
 
-    public static void updateLore(ItemStack item, Map<String, Integer> abilities, List<Ability> abilityList) {
+    public static void updateLore(ItemStack item, Map<String, AbilityInfo> abilities, List<Ability> abilityList) {
         if (abilityList.isEmpty()) return;
 
         // At this point, we have a list of Abilities, so we just need to get their lore formats and update the item's lore for them
@@ -234,7 +248,7 @@ public static void updateLore(ItemStack item, Map<String, Integer> abilities, Li
         } else lore.remove(pos); // Otherwise, we'll remove it so we can add new lines at the position
 
         for (Ability ability : abilityList) {
-            int level = abilities.get(ability.getId());
+            int level = abilities.get(ability.getId()).getLevel();
             for (String format : ability.getLoreFormat()) {
                 String loreLine = format.replace("%level%", String.valueOf(level));
                 pos = LoreUT.addToLore(lore, pos, loreLine);
@@ -298,4 +312,17 @@ public boolean equals(Object o) {
         @Override
         public int hashCode() {return Objects.hash(id);}
     }
+
+    @Data
+    @NoArgsConstructor
+    @AllArgsConstructor
+    public static class AbilityInfo {
+        private String id;
+        private int    level;
+        private String source;
+
+        public String getSource() {
+            return Objects.requireNonNullElse(this.source, "item");
+        }
+    }
 }