Calculate Alchemy XP based on potion stage

Adds #1926

Changelog.txt

@@ -7,6 +7,26 @@ Key:
   ! Change
   - Removal
 
+Version 1.5.01-dev
+ + Added new child skill; Salvage
+ + Added new feature to Herbalism. Instantly-regrown crops are protected from being broken for 1 second
+ + Added option to config.yml to show the /mcstats scoreboard automatically after logging in
+ + Added option to config.yml for Alchemy. Skills.Alchemy.Prevent_Hopper_Transfer_Bottles
+ + Added support for `MATERIAL|data` format in treasures.yml
+ + Added API to experience events to get XP gain reason
+ + Added API to check if an entity is bleeding
+ = Fixed bug where the Updater was running on the main thread.
+ = Fixed bug when players would use /ptp without being in a party
+ = Fixed bug where player didn't have a mcMMOPlayer object in AsyncPlayerChatEvent
+ = Fixed bug where dodge would check the wrong player skill level
+ = Fixed bug which causes /party teleport to stop working
+ = Fixed bug where SaveTimerTask would produce an IndexOutOfBoundsException
+ ! Changed player data saving. Save tasks are now asynchronous
+ ! Vanished players no longer get hit by AoE effects
+ ! Changed Alchemy config option 'Prevent_Hopper_Transfer' renamed to 'Prevent_Hopper_Transfer_Ingredients'
+ ! Changed Alchemy XP distribution. XP is granted based on the stage of the potion.
+ - Removed salvage ability from Repair, salvage has it's own (child) skill now
+
 Version 1.5.00
  + Added Podzol & Red Sand to Excavation
  + Added Hardened Clay, Stained Clay, and Packed Ice to Mining blocks

README.md

@@ -34,7 +34,7 @@ mcMMO is currently developed by a team of individuals from all over the world.
 
 ### Special thanks
 [![EasyMFnE](https://www.gravatar.com/avatar/99c9a1fa3bbf957791ceac7b45daadb0.png)]
-(https://github.com/EasyMFnE)
+(https://github.com/EasyMFnE)  
 Added the Alchemy skill
 
 ## Compiling

pom.xml

@@ -2,7 +2,7 @@
     <modelVersion>4.0.0</modelVersion>
     <groupId>com.gmail.nossr50.mcMMO</groupId>
     <artifactId>mcMMO</artifactId>
-    <version>1.5.00</version>
+    <version>1.5.01-SNAPSHOT</version>
     <name>mcMMO</name>
     <url>https://github.com/mcMMO-Dev/mcMMO</url>
     <issueManagement>

src/main/java/com/gmail/nossr50/api/AbilityAPI.java

@@ -1,9 +1,11 @@
 package com.gmail.nossr50.api;
 
+import org.bukkit.entity.LivingEntity;
 import org.bukkit.entity.Player;
 
 import com.gmail.nossr50.datatypes.player.McMMOPlayer;
 import com.gmail.nossr50.datatypes.skills.AbilityType;
+import com.gmail.nossr50.runnables.skills.BleedTimerTask;
 import com.gmail.nossr50.util.player.UserManager;
 
 public final class AbilityAPI {
@@ -80,4 +82,8 @@ public final class AbilityAPI {
     public static void setTreeFellerCooldown(Player player, long cooldown) {
         UserManager.getPlayer(player).setAbilityDATS(AbilityType.TREE_FELLER, cooldown);
     }
+
+    public static boolean isBleeding(LivingEntity entity) {
+        return BleedTimerTask.isBleeding(entity);
+    }
 }

src/main/java/com/gmail/nossr50/api/ExperienceAPI.java

@@ -7,10 +7,12 @@ import org.bukkit.entity.Player;
 import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.api.exceptions.InvalidPlayerException;
 import com.gmail.nossr50.api.exceptions.InvalidSkillException;
+import com.gmail.nossr50.api.exceptions.InvalidXPGainReasonException;
 import com.gmail.nossr50.config.Config;
 import com.gmail.nossr50.config.experience.ExperienceConfig;
 import com.gmail.nossr50.datatypes.player.PlayerProfile;
 import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.datatypes.skills.XPGainReason;
 import com.gmail.nossr50.skills.child.FamilyTree;
 import com.gmail.nossr50.util.player.UserManager;
 
@@ -62,8 +64,26 @@ public final class ExperienceAPI {
      *
      * @throws InvalidSkillException if the given skill is not valid
      */
+    @Deprecated
     public static void addRawXP(Player player, String skillType, float XP) {
-        UserManager.getPlayer(player).applyXpGain(getSkillType(skillType), XP);
+        addRawXP(player, skillType, XP, "UNKNOWN");
+    }
+
+    /**
+     * Adds raw XP to the player.
+     * </br>
+     * This function is designed for API usage.
+     *
+     * @param player The player to add XP to
+     * @param skillType The skill to add XP to
+     * @param XP The amount of XP to add
+     * @param xpGainReason The reason to gain XP
+     *
+     * @throws InvalidSkillException if the given skill is not valid
+     * @throws InvalidXPGainReasonException if the given xpGainReason is not valid
+     */
+    public static void addRawXP(Player player, String skillType, float XP, String xpGainReason) {
+        UserManager.getPlayer(player).applyXpGain(getSkillType(skillType), XP, getXPGainReason(xpGainReason));
     }
 
     @Deprecated
@@ -98,8 +118,26 @@ public final class ExperienceAPI {
      *
      * @throws InvalidSkillException if the given skill is not valid
      */
+    @Deprecated
     public static void addMultipliedXP(Player player, String skillType, int XP) {
-        UserManager.getPlayer(player).applyXpGain(getSkillType(skillType), (int) (XP * ExperienceConfig.getInstance().getExperienceGainsGlobalMultiplier()));
+        addMultipliedXP(player, skillType, XP, "UNKNOWN");
+    }
+
+    /**
+     * Adds XP to the player, calculates for XP Rate only.
+     * </br>
+     * This function is designed for API usage.
+     *
+     * @param player The player to add XP to
+     * @param skillType The skill to add XP to
+     * @param XP The amount of XP to add
+     * @param xpGainReason The reason to gain XP
+     *
+     * @throws InvalidSkillException if the given skill is not valid
+     * @throws InvalidXPGainReasonException if the given xpGainReason is not valid
+     */
+    public static void addMultipliedXP(Player player, String skillType, int XP, String xpGainReason) {
+        UserManager.getPlayer(player).applyXpGain(getSkillType(skillType), (int) (XP * ExperienceConfig.getInstance().getExperienceGainsGlobalMultiplier()), getXPGainReason(xpGainReason));
     }
 
     /**
@@ -129,10 +167,28 @@ public final class ExperienceAPI {
      *
      * @throws InvalidSkillException if the given skill is not valid
      */
+    @Deprecated
     public static void addModifiedXP(Player player, String skillType, int XP) {
+        addModifiedXP(player, skillType, XP, "UNKNOWN");
+    }
+
+    /**
+     * Adds XP to the player, calculates for XP Rate and skill modifier.
+     * </br>
+     * This function is designed for API usage.
+     *
+     * @param player The player to add XP to
+     * @param skillType The skill to add XP to
+     * @param XP The amount of XP to add
+     * @param xpGainReason The reason to gain XP
+     *
+     * @throws InvalidSkillException if the given skill is not valid
+     * @throws InvalidXPGainReasonException if the given xpGainReason is not valid
+     */
+    public static void addModifiedXP(Player player, String skillType, int XP, String xpGainReason) {
         SkillType skill = getSkillType(skillType);
 
-        UserManager.getPlayer(player).applyXpGain(skill, (int) (XP / skill.getXpModifier() * ExperienceConfig.getInstance().getExperienceGainsGlobalMultiplier()));
+        UserManager.getPlayer(player).applyXpGain(skill, (int) (XP / skill.getXpModifier() * ExperienceConfig.getInstance().getExperienceGainsGlobalMultiplier()), getXPGainReason(xpGainReason));
     }
 
     /**
@@ -165,8 +221,27 @@ public final class ExperienceAPI {
      *
      * @throws InvalidSkillException if the given skill is not valid
      */
+    @Deprecated
     public static void addXP(Player player, String skillType, int XP) {
-        UserManager.getPlayer(player).beginXpGain(getSkillType(skillType), XP);
+        addXP(player, skillType, XP, "UNKNOWN");
+    }
+
+    /**
+     * Adds XP to the player, calculates for XP Rate, skill modifiers, perks, child skills,
+     * and party sharing.
+     * </br>
+     * This function is designed for API usage.
+     *
+     * @param player The player to add XP to
+     * @param skillType The skill to add XP to
+     * @param XP The amount of XP to add
+     * @param xpGainReason The reason to gain XP
+     *
+     * @throws InvalidSkillException if the given skill is not valid
+     * @throws InvalidXPGainReasonException if the given xpGainReason is not valid
+     */
+    public static void addXP(Player player, String skillType, int XP, String xpGainReason) {
+        UserManager.getPlayer(player).beginXpGain(getSkillType(skillType), XP, getXPGainReason(xpGainReason));
     }
 
     /**
@@ -347,12 +422,12 @@ public final class ExperienceAPI {
                 profile.addLevels(parentSkill, (levels / parentSkills.size()));
             }
 
-            profile.save();
+            profile.scheduleAsyncSave();
             return;
         }
 
         profile.addLevels(skill, levels);
-        profile.save();
+        profile.scheduleAsyncSave();
     }
 
     /**
@@ -581,7 +656,7 @@ public final class ExperienceAPI {
         PlayerProfile profile = getOfflineProfile(playerName);
 
         profile.addXp(skill, XP);
-        profile.save();
+        profile.scheduleAsyncSave();
     }
 
     private static PlayerProfile getOfflineProfile(String playerName) {
@@ -613,4 +688,14 @@ public final class ExperienceAPI {
 
         return skill;
     }
+
+    private static XPGainReason getXPGainReason(String reason) throws InvalidXPGainReasonException {
+        XPGainReason xpGainReason = XPGainReason.getXPGainReason(reason);
+
+        if (xpGainReason == null) {
+            throw new InvalidXPGainReasonException();
+        }
+
+        return xpGainReason;
+    }
 }

src/main/java/com/gmail/nossr50/api/PartyAPI.java

@@ -176,7 +176,7 @@ public final class PartyAPI {
     }
 
     public static boolean hasAlly(String partyName) {
-        return PartyManager.getParty(partyName).getAlly() != null;
+        return getAllyName(partyName) != null;
     }
 
     public static String getAllyName(String partyName) {

src/main/java/com/gmail/nossr50/api/exceptions/InvalidXPGainReasonException.java

@@ -0,0 +1,9 @@
+package com.gmail.nossr50.api.exceptions;
+
+public class InvalidXPGainReasonException extends RuntimeException {
+    private static final long serialVersionUID = 4427052841957931157L;
+
+    public InvalidXPGainReasonException() {
+        super("That is not a valid XPGainReason.");
+    }
+}

src/main/java/com/gmail/nossr50/commands/experience/AddlevelsCommand.java

@@ -5,6 +5,7 @@ import org.bukkit.entity.Player;
 
 import com.gmail.nossr50.datatypes.player.PlayerProfile;
 import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.datatypes.skills.XPGainReason;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.util.EventUtils;
 import com.gmail.nossr50.util.Permissions;
@@ -26,11 +27,11 @@ public class AddlevelsCommand extends ExperienceCommand {
         profile.addLevels(skill, value);
 
         if (player == null) {
-            profile.save();
+            profile.scheduleAsyncSave();
             return;
         }
 
-        EventUtils.handleLevelChangeEvent(player, skill, value, xpRemoved, true);
+        EventUtils.handleLevelChangeEvent(player, skill, value, xpRemoved, true, XPGainReason.COMMAND);
     }
 
     @Override

src/main/java/com/gmail/nossr50/commands/experience/AddxpCommand.java

@@ -5,6 +5,7 @@ import org.bukkit.entity.Player;
 
 import com.gmail.nossr50.datatypes.player.PlayerProfile;
 import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.datatypes.skills.XPGainReason;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.util.Permissions;
 import com.gmail.nossr50.util.player.UserManager;
@@ -23,11 +24,11 @@ public class AddxpCommand extends ExperienceCommand {
     @Override
     protected void handleCommand(Player player, PlayerProfile profile, SkillType skill, int value) {
         if (player != null) {
-            UserManager.getPlayer(player).applyXpGain(skill, value);
+            UserManager.getPlayer(player).applyXpGain(skill, value, XPGainReason.COMMAND);
         }
         else {
             profile.addXp(skill, value);
-            profile.save();
+            profile.scheduleAsyncSave();
         }
     }
 

src/main/java/com/gmail/nossr50/commands/experience/MmoeditCommand.java

@@ -5,6 +5,7 @@ import org.bukkit.entity.Player;
 
 import com.gmail.nossr50.datatypes.player.PlayerProfile;
 import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.datatypes.skills.XPGainReason;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.util.EventUtils;
 import com.gmail.nossr50.util.Permissions;
@@ -28,7 +29,7 @@ public class MmoeditCommand extends ExperienceCommand {
         profile.modifySkill(skill, value);
 
         if (player == null) {
-            profile.save();
+            profile.scheduleAsyncSave();
             return;
         }
 
@@ -36,7 +37,7 @@ public class MmoeditCommand extends ExperienceCommand {
             return;
         }
 
-        EventUtils.handleLevelChangeEvent(player, skill, value, xpRemoved, value > skillLevel);
+        EventUtils.handleLevelChangeEvent(player, skill, value, xpRemoved, value > skillLevel, XPGainReason.COMMAND);
     }
 
     @Override

src/main/java/com/gmail/nossr50/commands/experience/SkillresetCommand.java

@@ -13,6 +13,7 @@ import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.datatypes.player.McMMOPlayer;
 import com.gmail.nossr50.datatypes.player.PlayerProfile;
 import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.datatypes.skills.XPGainReason;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.util.EventUtils;
 import com.gmail.nossr50.util.Permissions;
@@ -109,11 +110,11 @@ public class SkillresetCommand implements TabExecutor {
         profile.modifySkill(skill, 0);
 
         if (player == null) {
-            profile.save();
+            profile.scheduleAsyncSave();
             return;
         }
 
-        EventUtils.handleLevelChangeEvent(player, skill, levelsRemoved, xpRemoved, false);
+        EventUtils.handleLevelChangeEvent(player, skill, levelsRemoved, xpRemoved, false, XPGainReason.COMMAND);
     }
 
     protected boolean permissionsCheckSelf(CommandSender sender) {

src/main/java/com/gmail/nossr50/commands/party/PartyCommand.java

@@ -12,7 +12,6 @@ import org.bukkit.command.TabExecutor;
 import org.bukkit.entity.Player;
 import org.bukkit.util.StringUtil;
 
-import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.commands.chat.PartyChatCommand;
 import com.gmail.nossr50.commands.party.alliance.PartyAllianceCommand;
 import com.gmail.nossr50.commands.party.teleport.PtpCommand;
@@ -56,7 +55,7 @@ public class PartyCommand implements TabExecutor {
     private CommandExecutor partyRenameCommand         = new PartyRenameCommand();
     private CommandExecutor partyInfoCommand           = new PartyInfoCommand();
     private CommandExecutor partyHelpCommand           = new PartyHelpCommand();
-    private CommandExecutor partyTeleportCommand       = mcMMO.p.getCommand("ptp").getExecutor();
+    private CommandExecutor partyTeleportCommand       = new PtpCommand();
     private CommandExecutor partyChatCommand           = new PartyChatCommand();
     private CommandExecutor partyAllianceCommand       = new PartyAllianceCommand();
 

src/main/java/com/gmail/nossr50/commands/party/teleport/PtpCommand.java

@@ -43,6 +43,12 @@ public class PtpCommand implements TabExecutor {
 
         Player player = (Player) sender;
         McMMOPlayer mcMMOPlayer = UserManager.getPlayer(player);
+
+        if (!mcMMOPlayer.inParty()) {
+            sender.sendMessage(LocaleLoader.getString("Commands.Party.None"));
+            return true;
+        }
+
         Party party = mcMMOPlayer.getParty();
 
         if (party.getLevel() < Config.getInstance().getPartyFeatureUnlockLevel(PartyFeature.TELEPORT)) {
@@ -109,9 +115,13 @@ public class PtpCommand implements TabExecutor {
 
                 if (matches.size() == 0) {
                     Player player = (Player) sender;
-                    Party party = UserManager.getPlayer(player).getParty();
+                    McMMOPlayer mcMMOPlayer = UserManager.getPlayer(player);
 
-                    List<String> playerNames = party.getOnlinePlayerNames(player);
+                    if (!mcMMOPlayer.inParty()) {
+                        return ImmutableList.of();
+                    }
+
+                    List<String> playerNames = mcMMOPlayer.getParty().getOnlinePlayerNames(player);
                     return StringUtil.copyPartialMatches(args[0], playerNames, new ArrayList<String>(playerNames.size()));
                 }
 

src/main/java/com/gmail/nossr50/commands/skills/FishingCommand.java

@@ -4,7 +4,6 @@ import java.util.ArrayList;
 import java.util.List;
 
 import org.bukkit.Location;
-import org.bukkit.block.Biome;
 import org.bukkit.entity.EntityType;
 import org.bukkit.entity.Player;
 

src/main/java/com/gmail/nossr50/commands/skills/RepairCommand.java

@@ -7,6 +7,7 @@ import org.bukkit.Material;
 import org.bukkit.entity.Player;
 
 import com.gmail.nossr50.mcMMO;
+import com.gmail.nossr50.datatypes.skills.MaterialType;
 import com.gmail.nossr50.datatypes.skills.SecondaryAbility;
 import com.gmail.nossr50.datatypes.skills.SkillType;
 import com.gmail.nossr50.locale.LocaleLoader;
@@ -26,7 +27,6 @@ public class RepairCommand extends SkillCommand {
     private boolean canSuperRepair;
     private boolean canMasterRepair;
     private boolean canArcaneForge;
-    private boolean canSalvage;
     private boolean canRepairStone;
     private boolean canRepairIron;
     private boolean canRepairGold;
@@ -77,14 +77,13 @@ public class RepairCommand extends SkillCommand {
         canSuperRepair = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.SUPER_REPAIR);
         canMasterRepair = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.REPAIR_MASTERY);
         canArcaneForge = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.ARCANE_FORGING);
-        canSalvage = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.SALVAGE);
-        canRepairDiamond = Permissions.repairDiamond(player);
-        canRepairGold = Permissions.repairGold(player);
-        canRepairIron = Permissions.repairIron(player);
-        canRepairStone = Permissions.repairStone(player);
-        canRepairString = Permissions.repairString(player);
-        canRepairLeather = Permissions.repairLeather(player);
-        canRepairWood = Permissions.repairWood(player);
+        canRepairDiamond = Permissions.repairMaterialType(player, MaterialType.DIAMOND);
+        canRepairGold = Permissions.repairMaterialType(player, MaterialType.GOLD);
+        canRepairIron = Permissions.repairMaterialType(player, MaterialType.IRON);
+        canRepairStone = Permissions.repairMaterialType(player, MaterialType.STONE);
+        canRepairString = Permissions.repairMaterialType(player, MaterialType.STRING);
+        canRepairLeather = Permissions.repairMaterialType(player, MaterialType.LEATHER);
+        canRepairWood = Permissions.repairMaterialType(player, MaterialType.WOOD);
         arcaneBypass = Permissions.arcaneBypass(player);
     }
 
@@ -122,10 +121,6 @@ public class RepairCommand extends SkillCommand {
             messages.add(LocaleLoader.getString("Effects.Template", LocaleLoader.getString("Repair.Effect.6", diamondLevel), LocaleLoader.getString("Repair.Effect.7")));
         }
 
-        if (canSalvage && Repair.salvageUnlockLevel > 0) {
-            messages.add(LocaleLoader.getString("Effects.Template", LocaleLoader.getString("Repair.Effect.16", Repair.salvageUnlockLevel), LocaleLoader.getString("Repair.Effect.17")));
-        }
-
         if (canArcaneForge) {
             messages.add(LocaleLoader.getString("Effects.Template", LocaleLoader.getString("Repair.Effect.8"), LocaleLoader.getString("Repair.Effect.9")));
         }

src/main/java/com/gmail/nossr50/commands/skills/SalvageCommand.java

@@ -0,0 +1,79 @@
+package com.gmail.nossr50.commands.skills;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.bukkit.entity.Player;
+
+import com.gmail.nossr50.datatypes.skills.SecondaryAbility;
+import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.skills.salvage.Salvage;
+import com.gmail.nossr50.skills.salvage.SalvageManager;
+import com.gmail.nossr50.util.Permissions;
+import com.gmail.nossr50.util.player.UserManager;
+
+public class SalvageCommand extends SkillCommand {
+    private boolean canAdvancedSalvage;
+    private boolean canArcaneSalvage;
+
+    public SalvageCommand() {
+        super(SkillType.SALVAGE);
+    }
+
+    @Override
+    protected void dataCalculations(Player player, float skillValue, boolean isLucky) {
+        // TODO Auto-generated method stub
+
+    }
+
+    @Override
+    protected void permissionsCheck(Player player) {
+        canAdvancedSalvage = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.ADVANCED_SALVAGE);
+        canArcaneSalvage = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.ARCANE_SALVAGE);
+    }
+
+    @Override
+    protected List<String> effectsDisplay() {
+        List<String> messages = new ArrayList<String>();
+
+        if (canAdvancedSalvage) {
+            messages.add(LocaleLoader.getString("Effects.Template", LocaleLoader.getString("Salvage.Effect.0"), LocaleLoader.getString("Salvage.Effect.1")));
+        }
+
+        if (canArcaneSalvage) {
+            messages.add(LocaleLoader.getString("Effects.Template", LocaleLoader.getString("Salvage.Effect.2"), LocaleLoader.getString("Salvage.Effect.3")));
+        }
+
+        return messages;
+    }
+
+    @Override
+    protected List<String> statsDisplay(Player player, float skillValue, boolean hasEndurance, boolean isLucky) {
+        List<String> messages = new ArrayList<String>();
+        SalvageManager salvageManager = UserManager.getPlayer(player).getSalvageManager();
+
+        if (canAdvancedSalvage) {
+            if (skillValue < Salvage.advancedSalvageUnlockLevel) {
+                messages.add(LocaleLoader.getString("Ability.Generic.Template.Lock", LocaleLoader.getString("Salvage.Ability.Locked.0", Salvage.advancedSalvageUnlockLevel)));
+            }
+            else {
+                messages.add(LocaleLoader.getString("Ability.Generic.Template", LocaleLoader.getString("Salvage.Ability.Bonus.0"), LocaleLoader.getString("Salvage.Ability.Bonus.1", percent.format(salvageManager.getMaxSalvagePercentage()))));
+            }
+        }
+
+        if (canArcaneSalvage) {
+            messages.add(LocaleLoader.getString("Salvage.Arcane.Rank", salvageManager.getArcaneSalvageRank(), Salvage.Tier.values().length));
+
+            if (Salvage.arcaneSalvageEnchantLoss) {
+                messages.add(LocaleLoader.getString("Ability.Generic.Template", LocaleLoader.getString("Salvage.Arcane.ExtractFull"), percent.format(salvageManager.getExtractFullEnchantChance() / 100)));
+            }
+
+            if (Salvage.arcaneSalvageDowngrades) {
+                messages.add(LocaleLoader.getString("Ability.Generic.Template", LocaleLoader.getString("Salvage.Arcane.ExtractPartial"), percent.format(salvageManager.getExtractPartialEnchantChance() / 100)));
+            }
+        }
+
+        return messages;
+    }
+}

src/main/java/com/gmail/nossr50/commands/skills/UnarmedCommand.java

@@ -57,7 +57,7 @@ public class UnarmedCommand extends SkillCommand {
 
         // IRON ARM
         if (canIronArm) {
-            ironArmBonus = Math.min(3 + ((int) skillValue / Unarmed.ironArmIncreaseLevel), Unarmed.ironArmMaxBonusDamage);
+            ironArmBonus = Math.min(Unarmed.ironArmMinBonusDamage + ((int) skillValue / Unarmed.ironArmIncreaseLevel), Unarmed.ironArmMaxBonusDamage);
         }
 
         // IRON GRIP

src/main/java/com/gmail/nossr50/config/AdvancedConfig.java

@@ -10,6 +10,7 @@ import com.gmail.nossr50.skills.alchemy.Alchemy;
 import com.gmail.nossr50.skills.fishing.Fishing;
 import com.gmail.nossr50.skills.mining.BlastMining;
 import com.gmail.nossr50.skills.repair.ArcaneForging;
+import com.gmail.nossr50.skills.salvage.Salvage;
 import com.gmail.nossr50.skills.smelting.Smelting;
 import com.gmail.nossr50.util.StringUtils;
 
@@ -378,10 +379,6 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
             reason.add("Skills.Repair.SuperRepair.MaxBonusLevel should be at least 1!");
         }
 
-        if (getSalvageUnlockLevel() < 0) {
-            reason.add("Skills.Repair.Salvage.UnlockLevel should be at least 0!");
-        }
-
         List<ArcaneForging.Tier> arcaneForgingTierList = Arrays.asList(ArcaneForging.Tier.values());
 
         for (ArcaneForging.Tier tier : arcaneForgingTierList) {
@@ -414,6 +411,51 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
             }
         }
 
+        /* SALVAGE */
+        if (getSalvageMaxPercentage() < 1) {
+            reason.add("Skills.Salvage.MaxPercentage should be at least 1!");
+        }
+
+        if (getSalvageMaxPercentageLevel() < 1) {
+            reason.add("Skills.Salvage.MaxPercentageLevel should be at least 1!");
+        }
+
+        if (getAdvancedSalvageUnlockLevel() < 1) {
+            reason.add("Skills.Salvage.AdvancedSalvage.UnlockLevel should be at least 1!");
+        }
+
+        List<Salvage.Tier> salvageTierList = Arrays.asList(Salvage.Tier.values());
+
+        for (Salvage.Tier tier : salvageTierList) {
+            if (getArcaneSalvageRankLevel(tier) < 0) {
+                reason.add("Skills.Salvage.ArcaneSalvage.Rank_Levels.Rank_" + tier.toNumerical() + " should be at least 0!");
+            }
+
+            if (getArcaneSalvageExtractFullEnchantsChance(tier) < 0 || getArcaneSalvageExtractFullEnchantsChance(tier) > 100) {
+                reason.add("Skills.Salvage.ArcaneSalvage.ExtractFullEnchant.Rank_" + tier.toNumerical() + " only accepts values from 0 to 100!");
+            }
+
+            if (getArcaneSalvageExtractPartialEnchantsChance(tier) < 0 || getArcaneSalvageExtractPartialEnchantsChance(tier) > 100) {
+                reason.add("Skills.Salvage.ArcaneSalvage.ExtractPartialEnchant.Rank_" + tier.toNumerical() + " only accepts values from 0 to 100!");
+            }
+
+            if (tier != Salvage.Tier.EIGHT) {
+                Salvage.Tier nextTier = salvageTierList.get(salvageTierList.indexOf(tier) - 1);
+
+                if (getArcaneSalvageRankLevel(tier) >= getArcaneSalvageRankLevel(nextTier)) {
+                    reason.add("Skills.Salvage.ArcaneSalvage.Rank_Levels.Rank_" + tier.toNumerical() + " should be less than Skills.Salvage.ArcaneSalvage.Rank_Levels.Rank_" + nextTier.toNumerical() + "!");
+                }
+
+                if (getArcaneSalvageExtractFullEnchantsChance(tier) > getArcaneSalvageExtractFullEnchantsChance(nextTier)) {
+                    reason.add("Skills.Salvage.ArcaneSalvage.ExtractFullEnchant.Rank_" + tier.toNumerical() + " should be less than or equal to Skills.Salvage.ArcaneSalvage.ExtractFullEnchant.Rank_" + nextTier.toNumerical() + "!");
+                }
+
+                if (getArcaneSalvageExtractPartialEnchantsChance(tier) > getArcaneSalvageExtractPartialEnchantsChance(nextTier)) {
+                    reason.add("Skills.Salvage.ArcaneSalvage.ExtractPartialEnchant.Rank_" + tier.toNumerical() + " should be less than or equal to Skills.Salvage.ArcaneSalvage.ExtractPartialEnchant.Rank_" + nextTier.toNumerical() + "!");
+                }
+            }
+        }
+
         /* SMELTING */
         if (getBurnModifierMaxLevel() < 1) {
             reason.add("Skills.Smelting.FuelEfficiency.MaxBonusLevel should be at least 1!");
@@ -725,7 +767,6 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
     /* REPAIR */
     public double getRepairMasteryMaxBonus() { return config.getDouble("Skills.Repair.RepairMastery.MaxBonusPercentage", 200.0D); }
     public int getRepairMasteryMaxLevel() { return config.getInt("Skills.Repair.RepairMastery.MaxBonusLevel", 1000); }
-    public int getSalvageUnlockLevel() { return config.getInt("Skills.Repair.Salvage.UnlockLevel", 600); }
 
     /* Arcane Forging */
     public int getArcaneForgingRankLevel(ArcaneForging.Tier tier) { return config.getInt("Skills.Repair.ArcaneForging.Rank_Levels.Rank_" + tier.toNumerical()); }
@@ -736,6 +777,19 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
     public boolean getArcaneForgingDowngradeEnabled() { return config.getBoolean("Skills.Repair.ArcaneForging.Downgrades_Enabled", true); }
     public double getArcaneForgingDowngradeChance(ArcaneForging.Tier tier) { return config.getDouble("Skills.Repair.ArcaneForging.Downgrades_Chance.Rank_" + tier.toNumerical()); }
 
+    /* SALVAGE */
+    public double getSalvageMaxPercentage() { return config.getDouble("Skills.Salvage.MaxPercentage", 100.0D); }
+    public int getSalvageMaxPercentageLevel() { return config.getInt("Skills.Salvage.MaxPercentageLevel", 1000); }
+
+    public int getAdvancedSalvageUnlockLevel() { return config.getInt("Skills.Salvage.AdvancedSalvage.UnlockLevel", 350); }
+
+    public boolean getArcaneSalvageEnchantDowngradeEnabled() { return config.getBoolean("Skills.Salvage.ArcaneSalvage.EnchantDowngradeEnabled", true); }
+    public boolean getArcaneSalvageEnchantLossEnabled() { return config.getBoolean("Skills.Salvage.ArcaneSalvage.EnchantLossEnabled", true); }
+
+    public int getArcaneSalvageRankLevel(Salvage.Tier tier) { return config.getInt("Skills.Salvage.ArcaneSalvage.Rank_Levels.Rank_" + tier.toNumerical()); }
+    public double getArcaneSalvageExtractFullEnchantsChance(Salvage.Tier tier) { return config.getDouble("Skills.Salvage.ArcaneSalvage.ExtractFullEnchant.Rank_" + tier.toNumerical()); }
+    public double getArcaneSalvageExtractPartialEnchantsChance(Salvage.Tier tier) { return config.getDouble("Skills.Salvage.ArcaneSalvage.ExtractPartialEnchant.Rank_" + tier.toNumerical()); }
+
     /* SMELTING */
     public int getBurnModifierMaxLevel() { return config.getInt("Skills.Smelting.FuelEfficiency.MaxBonusLevel", 1000); }
     public double getBurnTimeMultiplier() { return config.getDouble("Skills.Smelting.FuelEfficiency.Multiplier", 3.0D); }

src/main/java/com/gmail/nossr50/config/Config.java

@@ -266,6 +266,11 @@ public class Config extends AutoUpdateConfigLoader {
     public int getMobHealthbarTime() { return config.getInt("Mob_Healthbar.Display_Time", 3); }
 
     /* Scoreboards */
+    public boolean getPowerLevelTagsEnabled() { return config.getBoolean("Scoreboard.Power_Level_Tags", false); }
+    public boolean getAllowKeepBoard() { return config.getBoolean("Scoreboard.Allow_Keep", true); }
+    public boolean getShowStatsAfterLogin() { return config.getBoolean("Scoreboard.Show_Stats_After_Login", false); }
+    public boolean getScoreboardRainbows() { return config.getBoolean("Scoreboard.Rainbows", false); }
+
     public boolean getRankUseChat() { return config.getBoolean("Scoreboard.Types.Rank.Print", false); }
     public boolean getRankUseBoard() { return config.getBoolean("Scoreboard.Types.Rank.Board", true); }
     public int getRankScoreboardTime() { return config.getInt("Scoreboard.Types.Rank.Display_Time", 10); }
@@ -291,11 +296,6 @@ public class Config extends AutoUpdateConfigLoader {
     public boolean getSkillLevelUpBoard() { return config.getBoolean("Scoreboard.Types.Skill.LevelUp_Board", true); }
     public int getSkillLevelUpTime() { return config.getInt("Scoreboard.Types.Skill.LevelUp_Time", 5); }
 
-    public boolean getPowerLevelTagsEnabled() { return config.getBoolean("Scoreboard.Power_Level_Tags", false); }
-
-    public boolean getAllowKeepBoard() { return config.getBoolean("Scoreboard.Allow_Keep", true); }
-    public boolean getScoreboardRainbows() { return config.getBoolean("Scoreboard.Rainbows", false); }
-
     /* Database Purging */
     public int getPurgeInterval() { return config.getInt("Database_Purging.Purge_Interval", -1); }
     public int getOldUsersCutoff() { return config.getInt("Database_Purging.Old_User_Cutoff", 6); }
@@ -448,7 +448,8 @@ public class Config extends AutoUpdateConfigLoader {
 
     /* Alchemy */
     public boolean getEnabledForHoppers() { return config.getBoolean("Skills.Alchemy.Enabled_for_Hoppers", true); }
-    public boolean getPreventHopperTransfer() { return config.getBoolean("Skills.Alchemy.Prevent_Hopper_Transfer", false); }
+    public boolean getPreventHopperTransferIngredients() { return config.getBoolean("Skills.Alchemy.Prevent_Hopper_Transfer_Ingredients", false); }
+    public boolean getPreventHopperTransferBottles() { return config.getBoolean("Skills.Alchemy.Prevent_Hopper_Transfer_Bottles", false); }
 
     /* Fishing */
     public boolean getFishingDropsEnabled() { return config.getBoolean("Skills.Fishing.Drops_Enabled", true); }
@@ -463,11 +464,15 @@ public class Config extends AutoUpdateConfigLoader {
     public boolean getRepairAnvilPlaceSoundsEnabled() { return config.getBoolean("Skills.Repair.Anvil_Placed_Sounds", true); }
     public boolean getRepairAnvilUseSoundsEnabled() { return config.getBoolean("Skills.Repair.Anvil_Use_Sounds", true); }
     public Material getRepairAnvilMaterial() { return Material.matchMaterial(config.getString("Skills.Repair.Anvil_Material", "IRON_BLOCK")); }
-    public Material getSalvageAnvilMaterial() { return Material.matchMaterial(config.getString("Skills.Repair.Salvage_Anvil_Material", "GOLD_BLOCK")); }
-    public boolean getSalvageTools() { return config.getBoolean("Skills.Repair.Salvage_tools", true); }
-    public boolean getSalvageArmor() { return config.getBoolean("Skills.Repair.Salvage_armor", true); }
     public boolean getRepairConfirmRequired() { return config.getBoolean("Skills.Repair.Confirm_Required", true); }
 
+    /* Salvage */
+    public boolean getSalvageAnvilMessagesEnabled() { return config.getBoolean("Skills.Salvage.Anvil_Messages", true); }
+    public boolean getSalvageAnvilPlaceSoundsEnabled() { return config.getBoolean("Skills.Salvage.Anvil_Placed_Sounds", true); }
+    public boolean getSalvageAnvilUseSoundsEnabled() { return config.getBoolean("Skills.Salvage.Anvil_Use_Sounds", true); }
+    public Material getSalvageAnvilMaterial() { return Material.matchMaterial(config.getString("Skills.Salvage.Anvil_Material", "GOLD_BLOCK")); }
+    public boolean getSalvageConfirmRequired() { return config.getBoolean("Skills.Salvage.Confirm_Required", true); }
+
     /* Unarmed */
     public boolean getUnarmedBlockCrackerSmoothbrickToCracked() { return config.getBoolean("Skills.Unarmed.Block_Cracker.SmoothBrick_To_CrackedBrick", true); }
 

src/main/java/com/gmail/nossr50/config/experience/ExperienceConfig.java

@@ -11,8 +11,9 @@ import org.bukkit.material.MaterialData;
 
 import com.gmail.nossr50.config.AutoUpdateConfigLoader;
 import com.gmail.nossr50.datatypes.experience.FormulaType;
+import com.gmail.nossr50.datatypes.skills.MaterialType;
 import com.gmail.nossr50.datatypes.skills.SkillType;
-import com.gmail.nossr50.skills.repair.repairables.RepairMaterialType;
+import com.gmail.nossr50.datatypes.skills.alchemy.PotionStage;
 import com.gmail.nossr50.util.StringUtils;
 
 public class ExperienceConfig extends AutoUpdateConfigLoader {
@@ -80,8 +81,10 @@ public class ExperienceConfig extends AutoUpdateConfigLoader {
          */
 
         /* Alchemy */
-        if (getPotionXP() <= 0) {
-            reason.add("Experience.Alchemy.Potion should be greater than 0!");
+        for (PotionStage potionStage : PotionStage.values()) {
+            if (getPotionXP(potionStage) < 0) {
+                reason.add("Experience.Alchemy.Potion_Stage_" + potionStage.toNumerical() + " should be at least 0!");
+            }
         }
 
         /* Combat XP Multipliers */
@@ -157,7 +160,7 @@ public class ExperienceConfig extends AutoUpdateConfigLoader {
     /* Curve values */
     public double getMultiplier(FormulaType type) { return config.getDouble("Experience_Formula." + StringUtils.getCapitalized(type.toString()) + "_Values.multiplier"); }
     public int getBase(FormulaType type) { return config.getInt("Experience_Formula." + StringUtils.getCapitalized(type.toString()) + "_Values.base"); }
-    public double getExponent(FormulaType type) { return config.getDouble("Experience_Formula." + StringUtils.getCapitalized(type.toString()) +"_Values.exponent"); }
+    public double getExponent(FormulaType type) { return config.getDouble("Experience_Formula." + StringUtils.getCapitalized(type.toString()) + "_Values.exponent"); }
 
     /* Global modifier */
     public double getExperienceGainsGlobalMultiplier() { return config.getDouble("Experience_Formula.Multiplier.Global", 1.0); }
@@ -201,7 +204,7 @@ public class ExperienceConfig extends AutoUpdateConfigLoader {
     public double getFeatherFallXPModifier() { return config.getDouble("Experience.Acrobatics.FeatherFall_Multiplier", 2.0); }
 
     /* Alchemy */
-    public double getPotionXP() { return config.getDouble("Experience.Alchemy.Potion", 150D); }
+    public double getPotionXP(PotionStage stage) { return config.getDouble("Experience.Alchemy.Potion_Stage_" + stage.toNumerical(), 10D); }
 
     /* Fishing */
     public int getFishXp(MaterialData data) {
@@ -308,7 +311,7 @@ public class ExperienceConfig extends AutoUpdateConfigLoader {
 
     /* Repair */
     public double getRepairXPBase() { return config.getDouble("Experience.Repair.Base", 1000.0); }
-    public double getRepairXP(RepairMaterialType repairMaterialType) { return config.getDouble("Experience.Repair." + StringUtils.getCapitalized(repairMaterialType.toString())); }
+    public double getRepairXP(MaterialType repairMaterialType) { return config.getDouble("Experience.Repair." + StringUtils.getCapitalized(repairMaterialType.toString())); }
 
     /* Taming */
     public int getTamingXPHorse() { return config.getInt("Experience.Taming.Animal_Taming.Horse", 1000); }

src/main/java/com/gmail/nossr50/config/mods/CustomArmorConfig.java

@@ -9,11 +9,11 @@ import org.bukkit.configuration.ConfigurationSection;
 import org.bukkit.inventory.ItemStack;
 
 import com.gmail.nossr50.config.ConfigLoader;
-import com.gmail.nossr50.skills.repair.Repair;
-import com.gmail.nossr50.skills.repair.repairables.RepairItemType;
-import com.gmail.nossr50.skills.repair.repairables.RepairMaterialType;
+import com.gmail.nossr50.datatypes.skills.ItemType;
+import com.gmail.nossr50.datatypes.skills.MaterialType;
 import com.gmail.nossr50.skills.repair.repairables.Repairable;
 import com.gmail.nossr50.skills.repair.repairables.RepairableFactory;
+import com.gmail.nossr50.util.skills.SkillUtils;
 
 public class CustomArmorConfig extends ConfigLoader {
     private boolean needsUpdate = false;
@@ -79,7 +79,7 @@ public class CustomArmorConfig extends ConfigLoader {
 
             if (repairable) {
                 byte repairData = (byte) config.getInt(armorType + "." + armorName + ".Repair_Material_Data_Value", -1);
-                int repairQuantity = Repair.getRepairAndSalvageQuantities(new ItemStack(armorMaterial), repairMaterial, repairData);
+                int repairQuantity = SkillUtils.getRepairAndSalvageQuantities(new ItemStack(armorMaterial), repairMaterial, repairData);
 
                 if (repairQuantity == 0) {
                     repairQuantity = config.getInt(armorType + "." + armorName + ".Repair_Material_Data_Quantity", 2);
@@ -91,7 +91,7 @@ public class CustomArmorConfig extends ConfigLoader {
                     durability = (short) config.getInt(armorType + "." + armorName + ".Durability", 70);
                 }
 
-                repairables.add(RepairableFactory.getRepairable(armorMaterial, repairMaterial, repairData, 0, repairQuantity, durability, RepairItemType.ARMOR, RepairMaterialType.OTHER, 1.0));
+                repairables.add(RepairableFactory.getRepairable(armorMaterial, repairMaterial, repairData, 0, repairQuantity, durability, ItemType.ARMOR, MaterialType.OTHER, 1.0));
             }
 
             materialList.add(armorMaterial);

src/main/java/com/gmail/nossr50/config/mods/CustomToolConfig.java

@@ -11,11 +11,11 @@ import org.bukkit.inventory.ItemStack;
 
 import com.gmail.nossr50.config.ConfigLoader;
 import com.gmail.nossr50.datatypes.mods.CustomTool;
-import com.gmail.nossr50.skills.repair.Repair;
-import com.gmail.nossr50.skills.repair.repairables.RepairItemType;
-import com.gmail.nossr50.skills.repair.repairables.RepairMaterialType;
+import com.gmail.nossr50.datatypes.skills.ItemType;
+import com.gmail.nossr50.datatypes.skills.MaterialType;
 import com.gmail.nossr50.skills.repair.repairables.Repairable;
 import com.gmail.nossr50.skills.repair.repairables.RepairableFactory;
+import com.gmail.nossr50.util.skills.SkillUtils;
 
 public class CustomToolConfig extends ConfigLoader {
     private boolean needsUpdate = false;
@@ -87,7 +87,7 @@ public class CustomToolConfig extends ConfigLoader {
 
             if (repairable) {
                 byte repairData = (byte) config.getInt(toolType + "." + toolName + ".Repair_Material_Data_Value", -1);
-                int repairQuantity = Repair.getRepairAndSalvageQuantities(new ItemStack(toolMaterial), repairMaterial, repairData);
+                int repairQuantity = SkillUtils.getRepairAndSalvageQuantities(new ItemStack(toolMaterial), repairMaterial, repairData);
 
                 if (repairQuantity == 0) {
                     repairQuantity = config.getInt(toolType + "." + toolName + ".Repair_Material_Data_Quantity", 2);
@@ -99,7 +99,7 @@ public class CustomToolConfig extends ConfigLoader {
                     durability = (short) config.getInt(toolType + "." + toolName + ".Durability", 60);
                 }
 
-                repairables.add(RepairableFactory.getRepairable(toolMaterial, repairMaterial, repairData, 0, repairQuantity, durability, RepairItemType.TOOL, RepairMaterialType.OTHER, 1.0));
+                repairables.add(RepairableFactory.getRepairable(toolMaterial, repairMaterial, repairData, 0, repairQuantity, durability, ItemType.TOOL, MaterialType.OTHER, 1.0));
             }
 
             double multiplier = config.getDouble(toolType + "." + toolName + ".XP_Modifier", 1.0);

src/main/java/com/gmail/nossr50/config/skills/repair/RepairConfig.java

@@ -9,12 +9,12 @@ import org.bukkit.configuration.ConfigurationSection;
 import org.bukkit.inventory.ItemStack;
 
 import com.gmail.nossr50.config.ConfigLoader;
-import com.gmail.nossr50.skills.repair.Repair;
-import com.gmail.nossr50.skills.repair.repairables.RepairItemType;
-import com.gmail.nossr50.skills.repair.repairables.RepairMaterialType;
+import com.gmail.nossr50.datatypes.skills.ItemType;
+import com.gmail.nossr50.datatypes.skills.MaterialType;
 import com.gmail.nossr50.skills.repair.repairables.Repairable;
 import com.gmail.nossr50.skills.repair.repairables.RepairableFactory;
 import com.gmail.nossr50.util.ItemUtils;
+import com.gmail.nossr50.util.skills.SkillUtils;
 
 public class RepairConfig extends ConfigLoader {
     private List<Repairable> repairables;
@@ -48,37 +48,37 @@ public class RepairConfig extends ConfigLoader {
             }
 
             // Repair Material Type
-            RepairMaterialType repairMaterialType = RepairMaterialType.OTHER;
+            MaterialType repairMaterialType = MaterialType.OTHER;
             String repairMaterialTypeString = config.getString("Repairables." + key + ".MaterialType", "OTHER");
 
             if (!config.contains("Repairables." + key + ".MaterialType") && itemMaterial != null) {
                 ItemStack repairItem = new ItemStack(itemMaterial);
 
                 if (ItemUtils.isWoodTool(repairItem)) {
-                    repairMaterialType = RepairMaterialType.WOOD;
+                    repairMaterialType = MaterialType.WOOD;
                 }
                 else if (ItemUtils.isStoneTool(repairItem)) {
-                    repairMaterialType = RepairMaterialType.STONE;
+                    repairMaterialType = MaterialType.STONE;
                 }
                 else if (ItemUtils.isStringTool(repairItem)) {
-                    repairMaterialType = RepairMaterialType.STRING;
+                    repairMaterialType = MaterialType.STRING;
                 }
                 else if (ItemUtils.isLeatherArmor(repairItem)) {
-                    repairMaterialType = RepairMaterialType.LEATHER;
+                    repairMaterialType = MaterialType.LEATHER;
                 }
                 else if (ItemUtils.isIronArmor(repairItem) || ItemUtils.isIronTool(repairItem)) {
-                    repairMaterialType = RepairMaterialType.IRON;
+                    repairMaterialType = MaterialType.IRON;
                 }
                 else if (ItemUtils.isGoldArmor(repairItem) || ItemUtils.isGoldTool(repairItem)) {
-                    repairMaterialType = RepairMaterialType.GOLD;
+                    repairMaterialType = MaterialType.GOLD;
                 }
                 else if (ItemUtils.isDiamondArmor(repairItem) || ItemUtils.isDiamondTool(repairItem)) {
-                    repairMaterialType = RepairMaterialType.DIAMOND;
+                    repairMaterialType = MaterialType.DIAMOND;
                 }
             }
             else {
                 try {
-                    repairMaterialType = RepairMaterialType.valueOf(repairMaterialTypeString);
+                    repairMaterialType = MaterialType.valueOf(repairMaterialTypeString);
                 }
                 catch (IllegalArgumentException ex) {
                     reason.add(key + " has an invalid MaterialType of " + repairMaterialTypeString);
@@ -87,7 +87,7 @@ public class RepairConfig extends ConfigLoader {
 
             // Repair Material
             String repairMaterialName = config.getString("Repairables." + key + ".RepairMaterial");
-            Material repairMaterial = (repairMaterialName == null ? repairMaterialType.getDefaultRepairMaterial() : Material.matchMaterial(repairMaterialName));
+            Material repairMaterial = (repairMaterialName == null ? repairMaterialType.getDefaultMaterial() : Material.matchMaterial(repairMaterialName));
 
             if (repairMaterial == null) {
                 reason.add(key + " has an invalid repair material: " + repairMaterialName);
@@ -105,22 +105,22 @@ public class RepairConfig extends ConfigLoader {
             }
 
             // Item Type
-            RepairItemType repairItemType = RepairItemType.OTHER;
+            ItemType repairItemType = ItemType.OTHER;
             String repairItemTypeString = config.getString("Repairables." + key + ".ItemType", "OTHER");
 
             if (!config.contains("Repairables." + key + ".ItemType") && itemMaterial != null) {
                 ItemStack repairItem = new ItemStack(itemMaterial);
 
                 if (ItemUtils.isMinecraftTool(repairItem)) {
-                    repairItemType = RepairItemType.TOOL;
+                    repairItemType = ItemType.TOOL;
                 }
                 else if (ItemUtils.isArmor(repairItem)) {
-                    repairItemType = RepairItemType.ARMOR;
+                    repairItemType = ItemType.ARMOR;
                 }
             }
             else {
                 try {
-                    repairItemType = RepairItemType.valueOf(repairItemTypeString);
+                    repairItemType = ItemType.valueOf(repairItemTypeString);
                 }
                 catch (IllegalArgumentException ex) {
                     reason.add(key + " has an invalid ItemType of " + repairItemTypeString);
@@ -136,7 +136,7 @@ public class RepairConfig extends ConfigLoader {
             }
 
             // Minimum Quantity
-            int minimumQuantity = (itemMaterial != null ? Repair.getRepairAndSalvageQuantities(new ItemStack(itemMaterial), repairMaterial, repairMetadata) : config.getInt("Repairables." + key + ".MinimumQuantity", 2));
+            int minimumQuantity = (itemMaterial != null ? SkillUtils.getRepairAndSalvageQuantities(new ItemStack(itemMaterial), repairMaterial, repairMetadata) : config.getInt("Repairables." + key + ".MinimumQuantity", 2));
 
             if (minimumQuantity <= 0 && itemMaterial != null) {
                 minimumQuantity = config.getInt("Repairables." + key + ".MinimumQuantity", 2);

src/main/java/com/gmail/nossr50/config/skills/salvage/SalvageConfig.java

@@ -0,0 +1,165 @@
+package com.gmail.nossr50.config.skills.salvage;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+
+import org.bukkit.Material;
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.inventory.ItemStack;
+
+import com.gmail.nossr50.config.ConfigLoader;
+import com.gmail.nossr50.datatypes.skills.ItemType;
+import com.gmail.nossr50.datatypes.skills.MaterialType;
+import com.gmail.nossr50.skills.salvage.salvageables.Salvageable;
+import com.gmail.nossr50.skills.salvage.salvageables.SalvageableFactory;
+import com.gmail.nossr50.util.ItemUtils;
+import com.gmail.nossr50.util.skills.SkillUtils;
+
+public class SalvageConfig extends ConfigLoader {
+    private List<Salvageable> salvageables;
+
+    public SalvageConfig(String fileName) {
+        super(fileName);
+        loadKeys();
+    }
+
+    @Override
+    protected void loadKeys() {
+        salvageables = new ArrayList<Salvageable>();
+
+        ConfigurationSection section = config.getConfigurationSection("Salvageables");
+        Set<String> keys = section.getKeys(false);
+
+        for (String key : keys) {
+            // Validate all the things!
+            List<String> reason = new ArrayList<String>();
+
+            // Item Material
+            Material itemMaterial = Material.matchMaterial(key);
+
+            if (itemMaterial == null) {
+                reason.add("Invalid material: " + key);
+            }
+
+            // Salvage Material Type
+            MaterialType salvageMaterialType = MaterialType.OTHER;
+            String salvageMaterialTypeString = config.getString("Salvageables." + key + ".MaterialType", "OTHER");
+
+            if (!config.contains("Salvageables." + key + ".MaterialType") && itemMaterial != null) {
+                ItemStack salvageItem = new ItemStack(itemMaterial);
+
+                if (ItemUtils.isWoodTool(salvageItem)) {
+                    salvageMaterialType = MaterialType.WOOD;
+                }
+                else if (ItemUtils.isStoneTool(salvageItem)) {
+                    salvageMaterialType = MaterialType.STONE;
+                }
+                else if (ItemUtils.isStringTool(salvageItem)) {
+                    salvageMaterialType = MaterialType.STRING;
+                }
+                else if (ItemUtils.isLeatherArmor(salvageItem)) {
+                    salvageMaterialType = MaterialType.LEATHER;
+                }
+                else if (ItemUtils.isIronArmor(salvageItem) || ItemUtils.isIronTool(salvageItem)) {
+                    salvageMaterialType = MaterialType.IRON;
+                }
+                else if (ItemUtils.isGoldArmor(salvageItem) || ItemUtils.isGoldTool(salvageItem)) {
+                    salvageMaterialType = MaterialType.GOLD;
+                }
+                else if (ItemUtils.isDiamondArmor(salvageItem) || ItemUtils.isDiamondTool(salvageItem)) {
+                    salvageMaterialType = MaterialType.DIAMOND;
+                }
+            }
+            else {
+                try {
+                    salvageMaterialType = MaterialType.valueOf(salvageMaterialTypeString);
+                }
+                catch (IllegalArgumentException ex) {
+                    reason.add(key + " has an invalid MaterialType of " + salvageMaterialTypeString);
+                }
+            }
+
+            // Salvage Material
+            String salvageMaterialName = config.getString("Salvageables." + key + ".SalvageMaterial");
+            Material salvageMaterial = (salvageMaterialName == null ? salvageMaterialType.getDefaultMaterial() : Material.matchMaterial(salvageMaterialName));
+
+            if (salvageMaterial == null) {
+                reason.add(key + " has an invalid salvage material: " + salvageMaterialName);
+            }
+
+            // Maximum Durability
+            short maximumDurability = (itemMaterial != null ? itemMaterial.getMaxDurability() : (short) config.getInt("Salvageables." + key + ".MaximumDurability"));
+
+            // Item Type
+            ItemType salvageItemType = ItemType.OTHER;
+            String salvageItemTypeString = config.getString("Salvageables." + key + ".ItemType", "OTHER");
+
+            if (!config.contains("Salvageables." + key + ".ItemType") && itemMaterial != null) {
+                ItemStack salvageItem = new ItemStack(itemMaterial);
+
+                if (ItemUtils.isMinecraftTool(salvageItem)) {
+                    salvageItemType = ItemType.TOOL;
+                }
+                else if (ItemUtils.isArmor(salvageItem)) {
+                    salvageItemType = ItemType.ARMOR;
+                }
+            }
+            else {
+                try {
+                    salvageItemType = ItemType.valueOf(salvageItemTypeString);
+                }
+                catch (IllegalArgumentException ex) {
+                    reason.add(key + " has an invalid ItemType of " + salvageItemTypeString);
+                }
+            }
+
+            byte salvageMetadata = (byte) config.getInt("Salvageables." + key + ".SalvageMaterialMetadata", -1);
+            int minimumLevel = config.getInt("Salvageables." + key + ".MinimumLevel");
+            double xpMultiplier = config.getDouble("Salvageables." + key + ".XpMultiplier", 1);
+
+            if (minimumLevel < 0) {
+                reason.add(key + " has an invalid MinimumLevel of " + minimumLevel);
+            }
+
+            // Maximum Quantity
+            int maximumQuantity = (itemMaterial != null ? SkillUtils.getRepairAndSalvageQuantities(new ItemStack(itemMaterial), salvageMaterial, salvageMetadata) : config.getInt("Salvageables." + key + ".MaximumQuantity", 2));
+
+            if (maximumQuantity <= 0 && itemMaterial != null) {
+                maximumQuantity = config.getInt("Salvageables." + key + ".MaximumQuantity", 2);
+            }
+
+            int configMaximumQuantity = config.getInt("Salvageables." + key + ".MaximumQuantity", -1);
+
+            if (configMaximumQuantity > 0) {
+                maximumQuantity = configMaximumQuantity;
+            }
+
+            if (maximumQuantity <= 0) {
+                reason.add("Maximum quantity of " + key + " must be greater than 0!");
+            }
+
+            if (noErrorsInSalvageable(reason)) {
+                Salvageable salvageable = SalvageableFactory.getSalvageable(itemMaterial, salvageMaterial, salvageMetadata, minimumLevel, maximumQuantity, maximumDurability, salvageItemType, salvageMaterialType, xpMultiplier);
+                salvageables.add(salvageable);
+            }
+        }
+    }
+
+    protected List<Salvageable> getLoadedSalvageables() {
+        return salvageables == null ? new ArrayList<Salvageable>() : salvageables;
+    }
+
+    private boolean noErrorsInSalvageable(List<String> issues) {
+        if (!issues.isEmpty()) {
+            plugin.getLogger().warning("Errors have been found in: " + fileName);
+            plugin.getLogger().warning("The following issues were found:");
+        }
+
+        for (String issue : issues) {
+            plugin.getLogger().warning(issue);
+        }
+
+        return issues.isEmpty();
+    }
+}

src/main/java/com/gmail/nossr50/config/skills/salvage/SalvageConfigManager.java

@@ -0,0 +1,42 @@
+package com.gmail.nossr50.config.skills.salvage;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Pattern;
+
+import com.gmail.nossr50.mcMMO;
+import com.gmail.nossr50.skills.salvage.salvageables.Salvageable;
+
+public class SalvageConfigManager {
+    private final List<Salvageable> salvageables = new ArrayList<Salvageable>();
+
+    public SalvageConfigManager(mcMMO plugin) {
+        Pattern pattern = Pattern.compile("salvage\\.(?:.+)\\.yml");
+        File dataFolder = plugin.getDataFolder();
+        File vanilla = new File(dataFolder, "salvage.vanilla.yml");
+
+        if (!vanilla.exists()) {
+            plugin.saveResource("salvage.vanilla.yml", false);
+        }
+
+        for (String fileName : dataFolder.list()) {
+            if (!pattern.matcher(fileName).matches()) {
+                continue;
+            }
+
+            File file = new File(dataFolder, fileName);
+
+            if (file.isDirectory()) {
+                continue;
+            }
+
+            SalvageConfig salvageConfig = new SalvageConfig(fileName);
+            salvageables.addAll(salvageConfig.getLoadedSalvageables());
+        }
+    }
+
+    public List<Salvageable> getLoadedSalvageables() {
+        return salvageables;
+    }
+}

src/main/java/com/gmail/nossr50/config/treasure/TreasureConfig.java

@@ -160,26 +160,29 @@ public class TreasureConfig extends ConfigLoader {
             // Validate all the things!
             List<String> reason = new ArrayList<String>();
 
+            String[] treasureInfo = treasureName.split("[|]");
+            String materialName = treasureInfo[0];
+
             /*
              * Material, Amount, and Data
              */
             Material material;
 
-            if (treasureName.contains("POTION")) {
+            if (materialName.contains("POTION")) {
                 material = Material.POTION;
             }
-            else if (treasureName.contains("INK_SACK")) {
+            else if (materialName.contains("INK_SACK")) {
                 material = Material.INK_SACK;
             }
             else {
-                material = Material.matchMaterial(treasureName);
+                material = Material.matchMaterial(materialName);
             }
 
             int amount = config.getInt(type + "." + treasureName + ".Amount");
-            int data = config.getInt(type + "." + treasureName + ".Data");
+            short data = (treasureInfo.length == 2) ? Byte.valueOf(treasureInfo[1]) : (short) config.getInt(type + "." + treasureName + ".Data");
 
             if (material == null) {
-                reason.add("Invalid material: " + treasureName);
+                reason.add("Invalid material: " + materialName);
             }
 
             if (amount <= 0) {
@@ -228,8 +231,8 @@ public class TreasureConfig extends ConfigLoader {
              */
             ItemStack item = null;
 
-            if (treasureName.contains("POTION")) {
-                String potionType = treasureName.substring(7);
+            if (materialName.contains("POTION")) {
+                String potionType = materialName.substring(7);
 
                 try {
                     item = new Potion(PotionType.valueOf(potionType.toUpperCase().trim())).toItemStack(amount);
@@ -238,8 +241,8 @@ public class TreasureConfig extends ConfigLoader {
                     reason.add("Invalid Potion_Type: " + potionType);
                 }
             }
-            else if (treasureName.contains("INK_SACK")) {
-                String color = treasureName.substring(9);
+            else if (materialName.contains("INK_SACK")) {
+                String color = materialName.substring(9);
 
                 try {
                     Dye dye = new Dye();
@@ -252,7 +255,7 @@ public class TreasureConfig extends ConfigLoader {
                 }
             }
             else if (material != null) {
-                item = new ItemStack(material, amount, (short) data);
+                item = new ItemStack(material, amount, data);
 
                 if (config.contains(type + "." + treasureName + ".Custom_Name")) {
                     ItemMeta itemMeta = item.getItemMeta();

src/main/java/com/gmail/nossr50/datatypes/party/Party.java

@@ -185,7 +185,7 @@ public class Party {
 
     public String getXpToLevelPercentage() {
         DecimalFormat percent = new DecimalFormat("##0.00%");
-        return percent.format( this.getXp() / getXpToLevel());
+        return percent.format(this.getXp() / getXpToLevel());
     }
 
     /**

src/main/java/com/gmail/nossr50/datatypes/player/McMMOPlayer.java

@@ -24,6 +24,7 @@ import com.gmail.nossr50.datatypes.party.PartyTeleportRecord;
 import com.gmail.nossr50.datatypes.skills.AbilityType;
 import com.gmail.nossr50.datatypes.skills.SkillType;
 import com.gmail.nossr50.datatypes.skills.ToolType;
+import com.gmail.nossr50.datatypes.skills.XPGainReason;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.party.PartyManager;
 import com.gmail.nossr50.party.ShareHandler;
@@ -40,6 +41,7 @@ import com.gmail.nossr50.skills.fishing.FishingManager;
 import com.gmail.nossr50.skills.herbalism.HerbalismManager;
 import com.gmail.nossr50.skills.mining.MiningManager;
 import com.gmail.nossr50.skills.repair.RepairManager;
+import com.gmail.nossr50.skills.salvage.SalvageManager;
 import com.gmail.nossr50.skills.smelting.SmeltingManager;
 import com.gmail.nossr50.skills.swords.SwordsManager;
 import com.gmail.nossr50.skills.taming.TamingManager;
@@ -223,6 +225,10 @@ public class McMMOPlayer {
         return (RepairManager) skillManagers.get(SkillType.REPAIR);
     }
 
+    public SalvageManager getSalvageManager() {
+        return (SalvageManager) skillManagers.get(SkillType.SALVAGE);
+    }
+
     public SmeltingManager getSmeltingManager() {
         return (SmeltingManager) skillManagers.get(SkillType.SMELTING);
     }
@@ -453,7 +459,7 @@ public class McMMOPlayer {
      * @param skill Skill being used
      * @param xp Experience amount to process
      */
-    public void beginXpGain(SkillType skill, float xp) {
+    public void beginXpGain(SkillType skill, float xp, XPGainReason xpGainReason) {
         Validate.isTrue(xp >= 0.0, "XP gained should be greater than or equal to zero.");
 
         if (xp <= 0.0) {
@@ -466,7 +472,7 @@ public class McMMOPlayer {
 
             for (SkillType parentSkill : parentSkills) {
                 if (parentSkill.getPermissions(player)) {
-                    beginXpGain(parentSkill, splitXp);
+                    beginXpGain(parentSkill, splitXp, xpGainReason);
                 }
             }
 
@@ -474,11 +480,11 @@ public class McMMOPlayer {
         }
 
         // Return if the experience has been shared
-        if (party != null && ShareHandler.handleXpShare(xp, this, skill)) {
+        if (party != null && ShareHandler.handleXpShare(xp, this, skill, ShareHandler.getSharedXpGainReason(xpGainReason))) {
             return;
         }
 
-        beginUnsharedXpGain(skill, xp);
+        beginUnsharedXpGain(skill, xp, xpGainReason);
     }
 
     /**
@@ -487,8 +493,8 @@ public class McMMOPlayer {
      * @param skill Skill being used
      * @param xp Experience amount to process
      */
-    public void beginUnsharedXpGain(SkillType skill, float xp) {
-        applyXpGain(skill, modifyXpGain(skill, xp));
+    public void beginUnsharedXpGain(SkillType skill, float xp, XPGainReason xpGainReason) {
+        applyXpGain(skill, modifyXpGain(skill, xp), xpGainReason);
 
         if (party == null) {
             return;
@@ -505,7 +511,7 @@ public class McMMOPlayer {
      * @param skillType Skill being used
      * @param xp Experience amount to add
      */
-    public void applyXpGain(SkillType skillType, float xp) {
+    public void applyXpGain(SkillType skillType, float xp, XPGainReason xpGainReason) {
         if (!skillType.getPermissions(player)) {
             return;
         }
@@ -514,18 +520,18 @@ public class McMMOPlayer {
             Set<SkillType> parentSkills = FamilyTree.getParents(skillType);
 
             for (SkillType parentSkill : parentSkills) {
-                applyXpGain(parentSkill, xp / parentSkills.size());
+                applyXpGain(parentSkill, xp / parentSkills.size(), xpGainReason);
             }
 
             return;
         }
 
-        if (!EventUtils.handleXpGainEvent(player, skillType, xp)) {
+        if (!EventUtils.handleXpGainEvent(player, skillType, xp, xpGainReason)) {
             return;
         }
 
         isUsingUnarmed = (skillType == SkillType.UNARMED);
-        checkXp(skillType);
+        checkXp(skillType, xpGainReason);
     }
 
     /**
@@ -533,7 +539,7 @@ public class McMMOPlayer {
      *
      * @param skillType The skill to check
      */
-    private void checkXp(SkillType skillType) {
+    private void checkXp(SkillType skillType, XPGainReason xpGainReason) {
         if (getSkillXpLevelRaw(skillType) < getXpToLevel(skillType)) {
             return;
         }
@@ -551,7 +557,7 @@ public class McMMOPlayer {
             levelsGained++;
         }
 
-        if (!EventUtils.handleLevelChangeEvent(player, skillType, levelsGained, xpRemoved, true)) {
+        if (!EventUtils.handleLevelChangeEvent(player, skillType, levelsGained, xpRemoved, true, xpGainReason)) {
             return;
         }
 

src/main/java/com/gmail/nossr50/datatypes/player/PlayerProfile.java

@@ -11,6 +11,7 @@ import com.gmail.nossr50.datatypes.MobHealthbarType;
 import com.gmail.nossr50.datatypes.experience.FormulaType;
 import com.gmail.nossr50.datatypes.skills.AbilityType;
 import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.runnables.player.PlayerProfileSaveTask;
 import com.gmail.nossr50.skills.child.FamilyTree;
 import com.gmail.nossr50.util.player.UserManager;
 
@@ -19,7 +20,7 @@ import com.google.common.collect.ImmutableMap;
 public class PlayerProfile {
     private final String playerName;
     private boolean loaded;
-    private boolean changed;
+    private volatile boolean changed;
 
     /* HUDs */
     private MobHealthbarType mobHealthbarType;
@@ -60,12 +61,18 @@ public class PlayerProfile {
         loaded = true;
     }
 
+    public void scheduleAsyncSave() {
+        new PlayerProfileSaveTask(this).runTaskAsynchronously(mcMMO.p);
+    }
+
     public void save() {
         if (!changed || !loaded) {
             return;
         }
 
-        changed = !mcMMO.getDatabaseManager().saveUser(new PlayerProfile(playerName, ImmutableMap.copyOf(skills), ImmutableMap.copyOf(skillsXp), ImmutableMap.copyOf(abilityDATS), mobHealthbarType));
+        // TODO should this part be synchronized?
+        PlayerProfile profileCopy = new PlayerProfile(playerName, ImmutableMap.copyOf(skills), ImmutableMap.copyOf(skillsXp), ImmutableMap.copyOf(abilityDATS), mobHealthbarType);
+        changed = !mcMMO.getDatabaseManager().saveUser(profileCopy);
 
         if (changed) {
             mcMMO.p.getLogger().warning("PlayerProfile for " + playerName + " failed to save");

src/main/java/com/gmail/nossr50/datatypes/skills/ItemType.java

@@ -0,0 +1,7 @@
+package com.gmail.nossr50.datatypes.skills;
+
+public enum ItemType {
+    ARMOR,
+    TOOL,
+    OTHER;
+}

src/main/java/com/gmail/nossr50/datatypes/skills/MaterialType.java

@@ -0,0 +1,43 @@
+package com.gmail.nossr50.datatypes.skills;
+
+import org.bukkit.Material;
+
+public enum MaterialType {
+    STRING,
+    LEATHER,
+    WOOD,
+    STONE,
+    IRON,
+    GOLD,
+    DIAMOND,
+    OTHER;
+
+    public Material getDefaultMaterial() {
+        switch (this) {
+            case STRING:
+                return Material.STRING;
+
+            case LEATHER:
+                return Material.LEATHER;
+
+            case WOOD:
+                return Material.WOOD;
+
+            case STONE:
+                return Material.COBBLESTONE;
+
+            case IRON:
+                return Material.IRON_INGOT;
+
+            case GOLD:
+                return Material.GOLD_INGOT;
+
+            case DIAMOND:
+                return Material.DIAMOND;
+
+            case OTHER:
+            default:
+                return null;
+        }
+    }
+}

src/main/java/com/gmail/nossr50/datatypes/skills/SecondaryAbility.java

@@ -46,9 +46,12 @@ public enum SecondaryAbility {
     /* Repair */
     ARCANE_FORGING,
     REPAIR_MASTERY,
-    SALVAGE,
     SUPER_REPAIR,
 
+    /* Salvage */
+    ADVANCED_SALVAGE,
+    ARCANE_SALVAGE,
+
     /* Smelting */
     FLUX_MINING,
     FUEL_EFFICIENCY,

src/main/java/com/gmail/nossr50/datatypes/skills/SkillType.java

@@ -23,6 +23,7 @@ import com.gmail.nossr50.skills.fishing.FishingManager;
 import com.gmail.nossr50.skills.herbalism.HerbalismManager;
 import com.gmail.nossr50.skills.mining.MiningManager;
 import com.gmail.nossr50.skills.repair.RepairManager;
+import com.gmail.nossr50.skills.salvage.SalvageManager;
 import com.gmail.nossr50.skills.smelting.SmeltingManager;
 import com.gmail.nossr50.skills.swords.SwordsManager;
 import com.gmail.nossr50.skills.taming.TamingManager;
@@ -43,7 +44,8 @@ public enum SkillType {
     FISHING(FishingManager.class, Color.NAVY, ImmutableList.of(SecondaryAbility.FISHERMANS_DIET, SecondaryAbility.FISHING_TREASURE_HUNTER, SecondaryAbility.ICE_FISHING, SecondaryAbility.MAGIC_HUNTER, SecondaryAbility.MASTER_ANGLER, SecondaryAbility.SHAKE)),
     HERBALISM(HerbalismManager.class, Color.GREEN, AbilityType.GREEN_TERRA, ToolType.HOE, ImmutableList.of(SecondaryAbility.FARMERS_DIET, SecondaryAbility.GREEN_THUMB_PLANT, SecondaryAbility.GREEN_THUMB_BLOCK, SecondaryAbility.HERBALISM_DOUBLE_DROPS, SecondaryAbility.HYLIAN_LUCK, SecondaryAbility.SHROOM_THUMB)),
     MINING(MiningManager.class, Color.GRAY, AbilityType.SUPER_BREAKER, ToolType.PICKAXE, ImmutableList.of(SecondaryAbility.MINING_DOUBLE_DROPS)),
-    REPAIR(RepairManager.class, Color.SILVER, ImmutableList.of(SecondaryAbility.ARCANE_FORGING, SecondaryAbility.REPAIR_MASTERY, SecondaryAbility.SALVAGE, SecondaryAbility.SUPER_REPAIR)),
+    REPAIR(RepairManager.class, Color.SILVER, ImmutableList.of(SecondaryAbility.ARCANE_FORGING, SecondaryAbility.REPAIR_MASTERY, SecondaryAbility.SUPER_REPAIR)),
+    SALVAGE(SalvageManager.class, Color.ORANGE, ImmutableList.of(SecondaryAbility.ADVANCED_SALVAGE, SecondaryAbility.ARCANE_SALVAGE)),
     SMELTING(SmeltingManager.class, Color.YELLOW, ImmutableList.of(SecondaryAbility.FLUX_MINING, SecondaryAbility.FUEL_EFFICIENCY, SecondaryAbility.SECOND_SMELT)),
     SWORDS(SwordsManager.class, Color.fromRGB(178, 34, 34), AbilityType.SERRATED_STRIKES, ToolType.SWORD, ImmutableList.of(SecondaryAbility.BLEED, SecondaryAbility.COUNTER)),
     TAMING(TamingManager.class, Color.PURPLE, ImmutableList.of(SecondaryAbility.BEAST_LORE, SecondaryAbility.CALL_OF_THE_WILD, SecondaryAbility.ENVIROMENTALLY_AWARE, SecondaryAbility.FAST_FOOD, SecondaryAbility.GORE, SecondaryAbility.HOLY_HOUND, SecondaryAbility.SHARPENED_CLAWS, SecondaryAbility.SHOCK_PROOF, SecondaryAbility.THICK_FUR)),
@@ -63,7 +65,7 @@ public enum SkillType {
 
     public static final List<SkillType> COMBAT_SKILLS = ImmutableList.of(ARCHERY, AXES, SWORDS, TAMING, UNARMED);
     public static final List<SkillType> GATHERING_SKILLS = ImmutableList.of(EXCAVATION, FISHING, HERBALISM, MINING, WOODCUTTING);
-    public static final List<SkillType> MISC_SKILLS = ImmutableList.of(ACROBATICS, ALCHEMY, REPAIR, SMELTING);
+    public static final List<SkillType> MISC_SKILLS = ImmutableList.of(ACROBATICS, ALCHEMY, REPAIR, SALVAGE, SMELTING);
 
     static {
         List<SkillType> childSkills = new ArrayList<SkillType>();
@@ -182,6 +184,7 @@ public enum SkillType {
     // TODO: This is a little "hacky", we probably need to add something to distinguish child skills in the enum, or to use another enum for them
     public boolean isChildSkill() {
         switch (this) {
+            case SALVAGE:
             case SMELTING:
                 return true;
 

src/main/java/com/gmail/nossr50/datatypes/skills/XPGainReason.java

@@ -0,0 +1,21 @@
+package com.gmail.nossr50.datatypes.skills;
+
+public enum XPGainReason {
+    PVP,
+    PVE,
+    VAMPIRISM,
+    SHARED_PVP,
+    SHARED_PVE,
+    COMMAND,
+    UNKNOWN;
+
+    public static XPGainReason getXPGainReason(String reason) {
+        for (XPGainReason type : values()) {
+            if (type.name().equalsIgnoreCase(reason)) {
+                return type;
+            }
+        }
+
+        return null;
+    }
+}

src/main/java/com/gmail/nossr50/datatypes/skills/alchemy/PotionStage.java

@@ -0,0 +1,70 @@
+package com.gmail.nossr50.datatypes.skills.alchemy;
+
+import org.bukkit.Material;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.potion.Potion;
+
+public enum PotionStage {
+    FIVE(5),
+    FOUR(4),
+    THREE(3),
+    TWO(2),
+    ONE(1);
+
+    int numerical;
+
+    private PotionStage(int numerical) {
+        this.numerical = numerical;
+    }
+
+    public int toNumerical() {
+        return numerical;
+    }
+
+    private static PotionStage getPotionStageNumerical(int numerical) {
+        for (PotionStage potionStage : values()) {
+            if (numerical >= potionStage.toNumerical()) {
+                return potionStage;
+            }
+        }
+
+        return ONE;
+    }
+
+    public static PotionStage getPotionStage(AlchemyPotion input, AlchemyPotion output) {
+        PotionStage potionStage = getPotionStage(output);
+        if (getPotionStage(input) == potionStage) {
+            potionStage = PotionStage.FIVE;
+        }
+
+        return potionStage;
+    }
+
+    public static PotionStage getPotionStage(AlchemyPotion alchemyPotion) {
+        Potion potion = Potion.fromItemStack(new ItemStack(Material.POTION, 1, alchemyPotion.getDataValue()));
+
+        int stage = 1;
+
+        // Check if potion isn't awkward or mundane
+        if (potion.getType() != null) {
+            stage++;
+        }
+
+        // Check if potion has a glowstone dust amplifier
+        if (potion.getLevel() > 1) {
+            stage++;
+        }
+
+        // Check if potion has a redstone dust amplifier
+        if (potion.hasExtendedDuration()) {
+            stage++;
+        }
+
+        // Check if potion has a gunpowder amplifier
+        if (potion.isSplash()) {
+            stage++;
+        }
+
+        return PotionStage.getPotionStageNumerical(stage);
+    }
+}

src/main/java/com/gmail/nossr50/events/experience/McMMOPlayerExperienceEvent.java

@@ -6,6 +6,7 @@ import org.bukkit.event.HandlerList;
 import org.bukkit.event.player.PlayerEvent;
 
 import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.datatypes.skills.XPGainReason;
 import com.gmail.nossr50.util.player.UserManager;
 
 /**
@@ -15,11 +16,21 @@ public abstract class McMMOPlayerExperienceEvent extends PlayerEvent implements
     private boolean cancelled;
     protected SkillType skill;
     protected int skillLevel;
+    protected XPGainReason xpGainReason;
 
+    @Deprecated
     protected McMMOPlayerExperienceEvent(Player player, SkillType skill) {
         super(player);
         this.skill = skill;
         this.skillLevel = UserManager.getPlayer(player).getSkillLevel(skill);
+        this.xpGainReason = XPGainReason.UNKNOWN;
+    }
+
+    protected McMMOPlayerExperienceEvent(Player player, SkillType skill, XPGainReason xpGainReason) {
+        super(player);
+        this.skill = skill;
+        this.skillLevel = UserManager.getPlayer(player).getSkillLevel(skill);
+        this.xpGainReason = xpGainReason;
     }
 
     /**
@@ -36,6 +47,13 @@ public abstract class McMMOPlayerExperienceEvent extends PlayerEvent implements
         return skillLevel;
     }
 
+    /**
+     * @return The combat type involved in this event
+     */
+    public XPGainReason getXpGainReason() {
+        return xpGainReason;
+    }
+
     /** Following are required for Cancellable **/
     @Override
     public boolean isCancelled() {

src/main/java/com/gmail/nossr50/events/experience/McMMOPlayerLevelChangeEvent.java

@@ -3,12 +3,18 @@ package com.gmail.nossr50.events.experience;
 import org.bukkit.entity.Player;
 
 import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.datatypes.skills.XPGainReason;
 
 /**
  * Called when a user levels change
  */
 public abstract class McMMOPlayerLevelChangeEvent extends McMMOPlayerExperienceEvent {
+    @Deprecated
     public McMMOPlayerLevelChangeEvent(Player player, SkillType skill) {
-        super(player, skill);
+        super(player, skill, XPGainReason.UNKNOWN);
+    }
+
+    public McMMOPlayerLevelChangeEvent(Player player, SkillType skill, XPGainReason xpGainReason) {
+        super(player, skill, xpGainReason);
     }
 }

src/main/java/com/gmail/nossr50/events/experience/McMMOPlayerLevelDownEvent.java

@@ -3,6 +3,7 @@ package com.gmail.nossr50.events.experience;
 import org.bukkit.entity.Player;
 
 import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.datatypes.skills.XPGainReason;
 
 /**
  * Called when a user loses levels in a skill
@@ -10,13 +11,25 @@ import com.gmail.nossr50.datatypes.skills.SkillType;
 public class McMMOPlayerLevelDownEvent extends McMMOPlayerLevelChangeEvent {
     private int levelsLost;
 
+    @Deprecated
     public McMMOPlayerLevelDownEvent(Player player, SkillType skill) {
-        super(player, skill);
+        super(player, skill, XPGainReason.UNKNOWN);
         this.levelsLost = 1;
     }
 
+    @Deprecated
     public McMMOPlayerLevelDownEvent(Player player, SkillType skill, int levelsLost) {
-        super(player, skill);
+        super(player, skill, XPGainReason.UNKNOWN);
+        this.levelsLost = levelsLost;
+    }
+
+    public McMMOPlayerLevelDownEvent(Player player, SkillType skill, XPGainReason xpGainReason) {
+        super(player, skill, xpGainReason);
+        this.levelsLost = 1;
+    }
+
+    public McMMOPlayerLevelDownEvent(Player player, SkillType skill, int levelsLost, XPGainReason xpGainReason) {
+        super(player, skill, xpGainReason);
         this.levelsLost = levelsLost;
     }
 

src/main/java/com/gmail/nossr50/events/experience/McMMOPlayerLevelUpEvent.java

@@ -3,6 +3,7 @@ package com.gmail.nossr50.events.experience;
 import org.bukkit.entity.Player;
 
 import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.datatypes.skills.XPGainReason;
 
 /**
  * Called when a user levels up in a skill
@@ -10,13 +11,25 @@ import com.gmail.nossr50.datatypes.skills.SkillType;
 public class McMMOPlayerLevelUpEvent extends McMMOPlayerLevelChangeEvent {
     private int levelsGained;
 
+    @Deprecated
     public McMMOPlayerLevelUpEvent(Player player, SkillType skill) {
-        super(player, skill);
+        super(player, skill, XPGainReason.UNKNOWN);
         this.levelsGained = 1;
     }
 
+    @Deprecated
     public McMMOPlayerLevelUpEvent(Player player, SkillType skill, int levelsGained) {
-        super(player, skill);
+        super(player, skill, XPGainReason.UNKNOWN);
+        this.levelsGained = levelsGained;
+    }
+
+    public McMMOPlayerLevelUpEvent(Player player, SkillType skill, XPGainReason xpGainReason) {
+        super(player, skill, xpGainReason);
+        this.levelsGained = 1;
+    }
+
+    public McMMOPlayerLevelUpEvent(Player player, SkillType skill, int levelsGained, XPGainReason xpGainReason) {
+        super(player, skill, xpGainReason);
         this.levelsGained = levelsGained;
     }
 

src/main/java/com/gmail/nossr50/events/experience/McMMOPlayerXpGainEvent.java

@@ -3,6 +3,7 @@ package com.gmail.nossr50.events.experience;
 import org.bukkit.entity.Player;
 
 import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.datatypes.skills.XPGainReason;
 
 /**
  * Called when a player gains XP in a skill
@@ -10,8 +11,14 @@ import com.gmail.nossr50.datatypes.skills.SkillType;
 public class McMMOPlayerXpGainEvent extends McMMOPlayerExperienceEvent {
     private float xpGained;
 
+    @Deprecated
     public McMMOPlayerXpGainEvent(Player player, SkillType skill, float xpGained) {
-        super(player, skill);
+        super(player, skill, XPGainReason.UNKNOWN);
+        this.xpGained = xpGained;
+    }
+
+    public McMMOPlayerXpGainEvent(Player player, SkillType skill, float xpGained, XPGainReason xpGainReason) {
+        super(player, skill, xpGainReason);
         this.xpGained = xpGained;
     }
 

src/main/java/com/gmail/nossr50/events/fake/FakeEntityTameEvent.java

@@ -9,6 +9,6 @@ import org.bukkit.event.entity.EntityTameEvent;
  */
 public class FakeEntityTameEvent extends EntityTameEvent {
     public FakeEntityTameEvent(LivingEntity entity, AnimalTamer owner) {
-        super (entity, owner);
+        super(entity, owner);
     }
 }

src/main/java/com/gmail/nossr50/listeners/BlockListener.java

@@ -34,8 +34,11 @@ import com.gmail.nossr50.events.fake.FakeBlockDamageEvent;
 import com.gmail.nossr50.runnables.StickyPistonTrackerTask;
 import com.gmail.nossr50.skills.alchemy.Alchemy;
 import com.gmail.nossr50.skills.excavation.ExcavationManager;
+import com.gmail.nossr50.skills.herbalism.Herbalism;
 import com.gmail.nossr50.skills.herbalism.HerbalismManager;
 import com.gmail.nossr50.skills.mining.MiningManager;
+import com.gmail.nossr50.skills.repair.Repair;
+import com.gmail.nossr50.skills.salvage.Salvage;
 import com.gmail.nossr50.skills.smelting.SmeltingManager;
 import com.gmail.nossr50.skills.woodcutting.WoodcuttingManager;
 import com.gmail.nossr50.util.BlockUtils;
@@ -120,8 +123,13 @@ public class BlockListener implements Listener {
             mcMMO.getPlaceStore().setTrue(blockState);
         }
 
-        if (BlockUtils.isMcMMOAnvil(blockState)) {
-            UserManager.getPlayer(player).getRepairManager().placedAnvilCheck(blockState.getType());
+        McMMOPlayer mcMMOPlayer = UserManager.getPlayer(player);
+
+        if (blockState.getType() == Repair.anvilMaterial && SkillType.REPAIR.getPermissions(player)) {
+            mcMMOPlayer.getRepairManager().placedAnvilCheck();
+        }
+        else if (blockState.getType() == Salvage.anvilMaterial && SkillType.SALVAGE.getPermissions(player)) {
+            mcMMOPlayer.getSalvageManager().placedAnvilCheck();
         }
     }
 
@@ -227,6 +235,11 @@ public class BlockListener implements Listener {
         BlockState blockState = event.getBlock().getState();
         ItemStack heldItem = player.getItemInHand();
 
+        if (Herbalism.isRecentlyRegrown(blockState)) {
+            event.setCancelled(true);
+            return;
+        }
+
         if (ItemUtils.isSword(heldItem)) {
             HerbalismManager herbalismManager = UserManager.getPlayer(player).getHerbalismManager();
 

src/main/java/com/gmail/nossr50/listeners/EntityListener.java

@@ -1,5 +1,6 @@
 package com.gmail.nossr50.listeners;
 
+import org.bukkit.Material;
 import org.bukkit.OfflinePlayer;
 import org.bukkit.block.Block;
 import org.bukkit.enchantments.Enchantment;
@@ -31,6 +32,7 @@ import org.bukkit.event.entity.ExplosionPrimeEvent;
 import org.bukkit.event.entity.FoodLevelChangeEvent;
 import org.bukkit.event.entity.PotionSplashEvent;
 import org.bukkit.event.entity.ProjectileLaunchEvent;
+import org.bukkit.inventory.ItemStack;
 import org.bukkit.inventory.meta.PotionMeta;
 import org.bukkit.metadata.FixedMetadataValue;
 import org.bukkit.potion.PotionEffect;
@@ -76,7 +78,9 @@ public class EntityListener implements Listener {
             return;
         }
 
-        if (event.getBow().containsEnchantment(Enchantment.ARROW_INFINITE)) {
+        ItemStack bow = event.getBow();
+
+        if (bow != null && bow.containsEnchantment(Enchantment.ARROW_INFINITE)) {
             projectile.setMetadata(mcMMO.infiniteArrowKey, mcMMO.metadataValue);
         }
 
@@ -122,6 +126,9 @@ public class EntityListener implements Listener {
                 mcMMO.getPlaceStore().setTrue(block);
             }
         }
+        else if ((block.getType() == Material.REDSTONE_ORE || block.getType() == Material.GLOWING_REDSTONE_ORE) && (event.getTo() == Material.REDSTONE_ORE || event.getTo() == Material.GLOWING_REDSTONE_ORE)) {
+            return;
+        }
         else {
             if (mcMMO.getPlaceStore().isTrue(block)) {
                 mcMMO.getPlaceStore().setFalse(block);

src/main/java/com/gmail/nossr50/listeners/InventoryListener.java

@@ -34,7 +34,7 @@ import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.config.Config;
 import com.gmail.nossr50.datatypes.skills.SecondaryAbility;
 import com.gmail.nossr50.datatypes.skills.SkillType;
-import com.gmail.nossr50.runnables.PlayerUpdateInventoryTask;
+import com.gmail.nossr50.runnables.player.PlayerUpdateInventoryTask;
 import com.gmail.nossr50.skills.alchemy.Alchemy;
 import com.gmail.nossr50.skills.alchemy.AlchemyPotionBrewer;
 import com.gmail.nossr50.util.ItemUtils;
@@ -51,7 +51,7 @@ public class InventoryListener implements Listener {
 
     @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
     public void onInventoryOpen(InventoryOpenEvent event) {
-        Block furnaceBlock = processInventoryOpenorCloseEvent(event.getInventory());
+        Block furnaceBlock = processInventoryOpenOrCloseEvent(event.getInventory());
 
         if (furnaceBlock == null || furnaceBlock.hasMetadata(mcMMO.furnaceMetadataKey)) {
             return;
@@ -68,7 +68,7 @@ public class InventoryListener implements Listener {
 
     @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
     public void onInventoryClose(InventoryCloseEvent event) {
-        Block furnaceBlock = processInventoryOpenorCloseEvent(event.getInventory());
+        Block furnaceBlock = processInventoryOpenOrCloseEvent(event.getInventory());
 
         if (furnaceBlock == null || furnaceBlock.hasMetadata(mcMMO.furnaceMetadataKey)) {
             return;
@@ -295,7 +295,12 @@ public class InventoryListener implements Listener {
 
         ItemStack item = event.getItem();
 
-        if (Config.getInstance().getPreventHopperTransfer() && item.getType() != Material.POTION) {
+        if (Config.getInstance().getPreventHopperTransferIngredients() && item.getType() != Material.POTION) {
+            event.setCancelled(true);
+            return;
+        }
+
+        if (Config.getInstance().getPreventHopperTransferBottles() && item.getType() == Material.POTION) {
             event.setCancelled(true);
             return;
         }
@@ -327,7 +332,7 @@ public class InventoryListener implements Listener {
         new PlayerUpdateInventoryTask((Player) whoClicked).runTaskLater(plugin, 0);
     }
 
-    private Block processInventoryOpenorCloseEvent(Inventory inventory) {
+    private Block processInventoryOpenOrCloseEvent(Inventory inventory) {
         if (!(inventory instanceof FurnaceInventory)) {
             return null;
         }

src/main/java/com/gmail/nossr50/listeners/PlayerListener.java

@@ -38,16 +38,18 @@ import com.gmail.nossr50.datatypes.chat.ChatMode;
 import com.gmail.nossr50.datatypes.party.Party;
 import com.gmail.nossr50.datatypes.player.McMMOPlayer;
 import com.gmail.nossr50.datatypes.skills.AbilityType;
-import com.gmail.nossr50.datatypes.skills.SecondaryAbility;
 import com.gmail.nossr50.datatypes.skills.SkillType;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.party.ShareHandler;
+import com.gmail.nossr50.runnables.commands.McScoreboardKeepTask;
 import com.gmail.nossr50.runnables.skills.BleedTimerTask;
 import com.gmail.nossr50.skills.fishing.FishingManager;
 import com.gmail.nossr50.skills.herbalism.HerbalismManager;
 import com.gmail.nossr50.skills.mining.MiningManager;
 import com.gmail.nossr50.skills.repair.Repair;
 import com.gmail.nossr50.skills.repair.RepairManager;
+import com.gmail.nossr50.skills.salvage.Salvage;
+import com.gmail.nossr50.skills.salvage.SalvageManager;
 import com.gmail.nossr50.skills.taming.TamingManager;
 import com.gmail.nossr50.skills.unarmed.Unarmed;
 import com.gmail.nossr50.util.BlockUtils;
@@ -361,7 +363,7 @@ public class PlayerListener implements Listener {
 
         mcMMOPlayer.resetAbilityMode();
         BleedTimerTask.bleedOut(player);
-        mcMMOPlayer.getProfile().save();
+        mcMMOPlayer.getProfile().scheduleAsyncSave();
         UserManager.remove(player);
         ScoreboardManager.teardownPlayer(player);
     }
@@ -399,6 +401,11 @@ public class PlayerListener implements Listener {
             player.sendMessage(LocaleLoader.getString("UpdateChecker.Outdated"));
             player.sendMessage(LocaleLoader.getString("UpdateChecker.NewAvailable"));
         }
+
+        if (Config.getInstance().getShowStatsAfterLogin()) {
+            ScoreboardManager.enablePlayerStatsScoreboard(player);
+            new McScoreboardKeepTask(player).runTaskLater(mcMMO.p, 1 * Misc.TICK_CONVERSION_FACTOR);
+        }
     }
 
     /**
@@ -445,24 +452,24 @@ public class PlayerListener implements Listener {
 
                 if (!Config.getInstance().getAbilitiesOnlyActivateWhenSneaking() || player.isSneaking()) {
                     /* REPAIR CHECKS */
-                    if (type == Repair.repairAnvilMaterial && SkillType.REPAIR.getPermissions(player) && mcMMO.getRepairableManager().isRepairable(heldItem)) {
+                    if (type == Repair.anvilMaterial && SkillType.REPAIR.getPermissions(player) && mcMMO.getRepairableManager().isRepairable(heldItem)) {
                         RepairManager repairManager = mcMMOPlayer.getRepairManager();
                         event.setCancelled(true);
 
                         // Make sure the player knows what he's doing when trying to repair an enchanted item
-                        if (!(heldItem.getEnchantments().size() > 0) || repairManager.checkConfirmation(type, true)) {
+                        if (!(heldItem.getEnchantments().size() > 0) || repairManager.checkConfirmation(true)) {
                             repairManager.handleRepair(heldItem);
                             player.updateInventory();
                         }
                     }
                     /* SALVAGE CHECKS */
-                    else if (type == Repair.salvageAnvilMaterial && Permissions.secondaryAbilityEnabled(player, SecondaryAbility.SALVAGE) && Repair.isSalvageable(heldItem)) {
-                        RepairManager repairManager = mcMMOPlayer.getRepairManager();
+                    else if (type == Salvage.anvilMaterial && SkillType.SALVAGE.getPermissions(player) && mcMMO.getSalvageableManager().isSalvageable(heldItem)) {
+                        SalvageManager salvageManager = UserManager.getPlayer(player).getSalvageManager();
                         event.setCancelled(true);
 
                         // Make sure the player knows what he's doing when trying to salvage an enchanted item
-                        if (!(heldItem.getEnchantments().size() > 0) || repairManager.checkConfirmation(type, true)) {
-                            repairManager.handleSalvage(block.getLocation(), heldItem);
+                        if (!(heldItem.getEnchantments().size() > 0) || salvageManager.checkConfirmation(true)) {
+                            salvageManager.handleSalvage(block.getLocation(), heldItem);
                             player.updateInventory();
                         }
                     }
@@ -484,22 +491,22 @@ public class PlayerListener implements Listener {
 
                 if ((Config.getInstance().getAbilitiesOnlyActivateWhenSneaking() && player.isSneaking()) || !Config.getInstance().getAbilitiesOnlyActivateWhenSneaking()) {
                     /* REPAIR CHECKS */
-                    if (type == Repair.repairAnvilMaterial && SkillType.REPAIR.getPermissions(player) && mcMMO.getRepairableManager().isRepairable(heldItem)) {
+                    if (type == Repair.anvilMaterial && SkillType.REPAIR.getPermissions(player) && mcMMO.getRepairableManager().isRepairable(heldItem)) {
                         RepairManager repairManager = mcMMOPlayer.getRepairManager();
 
                         // Cancel repairing an enchanted item
-                        if (repairManager.checkConfirmation(type, false) && Config.getInstance().getRepairConfirmRequired()) {
-                            repairManager.setLastAnvilUse(Repair.repairAnvilMaterial, 0);
+                        if (repairManager.checkConfirmation(false)) {
+                            repairManager.setLastAnvilUse(0);
                             player.sendMessage(LocaleLoader.getString("Skills.Cancelled", LocaleLoader.getString("Repair.Pretty.Name")));
                         }
                     }
                     /* SALVAGE CHECKS */
-                    else if (type == Repair.salvageAnvilMaterial && Permissions.secondaryAbilityEnabled(player, SecondaryAbility.SALVAGE) && Repair.isSalvageable(heldItem)) {
-                        RepairManager repairManager = mcMMOPlayer.getRepairManager();
+                    else if (type == Salvage.anvilMaterial && SkillType.SALVAGE.getPermissions(player) && mcMMO.getSalvageableManager().isSalvageable(heldItem)) {
+                        SalvageManager salvageManager = mcMMOPlayer.getSalvageManager();
 
                         // Cancel salvaging an enchanted item
-                        if (repairManager.checkConfirmation(type, false) && Config.getInstance().getRepairConfirmRequired()) {
-                            repairManager.setLastAnvilUse(Repair.salvageAnvilMaterial, 0);
+                        if (salvageManager.checkConfirmation(false)) {
+                            salvageManager.setLastAnvilUse(0);
                             player.sendMessage(LocaleLoader.getString("Skills.Cancelled", LocaleLoader.getString("Salvage.Pretty.Name")));
                         }
                     }
@@ -631,7 +638,7 @@ public class PlayerListener implements Listener {
     public void onPlayerChat(AsyncPlayerChatEvent event) {
         Player player = event.getPlayer();
 
-        if (Misc.isNPCEntity(player)) {
+        if (Misc.isNPCEntity(player) || !UserManager.hasPlayerDataKey(player)) {
             return;
         }
 

src/main/java/com/gmail/nossr50/mcMMO.java

@@ -20,6 +20,7 @@ import com.gmail.nossr50.config.mods.EntityConfigManager;
 import com.gmail.nossr50.config.mods.ToolConfigManager;
 import com.gmail.nossr50.config.skills.alchemy.PotionConfig;
 import com.gmail.nossr50.config.skills.repair.RepairConfigManager;
+import com.gmail.nossr50.config.skills.salvage.SalvageConfigManager;
 import com.gmail.nossr50.config.treasure.TreasureConfig;
 import com.gmail.nossr50.database.DatabaseManager;
 import com.gmail.nossr50.database.DatabaseManagerFactory;
@@ -29,11 +30,11 @@ import com.gmail.nossr50.listeners.InventoryListener;
 import com.gmail.nossr50.listeners.PlayerListener;
 import com.gmail.nossr50.listeners.SelfListener;
 import com.gmail.nossr50.listeners.WorldListener;
-import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.metrics.MetricsManager;
 import com.gmail.nossr50.party.PartyManager;
 import com.gmail.nossr50.runnables.CheckDateTask;
 import com.gmail.nossr50.runnables.SaveTimerTask;
+import com.gmail.nossr50.runnables.UpdaterResultAsyncTask;
 import com.gmail.nossr50.runnables.backups.CleanBackupsTask;
 import com.gmail.nossr50.runnables.database.UserPurgeTask;
 import com.gmail.nossr50.runnables.party.PartyAutoKickTask;
@@ -44,6 +45,9 @@ import com.gmail.nossr50.skills.child.ChildConfig;
 import com.gmail.nossr50.skills.repair.repairables.Repairable;
 import com.gmail.nossr50.skills.repair.repairables.RepairableManager;
 import com.gmail.nossr50.skills.repair.repairables.SimpleRepairableManager;
+import com.gmail.nossr50.skills.salvage.salvageables.Salvageable;
+import com.gmail.nossr50.skills.salvage.salvageables.SalvageableManager;
+import com.gmail.nossr50.skills.salvage.salvageables.SimpleSalvageableManager;
 import com.gmail.nossr50.util.ChimaeraWing;
 import com.gmail.nossr50.util.HolidayManager;
 import com.gmail.nossr50.util.LogFilter;
@@ -57,19 +61,17 @@ import com.gmail.nossr50.util.experience.FormulaManager;
 import com.gmail.nossr50.util.player.UserManager;
 import com.gmail.nossr50.util.scoreboards.ScoreboardManager;
 
-import net.gravitydevelopment.updater.mcmmo.Updater;
-import net.gravitydevelopment.updater.mcmmo.Updater.UpdateResult;
-import net.gravitydevelopment.updater.mcmmo.Updater.UpdateType;
 import net.shatteredlands.shatt.backup.ZipLibrary;
 
 public class mcMMO extends JavaPlugin {
     /* Managers */
-    private static ChunkManager      placeStore;
-    private static RepairableManager repairableManager;
-    private static ModManager        modManager;
-    private static DatabaseManager   databaseManager;
-    private static FormulaManager    formulaManager;
-    private static HolidayManager    holidayManager;
+    private static ChunkManager       placeStore;
+    private static RepairableManager  repairableManager;
+    private static SalvageableManager salvageableManager;
+    private static ModManager         modManager;
+    private static DatabaseManager    databaseManager;
+    private static FormulaManager     formulaManager;
+    private static HolidayManager     holidayManager;
 
     /* File Paths */
     private static String mainDirectory;
@@ -86,7 +88,6 @@ public class mcMMO extends JavaPlugin {
     private boolean updateAvailable;
 
     /* Plugin Checks */
-    private static boolean combatTagEnabled;
     private static boolean healthBarPluginEnabled;
 
     // Config Validation Check
@@ -110,6 +111,7 @@ public class mcMMO extends JavaPlugin {
     public final static String customDamageKey     = "mcMMO: Custom Damage";
     public final static String disarmedItemKey     = "mcMMO: Disarmed Item";
     public final static String playerDataKey       = "mcMMO: Player Data";
+    public final static String greenThumbDataKey   = "mcMMO: Green Thumb";
 
     public static FixedMetadataValue metadataValue;
 
@@ -124,7 +126,6 @@ public class mcMMO extends JavaPlugin {
             metadataValue = new FixedMetadataValue(this, true);
 
             PluginManager pluginManager = getServer().getPluginManager();
-            combatTagEnabled = pluginManager.getPlugin("CombatTag") != null;
             healthBarPluginEnabled = pluginManager.getPlugin("HealthBar") != null;
 
             setupFilePaths();
@@ -202,6 +203,7 @@ public class mcMMO extends JavaPlugin {
         try {
             Alchemy.finishAllBrews();   // Finish all partially complete AlchemyBrewTasks to prevent vanilla brewing continuation on restart
             UserManager.saveAll();      // Make sure to save player information if the server shuts down
+            UserManager.clearAll();
             PartyManager.saveParties(); // Save our parties
             ScoreboardManager.teardownAll();
             formulaManager.saveFormula();
@@ -258,6 +260,10 @@ public class mcMMO extends JavaPlugin {
         return updateAvailable;
     }
 
+    public void setUpdateAvailable(boolean available) {
+        this.updateAvailable = available;
+    }
+
     public boolean isXPEventEnabled() {
         return xpEventEnabled;
     }
@@ -290,6 +296,10 @@ public class mcMMO extends JavaPlugin {
         return repairableManager;
     }
 
+    public static SalvageableManager getSalvageableManager() {
+        return salvageableManager;
+    }
+
     public static DatabaseManager getDatabaseManager() {
         return databaseManager;
     }
@@ -303,10 +313,6 @@ public class mcMMO extends JavaPlugin {
         mcMMO.databaseManager = databaseManager;
     }
 
-    public static boolean isCombatTagEnabled() {
-        return combatTagEnabled;
-    }
-
     public static boolean isHealthBarPluginEnabled() {
         return healthBarPluginEnabled;
     }
@@ -377,21 +383,7 @@ public class mcMMO extends JavaPlugin {
             return;
         }
 
-        Updater updater = new Updater(this, 31030, mcmmo, UpdateType.NO_DOWNLOAD, false);
-
-        if (updater.getResult() != UpdateResult.UPDATE_AVAILABLE) {
-            this.updateAvailable = false;
-            return;
-        }
-
-        if (updater.getLatestType().equals("beta") && !Config.getInstance().getPreferBeta()) {
-            this.updateAvailable = false;
-            return;
-        }
-
-        this.updateAvailable = true;
-        getLogger().info(LocaleLoader.getString("UpdateChecker.Outdated"));
-        getLogger().info(LocaleLoader.getString("UpdateChecker.NewAvailable"));
+        new UpdaterResultAsyncTask(this).runTaskAsynchronously(mcMMO.p);
     }
 
     private void loadConfigFiles() {
@@ -403,6 +395,7 @@ public class mcMMO extends JavaPlugin {
         new ChildConfig();
 
         List<Repairable> repairables = new ArrayList<Repairable>();
+        List<Salvageable> salvageables = new ArrayList<Salvageable>();
 
         if (Config.getInstance().getToolModsEnabled()) {
             new ToolConfigManager(this);
@@ -425,6 +418,12 @@ public class mcMMO extends JavaPlugin {
         repairables.addAll(modManager.getLoadedRepairables());
         repairableManager = new SimpleRepairableManager(repairables.size());
         repairableManager.registerRepairables(repairables);
+
+        // Load salvage configs, make manager and register them at this time
+        SalvageConfigManager sManager = new SalvageConfigManager(this);
+        salvageables.addAll(sManager.getLoadedSalvageables());
+        salvageableManager = new SimpleSalvageableManager(salvageables.size());
+        salvageableManager.registerSalvageables(salvageables);
     }
 
     private void registerEvents() {

src/main/java/com/gmail/nossr50/party/ShareHandler.java

@@ -13,6 +13,7 @@ import com.gmail.nossr50.datatypes.party.Party;
 import com.gmail.nossr50.datatypes.party.ShareMode;
 import com.gmail.nossr50.datatypes.player.McMMOPlayer;
 import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.datatypes.skills.XPGainReason;
 import com.gmail.nossr50.util.Misc;
 import com.gmail.nossr50.util.player.UserManager;
 
@@ -27,7 +28,7 @@ public final class ShareHandler {
      * @param skillType Skill being used
      * @return True is the xp has been shared
      */
-    public static boolean handleXpShare(float xp, McMMOPlayer mcMMOPlayer, SkillType skillType) {
+    public static boolean handleXpShare(float xp, McMMOPlayer mcMMOPlayer, SkillType skillType, XPGainReason xpGainReason) {
         Party party = mcMMOPlayer.getParty();
 
         if (party.getXpShareMode() != ShareMode.EQUAL) {
@@ -47,7 +48,7 @@ public final class ShareHandler {
         float splitXp = (float) (xp / partySize * shareBonus);
 
         for (Player member : nearMembers) {
-            UserManager.getPlayer(member).beginUnsharedXpGain(skillType, splitXp);
+            UserManager.getPlayer(member).beginUnsharedXpGain(skillType, splitXp, xpGainReason);
         }
 
         return true;
@@ -142,6 +143,18 @@ public final class ShareHandler {
         }
     }
 
+    public static XPGainReason getSharedXpGainReason(XPGainReason xpGainReason) {
+        if (xpGainReason == XPGainReason.PVE) {
+            return XPGainReason.SHARED_PVE;
+        }
+        else if (xpGainReason == XPGainReason.PVP) {
+            return XPGainReason.SHARED_PVP;
+        }
+        else {
+            return xpGainReason;
+        }
+    }
+
     private static void awardDrop(Player winningPlayer, ItemStack drop) {
         if (winningPlayer.getInventory().addItem(drop).size() != 0) {
             winningPlayer.getWorld().dropItemNaturally(winningPlayer.getLocation(), drop);

src/main/java/com/gmail/nossr50/runnables/UpdaterResultAsyncTask.java

@@ -0,0 +1,36 @@
+package com.gmail.nossr50.runnables;
+
+import org.bukkit.scheduler.BukkitRunnable;
+
+import com.gmail.nossr50.mcMMO;
+import com.gmail.nossr50.config.Config;
+import com.gmail.nossr50.locale.LocaleLoader;
+
+import net.gravitydevelopment.updater.mcmmo.Updater;
+
+public class UpdaterResultAsyncTask extends BukkitRunnable {
+    private mcMMO plugin;
+
+    public UpdaterResultAsyncTask(mcMMO plugin) {
+        this.plugin = plugin;
+    }
+
+    @Override
+    public void run() {
+        Updater updater = new Updater(plugin, 31030, plugin.mcmmo, Updater.UpdateType.NO_DOWNLOAD, false);
+
+        if (updater.getResult() != Updater.UpdateResult.UPDATE_AVAILABLE) {
+            plugin.setUpdateAvailable(false);
+            return;
+        }
+
+        if (updater.getLatestType().equals("beta") && !Config.getInstance().getPreferBeta()) {
+            plugin.setUpdateAvailable(false);
+            return;
+        }
+
+        plugin.setUpdateAvailable(true);
+        plugin.getLogger().info(LocaleLoader.getString("UpdateChecker.Outdated"));
+        plugin.getLogger().info(LocaleLoader.getString("UpdateChecker.NewAvailable"));
+    }
+}

src/main/java/com/gmail/nossr50/runnables/commands/McScoreboardKeepTask.java

@@ -0,0 +1,21 @@
+package com.gmail.nossr50.runnables.commands;
+
+import org.bukkit.entity.Player;
+import org.bukkit.scheduler.BukkitRunnable;
+
+import com.gmail.nossr50.util.scoreboards.ScoreboardManager;
+
+public class McScoreboardKeepTask extends BukkitRunnable {
+    private Player player;
+
+    public McScoreboardKeepTask(Player player) {
+        this.player = player;
+    }
+
+    @Override
+    public void run() {
+        if (player.isValid() && ScoreboardManager.isBoardShown(player.getName())) {
+            ScoreboardManager.keepBoard(player.getName());
+        }
+    }
+}

src/main/java/com/gmail/nossr50/runnables/commands/McrankCommandDisplayTask.java

@@ -34,7 +34,7 @@ public class McrankCommandDisplayTask extends BukkitRunnable {
             displayBoard();
         }
 
-        if (useChat){
+        if (useChat) {
             displayChat();
         }
     }

src/main/java/com/gmail/nossr50/runnables/database/DatabaseConversionTask.java

@@ -28,5 +28,5 @@ public class DatabaseConversionTask extends BukkitRunnable {
                 sender.sendMessage(message);
             }
         });
-   }
+    }
 }

src/main/java/com/gmail/nossr50/runnables/database/FormulaConversionTask.java

@@ -41,7 +41,8 @@ public class FormulaConversionTask extends BukkitRunnable {
                 }
 
                 editValues(profile);
-                profile.save(); // Since this is a temporary profile, we save it here.
+                // Since this is a temporary profile, we save it here.
+                profile.scheduleAsyncSave();
             }
             else {
                 profile = mcMMOPlayer.getProfile();

src/main/java/com/gmail/nossr50/runnables/player/PlayerUpdateInventoryTask.java

@@ -1,4 +1,4 @@
-package com.gmail.nossr50.runnables;
+package com.gmail.nossr50.runnables.player;
 
 import org.bukkit.entity.Player;
 import org.bukkit.scheduler.BukkitRunnable;

src/main/java/com/gmail/nossr50/runnables/skills/AwardCombatXpTask.java

@@ -5,19 +5,22 @@ import org.bukkit.scheduler.BukkitRunnable;
 
 import com.gmail.nossr50.datatypes.player.McMMOPlayer;
 import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.datatypes.skills.XPGainReason;
 
 public class AwardCombatXpTask extends BukkitRunnable {
     private McMMOPlayer mcMMOPlayer;
     private double baseXp;
     private SkillType skillType;
     private LivingEntity target;
+    private XPGainReason xpGainReason;
     private double baseHealth;
 
-    public AwardCombatXpTask(McMMOPlayer mcMMOPlayer, SkillType skillType, double baseXp, LivingEntity target) {
+    public AwardCombatXpTask(McMMOPlayer mcMMOPlayer, SkillType skillType, double baseXp, LivingEntity target, XPGainReason xpGainReason) {
         this.mcMMOPlayer = mcMMOPlayer;
         this.skillType = skillType;
         this.baseXp = baseXp;
         this.target = target;
+        this.xpGainReason = xpGainReason;
         baseHealth = target.getHealth();
     }
 
@@ -36,6 +39,6 @@ public class AwardCombatXpTask extends BukkitRunnable {
             damage += health;
         }
 
-        mcMMOPlayer.beginXpGain(skillType, (int) (damage * baseXp));
+        mcMMOPlayer.beginXpGain(skillType, (int) (damage * baseXp), xpGainReason);
     }
 }

src/main/java/com/gmail/nossr50/runnables/skills/BleedTimerTask.java

@@ -19,7 +19,7 @@ public class BleedTimerTask extends BukkitRunnable {
 
     @Override
     public void run() {
-        for (Iterator<Entry<LivingEntity, Integer>> bleedIterator = bleedList.entrySet().iterator(); bleedIterator.hasNext();) {
+        for (Iterator<Entry<LivingEntity, Integer>> bleedIterator = bleedList.entrySet().iterator(); bleedIterator.hasNext(); ) {
             Entry<LivingEntity, Integer> entry = bleedIterator.next();
             LivingEntity entity = entry.getKey();
 
@@ -107,4 +107,8 @@ public class BleedTimerTask extends BukkitRunnable {
             bleedList.put(entity, Math.min(newTicks, MAX_BLEED_TICKS));
         }
     }
+
+    public static boolean isBleeding(LivingEntity entity) {
+        return bleedList.containsKey(entity);
+    }
 }

src/main/java/com/gmail/nossr50/skills/SkillManager.java

@@ -1,9 +1,12 @@
 package com.gmail.nossr50.skills;
 
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.LivingEntity;
 import org.bukkit.entity.Player;
 
 import com.gmail.nossr50.datatypes.player.McMMOPlayer;
 import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.datatypes.skills.XPGainReason;
 import com.gmail.nossr50.util.skills.PerksUtils;
 
 public abstract class SkillManager {
@@ -25,7 +28,11 @@ public abstract class SkillManager {
         return mcMMOPlayer.getSkillLevel(skill);
     }
 
-    public void applyXpGain(float xp) {
-        mcMMOPlayer.beginXpGain(skill, xp);
+    public void applyXpGain(float xp, XPGainReason xpGainReason) {
+        mcMMOPlayer.beginXpGain(skill, xp, xpGainReason);
+    }
+
+    public XPGainReason getXPGainReason(LivingEntity target, Entity damager) {
+        return (damager instanceof Player && target instanceof Player) ? XPGainReason.PVP : XPGainReason.PVE;
     }
 }

src/main/java/com/gmail/nossr50/skills/acrobatics/AcrobaticsManager.java

@@ -12,6 +12,7 @@ import com.gmail.nossr50.config.Config;
 import com.gmail.nossr50.datatypes.player.McMMOPlayer;
 import com.gmail.nossr50.datatypes.skills.SecondaryAbility;
 import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.datatypes.skills.XPGainReason;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.skills.SkillManager;
 import com.gmail.nossr50.util.Misc;
@@ -62,7 +63,7 @@ public class AcrobaticsManager extends SkillManager {
 
             // Why do we check respawn cooldown here?
             if (SkillUtils.cooldownExpired(mcMMOPlayer.getRespawnATS(), Misc.PLAYER_RESPAWN_COOLDOWN_SECONDS)) {
-                applyXpGain((float) (damage * Acrobatics.dodgeXpModifier));
+                applyXpGain((float) (damage * Acrobatics.dodgeXpModifier), XPGainReason.PVP);
             }
 
             return modifiedDamage;
@@ -88,12 +89,12 @@ public class AcrobaticsManager extends SkillManager {
 
         if (!isFatal(modifiedDamage) && SkillUtils.activationSuccessful(SecondaryAbility.ROLL, player, getSkillLevel(), activationChance)) {
             player.sendMessage(LocaleLoader.getString("Acrobatics.Roll.Text"));
-            applyXpGain(calculateRollXP(damage, true));
+            applyXpGain(calculateRollXP(damage, true), XPGainReason.PVE);
 
             return modifiedDamage;
         }
         else if (!isFatal(damage)) {
-            applyXpGain(calculateRollXP(damage, false));
+            applyXpGain(calculateRollXP(damage, false), XPGainReason.PVE);
         }
 
         lastFallLocation = player.getLocation();
@@ -112,12 +113,12 @@ public class AcrobaticsManager extends SkillManager {
 
         if (!isFatal(modifiedDamage) && SkillUtils.activationSuccessful(SecondaryAbility.GRACEFUL_ROLL, getPlayer(), getSkillLevel(), activationChance)) {
             getPlayer().sendMessage(LocaleLoader.getString("Acrobatics.Ability.Proc"));
-            applyXpGain(calculateRollXP(damage, true));
+            applyXpGain(calculateRollXP(damage, true), XPGainReason.PVE);
 
             return modifiedDamage;
         }
         else if (!isFatal(damage)) {
-            applyXpGain(calculateRollXP(damage, false));
+            applyXpGain(calculateRollXP(damage, false), XPGainReason.PVE);
         }
 
         return damage;

src/main/java/com/gmail/nossr50/skills/alchemy/AlchemyManager.java

@@ -8,6 +8,8 @@ import com.gmail.nossr50.config.experience.ExperienceConfig;
 import com.gmail.nossr50.config.skills.alchemy.PotionConfig;
 import com.gmail.nossr50.datatypes.player.McMMOPlayer;
 import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.datatypes.skills.XPGainReason;
+import com.gmail.nossr50.datatypes.skills.alchemy.PotionStage;
 import com.gmail.nossr50.skills.SkillManager;
 import com.gmail.nossr50.util.StringUtils;
 
@@ -63,7 +65,7 @@ public class AlchemyManager extends SkillManager {
         return Math.min(Alchemy.catalysisMaxSpeed, Alchemy.catalysisMinSpeed + (Alchemy.catalysisMaxSpeed - Alchemy.catalysisMinSpeed) * (skillLevel - Alchemy.catalysisUnlockLevel) / (Alchemy.catalysisMaxBonusLevel - Alchemy.catalysisUnlockLevel)) * (isLucky ? LUCKY_MODIFIER : 1.0);
     }
 
-    public void handlePotionBrewSuccesses(int amount) {
-        applyXpGain((float) (ExperienceConfig.getInstance().getPotionXP() * amount));
+    public void handlePotionBrewSuccesses(PotionStage potionStage, int amount) {
+        applyXpGain((float) (ExperienceConfig.getInstance().getPotionXP(potionStage) * amount), XPGainReason.PVE);
     }
 }

src/main/java/com/gmail/nossr50/skills/alchemy/AlchemyPotionBrewer.java

@@ -17,7 +17,8 @@ import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.config.skills.alchemy.PotionConfig;
 import com.gmail.nossr50.datatypes.skills.SecondaryAbility;
 import com.gmail.nossr50.datatypes.skills.alchemy.AlchemyPotion;
-import com.gmail.nossr50.runnables.PlayerUpdateInventoryTask;
+import com.gmail.nossr50.datatypes.skills.alchemy.PotionStage;
+import com.gmail.nossr50.runnables.player.PlayerUpdateInventoryTask;
 import com.gmail.nossr50.runnables.skills.AlchemyBrewCheckTask;
 import com.gmail.nossr50.util.Permissions;
 import com.gmail.nossr50.util.player.UserManager;
@@ -114,7 +115,8 @@ public final class AlchemyPotionBrewer {
                 inventory.setItem(i, output.toItemStack(item.getAmount()).clone());
 
                 if (player != null) {
-                    UserManager.getPlayer(player).getAlchemyManager().handlePotionBrewSuccesses(1);
+                    PotionStage potionStage = PotionStage.getPotionStage(input, output);
+                    UserManager.getPlayer(player).getAlchemyManager().handlePotionBrewSuccesses(potionStage, 1);
                 }
             }
         }

src/main/java/com/gmail/nossr50/skills/archery/ArcheryManager.java

@@ -52,7 +52,7 @@ public class ArcheryManager extends SkillManager {
             return;
         }
 
-        applyXpGain((int) (firedLocation.distanceSquared(targetLocation) * Archery.DISTANCE_XP_MULTIPLIER));
+        applyXpGain((int) (firedLocation.distanceSquared(targetLocation) * Archery.DISTANCE_XP_MULTIPLIER), getXPGainReason(target, damager));
     }
 
     /**

src/main/java/com/gmail/nossr50/skills/excavation/ExcavationManager.java

@@ -9,6 +9,7 @@ import com.gmail.nossr50.config.Config;
 import com.gmail.nossr50.datatypes.player.McMMOPlayer;
 import com.gmail.nossr50.datatypes.skills.SecondaryAbility;
 import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.datatypes.skills.XPGainReason;
 import com.gmail.nossr50.datatypes.treasure.ExcavationTreasure;
 import com.gmail.nossr50.skills.SkillManager;
 import com.gmail.nossr50.util.Misc;
@@ -44,7 +45,7 @@ public class ExcavationManager extends SkillManager {
             }
         }
 
-        applyXpGain(xp);
+        applyXpGain(xp, XPGainReason.PVE);
     }
 
     /**

src/main/java/com/gmail/nossr50/skills/fishing/FishingManager.java

@@ -42,6 +42,7 @@ import com.gmail.nossr50.config.treasure.TreasureConfig;
 import com.gmail.nossr50.datatypes.player.McMMOPlayer;
 import com.gmail.nossr50.datatypes.skills.SecondaryAbility;
 import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.datatypes.skills.XPGainReason;
 import com.gmail.nossr50.datatypes.treasure.EnchantmentTreasure;
 import com.gmail.nossr50.datatypes.treasure.FishingTreasure;
 import com.gmail.nossr50.datatypes.treasure.Rarity;
@@ -69,6 +70,7 @@ public class FishingManager extends SkillManager {
     private Location fishingTarget;
     private Item fishingCatch;
     private Location hookLocation;
+
     public FishingManager(McMMOPlayer mcMMOPlayer) {
         super(mcMMOPlayer, SkillType.FISHING);
     }
@@ -348,7 +350,7 @@ public class FishingManager extends SkillManager {
             }
         }
 
-        applyXpGain(fishXp + treasureXp);
+        applyXpGain(fishXp + treasureXp, XPGainReason.PVE);
     }
 
     /**
@@ -436,7 +438,7 @@ public class FishingManager extends SkillManager {
 
             Misc.dropItem(target.getLocation(), drop);
             CombatUtils.dealDamage(target, Math.max(target.getMaxHealth() / 4, 1)); // Make it so you can shake a mob no more than 4 times.
-            applyXpGain(ExperienceConfig.getInstance().getFishingShakeXP());
+            applyXpGain(ExperienceConfig.getInstance().getFishingShakeXP(), XPGainReason.PVE);
         }
     }
 

src/main/java/com/gmail/nossr50/skills/herbalism/Herbalism.java

@@ -8,6 +8,7 @@ import org.bukkit.material.SmoothBrick;
 
 import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.config.AdvancedConfig;
+import com.gmail.nossr50.util.skills.SkillUtils;
 
 public class Herbalism {
     public static int farmersDietRankLevel1 = AdvancedConfig.getInstance().getFarmerDietRankChange();
@@ -93,4 +94,14 @@ public class Herbalism {
                 return false;
         }
     }
+
+    /**
+     * Check if the block has a recently grown crop from Green Thumb
+     *
+     * @param blockState The {@link BlockState} to check green thumb regrown for
+     * @return true if the block is recently regrown, false otherwise
+     */
+    public static boolean isRecentlyRegrown(BlockState blockState) {
+        return blockState.hasMetadata(mcMMO.greenThumbDataKey) && !SkillUtils.cooldownExpired(blockState.getMetadata(mcMMO.greenThumbDataKey).get(0).asInt(), 1);
+    }
 }

src/main/java/com/gmail/nossr50/skills/herbalism/HerbalismManager.java

@@ -14,6 +14,7 @@ import org.bukkit.material.CocoaPlant;
 import org.bukkit.material.CocoaPlant.CocoaPlantSize;
 import org.bukkit.material.Crops;
 import org.bukkit.material.NetherWarts;
+import org.bukkit.metadata.FixedMetadataValue;
 
 import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.config.Config;
@@ -25,6 +26,7 @@ import com.gmail.nossr50.datatypes.skills.AbilityType;
 import com.gmail.nossr50.datatypes.skills.SecondaryAbility;
 import com.gmail.nossr50.datatypes.skills.SkillType;
 import com.gmail.nossr50.datatypes.skills.ToolType;
+import com.gmail.nossr50.datatypes.skills.XPGainReason;
 import com.gmail.nossr50.datatypes.treasure.HylianTreasure;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.runnables.skills.HerbalismBlockUpdaterTask;
@@ -113,8 +115,6 @@ public class HerbalismManager extends SkillManager {
     }
 
     /**
-     * 
-     *
      * @param blockState The {@link BlockState} to check ability activation for
      */
     public void herbalismBlockCheck(BlockState blockState) {
@@ -165,7 +165,7 @@ public class HerbalismManager extends SkillManager {
             }
         }
 
-        applyXpGain(xp);
+        applyXpGain(xp, XPGainReason.PVE);
 
         if (drops == null) {
             return;
@@ -330,6 +330,8 @@ public class HerbalismManager extends SkillManager {
     private boolean handleBlockState(BlockState blockState, boolean greenTerra) {
         byte greenThumbStage = getGreenThumbStage();
 
+        blockState.setMetadata(mcMMO.greenThumbDataKey, new FixedMetadataValue(mcMMO.p, (int) (System.currentTimeMillis() / Misc.TIME_CONVERSION_FACTOR)));
+
         switch (blockState.getType()) {
             case CROPS:
                 Crops crops = (Crops) blockState.getData();

src/main/java/com/gmail/nossr50/skills/mining/MiningManager.java

@@ -16,6 +16,7 @@ import com.gmail.nossr50.datatypes.player.McMMOPlayer;
 import com.gmail.nossr50.datatypes.skills.AbilityType;
 import com.gmail.nossr50.datatypes.skills.SecondaryAbility;
 import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.datatypes.skills.XPGainReason;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.runnables.skills.AbilityCooldownTask;
 import com.gmail.nossr50.skills.SkillManager;
@@ -57,7 +58,7 @@ public class MiningManager extends SkillManager {
     public void miningBlockCheck(BlockState blockState) {
         Player player = getPlayer();
 
-        applyXpGain(Mining.getBlockXp(blockState));
+        applyXpGain(Mining.getBlockXp(blockState), XPGainReason.PVE);
 
         if (!Permissions.secondaryAbilityEnabled(player, SecondaryAbility.MINING_DOUBLE_DROPS)) {
             return;
@@ -164,7 +165,7 @@ public class MiningManager extends SkillManager {
             }
         }
 
-        applyXpGain(xp);
+        applyXpGain(xp, XPGainReason.PVE);
     }
 
     /**

src/main/java/com/gmail/nossr50/skills/repair/Repair.java

@@ -1,108 +1,13 @@
 package com.gmail.nossr50.skills.repair;
 
-import java.util.List;
-
 import org.bukkit.Material;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.inventory.Recipe;
-import org.bukkit.inventory.ShapedRecipe;
-import org.bukkit.inventory.ShapelessRecipe;
-import org.bukkit.material.MaterialData;
 
-import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.config.AdvancedConfig;
 import com.gmail.nossr50.config.Config;
-import com.gmail.nossr50.locale.LocaleLoader;
-import com.gmail.nossr50.util.ItemUtils;
 
 public class Repair {
     public static int    repairMasteryMaxBonusLevel = AdvancedConfig.getInstance().getRepairMasteryMaxLevel();
     public static double repairMasteryMaxBonus      = AdvancedConfig.getInstance().getRepairMasteryMaxBonus();
 
-    public static int salvageUnlockLevel = AdvancedConfig.getInstance().getSalvageUnlockLevel();
-
-    public static Material salvageAnvilMaterial = Config.getInstance().getSalvageAnvilMaterial();
-    public static Material repairAnvilMaterial  = Config.getInstance().getRepairAnvilMaterial();
-    public static boolean  anvilMessagesEnabled = Config.getInstance().getRepairAnvilMessagesEnabled();
-
-    /**
-     * Checks if the item is salvageable.
-     *
-     * @param item Item to check
-     *
-     * @return true if the item is salvageable, false otherwise
-     */
-    public static boolean isSalvageable(ItemStack item) {
-        return (Config.getInstance().getSalvageTools() && ItemUtils.isMinecraftTool(item)) || (Config.getInstance().getSalvageArmor() && !ItemUtils.isChainmailArmor(item) && ItemUtils.isMinecraftArmor(item));
-    }
-
-    public static String getAnvilMessage(Material type) {
-        if (type == repairAnvilMaterial) {
-            return LocaleLoader.getString("Repair.Listener.Anvil");
-        }
-
-        if (type == salvageAnvilMaterial) {
-            return LocaleLoader.getString("Repair.Listener.Anvil2");
-        }
-
-        return "";
-    }
-
-    protected static Material getRepairAndSalvageItem(ItemStack inHand) {
-        if (ItemUtils.isDiamondTool(inHand) || ItemUtils.isDiamondArmor(inHand)) {
-            return Material.DIAMOND;
-        }
-        else if (ItemUtils.isGoldTool(inHand) || ItemUtils.isGoldArmor(inHand)) {
-            return Material.GOLD_INGOT;
-        }
-        else if (ItemUtils.isIronTool(inHand) || ItemUtils.isIronArmor(inHand)) {
-            return Material.IRON_INGOT;
-        }
-        else if (ItemUtils.isStoneTool(inHand)) {
-            return Material.COBBLESTONE;
-        }
-        else if (ItemUtils.isWoodTool(inHand)) {
-            return Material.WOOD;
-        }
-        else if (ItemUtils.isLeatherArmor(inHand)) {
-            return Material.LEATHER;
-        }
-        else if (ItemUtils.isStringTool(inHand)) {
-            return Material.STRING;
-        }
-        else {
-            return null;
-        }
-    }
-
-    public static int getRepairAndSalvageQuantities(ItemStack item) {
-        return getRepairAndSalvageQuantities(item, getRepairAndSalvageItem(item), (byte) -1);
-    }
-
-    public static int getRepairAndSalvageQuantities(ItemStack item, Material repairMaterial, byte repairMetadata) {
-        int quantity = 0;
-        MaterialData repairData = repairMaterial != null ? new MaterialData(repairMaterial, repairMetadata) : null;
-        List<Recipe> recipes = mcMMO.p.getServer().getRecipesFor(item);
-
-        if (!recipes.isEmpty()) {
-            Recipe recipe = recipes.get(0);
-
-            if (recipe instanceof ShapelessRecipe) {
-                for (ItemStack ingredient : ((ShapelessRecipe) recipe).getIngredientList()) {
-                    if (ingredient != null && (repairMaterial == null || ingredient.getType() == repairMaterial) && (repairMetadata == -1 || ingredient.getData().equals(repairData))) {
-                        quantity += ingredient.getAmount();
-                    }
-                }
-            }
-            else if (recipe instanceof ShapedRecipe) {
-                for (ItemStack ingredient : ((ShapedRecipe) recipe).getIngredientMap().values()) {
-                    if (ingredient != null && (repairMaterial == null || ingredient.getType() == repairMaterial) && (repairMetadata == -1 || ingredient.getData().equals(repairData))) {
-                        quantity += ingredient.getAmount();
-                    }
-                }
-            }
-        }
-
-        return quantity;
-    }
+    public static Material anvilMaterial  = Config.getInstance().getRepairAnvilMaterial();
 }

src/main/java/com/gmail/nossr50/skills/repair/RepairManager.java

@@ -3,7 +3,6 @@ package com.gmail.nossr50.skills.repair;
 import java.util.Map;
 import java.util.Map.Entry;
 
-import org.bukkit.Location;
 import org.bukkit.Material;
 import org.bukkit.Sound;
 import org.bukkit.enchantments.Enchantment;
@@ -18,6 +17,7 @@ import com.gmail.nossr50.config.experience.ExperienceConfig;
 import com.gmail.nossr50.datatypes.player.McMMOPlayer;
 import com.gmail.nossr50.datatypes.skills.SecondaryAbility;
 import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.datatypes.skills.XPGainReason;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.skills.SkillManager;
 import com.gmail.nossr50.skills.repair.ArcaneForging.Tier;
@@ -29,10 +29,8 @@ import com.gmail.nossr50.util.StringUtils;
 import com.gmail.nossr50.util.skills.SkillUtils;
 
 public class RepairManager extends SkillManager {
-    private boolean placedRepairAnvil;
-    private int     lastRepairClick;
-    private boolean placedSalvageAnvil;
-    private int     lastSalvageClick;
+    private boolean placedAnvil;
+    private int     lastClick;
 
     public RepairManager(McMMOPlayer mcMMOPlayer) {
         super(mcMMOPlayer, SkillType.REPAIR);
@@ -40,25 +38,23 @@ public class RepairManager extends SkillManager {
 
     /**
      * Handles notifications for placing an anvil.
-     *
-     * @param anvilType The {@link Material} of the anvil block
      */
-    public void placedAnvilCheck(Material anvilType) {
+    public void placedAnvilCheck() {
         Player player = getPlayer();
 
-        if (getPlacedAnvil(anvilType)) {
+        if (getPlacedAnvil()) {
             return;
         }
 
-        if (Repair.anvilMessagesEnabled) {
-            player.sendMessage(Repair.getAnvilMessage(anvilType));
+        if (Config.getInstance().getRepairAnvilMessagesEnabled()) {
+            player.sendMessage(LocaleLoader.getString("Repair.Listener.Anvil"));
         }
 
         if (Config.getInstance().getRepairAnvilPlaceSoundsEnabled()) {
             player.playSound(player.getLocation(), Sound.ANVIL_LAND, Misc.ANVIL_USE_VOLUME, Misc.ANVIL_USE_PITCH);
         }
 
-        togglePlacedAnvil(anvilType);
+        togglePlacedAnvil();
     }
 
     public void handleRepair(ItemStack item) {
@@ -66,12 +62,12 @@ public class RepairManager extends SkillManager {
         Repairable repairable = mcMMO.getRepairableManager().getRepairable(item.getType());
 
         // Permissions checks on material and item types
-        if (!repairable.getRepairItemType().getPermissions(player)) {
+        if (!Permissions.repairMaterialType(player, repairable.getRepairMaterialType())) {
             player.sendMessage(LocaleLoader.getString("mcMMO.NoPermission"));
             return;
         }
 
-        if (!repairable.getRepairMaterialType().getPermissions(player)) {
+        if (!Permissions.repairMaterialType(player, repairable.getRepairMaterialType())) {
             player.sendMessage(LocaleLoader.getString("mcMMO.NoPermission"));
             return;
         }
@@ -90,7 +86,7 @@ public class RepairManager extends SkillManager {
         Material repairMaterial = repairable.getRepairMaterial();
         byte repairMaterialMetadata = repairable.getRepairMaterialMetadata();
         ItemStack toRemove = new MaterialData(repairMaterial, repairMaterialMetadata).toItemStack(1);
-        
+
         short startDurability = item.getDurability();
 
         // Do not repair if at full durability
@@ -98,7 +94,7 @@ public class RepairManager extends SkillManager {
             player.sendMessage(LocaleLoader.getString("Repair.Skills.FullDurability"));
             return;
         }
-        
+
         // Check if they have the proper material to repair with
         if (!inventory.contains(repairMaterial)) {
             String message = LocaleLoader.getString("Skills.NeedMore", StringUtils.getPrettyItemString(repairMaterial));
@@ -144,7 +140,7 @@ public class RepairManager extends SkillManager {
         inventory.removeItem(toRemove);
 
         // Give out XP like candy
-        applyXpGain((float) ((getPercentageRepaired(startDurability, newDurability, repairable.getMaximumDurability()) * repairable.getXpMultiplier()) * ExperienceConfig.getInstance().getRepairXPBase() * ExperienceConfig.getInstance().getRepairXP(repairable.getRepairMaterialType())));
+        applyXpGain((float) ((getPercentageRepaired(startDurability, newDurability, repairable.getMaximumDurability()) * repairable.getXpMultiplier()) * ExperienceConfig.getInstance().getRepairXPBase() * ExperienceConfig.getInstance().getRepairXP(repairable.getRepairMaterialType())), XPGainReason.PVE);
 
         // BWONG BWONG BWONG
         if (Config.getInstance().getRepairAnvilUseSoundsEnabled()) {
@@ -159,39 +155,14 @@ public class RepairManager extends SkillManager {
         return ((startDurability - newDurability) / (float) totalDurability);
     }
 
-    public void handleSalvage(Location location, ItemStack item) {
-        Player player = getPlayer();
-
-        if (getSkillLevel() < Repair.salvageUnlockLevel) {
-            player.sendMessage(LocaleLoader.getString("Repair.Skills.AdeptSalvage"));
-            return;
-        }
-
-        if (item.getDurability() == 0) {
-            player.setItemInHand(new ItemStack(Material.AIR));
-            location.setY(location.getY() + 1);
-
-            Misc.dropItems(location, new ItemStack(Repair.getRepairAndSalvageItem(item)), Repair.getRepairAndSalvageQuantities(item) * item.getAmount());
-
-            if (Config.getInstance().getRepairAnvilUseSoundsEnabled()) {
-                player.playSound(player.getLocation(), Sound.ANVIL_USE, Misc.ANVIL_USE_VOLUME, Misc.ANVIL_USE_PITCH);
-            }
-
-            player.sendMessage(LocaleLoader.getString("Repair.Skills.SalvageSuccess"));
-        }
-        else {
-            player.sendMessage(LocaleLoader.getString("Repair.Skills.NotFullDurability"));
-        }
-    }
-
     /**
      * Check if the player has tried to use an Anvil before.
      *
      * @return true if the player has confirmed using an Anvil
      */
-    public boolean checkConfirmation(Material anvilType, boolean actualize) {
+    public boolean checkConfirmation(boolean actualize) {
         Player player = getPlayer();
-        long lastUse = getLastAnvilUse(anvilType);
+        long lastUse = getLastAnvilUse();
 
         if (!SkillUtils.cooldownExpired(lastUse, 3) || !Config.getInstance().getRepairConfirmRequired()) {
             return true;
@@ -201,14 +172,8 @@ public class RepairManager extends SkillManager {
             return false;
         }
 
-        actualizeLastAnvilUse(anvilType);
-
-        if (anvilType == Repair.repairAnvilMaterial) {
-            player.sendMessage(LocaleLoader.getString("Skills.ConfirmOrCancel", LocaleLoader.getString("Repair.Pretty.Name")));
-        }
-        else if (anvilType == Repair.salvageAnvilMaterial) {
-            player.sendMessage(LocaleLoader.getString("Skills.ConfirmOrCancel", LocaleLoader.getString("Salvage.Pretty.Name")));
-        }
+        actualizeLastAnvilUse();
+        player.sendMessage(LocaleLoader.getString("Skills.ConfirmOrCancel", LocaleLoader.getString("Repair.Pretty.Name")));
 
         return false;
     }
@@ -367,61 +332,27 @@ public class RepairManager extends SkillManager {
      * Repair Anvil Placement
      */
 
-    public boolean getPlacedAnvil(Material anvilType) {
-        if (anvilType == Repair.repairAnvilMaterial) {
-            return placedRepairAnvil;
-        }
-
-        if (anvilType == Repair.salvageAnvilMaterial) {
-            return placedSalvageAnvil;
-        }
-
-        return true;
+    public boolean getPlacedAnvil() {
+        return placedAnvil;
     }
 
-    public void togglePlacedAnvil(Material anvilType) {
-        if (anvilType == Repair.repairAnvilMaterial) {
-            placedRepairAnvil = !placedRepairAnvil;
-        }
-
-        if (anvilType == Repair.salvageAnvilMaterial) {
-            placedSalvageAnvil = !placedSalvageAnvil;
-        }
+    public void togglePlacedAnvil() {
+        placedAnvil = !placedAnvil;
     }
 
     /*
      * Repair Anvil Usage
      */
 
-    public int getLastAnvilUse(Material anvilType) {
-        if (anvilType == Repair.repairAnvilMaterial) {
-            return lastRepairClick;
-        }
-
-        if (anvilType == Repair.salvageAnvilMaterial) {
-            return lastSalvageClick;
-        }
-
-        return 0;
+    public int getLastAnvilUse() {
+        return lastClick;
     }
 
-    public void setLastAnvilUse(Material anvilType, int value) {
-        if (anvilType == Repair.repairAnvilMaterial) {
-            lastRepairClick = value;
-        }
-
-        if (anvilType == Repair.salvageAnvilMaterial) {
-            lastSalvageClick = value;
-        }
+    public void setLastAnvilUse(int value) {
+        lastClick = value;
     }
 
-    public void actualizeLastAnvilUse(Material anvilType) {
-        if (anvilType == Repair.repairAnvilMaterial) {
-            lastRepairClick = (int) (System.currentTimeMillis() / Misc.TIME_CONVERSION_FACTOR);
-        }
-
-        if (anvilType == Repair.salvageAnvilMaterial) {
-            lastSalvageClick = (int) (System.currentTimeMillis() / Misc.TIME_CONVERSION_FACTOR);
-        }
+    public void actualizeLastAnvilUse() {
+        lastClick = (int) (System.currentTimeMillis() / Misc.TIME_CONVERSION_FACTOR);
     }
 }

src/main/java/com/gmail/nossr50/skills/repair/repairables/RepairItemType.java

@@ -1,33 +0,0 @@
-package com.gmail.nossr50.skills.repair.repairables;
-
-import org.bukkit.entity.Player;
-
-import com.gmail.nossr50.util.Permissions;
-
-public enum RepairItemType {
-    ARMOR,
-    TOOL,
-    OTHER;
-
-    /**
-     * Get the base permissions associated with this RepairItemType.
-     *
-     * @param player The player to check the permissions for
-     * @return true if the player has permissions, false otherwise
-     */
-    public boolean getPermissions(Player player) {
-        switch (this) {
-            case ARMOR:
-                return Permissions.repairArmor(player);
-
-            case TOOL:
-                return Permissions.repairTools(player);
-
-            case OTHER:
-                return Permissions.repairOtherItems(player);
-
-            default:
-                return false;
-        }
-    }
-}

src/main/java/com/gmail/nossr50/skills/repair/repairables/RepairMaterialType.java

@@ -1,84 +0,0 @@
-package com.gmail.nossr50.skills.repair.repairables;
-
-import org.bukkit.Material;
-import org.bukkit.entity.Player;
-
-import com.gmail.nossr50.util.Permissions;
-
-public enum RepairMaterialType {
-    STRING,
-    LEATHER,
-    WOOD,
-    STONE,
-    IRON,
-    GOLD,
-    DIAMOND,
-    OTHER;
-
-    /**
-     * Get the base permissions associated with this RepairMaterialType.
-     *
-     * @param player The player to check the permissions for
-     *
-     * @return true if the player has permissions, false otherwise
-     */
-    public boolean getPermissions(Player player) {
-        switch (this) {
-            case STRING:
-                return Permissions.repairString(player);
-
-            case LEATHER:
-                return Permissions.repairLeather(player);
-
-            case WOOD:
-                return Permissions.repairWood(player);
-
-            case STONE:
-                return Permissions.repairStone(player);
-
-            case IRON:
-                return Permissions.repairIron(player);
-
-            case GOLD:
-                return Permissions.repairGold(player);
-
-            case DIAMOND:
-                return Permissions.repairDiamond(player);
-
-            case OTHER:
-                return Permissions.repairOtherMaterials(player);
-
-            default:
-                return false;
-        }
-    }
-
-    public Material getDefaultRepairMaterial() {
-        switch (this) {
-            case STRING:
-                return Material.STRING;
-
-            case LEATHER:
-                return Material.LEATHER;
-
-            case WOOD:
-                return Material.WOOD;
-
-            case STONE:
-                return Material.COBBLESTONE;
-
-            case IRON:
-                return Material.IRON_INGOT;
-
-            case GOLD:
-                return Material.GOLD_INGOT;
-
-            case DIAMOND:
-                return Material.DIAMOND;
-
-            case OTHER:
-            default:
-                return null;
-        }
-    }
-}

src/main/java/com/gmail/nossr50/skills/repair/repairables/Repairable.java

@@ -2,6 +2,9 @@ package com.gmail.nossr50.skills.repair.repairables;
 
 import org.bukkit.Material;
 
+import com.gmail.nossr50.datatypes.skills.ItemType;
+import com.gmail.nossr50.datatypes.skills.MaterialType;
+
 
 public interface Repairable {
     /**
@@ -30,14 +33,14 @@ public interface Repairable {
      *
      * @return the RepairItemType for this repairable
      */
-    public RepairItemType getRepairItemType();
+    public ItemType getRepairItemType();
 
     /**
      * Gets the RepairMaterialType value for this repairable item
      *
      * @return the RepairMaterialType for this repairable
      */
-    public RepairMaterialType getRepairMaterialType();
+    public MaterialType getRepairMaterialType();
 
     /**
      * Gets the minimum quantity of repair materials ignoring all other repair bonuses

src/main/java/com/gmail/nossr50/skills/repair/repairables/RepairableFactory.java

@@ -2,13 +2,16 @@ package com.gmail.nossr50.skills.repair.repairables;
 
 import org.bukkit.Material;
 
+import com.gmail.nossr50.datatypes.skills.ItemType;
+import com.gmail.nossr50.datatypes.skills.MaterialType;
+
 
 public class RepairableFactory {
     public static Repairable getRepairable(Material itemMaterial, Material repairMaterial, byte repairMetadata, int minimumQuantity, short maximumDurability) {
-        return getRepairable(itemMaterial, repairMaterial, repairMetadata, 0, minimumQuantity, maximumDurability, RepairItemType.OTHER, RepairMaterialType.OTHER, 1);
+        return getRepairable(itemMaterial, repairMaterial, repairMetadata, 0, minimumQuantity, maximumDurability, ItemType.OTHER, MaterialType.OTHER, 1);
     }
 
-    public static Repairable getRepairable(Material itemMaterial, Material repairMaterial, byte repairMetadata, int minimumLevel, int minimumQuantity, short maximumDurability, RepairItemType repairItemType, RepairMaterialType repairMaterialType, double xpMultiplier) {
+    public static Repairable getRepairable(Material itemMaterial, Material repairMaterial, byte repairMetadata, int minimumLevel, int minimumQuantity, short maximumDurability, ItemType repairItemType, MaterialType repairMaterialType, double xpMultiplier) {
         // TODO: Add in loading from config what type of repairable we want.
         return new SimpleRepairable(itemMaterial, repairMaterial, repairMetadata, minimumLevel, minimumQuantity, maximumDurability, repairItemType, repairMaterialType, xpMultiplier);
     }

src/main/java/com/gmail/nossr50/skills/repair/repairables/SimpleRepairable.java

@@ -2,17 +2,20 @@ package com.gmail.nossr50.skills.repair.repairables;
 
 import org.bukkit.Material;
 
+import com.gmail.nossr50.datatypes.skills.ItemType;
+import com.gmail.nossr50.datatypes.skills.MaterialType;
+
 
 public class SimpleRepairable implements Repairable {
     private final Material itemMaterial, repairMaterial;
     private final int minimumQuantity, minimumLevel;
     private final short maximumDurability, baseRepairDurability;
     private final byte repairMetadata;
-    private final RepairItemType repairItemType;
-    private final RepairMaterialType repairMaterialType;
+    private final ItemType repairItemType;
+    private final MaterialType repairMaterialType;
     private final double xpMultiplier;
 
-    protected SimpleRepairable(Material type, Material repairMaterial, byte repairMetadata, int minimumLevel, int minimumQuantity, short maximumDurability, RepairItemType repairItemType, RepairMaterialType repairMaterialType, double xpMultiplier) {
+    protected SimpleRepairable(Material type, Material repairMaterial, byte repairMetadata, int minimumLevel, int minimumQuantity, short maximumDurability, ItemType repairItemType, MaterialType repairMaterialType, double xpMultiplier) {
         this.itemMaterial = type;
         this.repairMaterial = repairMaterial;
         this.repairMetadata = repairMetadata;
@@ -41,12 +44,12 @@ public class SimpleRepairable implements Repairable {
     }
 
     @Override
-    public RepairItemType getRepairItemType() {
+    public ItemType getRepairItemType() {
         return repairItemType;
     }
 
     @Override
-    public RepairMaterialType getRepairMaterialType() {
+    public MaterialType getRepairMaterialType() {
         return repairMaterialType;
     }
 

src/main/java/com/gmail/nossr50/skills/salvage/Salvage.java

@@ -0,0 +1,58 @@
+package com.gmail.nossr50.skills.salvage;
+
+import org.bukkit.Material;
+
+import com.gmail.nossr50.config.AdvancedConfig;
+import com.gmail.nossr50.config.Config;
+
+public class Salvage {
+    // The order of the values is extremely important, a few methods depend on it to work properly
+    public enum Tier {
+        EIGHT(8),
+        SEVEN(7),
+        SIX(6),
+        FIVE(5),
+        FOUR(4),
+        THREE(3),
+        TWO(2),
+        ONE(1);
+
+        int numerical;
+
+        private Tier(int numerical) {
+            this.numerical = numerical;
+        }
+
+        public int toNumerical() {
+            return numerical;
+        }
+
+        protected int getLevel() {
+            return AdvancedConfig.getInstance().getArcaneSalvageRankLevel(this);
+        }
+
+        protected double getExtractFullEnchantChance() {
+            return AdvancedConfig.getInstance().getArcaneSalvageExtractFullEnchantsChance(this);
+        }
+
+        protected double getExtractPartialEnchantChance() {
+            return AdvancedConfig.getInstance().getArcaneSalvageExtractPartialEnchantsChance(this);
+        }
+    }
+
+    public static Material anvilMaterial = Config.getInstance().getSalvageAnvilMaterial();
+
+    public static int    salvageMaxPercentageLevel = AdvancedConfig.getInstance().getSalvageMaxPercentageLevel();
+    public static double salvageMaxPercentage      = AdvancedConfig.getInstance().getSalvageMaxPercentage();
+
+    public static int advancedSalvageUnlockLevel = AdvancedConfig.getInstance().getAdvancedSalvageUnlockLevel();
+
+    public static boolean arcaneSalvageDowngrades  = AdvancedConfig.getInstance().getArcaneSalvageEnchantDowngradeEnabled();
+    public static boolean arcaneSalvageEnchantLoss = AdvancedConfig.getInstance().getArcaneSalvageEnchantLossEnabled();
+
+    protected static int calculateSalvageableAmount(short currentDurability, short maxDurability, int baseAmount) {
+        double percentDamaged = (maxDurability <= 0) ? 1D : (double) (maxDurability - currentDurability) / maxDurability;
+
+        return (int) Math.floor(baseAmount * percentDamaged);
+    }
+}

src/main/java/com/gmail/nossr50/skills/salvage/SalvageManager.java

@@ -0,0 +1,265 @@
+package com.gmail.nossr50.skills.salvage;
+
+import java.util.Map;
+import java.util.Map.Entry;
+
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.EnchantmentStorageMeta;
+import org.bukkit.material.MaterialData;
+
+import com.gmail.nossr50.mcMMO;
+import com.gmail.nossr50.config.Config;
+import com.gmail.nossr50.datatypes.player.McMMOPlayer;
+import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.skills.SkillManager;
+import com.gmail.nossr50.skills.salvage.Salvage.Tier;
+import com.gmail.nossr50.skills.salvage.salvageables.Salvageable;
+import com.gmail.nossr50.util.Misc;
+import com.gmail.nossr50.util.Permissions;
+import com.gmail.nossr50.util.StringUtils;
+import com.gmail.nossr50.util.skills.SkillUtils;
+
+public class SalvageManager extends SkillManager {
+    private boolean placedAnvil;
+    private int     lastClick;
+
+    public SalvageManager(McMMOPlayer mcMMOPlayer) {
+        super(mcMMOPlayer, SkillType.SALVAGE);
+    }
+
+    /**
+     * Handles notifications for placing an anvil.
+     */
+    public void placedAnvilCheck() {
+        Player player = getPlayer();
+
+        if (getPlacedAnvil()) {
+            return;
+        }
+
+        if (Config.getInstance().getSalvageAnvilMessagesEnabled()) {
+            player.sendMessage(LocaleLoader.getString("Salvage.Listener.Anvil"));
+        }
+
+        if (Config.getInstance().getSalvageAnvilPlaceSoundsEnabled()) {
+            player.playSound(player.getLocation(), Sound.ANVIL_LAND, Misc.ANVIL_USE_VOLUME, Misc.ANVIL_USE_PITCH);
+        }
+
+        togglePlacedAnvil();
+    }
+
+    public void handleSalvage(Location location, ItemStack item) {
+        Player player = getPlayer();
+
+        Salvageable salvageable = mcMMO.getSalvageableManager().getSalvageable(item.getType());
+
+        // Permissions checks on material and item types
+        if (!Permissions.salvageItemType(player, salvageable.getSalvageItemType())) {
+            player.sendMessage(LocaleLoader.getString("mcMMO.NoPermission"));
+            return;
+        }
+
+        if (!Permissions.salvageMaterialType(player, salvageable.getSalvageMaterialType())) {
+            player.sendMessage(LocaleLoader.getString("mcMMO.NoPermission"));
+            return;
+        }
+
+        int skillLevel = getSkillLevel();
+        int minimumSalvageableLevel = salvageable.getMinimumLevel();
+
+        // Level check
+        if (skillLevel < minimumSalvageableLevel) {
+            player.sendMessage(LocaleLoader.getString("Salvage.Skills.Adept.Level", minimumSalvageableLevel, StringUtils.getPrettyItemString(item.getType())));
+            return;
+        }
+
+        if (item.getDurability() != 0 && (getSkillLevel() < Salvage.advancedSalvageUnlockLevel || !Permissions.advancedSalvage(player))) {
+            player.sendMessage(LocaleLoader.getString("Salvage.Skills.Adept.Damaged"));
+            return;
+        }
+
+        byte salvageMaterialMetadata = salvageable.getSalvageMaterialMetadata();
+
+        int salvageableAmount = Salvage.calculateSalvageableAmount(item.getDurability(), salvageable.getMaximumDurability(), salvageable.getMaximumQuantity());
+
+        if (salvageableAmount == 0) {
+            player.sendMessage(LocaleLoader.getString("Salvage.Skills.TooDamaged"));
+            return;
+        }
+
+        salvageableAmount = Math.max((int) (salvageableAmount * getMaxSalvagePercentage()), 1); // Always get at least something back, if you're capable of salvaging it.
+
+        player.setItemInHand(new ItemStack(Material.AIR));
+        location.add(0, 1, 0);
+
+        Map<Enchantment, Integer> enchants = item.getEnchantments();
+
+        if (!enchants.isEmpty()) {
+            ItemStack enchantBook = arcaneSalvageCheck(enchants);
+
+            if (enchantBook != null) {
+                Misc.dropItem(location, enchantBook);
+            }
+        }
+
+        Misc.dropItems(location, new MaterialData(salvageable.getSalvageMaterial(), salvageMaterialMetadata).toItemStack(salvageableAmount), 1);
+
+        // BWONG BWONG BWONG - CLUNK!
+        if (Config.getInstance().getSalvageAnvilUseSoundsEnabled()) {
+            player.playSound(player.getLocation(), Sound.ANVIL_USE, Misc.ANVIL_USE_VOLUME, Misc.ANVIL_USE_PITCH);
+            player.playSound(player.getLocation(), Sound.ITEM_BREAK, 1.0F, 1.0F);
+        }
+
+        player.sendMessage(LocaleLoader.getString("Salvage.Skills.Success"));
+    }
+
+    public double getMaxSalvagePercentage() {
+        return Math.min((((Salvage.salvageMaxPercentage / Salvage.salvageMaxPercentageLevel) * getSkillLevel()) / 100.0D), Salvage.salvageMaxPercentage / 100.0D);
+    }
+
+    /**
+     * Gets the Arcane Salvage rank
+     *
+     * @return the current Arcane Salvage rank
+     */
+    public int getArcaneSalvageRank() {
+        int skillLevel = getSkillLevel();
+
+        for (Tier tier : Tier.values()) {
+            if (skillLevel >= tier.getLevel()) {
+                return tier.toNumerical();
+            }
+        }
+
+        return 0;
+    }
+
+    public double getExtractFullEnchantChance() {
+        int skillLevel = getSkillLevel();
+
+        for (Tier tier : Tier.values()) {
+            if (skillLevel >= tier.getLevel()) {
+                return tier.getExtractFullEnchantChance();
+            }
+        }
+
+        return 0;
+    }
+
+    public double getExtractPartialEnchantChance() {
+        int skillLevel = getSkillLevel();
+
+        for (Tier tier : Tier.values()) {
+            if (skillLevel >= tier.getLevel()) {
+                return tier.getExtractPartialEnchantChance();
+            }
+        }
+
+        return 0;
+    }
+
+    private ItemStack arcaneSalvageCheck(Map<Enchantment, Integer> enchants) {
+        Player player = getPlayer();
+
+        if (getArcaneSalvageRank() == 0 || !Permissions.arcaneSalvage(player)) {
+            player.sendMessage(LocaleLoader.getString("Salvage.Skills.ArcaneFailed"));
+            return null;
+        }
+
+        ItemStack book = new ItemStack(Material.ENCHANTED_BOOK);
+        EnchantmentStorageMeta enchantMeta = (EnchantmentStorageMeta) book.getItemMeta();
+
+        boolean downgraded = false;
+
+        for (Entry<Enchantment, Integer> enchant : enchants.entrySet()) {
+            int successChance = Misc.getRandom().nextInt(activationChance);
+
+            if (!Salvage.arcaneSalvageEnchantLoss || getExtractFullEnchantChance() > successChance) {
+                enchantMeta.addStoredEnchant(enchant.getKey(), enchant.getValue(), true);
+            }
+            else if (enchant.getValue() > 1 && Salvage.arcaneSalvageDowngrades && getExtractPartialEnchantChance() > successChance) {
+                enchantMeta.addStoredEnchant(enchant.getKey(), enchant.getValue() - 1, true);
+                downgraded = true;
+            }
+            else {
+                downgraded = true;
+            }
+        }
+
+        Map<Enchantment, Integer> newEnchants = enchantMeta.getStoredEnchants();
+
+        if (newEnchants.isEmpty()) {
+            player.sendMessage(LocaleLoader.getString("Salvage.Skills.ArcaneFailed"));
+            return null;
+        }
+
+        if (downgraded || newEnchants.size() < enchants.size()) {
+            player.sendMessage(LocaleLoader.getString("Salvage.Skills.ArcanePartial"));
+        }
+        else {
+            player.sendMessage(LocaleLoader.getString("Salvage.Skills.ArcaneSuccess"));
+        }
+
+        book.setItemMeta(enchantMeta);
+        return book;
+    }
+
+    /**
+     * Check if the player has tried to use an Anvil before.
+     * @param actualize
+     *
+     * @return true if the player has confirmed using an Anvil
+     */
+    public boolean checkConfirmation(boolean actualize) {
+        Player player = getPlayer();
+        long lastUse = getLastAnvilUse();
+
+        if (!SkillUtils.cooldownExpired(lastUse, 3) || !Config.getInstance().getSalvageConfirmRequired()) {
+            return true;
+        }
+
+        if (!actualize) {
+            return false;
+        }
+
+        actualizeLastAnvilUse();
+
+        player.sendMessage(LocaleLoader.getString("Skills.ConfirmOrCancel", LocaleLoader.getString("Salvage.Pretty.Name")));
+
+        return false;
+    }
+
+    /*
+     * Salvage Anvil Placement
+     */
+
+    public boolean getPlacedAnvil() {
+        return placedAnvil;
+    }
+
+    public void togglePlacedAnvil() {
+        placedAnvil = !placedAnvil;
+    }
+
+    /*
+     * Salvage Anvil Usage
+     */
+
+    public int getLastAnvilUse() {
+        return lastClick;
+    }
+
+    public void setLastAnvilUse(int value) {
+        lastClick = value;
+    }
+
+    public void actualizeLastAnvilUse() {
+        lastClick = (int) (System.currentTimeMillis() / Misc.TIME_CONVERSION_FACTOR);
+    }
+}

src/main/java/com/gmail/nossr50/skills/salvage/salvageables/Salvageable.java

@@ -0,0 +1,82 @@
+package com.gmail.nossr50.skills.salvage.salvageables;
+
+import org.bukkit.Material;
+
+import com.gmail.nossr50.datatypes.skills.ItemType;
+import com.gmail.nossr50.datatypes.skills.MaterialType;
+
+public interface Salvageable {
+    /**
+     * Gets the type of this repairable item
+     *
+     * @return the type of this repairable
+     */
+    public Material getItemMaterial();
+
+    /**
+     * Gets the id of the material used to repair this item
+     *
+     * @return the id of the repair material
+     */
+    public Material getSalvageMaterial();
+
+    /**
+     * Gets the metadata byte value of the material used to repair this item
+     *
+     * @return the byte metadata of the repair material
+     */
+    public byte getSalvageMaterialMetadata();
+
+    /**
+     * Gets the RepairItemType value for this repairable item
+     *
+     * @return the RepairItemType for this repairable
+     */
+    public ItemType getSalvageItemType();
+
+    /**
+     * Gets the RepairMaterialType value for this repairable item
+     *
+     * @return the RepairMaterialType for this repairable
+     */
+    public MaterialType getSalvageMaterialType();
+
+    /**
+     * Gets the maximum quantity of salvage materials ignoring all other salvage bonuses
+     *
+     * This is typically set to the number of items needed to create that item, for example 5 for helmets or 2 for swords
+     *
+     * @return the maximum number of items
+     */
+    public int getMaximumQuantity();
+
+    /**
+     * Gets the maximum durability of this item before it breaks
+     *
+     * @return the maximum durability
+     */
+    public short getMaximumDurability();
+
+    /**
+     * Gets the base repair durability on which to calculate bonuses.
+     *
+     * This is actually the maximum durability divided by the minimum quantity
+     *
+     * @return the base repair durability
+     */
+    public short getBaseSalvageDurability();
+
+    /**
+     * Gets the minimum repair level needed to repair this item
+     *
+     * @return the minimum level to repair this item, or 0 for no minimum
+     */
+    public int getMinimumLevel();
+
+    /**
+     * Gets the xpMultiplier for this repairable
+     *
+     * @return the xpMultiplier of this repairable
+     */
+    public double getXpMultiplier();
+}

src/main/java/com/gmail/nossr50/skills/salvage/salvageables/SalvageableFactory.java

@@ -0,0 +1,17 @@
+package com.gmail.nossr50.skills.salvage.salvageables;
+
+import org.bukkit.Material;
+
+import com.gmail.nossr50.datatypes.skills.ItemType;
+import com.gmail.nossr50.datatypes.skills.MaterialType;
+
+public class SalvageableFactory {
+    public static Salvageable getSalvageable(Material itemMaterial, Material repairMaterial, byte repairMetadata, int maximumQuantity, short maximumDurability) {
+        return getSalvageable(itemMaterial, repairMaterial, repairMetadata, 0, maximumQuantity, maximumDurability, ItemType.OTHER, MaterialType.OTHER, 1);
+    }
+
+    public static Salvageable getSalvageable(Material itemMaterial, Material repairMaterial, byte repairMetadata, int minimumLevel, int maximumQuantity, short maximumDurability, ItemType repairItemType, MaterialType repairMaterialType, double xpMultiplier) {
+        // TODO: Add in loading from config what type of repairable we want.
+        return new SimpleSalvageable(itemMaterial, repairMaterial, repairMetadata, minimumLevel, maximumQuantity, maximumDurability, repairItemType, repairMaterialType, xpMultiplier);
+    }
+}

src/main/java/com/gmail/nossr50/skills/salvage/salvageables/SalvageableManager.java

@@ -0,0 +1,49 @@
+package com.gmail.nossr50.skills.salvage.salvageables;
+
+import java.util.List;
+
+import org.bukkit.Material;
+import org.bukkit.inventory.ItemStack;
+
+public interface SalvageableManager {
+    /**
+     * Register a salvageable with the SalvageManager
+     *
+     * @param salvageable Salvageable to register
+     */
+    public void registerSalvageable(Salvageable salvageable);
+
+    /**
+     * Register a list of salvageables with the SalvageManager
+     *
+     * @param salvageables List<Salvageable> to register
+     */
+    public void registerSalvageables(List<Salvageable> salvageables);
+
+    /**
+     * Checks if an item is salvageable
+     *
+     * @param type Material to check if salvageable
+     *
+     * @return true if salvageable, false if not
+     */
+    public boolean isSalvageable(Material type);
+
+    /**
+     * Checks if an item is salvageable
+     *
+     * @param itemStack Item to check if salvageable
+     *
+     * @return true if salvageable, false if not
+     */
+    public boolean isSalvageable(ItemStack itemStack);
+
+    /**
+     * Gets the salvageable with this type
+     *
+     * @param type Material of the salvageable to look for
+     *
+     * @return the salvageable, can be null
+     */
+    public Salvageable getSalvageable(Material type);
+}

src/main/java/com/gmail/nossr50/skills/salvage/salvageables/SimpleSalvageable.java

@@ -0,0 +1,80 @@
+package com.gmail.nossr50.skills.salvage.salvageables;
+
+import org.bukkit.Material;
+
+import com.gmail.nossr50.datatypes.skills.ItemType;
+import com.gmail.nossr50.datatypes.skills.MaterialType;
+
+
+public class SimpleSalvageable implements Salvageable {
+    private final Material itemMaterial, salvageMaterial;
+    private final int maximumQuantity, minimumLevel;
+    private final short maximumDurability, baseSalvageDurability;
+    private final byte salvageMetadata;
+    private final ItemType salvageItemType;
+    private final MaterialType salvageMaterialType;
+    private final double xpMultiplier;
+
+    protected SimpleSalvageable(Material type, Material salvageMaterial, byte salvageMetadata, int minimumLevel, int maximumQuantity, short maximumDurability, ItemType salvageItemType, MaterialType salvageMaterialType, double xpMultiplier) {
+        this.itemMaterial = type;
+        this.salvageMaterial = salvageMaterial;
+        this.salvageMetadata = salvageMetadata;
+        this.salvageItemType = salvageItemType;
+        this.salvageMaterialType = salvageMaterialType;
+        this.minimumLevel = minimumLevel;
+        this.maximumQuantity = maximumQuantity;
+        this.maximumDurability = maximumDurability;
+        this.baseSalvageDurability = (short) (maximumDurability / maximumQuantity);
+        this.xpMultiplier = xpMultiplier;
+    }
+
+    @Override
+    public Material getItemMaterial() {
+        return itemMaterial;
+    }
+
+    @Override
+    public Material getSalvageMaterial() {
+        return salvageMaterial;
+    }
+
+    @Override
+    public byte getSalvageMaterialMetadata() {
+        return salvageMetadata;
+    }
+
+    @Override
+    public ItemType getSalvageItemType() {
+        return salvageItemType;
+    }
+
+    @Override
+    public MaterialType getSalvageMaterialType() {
+        return salvageMaterialType;
+    }
+
+    @Override
+    public int getMaximumQuantity() {
+        return maximumQuantity;
+    }
+
+    @Override
+    public short getMaximumDurability() {
+        return maximumDurability;
+    }
+
+    @Override
+    public short getBaseSalvageDurability() {
+        return baseSalvageDurability;
+    }
+
+    @Override
+    public int getMinimumLevel() {
+        return minimumLevel;
+    }
+
+    @Override
+    public double getXpMultiplier() {
+        return xpMultiplier;
+    }
+}

src/main/java/com/gmail/nossr50/skills/salvage/salvageables/SimpleSalvageableManager.java

@@ -0,0 +1,48 @@
+package com.gmail.nossr50.skills.salvage.salvageables;
+
+import java.util.HashMap;
+import java.util.List;
+
+import org.bukkit.Material;
+import org.bukkit.inventory.ItemStack;
+
+
+public class SimpleSalvageableManager implements SalvageableManager {
+    private HashMap<Material, Salvageable> salvageables;
+
+    public SimpleSalvageableManager() {
+        this(55);
+    }
+
+    public SimpleSalvageableManager(int salvageablesSize) {
+        this.salvageables = new HashMap<Material, Salvageable>(salvageablesSize);
+    }
+
+    @Override
+    public void registerSalvageable(Salvageable salvageable) {
+        Material item = salvageable.getItemMaterial();
+        salvageables.put(item, salvageable);
+    }
+
+    @Override
+    public void registerSalvageables(List<Salvageable> salvageables) {
+        for (Salvageable salvageable : salvageables) {
+            registerSalvageable(salvageable);
+        }
+    }
+
+    @Override
+    public boolean isSalvageable(Material type) {
+        return salvageables.containsKey(type);
+    }
+
+    @Override
+    public boolean isSalvageable(ItemStack itemStack) {
+        return isSalvageable(itemStack.getType());
+    }
+
+    @Override
+    public Salvageable getSalvageable(Material type) {
+        return salvageables.get(type);
+    }
+}

src/main/java/com/gmail/nossr50/skills/smelting/SmeltingManager.java

@@ -10,6 +10,7 @@ import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.datatypes.player.McMMOPlayer;
 import com.gmail.nossr50.datatypes.skills.SecondaryAbility;
 import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.datatypes.skills.XPGainReason;
 import com.gmail.nossr50.events.skills.secondaryabilities.SecondaryAbilityWeightedActivationCheckEvent;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.skills.SkillManager;
@@ -85,7 +86,7 @@ public class SmeltingManager extends SkillManager {
     }
 
     public ItemStack smeltProcessing(ItemStack smelting, ItemStack result) {
-        applyXpGain(Smelting.getResourceXp(smelting));
+        applyXpGain(Smelting.getResourceXp(smelting), XPGainReason.PVE);
 
         if (isSecondSmeltSuccessful()) {
             ItemStack newResult = result.clone();

src/main/java/com/gmail/nossr50/skills/taming/Taming.java

@@ -67,7 +67,7 @@ public class Taming {
 
             case WOLF:
                 return LocaleLoader.getString("Taming.Summon.Fail.Wolf");
-                
+
             case HORSE:
                 return LocaleLoader.getString("Taming.Summon.Fail.Horse");
 

src/main/java/com/gmail/nossr50/skills/taming/TamingManager.java

@@ -16,6 +16,7 @@ import com.gmail.nossr50.config.Config;
 import com.gmail.nossr50.datatypes.player.McMMOPlayer;
 import com.gmail.nossr50.datatypes.skills.SecondaryAbility;
 import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.datatypes.skills.XPGainReason;
 import com.gmail.nossr50.events.fake.FakeEntityTameEvent;
 import com.gmail.nossr50.events.skills.secondaryabilities.SecondaryAbilityWeightedActivationCheckEvent;
 import com.gmail.nossr50.locale.LocaleLoader;
@@ -72,15 +73,15 @@ public class TamingManager extends SkillManager {
     public void awardTamingXP(LivingEntity entity) {
         switch (entity.getType()) {
             case HORSE:
-                applyXpGain(Taming.horseXp);
+                applyXpGain(Taming.horseXp, XPGainReason.PVE);
                 return;
 
             case WOLF:
-                applyXpGain(Taming.wolfXp);
+                applyXpGain(Taming.wolfXp, XPGainReason.PVE);
                 return;
 
             case OCELOT:
-                applyXpGain(Taming.ocelotXp);
+                applyXpGain(Taming.ocelotXp, XPGainReason.PVE);
                 return;
 
             default:

src/main/java/com/gmail/nossr50/skills/unarmed/Unarmed.java

@@ -26,7 +26,7 @@ public class Unarmed {
         if (inventory.containsAtLeast(dropStack, 1)) {
             int nextSlot = 0;
 
-            for (ItemStack itemstack: inventory) {
+            for (ItemStack itemstack : inventory) {
                 if (dropStack.isSimilar(itemstack)) {
                     int itemAmount = itemstack.getAmount();
                     int itemMax = itemstack.getMaxStackSize();
@@ -57,7 +57,7 @@ public class Unarmed {
         if (firstEmpty == inventory.getHeldItemSlot()) {
             int nextSlot = firstEmpty + 1;
 
-            for (Iterator<ItemStack> iterator = inventory.iterator(nextSlot); iterator.hasNext();) {
+            for (Iterator<ItemStack> iterator = inventory.iterator(nextSlot); iterator.hasNext(); ) {
                 ItemStack itemstack = iterator.next();
 
                 if (itemstack == null) {

src/main/java/com/gmail/nossr50/skills/woodcutting/WoodcuttingManager.java

@@ -17,6 +17,7 @@ import com.gmail.nossr50.datatypes.player.McMMOPlayer;
 import com.gmail.nossr50.datatypes.skills.AbilityType;
 import com.gmail.nossr50.datatypes.skills.SecondaryAbility;
 import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.datatypes.skills.XPGainReason;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.skills.SkillManager;
 import com.gmail.nossr50.skills.woodcutting.Woodcutting.ExperienceGainMethod;
@@ -63,7 +64,7 @@ public class WoodcuttingManager extends SkillManager {
                 }
         }
 
-        applyXpGain(xp);
+        applyXpGain(xp, XPGainReason.PVE);
     }
 
     /**
@@ -170,7 +171,7 @@ public class WoodcuttingManager extends SkillManager {
             blockState.update(true);
         }
 
-        applyXpGain(xp);
+        applyXpGain(xp, XPGainReason.PVE);
     }
 
 }

src/main/java/com/gmail/nossr50/util/BlockUtils.java

@@ -14,6 +14,7 @@ import org.bukkit.material.SmoothBrick;
 
 import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.skills.repair.Repair;
+import com.gmail.nossr50.skills.salvage.Salvage;
 
 public final class BlockUtils {
     private BlockUtils() {}
@@ -304,7 +305,7 @@ public final class BlockUtils {
     public static boolean isMcMMOAnvil(BlockState blockState) {
         Material type = blockState.getType();
 
-        return type == Repair.repairAnvilMaterial || type == Repair.salvageAnvilMaterial;
+        return type == Repair.anvilMaterial || type == Salvage.anvilMaterial;
     }
 
     /**

src/main/java/com/gmail/nossr50/util/ChimaeraWing.java

@@ -66,7 +66,7 @@ public final class ChimaeraWing {
         long lastTeleport = mcMMOPlayer.getChimeraWingLastUse();
         int cooldown = Config.getInstance().getChimaeraCooldown();
 
-        if (cooldown > 0 ) {
+        if (cooldown > 0) {
             int timeRemaining = SkillUtils.calculateTimeLeft(lastTeleport * Misc.TIME_CONVERSION_FACTOR, cooldown, player);
 
             if (timeRemaining > 0) {
@@ -142,7 +142,7 @@ public final class ChimaeraWing {
         if (Config.getInstance().getChimaeraSoundEnabled()) {
             player.playSound(location, Sound.BAT_TAKEOFF, Misc.BAT_VOLUME, Misc.BAT_PITCH);
         }
-        
+
         player.sendMessage(LocaleLoader.getString("Item.ChimaeraWing.Pass"));
     }
 

src/main/java/com/gmail/nossr50/util/EventUtils.java

@@ -16,6 +16,7 @@ import com.gmail.nossr50.datatypes.player.McMMOPlayer;
 import com.gmail.nossr50.datatypes.player.PlayerProfile;
 import com.gmail.nossr50.datatypes.skills.AbilityType;
 import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.datatypes.skills.XPGainReason;
 import com.gmail.nossr50.events.experience.McMMOPlayerLevelChangeEvent;
 import com.gmail.nossr50.events.experience.McMMOPlayerLevelDownEvent;
 import com.gmail.nossr50.events.experience.McMMOPlayerLevelUpEvent;
@@ -52,8 +53,8 @@ public class EventUtils {
         return event;
     }
 
-    public static boolean handleLevelChangeEvent(Player player, SkillType skill, int levelsChanged, float xpRemoved, boolean isLevelUp) {
-        McMMOPlayerLevelChangeEvent event = isLevelUp ? new McMMOPlayerLevelUpEvent(player, skill, levelsChanged) : new McMMOPlayerLevelDownEvent(player, skill, levelsChanged);
+    public static boolean handleLevelChangeEvent(Player player, SkillType skill, int levelsChanged, float xpRemoved, boolean isLevelUp, XPGainReason xpGainReason) {
+        McMMOPlayerLevelChangeEvent event = isLevelUp ? new McMMOPlayerLevelUpEvent(player, skill, levelsChanged, xpGainReason) : new McMMOPlayerLevelDownEvent(player, skill, levelsChanged, xpGainReason);
         mcMMO.p.getServer().getPluginManager().callEvent(event);
 
         boolean isCancelled = event.isCancelled();
@@ -139,8 +140,8 @@ public class EventUtils {
         return !isCancelled;
     }
 
-    public static boolean handleXpGainEvent(Player player, SkillType skill, float xpGained) {
-        McMMOPlayerXpGainEvent event = new McMMOPlayerXpGainEvent(player, skill, xpGained);
+    public static boolean handleXpGainEvent(Player player, SkillType skill, float xpGained, XPGainReason xpGainReason) {
+        McMMOPlayerXpGainEvent event = new McMMOPlayerXpGainEvent(player, skill, xpGained, xpGainReason);
         mcMMO.p.getServer().getPluginManager().callEvent(event);
 
         boolean isCancelled = event.isCancelled();

src/main/java/com/gmail/nossr50/util/HardcoreManager.java

@@ -6,6 +6,7 @@ import com.gmail.nossr50.config.Config;
 import com.gmail.nossr50.datatypes.player.McMMOPlayer;
 import com.gmail.nossr50.datatypes.player.PlayerProfile;
 import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.datatypes.skills.XPGainReason;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.util.player.UserManager;
 
@@ -82,7 +83,7 @@ public final class HardcoreManager {
             totalLevelsStolen += levelsStolen;
 
             killerPlayer.addLevels(skillType, levelsStolen);
-            killerPlayer.beginUnsharedXpGain(skillType, xpStolen);
+            killerPlayer.beginUnsharedXpGain(skillType, xpStolen, XPGainReason.VAMPIRISM);
 
             victimProfile.modifySkill(skillType, victimSkillLevel - levelsStolen);
             victimProfile.removeXp(skillType, xpStolen);

src/main/java/com/gmail/nossr50/util/HolidayManager.java

@@ -342,7 +342,8 @@ public final class HolidayManager {
         return mcMMO.getHolidayManager().getDateRange(day.getTime(), start.getTime(), end.getTime());
     }
 
-    public void handleStatisticEvent(PlayerStatisticIncrementEvent event) {Player player = event.getPlayer();
+    public void handleStatisticEvent(PlayerStatisticIncrementEvent event) {
+        Player player = event.getPlayer();
         Statistic statistic = event.getStatistic();
         int newValue = event.getNewValue();
 
@@ -369,12 +370,12 @@ public final class HolidayManager {
         }
 
         if (newValue % modifier == 0) {
-            mcMMO.p.getHolidayManager().levelUpApril(player, FakeSkillType.getByStatistic(statistic));
+            mcMMO.getHolidayManager().levelUpApril(player, FakeSkillType.getByStatistic(statistic));
         }
     }
 
     public void levelUpApril(Player player, FakeSkillType fakeSkillType) {
-        int levelTotal = Misc.getRandom().nextInt(UserManager.getPlayer(player).getSkillLevel(SkillType.MINING)) + 1;
+        int levelTotal = Misc.getRandom().nextInt(1 + UserManager.getPlayer(player).getSkillLevel(SkillType.MINING)) + 1;
         player.playSound(player.getLocation(), Sound.LEVEL_UP, Misc.LEVELUP_VOLUME, Misc.LEVELUP_PITCH);
         player.sendMessage(ChatColor.YELLOW + StringUtils.getCapitalized(fakeSkillType.toString()) + " skill increased by 1. Total (" + levelTotal + ")");
         ParticleEffectUtils.fireworkParticleShower(player, ALL_COLORS.get(Misc.getRandom().nextInt(ALL_COLORS.size())));

src/main/java/com/gmail/nossr50/util/Misc.java

@@ -6,7 +6,6 @@ import java.util.Random;
 import org.bukkit.Location;
 import org.bukkit.Material;
 import org.bukkit.entity.Entity;
-import org.bukkit.entity.HumanEntity;
 import org.bukkit.entity.Item;
 import org.bukkit.entity.NPC;
 import org.bukkit.entity.Player;
@@ -51,7 +50,7 @@ public final class Misc {
     }
 
     public static boolean isNPCEntity(Entity entity) {
-        return (entity == null || entity.hasMetadata("NPC") || entity instanceof NPC || (mcMMO.isCombatTagEnabled() && entity instanceof HumanEntity && ((HumanEntity) entity).getName().contains("PvpLogger")) || entity.getClass().getName().equalsIgnoreCase("cofh.entity.PlayerFake"));
+        return (entity == null || entity.hasMetadata("NPC") || entity instanceof NPC || entity.getClass().getName().equalsIgnoreCase("cofh.entity.PlayerFake"));
     }
 
     /**

src/main/java/com/gmail/nossr50/util/Permissions.java

@@ -11,6 +11,8 @@ import org.bukkit.plugin.PluginManager;
 
 import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.commands.party.PartySubcommandType;
+import com.gmail.nossr50.datatypes.skills.ItemType;
+import com.gmail.nossr50.datatypes.skills.MaterialType;
 import com.gmail.nossr50.datatypes.skills.SecondaryAbility;
 import com.gmail.nossr50.datatypes.skills.SkillType;
 
@@ -162,18 +164,19 @@ public final class Permissions {
     public static boolean superBreaker(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.mining.superbreaker"); }
 
     /* REPAIR */
-    public static boolean repairArmor(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.repair.armorrepair"); }
-    public static boolean repairTools(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.repair.toolrepair"); }
-    public static boolean repairOtherItems(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.repair.otherrepair"); }
+    public static boolean repairItemType(Permissible permissible, ItemType repairItemType) { return permissible.hasPermission("mcmmo.ability.repair." + repairItemType.toString().toLowerCase() + "repair"); }
+    public static boolean repairMaterialType(Permissible permissible, MaterialType repairMaterialType) { return permissible.hasPermission("mcmmo.ability.repair." + repairMaterialType.toString().toLowerCase() + "repair"); }
 
-    public static boolean repairDiamond(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.repair.diamondrepair"); }
-    public static boolean repairGold(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.repair.goldrepair"); }
-    public static boolean repairIron(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.repair.ironrepair"); }
-    public static boolean repairLeather(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.repair.leatherrepair"); }
-    public static boolean repairOtherMaterials(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.repair.othermaterialrepair"); }
-    public static boolean repairString(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.repair.stringrepair"); }
-    public static boolean repairStone(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.repair.stonerepair"); }
-    public static boolean repairWood(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.repair.woodrepair"); }
+    /* SALVAGE */
+    public static boolean advancedSalvage(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.salvage.advancedsalvage"); }
+    public static boolean arcaneSalvage(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.salvage.arcanesalvage"); }
+
+    public static boolean salvageItemType(Permissible permissible, ItemType salvageItemType) { return permissible.hasPermission("mcmmo.ability.salvage." + salvageItemType.toString().toLowerCase() + "salvage"); }
+    public static boolean salvageMaterialType(Permissible permissible, MaterialType salvageMaterialType) { return permissible.hasPermission("mcmmo.ability.salvage." + salvageMaterialType.toString().toLowerCase() + "salvage"); }
+
+    /* SMELTING */
+    public static boolean fluxMining(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.smelting.fluxmining"); }
+    public static boolean fuelEfficiency(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.smelting.fuelefficiency"); }
 
     /* SWORDS */
     public static boolean serratedStrikes(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.swords.serratedstrikes"); }

src/main/java/com/gmail/nossr50/util/blockmeta/chunkmeta/HashChunkManager.java

@@ -29,7 +29,7 @@ public class HashChunkManager implements ChunkManager {
     public synchronized void closeAll() {
         for (UUID uid : regionFiles.keySet()) {
             HashMap<Long, McMMOSimpleRegionFile> worldRegions = regionFiles.get(uid);
-            for (Iterator<McMMOSimpleRegionFile> worldRegionIterator = worldRegions.values().iterator(); worldRegionIterator.hasNext();) {
+            for (Iterator<McMMOSimpleRegionFile> worldRegionIterator = worldRegions.values().iterator(); worldRegionIterator.hasNext(); ) {
                 McMMOSimpleRegionFile rf = worldRegionIterator.next();
                 if (rf != null) {
                     rf.close();

src/main/java/com/gmail/nossr50/util/commands/CommandRegistrationManager.java

@@ -43,6 +43,7 @@ import com.gmail.nossr50.commands.skills.FishingCommand;
 import com.gmail.nossr50.commands.skills.HerbalismCommand;
 import com.gmail.nossr50.commands.skills.MiningCommand;
 import com.gmail.nossr50.commands.skills.RepairCommand;
+import com.gmail.nossr50.commands.skills.SalvageCommand;
 import com.gmail.nossr50.commands.skills.SmeltingCommand;
 import com.gmail.nossr50.commands.skills.SwordsCommand;
 import com.gmail.nossr50.commands.skills.TamingCommand;
@@ -109,6 +110,10 @@ public final class CommandRegistrationManager {
                     command.setExecutor(new RepairCommand());
                     break;
 
+                case SALVAGE:
+                    command.setExecutor(new SalvageCommand());
+                    break;
+
                 case SMELTING:
                     command.setExecutor(new SmeltingCommand());
                     break;

src/main/java/com/gmail/nossr50/util/experience/FormulaManager.java

@@ -90,7 +90,7 @@ public class FormulaManager {
             experience -= experienceToNextLevel;
         }
 
-        return new int[]{newLevel, remainder};
+        return new int[]{ newLevel, remainder };
     }
 
     /**

src/main/java/com/gmail/nossr50/util/player/UserManager.java

@@ -47,7 +47,7 @@ public final class UserManager {
     }
 
     /**
-     * Save all users.
+     * Save all users ON THIS THREAD.
      */
     public static void saveAll() {
         Player[] onlinePlayers = mcMMO.p.getServer().getOnlinePlayers();
@@ -59,10 +59,12 @@ public final class UserManager {
     }
 
     public static Collection<McMMOPlayer> getPlayers() {
-        Collection<McMMOPlayer> playerCollection  = new ArrayList<McMMOPlayer>();
+        Collection<McMMOPlayer> playerCollection = new ArrayList<McMMOPlayer>();
 
         for (Player player : mcMMO.p.getServer().getOnlinePlayers()) {
-            playerCollection.add(getPlayer(player));
+            if (hasPlayerDataKey(player)) {
+                playerCollection.add(getPlayer(player));
+            }
         }
 
         return playerCollection;

src/main/java/com/gmail/nossr50/util/scoreboards/ScoreboardManager.java

@@ -7,7 +7,6 @@ import java.util.List;
 import java.util.Map;
 
 import org.bukkit.ChatColor;
-import org.bukkit.OfflinePlayer;
 import org.bukkit.entity.Player;
 import org.bukkit.scoreboard.DisplaySlot;
 import org.bukkit.scoreboard.Objective;
@@ -40,21 +39,21 @@ public class ScoreboardManager {
 
     static final String POWER_LEVEL = LocaleLoader.getString("Scoreboard.Misc.PowerLevel");
 
-    static final OfflinePlayer LABEL_POWER_LEVEL = getOfflinePlayer(POWER_LEVEL);
-    static final OfflinePlayer LABEL_LEVEL = getOfflinePlayer(LocaleLoader.getString("Scoreboard.Misc.Level"));
-    static final OfflinePlayer LABEL_CURRENT_XP = getOfflinePlayer(LocaleLoader.getString("Scoreboard.Misc.CurrentXP"));
-    static final OfflinePlayer LABEL_REMAINING_XP = getOfflinePlayer(LocaleLoader.getString("Scoreboard.Misc.RemainingXP"));
-    static final OfflinePlayer LABEL_ABILITY_COOLDOWN = getOfflinePlayer(LocaleLoader.getString("Scoreboard.Misc.Cooldown"));
-    static final OfflinePlayer LABEL_OVERALL = getOfflinePlayer(LocaleLoader.getString("Scoreboard.Misc.Overall"));
+    static final String LABEL_POWER_LEVEL = POWER_LEVEL;
+    static final String LABEL_LEVEL = LocaleLoader.getString("Scoreboard.Misc.Level");
+    static final String LABEL_CURRENT_XP = LocaleLoader.getString("Scoreboard.Misc.CurrentXP");
+    static final String LABEL_REMAINING_XP = LocaleLoader.getString("Scoreboard.Misc.RemainingXP");
+    static final String LABEL_ABILITY_COOLDOWN = LocaleLoader.getString("Scoreboard.Misc.Cooldown");
+    static final String LABEL_OVERALL = LocaleLoader.getString("Scoreboard.Misc.Overall");
 
-    static final Map<SkillType, OfflinePlayer>   skillLabels;
-    static final Map<AbilityType, OfflinePlayer> abilityLabelsColored;
-    static final Map<AbilityType, OfflinePlayer> abilityLabelsSkill;
+    static final Map<SkillType, String>   skillLabels;
+    static final Map<AbilityType, String> abilityLabelsColored;
+    static final Map<AbilityType, String> abilityLabelsSkill;
 
     static {
-        ImmutableMap.Builder<SkillType, OfflinePlayer> skillLabelBuilder = ImmutableMap.builder();
-        ImmutableMap.Builder<AbilityType, OfflinePlayer> abilityLabelBuilder = ImmutableMap.builder();
-        ImmutableMap.Builder<AbilityType, OfflinePlayer> abilityLabelSkillBuilder = ImmutableMap.builder();
+        ImmutableMap.Builder<SkillType, String> skillLabelBuilder = ImmutableMap.builder();
+        ImmutableMap.Builder<AbilityType, String> abilityLabelBuilder = ImmutableMap.builder();
+        ImmutableMap.Builder<AbilityType, String> abilityLabelSkillBuilder = ImmutableMap.builder();
 
         if (Config.getInstance().getScoreboardRainbows()) {
             // Everything but black, gray, gold
@@ -78,36 +77,38 @@ public class ScoreboardManager {
             int i = 0;
             for (SkillType type : SkillType.values()) {
                 // Include child skills
-                skillLabelBuilder.put(type, getOfflinePlayer(colors.get(i) + type.getName()));
+                skillLabelBuilder.put(type, getShortenedName(colors.get(i) + type.getName(), false));
 
                 if (type.getAbility() != null) {
-                    abilityLabelBuilder.put(type.getAbility(), getOfflinePlayer(colors.get(i) + type.getAbility().getName()));
+                    abilityLabelBuilder.put(type.getAbility(), getShortenedName(colors.get(i) + type.getAbility().getName()));
 
                     if (type == SkillType.MINING) {
-                        abilityLabelBuilder.put(AbilityType.BLAST_MINING, getOfflinePlayer(colors.get(i) + AbilityType.BLAST_MINING.getName()));
+                        abilityLabelBuilder.put(AbilityType.BLAST_MINING, getShortenedName(colors.get(i) + AbilityType.BLAST_MINING.getName()));
                     }
                 }
 
-                if (++i == colors.size()) i = 0;
+                if (++i == colors.size()) {
+                    i = 0;
+                }
             }
         }
         else {
             for (SkillType type : SkillType.values()) {
                 // Include child skills
-                skillLabelBuilder.put(type, getOfflinePlayer(ChatColor.GREEN + type.getName()));
+                skillLabelBuilder.put(type, getShortenedName(ChatColor.GREEN + type.getName()));
 
                 if (type.getAbility() != null) {
-                    abilityLabelBuilder.put(type.getAbility(), getOfflinePlayerDots(ChatColor.AQUA + type.getAbility().getName()));
+                    abilityLabelBuilder.put(type.getAbility(), getShortenedName(ChatColor.AQUA + type.getAbility().getName()));
 
                     if (type == SkillType.MINING) {
-                        abilityLabelBuilder.put(AbilityType.BLAST_MINING, getOfflinePlayerDots(ChatColor.AQUA + AbilityType.BLAST_MINING.getName()));
+                        abilityLabelBuilder.put(AbilityType.BLAST_MINING, getShortenedName(ChatColor.AQUA + AbilityType.BLAST_MINING.getName()));
                     }
                 }
             }
         }
 
         for (AbilityType type : AbilityType.values()) {
-            abilityLabelSkillBuilder.put(type, getOfflinePlayerDots((type == AbilityType.BLAST_MINING ? ChatColor.BLUE : ChatColor.AQUA) + type.getName()));
+            abilityLabelSkillBuilder.put(type, getShortenedName((type == AbilityType.BLAST_MINING ? ChatColor.BLUE : ChatColor.AQUA) + type.getName()));
         }
 
         skillLabels = skillLabelBuilder.build();
@@ -117,22 +118,6 @@ public class ScoreboardManager {
 
     private static List<String> dirtyPowerLevels = new ArrayList<String>();
 
-    private static OfflinePlayer getOfflinePlayer(String name) {
-        return getOfflinePlayer(name, false);
-    }
-
-    private static OfflinePlayer getOfflinePlayerDots(String name) {
-        return getOfflinePlayer(name, true);
-    }
-
-    private static OfflinePlayer getOfflinePlayer(String name, boolean useDots) {
-        if (name.length() > 16) {
-            name = useDots ? name.substring(0, 14) + ".." : name.substring(0, 16);
-        }
-
-        return mcMMO.p.getServer().getOfflinePlayer(name);
-    }
-
     public enum SidebarType {
         NONE,
         SKILL_BOARD,
@@ -142,6 +127,18 @@ public class ScoreboardManager {
         TOP_BOARD;
     }
 
+    private static String getShortenedName(String name) {
+        return getShortenedName(name, true);
+    }
+
+    private static String getShortenedName(String name, boolean useDots) {
+        if (name.length() > 16) {
+            name = useDots ? name.substring(0, 14) + ".." : name.substring(0, 16);
+        }
+
+        return name;
+    }
+
     // **** Listener call-ins **** //
 
     // Called by PlayerJoinEvent listener
@@ -338,7 +335,7 @@ public class ScoreboardManager {
             Player player = mcMMOPlayer.getPlayer();
             int power = mcMMOPlayer.getPowerLevel();
 
-            mainObjective.getScore(player).setScore(power);
+            mainObjective.getScore(playerName).setScore(power);
 
             for (ScoreboardWrapper wrapper : PLAYER_SCOREBOARDS.values()) {
                 wrapper.updatePowerLevel(player, power);
@@ -351,7 +348,7 @@ public class ScoreboardManager {
 
     /**
      * Gets or creates the power level objective on the main scoreboard.
-     * <p>
+     * <p/>
      * If power levels are disabled, the objective is deleted and null is
      * returned.
      *

src/main/java/com/gmail/nossr50/util/scoreboards/ScoreboardWrapper.java

@@ -28,7 +28,6 @@ import com.gmail.nossr50.util.scoreboards.ScoreboardManager.SidebarType;
 import org.apache.commons.lang.Validate;
 
 public class ScoreboardWrapper {
-
     // Initialization variables
     public final String playerName;
     private final Scoreboard scoreboard;
@@ -59,7 +58,7 @@ public class ScoreboardWrapper {
             powerObjective.setDisplaySlot(DisplaySlot.BELOW_NAME);
 
             for (McMMOPlayer mcMMOPlayer : UserManager.getPlayers()) {
-                powerObjective.getScore(mcMMOPlayer.getPlayer()).setScore(mcMMOPlayer.getPowerLevel());
+                powerObjective.getScore(mcMMOPlayer.getProfile().getPlayerName()).setScore(mcMMOPlayer.getPowerLevel());
             }
         }
     }
@@ -69,6 +68,7 @@ public class ScoreboardWrapper {
     }
 
     public BukkitTask updateTask = null;
+
     private class ScoreboardQuickUpdate extends BukkitRunnable {
         @Override
         public void run() {
@@ -78,6 +78,7 @@ public class ScoreboardWrapper {
     }
 
     public BukkitTask revertTask = null;
+
     private class ScoreboardChangeTask extends BukkitRunnable {
         @Override
         public void run() {
@@ -87,6 +88,7 @@ public class ScoreboardWrapper {
     }
 
     public BukkitTask cooldownTask = null;
+
     private class ScoreboardCooldownTask extends BukkitRunnable {
         @Override
         public void run() {
@@ -121,7 +123,8 @@ public class ScoreboardWrapper {
             try {
                 cooldownTask.cancel();
             }
-            catch (Throwable ignored) {}
+            catch (Throwable ignored) {
+            }
 
             cooldownTask = null;
         }
@@ -274,7 +277,7 @@ public class ScoreboardWrapper {
         targetProfile = null;
         leaderboardPage = -1;
 
-        loadObjective(ScoreboardManager.skillLabels.get(skill).getName());
+        loadObjective(ScoreboardManager.skillLabels.get(skill));
     }
 
     public void setTypeSelfStats() {
@@ -355,7 +358,7 @@ public class ScoreboardWrapper {
 
         int endPosition = page * 15;
         int startPosition = endPosition - 14;
-        loadObjective(String.format("%s (%2d - %2d)", ScoreboardManager.skillLabels.get(skill).getName(), startPosition, endPosition));
+        loadObjective(String.format("%s (%2d - %2d)", ScoreboardManager.skillLabels.get(skill), startPosition, endPosition));
     }
 
     // Setup for after a board type change
@@ -381,7 +384,8 @@ public class ScoreboardWrapper {
         try {
             updateTask.cancel();
         }
-        catch (Throwable ignored) {} // catch NullPointerException and IllegalStateException and any Error; don't care
+        catch (Throwable ignored) {
+        } // catch NullPointerException and IllegalStateException and any Error; don't care
 
         updateTask = null;
 
@@ -399,124 +403,123 @@ public class ScoreboardWrapper {
         McMMOPlayer mcMMOPlayer = UserManager.getPlayer(player);
 
         switch (sidebarType) {
-        case NONE:
-            break;
+            case NONE:
+                break;
 
-        case SKILL_BOARD:
-            Validate.notNull(targetSkill);
+            case SKILL_BOARD:
+                Validate.notNull(targetSkill);
 
-            if (!targetSkill.isChildSkill()) {
-                int currentXP = mcMMOPlayer.getSkillXpLevel(targetSkill);
+                if (!targetSkill.isChildSkill()) {
+                    int currentXP = mcMMOPlayer.getSkillXpLevel(targetSkill);
 
-                sidebarObjective.getScore(ScoreboardManager.LABEL_CURRENT_XP).setScore(currentXP);
-                sidebarObjective.getScore(ScoreboardManager.LABEL_REMAINING_XP).setScore(mcMMOPlayer.getXpToLevel(targetSkill) - currentXP);
-            }
-            else {
-                for (SkillType parentSkill : FamilyTree.getParents(targetSkill)) {
-                    sidebarObjective.getScore(ScoreboardManager.skillLabels.get(parentSkill)).setScore(mcMMOPlayer.getSkillLevel(parentSkill));
-                }
-            }
-
-            sidebarObjective.getScore(ScoreboardManager.LABEL_LEVEL).setScore(mcMMOPlayer.getSkillLevel(targetSkill));
-
-            if (targetSkill.getAbility() != null) {
-                boolean stopUpdating;
-
-                if (targetSkill == SkillType.MINING) {
-                    // Special-Case: Mining has two abilities, both with cooldowns
-                    Score cooldownSB = sidebarObjective.getScore(ScoreboardManager.abilityLabelsSkill.get(AbilityType.SUPER_BREAKER));
-                    Score cooldownBM = sidebarObjective.getScore(ScoreboardManager.abilityLabelsSkill.get(AbilityType.BLAST_MINING));
-                    int secondsSB = Math.max(mcMMOPlayer.calculateTimeRemaining(AbilityType.SUPER_BREAKER), 0);
-                    int secondsBM = Math.max(mcMMOPlayer.calculateTimeRemaining(AbilityType.BLAST_MINING), 0);
-
-                    cooldownSB.setScore(secondsSB);
-                    cooldownBM.setScore(secondsBM);
-
-                    stopUpdating = (secondsSB == 0 && secondsBM == 0);
+                    sidebarObjective.getScore(ScoreboardManager.LABEL_CURRENT_XP).setScore(currentXP);
+                    sidebarObjective.getScore(ScoreboardManager.LABEL_REMAINING_XP).setScore(mcMMOPlayer.getXpToLevel(targetSkill) - currentXP);
                 }
                 else {
-                    AbilityType ability = targetSkill.getAbility();
-                    Score cooldown = sidebarObjective.getScore(ScoreboardManager.abilityLabelsSkill.get(ability));
+                    for (SkillType parentSkill : FamilyTree.getParents(targetSkill)) {
+                        sidebarObjective.getScore(ScoreboardManager.skillLabels.get(parentSkill)).setScore(mcMMOPlayer.getSkillLevel(parentSkill));
+                    }
+                }
+
+                sidebarObjective.getScore(ScoreboardManager.LABEL_LEVEL).setScore(mcMMOPlayer.getSkillLevel(targetSkill));
+
+                if (targetSkill.getAbility() != null) {
+                    boolean stopUpdating;
+
+                    if (targetSkill == SkillType.MINING) {
+                        // Special-Case: Mining has two abilities, both with cooldowns
+                        Score cooldownSB = sidebarObjective.getScore(ScoreboardManager.abilityLabelsSkill.get(AbilityType.SUPER_BREAKER));
+                        Score cooldownBM = sidebarObjective.getScore(ScoreboardManager.abilityLabelsSkill.get(AbilityType.BLAST_MINING));
+                        int secondsSB = Math.max(mcMMOPlayer.calculateTimeRemaining(AbilityType.SUPER_BREAKER), 0);
+                        int secondsBM = Math.max(mcMMOPlayer.calculateTimeRemaining(AbilityType.BLAST_MINING), 0);
+
+                        cooldownSB.setScore(secondsSB);
+                        cooldownBM.setScore(secondsBM);
+
+                        stopUpdating = (secondsSB == 0 && secondsBM == 0);
+                    }
+                    else {
+                        AbilityType ability = targetSkill.getAbility();
+                        Score cooldown = sidebarObjective.getScore(ScoreboardManager.abilityLabelsSkill.get(ability));
+                        int seconds = Math.max(mcMMOPlayer.calculateTimeRemaining(ability), 0);
+
+                        cooldown.setScore(seconds);
+
+                        stopUpdating = seconds == 0;
+                    }
+
+                    if (stopUpdating) {
+                        stopCooldownUpdating();
+                    }
+                    else {
+                        startCooldownUpdating();
+                    }
+                }
+                break;
+
+            case COOLDOWNS_BOARD:
+                boolean anyCooldownsActive = false;
+
+                for (AbilityType ability : AbilityType.values()) {
                     int seconds = Math.max(mcMMOPlayer.calculateTimeRemaining(ability), 0);
 
-                    cooldown.setScore(seconds);
+                    if (seconds != 0) {
+                        anyCooldownsActive = true;
+                    }
 
-                    stopUpdating = seconds == 0;
+                    sidebarObjective.getScore(ScoreboardManager.abilityLabelsColored.get(ability)).setScore(seconds);
                 }
 
-                if (stopUpdating) {
-                    stopCooldownUpdating();
-                }
-                else {
+                if (anyCooldownsActive) {
                     startCooldownUpdating();
                 }
-            }
-            break;
+                else {
+                    stopCooldownUpdating();
+                }
+                break;
 
-        case COOLDOWNS_BOARD:
-            boolean anyCooldownsActive = false;
+            case STATS_BOARD:
+                // Select the profile to read from
+                PlayerProfile newProfile;
 
-            for (AbilityType ability : AbilityType.values()) {
-                int seconds = Math.max(mcMMOPlayer.calculateTimeRemaining(ability), 0);
-
-                if (seconds != 0) {
-                    anyCooldownsActive = true;
+                if (targetProfile != null) {
+                    newProfile = targetProfile; // offline
+                }
+                else if (targetPlayer == null) {
+                    newProfile = mcMMOPlayer.getProfile(); // self
+                }
+                else {
+                    newProfile = UserManager.getPlayer(targetPlayer).getProfile(); // online
                 }
 
-                sidebarObjective.getScore(ScoreboardManager.abilityLabelsColored.get(ability)).setScore(seconds);
-            }
+                // Calculate power level here
+                int powerLevel = 0;
+                for (SkillType skill : SkillType.NON_CHILD_SKILLS) { // Don't include child skills, makes the list too long
+                    int level = newProfile.getSkillLevel(skill);
 
-            if (anyCooldownsActive) {
-                startCooldownUpdating();
-            }
-            else {
-                stopCooldownUpdating();
-            }
-            break;
-
-        case STATS_BOARD:
-            // Select the profile to read from
-            PlayerProfile newProfile;
-
-            if (targetProfile != null) {
-                newProfile = targetProfile; // offline
-            }
-            else if (targetPlayer == null) {
-                newProfile = mcMMOPlayer.getProfile(); // self
-            }
-            else {
-                newProfile = UserManager.getPlayer(targetPlayer).getProfile(); // online
-            }
-
-            // Calculate power level here
-            int powerLevel = 0;
-            for (SkillType skill : SkillType.values()) { // Include child skills, but not in power level
-                int level = newProfile.getSkillLevel(skill);
-
-                if (!skill.isChildSkill())
                     powerLevel += level;
 
-                // TODO: Verify that this is what we want - calculated in power level but not displayed
-                if (!skill.getPermissions(player)) {
-                    continue;
+                    // TODO: Verify that this is what we want - calculated in power level but not displayed
+                    if (!skill.getPermissions(player)) {
+                        continue;
+                    }
+
+                    sidebarObjective.getScore(ScoreboardManager.skillLabels.get(skill)).setScore(level);
                 }
 
-                sidebarObjective.getScore(ScoreboardManager.skillLabels.get(skill)).setScore(level);
-            }
+                sidebarObjective.getScore(ScoreboardManager.LABEL_POWER_LEVEL).setScore(powerLevel);
+                break;
 
-            sidebarObjective.getScore(ScoreboardManager.LABEL_POWER_LEVEL).setScore(powerLevel);
-            break;
-
-        case RANK_BOARD:
-        case TOP_BOARD:
+            case RANK_BOARD:
+            case TOP_BOARD:
             /*
              * @see #acceptRankData(Map<SkillType, Integer> rank)
              * @see #acceptLeaderboardData(List<PlayerStat> stats)
              */
-            break;
+                break;
 
-        default:
-            break;
+            default:
+                break;
         }
     }
 
@@ -551,11 +554,11 @@ public class ScoreboardWrapper {
                 name = ChatColor.GOLD + "--You--";
             }
 
-            sidebarObjective.getScore(mcMMO.p.getServer().getOfflinePlayer(name)).setScore(stat.statVal);
+            sidebarObjective.getScore(name).setScore(stat.statVal);
         }
     }
 
     public void updatePowerLevel(Player player, int newPowerLevel) {
-        powerObjective.getScore(player).setScore(newPowerLevel);
+        powerObjective.getScore(player.getName()).setScore(newPowerLevel);
     }
 }

src/main/java/com/gmail/nossr50/util/skills/CombatUtils.java

@@ -23,6 +23,7 @@ import com.gmail.nossr50.config.Config;
 import com.gmail.nossr50.config.experience.ExperienceConfig;
 import com.gmail.nossr50.datatypes.player.McMMOPlayer;
 import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.datatypes.skills.XPGainReason;
 import com.gmail.nossr50.events.fake.FakeEntityDamageByEntityEvent;
 import com.gmail.nossr50.events.fake.FakeEntityDamageEvent;
 import com.gmail.nossr50.locale.LocaleLoader;
@@ -283,7 +284,7 @@ public final class CombatUtils {
             McMMOPlayer mcMMOPlayer = UserManager.getPlayer(player);
             AcrobaticsManager acrobaticsManager = mcMMOPlayer.getAcrobaticsManager();
 
-            if (acrobaticsManager.canDodge(damager)) {
+            if (acrobaticsManager.canDodge(target)) {
                 event.setDamage(acrobaticsManager.dodgeCheck(event.getDamage()));
             }
 
@@ -399,12 +400,14 @@ public final class CombatUtils {
      */
     private static void startGainXp(McMMOPlayer mcMMOPlayer, LivingEntity target, SkillType skillType, double multiplier) {
         double baseXP = 0;
+        XPGainReason xpGainReason;
 
         if (target instanceof Player) {
             if (!ExperienceConfig.getInstance().getExperienceGainsPlayerVersusPlayerEnabled()) {
                 return;
             }
 
+            xpGainReason = XPGainReason.PVP;
             Player defender = (Player) target;
 
             if (defender.isOnline() && SkillUtils.cooldownExpired(mcMMOPlayer.getRespawnATS(), Misc.PLAYER_RESPAWN_COOLDOWN_SECONDS)) {
@@ -473,13 +476,15 @@ public final class CombatUtils {
                 baseXP *= ExperienceConfig.getInstance().getSpawnedMobXpMultiplier();
             }
 
+            xpGainReason = XPGainReason.PVE;
+
             baseXP *= 10;
         }
 
         baseXP *= multiplier;
 
         if (baseXP != 0) {
-            new AwardCombatXpTask(mcMMOPlayer, skillType, baseXP, target).runTaskLater(mcMMO.p, 0);
+            new AwardCombatXpTask(mcMMOPlayer, skillType, baseXP, target, xpGainReason).runTaskLater(mcMMO.p, 0);
         }
     }
 
@@ -502,6 +507,11 @@ public final class CombatUtils {
                 return false;
             }
 
+            // Vanished players should not be able to get hit by AoE effects
+            if (!player.canSee(defender)) {
+                return false;
+            }
+
             // It may seem a bit redundant but we need a check here to prevent bleed from being applied in applyAbilityAoE()
             if (callFakeDamageEvent(player, entity, 1.0) == 0) {
                 return false;

src/main/java/com/gmail/nossr50/util/skills/SkillUtils.java

@@ -8,7 +8,11 @@ import org.bukkit.Material;
 import org.bukkit.enchantments.Enchantment;
 import org.bukkit.entity.Player;
 import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.Recipe;
+import org.bukkit.inventory.ShapedRecipe;
+import org.bukkit.inventory.ShapelessRecipe;
 import org.bukkit.inventory.meta.ItemMeta;
+import org.bukkit.material.MaterialData;
 import org.bukkit.potion.PotionEffect;
 import org.bukkit.potion.PotionEffectType;
 
@@ -219,4 +223,68 @@ public class SkillUtils {
 
         return false;
     }
+
+    protected static Material getRepairAndSalvageItem(ItemStack inHand) {
+        if (ItemUtils.isDiamondTool(inHand) || ItemUtils.isDiamondArmor(inHand)) {
+            return Material.DIAMOND;
+        }
+        else if (ItemUtils.isGoldTool(inHand) || ItemUtils.isGoldArmor(inHand)) {
+            return Material.GOLD_INGOT;
+        }
+        else if (ItemUtils.isIronTool(inHand) || ItemUtils.isIronArmor(inHand)) {
+            return Material.IRON_INGOT;
+        }
+        else if (ItemUtils.isStoneTool(inHand)) {
+            return Material.COBBLESTONE;
+        }
+        else if (ItemUtils.isWoodTool(inHand)) {
+            return Material.WOOD;
+        }
+        else if (ItemUtils.isLeatherArmor(inHand)) {
+            return Material.LEATHER;
+        }
+        else if (ItemUtils.isStringTool(inHand)) {
+            return Material.STRING;
+        }
+        else {
+            return null;
+        }
+    }
+
+    public static int getRepairAndSalvageQuantities(ItemStack item) {
+        return getRepairAndSalvageQuantities(item, getRepairAndSalvageItem(item), (byte) -1);
+    }
+
+    public static int getRepairAndSalvageQuantities(ItemStack item, Material repairMaterial, byte repairMetadata) {
+        // Workaround for Bukkit bug where damaged items would not return any recipes
+        item = item.clone();
+        item.setDurability((short) 0);
+
+        int quantity = 0;
+        MaterialData repairData = repairMaterial != null ? new MaterialData(repairMaterial, repairMetadata) : null;
+        List<Recipe> recipes = mcMMO.p.getServer().getRecipesFor(item);
+
+        if (recipes.isEmpty()) {
+            return quantity;
+        }
+
+        Recipe recipe = recipes.get(0);
+
+        if (recipe instanceof ShapelessRecipe) {
+            for (ItemStack ingredient : ((ShapelessRecipe) recipe).getIngredientList()) {
+                if (ingredient != null && (repairMaterial == null || ingredient.getType() == repairMaterial) && (repairMetadata == -1 || ingredient.getData().equals(repairData))) {
+                    quantity += ingredient.getAmount();
+                }
+            }
+        }
+        else if (recipe instanceof ShapedRecipe) {
+            for (ItemStack ingredient : ((ShapedRecipe) recipe).getIngredientMap().values()) {
+                if (ingredient != null && (repairMaterial == null || ingredient.getType() == repairMaterial) && (repairMetadata == -1 || ingredient.getData().equals(repairData))) {
+                    quantity += ingredient.getAmount();
+                }
+            }
+        }
+
+        return quantity;
+    }
 }

src/main/resources/advanced.yml

@@ -314,10 +314,6 @@ Skills:
             ChanceMax: 100.0
             MaxBonusLevel: 1000
 
-        Salvage:
-            # UnlockLevel: Level when Salvage become available
-            UnlockLevel: 600
-
         ArcaneForging:
             May_Lose_Enchants: true
             Rank_Levels:
@@ -349,6 +345,55 @@ Skills:
                 Rank_7: 15.0
                 Rank_8: 10.0
     #
+    #  Settings for Salvage
+    ###
+    Salvage:
+        # MaxPercentage: Maximum percentage of materials to be returned when Salvaging
+        # MaxPercentageLevel: On this level, the Salvage percentage will be <MaxPercentage>
+        MaxPercentage: 100.0
+        MaxPercentageLevel: 1000
+
+        # AdvancedSalvage_UnlockLevel: The level at which Advance Salvage become available
+        AdvancedSalvage:
+            UnlockLevel: 350
+
+        ArcaneSalvage:
+            # EnchantLossEnabled: When salvaging enchanted items, the enchants may be lost
+            # EnchantDowngradeEnabled: When salvaging enchanted items, the enchants may be downgraded
+            EnchantLossEnabled: true
+            EnchantDowngradeEnabled: true
+            Rank_Levels:
+                Rank_1: 125
+                Rank_2: 250
+                Rank_3: 375
+                Rank_4: 500
+                Rank_5: 625
+                Rank_6: 750
+                Rank_7: 875
+                Rank_8: 1000
+
+            # ExtractFullEnchant: Chance to extract the full enchant at each ArcaneSalvage rank
+            ExtractFullEnchant:
+                Rank_1: 2.5
+                Rank_2: 5.0
+                Rank_3: 7.5
+                Rank_4: 10.0
+                Rank_5: 12.5
+                Rank_6: 17.5
+                Rank_7: 25.0
+                Rank_8: 32.5
+
+            # ExtractPartialEnchant: Chance to extract the partial enchant at each ArcaneSalvage rank
+            ExtractPartialEnchant:
+                Rank_1: 2.0
+                Rank_2: 2.5
+                Rank_3: 5.0
+                Rank_4: 7.5
+                Rank_5: 10.0
+                Rank_6: 12.5
+                Rank_7: 15.0
+                Rank_8: 17.5
+    #
     #  Settings for Smelting
     ###
     Smelting: