Fix casing

People will complain if we don’t

Changelog.txt

@@ -7,6 +7,58 @@ 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
+ + Added options to tools.yml and armor.yml config files to set a pretty repair material name
+ + Added full support for repairables in tools.yml and armor.yml config files
+ + Added new API class SkillAPI used to get a list of valid skill names
+ = Fixed bug where pistons would mess with the block tracking
+ = 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
+ = Fixed bug where Alchemy would not fire BrewEvents
+ = Fixed bug with setting custom names and lore in treasures config
+ = Fixed bug which would cause a NullPointerException with getFlowerAndGrassXp()
+ = Fixed bug which could cause and SQLException regarding the connection property 'maxReconnects'.
+ = Fixed bug where falling blocks were incorrectly tracked
+ = Fixed bug where items would get deleted when in Berserk with a full inventory
+ = Fixed bug where the console would not correctly show party chat colors
+ = Fixed bug where party chat was using non thread safe methods
+ = Fixed bug where Blast Mining unlock levels could be to high in certain occasions
+ = Fixed bug where Blast Minings ability "Demolition Expert" would not work
+ ! Changed SecondaryAbilityEvent to implement Cancellable and it now gets fired for damage related secondary abilities
+ ! Changed the way mcMMO handles bonus damage, updated for the new damage event API
+ ! 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.
+ ! Changed behavior of the Blast Mining ability "Demolition Expert"; now only decreases damage for the ability user
+ ! Updated for new getOnlinePlayers() behavior
+ - 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
+ + Added Acacia and Dark Oak to Woodcutting blocks
+ + Added Salmon, Clownfish, and Pufferfish to Fishing XP
+ + Added new flowers and grasses to Herbalism XP
+ + Added option to config.yml which allows players to always catch fish, even when a treasure is found
+ + Added option to config.yml to override vanilla Minecraft treasures
+ ! Fishing XP now depends on the type of fish.
+ ! Woodcutting XP in experience.yml and Woodcutting double drops in config.yml now use the tree species names. Oak is now Generic, and Spruce is now Redwood.
+ ! Red_Rose was replaced by Poppy, and so the key in experience.yml has been updated accordingly.
+ - Removed deprecated permission nodes
+ - Removed "Treasure found!" message
+
 Version 1.4.08
  + Added a new skill; Alchemy. Special thanks to EasyMFnE for creating this!
  + Added SecondaryAbilityType enum, and new SecondaryAbilityWeightedActivationCheckEvent, fired when a secondary ability checkes its activation chances

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

extras/mods/1.7.x/twilightforest.armor.yml

@@ -0,0 +1,132 @@
+# Config created by joulesbeef
+# Created For twilightforest-2.2.3
+#
+#
+#  Settings for Boots
+###
+Boots:
+    # Ironwood
+    TWILIGHTFOREST_ITEM_IRONWOODBOOTS:
+        Repairable: true
+        Repair_Material: TWILIGHTFOREST_ITEM_IRONWOODINGOT
+        Repair_Material_Data_Value: 0
+        Repair_Material_Quantity: 2
+        Durability: 500
+    # Fiery
+    TWILIGHTFOREST_ITEM_FIERYBOOTS:
+        Repairable: true
+        Repair_Material: TWILIGHTFOREST_ITEM_FIERYINGOT
+        Repair_Material_Data_Value: 0
+        Repair_Material_Quantity: 2
+        Durability: 500
+    # Stealeaf
+    TWILIGHTFOREST_ITEM_STEELEAFBOOTS:
+        Repairable: true
+        Repair_Material: TWILIGHTFOREST_ITEM_STEELEAFINGOT
+        Repair_Material_Data_Value: 0
+        Repair_Material_Quantity: 2
+        Durability: 500
+    # Knightmetal
+    TWILIGHTFOREST_ITEM_KNIGHTLYBOOTS:
+        Repairable: true
+        Repair_Material: TWILIGHTFOREST_ITEM_KNIGHTMETAL
+        Repair_Material_Data_Value: 0
+        Repair_Material_Quantity: 2
+        Durability: 500
+
+#
+#  Settings for Chestplates
+###
+Chestplates:
+    # Ironwood
+    TWILIGHTFOREST_ITEM_IRONWOODPLATE:
+        Repairable: true
+        Repair_Material: TWILIGHTFOREST_ITEM_IRONWOODINGOT
+        Repair_Material_Data_Value: 0
+        Repair_Material_Quantity: 2
+        Durability: 500
+    # Fiery
+    TWILIGHTFOREST_ITEM_FIERYPLATE:
+        Repairable: true
+        Repair_Material: TWILIGHTFOREST_ITEM_FIERYINGOT
+        Repair_Material_Data_Value: 0
+        Repair_Material_Quantity: 2
+        Durability: 500
+    # Stealeaf
+    TWILIGHTFOREST_ITEM_STEELEAFPLATE:
+        Repairable: true
+        Repair_Material: TWILIGHTFOREST_ITEM_STEELEAFINGOT
+        Repair_Material_Data_Value: 0
+        Repair_Material_Quantity: 2
+        Durability: 500
+    # Knightmetal
+    TWILIGHTFOREST_ITEM_KNIGHTLYPLATE:
+        Repairable: true
+        Repair_Material: TWILIGHTFOREST_ITEM_KNIGHTMETAL
+        Repair_Material_Data_Value: 0
+        Repair_Material_Quantity: 2
+        Durability: 500
+
+#
+#  Settings for Helmets
+###
+Helmets:
+    # Ironwood
+    TWILIGHTFOREST_ITEM_IRONWOODHELM:
+        Repairable: true
+        Repair_Material: TWILIGHTFOREST_ITEM_IRONWOODINGOT
+        Repair_Material_Data_Value: 0
+        Repair_Material_Quantity: 2
+        Durability: 500
+    # Fiery
+    TWILIGHTFOREST_ITEM_FIERYHELM:
+        Repairable: true
+        Repair_Material: TWILIGHTFOREST_ITEM_FIERYINGOT
+        Repair_Material_Data_Value: 0
+        Repair_Material_Quantity: 2
+        Durability: 500
+    # Stealeaf
+    TWILIGHTFOREST_ITEM_STEELEAFHELM:
+        Repairable: true
+        Repair_Material: TWILIGHTFOREST_ITEM_STEELEAFINGOT
+        Repair_Material_Data_Value: 0
+        Repair_Material_Quantity: 2
+        Durability: 500
+    # Knightmetal
+    TWILIGHTFOREST_ITEM_KNIGHTLYHELM:
+        Repairable: true
+        Repair_Material: TWILIGHTFOREST_ITEM_KNIGHTMETAL
+        Repair_Material_Data_Value: 0
+        Repair_Material_Quantity: 2
+        Durability: 50
+#  Settings for Leggings
+###
+Leggings:
+    # Ironwood
+    TWILIGHTFOREST_ITEM_IRONWOODLEGS:
+        Repairable: true
+        Repair_Material: TWILIGHTFOREST_ITEM_IRONWOODINGOT
+        Repair_Material_Data_Value: 0
+        Repair_Material_Quantity: 2
+        Durability: 500
+    # Fiery
+    TWILIGHTFOREST_ITEM_FIERYLEGS:
+        Repairable: true
+        Repair_Material: TWILIGHTFOREST_ITEM_FIERYINGOT
+        Repair_Material_Data_Value: 0
+        Repair_Material_Quantity: 2
+        Durability: 500
+    # Stealeaf
+    TWILIGHTFOREST_ITEM_STEELEAFLEGS:
+        Repairable: true
+        Repair_Material: TWILIGHTFOREST_ITEM_STEELEAFINGOT
+        Repair_Material_Data_Value: 0
+        Repair_Material_Quantity: 2
+        Durability: 500
+    # Knightmetal
+    TWILIGHTFOREST_ITEM_KNIGHTLYLEGS:
+        Repairable: true
+        Repair_Material: TWILIGHTFOREST_ITEM_KNIGHTMETAL
+        Repair_Material_Data_Value: 0
+        Repair_Material_Quantity: 2
+        Durability: 500

extras/mods/1.7.x/twilightforest.blocks.yml

@@ -0,0 +1,116 @@
+# Config created by joulesbeef
+# Created For twilightforest-2.2.3
+#
+#
+#  Settings for Custom Herbalism Blocks
+###
+Herbalism:
+    # Mushgloom
+    TWILIGHTFOREST_TILE_TFLOG|9:
+        XP_Gain: 150
+        Double_Drops_Enabled: true
+    # Torchberry Plant
+    TWILIGHTFOREST_TILE_TFLOG|13:
+        XP_Gain: 20
+        Double_Drops_Enabled: true
+    # Mayapple
+    TWILIGHTFOREST_TILE_TFLOG|4:
+        XP_Gain: 30
+        Double_Drops_Enabled: true
+    # Fiddlehead
+    TWILIGHTFOREST_TILE_TFLOG|8:
+        XP_Gain: 35
+        Double_Drops_Enabled: true
+
+
+#
+#  Settings for Custom Mining Blocks
+###
+Mining:
+    # Mazestone
+    TWILIGHTFOREST_TILE_TFMAZESTONE|0:
+        XP_Gain: 250
+        Double_Drops_Enabled: true
+        Is_Ore: false
+    TWILIGHTFOREST_TILE_TFMAZESTONE|1:
+        XP_Gain: 250
+        Double_Drops_Enabled: true
+        Is_Ore: false
+    TWILIGHTFOREST_TILE_TFMAZESTONE|2:
+        XP_Gain: 250
+        Double_Drops_Enabled: true
+        Is_Ore: false
+    TWILIGHTFOREST_TILE_TFMAZESTONE|3:
+        XP_Gain: 250
+        Double_Drops_Enabled: true
+        Is_Ore: false
+    TWILIGHTFOREST_TILE_TFMAZESTONE|4:
+        XP_Gain: 250
+        Double_Drops_Enabled: true
+        Is_Ore: false
+    TWILIGHTFOREST_TILE_TFMAZESTONE|5:
+        XP_Gain: 250
+        Double_Drops_Enabled: true
+        Is_Ore: false
+    TWILIGHTFOREST_TILE_TFMAZESTONE|6:
+        XP_Gain: 250
+        Double_Drops_Enabled: true
+        Is_Ore: false
+    TWILIGHTFOREST_TILE_TFMAZESTONE|7:
+        XP_Gain: 250
+        Double_Drops_Enabled: true
+        Is_Ore: false
+        
+#
+#  Settings for Custom Woodcutting Blocks
+###
+Woodcutting:
+    # Twilight Oak
+    TWILIGHTFOREST_TILE_TFLOG|0:
+        XP_Gain: 70
+        Double_Drops_Enabled: true
+        Is_Log: true
+    # Canopy
+    TWILIGHTFOREST_TILE_TFLOG|1:
+        XP_Gain: 80
+        Double_Drops_Enabled: true
+        Is_Log: true
+    # Mangrove
+    TWILIGHTFOREST_TILE_TFLOG|2:
+        XP_Gain: 90
+        Double_Drops_Enabled: true
+        Is_Log: true
+    # Darkwood
+    TWILIGHTFOREST_TILE_TFLOG|3:
+        XP_Gain: 100
+        Double_Drops_Enabled: true
+        Is_Log: true
+    # Roots
+    TWILIGHTFOREST_TILE_TFROOTS|0:
+        XP_Gain: 10
+        Double_Drops_Enabled: true
+        Is_Log: false
+    TWILIGHTFOREST_TILE_TFROOTS|1:
+        XP_Gain: 10
+        Double_Drops_Enabled: true
+        Is_Log: false
+    # Timewood
+    TWILIGHTFOREST_TILE_TFMAGICLOG|0:
+        XP_Gain: 1000
+        Double_Drops_Enabled: true
+        Is_Log: true
+    # Transwood
+    TWILIGHTFOREST_TILE_TFMAGICLOG|1:
+        XP_Gain: 1000
+        Double_Drops_Enabled: true
+        Is_Log: true
+    # Minewood
+    TWILIGHTFOREST_TILE_TFMAGICLOG|2:
+        XP_Gain: 1000
+        Double_Drops_Enabled: true
+        Is_Log: true
+    # Sortingwood
+    TWILIGHTFOREST_TILE_TFMAGICLOG|3:
+        XP_Gain: 1000
+        Double_Drops_Enabled: true
+        Is_Log: true

extras/mods/1.7.x/twilightforest.entities.yml

@@ -0,0 +1,152 @@
+# Config created by joulesbeef
+# Created For twilightforest-2.2.3
+#
+#  Settings for Custom Mobs
+MoCreatures-Ogre:
+  Class: Monster
+  XP_Multiplier: 1.0
+  Tameable: false
+  Taming_XP: 0
+  CanBeSummoned: false
+  COTW_Material: ''
+  COTW_Material_Data: 0
+  COTW_Material_Amount: 0
+TwilightForest-TwilightLich:
+  Class: Monster
+  XP_Multiplier: 1.0
+  Tameable: false
+  Taming_XP: 0
+  CanBeSummoned: false
+  COTW_Material: ''
+  COTW_Material_Data: 0
+  COTW_Material_Amount: 0
+TwilightForest-HelmetCrab:
+  Class: Monster
+  XP_Multiplier: 1.0
+  Tameable: false
+  Taming_XP: 0
+  CanBeSummoned: false
+  COTW_Material: ''
+  COTW_Material_Data: 0
+  COTW_Material_Amount: 0
+TwilightForest-SlimeBeetle:
+  Class: Monster
+  XP_Multiplier: 1.0
+  Tameable: false
+  Taming_XP: 0
+  CanBeSummoned: false
+  COTW_Material: ''
+  COTW_Material_Data: 0
+  COTW_Material_Amount: 0
+TwilightForest-TwilightWraith:
+  Class: Monster
+  XP_Multiplier: 1.0
+  Tameable: false
+  Taming_XP: 0
+  CanBeSummoned: false
+  COTW_Material: ''
+  COTW_Material_Data: 0
+  COTW_Material_Amount: 0
+TwilightForest-Naga:
+  Class: Monster
+  XP_Multiplier: 1.0
+  Tameable: false
+  Taming_XP: 0
+  CanBeSummoned: false
+  COTW_Material: ''
+  COTW_Material_Data: 0
+  COTW_Material_Amount: 0
+MoCreatures-Shark:
+  Class: Monster
+  XP_Multiplier: 1.0
+  Tameable: false
+  Taming_XP: 0
+  CanBeSummoned: false
+  COTW_Material: ''
+  COTW_Material_Data: 0
+  COTW_Material_Amount: 0
+TwilightForest-TowerTermite:
+  Class: Monster
+  XP_Multiplier: 1.0
+  Tameable: false
+  Taming_XP: 0
+  CanBeSummoned: false
+  COTW_Material: ''
+  COTW_Material_Data: 0
+  COTW_Material_Amount: 0
+MoCreatures-SmallFish:
+  Class: Monster
+  XP_Multiplier: 1.0
+  Tameable: false
+  Taming_XP: 0
+  CanBeSummoned: false
+  COTW_Material: ''
+  COTW_Material_Data: 0
+  COTW_Material_Amount: 0
+TwilightForest-Redcap:
+  Class: Monster
+  XP_Multiplier: 1.0
+  Tameable: false
+  Taming_XP: 0
+  CanBeSummoned: false
+  COTW_Material: ''
+  COTW_Material_Data: 0
+  COTW_Material_Amount: 0
+TwilightForest-YetiBoss:
+  Class: Monster
+  XP_Multiplier: 1.0
+  Tameable: false
+  Taming_XP: 0
+  CanBeSummoned: false
+  COTW_Material: ''
+  COTW_Material_Data: 0
+  COTW_Material_Amount: 0
+MoCreatures-HellRat:
+  Class: Monster
+  XP_Multiplier: 1.0
+  Tameable: false
+  Taming_XP: 0
+  CanBeSummoned: false
+  COTW_Material: ''
+  COTW_Material_Data: 0
+  COTW_Material_Amount: 0
+TwilightForest-Hydra:
+  XP_Multiplier: 1.0
+  Tameable: false
+  Taming_XP: 0
+  CanBeSummoned: false
+  COTW_Material: ''
+  COTW_Material_Data: 0
+  COTW_Material_Amount: 0
+TwilightForest-Firefly:
+  XP_Multiplier: 1.0
+  Tameable: false
+  Taming_XP: 0
+  CanBeSummoned: false
+  COTW_Material: ''
+  COTW_Material_Data: 0
+  COTW_Material_Amount: 0
+TwilightForest-KnightPhantom:
+  XP_Multiplier: 1.0
+  Tameable: false
+  Taming_XP: 0
+  CanBeSummoned: false
+  COTW_Material: ''
+  COTW_Material_Data: 0
+  COTW_Material_Amount: 0
+TwilightForest-TowerGolem:
+  XP_Multiplier: 1.0
+  Tameable: false
+  Taming_XP: 0
+  CanBeSummoned: false
+  COTW_Material: ''
+  COTW_Material_Data: 0
+  COTW_Material_Amount: 0
+MoCreatures-FishBowl:
+  XP_Multiplier: 1.0
+  Tameable: false
+  Taming_XP: 0
+  CanBeSummoned: false
+  COTW_Material: ''
+  COTW_Material_Data: 0
+  COTW_Material_Amount: 0

extras/mods/1.7.x/twilightforest.tools.yml

@@ -0,0 +1,184 @@
+# Config created by joulesbeef
+# Created For twilightforest-2.2.3
+#
+#
+#  Settings for Axes
+###
+Axes:
+    # Ironwood
+    TWILIGHTFOREST_ITEM_IRONWOODAXE:
+        XP_Modifer: 1.0
+        Ability_Enabled: true
+        Tier: 1
+        Repairable: true
+        Repair_Material: TWILIGHTFOREST_ITEM_IRONWOODINGOT
+        Repair_Material_Data_Value: 0
+        Repair_Material_Quantity: 2
+        Durability: 500
+    # Steeleaf
+    TWILIGHTFOREST_ITEM_STEELEAFAXE:
+        XP_Modifer: 1.0
+        Ability_Enabled: true
+        Tier: 1
+        Repairable: true
+        Repair_Material: TWILIGHTFOREST_ITEM_STEELEAFINGOT
+        Repair_Material_Data_Value: 0
+        Repair_Material_Quantity: 2
+        Durability: 500
+    # Knightmetal
+    TWILIGHTFOREST_ITEM_KNIGHTLYAXE:
+        XP_Modifer: 1.0
+        Ability_Enabled: true
+        Tier: 1
+        Repairable: true
+        Repair_Material: TWILIGHTFOREST_ITEM_KNIGHTMETAL
+        Repair_Material_Data_Value: 0
+        Repair_Material_Quantity: 2
+        Durability: 500
+    # Minotaur
+    TWILIGHTFOREST_ITEM_MINOTAURAXE:
+        XP_Modifer: 1.0
+        Ability_Enabled: true
+        Tier: 1
+        Repairable: true
+        Repair_Material: Diamond
+        Repair_Material_Data_Value: 0
+        Repair_Material_Quantity: 2
+        Durability: 500
+#
+#  Settings for Hoes
+###
+Hoes:
+    # Ironwood
+    TWILIGHTFOREST_ITEM_IRONWOODHOE:
+        XP_Modifer: 1.0
+        Ability_Enabled: true
+        Tier: 1
+        Repairable: true
+        Repair_Material: TWILIGHTFOREST_ITEM_IRONWOODINGOT
+        Repair_Material_Data_Value: 0
+        Repair_Material_Quantity: 2
+        Durability: 500
+    # Steeleaf
+    TWILIGHTFOREST_ITEM_STEELEAFHOE:
+        XP_Modifer: 1.0
+        Ability_Enabled: true
+        Tier: 1
+        Repairable: true
+        Repair_Material: TWILIGHTFOREST_ITEM_STEELEAFINGOT
+        Repair_Material_Data_Value: 0
+        Repair_Material_Quantity: 2
+        Durability: 500
+
+#
+#  Settings for Pickaxes
+###
+Pickaxes:
+    # Ironwood
+    TWILIGHTFOREST_ITEM_IRONWOODPICK:
+        XP_Modifer: 1.0
+        Ability_Enabled: true
+        Tier: 1
+        Repairable: true
+        Repair_Material: TWILIGHTFOREST_ITEM_IRONWOODINGOT
+        Repair_Material_Data_Value: 0
+        Repair_Material_Quantity: 2
+        Durability: 500
+    # Fiery
+    TWILIGHTFOREST_ITEM_FIERYPICK:
+        XP_Modifer: 1.0
+        Ability_Enabled: true
+        Tier: 1
+        Repairable: true
+        Repair_Material: TWILIGHTFOREST_ITEM_FIERYINGOT
+        Repair_Material_Data_Value: 0
+        Repair_Material_Quantity: 2
+        Durability: 500
+    # Steeleaf
+    TWILIGHTFOREST_ITEM_STEELEAFPICK:
+        XP_Modifer: 1.0
+        Ability_Enabled: true
+        Tier: 1
+        Repairable: true
+        Repair_Material: TWILIGHTFOREST_ITEM_STEELEAFINGOT
+        Repair_Material_Data_Value: 0
+        Repair_Material_Quantity: 2
+        Durability: 500
+    # Knightmetal
+    TWILIGHTFOREST_ITEM_KNIGHTLYPICK:
+        XP_Modifer: 1.0
+        Ability_Enabled: true
+        Tier: 1
+        Repairable: true
+        Repair_Material: TWILIGHTFOREST_ITEM_KNIGHTMETAL
+        Repair_Material_Data_Value: 0
+        Repair_Material_Quantity: 2
+        Durability: 500
+#
+#  Settings for Shovels
+###
+Shovels:
+    # Ironwood
+    TWILIGHTFOREST_ITEM_IRONWOODSHOVEL:
+        XP_Modifer: 1.0
+        Ability_Enabled: true
+        Tier: 1
+        Repairable: true
+        Repair_Material: TWILIGHTFOREST_ITEM_IRONWOODINGOT
+        Repair_Material_Data_Value: 0
+        Repair_Material_Quantity: 2
+        Durability: 500
+    # Steeleaf
+    TWILIGHTFOREST_ITEM_STEELEAFSHOVEL:
+        XP_Modifer: 1.0
+        Ability_Enabled: true
+        Tier: 1
+        Repairable: true
+        Repair_Material: TWILIGHTFOREST_ITEM_STEELEAFINGOT
+        Repair_Material_Data_Value: 0
+        Repair_Material_Quantity: 2
+        Durability: 500
+#
+#  Settings for Swords
+###
+Swords:
+    # Ironwood
+    TWILIGHTFOREST_ITEM_IRONWOODSWORD:
+        XP_Modifer: 1.0
+        Ability_Enabled: true
+        Tier: 1
+        Repairable: true
+        Repair_Material: TWILIGHTFOREST_ITEM_IRONWOODINGOT
+        Repair_Material_Data_Value: 0
+        Repair_Material_Quantity: 2
+        Durability: 500
+    # Fiery
+    TWILIGHTFOREST_ITEM_FIERYSWORD:
+        XP_Modifer: 1.0
+        Ability_Enabled: true
+        Tier: 1
+        Repairable: true
+        Repair_Material: TWILIGHTFOREST_ITEM_FIERYINGOT
+        Repair_Material_Data_Value: 0
+        Repair_Material_Quantity: 2
+        Durability: 500
+    # Steeleaf
+    TWILIGHTFOREST_ITEM_STEELEAFSWORD:
+        XP_Modifer: 1.0
+        Ability_Enabled: true
+        Tier: 1
+        Repairable: true
+        Repair_Material: TWILIGHTFOREST_ITEM_STEELEAFINGOT
+        Repair_Material_Data_Value: 0
+        Repair_Material_Quantity: 2
+        Durability: 500
+    # Knightmetal
+    TWILIGHTFOREST_ITEM_KNIGHTLYSWORD:
+        XP_Modifer: 1.0
+        Ability_Enabled: true
+        Tier: 1
+        Repairable: true
+        Repair_Material: TWILIGHTFOREST_ITEM_KNIGHTMETAL
+        Repair_Material_Data_Value: 0
+        Repair_Material_Quantity: 2
+        Durability: 500

pom.xml

@@ -2,7 +2,7 @@
     <modelVersion>4.0.0</modelVersion>
     <groupId>com.gmail.nossr50.mcMMO</groupId>
     <artifactId>mcMMO</artifactId>
-    <version>1.4.08</version>
+    <version>1.5.01-SNAPSHOT</version>
     <name>mcMMO</name>
     <url>https://github.com/mcMMO-Dev/mcMMO</url>
     <issueManagement>
@@ -76,6 +76,8 @@
                     <artifactSet>
                         <includes>
                             <include>com.turt2live.metrics:MetricsExtension</include>
+                            <include>commons-logging:commons-logging</include>
+                            <include>net.snaq:dbpool</include>
                         </includes>
                     </artifactSet>
                     <relocations>
@@ -83,6 +85,14 @@
                             <pattern>com.turt2live.metrics</pattern>
                             <shadedPattern>com.gmail.nossr50.metrics.mcstats</shadedPattern>
                         </relocation>
+                        <relocation>
+                            <pattern>org.apache.commons.logging</pattern>
+                            <shadedPattern>com.gmail.nossr50.commons.logging</shadedPattern>
+                        </relocation>
+                        <relocation>
+                            <pattern>net.snaq</pattern>
+                            <shadedPattern>com.gmail.nossr50.dbpool</shadedPattern>
+                        </relocation>
                     </relocations>
                 </configuration>
                 <executions>
@@ -121,7 +131,7 @@
         <dependency>
             <groupId>org.bukkit</groupId>
             <artifactId>bukkit</artifactId>
-            <version>1.6.4-R2.0</version>
+            <version>LATEST</version>
             <type>jar</type>
             <scope>compile</scope>
         </dependency>
@@ -136,6 +146,11 @@
             <artifactId>MetricsExtension</artifactId>
             <version>0.0.5-SNAPSHOT</version>
         </dependency>
+        <dependency>
+            <groupId>net.snaq</groupId>
+            <artifactId>dbpool</artifactId>
+            <version>5.1</version>
+        </dependency>
     </dependencies>
     <distributionManagement>
         <repository>

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

@@ -1,16 +1,19 @@
 package com.gmail.nossr50.api;
 
 import java.util.Set;
+import java.util.UUID;
 
 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,10 +65,36 @@ 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));
+    }
+
+    /**
+     * Adds raw XP to an offline player.
+     * </br>
+     * This function is designed for API usage.
+     *
+     * @deprecated We're using float for our XP values now
+     * replaced by {@link #addRawXPOffline(String playerName, String skillType, float XP)}
+     */
     @Deprecated
     public static void addRawXPOffline(String playerName, String skillType, int XP) {
         addRawXPOffline(playerName, skillType, (float) XP);
@@ -76,6 +105,9 @@ public final class ExperienceAPI {
      * </br>
      * This function is designed for API usage.
      *
+     * @deprecated We're using uuids to get an offline player
+     * replaced by {@link #addRawXPOffline(UUID uuid, String skillType, float XP)}
+     *
      * @param playerName The player to add XP to
      * @param skillType The skill to add XP to
      * @param XP The amount of XP to add
@@ -83,10 +115,27 @@ public final class ExperienceAPI {
      * @throws InvalidSkillException if the given skill is not valid
      * @throws InvalidPlayerException if the given player does not exist in the database
      */
+    @Deprecated
     public static void addRawXPOffline(String playerName, String skillType, float XP) {
         addOfflineXP(playerName, getSkillType(skillType), (int) Math.floor(XP));
     }
 
+    /**
+     * Adds raw XP to an offline player.
+     * </br>
+     * This function is designed for API usage.
+     *
+     * @param uuid The UUID of player to add XP to
+     * @param skillType The skill to add XP to
+     * @param XP The amount of XP to add
+     *
+     * @throws InvalidSkillException if the given skill is not valid
+     * @throws InvalidPlayerException if the given player does not exist in the database
+     */
+    public static void addRawXPOffline(UUID uuid, String skillType, float XP) {
+        addOfflineXP(uuid, getSkillType(skillType), (int) Math.floor(XP));
+    }
+
     /**
      * Adds XP to the player, calculates for XP Rate only.
      * </br>
@@ -98,8 +147,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));
     }
 
     /**
@@ -114,6 +181,7 @@ public final class ExperienceAPI {
      * @throws InvalidSkillException if the given skill is not valid
      * @throws InvalidPlayerException if the given player does not exist in the database
      */
+    @Deprecated
     public static void addMultipliedXPOffline(String playerName, String skillType, int XP) {
         addOfflineXP(playerName, getSkillType(skillType), (int) (XP * ExperienceConfig.getInstance().getExperienceGainsGlobalMultiplier()));
     }
@@ -129,10 +197,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));
     }
 
     /**
@@ -147,6 +233,7 @@ public final class ExperienceAPI {
      * @throws InvalidSkillException if the given skill is not valid
      * @throws InvalidPlayerException if the given player does not exist in the database
      */
+    @Deprecated
     public static void addModifiedXPOffline(String playerName, String skillType, int XP) {
         SkillType skill = getSkillType(skillType);
 
@@ -165,8 +252,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));
     }
 
     /**
@@ -198,10 +304,28 @@ public final class ExperienceAPI {
      * @throws InvalidPlayerException if the given player does not exist in the database
      * @throws UnsupportedOperationException if the given skill is a child skill
      */
+    @Deprecated
     public static int getOfflineXP(String playerName, String skillType) {
         return getOfflineProfile(playerName).getSkillXpLevel(getNonChildSkillType(skillType));
     }
 
+    /**
+     * Get the amount of XP an offline player has in a specific skill.
+     * </br>
+     * This function is designed for API usage.
+     *
+     * @param uuid The player to get XP for
+     * @param skillType The skill to get XP for
+     * @return the amount of XP in a given skill
+     *
+     * @throws InvalidSkillException if the given skill is not valid
+     * @throws InvalidPlayerException if the given player does not exist in the database
+     * @throws UnsupportedOperationException if the given skill is a child skill
+     */
+    public static int getOfflineXP(UUID uuid, String skillType) {
+        return getOfflineProfile(uuid).getSkillXpLevel(getNonChildSkillType(skillType));
+    }
+
     /**
      * Get the raw amount of XP a player has in a specific skill.
      * </br>
@@ -231,10 +355,28 @@ public final class ExperienceAPI {
      * @throws InvalidPlayerException if the given player does not exist in the database
      * @throws UnsupportedOperationException if the given skill is a child skill
      */
+    @Deprecated
     public static float getOfflineXPRaw(String playerName, String skillType) {
         return getOfflineProfile(playerName).getSkillXpLevelRaw(getNonChildSkillType(skillType));
     }
 
+    /**
+     * Get the raw amount of XP an offline player has in a specific skill.
+     * </br>
+     * This function is designed for API usage.
+     *
+     * @param uuid The player to get XP for
+     * @param skillType The skill to get XP for
+     * @return the amount of XP in a given skill
+     *
+     * @throws InvalidSkillException if the given skill is not valid
+     * @throws InvalidPlayerException if the given player does not exist in the database
+     * @throws UnsupportedOperationException if the given skill is a child skill
+     */
+    public static float getOfflineXPRaw(UUID uuid, String skillType) {
+        return getOfflineProfile(uuid).getSkillXpLevelRaw(getNonChildSkillType(skillType));
+    }
+
     /**
      * Get the total amount of XP needed to reach the next level.
      * </br>
@@ -264,10 +406,28 @@ public final class ExperienceAPI {
      * @throws InvalidPlayerException if the given player does not exist in the database
      * @throws UnsupportedOperationException if the given skill is a child skill
      */
+    @Deprecated
     public static int getOfflineXPToNextLevel(String playerName, String skillType) {
         return getOfflineProfile(playerName).getXpToLevel(getNonChildSkillType(skillType));
     }
 
+    /**
+     * Get the total amount of XP an offline player needs to reach the next level.
+     * </br>
+     * This function is designed for API usage.
+     *
+     * @param uuid The player to get XP for
+     * @param skillType The skill to get XP for
+     * @return the total amount of XP needed to reach the next level
+     *
+     * @throws InvalidSkillException if the given skill is not valid
+     * @throws InvalidPlayerException if the given player does not exist in the database
+     * @throws UnsupportedOperationException if the given skill is a child skill
+     */
+    public static int getOfflineXPToNextLevel(UUID uuid, String skillType) {
+        return getOfflineProfile(uuid).getXpToLevel(getNonChildSkillType(skillType));
+    }
+
     /**
      * Get the amount of XP remaining until the next level.
      * </br>
@@ -301,14 +461,34 @@ public final class ExperienceAPI {
      * @throws InvalidPlayerException if the given player does not exist in the database
      * @throws UnsupportedOperationException if the given skill is a child skill
      */
+    @Deprecated
     public static int getOfflineXPRemaining(String playerName, String skillType) {
         SkillType skill = getNonChildSkillType(skillType);
-
         PlayerProfile profile = getOfflineProfile(playerName);
 
         return profile.getXpToLevel(skill) - profile.getSkillXpLevel(skill);
     }
 
+    /**
+     * Get the amount of XP an offline player has left before leveling up.
+     * </br>
+     * This function is designed for API usage.
+     *
+     * @param uuid The player to get XP for
+     * @param skillType The skill to get XP for
+     * @return the amount of XP needed to reach the next level
+     *
+     * @throws InvalidSkillException if the given skill is not valid
+     * @throws InvalidPlayerException if the given player does not exist in the database
+     * @throws UnsupportedOperationException if the given skill is a child skill
+     */
+    public static float getOfflineXPRemaining(UUID uuid, String skillType) {
+        SkillType skill = getNonChildSkillType(skillType);
+        PlayerProfile profile = getOfflineProfile(uuid);
+
+        return profile.getXpToLevel(skill) - profile.getSkillXpLevelRaw(skill);
+    }
+
     /**
      * Add levels to a skill.
      * </br>
@@ -336,6 +516,7 @@ public final class ExperienceAPI {
      * @throws InvalidSkillException if the given skill is not valid
      * @throws InvalidPlayerException if the given player does not exist in the database
      */
+    @Deprecated
     public static void addLevelOffline(String playerName, String skillType, int levels) {
         PlayerProfile profile = getOfflineProfile(playerName);
         SkillType skill = getSkillType(skillType);
@@ -347,12 +528,43 @@ public final class ExperienceAPI {
                 profile.addLevels(parentSkill, (levels / parentSkills.size()));
             }
 
-            profile.save();
+            profile.scheduleAsyncSave();
             return;
         }
 
         profile.addLevels(skill, levels);
-        profile.save();
+        profile.scheduleAsyncSave();
+    }
+
+    /**
+     * Add levels to a skill for an offline player.
+     * </br>
+     * This function is designed for API usage.
+     *
+     * @param uuid The player to add levels to
+     * @param skillType Type of skill to add levels to
+     * @param levels Number of levels to add
+     *
+     * @throws InvalidSkillException if the given skill is not valid
+     * @throws InvalidPlayerException if the given player does not exist in the database
+     */
+    public static void addLevelOffline(UUID uuid, String skillType, int levels) {
+        PlayerProfile profile = getOfflineProfile(uuid);
+        SkillType skill = getSkillType(skillType);
+
+        if (skill.isChildSkill()) {
+            Set<SkillType> parentSkills = FamilyTree.getParents(skill);
+
+            for (SkillType parentSkill : parentSkills) {
+                profile.addLevels(parentSkill, (levels / parentSkills.size()));
+            }
+
+            profile.scheduleAsyncSave();
+            return;
+        }
+
+        profile.addLevels(skill, levels);
+        profile.scheduleAsyncSave();
     }
 
     /**
@@ -382,10 +594,27 @@ public final class ExperienceAPI {
      * @throws InvalidSkillException if the given skill is not valid
      * @throws InvalidPlayerException if the given player does not exist in the database
      */
+    @Deprecated
     public static int getLevelOffline(String playerName, String skillType) {
         return getOfflineProfile(playerName).getSkillLevel(getSkillType(skillType));
     }
 
+    /**
+     * Get the level an offline player has in a specific skill.
+     * </br>
+     * This function is designed for API usage.
+     *
+     * @param uuid The player to get the level for
+     * @param skillType The skill to get the level for
+     * @return the level of a given skill
+     *
+     * @throws InvalidSkillException if the given skill is not valid
+     * @throws InvalidPlayerException if the given player does not exist in the database
+     */
+    public static int getLevelOffline(UUID uuid, String skillType) {
+        return getOfflineProfile(uuid).getSkillLevel(getSkillType(skillType));
+    }
+
     /**
      * Gets the power level of a player.
      * </br>
@@ -408,6 +637,7 @@ public final class ExperienceAPI {
      *
      * @throws InvalidPlayerException if the given player does not exist in the database
      */
+    @Deprecated
     public static int getPowerLevelOffline(String playerName) {
         int powerLevel = 0;
         PlayerProfile profile = getOfflineProfile(playerName);
@@ -419,6 +649,27 @@ public final class ExperienceAPI {
         return powerLevel;
     }
 
+    /**
+     * Gets the power level of an offline player.
+     * </br>
+     * This function is designed for API usage.
+     *
+     * @param uuid The player to get the power level for
+     * @return the power level of the player
+     *
+     * @throws InvalidPlayerException if the given player does not exist in the database
+     */
+    public static int getPowerLevelOffline(UUID uuid) {
+        int powerLevel = 0;
+        PlayerProfile profile = getOfflineProfile(uuid);
+
+        for (SkillType type : SkillType.NON_CHILD_SKILLS) {
+            powerLevel += profile.getSkillLevel(type);
+        }
+
+        return powerLevel;
+    }
+
     /**
      * Get the level cap of a specific skill.
      * </br>
@@ -458,10 +709,28 @@ public final class ExperienceAPI {
      *
      * @return the position on the leaderboard
      */
+    @Deprecated
     public static int getPlayerRankSkill(String playerName, String skillType) {
         return mcMMO.getDatabaseManager().readRank(getOfflineProfile(playerName).getPlayerName()).get(getNonChildSkillType(skillType));
     }
 
+    /**
+     * Get the position on the leaderboard of a player.
+     * </br>
+     * This function is designed for API usage.
+     *
+     * @param uuid The name of the player to check
+     * @param skillType The skill to check
+     *
+     * @throws InvalidSkillException if the given skill is not valid
+     * @throws InvalidPlayerException if the given player does not exist in the database
+     * @throws UnsupportedOperationException if the given skill is a child skill
+     *
+     * @return the position on the leaderboard
+     */
+    public static int getPlayerRankSkill(UUID uuid, String skillType) {
+        return mcMMO.getDatabaseManager().readRank(getOfflineProfile(uuid).getPlayerName()).get(getNonChildSkillType(skillType));
+    }
 
     /**
      * Get the position on the power level leaderboard of a player.
@@ -474,10 +743,26 @@ public final class ExperienceAPI {
      *
      * @return the position on the power level leaderboard
      */
+    @Deprecated
     public static int getPlayerRankOverall(String playerName) {
         return mcMMO.getDatabaseManager().readRank(getOfflineProfile(playerName).getPlayerName()).get(null);
     }
 
+    /**
+     * Get the position on the power level leaderboard of a player.
+     * </br>
+     * This function is designed for API usage.
+     *
+     * @param uuid The name of the player to check
+     *
+     * @throws InvalidPlayerException if the given player does not exist in the database
+     *
+     * @return the position on the power level leaderboard
+     */
+    public static int getPlayerRankOverall(UUID uuid) {
+        return mcMMO.getDatabaseManager().readRank(getOfflineProfile(uuid).getPlayerName()).get(null);
+    }
+
     /**
      * Sets the level of a player in a specific skill type.
      * </br>
@@ -505,10 +790,27 @@ public final class ExperienceAPI {
      * @throws InvalidSkillException if the given skill is not valid
      * @throws InvalidPlayerException if the given player does not exist in the database
      */
+    @Deprecated
     public static void setLevelOffline(String playerName, String skillType, int skillLevel) {
         getOfflineProfile(playerName).modifySkill(getSkillType(skillType), skillLevel);
     }
 
+    /**
+     * Sets the level of an offline player in a specific skill type.
+     * </br>
+     * This function is designed for API usage.
+     *
+     * @param uuid The player to set the level of
+     * @param skillType The skill to set the level for
+     * @param skillLevel The value to set the level to
+     *
+     * @throws InvalidSkillException if the given skill is not valid
+     * @throws InvalidPlayerException if the given player does not exist in the database
+     */
+    public static void setLevelOffline(UUID uuid, String skillType, int skillLevel) {
+        getOfflineProfile(uuid).modifySkill(getSkillType(skillType), skillLevel);
+    }
+
     /**
      * Sets the XP of a player in a specific skill type.
      * </br>
@@ -538,10 +840,28 @@ public final class ExperienceAPI {
      * @throws InvalidPlayerException if the given player does not exist in the database
      * @throws UnsupportedOperationException if the given skill is a child skill
      */
+    @Deprecated
     public static void setXPOffline(String playerName, String skillType, int newValue) {
         getOfflineProfile(playerName).setSkillXpLevel(getNonChildSkillType(skillType), newValue);
     }
 
+    /**
+     * Sets the XP of an offline player in a specific skill type.
+     * </br>
+     * This function is designed for API usage.
+     *
+     * @param uuid The player to set the XP of
+     * @param skillType The skill to set the XP for
+     * @param newValue The value to set the XP to
+     *
+     * @throws InvalidSkillException if the given skill is not valid
+     * @throws InvalidPlayerException if the given player does not exist in the database
+     * @throws UnsupportedOperationException if the given skill is a child skill
+     */
+    public static void setXPOffline(UUID uuid, String skillType, int newValue) {
+        getOfflineProfile(uuid).setSkillXpLevel(getNonChildSkillType(skillType), newValue);
+    }
+
     /**
      * Removes XP from a player in a specific skill type.
      * </br>
@@ -571,21 +891,58 @@ public final class ExperienceAPI {
      * @throws InvalidPlayerException if the given player does not exist in the database
      * @throws UnsupportedOperationException if the given skill is a child skill
      */
+    @Deprecated
     public static void removeXPOffline(String playerName, String skillType, int xp) {
         getOfflineProfile(playerName).removeXp(getNonChildSkillType(skillType), xp);
     }
 
-    // Utility methods follow.
+    /**
+     * Removes XP from an offline player in a specific skill type.
+     * </br>
+     * This function is designed for API usage.
+     *
+     * @param uuid The player to change the XP of
+     * @param skillType The skill to change the XP for
+     * @param xp The amount of XP to remove
+     *
+     * @throws InvalidSkillException if the given skill is not valid
+     * @throws InvalidPlayerException if the given player does not exist in the database
+     * @throws UnsupportedOperationException if the given skill is a child skill
+     */
+    public static void removeXPOffline(UUID uuid, String skillType, int xp) {
+        getOfflineProfile(uuid).removeXp(getNonChildSkillType(skillType), xp);
+    }
 
-    private static void addOfflineXP(String playerName, SkillType skill, int XP) {
-        PlayerProfile profile = getOfflineProfile(playerName);
+    // Utility methods follow.
+    private static void addOfflineXP(UUID playerUniqueId, SkillType skill, int XP) {
+        PlayerProfile profile = getOfflineProfile(playerUniqueId);
 
         profile.addXp(skill, XP);
         profile.save();
     }
 
+    @Deprecated
+    private static void addOfflineXP(String playerName, SkillType skill, int XP) {
+        PlayerProfile profile = getOfflineProfile(playerName);
+
+        profile.addXp(skill, XP);
+        profile.scheduleAsyncSave();
+    }
+
+    private static PlayerProfile getOfflineProfile(UUID uuid) {
+        PlayerProfile profile = mcMMO.getDatabaseManager().loadPlayerProfile(uuid);
+
+        if (!profile.isLoaded()) {
+            throw new InvalidPlayerException();
+        }
+
+        return profile;
+    }
+
+    @Deprecated
     private static PlayerProfile getOfflineProfile(String playerName) {
-        PlayerProfile profile = mcMMO.getDatabaseManager().loadPlayerProfile(playerName, false);
+        UUID uuid = mcMMO.p.getServer().getOfflinePlayer(playerName).getUniqueId();
+        PlayerProfile profile = mcMMO.getDatabaseManager().loadPlayerProfile(uuid);
 
         if (!profile.isLoaded()) {
             throw new InvalidPlayerException();
@@ -613,4 +970,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/SkillAPI.java

@@ -0,0 +1,93 @@
+package com.gmail.nossr50.api;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import com.gmail.nossr50.datatypes.skills.SkillType;
+
+public final class SkillAPI {
+    private SkillAPI() {}
+
+    /**
+     * Returns a list of strings with mcMMO's skills
+     * This includes parent and child skills
+     * </br>
+     * This function is designed for API usage.
+     *
+     * @return a list of strings with valid skill names
+     */
+    public static List<String> getSkills() {
+        return getListFromEnum(Arrays.asList(SkillType.values()));
+    }
+
+    /**
+     * Returns a list of strings with mcMMO's skills
+     * This only includes parent skills
+     * </br>
+     * This function is designed for API usage.
+     *
+     * @return a list of strings with valid skill names
+     */
+    public static List<String> getNonChildSkills() {
+        return getListFromEnum(SkillType.NON_CHILD_SKILLS);
+    }
+
+    /**
+     * Returns a list of strings with mcMMO's skills
+     * This only includes child skills
+     * </br>
+     * This function is designed for API usage.
+     *
+     * @return a list of strings with valid skill names
+     */
+    public static List<String> getChildSkills() {
+        return getListFromEnum(SkillType.CHILD_SKILLS);
+    }
+
+    /**
+     * Returns a list of strings with mcMMO's skills
+     * This only includes combat skills
+     * </br>
+     * This function is designed for API usage.
+     *
+     * @return a list of strings with valid skill names
+     */
+    public static List<String> getCombatSkills() {
+        return getListFromEnum(SkillType.COMBAT_SKILLS);
+    }
+
+    /**
+     * Returns a list of strings with mcMMO's skills
+     * This only includes gathering skills
+     * </br>
+     * This function is designed for API usage.
+     *
+     * @return a list of strings with valid skill names
+     */
+    public static List<String> getGatheringSkills() {
+        return getListFromEnum(SkillType.GATHERING_SKILLS);
+    }
+
+    /**
+     * Returns a list of strings with mcMMO's skills
+     * This only includes misc skills
+     * </br>
+     * This function is designed for API usage.
+     *
+     * @return a list of strings with valid skill names
+     */
+    public static List<String> getMiscSkills() {
+        return getListFromEnum(SkillType.MISC_SKILLS);
+    }
+
+    private static List<String> getListFromEnum(List<SkillType> skillsTypes) {
+        List<String> skills = new ArrayList<String>();
+
+        for (SkillType skillType : skillsTypes) {
+            skills.add(skillType.name());
+        }
+
+        return skills;
+    }
+}

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/chat/PartyChatManager.java

@@ -1,16 +1,11 @@
 package com.gmail.nossr50.chat;
 
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
-import org.bukkit.ChatColor;
-import org.bukkit.entity.Player;
 import org.bukkit.plugin.Plugin;
 
 import com.gmail.nossr50.config.Config;
 import com.gmail.nossr50.datatypes.party.Party;
 import com.gmail.nossr50.events.chat.McMMOPartyChatEvent;
-import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.runnables.party.PartyChatTask;
 
 public class PartyChatManager extends ChatManager {
     private Party party;
@@ -30,21 +25,6 @@ public class PartyChatManager extends ChatManager {
 
     @Override
     protected void sendMessage() {
-        if (Config.getInstance().getPartyChatColorLeaderName() && senderName.equalsIgnoreCase(party.getLeader())) {
-            message = message.replaceFirst(Pattern.quote(displayName), ChatColor.GOLD + Matcher.quoteReplacement(displayName) + ChatColor.RESET);
-        }
-
-        for (Player member : party.getOnlineMembers()) {
-            member.sendMessage(message);
-        }
-
-        if (party.getAlly() != null) {
-            for (Player member : party.getAlly().getOnlineMembers()) {
-                String allyPrefix = LocaleLoader.formatString(Config.getInstance().getPartyChatPrefixAlly());
-                member.sendMessage(allyPrefix + message);
-            }
-        }
-
-        plugin.getLogger().info("[P]<" + party.getName() + ">" + message);
+        new PartyChatTask(plugin, party, senderName, displayName, message).runTask(plugin);
     }
 }

src/main/java/com/gmail/nossr50/commands/database/ConvertDatabaseCommand.java

@@ -12,6 +12,7 @@ import com.gmail.nossr50.datatypes.database.DatabaseType;
 import com.gmail.nossr50.datatypes.player.PlayerProfile;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.runnables.database.DatabaseConversionTask;
+import com.gmail.nossr50.runnables.player.PlayerProfileLoadingTask;
 import com.gmail.nossr50.util.player.UserManager;
 
 public class ConvertDatabaseCommand implements CommandExecutor {
@@ -55,13 +56,13 @@ public class ConvertDatabaseCommand implements CommandExecutor {
                 UserManager.clearAll();
 
                 for (Player player : mcMMO.p.getServer().getOnlinePlayers()) {
-                    PlayerProfile profile = oldDatabase.loadPlayerProfile(player.getName(), false);
+                    PlayerProfile profile = oldDatabase.loadPlayerProfile(player.getUniqueId());
 
                     if (profile.isLoaded()) {
                         mcMMO.getDatabaseManager().saveUser(profile);
                     }
 
-                    UserManager.addUser(player);
+                    new PlayerProfileLoadingTask(player).runTaskTimerAsynchronously(mcMMO.p, 1, 20); // 1 Tick delay to ensure the player is marked as online before we begin loading
                 }
 
                 new DatabaseConversionTask(oldDatabase, sender, previousType.toString(), newType.toString()).runTaskAsynchronously(mcMMO.p);

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/ConvertExperienceCommand.java

@@ -9,6 +9,7 @@ import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.datatypes.experience.FormulaType;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.runnables.database.FormulaConversionTask;
+import com.gmail.nossr50.runnables.player.PlayerProfileLoadingTask;
 import com.gmail.nossr50.util.player.UserManager;
 
 public class ConvertExperienceCommand implements CommandExecutor {
@@ -37,7 +38,7 @@ public class ConvertExperienceCommand implements CommandExecutor {
                 new FormulaConversionTask(sender, newType).runTaskLater(mcMMO.p, 1);
 
                 for (Player player : mcMMO.p.getServer().getOnlinePlayers()) {
-                    UserManager.addUser(player);
+                    new PlayerProfileLoadingTask(player).runTaskTimerAsynchronously(mcMMO.p, 1, 20); // 1 Tick delay to ensure the player is marked as online before we begin loading
                 }
 
                 return true;

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/ArcheryCommand.java

@@ -65,7 +65,7 @@ public class ArcheryCommand extends SkillCommand {
         }
 
         if (canDaze) {
-            messages.add(LocaleLoader.getString("Effects.Template", LocaleLoader.getString("Archery.Effect.2"), LocaleLoader.getString("Archery.Effect.3", Archery.dazeModifier)));
+            messages.add(LocaleLoader.getString("Effects.Template", LocaleLoader.getString("Archery.Effect.2"), LocaleLoader.getString("Archery.Effect.3", Archery.dazeBonusDamage)));
         }
 
         if (canRetrieve) {

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;
 
@@ -98,9 +97,7 @@ public class FishingCommand extends SkillCommand {
                 location = player.getLocation();
             }
 
-            Biome biome = location.getBlock().getBiome();
-
-            if (biome == Biome.RIVER || biome == Biome.OCEAN) {
+            if (Fishing.masterAnglerBiomes.contains(location.getBlock().getBiome())) {
                 rawBiteChance = rawBiteChance * AdvancedConfig.getInstance().getMasterAnglerBiomeModifier();
             }
 

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

@@ -9,6 +9,7 @@ import com.gmail.nossr50.config.AdvancedConfig;
 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.mining.BlastMining;
 import com.gmail.nossr50.skills.mining.BlastMining.Tier;
 import com.gmail.nossr50.skills.mining.MiningManager;
 import com.gmail.nossr50.util.Permissions;
@@ -126,7 +127,7 @@ public class MiningCommand extends SkillCommand {
         }
 
         if (canBiggerBombs) {
-            int unlockLevel = AdvancedConfig.getInstance().getBlastMiningRankLevel(Tier.TWO);
+            int unlockLevel = BlastMining.getBiggerBombsUnlockLevel();
 
             if (skillValue < unlockLevel) {
                 messages.add(LocaleLoader.getString("Ability.Generic.Template.Lock", LocaleLoader.getString("Mining.Ability.Locked.1", unlockLevel)));
@@ -137,7 +138,7 @@ public class MiningCommand extends SkillCommand {
         }
 
         if (canDemoExpert) {
-            int unlockLevel = AdvancedConfig.getInstance().getBlastMiningRankLevel(Tier.FOUR);
+            int unlockLevel = BlastMining.getDemolitionExpertUnlockLevel();
 
             if (skillValue < unlockLevel) {
                 messages.add(LocaleLoader.getString("Ability.Generic.Template.Lock", LocaleLoader.getString("Mining.Ability.Locked.2", unlockLevel)));

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;
 
@@ -133,7 +134,7 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
             reason.add("Skills.Acrobatics.Daze.MaxBonusLevel should be at least 1!");
         }
 
-        if (getDazeModifier() < 0) {
+        if (getDazeBonusDamage() < 0) {
             reason.add("Skills.Acrobatics.Daze.BonusDamage should be at least 0!");
         }
 
@@ -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!");
@@ -672,7 +714,7 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
     public double getSkillShotBonusMax() { return config.getDouble("Skills.Archery.SkillShot.MaxBonus", 2.0D); }
     public double getSkillShotDamageMax() { return config.getDouble("Skills.Archery.SkillShot.MaxDamage", 9.0D); }
 
-    public double getDazeModifier() { return config.getDouble("Skills.Archery.Daze.BonusDamage", 4.0D); }
+    public double getDazeBonusDamage() { return config.getDouble("Skills.Archery.Daze.BonusDamage", 4.0D); }
 
     public double getForceMultiplier() { return config.getDouble("Skills.Archery.ForceMultiplier", 2.0D); }
 
@@ -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

@@ -5,6 +5,7 @@ import java.util.List;
 import java.util.Set;
 
 import org.bukkit.Material;
+import org.bukkit.TreeSpecies;
 import org.bukkit.configuration.ConfigurationSection;
 import org.bukkit.entity.EntityType;
 
@@ -231,12 +232,12 @@ public class Config extends AutoUpdateConfigLoader {
     /* General Settings */
     public String getLocale() { return config.getString("General.Locale", "en_us"); }
     public boolean getMOTDEnabled() { return config.getBoolean("General.MOTD_Enabled", true); }
+    public boolean getShowProfileLoadedMessage() { return config.getBoolean("General.Show_Profile_Loaded", true); }
     public boolean getDonateMessageEnabled() { return config.getBoolean("Commands.mcmmo.Donate_Message", true); }
     public int getSaveInterval() { return config.getInt("General.Save_Interval", 10); }
     public boolean getStatsTrackingEnabled() { return config.getBoolean("General.Stats_Tracking", true); }
     public boolean getUpdateCheckEnabled() { return config.getBoolean("General.Update_Check", true); }
     public boolean getPreferBeta() { return config.getBoolean("General.Prefer_Beta", false); }
-    public boolean getEventCallbackEnabled() { return config.getBoolean("General.Event_Callback", true); }
     public boolean getVerboseLoggingEnabled() { return config.getBoolean("General.Verbose_Logging", false); }
 
     public String getPartyChatPrefix() { return config.getString("Commands.partychat.Chat_Prefix_Format", "[[GREEN]]([[WHITE]]{0}[[GREEN]])"); }
@@ -265,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); }
@@ -290,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); }
@@ -313,6 +314,8 @@ public class Config extends AutoUpdateConfigLoader {
     public int getMySQLServerPort() { return config.getInt("MySQL.Server.Port", 3306); }
     public String getMySQLServerName() { return config.getString("MySQL.Server.Address", "localhost"); }
     public String getMySQLUserPassword() { return getStringIncludingInts("MySQL.Database.User_Password"); }
+    public int getMySQLMaxConnections() { return config.getInt("MySQL.Database.MaxConnections"); }
+    public int getMySQLMaxPoolSize() { return config.getInt("MySQL.Database.MaxPoolSize"); }
 
     private String getStringIncludingInts(String key) {
         String str = config.getString(key);
@@ -447,10 +450,13 @@ 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); }
+    public boolean getFishingOverrideTreasures() { return config.getBoolean("Skills.Fishing.Override_Vanilla_Treasures", true); }
+    public boolean getFishingExtraFish() { return config.getBoolean("Skills.Fishing.Extra_Fish", true); }
 
     /* Mining */
     public Material getDetonatorItem() { return Material.matchMaterial(config.getString("Skills.Mining.Detonator_Name", "FLINT_AND_STEEL")); }
@@ -460,13 +466,18 @@ 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); }
+    public boolean getUnarmedItemPickupDisabled() { return config.getBoolean("Skills.Unarmed.Item_Pickup_Disabled_Full_Inventory", true); }
 
     /* Taming */
     public Material getTamingCOTWMaterial(EntityType type) { return Material.matchMaterial(config.getString("Skills.Taming.Call_Of_The_Wild." + StringUtils.getPrettyEntityTypeString(type) + ".Item_Material")); }
@@ -475,10 +486,7 @@ public class Config extends AutoUpdateConfigLoader {
     public double getTamingCOTWRange() { return config.getDouble("Skills.Taming.Call_Of_The_Wild.Range", 40.0D); }
 
     /* Woodcutting */
-    public boolean getOakDoubleDropsEnabled() { return config.getBoolean("Double_Drops.Woodcutting.Oak", true); }
-    public boolean getBirchDoubleDropsEnabled() { return config.getBoolean("Double_Drops.Woodcutting.Birch", true); }
-    public boolean getSpruceDoubleDropsEnabled() { return config.getBoolean("Double_Drops.Woodcutting.Spruce", true); }
-    public boolean getJungleDoubleDropsEnabled() { return config.getBoolean("Double_Drops.Woodcutting.Jungle", true); }
+    public boolean getWoodcuttingDoubleDropsEnabled(TreeSpecies species) { return config.getBoolean("Double_Drops.Woodcutting." + StringUtils.getPrettyTreeSpeciesString(species).replace(" ", "_")); }
     public boolean getTreeFellerSoundsEnabled() { return config.getBoolean("Skills.Woodcutting.Tree_Feller_Sounds", true); }
 
     /* AFK Leveling */

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

@@ -12,6 +12,7 @@ public class HiddenConfig {
     private static int conversionRate;
     private static boolean useEnchantmentBuffs;
     private static boolean resendChunksAfterBlockAbility;
+    private static int uuidConvertAmount;
 
     public HiddenConfig(String fileName) {
         HiddenConfig.fileName = fileName;
@@ -33,6 +34,7 @@ public class HiddenConfig {
             conversionRate = config.getInt("Options.ConversionRate", 1);
             useEnchantmentBuffs = config.getBoolean("Options.EnchantmentBuffs", true);
             resendChunksAfterBlockAbility = config.getBoolean("Options.RefreshChunks", false);
+            uuidConvertAmount = config.getInt("Options.UUIDConvertAmount", 5);
         }
     }
 
@@ -51,4 +53,8 @@ public class HiddenConfig {
     public boolean resendChunksAfterBlockAbility() {
         return resendChunksAfterBlockAbility;
     }
+
+    public int getUUIDConvertAmount() {
+        return uuidConvertAmount;
+    }
 }

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

@@ -3,13 +3,18 @@ package com.gmail.nossr50.config.experience;
 import java.util.ArrayList;
 import java.util.List;
 
+import org.bukkit.GrassSpecies;
 import org.bukkit.Material;
+import org.bukkit.TreeSpecies;
 import org.bukkit.entity.EntityType;
+import org.bukkit.material.LongGrass;
+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 {
@@ -77,8 +82,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 */
@@ -103,9 +110,7 @@ public class ExperienceConfig extends AutoUpdateConfigLoader {
         }
 
         /* Fishing */
-        if (getFishingBaseXP() <= 0) {
-            reason.add("Experience.Fishing.Base should be greater than 0!");
-        }
+        // TODO: Add validation for each fish type once enum is available.
 
         if (getFishingShakeXP() <= 0) {
             reason.add("Experience.Fishing.Shake should be greater than 0!");
@@ -126,20 +131,12 @@ public class ExperienceConfig extends AutoUpdateConfigLoader {
         }
 
         /* Woodcutting */
-        if (getWoodcuttingXPOak() <= 0) {
-            reason.add("Experience.Woodcutting.Oak should be greater than 0!");
-        }
+        for (TreeSpecies species : TreeSpecies.values()) {
+            String key = "Experience.Woodcutting." + StringUtils.getPrettyTreeSpeciesString(species).replace(" ", "_");
 
-        if (getWoodcuttingXPBirch() <= 0) {
-            reason.add("Experience.Woodcutting.Birch should be greater than 0!");
-        }
-
-        if (getWoodcuttingXPSpruce() <= 0) {
-            reason.add("Experience.Woodcutting.Spruce should be greater than 0!");
-        }
-
-        if (getWoodcuttingXPJungle() <= 0) {
-            reason.add("Experience.Woodcutting.Jungle should be greater than 0!");
+            if (config.getInt(key) <= 0) {
+                reason.add(key + " should be greater than 0!");
+            }
         }
 
         if (getWoodcuttingXPHugeBrownMushroom() <= 0) {
@@ -164,7 +161,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); }
@@ -208,15 +205,119 @@ 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 getFishingBaseXP() { return config.getInt("Experience.Fishing.Base", 800); }
+    public int getFishXp(MaterialData data) {
+        switch (data.getData()) {
+            case 0x0:
+                return config.getInt("Experience.Fishing.Raw_Fish", 800);
+
+            case 0x1:
+                return config.getInt("Experience.Fishing.Raw_Salmon", 800);
+
+            case 0x2:
+                return config.getInt("Experience.Fishing.Clownfish", 800);
+
+            case 0x3:
+                return config.getInt("Experience.Fishing.Pufferfish", 800);
+
+            default:
+                return 0;
+        }
+    }
+
     public int getFishingShakeXP() { return config.getInt("Experience.Fishing.Shake", 50); }
 
+    /* Herbalism */
+    public int getFlowerAndGrassXp(MaterialData data) {
+        Material type = data.getItemType();
+
+        if (type == Material.RED_ROSE) {
+            switch (data.getData()) {
+                case 0x0:
+                    return config.getInt("Experience.Herbalism.Poppy", 100);
+
+                case 0x1:
+                    return config.getInt("Experience.Herbalism.Blue_Orchid", 150);
+
+                case 0x2:
+                    return config.getInt("Experience.Herbalism.Allium", 300);
+
+                case 0x3:
+                    return config.getInt("Experience.Herbalism.Azure_Bluet", 150);
+
+                case 0x4:
+                    return config.getInt("Experience.Herbalism.Red_Tulip", 150);
+
+                case 0x5:
+                    return config.getInt("Experience.Herbalism.Orange_Tulip", 150);
+
+                case 0x6:
+                    return config.getInt("Experience.Herbalism.White_Tulip", 150);
+
+                case 0x7:
+                    return config.getInt("Experience.Herbalism.Pink_Tulip", 150);
+
+                case 0x8:
+                    return config.getInt("Experience.Herbalism.Oxeye_Daisy", 150);
+
+                default:
+                    return 0;
+            }
+
+        }
+        else if (type == Material.LONG_GRASS) {
+            GrassSpecies species = ((LongGrass) data).getSpecies();
+            if (species == null) {
+                return 0;
+            }
+
+            switch (species) {
+                case DEAD:
+                    return config.getInt("Experience.Herbalism.Dead_Bush", 30);
+
+                case FERN_LIKE:
+                    return config.getInt("Experience.Herbalism.Small_Fern", 10);
+
+                case NORMAL:
+                    return config.getInt("Experience.Herbalism.Small_Grass", 10);
+
+                default:
+                    return 0;
+            }
+        }
+        else if (type == Material.DOUBLE_PLANT) {
+            switch (data.getData()) {
+                case 0x0:
+                    return config.getInt("Experience.Herbalism.Sunflower", 50);
+
+                case 0x1:
+                    return config.getInt("Experience.Herbalism.Lilac", 50);
+
+                case 0x2:
+                    return config.getInt("Experience.Herbalism.Tall_Grass", 50);
+
+                case 0x3:
+                    return config.getInt("Experience.Herbalism.Tall_Fern", 50);
+
+                case 0x4:
+                    return config.getInt("Experience.Herbalism.Rose_Bush", 50);
+
+                case 0x5:
+                    return config.getInt("Experience.Herbalism.Peony", 50);
+
+                default:
+                    return 0;
+            }
+        }
+
+        return 0;
+    }
+
     /* 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); }
@@ -224,10 +325,7 @@ public class ExperienceConfig extends AutoUpdateConfigLoader {
     public int getTamingXPOcelot() { return config.getInt("Experience.Taming.Animal_Taming.Ocelot", 500); }
 
     /* Woodcutting */
-    public int getWoodcuttingXPOak() { return config.getInt("Experience.Woodcutting.Oak", 70); }
-    public int getWoodcuttingXPBirch() { return config.getInt("Experience.Woodcutting.Birch", 90); }
-    public int getWoodcuttingXPSpruce() { return config.getInt("Experience.Woodcutting.Spruce", 80); }
-    public int getWoodcuttingXPJungle() { return config.getInt("Experience.Woodcutting.Jungle", 100); }
+    public int getWoodcuttingTreeXP(TreeSpecies species) { return config.getInt("Experience.Woodcutting." + StringUtils.getPrettyTreeSpeciesString(species).replace(" ", "_")); }
     public int getWoodcuttingXPHugeBrownMushroom() { return config.getInt("Experience.Woodcutting.Huge_Mushroom_Brown", 70); }
     public int getWoodcuttingXPHugeRedMushroom() { return config.getInt("Experience.Woodcutting.Huge_Mushroom_Red", 70); }
 }

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,19 +79,23 @@ 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);
                 }
 
+                String repairItemName = config.getString(armorType + "." + armorName + ".Repair_Material_Pretty_Name");
+                int repairMinimumLevel = config.getInt(armorType + "." + armorName + ".Repair_MinimumLevel", 0);
+                double repairXpMultiplier = config.getDouble(armorType + "." + armorName + ".Repair_XpMultiplier", 1);
+
                 short durability = armorMaterial.getMaxDurability();
 
                 if (durability == 0) {
                     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, repairItemName, repairMinimumLevel, repairQuantity, durability, ItemType.ARMOR, MaterialType.OTHER, repairXpMultiplier));
             }
 
             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,19 +87,23 @@ 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);
                 }
 
+                String repairItemName = config.getString(toolType + "." + toolName + ".Repair_Material_Pretty_Name");
+                int repairMinimumLevel = config.getInt(toolType + "." + toolName + ".Repair_MinimumLevel", 0);
+                double repairXpMultiplier = config.getDouble(toolType + "." + toolName + ".Repair_XpMultiplier", 1);
+
                 short durability = toolMaterial.getMaxDurability();
 
                 if (durability == 0) {
                     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, repairItemName, repairMinimumLevel, repairQuantity, durability, ItemType.TOOL, MaterialType.OTHER, repairXpMultiplier));
             }
 
             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

@@ -35,6 +35,8 @@ public class TreasureConfig extends ConfigLoader {
     public List<ExcavationTreasure> excavationFromMycel     = new ArrayList<ExcavationTreasure>();
     public List<ExcavationTreasure> excavationFromSoulSand  = new ArrayList<ExcavationTreasure>();
     public List<ExcavationTreasure> excavationFromSnow      = new ArrayList<ExcavationTreasure>();
+    public List<ExcavationTreasure> excavationFromRedSand   = new ArrayList<ExcavationTreasure>();
+    public List<ExcavationTreasure> excavationFromPodzol    = new ArrayList<ExcavationTreasure>();
 
     public List<HylianTreasure> hylianFromBushes  = new ArrayList<HylianTreasure>();
     public List<HylianTreasure> hylianFromFlowers = new ArrayList<HylianTreasure>();
@@ -158,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) {
@@ -226,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);
@@ -236,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();
@@ -250,17 +255,17 @@ 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();
-                    itemMeta.setDisplayName(config.getString(type + "." + treasureName + "Custom_Name"));
+                    itemMeta.setDisplayName(config.getString(type + "." + treasureName + ".Custom_Name"));
                     item.setItemMeta(itemMeta);
                 }
 
                 if (config.contains(type + "." + treasureName + ".Lore")) {
                     ItemMeta itemMeta = item.getItemMeta();
-                    itemMeta.setLore(config.getStringList(type + "." + treasureName + "Custom_Name"));
+                    itemMeta.setLore(config.getStringList(type + "." + treasureName + ".Lore"));
                     item.setItemMeta(itemMeta);
                 }
             }
@@ -371,6 +376,14 @@ public class TreasureConfig extends ConfigLoader {
                     if (dropList.contains("Snow")) {
                         excavationFromSnow.add(excavationTreasure);
                     }
+
+                    if (dropList.contains("Red_Sand")) {
+                        excavationFromRedSand.add(excavationTreasure);
+                    }
+
+                    if (dropList.contains("Podzol")) {
+                        excavationFromPodzol.add(excavationTreasure);
+                    }
                 }
                 else if (isHylian) {
                     HylianTreasure hylianTreasure = new HylianTreasure(item, xp, dropChance, dropLevel);

src/main/java/com/gmail/nossr50/database/DatabaseManager.java

@@ -2,6 +2,7 @@ package com.gmail.nossr50.database;
 
 import java.util.List;
 import java.util.Map;
+import java.util.UUID;
 
 import com.gmail.nossr50.config.Config;
 import com.gmail.nossr50.datatypes.database.DatabaseType;
@@ -67,19 +68,42 @@ public interface DatabaseManager {
      *
      * @param playerName The name of the player to be added to the database
      */
-    public void newUser(String playerName);
+    public void newUser(String playerName, String uuid);
 
     /**
      * Load a player from the database.
      *
+     * @deprecated replaced by {@link #loadPlayerProfile(String playerName, UUID uuid, boolean createNew)}
+     *
      * @param playerName The name of the player to load from the database
      * @param createNew Whether to create a new record if the player is not
      *          found
      * @return The player's data, or an unloaded PlayerProfile if not found
      *          and createNew is false
      */
+    @Deprecated
     public PlayerProfile loadPlayerProfile(String playerName, boolean createNew);
 
+    /**
+     * Load a player from the database.
+     *
+     * @param uuid The uuid of the player to load from the database
+     * @return The player's data, or an unloaded PlayerProfile if not found
+     */
+    public PlayerProfile loadPlayerProfile(UUID uuid);
+
+    /**
+     * Load a player from the database. Attempt to use uuid, fall back on playername
+     *
+     * @param playerName The name of the player to load from the database
+     * @param uuid The uuid of the player to load from the database
+     * @param createNew Whether to create a new record if the player is not
+     *          found
+     * @return The player's data, or an unloaded PlayerProfile if not found
+     *          and createNew is false
+     */
+    public PlayerProfile loadPlayerProfile(String playerName, UUID uuid, boolean createNew);
+
     /**
      * Get all users currently stored in the database.
      *
@@ -95,10 +119,19 @@ public interface DatabaseManager {
      */
     public void convertUsers(DatabaseManager destination);
 
+    public boolean saveUserUUID(String userName, UUID uuid);
+
+    public boolean saveUserUUIDs(Map<String, UUID> fetchedUUIDs);
+
     /**
      * Retrieve the type of database in use. Custom databases should return CUSTOM.
      *
      * @return The type of database
      */
     public DatabaseType getDatabaseType();
+
+    /**
+     * Called when the plugin disables
+     */
+    public void onDisable();
 }

src/main/java/com/gmail/nossr50/database/FlatfileDatabaseManager.java

@@ -2,7 +2,6 @@ package com.gmail.nossr50.database;
 
 import java.io.BufferedReader;
 import java.io.BufferedWriter;
-import java.io.Closeable;
 import java.io.File;
 import java.io.FileReader;
 import java.io.FileWriter;
@@ -10,10 +9,12 @@ import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Comparator;
+import java.util.EnumMap;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.UUID;
 
 import org.bukkit.OfflinePlayer;
 
@@ -22,9 +23,11 @@ import com.gmail.nossr50.config.Config;
 import com.gmail.nossr50.datatypes.MobHealthbarType;
 import com.gmail.nossr50.datatypes.database.DatabaseType;
 import com.gmail.nossr50.datatypes.database.PlayerStat;
+import com.gmail.nossr50.datatypes.database.UpgradeType;
 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.runnables.database.UUIDUpdateAsyncTask;
 import com.gmail.nossr50.util.Misc;
 import com.gmail.nossr50.util.StringUtils;
 
@@ -43,6 +46,10 @@ public final class FlatfileDatabaseManager implements DatabaseManager {
         usersFile = new File(mcMMO.getUsersFilePath());
         checkStructure();
         updateLeaderboards();
+
+        if (mcMMO.getUpgradeManager().shouldUpgrade(UpgradeType.ADD_UUIDS)) {
+            new UUIDUpdateAsyncTask(mcMMO.p, getStoredUsers()).runTaskAsynchronously(mcMMO.p);
+        }
     }
 
     public void purgePowerlessUsers() {
@@ -91,8 +98,22 @@ public final class FlatfileDatabaseManager implements DatabaseManager {
                 mcMMO.p.getLogger().severe("Exception while reading " + usersFilePath + " (Are you sure you formatted it correctly?)" + e.toString());
             }
             finally {
-                tryClose(in);
-                tryClose(out);
+                if (in != null) {
+                    try {
+                        in.close();
+                    }
+                    catch (IOException e) {
+                        // Ignore
+                    }
+                }
+                if (out != null) {
+                    try {
+                        out.close();
+                    }
+                    catch (IOException e) {
+                        // Ignore
+                    }
+                }
             }
         }
 
@@ -157,8 +178,22 @@ public final class FlatfileDatabaseManager implements DatabaseManager {
                 mcMMO.p.getLogger().severe("Exception while reading " + usersFilePath + " (Are you sure you formatted it correctly?)" + e.toString());
             }
             finally {
-                tryClose(in);
-                tryClose(out);
+                if (in != null) {
+                    try {
+                        in.close();
+                    }
+                    catch (IOException e) {
+                        // Ignore
+                    }
+                }
+                if (out != null) {
+                    try {
+                        out.close();
+                    }
+                    catch (IOException e) {
+                        // Ignore
+                    }
+                }
             }
         }
 
@@ -196,8 +231,22 @@ public final class FlatfileDatabaseManager implements DatabaseManager {
                 mcMMO.p.getLogger().severe("Exception while reading " + usersFilePath + " (Are you sure you formatted it correctly?)" + e.toString());
             }
             finally {
-                tryClose(in);
-                tryClose(out);
+                if (in != null) {
+                    try {
+                        in.close();
+                    }
+                    catch (IOException e) {
+                        // Ignore
+                    }
+                }
+                if (out != null) {
+                    try {
+                        out.close();
+                    }
+                    catch (IOException e) {
+                        // Ignore
+                    }
+                }
             }
         }
 
@@ -208,6 +257,7 @@ public final class FlatfileDatabaseManager implements DatabaseManager {
 
     public boolean saveUser(PlayerProfile profile) {
         String playerName = profile.getPlayerName();
+        UUID uuid = profile.getUniqueId();
 
         BufferedReader in = null;
         FileWriter out = null;
@@ -222,8 +272,9 @@ public final class FlatfileDatabaseManager implements DatabaseManager {
 
                 // While not at the end of the file
                 while ((line = in.readLine()) != null) {
-                    // Read the line in and copy it to the output it's not the player we want to edit
-                    if (!line.split(":")[0].equalsIgnoreCase(playerName)) {
+                    // Read the line in and copy it to the output if it's not the player we want to edit
+                    String[] character = line.split(":");
+                    if (!character[41].equalsIgnoreCase(uuid.toString()) && !character[0].equalsIgnoreCase(playerName)) {
                         writer.append(line).append("\r\n");
                     }
                     else {
@@ -270,6 +321,7 @@ public final class FlatfileDatabaseManager implements DatabaseManager {
                         writer.append(mobHealthbarType == null ? Config.getInstance().getMobHealthbarDefault().toString() : mobHealthbarType.toString()).append(":");
                         writer.append(profile.getSkillLevel(SkillType.ALCHEMY)).append(":");
                         writer.append(profile.getSkillXpLevel(SkillType.ALCHEMY)).append(":");
+                        writer.append(uuid.toString()).append(":");
                         writer.append("\r\n");
                     }
                 }
@@ -284,8 +336,22 @@ public final class FlatfileDatabaseManager implements DatabaseManager {
                 return false;
             }
             finally {
-                tryClose(in);
-                tryClose(out);
+                if (in != null) {
+                    try {
+                        in.close();
+                    }
+                    catch (IOException e) {
+                        // Ignore
+                    }
+                }
+                if (out != null) {
+                    try {
+                        out.close();
+                    }
+                    catch (IOException e) {
+                        // Ignore
+                    }
+                }
             }
         }
     }
@@ -301,7 +367,7 @@ public final class FlatfileDatabaseManager implements DatabaseManager {
     public Map<SkillType, Integer> readRank(String playerName) {
         updateLeaderboards();
 
-        Map<SkillType, Integer> skills = new HashMap<SkillType, Integer>();
+        Map<SkillType, Integer> skills = new EnumMap<SkillType, Integer>(SkillType.class);
 
         for (SkillType skill : SkillType.NON_CHILD_SKILLS) {
             skills.put(skill, getPlayerRank(playerName, playerStatHash.get(skill)));
@@ -312,7 +378,7 @@ public final class FlatfileDatabaseManager implements DatabaseManager {
         return skills;
     }
 
-    public void newUser(String playerName) {
+    public void newUser(String playerName, String uuid) {
         BufferedWriter out = null;
         synchronized (fileWritingLock) {
             try {
@@ -361,7 +427,8 @@ public final class FlatfileDatabaseManager implements DatabaseManager {
                 out.append(Config.getInstance().getMobHealthbarDefault().toString()).append(":"); // Mob Healthbar HUD
                 out.append("0:"); // Alchemy
                 out.append("0:"); // AlchemyXp
-                
+                out.append(uuid).append(":"); // UUID
+
                 // Add more in the same format as the line above
 
                 out.newLine();
@@ -370,12 +437,32 @@ public final class FlatfileDatabaseManager implements DatabaseManager {
                 e.printStackTrace();
             }
             finally {
-                tryClose(out);
+                if (out != null) {
+                    try {
+                        out.close();
+                    }
+                    catch (IOException e) {
+                        // Ignore
+                    }
+                }
             }
         }
     }
 
+    @Deprecated
     public PlayerProfile loadPlayerProfile(String playerName, boolean create) {
+        return loadPlayerProfile(playerName, "", false);
+    }
+
+    public PlayerProfile loadPlayerProfile(UUID uuid) {
+        return loadPlayerProfile("", uuid.toString(), false);
+    }
+
+    public PlayerProfile loadPlayerProfile(String playerName, UUID uuid, boolean create) {
+        return loadPlayerProfile(playerName, uuid.toString(), create);
+    }
+
+    private PlayerProfile loadPlayerProfile(String playerName, String uuid, boolean create) {
         BufferedReader in = null;
         String usersFilePath = mcMMO.getUsersFilePath();
 
@@ -389,17 +476,28 @@ public final class FlatfileDatabaseManager implements DatabaseManager {
                     // Find if the line contains the player we want.
                     String[] character = line.split(":");
 
-                    if (!character[0].equalsIgnoreCase(playerName)) {
+                    if (!character[41].equalsIgnoreCase(uuid) && !character[0].equalsIgnoreCase(playerName)) {
                         continue;
                     }
 
+                    // Update playerName in database after name change
+                    if (!character[0].equalsIgnoreCase(playerName)) {
+                        mcMMO.p.debug("Name change detected: " + character[0] + " => " + playerName);
+                        character[0] = playerName;
+                    }
+
                     return loadFromLine(character);
                 }
 
                 // Didn't find the player, create a new one
                 if (create) {
-                    newUser(playerName);
-                    return new PlayerProfile(playerName, true);
+                    if (uuid.isEmpty()) {
+                        newUser(playerName, uuid);
+                        return new PlayerProfile(playerName, true);
+                    }
+
+                    newUser(playerName, uuid);
+                    return new PlayerProfile(playerName, UUID.fromString(uuid), true);
                 }
             }
             catch (Exception e) {
@@ -413,14 +511,18 @@ public final class FlatfileDatabaseManager implements DatabaseManager {
                         in.close();
                     }
                     catch (IOException e) {
-                        e.printStackTrace();
+                        // Ignore
                     }
                 }
             }
         }
 
         // Return unloaded profile
-        return new PlayerProfile(playerName);
+        if (uuid.isEmpty()) {
+            return new PlayerProfile(playerName);
+        }
+
+        return new PlayerProfile(playerName, UUID.fromString(uuid));
     }
 
     public void convertUsers(DatabaseManager destination) {
@@ -452,11 +554,131 @@ public final class FlatfileDatabaseManager implements DatabaseManager {
                 e.printStackTrace();
             }
             finally {
-                tryClose(in);
+                if (in != null) {
+                    try {
+                        in.close();
+                    }
+                    catch (IOException e) {
+                        // Ignore
+                    }
+                }
             }
         }
     }
 
+    public boolean saveUserUUID(String userName, UUID uuid) {
+        boolean worked = false;
+
+        BufferedReader in = null;
+        FileWriter out = null;
+        String usersFilePath = mcMMO.getUsersFilePath();
+
+        synchronized (fileWritingLock) {
+            try {
+                in = new BufferedReader(new FileReader(usersFilePath));
+                StringBuilder writer = new StringBuilder();
+                String line;
+
+                while ((line = in.readLine()) != null) {
+                    String[] character = line.split(":");
+                    if (!worked && character[0].equalsIgnoreCase(userName)) {
+                        if (character.length < 42) {
+                            mcMMO.p.getLogger().severe("Could not update UUID for " + userName + "!");
+                            mcMMO.p.getLogger().severe("Database entry is invalid.");
+                            break;
+                        }
+
+                        line = line.replace(character[41], uuid.toString());
+                        worked = true;
+                    }
+
+                    writer.append(line).append("\r\n");
+                }
+
+                out = new FileWriter(usersFilePath); // Write out the new file
+                out.write(writer.toString());
+            }
+            catch (Exception e) {
+                mcMMO.p.getLogger().severe("Exception while reading " + usersFilePath + " (Are you sure you formatted it correctly?)" + e.toString());
+            }
+            finally {
+                if (in != null) {
+                    try {
+                        in.close();
+                    }
+                    catch (IOException e) {
+                        // Ignore
+                    }
+                }
+                if (out != null) {
+                    try {
+                        out.close();
+                    }
+                    catch (IOException e) {
+                        // Ignore
+                    }
+                }
+            }
+        }
+
+        return worked;
+    }
+
+    public boolean saveUserUUIDs(Map<String, UUID> fetchedUUIDs) {
+        BufferedReader in = null;
+        FileWriter out = null;
+        String usersFilePath = mcMMO.getUsersFilePath();
+
+        synchronized (fileWritingLock) {
+            try {
+                in = new BufferedReader(new FileReader(usersFilePath));
+                StringBuilder writer = new StringBuilder();
+                String line;
+
+                while (((line = in.readLine()) != null) && !fetchedUUIDs.isEmpty()) {
+                    String[] character = line.split(":");
+                    if (fetchedUUIDs.containsKey(character[0])) {
+                        if (character.length < 42) {
+                            mcMMO.p.getLogger().severe("Could not update UUID for " + character[0] + "!");
+                            mcMMO.p.getLogger().severe("Database entry is invalid.");
+                            return false;
+                        }
+
+                        line = line.replace(character[41], fetchedUUIDs.remove(character[0]).toString());
+                    }
+
+                    writer.append(line).append("\r\n");
+                }
+
+                out = new FileWriter(usersFilePath); // Write out the new file
+                out.write(writer.toString());
+            }
+            catch (Exception e) {
+                mcMMO.p.getLogger().severe("Exception while reading " + usersFilePath + " (Are you sure you formatted it correctly?)" + e.toString());
+            }
+            finally {
+                if (in != null) {
+                    try {
+                        in.close();
+                    }
+                    catch (IOException e) {
+                        // Ignore
+                    }
+                }
+                if (out != null) {
+                    try {
+                        out.close();
+                    }
+                    catch (IOException e) {
+                        // Ignore
+                    }
+                }
+            }
+        }
+
+        return true;
+    }
+
     public List<String> getStoredUsers() {
         ArrayList<String> users = new ArrayList<String>();
         BufferedReader in = null;
@@ -477,7 +699,14 @@ public final class FlatfileDatabaseManager implements DatabaseManager {
                 e.printStackTrace();
             }
             finally {
-                tryClose(in);
+                if (in != null) {
+                    try {
+                        in.close();
+                    }
+                    catch (IOException e) {
+                        // Ignore
+                    }
+                }
             }
         }
         return users;
@@ -547,7 +776,14 @@ public final class FlatfileDatabaseManager implements DatabaseManager {
                 mcMMO.p.getLogger().severe("Exception while reading " + usersFilePath + " during user " + playerName + " (Are you sure you formatted it correctly?) " + e.toString());
             }
             finally {
-                tryClose(in);
+                if (in != null) {
+                    try {
+                        in.close();
+                    }
+                    catch (IOException e) {
+                        // Ignore
+                    }
+                }
             }
         }
 
@@ -597,6 +833,7 @@ public final class FlatfileDatabaseManager implements DatabaseManager {
                     in = new BufferedReader(new FileReader(usersFilePath));
                     StringBuilder writer = new StringBuilder();
                     String line;
+                    HashSet<String> usernames = new HashSet<String>();
                     HashSet<String> players = new HashSet<String>();
 
                     while ((line = in.readLine()) != null) {
@@ -611,8 +848,13 @@ public final class FlatfileDatabaseManager implements DatabaseManager {
                         }
                         String[] character = line.split(":");
 
+                        // Prevent the same username from being present multiple times
+                        if (!usernames.add(character[0])) {
+                            continue;
+                        }
+
                         // Prevent the same player from being present multiple times
-                        if (!players.add(character[0])) {
+                        if (character.length == 42 && (!character[41].isEmpty() && !players.add(character[41]))) {
                             continue;
                         }
 
@@ -644,7 +886,7 @@ public final class FlatfileDatabaseManager implements DatabaseManager {
                         }
 
                         // If they're valid, rewrite them to the file.
-                        if (character.length == 41) {
+                        if (character.length == 42) {
                             writer.append(line).append("\r\n");
                             continue;
                         }
@@ -698,16 +940,25 @@ public final class FlatfileDatabaseManager implements DatabaseManager {
                                 oldVersion = "1.4.08";
                             }
                         }
+                        if (character.length <= 41) {
+                            // Addition of UUIDs
+                            // Version 1.5.01
+                            // Add a space because otherwise it gets removed
+                            newLine.append(" :");
+                            if (oldVersion == null) {
+                                oldVersion = "1.5.01";
+                            }
+                        }
 
                         // Remove any blanks that shouldn't be there, and validate the other fields
                         String[] newCharacter = newLine.toString().split(":");
                         boolean corrupted = false;
 
                         for (int i = 0; i < newCharacter.length; i++) {
-                            if (newCharacter[i].isEmpty() && !(i == 2 || i == 3 || i == 23 || i == 33)) {
+                            if (newCharacter[i].isEmpty() && !(i == 2 || i == 3 || i == 23 || i == 33 || i == 41)) {
                                 corrupted = true;
 
-                                if (newCharacter.length != 41) {
+                                if (newCharacter.length != 42) {
                                     newCharacter = (String[]) ArrayUtils.remove(newCharacter, i);
                                 }
                                 else {
@@ -728,7 +979,7 @@ public final class FlatfileDatabaseManager implements DatabaseManager {
                                 newCharacter[i] = Config.getInstance().getMobHealthbarDefault().toString();
                             }
 
-                            if (!StringUtils.isInt(newCharacter[i]) && !(i == 0 || i == 2 || i == 3 || i == 23 || i == 33 || i == 38)) {
+                            if (!StringUtils.isInt(newCharacter[i]) && !(i == 0 || i == 2 || i == 3 || i == 23 || i == 33 || i == 38 || i == 41)) {
                                 corrupted = true;
                                 newCharacter[i] = "0";
                             }
@@ -736,11 +987,15 @@ public final class FlatfileDatabaseManager implements DatabaseManager {
 
                         if (corrupted) {
                             mcMMO.p.debug("Updating corrupted database line for player " + newCharacter[0]);
-                            newLine = new StringBuilder(org.apache.commons.lang.StringUtils.join(newCharacter, ":"));
                         }
 
                         if (oldVersion != null) {
-                            mcMMO.p.debug("Updating database line for player " + character[0] + " from before version " + oldVersion);
+                            mcMMO.p.debug("Updating database line from before version " + oldVersion + " for player " + character[0]);
+                        }
+
+                        if (corrupted || oldVersion != null) {
+                            newLine = new StringBuilder(org.apache.commons.lang.StringUtils.join(newCharacter, ":"));
+                            newLine = newLine.append(":");
                         }
 
                         writer.append(newLine).append("\r\n");
@@ -754,10 +1009,32 @@ public final class FlatfileDatabaseManager implements DatabaseManager {
                     mcMMO.p.getLogger().severe("Exception while reading " + usersFilePath + " (Are you sure you formatted it correctly?)" + e.toString());
                 }
                 finally {
-                    tryClose(in);
-                    tryClose(out);
+                    if (in != null) {
+                        try {
+                            in.close();
+                        }
+                        catch (IOException e) {
+                            // Ignore
+                        }
+                    }
+                    if (out != null) {
+                        try {
+                            out.close();
+                        }
+                        catch (IOException e) {
+                            // Ignore
+                        }
+                    }
                 }
             }
+
+            mcMMO.getUpgradeManager().setUpgradeCompleted(UpgradeType.ADD_FISHING);
+            mcMMO.getUpgradeManager().setUpgradeCompleted(UpgradeType.ADD_BLAST_MINING_COOLDOWN);
+            mcMMO.getUpgradeManager().setUpgradeCompleted(UpgradeType.ADD_SQL_INDEXES);
+            mcMMO.getUpgradeManager().setUpgradeCompleted(UpgradeType.ADD_MOB_HEALTHBARS);
+            mcMMO.getUpgradeManager().setUpgradeCompleted(UpgradeType.DROP_SQL_PARTY_NAMES);
+            mcMMO.getUpgradeManager().setUpgradeCompleted(UpgradeType.DROP_SPOUT);
+            mcMMO.getUpgradeManager().setUpgradeCompleted(UpgradeType.ADD_ALCHEMY);
             return;
         }
 
@@ -772,18 +1049,6 @@ public final class FlatfileDatabaseManager implements DatabaseManager {
         }
     }
 
-    private void tryClose(Closeable c) {
-        if (c == null) {
-            return;
-        }
-        try {
-            c.close();
-        }
-        catch (IOException e) {
-            e.printStackTrace();
-        }
-    }
-
     private Integer getPlayerRank(String playerName, List<PlayerStat> statsList) {
         if (statsList == null) {
             return null;
@@ -816,8 +1081,8 @@ public final class FlatfileDatabaseManager implements DatabaseManager {
 
     private PlayerProfile loadFromLine(String[] character) {
         Map<SkillType, Integer>   skills     = getSkillMapFromLine(character);      // Skill levels
-        Map<SkillType, Float>     skillsXp   = new HashMap<SkillType, Float>();     // Skill & XP
-        Map<AbilityType, Integer> skillsDATS = new HashMap<AbilityType, Integer>(); // Ability & Cooldown
+        Map<SkillType, Float>     skillsXp   = new EnumMap<SkillType, Float>(SkillType.class);     // Skill & XP
+        Map<AbilityType, Integer> skillsDATS = new EnumMap<AbilityType, Integer>(AbilityType.class); // Ability & Cooldown
         MobHealthbarType mobHealthbarType;
 
         // TODO on updates, put new values in a try{} ?
@@ -856,11 +1121,19 @@ public final class FlatfileDatabaseManager implements DatabaseManager {
             mobHealthbarType = Config.getInstance().getMobHealthbarDefault();
         }
 
-        return new PlayerProfile(character[0], skills, skillsXp, skillsDATS, mobHealthbarType);
+        UUID uuid;
+        try {
+            uuid = UUID.fromString(character[41]);
+        }
+        catch (Exception e) {
+            uuid = null;
+        }
+
+        return new PlayerProfile(character[0], uuid, skills, skillsXp, skillsDATS, mobHealthbarType);
     }
 
     private Map<SkillType, Integer> getSkillMapFromLine(String[] character) {
-        Map<SkillType, Integer> skills = new HashMap<SkillType, Integer>();   // Skill & Level
+        Map<SkillType, Integer> skills = new EnumMap<SkillType, Integer>(SkillType.class);   // Skill & Level
 
         skills.put(SkillType.TAMING, Integer.valueOf(character[24]));
         skills.put(SkillType.MINING, Integer.valueOf(character[1]));
@@ -882,4 +1155,7 @@ public final class FlatfileDatabaseManager implements DatabaseManager {
     public DatabaseType getDatabaseType() {
         return DatabaseType.FLATFILE;
     }
+
+    @Override
+    public void onDisable() { }
 }

src/main/java/com/gmail/nossr50/datatypes/database/DatabaseUpdateType.java

@@ -1,13 +0,0 @@
-package com.gmail.nossr50.datatypes.database;
-
-public enum DatabaseUpdateType {
-    FISHING,
-    BLAST_MINING,
-    INDEX,
-    MOB_HEALTHBARS,
-    PARTY_NAMES,
-    KILL_ORPHANS,
-    DROPPED_SPOUT,
-    ALCHEMY
-    ;
-}

src/main/java/com/gmail/nossr50/datatypes/database/UpgradeType.java

@@ -0,0 +1,12 @@
+package com.gmail.nossr50.datatypes.database;
+
+public enum UpgradeType {
+    ADD_FISHING,
+    ADD_BLAST_MINING_COOLDOWN,
+    ADD_SQL_INDEXES,
+    ADD_MOB_HEALTHBARS,
+    DROP_SQL_PARTY_NAMES,
+    DROP_SPOUT,
+    ADD_ALCHEMY,
+    ADD_UUIDS;
+}

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

@@ -3,6 +3,7 @@ package com.gmail.nossr50.datatypes.player;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Set;
+import java.util.UUID;
 
 import org.bukkit.GameMode;
 import org.bukkit.Location;
@@ -24,6 +25,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 +42,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;
@@ -90,15 +93,20 @@ public class McMMOPlayer {
     private boolean isUsingUnarmed;
     private final FixedMetadataValue playerMetadata;
 
-    public McMMOPlayer(Player player) {
+    public McMMOPlayer(Player player, PlayerProfile profile) {
         String playerName = player.getName();
+        UUID uuid = player.getUniqueId();
 
         this.player = player;
         playerMetadata = new FixedMetadataValue(mcMMO.p, playerName);
-        profile = mcMMO.getDatabaseManager().loadPlayerProfile(playerName, true);
+        this.profile = profile;
         party = PartyManager.getPlayerParty(playerName);
         ptpRecord = new PartyTeleportRecord();
 
+        if (profile.getUniqueId() == null) {
+            profile.setUniqueId(uuid);
+        }
+
         /*
          * I'm using this method because it makes code shorter and safer (we don't have to add all SkillTypes manually),
          * but I actually have no idea about the performance impact, if there is any.
@@ -122,69 +130,6 @@ public class McMMOPlayer {
         for (ToolType toolType : ToolType.values()) {
             toolMode.put(toolType, false);
         }
-
-        if (!profile.isLoaded()) {
-            mcMMO.p.getLogger().warning("Unable to load the PlayerProfile for " + playerName + ". Will retry over the next several seconds.");
-            new RetryProfileLoadingTask().runTaskTimerAsynchronously(mcMMO.p, 11L, 31L);
-        }
-    }
-
-    private class RetryProfileLoadingTask extends BukkitRunnable {
-        private static final int MAX_TRIES = 5;
-        private final String playerName = McMMOPlayer.this.player.getName();
-        private int attempt = 0;
-
-        // WARNING: ASYNC TASK
-        // DO NOT MODIFY THE McMMOPLAYER FROM THIS CODE
-        @Override
-        public void run() {
-            // Quit if they logged out
-            if (!player.isOnline()) {
-                mcMMO.p.getLogger().info("Aborting profile loading recovery for " + playerName + " - player logged out");
-                this.cancel();
-                return;
-            }
-
-            // Send the message that we're doing the recovery
-            if (attempt == 0) {
-                player.sendMessage(LocaleLoader.getString("Recovery.Notice"));
-            }
-
-            // Increment attempt counter and try
-            attempt++;
-            PlayerProfile profile = mcMMO.getDatabaseManager().loadPlayerProfile(playerName, true);
-            // If successful, schedule the apply
-            if (profile.isLoaded()) {
-                new ApplySuccessfulProfile(profile).runTask(mcMMO.p);
-                player.sendMessage(LocaleLoader.getString("Recovery.Success"));
-                this.cancel();
-                return;
-            }
-
-            // If we've failed five times, give up
-            if (attempt >= MAX_TRIES) {
-                mcMMO.p.getLogger().severe("Giving up on attempting to load the PlayerProfile for " + playerName);
-                mcMMO.p.getServer().broadcast(LocaleLoader.getString("Recovery.AdminFailureNotice", playerName), Server.BROADCAST_CHANNEL_ADMINISTRATIVE);
-                player.sendMessage(LocaleLoader.getString("Recovery.Failure").split("\n"));
-                this.cancel();
-                return;
-            }
-        }
-    }
-
-    private class ApplySuccessfulProfile extends BukkitRunnable {
-        private final PlayerProfile profile;
-
-        private ApplySuccessfulProfile(PlayerProfile profile) {
-            this.profile = profile;
-        }
-
-        // Synchronized task
-        // No database access permitted
-        @Override
-        public void run() {
-            McMMOPlayer.this.profile = profile;
-        }
     }
 
     public AcrobaticsManager getAcrobaticsManager() {
@@ -223,6 +168,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 +402,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 +415,7 @@ public class McMMOPlayer {
 
             for (SkillType parentSkill : parentSkills) {
                 if (parentSkill.getPermissions(player)) {
-                    beginXpGain(parentSkill, splitXp);
+                    beginXpGain(parentSkill, splitXp, xpGainReason);
                 }
             }
 
@@ -474,11 +423,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 +436,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 +454,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 +463,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 +482,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 +500,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

@@ -3,6 +3,7 @@ package com.gmail.nossr50.datatypes.player;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Set;
+import java.util.UUID;
 
 import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.config.Config;
@@ -11,6 +12,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;
 
@@ -18,8 +20,9 @@ import com.google.common.collect.ImmutableMap;
 
 public class PlayerProfile {
     private final String playerName;
+    private UUID uuid;
     private boolean loaded;
-    private boolean changed;
+    private volatile boolean changed;
 
     /* HUDs */
     private MobHealthbarType mobHealthbarType;
@@ -29,7 +32,13 @@ public class PlayerProfile {
     private final Map<SkillType, Float>     skillsXp   = new HashMap<SkillType, Float>();     // Skill & XP
     private final Map<AbilityType, Integer> abilityDATS = new HashMap<AbilityType, Integer>(); // Ability & Cooldown
 
+    @Deprecated
     public PlayerProfile(String playerName) {
+        this(playerName, null);
+    }
+
+    public PlayerProfile(String playerName, UUID uuid) {
+        this.uuid = uuid;
         this.playerName = playerName;
 
         mobHealthbarType = Config.getInstance().getMobHealthbarDefault();
@@ -44,13 +53,20 @@ public class PlayerProfile {
         }
     }
 
+    @Deprecated
     public PlayerProfile(String playerName, boolean isLoaded) {
         this(playerName);
         this.loaded = isLoaded;
     }
 
-    public PlayerProfile(String playerName, Map<SkillType, Integer> levelData, Map<SkillType, Float> xpData, Map<AbilityType, Integer> cooldownData, MobHealthbarType mobHealthbarType) {
+    public PlayerProfile(String playerName, UUID uuid, boolean isLoaded) {
+        this(playerName, uuid);
+        this.loaded = isLoaded;
+    }
+
+    public PlayerProfile(String playerName, UUID uuid, Map<SkillType, Integer> levelData, Map<SkillType, Float> xpData, Map<AbilityType, Integer> cooldownData, MobHealthbarType mobHealthbarType) {
         this.playerName = playerName;
+        this.uuid = uuid;
         this.mobHealthbarType = mobHealthbarType;
 
         skills.putAll(levelData);
@@ -60,15 +76,21 @@ 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, uuid, 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");
+            mcMMO.p.getLogger().warning("PlayerProfile saving failed for player: " + playerName + " " + uuid);
         }
     }
 
@@ -76,6 +98,16 @@ public class PlayerProfile {
         return playerName;
     }
 
+    public UUID getUniqueId() {
+        return uuid;
+    }
+
+    public void setUniqueId(UUID uuid) {
+        changed = true;
+
+        this.uuid = uuid;
+    }
+
     public boolean isLoaded() {
         return loaded;
     }

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/AlchemyPotion.java

@@ -7,6 +7,7 @@ import java.util.Map.Entry;
 import org.bukkit.Material;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.inventory.meta.PotionMeta;
+import org.bukkit.potion.Potion;
 import org.bukkit.potion.PotionEffect;
 
 public class AlchemyPotion {
@@ -50,6 +51,10 @@ public class AlchemyPotion {
         return potion;
     }
 
+    public Potion toPotion(int amount) {
+        return Potion.fromItemStack(this.toItemStack(amount));
+    }
+
     public short getDataValue() {
         return dataValue;
     }

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

@@ -0,0 +1,72 @@
+package com.gmail.nossr50.datatypes.skills.alchemy;
+
+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 (!isWaterBottle(input) && getPotionStage(input) == potionStage) {
+            potionStage = PotionStage.FIVE;
+        }
+
+        return potionStage;
+    }
+
+    private static boolean isWaterBottle(AlchemyPotion input) {
+        return input.getDataValue() == 0;
+    }
+
+    public static PotionStage getPotionStage(AlchemyPotion alchemyPotion) {
+        Potion potion = alchemyPotion.toPotion(1);
+
+        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/FakeBrewEvent.java

@@ -0,0 +1,11 @@
+package com.gmail.nossr50.events.fake;
+
+import org.bukkit.block.Block;
+import org.bukkit.event.inventory.BrewEvent;
+import org.bukkit.inventory.BrewerInventory;
+
+public class FakeBrewEvent extends BrewEvent {
+    public FakeBrewEvent(Block brewer, BrewerInventory contents) {
+        super(brewer, contents);
+    }
+}

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

@@ -1,13 +1,36 @@
 package com.gmail.nossr50.events.fake;
 
+import java.util.EnumMap;
+import java.util.Map;
+
 import org.bukkit.entity.Entity;
 import org.bukkit.event.entity.EntityDamageByEntityEvent;
 
+import com.google.common.base.Function;
+import com.google.common.base.Functions;
+
 /**
  * Called when mcMMO applies damage from an entity due to special abilities.
  */
 public class FakeEntityDamageByEntityEvent extends EntityDamageByEntityEvent {
+
+    public FakeEntityDamageByEntityEvent(Entity damager, Entity damagee, DamageCause cause, final Map<DamageModifier, Double> modifiers) {
+        super(damager, damagee, cause, modifiers, getFunctionModifiers(modifiers));
+    }
+
+    @Deprecated
     public FakeEntityDamageByEntityEvent(Entity damager, Entity damagee, DamageCause cause, double damage) {
         super(damager, damagee, cause, damage);
     }
+
+    public static EnumMap<DamageModifier, Function<? super Double, Double>> getFunctionModifiers(Map<DamageModifier, Double> modifiers) {
+        EnumMap<DamageModifier, Function<? super Double, Double>> modifierFunctions = new EnumMap<DamageModifier, Function<? super Double, Double>>(DamageModifier.class);
+        Function<? super Double, Double> ZERO = Functions.constant(-0.0);
+
+        for (DamageModifier modifier : modifiers.keySet()) {
+            modifierFunctions.put(modifier, ZERO);
+        }
+
+        return modifierFunctions;
+    }
 }

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

@@ -1,13 +1,36 @@
 package com.gmail.nossr50.events.fake;
 
+import java.util.EnumMap;
+import java.util.Map;
+
 import org.bukkit.entity.Entity;
 import org.bukkit.event.entity.EntityDamageEvent;
 
+import com.google.common.base.Function;
+import com.google.common.base.Functions;
+
 /**
  * Called when mcMMO applies damage due to special abilities.
  */
 public class FakeEntityDamageEvent extends EntityDamageEvent {
+
+    public FakeEntityDamageEvent(Entity damagee, DamageCause cause, final Map<DamageModifier, Double> modifiers) {
+        super(damagee, cause, modifiers, getFunctionModifiers(modifiers));
+    }
+
+    @Deprecated
     public FakeEntityDamageEvent(Entity damagee, DamageCause cause, double damage) {
         super(damagee, cause, damage);
     }
+
+    public static EnumMap<DamageModifier, Function<? super Double, Double>> getFunctionModifiers(Map<DamageModifier, Double> modifiers) {
+        EnumMap<DamageModifier, Function<? super Double, Double>> modifierFunctions = new EnumMap<DamageModifier, Function<? super Double, Double>>(DamageModifier.class);
+        Function<? super Double, Double> ZERO = Functions.constant(-0.0);
+
+        for (DamageModifier modifier : modifiers.keySet()) {
+            modifierFunctions.put(modifier, ZERO);
+        }
+
+        return modifierFunctions;
+    }
 }

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/events/skills/secondaryabilities/SecondaryAbilityEvent.java

@@ -1,18 +1,20 @@
 package com.gmail.nossr50.events.skills.secondaryabilities;
 
 import org.bukkit.entity.Player;
+import org.bukkit.event.Cancellable;
 
 import com.gmail.nossr50.datatypes.skills.SecondaryAbility;
 import com.gmail.nossr50.datatypes.skills.SkillType;
 import com.gmail.nossr50.events.skills.McMMOPlayerSkillEvent;
 
-public abstract class SecondaryAbilityEvent extends McMMOPlayerSkillEvent {
-
+public class SecondaryAbilityEvent extends McMMOPlayerSkillEvent implements Cancellable {
     private SecondaryAbility secondaryAbility;
+    private boolean cancelled;
 
     public SecondaryAbilityEvent(Player player, SecondaryAbility secondaryAbility) {
         super(player, SkillType.bySecondaryAbility(secondaryAbility));
         this.secondaryAbility = secondaryAbility;
+        cancelled = false;
     }
 
     /**
@@ -22,4 +24,12 @@ public abstract class SecondaryAbilityEvent extends McMMOPlayerSkillEvent {
     public SecondaryAbility getSecondaryAbility() {
         return secondaryAbility;
     }
+
+    public boolean isCancelled() {
+        return cancelled;
+    }
+
+    public void setCancelled(boolean newValue) {
+        this.cancelled = newValue;
+    }
 }

src/main/java/com/gmail/nossr50/events/skills/secondaryabilities/SecondaryAbilityWeightedActivationCheckEvent.java

@@ -5,7 +5,6 @@ import org.bukkit.entity.Player;
 import com.gmail.nossr50.datatypes.skills.SecondaryAbility;
 
 public class SecondaryAbilityWeightedActivationCheckEvent extends SecondaryAbilityEvent {
-
     private double chance;
 
     public SecondaryAbilityWeightedActivationCheckEvent(Player player, SecondaryAbility ability, double chance) {

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

@@ -31,11 +31,15 @@ import com.gmail.nossr50.datatypes.skills.SkillType;
 import com.gmail.nossr50.datatypes.skills.ToolType;
 import com.gmail.nossr50.events.fake.FakeBlockBreakEvent;
 import com.gmail.nossr50.events.fake.FakeBlockDamageEvent;
+import com.gmail.nossr50.runnables.PistonTrackerTask;
 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;
@@ -60,27 +64,27 @@ public class BlockListener implements Listener {
      */
     @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
     public void onBlockPistonExtend(BlockPistonExtendEvent event) {
-        List<Block> blocks = event.getBlocks();
+        if (!EventUtils.shouldProcessEvent(event.getBlock(), true)) {
+            return;
+        }
+
         BlockFace direction = event.getDirection();
         Block futureEmptyBlock = event.getBlock().getRelative(direction); // Block that would be air after piston is finished
 
+        if (futureEmptyBlock.getType() == Material.AIR) {
+            return;
+        }
+
+        List<Block> blocks = event.getBlocks();
+
         for (Block b : blocks) {
             if (BlockUtils.shouldBeWatched(b.getState()) && mcMMO.getPlaceStore().isTrue(b)) {
                 b.getRelative(direction).setMetadata(mcMMO.blockMetadataKey, mcMMO.metadataValue);
-                if (b.equals(futureEmptyBlock) && futureEmptyBlock.getType() == Material.AIR) {
-                    mcMMO.getPlaceStore().setFalse(b);
-                }
             }
         }
 
-        for (Block b : blocks) {
-            Block nextBlock = b.getRelative(direction);
-
-            if (nextBlock.hasMetadata(mcMMO.blockMetadataKey)) {
-                mcMMO.getPlaceStore().setTrue(nextBlock);
-                nextBlock.removeMetadata(mcMMO.blockMetadataKey, plugin);
-            }
-        }
+        // Needed because blocks sometimes don't move when two pistons push towards each other
+        new PistonTrackerTask(blocks, direction, futureEmptyBlock).runTaskLater(plugin, 2);
     }
 
     /**
@@ -90,6 +94,10 @@ public class BlockListener implements Listener {
      */
     @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
     public void onBlockPistonRetract(BlockPistonRetractEvent event) {
+        if (!EventUtils.shouldProcessEvent(event.getBlock(), false)) {
+            return;
+        }
+
         if (!event.isSticky()) {
             return;
         }
@@ -120,8 +128,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 +240,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,10 +32,12 @@ 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;
 import org.bukkit.potion.PotionEffectType;
+import org.bukkit.projectiles.ProjectileSource;
 
 import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.config.AdvancedConfig;
@@ -50,6 +53,7 @@ import com.gmail.nossr50.skills.acrobatics.AcrobaticsManager;
 import com.gmail.nossr50.skills.archery.Archery;
 import com.gmail.nossr50.skills.fishing.Fishing;
 import com.gmail.nossr50.skills.herbalism.Herbalism;
+import com.gmail.nossr50.skills.mining.BlastMining;
 import com.gmail.nossr50.skills.mining.MiningManager;
 import com.gmail.nossr50.skills.taming.Taming;
 import com.gmail.nossr50.skills.taming.TamingManager;
@@ -75,7 +79,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);
         }
 
@@ -104,7 +110,9 @@ public class EntityListener implements Listener {
     public void onEntityChangeBlock(EntityChangeBlockEvent event) {
         Block block = event.getBlock();
 
-        if (!BlockUtils.shouldBeWatched(block.getState())) {
+        // When the event is fired for the falling block that changes back to a normal block
+        // event.getBlock().getType() returns AIR
+        if (!BlockUtils.shouldBeWatched(block.getState()) && block.getType() != Material.AIR) {
             return;
         }
 
@@ -121,6 +129,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);
@@ -139,7 +150,7 @@ public class EntityListener implements Listener {
             return;
         }
 
-        double damage = event.getDamage();
+        double damage = event.getFinalDamage();
 
         if (damage <= 0) {
             return;
@@ -169,7 +180,11 @@ public class EntityListener implements Listener {
         }
 
         if (attacker instanceof Projectile) {
-            attacker = ((Projectile) attacker).getShooter();
+            ProjectileSource projectileSource = ((Projectile) attacker).getShooter();
+
+            if (projectileSource instanceof LivingEntity) {
+                attacker = (LivingEntity) projectileSource;
+            }
         }
         else if (attacker instanceof Tameable) {
             AnimalTamer animalTamer = ((Tameable) attacker).getOwner();
@@ -178,6 +193,11 @@ public class EntityListener implements Listener {
                 attacker = (Entity) animalTamer;
             }
         }
+        else if (attacker instanceof TNTPrimed && defender instanceof Player) {
+            if (BlastMining.processBlastMiningExplosion(event, (TNTPrimed) attacker, (Player) defender)) {
+                return;
+            }
+        }
 
         if (defender instanceof Player && attacker instanceof Player) {
             Player defendingPlayer = (Player) defender;
@@ -199,7 +219,7 @@ public class EntityListener implements Listener {
         }
 
         CombatUtils.processCombatAttack(event, attacker, target);
-        CombatUtils.handleHealthbars(attacker, target, event.getDamage());
+        CombatUtils.handleHealthbars(attacker, target, event.getFinalDamage());
     }
 
     /**
@@ -213,7 +233,7 @@ public class EntityListener implements Listener {
             return;
         }
 
-        double damage = event.getDamage();
+        double damage = event.getFinalDamage();
 
         if (damage <= 0) {
             return;
@@ -264,20 +284,7 @@ public class EntityListener implements Listener {
                     if (acrobaticsManager.canRoll()) {
                         event.setDamage(acrobaticsManager.rollCheck(event.getDamage()));
 
-                        if (event.getDamage() == 0) {
-                            event.setCancelled(true);
-                            return;
-                        }
-                    }
-                    break;
-
-                case BLOCK_EXPLOSION:
-                    MiningManager miningManager = mcMMOPlayer.getMiningManager();
-
-                    if (miningManager.canUseDemolitionsExpertise()) {
-                        event.setDamage(miningManager.processDemolitionsExpertise(event.getDamage()));
-
-                        if (event.getDamage() == 0) {
+                        if (event.getFinalDamage() == 0) {
                             event.setCancelled(true);
                             return;
                         }
@@ -288,7 +295,7 @@ public class EntityListener implements Listener {
                     break;
             }
 
-            if (event.getDamage() >= 1) {
+            if (event.getFinalDamage() >= 1) {
                 mcMMOPlayer.actualizeRecentlyHurt();
             }
         }
@@ -322,7 +329,7 @@ public class EntityListener implements Listener {
                         if (tamingManager.canUseThickFur()) {
                             event.setDamage(Taming.processThickFur(wolf, event.getDamage()));
 
-                            if (event.getDamage() == 0) {
+                            if (event.getFinalDamage() == 0) {
                                 event.setCancelled(true);
                             }
                         }
@@ -348,7 +355,7 @@ public class EntityListener implements Listener {
                         if (tamingManager.canUseShockProof()) {
                             event.setDamage(Taming.processShockProof(wolf, event.getDamage()));
 
-                            if (event.getDamage() == 0) {
+                            if (event.getFinalDamage() == 0) {
                                 event.setCancelled(true);
                             }
                         }

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

@@ -24,6 +24,7 @@ import org.bukkit.event.player.PlayerJoinEvent;
 import org.bukkit.event.player.PlayerPickupItemEvent;
 import org.bukkit.event.player.PlayerQuitEvent;
 import org.bukkit.event.player.PlayerRespawnEvent;
+import org.bukkit.event.player.PlayerStatisticIncrementEvent;
 import org.bukkit.event.player.PlayerTeleportEvent;
 import org.bukkit.inventory.ItemStack;
 
@@ -37,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.player.PlayerProfileLoadingTask;
 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;
@@ -223,6 +226,13 @@ public class PlayerListener implements Listener {
                 return;
 
             case CAUGHT_FISH:
+                //TODO Update to new API once available! Waiting for case CAUGHT_TREASURE:
+                Item fishingCatch = (Item) event.getCaught();
+
+                if (Config.getInstance().getFishingOverrideTreasures() && fishingCatch.getItemStack().getType() != Material.RAW_FISH) {
+                    fishingCatch.setItemStack(new ItemStack(Material.RAW_FISH, 1));
+                }
+
                 if (Permissions.vanillaXpBoost(player, SkillType.FISHING)) {
                     event.setExpToDrop(fishingManager.handleVanillaXpBoost(event.getExpToDrop()));
                 }
@@ -322,9 +332,11 @@ public class PlayerListener implements Listener {
         }
 
         if ((mcMMOPlayer.isUsingUnarmed() && ItemUtils.isSharable(dropStack)) || mcMMOPlayer.getAbilityMode(AbilityType.BERSERK)) {
-            event.setCancelled(Unarmed.handleItemPickup(player.getInventory(), drop));
+            boolean pickupSuccess = Unarmed.handleItemPickup(player.getInventory(), drop);
+            boolean cancel = Config.getInstance().getUnarmedItemPickupDisabled() || pickupSuccess;
+            event.setCancelled(cancel);
 
-            if (event.isCancelled()) {
+            if (pickupSuccess) {
                 player.playSound(player.getLocation(), Sound.ITEM_PICKUP, Misc.POP_VOLUME, Misc.getPopPitch());
                 player.updateInventory();
                 return;
@@ -353,7 +365,7 @@ public class PlayerListener implements Listener {
 
         mcMMOPlayer.resetAbilityMode();
         BleedTimerTask.bleedOut(player);
-        mcMMOPlayer.getProfile().save();
+        mcMMOPlayer.getProfile().scheduleAsyncSave();
         UserManager.remove(player);
         ScoreboardManager.teardownPlayer(player);
     }
@@ -375,9 +387,7 @@ public class PlayerListener implements Listener {
             return;
         }
 
-        McMMOPlayer mcMMOPlayer = UserManager.addUser(player);
-        mcMMOPlayer.actualizeRespawnATS();
-        ScoreboardManager.setupPlayer(player);
+        new PlayerProfileLoadingTask(player).runTaskTimerAsynchronously(mcMMO.p, 1, 20); // 1 Tick delay to ensure the player is marked as online before we begin loading
 
         if (Config.getInstance().getMOTDEnabled() && Permissions.motd(player)) {
             Motd.displayAll(player);
@@ -437,24 +447,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();
                         }
                     }
@@ -476,22 +486,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")));
                         }
                     }
@@ -623,7 +633,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;
         }
 
@@ -687,4 +697,13 @@ public class PlayerListener implements Listener {
             }
         }
     }
+
+    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+    public void onPlayerStatisticIncrementEvent(PlayerStatisticIncrementEvent event) {
+        if (!mcMMO.getHolidayManager().isAprilFirst()) {
+            return;
+        }
+
+        mcMMO.getHolidayManager().handleStatisticEvent(event);
+    }
 }

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,14 +30,15 @@ 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;
+import com.gmail.nossr50.runnables.player.PlayerProfileLoadingTask;
 import com.gmail.nossr50.runnables.player.PowerLevelUpdatingTask;
 import com.gmail.nossr50.runnables.skills.BleedTimerTask;
 import com.gmail.nossr50.skills.alchemy.Alchemy;
@@ -44,6 +46,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;
@@ -56,20 +61,20 @@ import com.gmail.nossr50.util.commands.CommandRegistrationManager;
 import com.gmail.nossr50.util.experience.FormulaManager;
 import com.gmail.nossr50.util.player.UserManager;
 import com.gmail.nossr50.util.scoreboards.ScoreboardManager;
+import com.gmail.nossr50.util.upgrade.UpgradeManager;
 
-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;
+    private static UpgradeManager     upgradeManager;
 
     /* File Paths */
     private static String mainDirectory;
@@ -86,7 +91,6 @@ public class mcMMO extends JavaPlugin {
     private boolean updateAvailable;
 
     /* Plugin Checks */
-    private static boolean combatTagEnabled;
     private static boolean healthBarPluginEnabled;
 
     // Config Validation Check
@@ -110,6 +114,8 @@ 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 final static String pistonDataKey       = "mcMMO: Piston State";
 
     public static FixedMetadataValue metadataValue;
 
@@ -124,9 +130,10 @@ public class mcMMO extends JavaPlugin {
             metadataValue = new FixedMetadataValue(this, true);
 
             PluginManager pluginManager = getServer().getPluginManager();
-            combatTagEnabled = pluginManager.getPlugin("CombatTag") != null;
             healthBarPluginEnabled = pluginManager.getPlugin("HealthBar") != null;
 
+            upgradeManager = new UpgradeManager();
+
             setupFilePaths();
 
             modManager = new ModManager();
@@ -137,7 +144,7 @@ public class mcMMO extends JavaPlugin {
                 return;
             }
 
-            if (getServer().getName().equals("MCPC+")) {
+            if (getServer().getName().equals("Cauldron") || getServer().getName().equals("MCPC+")) {
                 checkModConfigs();
             }
 
@@ -161,8 +168,7 @@ public class mcMMO extends JavaPlugin {
             holidayManager = new HolidayManager();
 
             for (Player player : getServer().getOnlinePlayers()) {
-                UserManager.addUser(player); // In case of reload add all users back into UserManager
-                ScoreboardManager.setupPlayer(player);
+                new PlayerProfileLoadingTask(player).runTaskTimerAsynchronously(mcMMO.p, 1, 20); // 1 Tick delay to ensure the player is marked as online before we begin loading
             }
 
             debug("Version " + getDescription().getVersion() + " is enabled!");
@@ -202,6 +208,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();
@@ -235,6 +242,7 @@ public class mcMMO extends JavaPlugin {
             }
         }
 
+        databaseManager.onDisable();
         debug("Was disabled."); // How informative!
     }
 
@@ -258,6 +266,10 @@ public class mcMMO extends JavaPlugin {
         return updateAvailable;
     }
 
+    public void setUpdateAvailable(boolean available) {
+        this.updateAvailable = available;
+    }
+
     public boolean isXPEventEnabled() {
         return xpEventEnabled;
     }
@@ -290,6 +302,10 @@ public class mcMMO extends JavaPlugin {
         return repairableManager;
     }
 
+    public static SalvageableManager getSalvageableManager() {
+        return salvageableManager;
+    }
+
     public static DatabaseManager getDatabaseManager() {
         return databaseManager;
     }
@@ -298,15 +314,15 @@ public class mcMMO extends JavaPlugin {
         return modManager;
     }
 
+    public static UpgradeManager getUpgradeManager() {
+        return upgradeManager;
+    }
+
     @Deprecated
     public static void setDatabaseManager(DatabaseManager databaseManager) {
         mcMMO.databaseManager = databaseManager;
     }
 
-    public static boolean isCombatTagEnabled() {
-        return combatTagEnabled;
-    }
-
     public static boolean isHealthBarPluginEnabled() {
         return healthBarPluginEnabled;
     }
@@ -377,21 +393,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 +405,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 +428,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() {
@@ -486,22 +495,22 @@ public class mcMMO extends JavaPlugin {
 
     private void checkModConfigs() {
         if (!Config.getInstance().getToolModsEnabled()) {
-            getLogger().info("MCPC+ implementation found, but the custom tool config for mcMMO is disabled!");
+            getLogger().warning("Cauldron implementation found, but the custom tool config for mcMMO is disabled!");
             getLogger().info("To enable, set Mods.Tool_Mods_Enabled to TRUE in config.yml.");
         }
 
         if (!Config.getInstance().getArmorModsEnabled()) {
-            getLogger().info("MCPC+ implementation found, but the custom armor config for mcMMO is disabled!");
+            getLogger().warning("Cauldron implementation found, but the custom armor config for mcMMO is disabled!");
             getLogger().info("To enable, set Mods.Armor_Mods_Enabled to TRUE in config.yml.");
         }
 
         if (!Config.getInstance().getBlockModsEnabled()) {
-            getLogger().info("MCPC+ implementation found, but the custom block config for mcMMO is disabled!");
+            getLogger().warning("Cauldron implementation found, but the custom block config for mcMMO is disabled!");
             getLogger().info("To enable, set Mods.Block_Mods_Enabled to TRUE in config.yml.");
         }
 
         if (!Config.getInstance().getEntityModsEnabled()) {
-            getLogger().info("MCPC+ implementation found, but the custom entity config for mcMMO is disabled!");
+            getLogger().warning("Cauldron implementation found, but the custom entity config for mcMMO is disabled!");
             getLogger().info("To enable, set Mods.Entity_Mods_Enabled to TRUE in config.yml.");
         }
     }

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/PistonTrackerTask.java

@@ -0,0 +1,47 @@
+package com.gmail.nossr50.runnables;
+
+import java.util.List;
+
+import org.bukkit.block.Block;
+import org.bukkit.block.BlockFace;
+import org.bukkit.scheduler.BukkitRunnable;
+
+import com.gmail.nossr50.mcMMO;
+import com.gmail.nossr50.util.BlockUtils;
+
+public class PistonTrackerTask extends BukkitRunnable {
+    private List<Block> blocks;
+    private BlockFace direction;
+    private Block futureEmptyBlock;
+
+    public PistonTrackerTask(List<Block> blocks, BlockFace direction, Block futureEmptyBlock) {
+        this.blocks = blocks;
+        this.direction = direction;
+        this.futureEmptyBlock = futureEmptyBlock;
+    }
+
+    @Override
+    public void run() {
+        // Check to see if futureEmptyBlock is empty - if it isn't; the blocks didn't move
+        if (!BlockUtils.isPistonPiece(futureEmptyBlock.getState())) {
+            return;
+        }
+
+        if (mcMMO.getPlaceStore().isTrue(futureEmptyBlock)) {
+            mcMMO.getPlaceStore().setFalse(futureEmptyBlock);
+        }
+
+        for (Block b : blocks) {
+            Block nextBlock = b.getRelative(direction);
+
+            if (nextBlock.hasMetadata(mcMMO.blockMetadataKey)) {
+                mcMMO.getPlaceStore().setTrue(nextBlock);
+                nextBlock.removeMetadata(mcMMO.blockMetadataKey, mcMMO.p);
+            }
+            else if (mcMMO.getPlaceStore().isTrue(nextBlock)) {
+                // Block doesn't have metadatakey but isTrue - set it to false
+                mcMMO.getPlaceStore().setFalse(nextBlock);
+            }
+        }
+    }
+}

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

@@ -2,7 +2,6 @@ package com.gmail.nossr50.runnables;
 
 import org.bukkit.block.Block;
 import org.bukkit.block.BlockFace;
-import org.bukkit.block.PistonMoveReaction;
 import org.bukkit.scheduler.BukkitRunnable;
 
 import com.gmail.nossr50.mcMMO;
@@ -21,10 +20,16 @@ public class StickyPistonTrackerTask extends BukkitRunnable {
 
     @Override
     public void run() {
-        if (!BlockUtils.shouldBeWatched(movedBlock.getState()) || movedBlock.getPistonMoveReaction() != PistonMoveReaction.MOVE || !mcMMO.getPlaceStore().isTrue(movedBlock)) {
+        if (!mcMMO.getPlaceStore().isTrue(movedBlock)) {
             return;
         }
 
+        if (!BlockUtils.isPistonPiece(movedBlock.getState())) {
+            // The block didn't move
+            return;
+        }
+
+        // The sticky piston actually pulled the block so move the PlaceStore data
         mcMMO.getPlaceStore().setFalse(movedBlock);
         mcMMO.getPlaceStore().setTrue(block.getRelative(direction));
     }

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/database/SQLDatabaseKeepaliveTask.java

@@ -1,39 +0,0 @@
-package com.gmail.nossr50.runnables.database;
-
-import java.lang.ref.WeakReference;
-
-import org.bukkit.scheduler.BukkitRunnable;
-
-import com.gmail.nossr50.database.SQLDatabaseManager;
-
-/**
- * This task is in charge of sending a MySQL ping over the MySQL connection
- * every hour to prevent the connection from timing out and losing players'
- * data when they join.
- * <p/>
- * A WeakReference is used to keep the database instance, because
- * {@link com.gmail.nossr50.commands.database.ConvertDatabaseCommand database
- * conversion} may create a SQLDatabaseManager that will be thrown out. If a
- * normal reference was used, the conversion would cause a combined data and
- * resource leak through this task.
- */
-public class SQLDatabaseKeepaliveTask extends BukkitRunnable {
-    WeakReference<SQLDatabaseManager> databaseInstance;
-
-    public SQLDatabaseKeepaliveTask(SQLDatabaseManager dbman) {
-        databaseInstance = new WeakReference<SQLDatabaseManager>(dbman);
-    }
-
-    public void run() {
-        SQLDatabaseManager dbman = databaseInstance.get();
-        if (dbman != null) {
-            dbman.checkConnected();
-        }
-        else {
-            // This happens when the database was started for a conversion,
-            // or discarded by its creator for any other reason. If this code
-            // was not present, we would leak the connection resources.
-            this.cancel();
-        }
-    }
-}

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

@@ -1,22 +0,0 @@
-package com.gmail.nossr50.runnables.database;
-
-import org.bukkit.entity.Player;
-import org.bukkit.scheduler.BukkitRunnable;
-
-import com.gmail.nossr50.mcMMO;
-import com.gmail.nossr50.database.SQLDatabaseManager;
-import com.gmail.nossr50.util.player.UserManager;
-
-public class SQLReconnectTask extends BukkitRunnable {
-    @Override
-    public void run() {
-        if (((SQLDatabaseManager) mcMMO.getDatabaseManager()).checkConnected()) {
-            UserManager.saveAll();  // Save all profiles
-            UserManager.clearAll(); // Clear the profiles
-
-            for (Player player : mcMMO.p.getServer().getOnlinePlayers()) {
-                UserManager.addUser(player); // Add in new profiles, forcing them to 'load' again from MySQL
-            }
-        }
-    }
-}

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

@@ -0,0 +1,73 @@
+package com.gmail.nossr50.runnables.database;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+import org.bukkit.scheduler.BukkitRunnable;
+
+import com.gmail.nossr50.mcMMO;
+import com.gmail.nossr50.config.HiddenConfig;
+import com.gmail.nossr50.database.DatabaseManager;
+import com.gmail.nossr50.datatypes.database.UpgradeType;
+import com.gmail.nossr50.util.Misc;
+import com.gmail.nossr50.util.uuid.UUIDFetcher;
+
+public class UUIDUpdateAsyncTask extends BukkitRunnable {
+    private mcMMO plugin;
+    private static final int MAX_LOOKUP = Math.max(HiddenConfig.getInstance().getUUIDConvertAmount(), 100);
+
+    private List<String> userNames;
+    private int size;
+    private int checkedUsers;
+    private long startMillis;
+
+    public UUIDUpdateAsyncTask(mcMMO plugin, List<String> userNames) {
+        this.plugin = plugin;
+        this.userNames = userNames;
+
+        this.checkedUsers = 0;
+        this.startMillis = System.currentTimeMillis();
+    }
+
+    @Override
+    public void run() {
+        size = userNames.size();
+
+        plugin.getLogger().info("Starting to check and update UUIDs, total amount of users: " + size);
+
+        List<String> userNamesSection;
+        Map<String, UUID> fetchedUUIDs = new HashMap<String, UUID>();
+
+        while (size != 0) {
+            if (size > MAX_LOOKUP) {
+                userNamesSection = userNames.subList(size - MAX_LOOKUP, size);
+                size -= MAX_LOOKUP;
+            }
+            else {
+                userNamesSection = userNames.subList(0, size);
+                size = 0;
+            }
+
+            try {
+                fetchedUUIDs.putAll(new UUIDFetcher(userNamesSection).call());
+            }
+            catch (Exception e) {
+                plugin.getLogger().severe("Unable to fetch UUIDs!");
+                return;
+            }
+
+            checkedUsers += userNamesSection.size();
+            userNamesSection.clear();
+            size = userNames.size();
+
+            Misc.printProgress(checkedUsers, DatabaseManager.progressInterval, startMillis);
+        }
+
+        if (mcMMO.getDatabaseManager().saveUserUUIDs(fetchedUUIDs)) {
+            mcMMO.getUpgradeManager().setUpgradeCompleted(UpgradeType.ADD_UUIDS);
+            plugin.getLogger().info("UUID upgrade completed!");
+        }
+    }
+}

src/main/java/com/gmail/nossr50/runnables/party/PartyChatTask.java

@@ -0,0 +1,51 @@
+package com.gmail.nossr50.runnables.party;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.bukkit.ChatColor;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.scheduler.BukkitRunnable;
+
+import com.gmail.nossr50.config.Config;
+import com.gmail.nossr50.datatypes.party.Party;
+import com.gmail.nossr50.locale.LocaleLoader;
+
+public class PartyChatTask extends BukkitRunnable {
+    private Plugin plugin;
+
+    private Party party;
+    private String senderName;
+    private String displayName;
+    private String message;
+
+    public PartyChatTask(Plugin plugin, Party party, String senderName, String displayName, String message) {
+        this.plugin = plugin;
+
+        this.party = party;
+        this.senderName = senderName;
+        this.displayName = displayName;
+        this.message = message;
+    }
+
+    @Override
+    public void run() {
+        if (Config.getInstance().getPartyChatColorLeaderName() && senderName.equalsIgnoreCase(party.getLeader())) {
+            message = message.replaceFirst(Pattern.quote(displayName), ChatColor.GOLD + Matcher.quoteReplacement(displayName) + ChatColor.RESET);
+        }
+
+        for (Player member : party.getOnlineMembers()) {
+            member.sendMessage(message);
+        }
+
+        if (party.getAlly() != null) {
+            for (Player member : party.getAlly().getOnlineMembers()) {
+                String allyPrefix = LocaleLoader.formatString(Config.getInstance().getPartyChatPrefixAlly());
+                member.sendMessage(allyPrefix + message);
+            }
+        }
+
+        plugin.getServer().getConsoleSender().sendMessage("[mcMMO] [P]<" + party.getName() + ">" + message);
+    }
+}

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

@@ -0,0 +1,108 @@
+package com.gmail.nossr50.runnables.player;
+
+import java.util.concurrent.locks.ReentrantLock;
+
+import org.bukkit.Server;
+import org.bukkit.entity.Player;
+import org.bukkit.scheduler.BukkitRunnable;
+
+import com.gmail.nossr50.mcMMO;
+import com.gmail.nossr50.config.Config;
+import com.gmail.nossr50.datatypes.player.McMMOPlayer;
+import com.gmail.nossr50.datatypes.player.PlayerProfile;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.runnables.commands.McScoreboardKeepTask;
+import com.gmail.nossr50.util.Misc;
+import com.gmail.nossr50.util.player.UserManager;
+import com.gmail.nossr50.util.scoreboards.ScoreboardManager;
+
+public class PlayerProfileLoadingTask extends BukkitRunnable {
+    private static final int MAX_TRIES = 5;
+    private final Player player;
+    private int attempt = 0;
+    private ReentrantLock lock = new ReentrantLock();
+    private boolean cancelled = false;
+
+    public PlayerProfileLoadingTask(Player player) {
+        this.player = player;
+    }
+
+    // WARNING: ASYNC TASK
+    // DO NOT MODIFY THE McMMOPLAYER FROM THIS CODE
+    @Override
+    public void run() {
+        lock.lock();
+
+        if (this.cancelled) {
+            return;
+        }
+
+        // Quit if they logged out
+        if (!player.isOnline()) {
+            mcMMO.p.getLogger().info("Aborting profile loading recovery for " + player.getName() + " - player logged out");
+            this.cancel();
+            cancelled = true;
+            lock.unlock();
+            return;
+        }
+
+        // Increment attempt counter and try
+        attempt++;
+
+        PlayerProfile profile = mcMMO.getDatabaseManager().loadPlayerProfile(player.getName(), player.getUniqueId(), true);
+        // If successful, schedule the apply
+        if (profile.isLoaded()) {
+            new ApplySuccessfulProfile(profile).runTask(mcMMO.p);
+            this.cancel();
+            cancelled = true;
+            lock.unlock();
+            return;
+        }
+
+        // If we've failed five times, give up
+        if (attempt >= MAX_TRIES) {
+            mcMMO.p.getLogger().severe("Giving up on attempting to load the PlayerProfile for " + player.getName());
+            mcMMO.p.getServer().broadcast(LocaleLoader.getString("Profile.Loading.AdminFailureNotice", player.getName()), Server.BROADCAST_CHANNEL_ADMINISTRATIVE);
+            player.sendMessage(LocaleLoader.getString("Profile.Loading.Failure").split("\n"));
+            this.cancel();
+            cancelled = true;
+            lock.unlock();
+            return;
+        }
+        lock.unlock();
+    }
+
+    private class ApplySuccessfulProfile extends BukkitRunnable {
+        private final PlayerProfile profile;
+
+        private ApplySuccessfulProfile(PlayerProfile profile) {
+            this.profile = profile;
+        }
+
+        // Synchronized task
+        // No database access permitted
+        @Override
+        public void run() {
+            if (!player.isOnline()) {
+                mcMMO.p.getLogger().info("Aborting profile loading recovery for " + player.getName() + " - player logged out");
+                return;
+            }
+
+            McMMOPlayer mcMMOPlayer = new McMMOPlayer(player, profile);
+            UserManager.track(mcMMOPlayer);
+            mcMMOPlayer.actualizeRespawnATS();
+            ScoreboardManager.setupPlayer(player);
+
+            if (Config.getInstance().getShowProfileLoadedMessage()) {
+                player.sendMessage(LocaleLoader.getString("Profile.Loading.Success"));
+            }
+
+            if (Config.getInstance().getShowStatsAfterLogin()) {
+                ScoreboardManager.enablePlayerStatsScoreboard(player);
+                new McScoreboardKeepTask(player).runTaskLater(mcMMO.p, 1 * Misc.TICK_CONVERSION_FACTOR);
+            }
+        }
+    }
+}
+
+