Implements netherite salvaging #24

src/main/java/net/knarcraft/blacksmith/trait/ReforgeSession.java

@@ -69,14 +69,14 @@ public class ReforgeSession extends Session implements Runnable {
     @Override
     public boolean isSessionInvalid() {
         // Prevent player from switching items during session
-        ItemStack itemInHand = player.getInventory().getItemInMainHand();
+        ItemStack itemInHand = this.player.getInventory().getItemInMainHand();
         if (!itemToReforge.equals(itemInHand)) {
-            sendNPCMessage(this.npc, player, config.getItemChangedMessage());
+            sendNPCMessage(this.npc, this.player, this.config.getItemChangedMessage());
             return true;
         }
         // The player is unable to pay
-        if (EconomyManager.cannotPayForHeldItemReforge(player)) {
-            sendNPCMessage(this.npc, player, config.getInsufficientFundsMessage());
+        if (EconomyManager.cannotPayForHeldItemReforge(this.player)) {
+            sendNPCMessage(this.npc, this.player, this.config.getInsufficientFundsMessage());
             return true;
         }
         return false;
@@ -84,9 +84,9 @@ public class ReforgeSession extends Session implements Runnable {
 
     @Override
     protected int getActionDelay() {
-        if (config.getMaxReforgeDelay() > 0) {
+        if (this.config.getMaxReforgeDelay() > 0) {
             //Finish the reforging after a random delay between the max and min
-            return new Random().nextInt(config.getMaxReforgeDelay()) + config.getMinReforgeDelay();
+            return new Random().nextInt(this.config.getMaxReforgeDelay()) + this.config.getMinReforgeDelay();
         } else {
             //Finish the salvaging as soon as possible
             return 0;
@@ -98,41 +98,41 @@ public class ReforgeSession extends Session implements Runnable {
      */
     @Override
     public void run() {
-        sendNPCMessage(this.npc, player, reforgeItem() ? config.getSuccessMessage() : config.getFailMessage());
+        sendNPCMessage(this.npc, this.player, reforgeItem() ? this.config.getSuccessMessage() : this.config.getFailMessage());
 
         //Stop the reforged item from displaying in the blacksmith's hand
-        if (npc.getEntity() instanceof Player) {
-            ((Player) npc.getEntity()).getInventory().setItemInMainHand(null);
+        if (this.npc.getEntity() instanceof Player) {
+            ((Player) this.npc.getEntity()).getInventory().setItemInMainHand(null);
         } else {
-            Objects.requireNonNull(((LivingEntity) npc.getEntity()).getEquipment()).setItemInMainHand(null);
+            Objects.requireNonNull(((LivingEntity) this.npc.getEntity()).getEquipment()).setItemInMainHand(null);
         }
 
         //Give the item back to the player
         giveReforgedItem();
 
         //Mark this blacksmith as available
-        blacksmithTrait.unsetSession();
+        this.blacksmithTrait.unsetSession();
 
         // Start cool-down
         Calendar wait = Calendar.getInstance();
-        wait.add(Calendar.SECOND, config.getReforgeCoolDown());
-        blacksmithTrait.addCoolDown(player.getUniqueId(), wait);
+        wait.add(Calendar.SECOND, this.config.getReforgeCoolDown());
+        this.blacksmithTrait.addCoolDown(this.player.getUniqueId(), wait);
     }
 
     /**
      * Gives the reforged item back to the player
      */
     private void giveReforgedItem() {
-        if (config.getMaxReforgeDelay() > 0) {
+        if (this.config.getMaxReforgeDelay() > 0) {
             //If the player isn't online, or the player cannot fit the item, drop the item to prevent it from disappearing
-            if (config.getDropItem() || !player.isOnline() || player.getInventory().firstEmpty() == -1) {
-                player.getWorld().dropItemNaturally(npc.getEntity().getLocation(), itemToReforge);
+            if (this.config.getDropItem() || !this.player.isOnline() || this.player.getInventory().firstEmpty() == -1) {
+                this.player.getWorld().dropItemNaturally(this.npc.getEntity().getLocation(), this.itemToReforge);
             } else {
-                player.getInventory().addItem(itemToReforge);
+                this.player.getInventory().addItem(this.itemToReforge);
             }
         } else {
             //It can be assumed as this happens instantly, that the player still has the item's previous slot selected
-            player.getInventory().setItemInMainHand(itemToReforge);
+            this.player.getInventory().setItemInMainHand(this.itemToReforge);
         }
     }
 
@@ -142,7 +142,7 @@ public class ReforgeSession extends Session implements Runnable {
      * @return <p>Whether the reforge was successful. False if the blacksmith failed to fully repair the item.</p>
      */
     private boolean reforgeItem() {
-        if (random.nextInt(100) < config.getFailChance()) {
+        if (random.nextInt(100) < this.config.getFailChance()) {
             failReforge();
             return false;
         } else {
@@ -156,18 +156,18 @@ public class ReforgeSession extends Session implements Runnable {
      */
     private void succeedReforge() {
         // Remove any damage done to the item
-        updateDamage(itemToReforge, 0);
+        updateDamage(this.itemToReforge, 0);
 
         //Replace damaged anvils with a normal anvil
-        if (ItemHelper.isAnvil(itemToReforge.getType(), true)) {
-            itemToReforge.setType(Material.ANVIL);
+        if (ItemHelper.isAnvil(this.itemToReforge.getType(), true)) {
+            this.itemToReforge.setType(Material.ANVIL);
         }
 
         //See if a random roll (0-99) is less than extraEnchantmentChance, and add a random enchantment
         int roll = random.nextInt(100);
-        if (roll < config.getExtraEnchantmentChance() &&
-                itemToReforge.getEnchantments().keySet().size() < config.getMaxEnchantments() &&
-                !ItemHelper.isAnvil(itemToReforge.getType(), false)) {
+        if (roll < this.config.getExtraEnchantmentChance() &&
+                this.itemToReforge.getEnchantments().keySet().size() < this.config.getMaxEnchantments() &&
+                !ItemHelper.isAnvil(this.itemToReforge.getType(), false)) {
             addRandomEnchantment();
         }
     }
@@ -180,12 +180,12 @@ public class ReforgeSession extends Session implements Runnable {
         List<Enchantment> usableEnchantments = new ArrayList<>();
         for (String enchantmentName : enchantments) {
             Enchantment enchantment = InputParsingHelper.matchEnchantment(enchantmentName);
-            if (enchantment != null && enchantment.canEnchantItem(itemToReforge)) {
+            if (enchantment != null && enchantment.canEnchantItem(this.itemToReforge)) {
                 usableEnchantments.add(enchantment);
             }
         }
         //Remove any enchantments in the block list
-        usableEnchantments.removeAll(blacksmithTrait.getSettings().getEnchantmentBlockList());
+        usableEnchantments.removeAll(this.blacksmithTrait.getSettings().getEnchantmentBlockList());
 
         //In case all usable enchantments have been blocked, abort
         if (usableEnchantments.isEmpty()) {
@@ -198,10 +198,10 @@ public class ReforgeSession extends Session implements Runnable {
             int randomBound = randomEnchantment.getMaxLevel() + 1;
             //A workaround for the random method's bound sometimes being negative
             if (randomBound >= 0) {
-                int existingLevel = itemToReforge.getEnchantmentLevel(randomEnchantment);
+                int existingLevel = this.itemToReforge.getEnchantmentLevel(randomEnchantment);
                 /* Add a random enchantment whose level is no lower than the start level, and no lower than the
                 existing level (to prevent making the item worse) */
-                itemToReforge.addEnchantment(randomEnchantment, Math.max(Math.max(random.nextInt(randomBound),
+                this.itemToReforge.addEnchantment(randomEnchantment, Math.max(Math.max(random.nextInt(randomBound),
                         randomEnchantment.getStartLevel()), existingLevel));
             }
         }
@@ -211,20 +211,20 @@ public class ReforgeSession extends Session implements Runnable {
      * The method to run when a blacksmith fails re-forging an item
      */
     private void failReforge() {
-        if (config.getFailRemovesEnchantments()) {
+        if (this.config.getFailRemovesEnchantments()) {
             removeOrDowngradeEnchantments();
         }
 
         //Damage the item
-        short currentItemDurability = ItemHelper.getDurability(itemToReforge);
+        short currentItemDurability = ItemHelper.getDurability(this.itemToReforge);
         short newDurability = (short) (currentItemDurability + (currentItemDurability * random.nextInt(8)));
-        short maxDurability = itemToReforge.getType().getMaxDurability();
+        short maxDurability = this.itemToReforge.getType().getMaxDurability();
         if (newDurability <= 0) {
             newDurability = (short) (maxDurability / 3);
         } else if (currentItemDurability + newDurability > maxDurability) {
             newDurability = (short) (maxDurability - random.nextInt(maxDurability - 25));
         }
-        updateDamage(itemToReforge, maxDurability - newDurability);
+        updateDamage(this.itemToReforge, maxDurability - newDurability);
     }
 
     /**
@@ -232,13 +232,13 @@ public class ReforgeSession extends Session implements Runnable {
      */
     private void removeOrDowngradeEnchantments() {
         //Remove or downgrade existing enchantments
-        for (Enchantment enchantment : itemToReforge.getEnchantments().keySet()) {
+        for (Enchantment enchantment : this.itemToReforge.getEnchantments().keySet()) {
             //Completely remove the enchantment, downgrade it, or keep it if lucky and already level 1
             if (random.nextBoolean()) {
-                itemToReforge.removeEnchantment(enchantment);
-            } else if (itemToReforge.getEnchantmentLevel(enchantment) > 1) {
-                itemToReforge.removeEnchantment(enchantment);
-                itemToReforge.addEnchantment(enchantment, 1);
+                this.itemToReforge.removeEnchantment(enchantment);
+            } else if (this.itemToReforge.getEnchantmentLevel(enchantment) > 1) {
+                this.itemToReforge.removeEnchantment(enchantment);
+                this.itemToReforge.addEnchantment(enchantment, 1);
             }
         }
     }