Fix this

Fixes  #1218

Changelog.txt

@@ -7,6 +7,64 @@ Key:
   ! Change
   - Removal
 
+Version 1.4.06-dev
+ + Added "Ice Fishing" ability to Fishing
+ + Added global scoreboards to track skill rankings (display using /mctop)
+ + Added per-player scoreboard displays for the /inspect, /mcrank, /mcstats, and /<skillname> commands
+ + Added tab-complete support for all commands
+ + Added ability to configure drops from Shake in treasures.yml
+ + Added "Master Angler" ability to Fishing.
+ + Added health display for mobs during combat.
+ + Added new API method to McMMOPlayerLevelUpEvent to set levels gained
+ + Added new permission node for /ptp; mcmmo.commands.ptp.send (enabled by default)
+ + Added configurable cooldown and warmup times when using /ptp
+ + Added a new Party item share category "Misc" which contains a list of configurable items. (By default all tools and armor)
+ + Added fishing exploit prevention
+ + Added permission node to bypass the fishing exploit prevention
+ + Added boosts to Fishing chance depending on conditions
+ + Added McMMOAbilityActivateEvent and McMMOAbilityDeactivateEvent
+ + Added config option to toggle the size of fireworks
+ + Added config option to multiply xp gains from mob spawner mobs
+ + Added multiplier to Archery XP based on bow force
+ + Added information about /party itemshare and /party expshare to the party help page
+ + Added option to use scoreboards for power level display instead of Spout.
+ + Added permission node to prevent inspecting hidden players
+ = Fixed bug where spawned arrows could throw ArrayIndexOutOfBoundsException
+ = Fixed bug where custom Spout titles were overwritten by mcMMO.
+ = Fixed bug where Nether Quartz wasn't included in Smelting or item sharing
+ = Fixed bug where players were able to join the same party multiple times
+ = Fixed displaying partial names when trying to use /ptp
+ = Fixed wolves from Call of the Wild only having 8 health
+ = Fixed bug where /party chat was not working
+ = Fixed bug where experience commands were adding levels to all skills when they shouldn't
+ = Fixed mcmmo.commands.ptp.send not being set by default
+ = Fixed NPE when trying to tab-complete /mctop
+ = Fixed Fishing treasures always having the same enchants
+ = Fixed Smelting returning ink sacs instead of Lapis when double-dropping
+ = Fixed bug where players could remain in party chat after leaving or being kicked from a party.
+ = Fixed bug where non-player arrows couldn't be deflected.
+ = Fixed experience being applied even when the permission for a skill was denied
+ = Fixed possible item duplication bug with infinity bows
+ = Fixed bug with removing players from mySQL database
+ = Fixed bug with empty metadata lists and Smelting
+ = Fixed bug where Blast Mining would drop wrong items
+ = Fixed bug with Blast Mining where the Ability refreshed message was being send too early
+ = Fixed bug where the chance of a successful Gracefull Roll was twice as high as displayed
+ = Fixed bug where lucky perks where not working
+ = Fixed bug with Ice Fishing on a single block of ice
+ ! Changed Spout notification tiers to be stored in SpoutConfig instead of AdvancedConfig
+ ! Changed Berserk to add items to inventory rather than denying pickup
+ ! Changed Call of the Wild, newly summoned pet's will have a custom name. (added permission node to disable this)
+ ! Changed Chimaera Wing's recipe result to use the ingredient Material
+ ! Changed Repair to ask a confirmation of the player when he tries to repair an enchanted item
+ ! Players will no longer pickup items to their hotbar while using Unarmed
+ ! ExperienceAPI methods will now throw InvalidSkillException if the skill name passed in is invalid.
+ ! Changed default value for recently-hurt cooldown between teleports, this is also fully configurable now
+ ! Changed the amount of info messages in the console when enabling/disabling, enable Verbose_Logging to enable them again
+ ! Items dropped by players are now being tracked and are not being shared with party members
+ ! Optimized tracking of tool & ability cooldowns.
+ ! Updated the localization files
+
 Version 1.4.05
  + Added option to allow refreshing of chunks after block-breaking abilities. (Disabled by default)
  + Added fireworks effects when a player levels-up, for every 100 levels (configurable)

README.md

@@ -29,7 +29,7 @@ mcMMO is currently developed by a team of individuals from all over the world.
 (https://github.com/shatteredbeam)
 [![TfT_02](http://www.gravatar.com/avatar/b8914f9970e1f6ffd5281ce4770e20a7.png)]
 (https://github.com/TfT-02)
-[![t00thpick1](http://www.gravatar.com/avatar/??.png)]
+[![t00thpick1](http://www.gravatar.com/avatar/ee23c7794a0c40120c3474287c7bce06.png)]
 (https://github.com/t00thpick1)
 
 ## Compiling

pom.xml

@@ -2,7 +2,7 @@
     <modelVersion>4.0.0</modelVersion>
     <groupId>com.gmail.nossr50.mcMMO</groupId>
     <artifactId>mcMMO</artifactId>
-    <version>1.4.05</version>
+    <version>1.4.06-dev6</version>
     <name>mcMMO</name>
     <url>https://github.com/mcMMO-Dev/mcMMO</url>
     <issueManagement>
@@ -177,4 +177,8 @@
     <properties>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
     </properties>
+    <ciManagement>
+    	<system>Jenkins</system>
+    	<url>ci.mcmmo.org</url>
+    </ciManagement>
 </project>

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

@@ -48,4 +48,36 @@ public final class AbilityAPI {
 
         return false;
     }
+
+    public static void resetCooldowns(Player player) {
+        UserManager.getPlayer(player).getProfile().resetCooldowns();
+    }
+
+    public static void setBerserkCooldown(Player player, long cooldown) {
+        UserManager.getPlayer(player).getProfile().setSkillDATS(AbilityType.BERSERK, cooldown);
+    }
+
+    public static void setGigaDrillBreakerCooldown(Player player, long cooldown) {
+        UserManager.getPlayer(player).getProfile().setSkillDATS(AbilityType.GIGA_DRILL_BREAKER, cooldown);
+    }
+
+    public static void setGreenTerraCooldown(Player player, long cooldown) {
+        UserManager.getPlayer(player).getProfile().setSkillDATS(AbilityType.GREEN_TERRA, cooldown);
+    }
+
+    public static void setSerratedStrikesCooldown(Player player, long cooldown) {
+        UserManager.getPlayer(player).getProfile().setSkillDATS(AbilityType.SERRATED_STRIKES, cooldown);
+    }
+
+    public static void setSkullSplitterCooldown(Player player, long cooldown) {
+        UserManager.getPlayer(player).getProfile().setSkillDATS(AbilityType.SKULL_SPLITTER, cooldown);
+    }
+
+    public static void setSuperBreakerCooldown(Player player, long cooldown) {
+        UserManager.getPlayer(player).getProfile().setSkillDATS(AbilityType.SUPER_BREAKER, cooldown);
+    }
+
+    public static void setTreeFellerCooldown(Player player, long cooldown) {
+        UserManager.getPlayer(player).getProfile().setSkillDATS(AbilityType.TREE_FELLER, cooldown);
+    }
 }

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

@@ -4,6 +4,9 @@ import org.bukkit.entity.Player;
 import org.bukkit.plugin.Plugin;
 
 import com.gmail.nossr50.chat.ChatManager;
+import com.gmail.nossr50.chat.ChatManagerFactory;
+import com.gmail.nossr50.chat.ChatMode;
+import com.gmail.nossr50.chat.PartyChatManager;
 import com.gmail.nossr50.party.PartyManager;
 import com.gmail.nossr50.util.player.UserManager;
 
@@ -22,7 +25,7 @@ public final class ChatAPI {
      * @param message The message to send
      */
     public static void sendPartyChat(Plugin plugin, String sender, String displayName, String party, String message) {
-        ChatManager.handlePartyChat(plugin, PartyManager.getParty(party), sender, displayName, message);
+        getPartyChatManager(plugin, party).handleChat(sender, displayName, message);
     }
 
     /**
@@ -36,7 +39,7 @@ public final class ChatAPI {
      * @param message The message to send
      */
     public static void sendPartyChat(Plugin plugin, String sender, String party, String message) {
-        ChatManager.handlePartyChat(plugin, PartyManager.getParty(party), sender, sender, message);
+        getPartyChatManager(plugin, party).handleChat(sender, message);
     }
 
     /**
@@ -50,7 +53,7 @@ public final class ChatAPI {
      * @param message The message to send
      */
     public static void sendAdminChat(Plugin plugin, String sender, String displayName, String message) {
-        ChatManager.handleAdminChat(plugin, sender, displayName, message);
+        ChatManagerFactory.getChatManager(plugin, ChatMode.ADMIN).handleChat(sender, displayName, message);
     }
 
     /**
@@ -63,7 +66,7 @@ public final class ChatAPI {
      * @param message The message to send
      */
     public static void sendAdminChat(Plugin plugin, String sender, String message) {
-        ChatManager.handleAdminChat(plugin, sender, sender, message);
+        ChatManagerFactory.getChatManager(plugin, ChatMode.ADMIN).handleChat(sender, message);
     }
 
     /**
@@ -73,7 +76,7 @@ public final class ChatAPI {
      * @return true if the player is using party chat, false otherwise
      */
     public static boolean isUsingPartyChat(Player player) {
-        return isUsingPartyChat(player.getName());
+        return UserManager.getPlayer(player).getPartyChatMode();
     }
 
     /**
@@ -93,7 +96,7 @@ public final class ChatAPI {
      * @return true if the player is using admin chat, false otherwise
      */
     public static boolean isUsingAdminChat(Player player) {
-        return isUsingAdminChat(player.getName());
+        return UserManager.getPlayer(player).getAdminChatMode();
     }
 
     /**
@@ -112,7 +115,7 @@ public final class ChatAPI {
      * @param player The player to toggle party chat on.
      */
     public static void togglePartyChat(Player player) {
-        togglePartyChat(player.getName());
+        UserManager.getPlayer(player).togglePartyChat();
     }
 
     /**
@@ -121,7 +124,7 @@ public final class ChatAPI {
      * @param playerName The name of the player to toggle party chat on.
      */
     public static void togglePartyChat(String playerName) {
-        UserManager.getPlayer(playerName).setPartyChat(!isUsingPartyChat(playerName));
+        UserManager.getPlayer(playerName).togglePartyChat();
     }
 
     /**
@@ -130,7 +133,7 @@ public final class ChatAPI {
      * @param player The player to toggle admin chat on.
      */
     public static void toggleAdminChat(Player player) {
-        toggleAdminChat(player.getName());
+        UserManager.getPlayer(player).toggleAdminChat();
     }
 
     /**
@@ -138,7 +141,14 @@ public final class ChatAPI {
      *
      * @param playerName The name of the player to toggle party chat on.
      */
-    public static void toggleAdminChat(String playerName){
-        UserManager.getPlayer(playerName).setAdminChat(!isUsingAdminChat(playerName));
+    public static void toggleAdminChat(String playerName) {
+        UserManager.getPlayer(playerName).toggleAdminChat();
+    }
+
+    private static ChatManager getPartyChatManager(Plugin plugin, String party) {
+        ChatManager chatManager = ChatManagerFactory.getChatManager(plugin, ChatMode.PARTY);
+        ((PartyChatManager) chatManager).setParty(PartyManager.getParty(party));
+
+        return chatManager;
     }
 }

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

@@ -4,6 +4,8 @@ import java.util.Set;
 
 import org.bukkit.entity.Player;
 
+import com.gmail.nossr50.api.exceptions.InvalidPlayerException;
+import com.gmail.nossr50.api.exceptions.InvalidSkillException;
 import com.gmail.nossr50.config.Config;
 import com.gmail.nossr50.datatypes.player.PlayerProfile;
 import com.gmail.nossr50.datatypes.skills.SkillType;
@@ -13,6 +15,37 @@ import com.gmail.nossr50.util.player.UserManager;
 public final class ExperienceAPI {
     private ExperienceAPI() {}
 
+    /**
+     * Returns whether given string is a valid type of skill suitable for the
+     * other API calls in this class.
+     * </br>
+     * This function is designed for API usage.
+     *
+     * @param skillType A string that may or may not be a skill
+     * @return true if this is a valid mcMMO skill
+     */
+    public static boolean isValidSkillType(String skillType) {
+        return SkillType.getSkill(skillType) != null;
+    }
+
+    /**
+     * Returns whether the given skill type string is both valid and not a
+     * child skill. (Child skills have no XP of their own, and their level is
+     * derived from the parent(s).)
+     * </br>
+     * This function is designed for API usage.
+     *
+     * @param skillType the skill to check
+     * @return true if this is a valid, non-child mcMMO skill
+     */
+    public static boolean isNonChildSkill(String skillType) {
+        SkillType skill = SkillType.getSkill(skillType);
+
+        if (skill == null) return false;
+
+        return !skill.isChildSkill();
+    }
+
     /**
      * Adds raw XP to the player.
      * </br>
@@ -21,9 +54,11 @@ public final class ExperienceAPI {
      * @param player The 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
      */
     public static void addRawXP(Player player, String skillType, int XP) {
-        UserManager.getPlayer(player).applyXpGain(SkillType.getSkill(skillType), XP);
+        UserManager.getPlayer(player).applyXpGain(getSkillType(skillType), XP);
     }
 
     /**
@@ -35,10 +70,11 @@ public final class ExperienceAPI {
      * @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(String playerName, String skillType, int XP) {
-        addOfflineXP(playerName, skillType, XP);
+        addOfflineXP(playerName, getSkillType(skillType), XP);
     }
 
     /**
@@ -49,9 +85,11 @@ public final class ExperienceAPI {
      * @param player The 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
      */
     public static void addMultipliedXP(Player player, String skillType, int XP) {
-        UserManager.getPlayer(player).applyXpGain(SkillType.getSkill(skillType), (int) (XP * Config.getInstance().getExperienceGainsGlobalMultiplier()));
+        UserManager.getPlayer(player).applyXpGain(getSkillType(skillType), (int) (XP * Config.getInstance().getExperienceGainsGlobalMultiplier()));
     }
 
     /**
@@ -63,10 +101,11 @@ public final class ExperienceAPI {
      * @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 addMultipliedXPOffline(String playerName, String skillType, int XP) {
-        addOfflineXP(playerName, skillType, (int) (XP * Config.getInstance().getExperienceGainsGlobalMultiplier()));
+        addOfflineXP(playerName, getSkillType(skillType), (int) (XP * Config.getInstance().getExperienceGainsGlobalMultiplier()));
     }
 
     /**
@@ -77,11 +116,13 @@ public final class ExperienceAPI {
      * @param player The 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
      */
     public static void addModifiedXP(Player player, String skillType, int XP) {
-        SkillType skill = SkillType.getSkill(skillType);
+        SkillType skill = getSkillType(skillType);
 
-        UserManager.getPlayer(player).applyXpGain(skill, (int) (XP  / skill.getXpModifier() * Config.getInstance().getExperienceGainsGlobalMultiplier()));
+        UserManager.getPlayer(player).applyXpGain(skill, (int) (XP / skill.getXpModifier() * Config.getInstance().getExperienceGainsGlobalMultiplier()));
     }
 
     /**
@@ -93,23 +134,29 @@ public final class ExperienceAPI {
      * @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 addModifiedXPOffline(String playerName, String skillType, int XP) {
-        addOfflineXP(playerName, skillType, (int) (XP / SkillType.getSkill(skillType).getXpModifier() * Config.getInstance().getExperienceGainsGlobalMultiplier()));
+        SkillType skill = getSkillType(skillType);
+
+        addOfflineXP(playerName, skill, (int) (XP / skill.getXpModifier() * Config.getInstance().getExperienceGainsGlobalMultiplier()));
     }
 
     /**
-     * Adds XP to the player, calculates for XP Rate, skill modifiers and perks. May be shared with the party.
+     * 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
+     *
+     * @throws InvalidSkillException if the given skill is not valid
      */
     public static void addXP(Player player, String skillType, int XP) {
-        UserManager.getPlayer(player).beginXpGain(SkillType.getSkill(skillType), XP);
+        UserManager.getPlayer(player).beginXpGain(getSkillType(skillType), XP);
     }
 
     /**
@@ -120,9 +167,12 @@ public final class ExperienceAPI {
      * @param player 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 UnsupportedOperationException if the given skill is a child skill
      */
     public static int getXP(Player player, String skillType) {
-        return UserManager.getPlayer(player).getProfile().getSkillXpLevel(SkillType.getSkill(skillType));
+        return UserManager.getPlayer(player).getProfile().getSkillXpLevel(getNonChildSkillType(skillType));
     }
 
     /**
@@ -133,23 +183,99 @@ public final class ExperienceAPI {
      * @param playerName 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(String playerName, String skillType) {
-        return getOfflineProfile(playerName).getSkillXpLevel(SkillType.getSkill(skillType));
+        return getOfflineProfile(playerName).getSkillXpLevel(getNonChildSkillType(skillType));
     }
 
     /**
-     * Get the amount of XP left before leveling up.
+     * Get the raw amount of XP a player has in a specific skill.
+     * </br>
+     * This function is designed for API usage.
+     *
+     * @param player 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 UnsupportedOperationException if the given skill is a child skill
+     */
+    public static float getXPRaw(Player player, String skillType) {
+        return UserManager.getPlayer(player).getProfile().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 playerName 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(String playerName, String skillType) {
+        return getOfflineProfile(playerName).getSkillXpLevelRaw(getNonChildSkillType(skillType));
+    }
+
+    /**
+     * Get the total amount of XP needed to reach the next level.
      * </br>
      * This function is designed for API usage.
      *
      * @param player The player to get the XP amount for
      * @param skillType The skill to get the XP amount for
-     * @return the amount of XP left before leveling up a specifc skill
+     * @return the total amount of XP needed to reach the next level
+     *
+     * @throws InvalidSkillException if the given skill is not valid
+     * @throws UnsupportedOperationException if the given skill is a child skill
      */
     public static int getXPToNextLevel(Player player, String skillType) {
-        return UserManager.getPlayer(player).getProfile().getXpToLevel(SkillType.getSkill(skillType));
+        return UserManager.getPlayer(player).getProfile().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 playerName 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(String playerName, String skillType) {
+        return getOfflineProfile(playerName).getXpToLevel(getNonChildSkillType(skillType));
+    }
+
+    /**
+     * Get the amount of XP remaining until the next level.
+     * </br>
+     * This function is designed for API usage.
+     *
+     * @param player The player to get the XP amount for
+     * @param skillType The skill to get the XP amount for
+     * @return the amount of XP remaining until the next level
+     *
+     * @throws InvalidSkillException if the given skill is not valid
+     * @throws UnsupportedOperationException if the given skill is a child skill
+     */
+    public static int getXPRemaining(Player player, String skillType) {
+        SkillType skill = getNonChildSkillType(skillType);
+
+        PlayerProfile profile = UserManager.getPlayer(player).getProfile();
+
+        return profile.getXpToLevel(skill) - profile.getSkillXpLevel(skill);
     }
 
     /**
@@ -159,11 +285,18 @@ public final class ExperienceAPI {
      *
      * @param playerName The player to get XP for
      * @param skillType The skill to get XP for
-     * @return the amount of XP in a given skill
+     * @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 int getOfflineXPToNextLevel(String playerName, String skillType) {
-        return getOfflineProfile(playerName).getXpToLevel(SkillType.getSkill(skillType));
+    public static int getOfflineXPRemaining(String playerName, String skillType) {
+        SkillType skill = getNonChildSkillType(skillType);
+
+        PlayerProfile profile = getOfflineProfile(playerName);
+
+        return profile.getXpToLevel(skill) - profile.getSkillXpLevel(skill);
     }
 
     /**
@@ -174,9 +307,11 @@ public final class ExperienceAPI {
      * @param player 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
      */
     public static void addLevel(Player player, String skillType, int levels) {
-        UserManager.getPlayer(player).getProfile().addLevels(SkillType.getSkill(skillType), levels);
+        UserManager.getPlayer(player).getProfile().addLevels(getSkillType(skillType), levels);
     }
 
     /**
@@ -188,12 +323,12 @@ public final class ExperienceAPI {
      * @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(String playerName, String skillType, int levels) {
         PlayerProfile profile = getOfflineProfile(playerName);
-
-        SkillType skill = SkillType.getSkill(skillType);
+        SkillType skill = getSkillType(skillType);
 
         if (skill.isChildSkill()) {
             Set<SkillType> parentSkills = FamilyTree.getParents(skill);
@@ -218,9 +353,11 @@ public final class ExperienceAPI {
      * @param player 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
      */
     public static int getLevel(Player player, String skillType) {
-        return UserManager.getPlayer(player).getProfile().getSkillLevel(SkillType.getSkill(skillType));
+        return UserManager.getPlayer(player).getProfile().getSkillLevel(getSkillType(skillType));
     }
 
     /**
@@ -231,10 +368,12 @@ public final class ExperienceAPI {
      * @param playerName 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(String playerName, String skillType) {
-        return getOfflineProfile(playerName).getSkillLevel(SkillType.getSkill(skillType));
+        return getOfflineProfile(playerName).getSkillLevel(getSkillType(skillType));
     }
 
     /**
@@ -256,17 +395,14 @@ public final class ExperienceAPI {
      *
      * @param playerName 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(String playerName) {
         int powerLevel = 0;
         PlayerProfile profile = getOfflineProfile(playerName);
 
-        for (SkillType type : SkillType.values()) {
-            if (type.isChildSkill()) {
-                continue;
-            }
-
+        for (SkillType type : SkillType.nonChildSkills()) {
             powerLevel += profile.getSkillLevel(type);
         }
 
@@ -280,9 +416,11 @@ public final class ExperienceAPI {
      *
      * @param skillType The skill to get the level cap for
      * @return the level cap of a given skill
+     *
+     * @throws InvalidSkillException if the given skill is not valid
      */
     public static int getLevelCap(String skillType) {
-        return Config.getInstance().getLevelCap(SkillType.getSkill(skillType));
+        return Config.getInstance().getLevelCap(getSkillType(skillType));
     }
 
     /**
@@ -290,7 +428,7 @@ public final class ExperienceAPI {
      * </br>
      * This function is designed for API usage.
      *
-     * @return the power level cap of a given skill
+     * @return the overall power level cap
      */
     public static int getPowerLevelCap() {
         return Config.getInstance().getPowerLevelCap();
@@ -304,9 +442,11 @@ public final class ExperienceAPI {
      * @param player 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
      */
     public static void setLevel(Player player, String skillType, int skillLevel) {
-        UserManager.getPlayer(player).getProfile().modifySkill(SkillType.getSkill(skillType), skillLevel);
+        UserManager.getPlayer(player).getProfile().modifySkill(getSkillType(skillType), skillLevel);
     }
 
     /**
@@ -318,10 +458,11 @@ public final class ExperienceAPI {
      * @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(String playerName, String skillType, int skillLevel) {
-        getOfflineProfile(playerName).modifySkill(SkillType.getSkill(skillType), skillLevel);
+        getOfflineProfile(playerName).modifySkill(getSkillType(skillType), skillLevel);
     }
 
     /**
@@ -332,9 +473,12 @@ public final class ExperienceAPI {
      * @param player 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 UnsupportedOperationException if the given skill is a child skill
      */
     public static void setXP(Player player, String skillType, int newValue) {
-        UserManager.getPlayer(player).getProfile().setSkillXpLevel(SkillType.getSkill(skillType), newValue);
+        UserManager.getPlayer(player).getProfile().setSkillXpLevel(getNonChildSkillType(skillType), newValue);
     }
 
     /**
@@ -346,10 +490,12 @@ public final class ExperienceAPI {
      * @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(String playerName, String skillType, int newValue) {
-        getOfflineProfile(playerName).setSkillXpLevel(SkillType.getSkill(skillType), newValue);
+        getOfflineProfile(playerName).setSkillXpLevel(getNonChildSkillType(skillType), newValue);
     }
 
     /**
@@ -360,9 +506,12 @@ public final class ExperienceAPI {
      * @param player 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 UnsupportedOperationException if the given skill is a child skill
      */
     public static void removeXP(Player player, String skillType, int xp) {
-        UserManager.getPlayer(player).getProfile().removeXp(SkillType.getSkill(skillType), xp);
+        UserManager.getPlayer(player).getProfile().removeXp(getNonChildSkillType(skillType), xp);
     }
 
     /**
@@ -374,23 +523,18 @@ public final class ExperienceAPI {
      * @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(String playerName, String skillType, int xp) {
-        getOfflineProfile(playerName).removeXp(SkillType.getSkill(skillType), xp);
+        getOfflineProfile(playerName).removeXp(getNonChildSkillType(skillType), xp);
     }
 
-    /**
-     * Add XP to an offline player.
-     *
-     * @param playerName The player to check
-     * @param skillType The skill to check
-     * @param XP The amount of XP to award.
-     */
-    private static void addOfflineXP(String playerName, String skillType, int XP) {
-        PlayerProfile profile = getOfflineProfile(playerName);
+    // Utility methods follow.
 
-        SkillType skill = SkillType.getSkill(skillType);
+    private static void addOfflineXP(String playerName, SkillType skill, int XP) {
+        PlayerProfile profile = getOfflineProfile(playerName);
 
         if (skill.isChildSkill()) {
             Set<SkillType> parentSkills = FamilyTree.getParents(skill);
@@ -416,4 +560,24 @@ public final class ExperienceAPI {
 
         return profile;
     }
+
+    private static SkillType getSkillType(String skillType) throws InvalidSkillException {
+        SkillType skill = SkillType.getSkill(skillType);
+
+        if (skill == null) {
+            throw new InvalidSkillException();
+        }
+
+        return skill;
+    }
+
+    private static SkillType getNonChildSkillType(String skillType) throws InvalidSkillException, UnsupportedOperationException {
+        SkillType skill = getSkillType(skillType);
+
+        if (skill.isChildSkill()) {
+            throw new UnsupportedOperationException("Child skills do not have XP");
+        }
+
+        return skill;
+    }
 }

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

@@ -1,10 +1,13 @@
 package com.gmail.nossr50.api;
 
+import java.util.ArrayList;
+import java.util.LinkedHashSet;
 import java.util.List;
 
 import org.bukkit.OfflinePlayer;
 import org.bukkit.entity.Player;
 
+import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.datatypes.party.Party;
 import com.gmail.nossr50.party.PartyManager;
 import com.gmail.nossr50.util.player.UserManager;
@@ -74,14 +77,13 @@ public final class PartyAPI {
      */
     public static void addToParty(Player player, String partyName) {
         Party party = PartyManager.getParty(partyName);
+        String playerName = player.getName();
 
         if (party == null) {
-            party = new Party();
-            party.setName(partyName);
-            party.setLeader(player.getName());
+            party = new Party(playerName, partyName);
         }
 
-        PartyManager.addToParty(player, UserManager.getPlayer(player), party);
+        PartyManager.addToParty(playerName, UserManager.getPlayer(player), party);
     }
 
     /**
@@ -127,7 +129,26 @@ public final class PartyAPI {
      * @param player The player to check
      * @return all the players in the player's party
      */
+    @Deprecated
     public static List<OfflinePlayer> getOnlineAndOfflineMembers(Player player) {
+        List<OfflinePlayer> members = new ArrayList<OfflinePlayer>();
+
+        for (String memberName : PartyManager.getAllMembers(player)) {
+            OfflinePlayer member = mcMMO.p.getServer().getOfflinePlayer(memberName);
+            members.add(member);
+        }
+        return members;
+    }
+
+    /**
+     * Get a list of all player names in this player's party.
+     * </br>
+     * This function is designed for API usage.
+     *
+     * @param player The player to check
+     * @return all the player names in the player's party
+     */
+    public static LinkedHashSet<String> getMembers(Player player) {
         return PartyManager.getAllMembers(player);
     }
 

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

@@ -1,4 +1,4 @@
-package com.gmail.nossr50.api;
+package com.gmail.nossr50.api.exceptions;
 
 public class InvalidPlayerException extends RuntimeException {
     private static final long serialVersionUID = 907213002618581385L;

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

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

src/main/java/com/gmail/nossr50/chat/AdminChatManager.java

@@ -0,0 +1,22 @@
+package com.gmail.nossr50.chat;
+
+import org.bukkit.plugin.Plugin;
+
+import com.gmail.nossr50.config.Config;
+import com.gmail.nossr50.events.chat.McMMOAdminChatEvent;
+
+public class AdminChatManager extends ChatManager {
+    protected AdminChatManager(Plugin plugin) {
+        super(plugin, Config.getInstance().getAdminDisplayNames(), "Commands.AdminChat.Prefix");
+    }
+
+    @Override
+    public void handleChat(String senderName, String displayName, String message, boolean isAsync) {
+        handleChat(new McMMOAdminChatEvent(plugin, senderName, displayName, message, isAsync));
+    }
+
+    @Override
+    protected void sendMessage() {
+        plugin.getServer().broadcast(message, "mcmmo.chat.adminchat");
+    }
+}

src/main/java/com/gmail/nossr50/chat/ChatManager.java

@@ -1,78 +1,51 @@
 package com.gmail.nossr50.chat;
 
-import org.bukkit.ChatColor;
 import org.bukkit.entity.Player;
 import org.bukkit.plugin.Plugin;
 
-import com.gmail.nossr50.mcMMO;
-import com.gmail.nossr50.config.Config;
-import com.gmail.nossr50.datatypes.party.Party;
-import com.gmail.nossr50.events.chat.McMMOAdminChatEvent;
-import com.gmail.nossr50.events.chat.McMMOPartyChatEvent;
+import com.gmail.nossr50.events.chat.McMMOChatEvent;
 import com.gmail.nossr50.locale.LocaleLoader;
 
-public final class ChatManager {
-    public ChatManager () {}
+public abstract class ChatManager {
+    protected Plugin plugin;
+    protected boolean useDisplayNames;
+    protected String chatPrefix;
 
-    public static void handleAdminChat(Plugin plugin, String playerName, String displayName, String message, boolean isAsync) {
-        McMMOAdminChatEvent chatEvent = new McMMOAdminChatEvent(plugin, playerName, displayName, message, isAsync);
-        mcMMO.p.getServer().getPluginManager().callEvent(chatEvent);
+    protected String displayName;
+    protected String message;
 
-        if (chatEvent.isCancelled()) {
+    protected ChatManager(Plugin plugin, boolean useDisplayNames, String chatPrefix) {
+        this.plugin = plugin;
+        this.useDisplayNames = useDisplayNames;
+        this.chatPrefix = chatPrefix;
+    }
+
+    protected void handleChat(McMMOChatEvent event) {
+        plugin.getServer().getPluginManager().callEvent(event);
+
+        if (event.isCancelled()) {
             return;
         }
 
-        if (Config.getInstance().getAdminDisplayNames()) {
-            displayName = chatEvent.getDisplayName();
-        }
-        else {
-            displayName = chatEvent.getSender();
-        }
+        displayName = useDisplayNames ? event.getDisplayName() : event.getSender();
+        message = LocaleLoader.getString(chatPrefix, displayName) + event.getMessage();
 
-        String adminMessage = chatEvent.getMessage();
-
-        mcMMO.p.getServer().broadcast(LocaleLoader.getString("Commands.AdminChat.Prefix", displayName) + adminMessage, "mcmmo.chat.adminchat");
+        sendMessage();
     }
 
-    public static void handleAdminChat(Plugin plugin, String senderName, String message) {
-        handleAdminChat(plugin, senderName, senderName, message);
+    public void handleChat(String senderName, String message) {
+        handleChat(senderName, senderName, message, false);
     }
 
-    public static void handleAdminChat(Plugin plugin, String playerName, String displayName, String message) {
-        handleAdminChat(plugin, playerName, displayName, message, false);
+    public void handleChat(Player player, String message, boolean isAsync) {
+        handleChat(player.getName(), player.getDisplayName(), message, isAsync);
     }
 
-    public static void handlePartyChat(Plugin plugin, Party party, String playerName, String displayName, String message, boolean isAsync) {
-        String partyName = party.getName();
-
-        McMMOPartyChatEvent chatEvent = new McMMOPartyChatEvent(plugin, playerName, displayName, partyName, message, isAsync);
-        mcMMO.p.getServer().getPluginManager().callEvent(chatEvent);
-
-        if (chatEvent.isCancelled()) {
-            return;
-        }
-
-        if (Config.getInstance().getPartyDisplayNames()) {
-            displayName = chatEvent.getDisplayName();
-        }
-        else {
-            displayName = chatEvent.getSender();
-        }
-
-        String partyMessage = chatEvent.getMessage();
-
-        for (Player member : party.getOnlineMembers()) {
-            member.sendMessage(LocaleLoader.getString("Commands.Party.Chat.Prefix", displayName) + partyMessage);
-        }
-
-        mcMMO.p.getLogger().info("[P](" + partyName + ")" + "<" + ChatColor.stripColor(displayName) + "> " + partyMessage);
+    public void handleChat(String senderName, String displayName, String message) {
+        handleChat(senderName, displayName, message, false);
     }
 
-    public static void handlePartyChat(Plugin plugin, Party party, String senderName, String message) {
-        handlePartyChat(plugin, party, senderName, senderName, message);
-    }
+    public abstract void handleChat(String senderName, String displayName, String message, boolean isAsync);
 
-    public static void handlePartyChat(Plugin plugin, Party party, String playerName, String displayName, String message) {
-        handlePartyChat(plugin, party, playerName, displayName, message, false);
-    }
+    protected abstract void sendMessage();
 }

src/main/java/com/gmail/nossr50/chat/ChatManagerFactory.java

@@ -0,0 +1,29 @@
+package com.gmail.nossr50.chat;
+
+import java.util.HashMap;
+
+import org.bukkit.plugin.Plugin;
+
+public class ChatManagerFactory {
+    private static final HashMap<Plugin, AdminChatManager> adminChatManagers = new HashMap<Plugin, AdminChatManager>();
+    private static final HashMap<Plugin, PartyChatManager> partyChatManagers = new HashMap<Plugin, PartyChatManager>();
+
+    public static ChatManager getChatManager(Plugin plugin, ChatMode mode) {
+        switch (mode) {
+            case ADMIN:
+                if (!adminChatManagers.containsKey(plugin)) {
+                    adminChatManagers.put(plugin, new AdminChatManager(plugin));
+                }
+
+                return adminChatManagers.get(plugin);
+            case PARTY:
+                if (!partyChatManagers.containsKey(plugin)) {
+                    partyChatManagers.put(plugin, new PartyChatManager(plugin));
+                }
+
+                return partyChatManagers.get(plugin);
+            default:
+                return null;
+        }
+    }
+}

src/main/java/com/gmail/nossr50/chat/PartyChatManager.java

@@ -0,0 +1,34 @@
+package com.gmail.nossr50.chat;
+
+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;
+
+public class PartyChatManager extends ChatManager {
+    private Party party;
+
+    protected PartyChatManager(Plugin plugin) {
+        super(plugin, Config.getInstance().getPartyDisplayNames(), "Commands.Party.Chat.Prefix");
+    }
+
+    public void setParty(Party party) {
+        this.party = party;
+    }
+
+    @Override
+    public void handleChat(String senderName, String displayName, String message, boolean isAsync) {
+        handleChat(new McMMOPartyChatEvent(plugin, senderName, displayName, party.getName(), message, isAsync));
+    }
+
+    @Override
+    protected void sendMessage() {
+        for (Player member : party.getOnlineMembers()) {
+            member.sendMessage(message);
+        }
+
+        plugin.getLogger().info("[P]<" + party.getName() + ">" + message);
+    }
+}

src/main/java/com/gmail/nossr50/commands/KrakenCommand.java

@@ -0,0 +1,66 @@
+package com.gmail.nossr50.commands;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
+import org.bukkit.entity.Player;
+import org.bukkit.util.StringUtil;
+
+import com.gmail.nossr50.datatypes.player.McMMOPlayer;
+import com.gmail.nossr50.util.Permissions;
+import com.gmail.nossr50.util.commands.CommandUtils;
+import com.gmail.nossr50.util.player.UserManager;
+import com.google.common.collect.ImmutableList;
+
+public class KrakenCommand implements TabExecutor {
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        switch (args.length) {
+            case 0:
+                if (CommandUtils.noConsoleUsage(sender)) {
+                    return true;
+                }
+
+                if (!Permissions.kraken(sender)) {
+                    sender.sendMessage(command.getPermissionMessage());
+                    return true;
+                }
+
+                UserManager.getPlayer((Player) sender).getFishingManager().unleashTheKraken();
+                return true;
+
+            case 1:
+                if (!Permissions.krakenOthers(sender)) {
+                    sender.sendMessage(command.getPermissionMessage());
+                    return true;
+                }
+
+                McMMOPlayer mcMMOPlayer = UserManager.getPlayer(args[0]);
+
+                if (!CommandUtils.checkPlayerExistence(sender, args[0], mcMMOPlayer)) {
+                    return true;
+                }
+
+                mcMMOPlayer.getFishingManager().unleashTheKraken();
+                return true;
+
+            default:
+                return false;
+        }
+    }
+
+    @Override
+    public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) {
+        switch (args.length) {
+            case 1:
+                Set<String> playerNames = UserManager.getPlayers().keySet();
+                return StringUtil.copyPartialMatches(args[0], playerNames, new ArrayList<String>(playerNames.size()));
+            default:
+                return ImmutableList.of();
+        }
+    }
+}

src/main/java/com/gmail/nossr50/commands/McabilityCommand.java

@@ -1,74 +1,29 @@
 package com.gmail.nossr50.commands;
 
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
 import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
 
-import com.gmail.nossr50.datatypes.player.McMMOPlayer;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.util.Permissions;
-import com.gmail.nossr50.util.commands.CommandUtils;
-import com.gmail.nossr50.util.player.UserManager;
 
-public class McabilityCommand implements CommandExecutor {
-    private McMMOPlayer mcMMOPlayer;
-    private Player player;
+public class McabilityCommand extends ToggleCommand {
+    @Override
+    protected boolean hasOtherPermission(CommandSender sender) {
+        return Permissions.mcabilityOthers(sender);
+    }
 
     @Override
-    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        switch (args.length) {
-            case 0:
-                if (CommandUtils.noConsoleUsage(sender)) {
-                    return true;
-                }
-
-                if (!Permissions.mcability(sender)) {
-                    sender.sendMessage(command.getPermissionMessage());
-                    return true;
-                }
-
-                mcMMOPlayer = UserManager.getPlayer(sender.getName());
-                player = mcMMOPlayer.getPlayer();
-
-                toggleAbilityUse();
-                return true;
-
-            case 1:
-                if (!Permissions.mcabilityOthers(sender)) {
-                    sender.sendMessage(command.getPermissionMessage());
-                    return true;
-                }
-
-                mcMMOPlayer = UserManager.getPlayer(args[0]);
-
-                if (!CommandUtils.checkPlayerExistence(sender, args[0], mcMMOPlayer)) {
-                    return true;
-                }
-
-                player = mcMMOPlayer.getPlayer();
-
-                if (CommandUtils.isOffline(sender, player)) {
-                    return true;
-                }
-
-                toggleAbilityUse();
-                sender.sendMessage("Ability use has been toggled for " + player.getName()); // TODO: Localize
-                return true;
-
-            default:
-                return false;
-        }
+    protected boolean hasSelfPermission(CommandSender sender) {
+        return Permissions.mcability(sender);
     }
 
-    private void toggleAbilityUse() {
-        if (mcMMOPlayer.getAbilityUse()) {
-            player.sendMessage(LocaleLoader.getString("Commands.Ability.Off"));
-        }
-        else {
-            player.sendMessage(LocaleLoader.getString("Commands.Ability.On"));
-        }
-
+    @Override
+    protected void applyCommandAction() {
+        player.sendMessage(LocaleLoader.getString("Commands.Ability." + (mcMMOPlayer.getAbilityUse() ? "Off" : "On")));
         mcMMOPlayer.toggleAbilityUse();
     }
+
+    @Override
+    protected void sendSuccessMessage(CommandSender sender) {
+        sender.sendMessage("Ability use has been toggled for " + player.getName()); // TODO: Localize
+    }
 }

src/main/java/com/gmail/nossr50/commands/McgodCommand.java

@@ -1,74 +1,29 @@
 package com.gmail.nossr50.commands;
 
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
 import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
 
-import com.gmail.nossr50.datatypes.player.McMMOPlayer;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.util.Permissions;
-import com.gmail.nossr50.util.commands.CommandUtils;
-import com.gmail.nossr50.util.player.UserManager;
 
-public class McgodCommand implements CommandExecutor {
-    private McMMOPlayer mcMMOPlayer;
-    private Player player;
+public class McgodCommand extends ToggleCommand {
+    @Override
+    protected boolean hasOtherPermission(CommandSender sender) {
+        return Permissions.mcgodOthers(sender);
+    }
 
     @Override
-    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        switch (args.length) {
-            case 0:
-                if (CommandUtils.noConsoleUsage(sender)) {
-                    return true;
-                }
-
-                if (!Permissions.mcgod(sender)) {
-                    sender.sendMessage(command.getPermissionMessage());
-                    return true;
-                }
-
-                mcMMOPlayer = UserManager.getPlayer(sender.getName());
-                player = mcMMOPlayer.getPlayer();
-
-                toggleGodMode();
-                return true;
-
-            case 1:
-                if (!Permissions.mcgodOthers(sender)) {
-                    sender.sendMessage(command.getPermissionMessage());
-                    return true;
-                }
-
-                mcMMOPlayer = UserManager.getPlayer(args[0]);
-
-                if (!CommandUtils.checkPlayerExistence(sender, args[0], mcMMOPlayer)) {
-                    return true;
-                }
-
-                player = mcMMOPlayer.getPlayer();
-
-                if (CommandUtils.isOffline(sender, player)) {
-                    return true;
-                }
-
-                toggleGodMode();
-                sender.sendMessage("God mode has been toggled for " + player.getName()); // TODO: Localize
-                return true;
-
-            default:
-                return false;
-        }
+    protected boolean hasSelfPermission(CommandSender sender) {
+        return Permissions.mcgod(sender);
     }
 
-    private void toggleGodMode() {
-        if (mcMMOPlayer.getGodMode()) {
-            player.sendMessage(LocaleLoader.getString("Commands.GodMode.Disabled"));
-        }
-        else {
-            player.sendMessage(LocaleLoader.getString("Commands.GodMode.Enabled"));
-        }
-
+    @Override
+    protected void applyCommandAction() {
+        player.sendMessage(LocaleLoader.getString("Commands.GodMode." + (mcMMOPlayer.getGodMode() ? "Disabled" : "Enabled")));
         mcMMOPlayer.toggleGodMode();
     }
+
+    @Override
+    protected void sendSuccessMessage(CommandSender sender) {
+        sender.sendMessage("God mode has been toggled for " + player.getName()); // TODO: Localize
+    }
 }

src/main/java/com/gmail/nossr50/commands/McmmoCommand.java

@@ -1,17 +1,17 @@
 package com.gmail.nossr50.commands;
 
 import org.bukkit.ChatColor;
-import org.bukkit.Material;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandExecutor;
 import org.bukkit.command.CommandSender;
-import org.getspout.spoutapi.player.SpoutPlayer;
+import org.bukkit.entity.Player;
 
 import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.commands.party.PartySubcommandType;
 import com.gmail.nossr50.config.Config;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.util.Permissions;
+import com.gmail.nossr50.util.spout.SpoutUtils;
 
 public class McmmoCommand implements CommandExecutor {
     @Override
@@ -28,13 +28,13 @@ public class McmmoCommand implements CommandExecutor {
                 sender.sendMessage(mcSplit);
 
                 if (Config.getInstance().getDonateMessageEnabled()) {
-                    if (mcMMO.spoutEnabled && sender instanceof SpoutPlayer) {
-                        SpoutPlayer spoutPlayer = (SpoutPlayer) sender;
-                        spoutPlayer.sendNotification(LocaleLoader.getString("Spout.Donate"), ChatColor.GREEN + "gjmcferrin@gmail.com", Material.DIAMOND);
+                    if (mcMMO.isSpoutEnabled() && sender instanceof Player) {
+                        SpoutUtils.sendDonationNotification((Player) sender);
+                    }
+                    else {
+                        sender.sendMessage(LocaleLoader.getString("MOTD.Donate"));
+                        sender.sendMessage(ChatColor.GOLD + " - " + ChatColor.GREEN + "gjmcferrin@gmail.com" + ChatColor.GOLD + " Paypal");
                     }
-
-                    sender.sendMessage(LocaleLoader.getString("MOTD.Donate"));
-                    sender.sendMessage(ChatColor.GOLD + " - " + ChatColor.GREEN + "gjmcferrin@gmail.com" + ChatColor.GOLD + " Paypal");
                 }
 
                 sender.sendMessage(LocaleLoader.getString("MOTD.Version", mcMMO.p.getDescription().getVersion()));
@@ -62,52 +62,52 @@ public class McmmoCommand implements CommandExecutor {
     private void displayPartyCommands(CommandSender sender) {
         if (Permissions.party(sender)) {
             sender.sendMessage(LocaleLoader.getString("Commands.Party.Commands"));
-            sender.sendMessage("/party create <" + LocaleLoader.getString("Commands.Usage.PartyName") + "> " + LocaleLoader.getString("Commands.Party1"));
-            sender.sendMessage("/party join <" + LocaleLoader.getString("Commands.Usage.Player") + "> " + LocaleLoader.getString("Commands.Party2"));
-            sender.sendMessage("/party quit " + LocaleLoader.getString("Commands.Party.Quit"));
+            sender.sendMessage(" /party create <" + LocaleLoader.getString("Commands.Usage.PartyName") + "> " + LocaleLoader.getString("Commands.Party1"));
+            sender.sendMessage(" /party join <" + LocaleLoader.getString("Commands.Usage.Player") + "> " + LocaleLoader.getString("Commands.Party2"));
+            sender.sendMessage(" /party quit " + LocaleLoader.getString("Commands.Party.Quit"));
 
             if (Permissions.partyChat(sender)) {
-                sender.sendMessage("/party chat " + LocaleLoader.getString("Commands.Party.Toggle"));
+                sender.sendMessage(" /party chat " + LocaleLoader.getString("Commands.Party.Toggle"));
             }
 
-            sender.sendMessage("/party invite <" + LocaleLoader.getString("Commands.Usage.Player") + "> " + LocaleLoader.getString("Commands.Party.Invite"));
-            sender.sendMessage("/party accept " + LocaleLoader.getString("Commands.Party.Accept"));
+            sender.sendMessage(" /party invite <" + LocaleLoader.getString("Commands.Usage.Player") + "> " + LocaleLoader.getString("Commands.Party.Invite"));
+            sender.sendMessage(" /party accept " + LocaleLoader.getString("Commands.Party.Accept"));
 
             if (Permissions.partySubcommand(sender, PartySubcommandType.TELEPORT)) {
-                sender.sendMessage("/party teleport " + LocaleLoader.getString("Commands.Party.Teleport"));
+                sender.sendMessage(" /party teleport " + LocaleLoader.getString("Commands.Party.Teleport"));
             }
         }
     }
 
     private void displayOtherCommands(CommandSender sender) {
         sender.sendMessage(LocaleLoader.getString("Commands.Other"));
-        sender.sendMessage("/mcstats " + LocaleLoader.getString("Commands.Stats"));
-        sender.sendMessage("/mctop " + LocaleLoader.getString("Commands.Leaderboards"));
+        sender.sendMessage(" /mcstats " + LocaleLoader.getString("Commands.Stats"));
+        sender.sendMessage(" /mctop " + LocaleLoader.getString("Commands.Leaderboards"));
 
         if (Permissions.skillreset(sender)) {
-            sender.sendMessage("/skillreset <skill|all> " + LocaleLoader.getString("Commands.Reset"));
+            sender.sendMessage(" /skillreset <skill|all> " + LocaleLoader.getString("Commands.Reset"));
         }
 
         if (Permissions.mcability(sender)) {
-            sender.sendMessage("/mcability " + LocaleLoader.getString("Commands.ToggleAbility"));
+            sender.sendMessage(" /mcability " + LocaleLoader.getString("Commands.ToggleAbility"));
         }
 
         if (Permissions.adminChat(sender)) {
-            sender.sendMessage("/adminchat " + LocaleLoader.getString("Commands.AdminToggle"));
+            sender.sendMessage(" /adminchat " + LocaleLoader.getString("Commands.AdminToggle"));
         }
 
         if (Permissions.inspect(sender)) {
-            sender.sendMessage("/inspect " + LocaleLoader.getString("Commands.Inspect"));
+            sender.sendMessage(" /inspect " + LocaleLoader.getString("Commands.Inspect"));
         }
 
         if (Permissions.mmoedit(sender)) {
-            sender.sendMessage("/mmoedit " + LocaleLoader.getString("Commands.mmoedit"));
+            sender.sendMessage(" /mmoedit " + LocaleLoader.getString("Commands.mmoedit"));
         }
 
         if (Permissions.mcgod(sender)) {
-            sender.sendMessage("/mcgod " + LocaleLoader.getString("Commands.mcgod"));
+            sender.sendMessage(" /mcgod " + LocaleLoader.getString("Commands.mcgod"));
         }
 
-        sender.sendMessage(LocaleLoader.getString("Commands.SkillInfo"));
+        sender.sendMessage(" /<skill>" + LocaleLoader.getString("Commands.SkillInfo"));
     }
 }

src/main/java/com/gmail/nossr50/commands/McnotifyCommand.java

@@ -1,27 +1,26 @@
 package com.gmail.nossr50.commands;
 
+import java.util.List;
+
 import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
 import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
+import org.bukkit.entity.Player;
 
 import com.gmail.nossr50.datatypes.player.McMMOPlayer;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.util.player.UserManager;
 
-public class McnotifyCommand implements CommandExecutor {
+import com.google.common.collect.ImmutableList;
+
+public class McnotifyCommand implements TabExecutor {
     @Override
     public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
         switch (args.length) {
             case 0:
-                McMMOPlayer mcMMOPlayer = UserManager.getPlayer(sender.getName());
-
-                if (mcMMOPlayer.useChatNotifications()) {
-                    sender.sendMessage(LocaleLoader.getString("Commands.Notifications.Off"));
-                }
-                else {
-                    sender.sendMessage(LocaleLoader.getString("Commands.Notifications.On"));
-                }
+                McMMOPlayer mcMMOPlayer = UserManager.getPlayer((Player) sender);
 
+                sender.sendMessage(LocaleLoader.getString("Commands.Notifications." + (mcMMOPlayer.useChatNotifications() ? "Off" : "On")));
                 mcMMOPlayer.toggleChatNotifications();
                 return true;
 
@@ -29,4 +28,9 @@ public class McnotifyCommand implements CommandExecutor {
                 return false;
         }
     }
+
+    @Override
+    public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) {
+        return ImmutableList.of();
+    }
 }

src/main/java/com/gmail/nossr50/commands/McrefreshCommand.java

@@ -1,74 +1,33 @@
 package com.gmail.nossr50.commands;
 
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
 import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
 
-import com.gmail.nossr50.datatypes.player.McMMOPlayer;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.util.Permissions;
-import com.gmail.nossr50.util.commands.CommandUtils;
-import com.gmail.nossr50.util.player.UserManager;
-
-public class McrefreshCommand implements CommandExecutor {
-    private McMMOPlayer mcMMOPlayer;
-    private Player player;
 
+public class McrefreshCommand extends ToggleCommand {
     @Override
-    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        switch (args.length) {
-            case 0:
-                if (CommandUtils.noConsoleUsage(sender)) {
-                    return true;
-                }
-
-                if (!Permissions.mcrefresh(sender)) {
-                    sender.sendMessage(command.getPermissionMessage());
-                    return true;
-                }
-
-                mcMMOPlayer = UserManager.getPlayer(sender.getName());
-                player = mcMMOPlayer.getPlayer();
-
-                refreshPlayer();
-                return true;
-
-            case 1:
-                if (!Permissions.mcrefreshOthers(sender)) {
-                    sender.sendMessage(command.getPermissionMessage());
-                    return true;
-                }
-
-                mcMMOPlayer = UserManager.getPlayer(args[0]);
-
-                if (!CommandUtils.checkPlayerExistence(sender, args[0], mcMMOPlayer)) {
-                    return true;
-                }
-
-                Player player = mcMMOPlayer.getPlayer();
-
-                if (CommandUtils.isOffline(sender, player)) {
-                    return true;
-                }
-
-                refreshPlayer();
-                sender.sendMessage(LocaleLoader.getString("Commands.mcrefresh.Success", player.getName()));
-                return true;
-
-            default:
-                return false;
-        }
+    protected boolean hasOtherPermission(CommandSender sender) {
+        return Permissions.mcrefreshOthers(sender);
     }
 
-    private void refreshPlayer() {
+    @Override
+    protected boolean hasSelfPermission(CommandSender sender) {
+        return Permissions.mcrefresh(sender);
+    }
+
+    @Override
+    protected void applyCommandAction() {
         mcMMOPlayer.setRecentlyHurt(0);
         mcMMOPlayer.getProfile().resetCooldowns();
         mcMMOPlayer.resetToolPrepMode();
         mcMMOPlayer.resetAbilityMode();
 
-        player.setCanPickupItems(true);
-        player = mcMMOPlayer.getPlayer();
         player.sendMessage(LocaleLoader.getString("Ability.Generic.Refresh"));
     }
+
+    @Override
+    protected void sendSuccessMessage(CommandSender sender) {
+        sender.sendMessage(LocaleLoader.getString("Commands.mcrefresh.Success", player.getName()));
+    }
 }

src/main/java/com/gmail/nossr50/commands/McscoreboardCommand.java

@@ -0,0 +1,141 @@
+package com.gmail.nossr50.commands;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
+import org.bukkit.entity.Player;
+import org.bukkit.util.StringUtil;
+
+import com.gmail.nossr50.mcMMO;
+import com.gmail.nossr50.config.Config;
+import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.util.StringUtils;
+import com.gmail.nossr50.util.commands.CommandUtils;
+import com.gmail.nossr50.util.player.UserManager;
+import com.gmail.nossr50.util.scoreboards.ScoreboardManager;
+import com.google.common.collect.ImmutableList;
+
+public class McscoreboardCommand implements TabExecutor {
+    private static final List<String> SCOREBOARD_TYPES = ImmutableList.of("clear", "rank", "stats", "top");
+
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        if (CommandUtils.noConsoleUsage(sender)) {
+            return true;
+        }
+
+        Player player = (Player) sender;
+
+        switch (args.length) {
+            case 0:
+                clearScoreboard(player);
+                return true;
+
+            case 1:
+                if (args[0].equalsIgnoreCase("clear")) {
+                    clearScoreboard(player);
+                }
+                else if (args[0].equalsIgnoreCase("rank")) {
+                    if (!Config.getInstance().getMcrankScoreboardEnabled()) {
+                        sender.sendMessage("This scoreboard is not enabled."); //TODO: Localize
+                        return true;
+                    }
+
+                    ScoreboardManager.setupPlayerScoreboard(player.getName());
+                    ScoreboardManager.enablePlayerRankScoreboard(player);
+                }
+                else if (args[0].equalsIgnoreCase("stats")) {
+                    if (!Config.getInstance().getMcstatsScoreboardsEnabled()) {
+                        sender.sendMessage("This scoreboard is not enabled."); //TODO: Localize
+                        return true;
+                    }
+
+                    ScoreboardManager.setupPlayerScoreboard(player.getName());
+                    ScoreboardManager.enablePlayerStatsScoreboard(UserManager.getPlayer(player));
+                }
+                else if (args[0].equalsIgnoreCase("top")) {
+                    if (!Config.getInstance().getMctopScoreboardEnabled()) {
+                        sender.sendMessage("This scoreboard is not enabled."); //TODO: Localize
+                        return true;
+                    }
+
+                    ScoreboardManager.enableGlobalStatsScoreboard(player, "all", 1);
+                }
+                else {
+                    return false;
+                }
+
+                return true;
+
+            case 2:
+                if (!args[0].equalsIgnoreCase("top")) {
+                    return false;
+                }
+
+                if (!Config.getInstance().getMctopScoreboardEnabled()) {
+                    sender.sendMessage("This scoreboard is not enabled."); //TODO: Localize
+                    return true;
+                }
+
+                if (StringUtils.isInt(args[1])) {
+                    ScoreboardManager.enableGlobalStatsScoreboard(player, "all", Math.abs(Integer.parseInt(args[1])));
+                    return true;
+                }
+
+                if (CommandUtils.isInvalidSkill(sender, args[1])) {
+                    return true;
+                }
+
+                ScoreboardManager.enableGlobalStatsScoreboard(player, args[1], 1);
+                return true;
+
+            case 3:
+                if (!args[0].equalsIgnoreCase("top")) {
+                    return false;
+                }
+
+                if (!Config.getInstance().getMctopScoreboardEnabled()) {
+                    sender.sendMessage("This scoreboard is not enabled."); //TODO: Localize
+                    return true;
+                }
+
+                if (CommandUtils.isInvalidSkill(sender, args[1])) {
+                    return true;
+                }
+
+                if (CommandUtils.isInvalidInteger(sender, args[2])) {
+                    return true;
+                }
+
+                ScoreboardManager.enableGlobalStatsScoreboard(player, args[1], Math.abs(Integer.parseInt(args[2])));
+                return true;
+
+            default:
+                return false;
+        }
+    }
+
+    @Override
+    public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) {
+        switch (args.length) {
+            case 1:
+                return StringUtil.copyPartialMatches(args[0], SCOREBOARD_TYPES, new ArrayList<String>(SCOREBOARD_TYPES.size()));
+            case 2:
+                if (args[0].equalsIgnoreCase("top")) {
+                    return StringUtil.copyPartialMatches(args[1], SkillType.SKILL_NAMES, new ArrayList<String>(SkillType.SKILL_NAMES.size()));
+                }
+                // Fallthrough
+
+            default:
+                return ImmutableList.of();
+        }
+    }
+
+    private void clearScoreboard(Player player) {
+        player.setScoreboard(mcMMO.p.getServer().getScoreboardManager().getMainScoreboard());
+        player.sendMessage("Your scoreboard has been cleared!"); //TODO: Locale
+    }
+}

src/main/java/com/gmail/nossr50/commands/MobhealthCommand.java

@@ -0,0 +1,69 @@
+package com.gmail.nossr50.commands;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
+import org.bukkit.entity.Player;
+import org.bukkit.util.StringUtil;
+
+import com.gmail.nossr50.datatypes.MobHealthbarType;
+import com.gmail.nossr50.datatypes.player.PlayerProfile;
+import com.gmail.nossr50.util.commands.CommandUtils;
+import com.gmail.nossr50.util.player.UserManager;
+
+import com.google.common.collect.ImmutableList;
+
+public class MobhealthCommand implements TabExecutor {
+    private static final List<String> MOB_HEALTHBAR_TYPES;
+
+    static {
+        ArrayList<String> types = new ArrayList<String>();
+
+        for (MobHealthbarType type : MobHealthbarType.values()) {
+            types.add(type.toString());
+        }
+
+        Collections.sort(types);
+        MOB_HEALTHBAR_TYPES = ImmutableList.copyOf(types);
+    }
+
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        if (CommandUtils.noConsoleUsage(sender)) {
+            return true;
+        }
+
+        switch (args.length) {
+            case 1:
+                PlayerProfile playerProfile = UserManager.getPlayer((Player) sender).getProfile();
+
+                try {
+                    MobHealthbarType type = MobHealthbarType.valueOf(args[0].toUpperCase().trim());
+                    playerProfile.setMobHealthbarType(type);
+                    sender.sendMessage("Display type changed to: " + type); //TODO: Localize
+                    return true;
+                }
+                catch (IllegalArgumentException ex) {
+                    sender.sendMessage("Invalid type!"); //TODO: Localize
+                    return true;
+                }
+
+            default:
+                return false;
+        }
+    }
+
+    @Override
+    public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) {
+        switch (args.length) {
+            case 1:
+                return StringUtil.copyPartialMatches(args[0], MOB_HEALTHBAR_TYPES, new ArrayList<String>(MOB_HEALTHBAR_TYPES.size()));
+            default:
+                return ImmutableList.of();
+        }
+    }
+}

src/main/java/com/gmail/nossr50/commands/ToggleCommand.java

@@ -0,0 +1,84 @@
+package com.gmail.nossr50.commands;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
+import org.bukkit.entity.Player;
+import org.bukkit.util.StringUtil;
+
+import com.gmail.nossr50.datatypes.player.McMMOPlayer;
+import com.gmail.nossr50.util.commands.CommandUtils;
+import com.gmail.nossr50.util.player.UserManager;
+
+import com.google.common.collect.ImmutableList;
+
+public abstract class ToggleCommand implements TabExecutor {
+    protected McMMOPlayer mcMMOPlayer;
+    protected Player player;
+
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        switch (args.length) {
+            case 0:
+                if (CommandUtils.noConsoleUsage(sender)) {
+                    return true;
+                }
+
+                if (!hasSelfPermission(sender)) {
+                    sender.sendMessage(command.getPermissionMessage());
+                    return true;
+                }
+
+                player = (Player) sender;
+                mcMMOPlayer = UserManager.getPlayer(player);
+
+                applyCommandAction();
+                return true;
+
+            case 1:
+                if (!hasOtherPermission(sender)) {
+                    sender.sendMessage(command.getPermissionMessage());
+                    return true;
+                }
+
+                mcMMOPlayer = UserManager.getPlayer(args[0]);
+
+                if (!CommandUtils.checkPlayerExistence(sender, args[0], mcMMOPlayer)) {
+                    return true;
+                }
+
+                player = mcMMOPlayer.getPlayer();
+
+                if (CommandUtils.isOffline(sender, player)) {
+                    return true;
+                }
+
+                applyCommandAction();
+                sendSuccessMessage(sender);
+                return true;
+
+            default:
+                return false;
+        }
+    }
+
+    @Override
+    public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) {
+        switch (args.length) {
+            case 1:
+                Set<String> playerNames = UserManager.getPlayers().keySet();
+                return StringUtil.copyPartialMatches(args[0], playerNames, new ArrayList<String>(playerNames.size()));
+            default:
+                return ImmutableList.of();
+        }
+    }
+
+    protected abstract boolean hasOtherPermission(CommandSender sender);
+    protected abstract boolean hasSelfPermission(CommandSender sender);
+    protected abstract void applyCommandAction();
+    protected abstract void sendSuccessMessage(CommandSender sender);
+}

src/main/java/com/gmail/nossr50/commands/XprateCommand.java

@@ -1,16 +1,23 @@
 package com.gmail.nossr50.commands;
 
+import java.util.ArrayList;
+import java.util.List;
+
 import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
 import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
+import org.bukkit.util.StringUtil;
 
 import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.config.Config;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.util.Permissions;
+import com.gmail.nossr50.util.StringUtils;
 import com.gmail.nossr50.util.commands.CommandUtils;
 
-public class XprateCommand implements CommandExecutor {
+import com.google.common.collect.ImmutableList;
+
+public class XprateCommand implements TabExecutor {
     private double originalRate;
 
     public XprateCommand() {
@@ -75,4 +82,20 @@ public class XprateCommand implements CommandExecutor {
                 return false;
         }
     }
+
+    @Override
+    public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) {
+        switch (args.length) {
+            case 1:
+                if (StringUtils.isInt(args[0])) {
+                    return ImmutableList.of();
+                }
+
+                return StringUtil.copyPartialMatches(args[0], CommandUtils.RESET_OPTIONS, new ArrayList<String>(CommandUtils.RESET_OPTIONS.size()));
+            case 2:
+                return StringUtil.copyPartialMatches(args[1], CommandUtils.TRUE_FALSE_OPTIONS, new ArrayList<String>(CommandUtils.TRUE_FALSE_OPTIONS.size()));
+            default:
+                return ImmutableList.of();
+        }
+    }
 }

src/main/java/com/gmail/nossr50/commands/chat/AdminChatCommand.java

@@ -1,12 +1,8 @@
 package com.gmail.nossr50.commands.chat;
 
 import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
 
-import com.gmail.nossr50.mcMMO;
-import com.gmail.nossr50.chat.ChatManager;
 import com.gmail.nossr50.chat.ChatMode;
-import com.gmail.nossr50.locale.LocaleLoader;
 
 public class AdminChatCommand extends ChatCommand {
     public AdminChatCommand() {
@@ -15,12 +11,6 @@ public class AdminChatCommand extends ChatCommand {
 
     @Override
     protected void handleChatSending(CommandSender sender, String[] args) {
-        if (sender instanceof Player) {
-            Player player = (Player) sender;
-            ChatManager.handleAdminChat(mcMMO.p, player.getName(), player.getDisplayName(), buildChatMessage(args, 0));
-        }
-        else {
-            ChatManager.handleAdminChat(mcMMO.p, LocaleLoader.getString("Commands.Chat.Console"), buildChatMessage(args, 0));
-        }
+        chatManager.handleChat(sender.getName(), getDisplayName(sender), buildChatMessage(args, 0));
     }
 }

src/main/java/com/gmail/nossr50/commands/chat/ChatCommand.java

@@ -1,21 +1,33 @@
 package com.gmail.nossr50.commands.chat;
 
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
-import org.bukkit.command.CommandSender;
+import java.util.ArrayList;
+import java.util.List;
 
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
+import org.bukkit.entity.Player;
+import org.bukkit.util.StringUtil;
+
+import com.gmail.nossr50.mcMMO;
+import com.gmail.nossr50.chat.ChatManager;
+import com.gmail.nossr50.chat.ChatManagerFactory;
 import com.gmail.nossr50.chat.ChatMode;
 import com.gmail.nossr50.datatypes.player.McMMOPlayer;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.util.commands.CommandUtils;
 import com.gmail.nossr50.util.player.UserManager;
 
-public abstract class ChatCommand implements CommandExecutor {
+import com.google.common.collect.ImmutableList;
+
+public abstract class ChatCommand implements TabExecutor {
     protected ChatMode chatMode;
+    protected ChatManager chatManager;
     private McMMOPlayer mcMMOPlayer;
 
     public ChatCommand(ChatMode chatMode) {
         this.chatMode = chatMode;
+        this.chatManager = ChatManagerFactory.getChatManager(mcMMO.p, chatMode);
     }
 
     @Override
@@ -26,7 +38,7 @@ public abstract class ChatCommand implements CommandExecutor {
                     return true;
                 }
 
-                mcMMOPlayer = UserManager.getPlayer(sender.getName());
+                mcMMOPlayer = UserManager.getPlayer((Player) sender);
 
                 if (chatMode.isEnabled(mcMMOPlayer)) {
                     disableChatMode(sender);
@@ -43,7 +55,7 @@ public abstract class ChatCommand implements CommandExecutor {
                         return true;
                     }
 
-                    mcMMOPlayer = UserManager.getPlayer(sender.getName());
+                    mcMMOPlayer = UserManager.getPlayer((Player) sender);
 
                     enableChatMode(sender);
                     return true;
@@ -54,7 +66,7 @@ public abstract class ChatCommand implements CommandExecutor {
                         return true;
                     }
 
-                    mcMMOPlayer = UserManager.getPlayer(sender.getName());
+                    mcMMOPlayer = UserManager.getPlayer((Player) sender);
 
                     disableChatMode(sender);
                     return true;
@@ -68,6 +80,16 @@ public abstract class ChatCommand implements CommandExecutor {
         }
     }
 
+    @Override
+    public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) {
+        switch (args.length) {
+            case 1:
+                return StringUtil.copyPartialMatches(args[0], CommandUtils.TRUE_FALSE_OPTIONS, new ArrayList<String>(CommandUtils.TRUE_FALSE_OPTIONS.size()));
+            default:
+                return ImmutableList.of();
+        }
+    }
+
     protected String buildChatMessage(String[] args, int index) {
         StringBuilder builder = new StringBuilder();
         builder.append(args[index]);
@@ -80,6 +102,10 @@ public abstract class ChatCommand implements CommandExecutor {
         return builder.toString();
     }
 
+    protected String getDisplayName(CommandSender sender) {
+        return (sender instanceof Player) ? ((Player) sender).getDisplayName() : LocaleLoader.getString("Commands.Chat.Console");
+    }
+
     protected abstract void handleChatSending(CommandSender sender, String[] args);
 
     private void enableChatMode(CommandSender sender) {

src/main/java/com/gmail/nossr50/commands/chat/PartyChatCommand.java

@@ -3,9 +3,8 @@ package com.gmail.nossr50.commands.chat;
 import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
 
-import com.gmail.nossr50.mcMMO;
-import com.gmail.nossr50.chat.ChatManager;
 import com.gmail.nossr50.chat.ChatMode;
+import com.gmail.nossr50.chat.PartyChatManager;
 import com.gmail.nossr50.datatypes.party.Party;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.party.PartyManager;
@@ -18,16 +17,18 @@ public class PartyChatCommand extends ChatCommand {
 
     @Override
     protected void handleChatSending(CommandSender sender, String[] args) {
+        Party party;
+        String message;
+
         if (sender instanceof Player) {
-            Player player = (Player) sender;
-            Party party = UserManager.getPlayer(player).getParty();
+            party = UserManager.getPlayer((Player) sender).getParty();
 
             if (party == null) {
                 sender.sendMessage(LocaleLoader.getString("Commands.Party.None"));
                 return;
             }
 
-            ChatManager.handlePartyChat(mcMMO.p, party, player.getName(), player.getDisplayName(), buildChatMessage(args, 0));
+            message = buildChatMessage(args, 0);
         }
         else {
             if (args.length < 2) {
@@ -35,14 +36,17 @@ public class PartyChatCommand extends ChatCommand {
                 return;
             }
 
-            Party party = PartyManager.getParty(args[0]);
+            party = PartyManager.getParty(args[0]);
 
             if (party == null) {
                 sender.sendMessage(LocaleLoader.getString("Party.InvalidName"));
                 return;
             }
 
-            ChatManager.handlePartyChat(mcMMO.p, party, LocaleLoader.getString("Commands.Chat.Console"), buildChatMessage(args, 1));
+            message = buildChatMessage(args, 1);
         }
+
+        ((PartyChatManager) chatManager).setParty(party);
+        chatManager.handleChat(sender.getName(), getDisplayName(sender), message);
     }
 }

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

@@ -1,38 +1,26 @@
 package com.gmail.nossr50.commands.database;
 
+import java.util.List;
+
 import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
 import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
 
+import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.config.Config;
-import com.gmail.nossr50.database.DatabaseManager;
-import com.gmail.nossr50.database.LeaderboardManager;
 import com.gmail.nossr50.locale.LocaleLoader;
-import com.gmail.nossr50.util.Permissions;
 
-public class McpurgeCommand implements CommandExecutor {
+import com.google.common.collect.ImmutableList;
+
+public class McpurgeCommand implements TabExecutor {
     @Override
     public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        if (!Permissions.mcpurge(sender)) {
-            sender.sendMessage(command.getPermissionMessage());
-            return true;
-        }
-
         switch (args.length) {
             case 0:
-                if (Config.getInstance().getUseMySQL()) {
-                    DatabaseManager.purgePowerlessSQL();
+                mcMMO.getDatabaseManager().purgePowerlessUsers();
 
-                    if (Config.getInstance().getOldUsersCutoff() != -1) {
-                        DatabaseManager.purgeOldSQL();
-                    }
-                }
-                else {
-                    LeaderboardManager.purgePowerlessFlatfile();
-
-                    if (Config.getInstance().getOldUsersCutoff() != -1) {
-                        LeaderboardManager.purgeOldFlatfile();
-                    }
+                if (Config.getInstance().getOldUsersCutoff() != -1) {
+                    mcMMO.getDatabaseManager().purgeOldUsers();
                 }
 
                 sender.sendMessage(LocaleLoader.getString("Commands.mcpurge.Success"));
@@ -42,4 +30,9 @@ public class McpurgeCommand implements CommandExecutor {
                 return false;
         }
     }
+
+    @Override
+    public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) {
+        return ImmutableList.of();
+    }
 }

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

@@ -1,46 +1,36 @@
 package com.gmail.nossr50.commands.database;
 
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+
 import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
 import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
+import org.bukkit.util.StringUtil;
 
-import com.gmail.nossr50.config.Config;
-import com.gmail.nossr50.database.DatabaseManager;
-import com.gmail.nossr50.database.LeaderboardManager;
+import com.gmail.nossr50.mcMMO;
+import com.gmail.nossr50.datatypes.player.PlayerProfile;
 import com.gmail.nossr50.locale.LocaleLoader;
-import com.gmail.nossr50.util.Misc;
-import com.gmail.nossr50.util.Permissions;
+import com.gmail.nossr50.util.commands.CommandUtils;
+import com.gmail.nossr50.util.player.UserManager;
 
-public class McremoveCommand implements CommandExecutor {
+import com.google.common.collect.ImmutableList;
+
+public class McremoveCommand implements TabExecutor {
     @Override
     public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        if (!Permissions.mcremove(sender)) {
-            sender.sendMessage(command.getPermissionMessage());
-            return true;
-        }
-
         switch (args.length) {
             case 1:
-                /* MySQL */
-                if (Config.getInstance().getUseMySQL()) {
-                    String tablePrefix = Config.getInstance().getMySQLTablePrefix();
+                if (UserManager.getPlayer(args[0]) == null && CommandUtils.unloadedProfile(sender, new PlayerProfile(args[0], false))) {
+                    return true;
+                }
 
-                    if (DatabaseManager.update("DELETE FROM " + tablePrefix + "users WHERE " + tablePrefix + "users.user = '" + args[0] + "'") != 0) {
-                        Misc.profileCleanup(args[0]);
-                        sender.sendMessage(LocaleLoader.getString("Commands.mcremove.Success", args[0]));
-                    }
-                    else {
-                        sender.sendMessage(LocaleLoader.getString("Commands.DoesNotExist"));
-                    }
+                if (mcMMO.getDatabaseManager().removeUser(args[0])) {
+                    sender.sendMessage(LocaleLoader.getString("Commands.mcremove.Success", args[0]));
                 }
                 else {
-                    if (LeaderboardManager.removeFlatFileUser(args[0])) {
-                        Misc.profileCleanup(args[0]);
-                        sender.sendMessage(LocaleLoader.getString("Commands.mcremove.Success", args[0]));
-                    }
-                    else {
-                        sender.sendMessage(LocaleLoader.getString("Commands.DoesNotExist"));
-                    }
+                    sender.sendMessage(args[0] + " could not be removed from the database."); // Pretty sure this should NEVER happen.
                 }
 
                 return true;
@@ -49,4 +39,15 @@ public class McremoveCommand implements CommandExecutor {
                 return false;
         }
     }
+
+    @Override
+    public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) {
+        switch (args.length) {
+            case 1:
+                Set<String> playerNames = UserManager.getPlayers().keySet();
+                return StringUtil.copyPartialMatches(args[0], playerNames, new ArrayList<String>(playerNames.size()));
+            default:
+                return ImmutableList.of();
+        }
+    }
 }

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

@@ -1,22 +1,25 @@
 package com.gmail.nossr50.commands.database;
 
+import java.util.List;
+
 import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
 import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
 import org.bukkit.entity.Player;
 
 import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.config.Config;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.runnables.database.SQLConversionTask;
-import com.gmail.nossr50.util.Permissions;
 import com.gmail.nossr50.util.player.UserManager;
 
-public class MmoupdateCommand implements CommandExecutor {
+import com.google.common.collect.ImmutableList;
+
+public class MmoupdateCommand implements TabExecutor {
     @Override
     public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        if (!Permissions.mmoupdate(sender)) {
-            sender.sendMessage(command.getPermissionMessage());
+        if (!Config.getInstance().getUseMySQL()) {
+            sender.sendMessage("SQL Mode is not enabled."); // TODO: Localize
             return true;
         }
 
@@ -25,7 +28,7 @@ public class MmoupdateCommand implements CommandExecutor {
                 sender.sendMessage(LocaleLoader.getString("Commands.mmoupdate.Start"));
                 UserManager.saveAll();
                 UserManager.clearAll();
-                convertToMySQL();
+                new SQLConversionTask().runTaskLaterAsynchronously(mcMMO.p, 1);
 
                 for (Player player : mcMMO.p.getServer().getOnlinePlayers()) {
                     UserManager.addUser(player);
@@ -39,14 +42,8 @@ public class MmoupdateCommand implements CommandExecutor {
         }
     }
 
-    /**
-     * Convert FlatFile data to MySQL data.
-     */
-    private void convertToMySQL() {
-        if (!Config.getInstance().getUseMySQL()) {
-            return;
-        }
-
-        new SQLConversionTask().runTaskLaterAsynchronously(mcMMO.p, 1);
+    @Override
+    public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) {
+        return ImmutableList.of();
     }
 }

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

@@ -2,7 +2,9 @@ package com.gmail.nossr50.commands.experience;
 
 import org.bukkit.command.CommandSender;
 
+import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.events.experience.McMMOPlayerLevelUpEvent;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.util.Permissions;
 import com.gmail.nossr50.util.skills.SkillUtils;
@@ -21,6 +23,10 @@ public class AddlevelsCommand extends ExperienceCommand {
     @Override
     protected void handleCommand(SkillType skill) {
         profile.addLevels(skill, value);
+
+        if (player != null) {
+            mcMMO.p.getServer().getPluginManager().callEvent(new McMMOPlayerLevelUpEvent(player, skill, value));
+        }
     }
 
     @Override
@@ -31,6 +37,5 @@ public class AddlevelsCommand extends ExperienceCommand {
     @Override
     protected void handlePlayerMessageSkill() {
         player.sendMessage(LocaleLoader.getString("Commands.addlevels.AwardSkill.1", value, SkillUtils.getSkillName(skill)));
-        
     }
 }

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

@@ -1,9 +1,14 @@
 package com.gmail.nossr50.commands.experience;
 
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+
 import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
 import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
 import org.bukkit.entity.Player;
+import org.bukkit.util.StringUtil;
 
 import com.gmail.nossr50.datatypes.player.McMMOPlayer;
 import com.gmail.nossr50.datatypes.player.PlayerProfile;
@@ -13,8 +18,9 @@ import com.gmail.nossr50.util.commands.CommandUtils;
 import com.gmail.nossr50.util.player.UserManager;
 import com.gmail.nossr50.util.skills.SkillUtils;
 
+import com.google.common.collect.ImmutableList;
 
-public abstract class ExperienceCommand implements CommandExecutor {
+public abstract class ExperienceCommand implements TabExecutor {
     protected McMMOPlayer mcMMOPlayer;
     protected Player player;
     protected PlayerProfile profile;
@@ -40,11 +46,12 @@ public abstract class ExperienceCommand implements CommandExecutor {
                     return true;
                 }
 
-                mcMMOPlayer = UserManager.getPlayer(sender.getName());
-                player = mcMMOPlayer.getPlayer();
+                player = (Player) sender;
+                mcMMOPlayer = UserManager.getPlayer(player);
                 profile = mcMMOPlayer.getProfile();
 
                 editValues();
+                allSkills = false;
                 return true;
 
             case 3:
@@ -58,7 +65,6 @@ public abstract class ExperienceCommand implements CommandExecutor {
                 }
 
                 mcMMOPlayer = UserManager.getPlayer(args[0]);
-                player = mcMMOPlayer.getPlayer();
 
                 // If the mcMMOPlayer doesn't exist, create a temporary profile and check if it's present in the database. If it's not, abort the process.
                 if (mcMMOPlayer == null) {
@@ -73,10 +79,12 @@ public abstract class ExperienceCommand implements CommandExecutor {
                 }
                 else {
                     profile = mcMMOPlayer.getProfile();
+                    player = mcMMOPlayer.getPlayer();
                     editValues();
                 }
 
                 handleSenderMessage(sender, args[0]);
+                allSkills = false;
                 return true;
 
             default:
@@ -84,6 +92,19 @@ public abstract class ExperienceCommand implements CommandExecutor {
         }
     }
 
+    @Override
+    public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) {
+        switch (args.length) {
+            case 1:
+                Set<String> playerNames = UserManager.getPlayers().keySet();
+                return StringUtil.copyPartialMatches(args[0], playerNames, new ArrayList<String>(playerNames.size()));
+            case 2:
+                return StringUtil.copyPartialMatches(args[1], SkillType.SKILL_NAMES, new ArrayList<String>(SkillType.SKILL_NAMES.size()));
+            default:
+                return ImmutableList.of();
+        }
+    }
+
     protected abstract boolean permissionsCheckSelf(CommandSender sender);
     protected abstract boolean permissionsCheckOthers(CommandSender sender);
     protected abstract void handleCommand(SkillType skill);

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

@@ -2,7 +2,9 @@ package com.gmail.nossr50.commands.experience;
 
 import org.bukkit.command.CommandSender;
 
+import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.events.experience.McMMOPlayerLevelUpEvent;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.util.Permissions;
 import com.gmail.nossr50.util.skills.SkillUtils;
@@ -21,6 +23,10 @@ public class MmoeditCommand extends ExperienceCommand {
     @Override
     protected void handleCommand(SkillType skill) {
         profile.modifySkill(skill, value);
+
+        if (player != null) {
+            mcMMO.p.getServer().getPluginManager().callEvent(new McMMOPlayerLevelUpEvent(player, skill, value - profile.getSkillLevel(skill)));
+        }
     }
 
     @Override

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

@@ -2,9 +2,12 @@ package com.gmail.nossr50.commands.experience;
 
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
 
+import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.datatypes.player.PlayerProfile;
 import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.events.experience.McMMOPlayerLevelUpEvent;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.util.Permissions;
 import com.gmail.nossr50.util.commands.CommandUtils;
@@ -37,8 +40,8 @@ public class SkillresetCommand extends ExperienceCommand {
                     return true;
                 }
 
-                mcMMOPlayer = UserManager.getPlayer(sender.getName());
-                player = mcMMOPlayer.getPlayer();
+                player = (Player) sender;
+                mcMMOPlayer = UserManager.getPlayer(player);
                 profile = mcMMOPlayer.getProfile();
 
                 editValues();
@@ -84,13 +87,11 @@ public class SkillresetCommand extends ExperienceCommand {
 
     @Override
     protected boolean permissionsCheckSelf(CommandSender sender) {
-        // TODO Auto-generated method stub
         return false;
     }
 
     @Override
     protected boolean permissionsCheckOthers(CommandSender sender) {
-        // TODO Auto-generated method stub
         return false;
     }
 
@@ -102,6 +103,10 @@ public class SkillresetCommand extends ExperienceCommand {
         }
 
         profile.modifySkill(skill, 0);
+
+        if (player != null) {
+            mcMMO.p.getServer().getPluginManager().callEvent(new McMMOPlayerLevelUpEvent(player, skill, 0 - profile.getSkillLevel(skill)));
+        }
     }
 
     @Override

src/main/java/com/gmail/nossr50/commands/hardcore/HardcoreModeCommand.java

@@ -1,15 +1,21 @@
 package com.gmail.nossr50.commands.hardcore;
 
 import java.text.DecimalFormat;
+import java.util.ArrayList;
+import java.util.List;
 
 import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
 import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
+import org.bukkit.util.StringUtil;
 
 import com.gmail.nossr50.util.Permissions;
+import com.gmail.nossr50.util.StringUtils;
 import com.gmail.nossr50.util.commands.CommandUtils;
 
-public abstract class HardcoreModeCommand implements CommandExecutor {
+import com.google.common.collect.ImmutableList;
+
+public abstract class HardcoreModeCommand implements TabExecutor {
     protected CommandSender sender;
     protected double newPercent;
     protected DecimalFormat percent;
@@ -76,6 +82,20 @@ public abstract class HardcoreModeCommand implements CommandExecutor {
         }
     }
 
+    @Override
+    public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) {
+        switch (args.length) {
+            case 1:
+                if (StringUtils.isDouble(args[0])) {
+                    return ImmutableList.of();
+                }
+
+                return StringUtil.copyPartialMatches(args[0], CommandUtils.TRUE_FALSE_OPTIONS, new ArrayList<String>(CommandUtils.TRUE_FALSE_OPTIONS.size()));
+            default:
+                return ImmutableList.of();
+        }
+    }
+
     protected abstract boolean checkTogglePermissions();
     protected abstract boolean checkModifyPermissions();
     protected abstract boolean checkEnabled();

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

@@ -15,8 +15,8 @@ public class PartyAcceptCommand implements CommandExecutor {
     public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
         switch (args.length) {
             case 1:
-                McMMOPlayer mcMMOPlayer = UserManager.getPlayer(sender.getName());
-                Player player = mcMMOPlayer.getPlayer();
+                Player player = (Player) sender;
+                McMMOPlayer mcMMOPlayer = UserManager.getPlayer(player);
 
                 if (!mcMMOPlayer.hasPartyInvite()) {
                     sender.sendMessage(LocaleLoader.getString("mcMMO.NoInvites"));

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

@@ -3,8 +3,8 @@ package com.gmail.nossr50.commands.party;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandExecutor;
 import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
 
-import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.datatypes.party.Party;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.party.PartyManager;
@@ -15,9 +15,9 @@ public class PartyChangeOwnerCommand implements CommandExecutor {
     public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
         switch (args.length) {
             case 2:
-                Party playerParty = UserManager.getPlayer(sender.getName()).getParty();
+                Party playerParty = UserManager.getPlayer((Player) sender).getParty();
 
-                if (!playerParty.getMembers().contains(mcMMO.p.getServer().getOfflinePlayer(args[1]))) {
+                if (!playerParty.getMembers().contains(args[1])) {
                     sender.sendMessage(LocaleLoader.getString("Party.NotInYourParty", args[1]));
                     return true;
                 }

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

@@ -3,6 +3,7 @@ package com.gmail.nossr50.commands.party;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandExecutor;
 import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
 
 import com.gmail.nossr50.datatypes.party.Party;
 import com.gmail.nossr50.locale.LocaleLoader;
@@ -13,7 +14,7 @@ public class PartyChangePasswordCommand implements CommandExecutor {
 
     @Override
     public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        playerParty = UserManager.getPlayer(sender.getName()).getParty();
+        playerParty = UserManager.getPlayer((Player) sender).getParty();
 
         switch (args.length) {
             case 1:

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

@@ -1,21 +1,46 @@
 package com.gmail.nossr50.commands.party;
 
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandExecutor;
 import org.bukkit.command.CommandSender;
+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.teleport.PtpCommand;
 import com.gmail.nossr50.datatypes.player.McMMOPlayer;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.util.Permissions;
 import com.gmail.nossr50.util.commands.CommandUtils;
 import com.gmail.nossr50.util.player.UserManager;
+import com.google.common.collect.ImmutableList;
 
-public class PartyCommand implements CommandExecutor {
+public class PartyCommand implements TabExecutor {
     private McMMOPlayer mcMMOPlayer;
     private Player player;
 
+    private static final List<String> PARTY_SUBCOMMANDS;
+    private static final List<String> EXPSHARE_COMPLETIONS = ImmutableList.of("none", "equal");
+    private static final List<String> ITEMSHARE_COMPLETIONS = ImmutableList.of("none", "equal", "random", "loot", "mining", "herbalism", "woodcutting", "misc");
+
+    static {
+        ArrayList<String> subcommands = new ArrayList<String>();
+
+        for (PartySubcommandType subcommand : PartySubcommandType.values()) {
+            subcommands.add(subcommand.toString());
+        }
+
+        Collections.sort(subcommands);
+        PARTY_SUBCOMMANDS = ImmutableList.copyOf(subcommands);
+    }
+
     private CommandExecutor partyJoinCommand           = new PartyJoinCommand();
     private CommandExecutor partyAcceptCommand         = new PartyAcceptCommand();
     private CommandExecutor partyCreateCommand         = new PartyCreateCommand();
@@ -32,7 +57,7 @@ public class PartyCommand implements CommandExecutor {
     private CommandExecutor partyInfoCommand           = new PartyInfoCommand();
     private CommandExecutor partyHelpCommand           = new PartyHelpCommand();
     private CommandExecutor partyTeleportCommand       = mcMMO.p.getCommand("ptp").getExecutor();
-    private CommandExecutor partyChatCommand           = mcMMO.p.getCommand("partychat").getExecutor();
+    private CommandExecutor partyChatCommand           = new PartyChatCommand();
 
     @Override
     public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
@@ -45,8 +70,8 @@ public class PartyCommand implements CommandExecutor {
             return true;
         }
 
-        mcMMOPlayer = UserManager.getPlayer(sender.getName());
-        player = mcMMOPlayer.getPlayer();
+        player = (Player) sender;
+        mcMMOPlayer = UserManager.getPlayer(player);
 
         if (args.length < 1) {
             if (!mcMMOPlayer.inParty()) {
@@ -134,6 +159,57 @@ public class PartyCommand implements CommandExecutor {
         return true;
     }
 
+    @Override
+    public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) {
+        switch (args.length) {
+            case 1:
+                return StringUtil.copyPartialMatches(args[0], PARTY_SUBCOMMANDS, new ArrayList<String>(PARTY_SUBCOMMANDS.size()));
+            case 2:
+                PartySubcommandType subcommand = PartySubcommandType.getSubcommand(args[0]);
+
+                if (subcommand == null) {
+                    return ImmutableList.of();
+                }
+
+                switch (subcommand) {
+                    case JOIN:
+                    case INVITE:
+                    case KICK:
+                    case OWNER:
+                        Set<String> playerNames = UserManager.getPlayers().keySet();
+                        return StringUtil.copyPartialMatches(args[1], playerNames, new ArrayList<String>(playerNames.size()));
+                    case EXPSHARE:
+                        return StringUtil.copyPartialMatches(args[1], EXPSHARE_COMPLETIONS, new ArrayList<String>(EXPSHARE_COMPLETIONS.size()));
+                    case ITEMSHARE:
+                        return StringUtil.copyPartialMatches(args[1], ITEMSHARE_COMPLETIONS, new ArrayList<String>(ITEMSHARE_COMPLETIONS.size()));
+                    case LOCK:
+                    case CHAT:
+                        return StringUtil.copyPartialMatches(args[1], CommandUtils.TRUE_FALSE_OPTIONS, new ArrayList<String>(CommandUtils.TRUE_FALSE_OPTIONS.size()));
+                    case PASSWORD:
+                        return StringUtil.copyPartialMatches(args[1], CommandUtils.RESET_OPTIONS, new ArrayList<String>(CommandUtils.RESET_OPTIONS.size()));
+                    case TELEPORT:
+                        List<String> matches = StringUtil.copyPartialMatches(args[1], PtpCommand.TELEPORT_SUBCOMMANDS, new ArrayList<String>(PtpCommand.TELEPORT_SUBCOMMANDS.size()));
+
+                        if (matches.size() == 0) {
+                            playerNames = UserManager.getPlayers().keySet();
+                            return StringUtil.copyPartialMatches(args[1], playerNames, new ArrayList<String>(playerNames.size()));
+                        }
+
+                        return matches;
+                    default:
+                        return ImmutableList.of();
+                }
+            case 3:
+                if (PartySubcommandType.getSubcommand(args[0]) == PartySubcommandType.ITEMSHARE && isItemShareCategory(args[1])) {
+                    return StringUtil.copyPartialMatches(args[2], CommandUtils.TRUE_FALSE_OPTIONS, new ArrayList<String>(CommandUtils.TRUE_FALSE_OPTIONS.size()));
+                }
+
+                return ImmutableList.of();
+            default:
+                return ImmutableList.of();
+        }
+    }
+
     private boolean printUsage() {
         player.sendMessage(LocaleLoader.getString("Party.Help.0", "/party join"));
         player.sendMessage(LocaleLoader.getString("Party.Help.1", "/party create"));
@@ -150,4 +226,9 @@ public class PartyCommand implements CommandExecutor {
 
         return newArgs;
     }
+
+    private boolean isItemShareCategory(String category) {
+        return category.equalsIgnoreCase("loot") || category.equalsIgnoreCase("mining") || category.equalsIgnoreCase("herbalism") || category.equalsIgnoreCase("woodcutting") || category.equalsIgnoreCase("misc");
+    }
 }
+

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

@@ -19,8 +19,8 @@ public class PartyCreateCommand implements CommandExecutor {
             case 3:
                 Party newParty = PartyManager.getParty(args[1]);
 
-                McMMOPlayer mcMMOPlayer = UserManager.getPlayer(sender.getName());
-                Player player = mcMMOPlayer.getPlayer();
+                Player player = (Player) sender;
+                McMMOPlayer mcMMOPlayer = UserManager.getPlayer(player);
 
                 // Check to see if the party exists, and if it does cancel creating a new party
                 if (PartyManager.checkPartyExistence(player, newParty, args[1])) {

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

@@ -16,7 +16,7 @@ public class PartyDisbandCommand implements CommandExecutor {
     public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
         switch (args.length) {
             case 1:
-                Party playerParty = UserManager.getPlayer(sender.getName()).getParty();
+                Party playerParty = UserManager.getPlayer((Player) sender).getParty();
                 String partyName = playerParty.getName();
 
                 for (Player member : playerParty.getOnlineMembers()) {

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

@@ -26,7 +26,7 @@ public class PartyExpShareCommand implements CommandExecutor {
 
         switch (args.length) {
             case 2:
-                playerParty = UserManager.getPlayer(sender.getName()).getParty();
+                playerParty = UserManager.getPlayer((Player) sender).getParty();
 
                 if (args[1].equalsIgnoreCase("none") || CommandUtils.shouldDisableToggle(args[1])) {
                     handleChangingShareMode(ShareMode.NONE);
@@ -35,7 +35,7 @@ public class PartyExpShareCommand implements CommandExecutor {
                     handleChangingShareMode(ShareMode.EQUAL);
                 }
                 else {
-                    sender.sendMessage(LocaleLoader.getString("Commands.Usage.2", "party", "expshare", "[NONE | EQUAL]"));
+                    sender.sendMessage(LocaleLoader.getString("Commands.Usage.2", "party", "expshare", "<NONE | EQUAL>"));
                 }
 
                 return true;

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

@@ -19,6 +19,8 @@ public class PartyHelpCommand implements CommandExecutor {
                 sender.sendMessage(LocaleLoader.getString("Party.Help.6", "/party kick"));
                 sender.sendMessage(LocaleLoader.getString("Party.Help.7", "/party leader"));
                 sender.sendMessage(LocaleLoader.getString("Party.Help.8", "/party disband"));
+                sender.sendMessage(LocaleLoader.getString("Party.Help.9", "/party itemshare"));
+                sender.sendMessage(LocaleLoader.getString("Party.Help.10", "/party expshare"));
                 return true;
 
             default:

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

@@ -7,6 +7,7 @@ import org.bukkit.command.CommandExecutor;
 import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
 
+import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.config.Config;
 import com.gmail.nossr50.datatypes.party.Party;
 import com.gmail.nossr50.datatypes.player.McMMOPlayer;
@@ -21,21 +22,28 @@ public class PartyInfoCommand implements CommandExecutor {
 
     @Override
     public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        McMMOPlayer mcMMOPlayer = UserManager.getPlayer(sender.getName());
-        player = mcMMOPlayer.getPlayer();
-        playerParty = mcMMOPlayer.getParty();
+        switch (args.length) {
+            case 0:
+            case 1:
+                player = (Player) sender;
+                McMMOPlayer mcMMOPlayer = UserManager.getPlayer(player);
+                playerParty = mcMMOPlayer.getParty();
 
-        displayPartyHeader();
-        displayShareModeInfo();
-        displayMemberInfo();
-        return true;
+                displayPartyHeader();
+                displayShareModeInfo();
+                displayMemberInfo();
+                return true;
+            default:
+                sender.sendMessage(LocaleLoader.getString("Commands.Usage.1", "party", "info"));
+                return true;
+        }
     }
 
     private String createMembersList() {
         StringBuilder memberList = new StringBuilder();
 
-        for (OfflinePlayer member : playerParty.getMembers()) {
-            String memberName = member.getName();
+        for (String memberName : playerParty.getMembers()) {
+            OfflinePlayer member = mcMMO.p.getServer().getOfflinePlayer(memberName);
 
             if (playerParty.getLeader().equalsIgnoreCase(memberName)) {
                 memberList.append(ChatColor.GOLD);

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

@@ -24,8 +24,8 @@ public class PartyInviteCommand implements CommandExecutor {
                 }
 
                 Player target = mcMMOTarget.getPlayer();
-                McMMOPlayer mcMMOPlayer = UserManager.getPlayer(sender.getName());
-                Player player = mcMMOPlayer.getPlayer();
+                Player player = (Player) sender;
+                McMMOPlayer mcMMOPlayer = UserManager.getPlayer(player);
 
                 if (player.equals(target)) {
                     sender.sendMessage(LocaleLoader.getString("Party.Invite.Self"));

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

@@ -6,9 +6,9 @@ import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
 
 import com.gmail.nossr50.config.Config;
+import com.gmail.nossr50.datatypes.party.ItemShareType;
 import com.gmail.nossr50.datatypes.party.Party;
 import com.gmail.nossr50.locale.LocaleLoader;
-import com.gmail.nossr50.party.ShareHandler;
 import com.gmail.nossr50.party.ShareHandler.ShareMode;
 import com.gmail.nossr50.util.StringUtils;
 import com.gmail.nossr50.util.commands.CommandUtils;
@@ -26,25 +26,19 @@ public class PartyItemShareCommand implements CommandExecutor {
 
         switch (args.length) {
             case 2:
-                playerParty = UserManager.getPlayer(sender.getName()).getParty();
+                playerParty = UserManager.getPlayer((Player) sender).getParty();
+                ShareMode mode = ShareMode.getShareMode(args[1].toUpperCase());
 
-                if (args[1].equalsIgnoreCase("none") || CommandUtils.shouldDisableToggle(args[1])) {
-                    handleChangingShareMode(ShareMode.NONE);
-                }
-                else if (args[1].equalsIgnoreCase("equal") || args[1].equalsIgnoreCase("even")) {
-                    handleChangingShareMode(ShareMode.EQUAL);
-                }
-                else if (args[1].equalsIgnoreCase("random")) {
-                    handleChangingShareMode(ShareMode.RANDOM);
-                }
-                else {
+                if (mode == null) {
                     sender.sendMessage(LocaleLoader.getString("Commands.Usage.2", "party", "itemshare", "<NONE | EQUAL | RANDOM>"));
+                    return true;
                 }
 
+                handleChangingShareMode(mode);
                 return true;
 
             case 3:
-                playerParty = UserManager.getPlayer(sender.getName()).getParty();
+                playerParty = UserManager.getPlayer((Player) sender).getParty();
                 boolean toggle = false;
 
                 if (CommandUtils.shouldEnableToggle(args[2])) {
@@ -54,37 +48,27 @@ public class PartyItemShareCommand implements CommandExecutor {
                     toggle = false;
                 }
                 else {
-                    sender.sendMessage(LocaleLoader.getString("Commands.Usage.2", "party", "itemshare", "<loot | mining | herbalism | woodcutting> <true | false>"));
+                    sender.sendMessage(LocaleLoader.getString("Commands.Usage.2", "party", "itemshare", "<loot | mining | herbalism | woodcutting | misc> <true | false>"));
                     return true;
                 }
 
-                if (args[1].equalsIgnoreCase("loot")) {
-                    playerParty.setSharingLootDrops(toggle);
+                try {
+                    handleToggleItemShareCategory(ItemShareType.valueOf(args[1].toUpperCase()), toggle);
                 }
-                else if (args[1].equalsIgnoreCase("mining")) {
-                    playerParty.setSharingMiningDrops(toggle);
-                }
-                else if (args[1].equalsIgnoreCase("herbalism")) {
-                    playerParty.setSharingHerbalismDrops(toggle);
-                }
-                else if (args[1].equalsIgnoreCase("woodcutting")) {
-                    playerParty.setSharingWoodcuttingDrops(toggle);
-                }
-                else {
-                    sender.sendMessage(LocaleLoader.getString("Commands.Usage.2", "party", "itemshare", "<loot | mining | herbalism | woodcutting> <true | false>"));
+                catch (IllegalArgumentException ex) {
+                    sender.sendMessage(LocaleLoader.getString("Commands.Usage.2", "party", "itemshare", "<loot | mining | herbalism | woodcutting | misc> <true | false>"));
                 }
 
-                notifyToggleItemShareCategory(args[1], toggle);
                 return true;
 
             default:
                 sender.sendMessage(LocaleLoader.getString("Commands.Usage.2", "party", "itemshare", "<NONE | EQUAL | RANDOM>"));
-                sender.sendMessage(LocaleLoader.getString("Commands.Usage.2", "party", "itemshare", "<loot | mining | herbalism | woodcutting> <true | false>"));
+                sender.sendMessage(LocaleLoader.getString("Commands.Usage.2", "party", "itemshare", "<loot | mining | herbalism | woodcutting | misc> <true | false>"));
                 return true;
         }
     }
 
-    private void handleChangingShareMode(ShareHandler.ShareMode mode) {
+    private void handleChangingShareMode(ShareMode mode) {
         playerParty.setItemShareMode(mode);
 
         String changeModeMessage = LocaleLoader.getString("Commands.Party.SetSharing", LocaleLoader.getString("Party.ShareType.Item"), LocaleLoader.getString("Party.ShareMode." + StringUtils.getCapitalized(mode.toString())));
@@ -94,10 +78,10 @@ public class PartyItemShareCommand implements CommandExecutor {
         }
     }
 
-    private void notifyToggleItemShareCategory(String category, boolean toggle) {
-        String state = toggle ? "enabled" : "disabled";
+    private void handleToggleItemShareCategory(ItemShareType type, boolean toggle) {
+        playerParty.setSharingDrops(type, toggle);
 
-        String toggleMessage = LocaleLoader.getString("Commands.Party.ToggleShareCategory", StringUtils.getCapitalized(category), state);
+        String toggleMessage = LocaleLoader.getString("Commands.Party.ToggleShareCategory", StringUtils.getCapitalized(type.toString()), toggle ? "enabled" : "disabled");
 
         for (Player member : playerParty.getOnlineMembers()) {
             member.sendMessage(toggleMessage);

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

@@ -77,8 +77,8 @@ public class PartyJoinCommand implements CommandExecutor {
             return false;
         }
 
-        mcMMOPlayer = UserManager.getPlayer(sender.getName());
-        player = mcMMOPlayer.getPlayer();
+        player = (Player) sender;
+        mcMMOPlayer = UserManager.getPlayer(player);
 
         playerParty = mcMMOPlayer.getParty();
         targetParty = mcMMOTarget.getParty();

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

@@ -18,10 +18,10 @@ public class PartyKickCommand implements CommandExecutor {
     public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
         switch (args.length) {
             case 2:
-                Party playerParty = UserManager.getPlayer(sender.getName()).getParty();
+                Party playerParty = UserManager.getPlayer((Player) sender).getParty();
                 OfflinePlayer target = mcMMO.p.getServer().getOfflinePlayer(args[1]);
 
-                if (!playerParty.getMembers().contains(target)) {
+                if (!playerParty.getMembers().contains(target.getName())) {
                     sender.sendMessage(LocaleLoader.getString("Party.NotInYourParty", args[1]));
                     return true;
                 }

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

@@ -3,6 +3,7 @@ package com.gmail.nossr50.commands.party;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandExecutor;
 import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
 
 import com.gmail.nossr50.datatypes.party.Party;
 import com.gmail.nossr50.locale.LocaleLoader;
@@ -15,7 +16,7 @@ public class PartyLockCommand implements CommandExecutor {
 
     @Override
     public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        playerParty = UserManager.getPlayer(sender.getName()).getParty();
+        playerParty = UserManager.getPlayer((Player) sender).getParty();
 
         switch (args.length) {
             case 1:

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

@@ -17,7 +17,7 @@ public class PartyRenameCommand implements CommandExecutor {
     public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
         switch (args.length) {
             case 2:
-                McMMOPlayer mcMMOPlayer = UserManager.getPlayer(sender.getName());
+                McMMOPlayer mcMMOPlayer = UserManager.getPlayer((Player) sender);
                 Party playerParty = mcMMOPlayer.getParty();
 
                 String oldPartyName = playerParty.getName();

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

@@ -18,8 +18,8 @@ public class PtpAcceptAnyCommand implements CommandExecutor {
             return true;
         }
 
-        McMMOPlayer mcMMOPlayer = UserManager.getPlayer(sender.getName());
-        Player player = mcMMOPlayer.getPlayer();
+        Player player = (Player) sender;
+        McMMOPlayer mcMMOPlayer = UserManager.getPlayer(player);
 
         if (mcMMOPlayer.getPtpConfirmRequired()) {
             player.sendMessage(LocaleLoader.getString("Commands.ptp.AcceptAny.Disabled"));

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

@@ -21,8 +21,8 @@ public class PtpAcceptCommand implements CommandExecutor {
             return true;
         }
 
-        McMMOPlayer mcMMOPlayer = UserManager.getPlayer(sender.getName());
-        Player player = mcMMOPlayer.getPlayer();
+        Player player = (Player) sender;
+        McMMOPlayer mcMMOPlayer = UserManager.getPlayer(player);
 
         if (!mcMMOPlayer.hasPtpRequest()) {
             player.sendMessage(LocaleLoader.getString("Commands.ptp.NoRequests"));
@@ -58,7 +58,7 @@ public class PtpAcceptCommand implements CommandExecutor {
             }
         }
 
-        PtpCommand.handlePartyTeleportEvent(target, player);
+        PtpCommand.handleTeleportWarmup(target, player);
         return true;
     }
 }

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

@@ -1,9 +1,15 @@
 package com.gmail.nossr50.commands.party.teleport;
 
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandExecutor;
 import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
 import org.bukkit.entity.Player;
+import org.bukkit.util.StringUtil;
 
 import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.config.Config;
@@ -11,14 +17,20 @@ import com.gmail.nossr50.datatypes.player.McMMOPlayer;
 import com.gmail.nossr50.events.party.McMMOPartyTeleportEvent;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.party.PartyManager;
+import com.gmail.nossr50.runnables.items.TeleportationWarmup;
 import com.gmail.nossr50.util.Misc;
+import com.gmail.nossr50.util.Permissions;
 import com.gmail.nossr50.util.commands.CommandUtils;
 import com.gmail.nossr50.util.player.UserManager;
+import com.gmail.nossr50.util.skills.SkillUtils;
+import com.google.common.collect.ImmutableList;
 
-public class PtpCommand implements CommandExecutor {
+public class PtpCommand implements TabExecutor {
     private static Player target;
     private static McMMOPlayer mcMMOTarget;
 
+    public static final List<String> TELEPORT_SUBCOMMANDS = ImmutableList.of("toggle", "accept", "acceptany", "acceptall");
+
     private CommandExecutor ptpToggleCommand = new PtpToggleCommand();
     private CommandExecutor ptpAcceptAnyCommand = new PtpAcceptAnyCommand();
     private CommandExecutor ptpAcceptCommand = new PtpAcceptCommand();
@@ -39,21 +51,42 @@ public class PtpCommand implements CommandExecutor {
                     return ptpAcceptAnyCommand.onCommand(sender, command, label, args);
                 }
 
-                McMMOPlayer mcMMOPlayer = UserManager.getPlayer(sender.getName());
-                Player player = mcMMOPlayer.getPlayer();
+                Player player = (Player) sender;
+                McMMOPlayer mcMMOPlayer = UserManager.getPlayer(player);
 
-                int ptpCooldown = Config.getInstance().getPTPCommandCooldown();
                 long recentlyHurt = mcMMOPlayer.getRecentlyHurt();
+                int hurtCooldown = Config.getInstance().getPTPCommandRecentlyHurtCooldown();
 
-                if (((recentlyHurt * Misc.TIME_CONVERSION_FACTOR) + (ptpCooldown * Misc.TIME_CONVERSION_FACTOR)) > System.currentTimeMillis()) {
-                    player.sendMessage(LocaleLoader.getString("Party.Teleport.Hurt", ptpCooldown));
-                    return true;
+                if (hurtCooldown > 0) {
+                    int timeRemaining = SkillUtils.calculateTimeLeft(recentlyHurt * Misc.TIME_CONVERSION_FACTOR, hurtCooldown, player);
+
+                    if (timeRemaining > 0) {
+                        player.sendMessage(LocaleLoader.getString("Item.Injured.Wait", timeRemaining));
+                        return true;
+                    }
                 }
 
                 if (args[0].equalsIgnoreCase("accept")) {
                     return ptpAcceptCommand.onCommand(sender, command, label, args);
                 }
 
+                if (!Permissions.partyTeleportSend(sender)) {
+                    sender.sendMessage(command.getPermissionMessage());
+                    return true;
+                }
+
+                int ptpCooldown = Config.getInstance().getPTPCommandCooldown();
+                long lastTeleport = mcMMOPlayer.getLastTeleport();
+
+                if (ptpCooldown > 0) {
+                    int timeRemaining = SkillUtils.calculateTimeLeft(lastTeleport * Misc.TIME_CONVERSION_FACTOR, ptpCooldown, player);
+
+                    if (timeRemaining > 0) {
+                        player.sendMessage(LocaleLoader.getString("Item.Generic.Wait", timeRemaining));
+                        return true;
+                    }
+                }
+
                 sendTeleportRequest(sender, player, args[0]);
                 return true;
 
@@ -62,13 +95,30 @@ public class PtpCommand implements CommandExecutor {
         }
     }
 
+    @Override
+    public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) {
+        switch (args.length) {
+            case 1:
+                List<String> matches = StringUtil.copyPartialMatches(args[0], TELEPORT_SUBCOMMANDS, new ArrayList<String>(TELEPORT_SUBCOMMANDS.size()));
+
+                if (matches.size() == 0) {
+                    Set<String> playerNames = UserManager.getPlayers().keySet();
+                    return StringUtil.copyPartialMatches(args[0], playerNames, new ArrayList<String>(playerNames.size()));
+                }
+
+                return matches;
+            default:
+                return ImmutableList.of();
+        }
+    }
+
     private void sendTeleportRequest(CommandSender sender, Player player, String targetName) {
         if (!canTeleport(sender, player, targetName)) {
             return;
         }
 
         if (!mcMMOTarget.getPtpConfirmRequired()) {
-            handlePartyTeleportEvent(player, target);
+            handleTeleportWarmup(player, target);
             return;
         }
 
@@ -89,6 +139,7 @@ public class PtpCommand implements CommandExecutor {
         }
 
         target = mcMMOTarget.getPlayer();
+        targetName = target.getName();
 
         if (player.equals(target)) {
             player.sendMessage(LocaleLoader.getString("Party.Teleport.Self"));
@@ -113,7 +164,24 @@ public class PtpCommand implements CommandExecutor {
         return true;
     }
 
-    protected static void handlePartyTeleportEvent(Player teleportingPlayer, Player targetPlayer) {
+    protected static void handleTeleportWarmup(Player teleportingPlayer, Player targetPlayer) {
+        McMMOPlayer mcMMOPlayer = UserManager.getPlayer(teleportingPlayer);
+        mcMMOTarget = UserManager.getPlayer(targetPlayer);
+
+        long warmup = Config.getInstance().getPTPCommandWarmup();
+
+        mcMMOPlayer.actualizeTeleportCommenceLocation(teleportingPlayer);
+
+        if (warmup > 0) {
+            teleportingPlayer.sendMessage(LocaleLoader.getString("Teleport.Commencing", warmup));
+            new TeleportationWarmup(mcMMOPlayer, mcMMOTarget).runTaskLater(mcMMO.p, 20 * warmup);
+        }
+        else {
+            handlePartyTeleportEvent(teleportingPlayer, targetPlayer);
+        }
+    }
+
+    public static void handlePartyTeleportEvent(Player teleportingPlayer, Player targetPlayer) {
         McMMOPlayer mcMMOPlayer = UserManager.getPlayer(teleportingPlayer);
         McMMOPartyTeleportEvent event = new McMMOPartyTeleportEvent(teleportingPlayer, targetPlayer, mcMMOPlayer.getParty().getName());
 

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

@@ -18,8 +18,8 @@ public class PtpToggleCommand implements CommandExecutor {
             return true;
         }
 
-        McMMOPlayer mcMMOPlayer = UserManager.getPlayer(sender.getName());
-        Player player = mcMMOPlayer.getPlayer();
+        Player player = (Player) sender;
+        McMMOPlayer mcMMOPlayer = UserManager.getPlayer(player);
 
         if (mcMMOPlayer.getPtpEnabled()) {
             player.sendMessage(LocaleLoader.getString("Commands.ptp.Disabled"));

src/main/java/com/gmail/nossr50/commands/player/InspectCommand.java

@@ -1,10 +1,16 @@
 package com.gmail.nossr50.commands.player;
 
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
 
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
+import org.bukkit.entity.Player;
+import org.bukkit.util.StringUtil;
+
+import com.gmail.nossr50.config.Config;
 import com.gmail.nossr50.datatypes.player.McMMOPlayer;
 import com.gmail.nossr50.datatypes.player.PlayerProfile;
 import com.gmail.nossr50.datatypes.skills.SkillType;
@@ -12,12 +18,19 @@ import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.util.Permissions;
 import com.gmail.nossr50.util.commands.CommandUtils;
 import com.gmail.nossr50.util.player.UserManager;
+import com.gmail.nossr50.util.scoreboards.ScoreboardManager;
 
-public class InspectCommand implements CommandExecutor {
+import com.google.common.collect.ImmutableList;
+
+public class InspectCommand implements TabExecutor {
     @Override
     public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
         switch (args.length) {
             case 1:
+                if (sender instanceof Player && Config.getInstance().getInspectScoreboardEnabled()) {
+                    ScoreboardManager.setupPlayerScoreboard(sender.getName());
+                }
+
                 McMMOPlayer mcMMOPlayer = UserManager.getPlayer(args[0]);
 
                 // If the mcMMOPlayer doesn't exist, create a temporary profile and check if it's present in the database. If it's not, abort the process.
@@ -28,6 +41,11 @@ public class InspectCommand implements CommandExecutor {
                         return true;
                     }
 
+                    if (sender instanceof Player && Config.getInstance().getInspectScoreboardEnabled()) {
+                        ScoreboardManager.enablePlayerInspectScoreboardOffline((Player) sender, profile);
+                        return true;
+                    }
+
                     sender.sendMessage(LocaleLoader.getString("Inspect.OfflineStats", args[0]));
 
                     sender.sendMessage(LocaleLoader.getString("Stats.Header.Gathering"));
@@ -51,7 +69,18 @@ public class InspectCommand implements CommandExecutor {
                 else {
                     Player target = mcMMOPlayer.getPlayer();
 
-                    if (CommandUtils.tooFar(sender, target, Permissions.inspectFar(sender))) {
+                    if (CommandUtils.hidden(sender, target, Permissions.inspectHidden(sender))) {
+                        if (!Permissions.inspectOffline(sender)) {
+                            sender.sendMessage(LocaleLoader.getString("Inspect.Offline"));
+                            return true;
+                        }
+                    }
+                    else if (CommandUtils.tooFar(sender, target, Permissions.inspectFar(sender))) {
+                        return true;
+                    }
+
+                    if (sender instanceof Player && Config.getInstance().getInspectScoreboardEnabled()) {
+                        ScoreboardManager.enablePlayerInspectScoreboardOnline((Player) sender, mcMMOPlayer);
                         return true;
                     }
 
@@ -68,4 +97,15 @@ public class InspectCommand implements CommandExecutor {
                 return false;
         }
     }
+
+    @Override
+    public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) {
+        switch (args.length) {
+            case 1:
+                Set<String> playerNames = UserManager.getPlayers().keySet();
+                return StringUtil.copyPartialMatches(args[0], playerNames, new ArrayList<String>(playerNames.size()));
+            default:
+                return ImmutableList.of();
+        }
+    }
 }

src/main/java/com/gmail/nossr50/commands/player/McrankCommand.java

@@ -1,23 +1,27 @@
 package com.gmail.nossr50.commands.player;
 
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+
 import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
 import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
+import org.bukkit.entity.Player;
+import org.bukkit.util.StringUtil;
 
 import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.config.Config;
-import com.gmail.nossr50.database.LeaderboardManager;
 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.locale.LocaleLoader;
 import com.gmail.nossr50.runnables.commands.McrankCommandAsyncTask;
 import com.gmail.nossr50.util.Permissions;
 import com.gmail.nossr50.util.commands.CommandUtils;
 import com.gmail.nossr50.util.player.UserManager;
-import com.gmail.nossr50.util.skills.SkillUtils;
+import com.gmail.nossr50.util.scoreboards.ScoreboardManager;
+import com.google.common.collect.ImmutableList;
 
-public class McrankCommand implements CommandExecutor {
+public class McrankCommand implements TabExecutor {
     @Override
     public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
         switch (args.length) {
@@ -31,11 +35,12 @@ public class McrankCommand implements CommandExecutor {
                     return true;
                 }
 
-                if (Config.getInstance().getUseMySQL()) {
-                    sqlDisplay(sender, sender.getName());
+                if (Config.getInstance().getMcrankScoreboardEnabled()) {
+                    ScoreboardManager.setupPlayerScoreboard(sender.getName());
+                    ScoreboardManager.enablePlayerRankScoreboard((Player) sender);
                 }
                 else {
-                    flatfileDisplay(sender, sender.getName());
+                    display(sender, sender.getName());
                 }
 
                 return true;
@@ -55,18 +60,18 @@ public class McrankCommand implements CommandExecutor {
                     if (CommandUtils.tooFar(sender, mcMMOPlayer.getPlayer(), Permissions.mcrankFar(sender))) {
                         return true;
                     }
-
-                } else if (CommandUtils.inspectOffline(sender, new PlayerProfile(playerName, false), Permissions.mcrankOffline(sender))) {
+                }
+                else if (CommandUtils.inspectOffline(sender, new PlayerProfile(playerName, false), Permissions.mcrankOffline(sender))) {
                     return true;
                 }
 
-                if (Config.getInstance().getUseMySQL()) {
-                    sqlDisplay(sender, playerName);
+                if (sender instanceof Player && Config.getInstance().getMcrankScoreboardEnabled()) {
+                    ScoreboardManager.setupPlayerScoreboard(sender.getName());
+                    ScoreboardManager.enablePlayerRankScoreboardOthers((Player) sender, playerName);
                 }
                 else {
-                    flatfileDisplay(sender, playerName);
+                    display(sender, playerName);
                 }
-
                 return true;
 
             default:
@@ -74,39 +79,18 @@ public class McrankCommand implements CommandExecutor {
         }
     }
 
-    private void flatfileDisplay(CommandSender sender, String playerName) {
-        LeaderboardManager.updateLeaderboards(); // Make sure the information is up to date
-
-        sender.sendMessage(LocaleLoader.getString("Commands.mcrank.Heading"));
-        sender.sendMessage(LocaleLoader.getString("Commands.mcrank.Player", playerName));
-
-        for (SkillType skillType : SkillType.values()) {
-            int[] rankInts = LeaderboardManager.getPlayerRank(playerName, skillType);
-
-            if (!Permissions.skillEnabled(sender, skillType) || skillType.isChildSkill()) {
-                continue;
-            }
-
-            if (rankInts[1] == 0) {
-                sender.sendMessage(LocaleLoader.getString("Commands.mcrank.Skill", SkillUtils.getSkillName(skillType), LocaleLoader.getString("Commands.mcrank.Unranked"))); // Don't bother showing ranking for players without skills
-            }
-            else {
-                sender.sendMessage(LocaleLoader.getString("Commands.mcrank.Skill", SkillUtils.getSkillName(skillType), rankInts[0]));
-            }
-        }
-
-        // Show the powerlevel ranking
-        int[] rankInts = LeaderboardManager.getPlayerRank(playerName);
-
-        if (rankInts[1] == 0) {
-            sender.sendMessage(LocaleLoader.getString("Commands.mcrank.Overall", LocaleLoader.getString("Commands.mcrank.Unranked"))); // Don't bother showing ranking for players without skills
-        }
-        else {
-            sender.sendMessage(LocaleLoader.getString("Commands.mcrank.Overall", rankInts[0]));
+    @Override
+    public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) {
+        switch (args.length) {
+            case 1:
+                Set<String> playerNames = UserManager.getPlayers().keySet();
+                return StringUtil.copyPartialMatches(args[0], playerNames, new ArrayList<String>(playerNames.size()));
+            default:
+                return ImmutableList.of();
         }
     }
 
-    private void sqlDisplay(CommandSender sender, String playerName) {
+    private void display(CommandSender sender, String playerName) {
         new McrankCommandAsyncTask(playerName, sender).runTaskAsynchronously(mcMMO.p);
     }
 }

src/main/java/com/gmail/nossr50/commands/player/McstatsCommand.java

@@ -1,8 +1,10 @@
 package com.gmail.nossr50.commands.player;
 
+import java.util.List;
+
 import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
 import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
 import org.bukkit.entity.Player;
 
 import com.gmail.nossr50.config.Config;
@@ -10,8 +12,10 @@ import com.gmail.nossr50.datatypes.player.McMMOPlayer;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.util.commands.CommandUtils;
 import com.gmail.nossr50.util.player.UserManager;
+import com.gmail.nossr50.util.scoreboards.ScoreboardManager;
+import com.google.common.collect.ImmutableList;
 
-public class McstatsCommand implements CommandExecutor {
+public class McstatsCommand implements TabExecutor {
     @Override
     public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
         if (CommandUtils.noConsoleUsage(sender)) {
@@ -20,23 +24,29 @@ public class McstatsCommand implements CommandExecutor {
 
         switch (args.length) {
             case 0:
-                McMMOPlayer mcMMOPlayer = UserManager.getPlayer(sender.getName());
-                Player player = mcMMOPlayer.getPlayer();
+                Player player = (Player) sender;
+                McMMOPlayer mcMMOPlayer = UserManager.getPlayer(player);
 
-                player.sendMessage(LocaleLoader.getString("Stats.Own.Stats"));
-                player.sendMessage(LocaleLoader.getString("mcMMO.NoSkillNote"));
-
-                CommandUtils.printGatheringSkills(player);
-                CommandUtils.printCombatSkills(player);
-                CommandUtils.printMiscSkills(player);
-
-                int powerLevelCap = Config.getInstance().getPowerLevelCap();
-
-                if (powerLevelCap != Integer.MAX_VALUE) {
-                    player.sendMessage(LocaleLoader.getString("Commands.PowerLevel.Capped", UserManager.getPlayer(player).getPowerLevel(), powerLevelCap));
+                if (Config.getInstance().getMcstatsScoreboardsEnabled()) {
+                    ScoreboardManager.setupPlayerScoreboard(player.getName());
+                    ScoreboardManager.enablePlayerStatsScoreboard(mcMMOPlayer);
                 }
                 else {
-                    player.sendMessage(LocaleLoader.getString("Commands.PowerLevel", UserManager.getPlayer(player).getPowerLevel()));
+                    player.sendMessage(LocaleLoader.getString("Stats.Own.Stats"));
+                    player.sendMessage(LocaleLoader.getString("mcMMO.NoSkillNote"));
+
+                    CommandUtils.printGatheringSkills(player);
+                    CommandUtils.printCombatSkills(player);
+                    CommandUtils.printMiscSkills(player);
+
+                    int powerLevelCap = Config.getInstance().getPowerLevelCap();
+
+                    if (powerLevelCap != Integer.MAX_VALUE) {
+                        player.sendMessage(LocaleLoader.getString("Commands.PowerLevel.Capped", UserManager.getPlayer(player).getPowerLevel(), powerLevelCap));
+                    }
+                    else {
+                        player.sendMessage(LocaleLoader.getString("Commands.PowerLevel", UserManager.getPlayer(player).getPowerLevel()));
+                    }
                 }
 
                 return true;
@@ -45,4 +55,9 @@ public class McstatsCommand implements CommandExecutor {
                 return false;
         }
     }
+
+    @Override
+    public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) {
+        return ImmutableList.of();
+    }
 }

src/main/java/com/gmail/nossr50/commands/player/MctopCommand.java

@@ -1,36 +1,38 @@
 package com.gmail.nossr50.commands.player;
 
-import org.bukkit.ChatColor;
+import java.util.ArrayList;
+import java.util.List;
+
 import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
 import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
+import org.bukkit.entity.Player;
+import org.bukkit.util.StringUtil;
 
 import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.config.Config;
-import com.gmail.nossr50.database.LeaderboardManager;
 import com.gmail.nossr50.datatypes.skills.SkillType;
-import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.runnables.commands.MctopCommandAsyncTask;
 import com.gmail.nossr50.util.Permissions;
 import com.gmail.nossr50.util.StringUtils;
 import com.gmail.nossr50.util.commands.CommandUtils;
+import com.gmail.nossr50.util.scoreboards.ScoreboardManager;
 
-public class MctopCommand implements CommandExecutor {
+import com.google.common.collect.ImmutableList;
+
+public class MctopCommand implements TabExecutor {
     private SkillType skill;
 
     @Override
     public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        boolean useMySQL = Config.getInstance().getUseMySQL();
-
-
         switch (args.length) {
             case 0:
-                display(1, "ALL", sender, useMySQL, command);
+                display(1, "ALL", sender, command);
                 return true;
 
             case 1:
                 if (StringUtils.isInt(args[0])) {
-                    display(Math.abs(Integer.parseInt(args[0])), "ALL", sender, useMySQL, command);
+                    display(Math.abs(Integer.parseInt(args[0])), "ALL", sender, command);
                     return true;
                 }
 
@@ -38,7 +40,7 @@ public class MctopCommand implements CommandExecutor {
                     return true;
                 }
 
-                display(1, skill.toString(), sender, useMySQL, command);
+                display(1, skill.toString(), sender, command);
                 return true;
 
             case 2:
@@ -50,7 +52,7 @@ public class MctopCommand implements CommandExecutor {
                     return true;
                 }
 
-                display(Math.abs(Integer.parseInt(args[1])), skill.toString(), sender, useMySQL, command);
+                display(Math.abs(Integer.parseInt(args[1])), skill.toString(), sender, command);
                 return true;
 
             default:
@@ -58,59 +60,31 @@ public class MctopCommand implements CommandExecutor {
         }
     }
 
-    private void display(int page, String skill, CommandSender sender, boolean sql, Command command) {
+    @Override
+    public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) {
+        switch (args.length) {
+            case 1:
+                return StringUtil.copyPartialMatches(args[0], SkillType.SKILL_NAMES, new ArrayList<String>(SkillType.SKILL_NAMES.size()));
+            default:
+                return ImmutableList.of();
+        }
+    }
+
+    private void display(int page, String skill, CommandSender sender, Command command) {
         if (!skill.equalsIgnoreCase("all") && !Permissions.mctop(sender, this.skill)) {
             sender.sendMessage(command.getPermissionMessage());
             return;
         }
 
-        if (sql) {
-            if (skill.equalsIgnoreCase("all")) {
-                sqlDisplay(page, "taming+mining+woodcutting+repair+unarmed+herbalism+excavation+archery+swords+axes+acrobatics+fishing", sender);
-            }
-            else {
-                sqlDisplay(page, skill, sender);
-            }
+        if (sender instanceof Player && Config.getInstance().getMctopScoreboardEnabled()) {
+            ScoreboardManager.enableGlobalStatsScoreboard((Player) sender, skill, page);
         }
         else {
-            flatfileDisplay(page, skill, sender);
+            display(page, skill, sender);
         }
     }
 
-    private void flatfileDisplay(int page, String skill, CommandSender sender) {
-        LeaderboardManager.updateLeaderboards(); // Make sure we have the latest information
-
-        if (skill.equalsIgnoreCase("all")) {
-            sender.sendMessage(LocaleLoader.getString("Commands.PowerLevel.Leaderboard"));
-        }
-        else {
-            sender.sendMessage(LocaleLoader.getString("Commands.Skill.Leaderboard", StringUtils.getCapitalized(skill)));
-        }
-
-        int position = (page * 10) - 9;
-
-        for (String playerStat : LeaderboardManager.retrieveInfo(skill, page)) {
-            if (playerStat == null) {
-                continue;
-            }
-
-            String digit = String.valueOf(position);
-
-            if (position < 10) {
-                digit = "0" + digit;
-            }
-
-            String[] splitStat = playerStat.split(":");
-
-            // Format: 1. Playername - skill value
-            sender.sendMessage(digit + ". " + ChatColor.GREEN + splitStat[1] + " - " + ChatColor.WHITE + splitStat[0]);
-            position++;
-        }
-
-        sender.sendMessage(LocaleLoader.getString("Commands.mctop.Tip"));
-    }
-
-    private void sqlDisplay(int page, String query, CommandSender sender) {
+    private void display(int page, String query, CommandSender sender) {
         new MctopCommandAsyncTask(page, query, sender).runTaskAsynchronously(mcMMO.p);
     }
 

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

@@ -1,5 +1,8 @@
 package com.gmail.nossr50.commands.skills;
 
+import org.bukkit.block.Biome;
+import org.bukkit.entity.EntityType;
+
 import com.gmail.nossr50.config.AdvancedConfig;
 import com.gmail.nossr50.datatypes.skills.SkillType;
 import com.gmail.nossr50.locale.LocaleLoader;
@@ -15,11 +18,14 @@ public class FishingCommand extends SkillCommand {
     private String shakeChance;
     private String shakeChanceLucky;
     private int fishermansDietRank;
+    private String biteChance;
 
     private boolean canTreasureHunt;
     private boolean canMagicHunt;
     private boolean canShake;
     private boolean canFishermansDiet;
+    private boolean canMasterAngler;
+    private boolean canIceFish;
 
     public FishingCommand() {
         super(SkillType.FISHING);
@@ -27,12 +33,14 @@ public class FishingCommand extends SkillCommand {
 
     @Override
     protected void dataCalculations() {
+        boolean isStorming = player.getWorld().hasStorm();
+
         // TREASURE HUNTER
         if (canTreasureHunt) {
             lootTier = mcMMOPlayer.getFishingManager().getLootTier();
             double enchantChance = lootTier * AdvancedConfig.getInstance().getFishingMagicMultiplier();
 
-            if (player.getWorld().hasStorm()) {
+            if (isStorming) {
                 chanceRaining = LocaleLoader.getString("Fishing.Chance.Raining");
                 enchantChance *= 1.1D;
             }
@@ -53,6 +61,22 @@ public class FishingCommand extends SkillCommand {
         if (canFishermansDiet) {
             fishermansDietRank = calculateRank(Fishing.fishermansDietMaxLevel, Fishing.fishermansDietRankLevel1);
         }
+
+        // MASTER ANGLER
+        if (canMasterAngler) {
+            double rawBiteChance = ((Math.max((skillValue / 200.0), 1.0)) / (isStorming ? 300 : 500));
+            Biome biome = player.getLocation().getBlock().getBiome();
+
+            if (biome == Biome.RIVER || biome == Biome.OCEAN) {
+                rawBiteChance = rawBiteChance * 2.0;
+            }
+
+            if (player.isInsideVehicle() && player.getVehicle().getType() == EntityType.BOAT) {
+                rawBiteChance = rawBiteChance * 2.0;
+            }
+
+            biteChance = calculateAbilityDisplayValues(rawBiteChance * 100.0)[0];
+        }
     }
 
     @Override
@@ -61,11 +85,13 @@ public class FishingCommand extends SkillCommand {
         canMagicHunt = Permissions.magicHunter(player);
         canShake = Permissions.shake(player);
         canFishermansDiet = Permissions.fishermansDiet(player);
+        canMasterAngler = Permissions.masterAngler(player);
+        canIceFish = Permissions.iceFishing(player);
     }
 
     @Override
     protected boolean effectsHeaderPermissions() {
-        return canTreasureHunt || canMagicHunt || canShake;
+        return canTreasureHunt || canMagicHunt || canShake || canMasterAngler || canFishermansDiet || canIceFish;
     }
 
     @Override
@@ -87,15 +113,27 @@ public class FishingCommand extends SkillCommand {
         if (canFishermansDiet) {
             player.sendMessage(LocaleLoader.getString("Effects.Template", LocaleLoader.getString("Fishing.Effect.6"), LocaleLoader.getString("Fishing.Effect.7")));
         }
+
+        if (canMasterAngler) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", LocaleLoader.getString("Fishing.Effect.8"), LocaleLoader.getString("Fishing.Effect.9")));
+        }
+
+        if (canIceFish) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", LocaleLoader.getString("Fishing.Effect.10"), LocaleLoader.getString("Fishing.Effect.11")));
+        }
     }
 
     @Override
     protected boolean statsHeaderPermissions() {
-        return canTreasureHunt || canMagicHunt || canShake;
+        return canTreasureHunt || canMagicHunt || canShake || canMasterAngler || canFishermansDiet || canIceFish;
     }
 
     @Override
     protected void statsDisplay() {
+        if (canMasterAngler) {
+            player.sendMessage(LocaleLoader.getString("Fishing.Ability.Chance", biteChance));
+        }
+
         if (canTreasureHunt) {
             player.sendMessage(LocaleLoader.getString("Fishing.Ability.Rank", lootTier));
         }
@@ -118,5 +156,16 @@ public class FishingCommand extends SkillCommand {
         if (canFishermansDiet) {
             player.sendMessage(LocaleLoader.getString("Fishing.Ability.FD", fishermansDietRank));
         }
+
+        if (canIceFish) {
+            int unlockLevel = AdvancedConfig.getInstance().getIceFishingUnlockLevel();
+
+            if (skillValue < unlockLevel) {
+                player.sendMessage(LocaleLoader.getString("Ability.Generic.Template.Lock", LocaleLoader.getString("Fishing.Ability.Locked.1", unlockLevel)));
+            }
+            else {
+                player.sendMessage(LocaleLoader.getString("Fishing.Ability.IceFishing"));
+            }
+        }
     }
 }

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

@@ -41,10 +41,10 @@ public class RepairCommand extends SkillCommand {
     @Override
     protected void dataCalculations() {
         // We're using pickaxes here, not the best but it works
-        Repairable diamondRepairable = mcMMO.repairableManager.getRepairable(Material.DIAMOND_PICKAXE.getId());
-        Repairable goldRepairable = mcMMO.repairableManager.getRepairable(Material.GOLD_PICKAXE.getId());
-        Repairable ironRepairable = mcMMO.repairableManager.getRepairable(Material.IRON_PICKAXE.getId());
-        Repairable stoneRepairable = mcMMO.repairableManager.getRepairable(Material.STONE_PICKAXE.getId());
+        Repairable diamondRepairable = mcMMO.getRepairableManager().getRepairable(Material.DIAMOND_PICKAXE.getId());
+        Repairable goldRepairable = mcMMO.getRepairableManager().getRepairable(Material.GOLD_PICKAXE.getId());
+        Repairable ironRepairable = mcMMO.getRepairableManager().getRepairable(Material.IRON_PICKAXE.getId());
+        Repairable stoneRepairable = mcMMO.getRepairableManager().getRepairable(Material.STONE_PICKAXE.getId());
 
         // TODO: This isn't really accurate - if they don't have pickaxes loaded it doesn't always mean the repair level is 0
         diamondLevel = (diamondRepairable == null) ? 0 : diamondRepairable.getMinimumLevel();

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

@@ -1,14 +1,17 @@
 package com.gmail.nossr50.commands.skills;
 
 import java.text.DecimalFormat;
+import java.util.List;
 import java.util.Set;
 
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandExecutor;
 import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
 import org.bukkit.entity.Player;
 
 import com.gmail.nossr50.config.AdvancedConfig;
+import com.gmail.nossr50.config.Config;
 import com.gmail.nossr50.datatypes.player.McMMOPlayer;
 import com.gmail.nossr50.datatypes.player.PlayerProfile;
 import com.gmail.nossr50.datatypes.skills.SkillType;
@@ -18,10 +21,13 @@ import com.gmail.nossr50.util.Permissions;
 import com.gmail.nossr50.util.StringUtils;
 import com.gmail.nossr50.util.commands.CommandUtils;
 import com.gmail.nossr50.util.player.UserManager;
+import com.gmail.nossr50.util.scoreboards.ScoreboardManager;
 import com.gmail.nossr50.util.skills.PerksUtils;
 import com.gmail.nossr50.util.skills.SkillUtils;
 
-public abstract class SkillCommand implements CommandExecutor {
+import com.google.common.collect.ImmutableList;
+
+public abstract class SkillCommand implements TabExecutor {
     protected SkillType skill;
     protected String skillName;
 
@@ -50,8 +56,8 @@ public abstract class SkillCommand implements CommandExecutor {
             return true;
         }
 
-        mcMMOPlayer = UserManager.getPlayer(sender.getName());
-        player = mcMMOPlayer.getPlayer();
+        player = (Player) sender;
+        mcMMOPlayer = UserManager.getPlayer(player);
 
         switch (args.length) {
             case 0:
@@ -67,7 +73,14 @@ public abstract class SkillCommand implements CommandExecutor {
                 if (!skill.isChildSkill()) {
                     player.sendMessage(LocaleLoader.getString("Skills.Header", skillName));
                     player.sendMessage(LocaleLoader.getString("Commands.XPGain", LocaleLoader.getString("Commands.XPGain." + StringUtils.getCapitalized(skill.toString()))));
-                    player.sendMessage(LocaleLoader.getString("Effects.Level", (int) skillValue, profile.getSkillXpLevel(skill), profile.getXpToLevel(skill)));
+
+                    if (Config.getInstance().getSkillScoreboardEnabled()) {
+                        ScoreboardManager.setupPlayerScoreboard(player.getName());
+                        ScoreboardManager.enablePlayerSkillScoreboard(mcMMOPlayer, skill);
+                    }
+                    else {
+                        player.sendMessage(LocaleLoader.getString("Effects.Level", (int) skillValue, profile.getSkillXpLevel(skill), profile.getXpToLevel(skill)));
+                    }
                 }
                 else {
                     player.sendMessage(LocaleLoader.getString("Skills.Header", skillName + " " + LocaleLoader.getString("Skills.Child")));
@@ -102,6 +115,16 @@ public abstract class SkillCommand implements CommandExecutor {
         }
     }
 
+    @Override
+    public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) {
+        switch (args.length) {
+            case 1:
+                return ImmutableList.of("?");
+            default:
+                return ImmutableList.of();
+        }
+    }
+
     protected int calculateRank(int maxLevel, int rankChangeLevel) {
         return Math.min((int) skillValue, maxLevel) / rankChangeLevel;
     }

src/main/java/com/gmail/nossr50/commands/spout/MchudCommand.java

@@ -1,12 +1,41 @@
 package com.gmail.nossr50.commands.spout;
 
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandSender;
+import org.bukkit.util.StringUtil;
 
 import com.gmail.nossr50.datatypes.spout.huds.HudType;
 import com.gmail.nossr50.locale.LocaleLoader;
+import com.google.common.collect.ImmutableList;
 
 public class MchudCommand extends SpoutCommand {
+    private static final List<String> HUD_TYPES;
+
+    static {
+        ArrayList<String> types = new ArrayList<String>();
+
+        for (HudType type : HudType.values()) {
+            types.add(type.toString());
+        }
+
+        Collections.sort(types);
+        HUD_TYPES = ImmutableList.copyOf(types);
+    }
+
+    @Override
+    public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) {
+        switch (args.length) {
+            case 1:
+                return StringUtil.copyPartialMatches(args[0], HUD_TYPES, new ArrayList<String>(HUD_TYPES.size()));
+            default:
+                return ImmutableList.of();
+        }
+    }
+
     @Override
     protected boolean noArguments(Command command, CommandSender sender, String[] args) {
         return false;
@@ -14,16 +43,15 @@ public class MchudCommand extends SpoutCommand {
 
     @Override
     protected boolean oneArgument(Command command, CommandSender sender, String[] args) {
-        for (HudType hudType : HudType.values()) {
-            if (hudType.toString().equalsIgnoreCase(args[0])) {
-                playerProfile.setHudType(hudType);
-                spoutHud.initializeXpBar();
-                spoutHud.updateXpBar();
-                return true;
-            }
+        try {
+            playerProfile.setHudType(HudType.valueOf(args[0].toUpperCase().trim()));
+            spoutHud.initializeXpBar();
+            spoutHud.updateXpBar();
+            return true;
+        }
+        catch (IllegalArgumentException ex) {
+            sender.sendMessage(LocaleLoader.getString("Commands.mchud.Invalid"));
+            return true;
         }
-
-        sender.sendMessage(LocaleLoader.getString("Commands.mchud.Invalid"));
-        return true;
     }
 }

src/main/java/com/gmail/nossr50/commands/spout/SpoutCommand.java

@@ -1,8 +1,9 @@
 package com.gmail.nossr50.commands.spout;
 
 import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
 import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
+import org.bukkit.entity.Player;
 
 import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.config.spout.SpoutConfig;
@@ -12,7 +13,7 @@ import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.util.commands.CommandUtils;
 import com.gmail.nossr50.util.player.UserManager;
 
-public abstract class SpoutCommand implements CommandExecutor {
+public abstract class SpoutCommand implements TabExecutor {
     protected PlayerProfile playerProfile;
     protected McMMOHud spoutHud;
 
@@ -22,12 +23,12 @@ public abstract class SpoutCommand implements CommandExecutor {
             return true;
         }
 
-        if (!mcMMO.spoutEnabled || !SpoutConfig.getInstance().getXPBarEnabled()) {
+        if (!mcMMO.isSpoutEnabled() || !SpoutConfig.getInstance().getXPBarEnabled()) {
             sender.sendMessage(LocaleLoader.getString("Commands.Disabled"));
             return true;
         }
 
-        playerProfile = UserManager.getPlayer(sender.getName()).getProfile();
+        playerProfile = UserManager.getPlayer((Player) sender).getProfile();
         spoutHud = playerProfile.getSpoutHud();
 
         if (spoutHud == null) {

src/main/java/com/gmail/nossr50/commands/spout/XplockCommand.java

@@ -1,15 +1,36 @@
 package com.gmail.nossr50.commands.spout;
 
+import java.util.ArrayList;
+import java.util.List;
+
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandSender;
+import org.bukkit.util.StringUtil;
 
 import com.gmail.nossr50.datatypes.skills.SkillType;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.util.Permissions;
 import com.gmail.nossr50.util.commands.CommandUtils;
 import com.gmail.nossr50.util.skills.SkillUtils;
+import com.google.common.collect.ImmutableList;
 
 public class XplockCommand extends SpoutCommand {
+    @Override
+    public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) {
+        switch (args.length) {
+            case 1:
+                List<String> matches = StringUtil.copyPartialMatches(args[0], CommandUtils.TRUE_FALSE_OPTIONS, new ArrayList<String>(CommandUtils.TRUE_FALSE_OPTIONS.size()));
+
+                if (matches.size() == 0) {
+                    return StringUtil.copyPartialMatches(args[0], SkillType.SKILL_NAMES, new ArrayList<String>(SkillType.SKILL_NAMES.size()));
+                }
+
+                return matches;
+            default:
+                return ImmutableList.of();
+        }
+    }
+
     @Override
     protected boolean noArguments(Command command, CommandSender sender, String[] args) {
         if (spoutHud.getXpBarLocked()) {

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

@@ -20,7 +20,10 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
 
     /* GENERAL */
     public int getAbilityLength() { return config.getInt("Skills.General.Ability_IncreaseLevel", 50); }
-    public int getEnchantBuff() { return config.getInt("Skills.General.Ability_EnchantBuff", 5); }
+    public int getEnchantBuff() {
+        int buff = config.getInt("Skills.General.Ability_EnchantBuff", 5);
+        return (buff <= 0) ? 1 : buff;
+    }
 
     /* ACROBATICS */
     public double getDodgeChanceMax() { return config.getDouble("Skills.Acrobatics.Dodge_ChanceMax", 20.0D); }
@@ -34,7 +37,6 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
     public double getGracefulRollChanceMax() { return config.getDouble("Skills.Acrobatics.GracefulRoll_ChanceMax", 100.0D); }
     public int getGracefulRollMaxBonusLevel() { return config.getInt("Skills.Acrobatics.GracefulRoll_MaxBonusLevel", 500); }
     public int getGracefulRollDamageThreshold() { return config.getInt("Skills.Acrobatics.GracefulRoll_DamageThreshold", 14); }
-    public int getGracefulRollSuccessModifer() { return config.getInt("Skills.Acrobatics.GracefulRoll_SuccessModifier", 2); }
 
     public int getDodgeXPModifier() { return config.getInt("Skills.Acrobatics.Dodge_XP_Modifier", 120); }
     public int getRollXPModifier() { return config.getInt("Skills.Acrobatics.Roll_XP_Modifier", 80); }
@@ -52,6 +54,8 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
     public double getRetrieveChanceMax() { return config.getDouble("Skills.Archery.Retrieve_MaxBonus", 100.0D); }
     public int getRetrieveMaxBonusLevel() { return config.getInt("Skills.Archery.Retrieve_MaxBonusLevel", 1000); }
 
+    public double getForceMultiplier() { return config.getDouble("Skills.Archery.Force_Multiplier", 2.0D); }
+
     /* AXES */
     public int getBonusDamageAxesBonusMax() { return config.getInt("Skills.Axes.DamageIncrease_MaxBonus", 4); }
     public int getBonusDamageAxesMaxBonusLevel() { return config.getInt("Skills.Axes.DamageIncrease_MaxBonusLevel", 200); }
@@ -85,6 +89,8 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
 
     public int getFishermanDietRankChange() { return config.getInt("Skills.Fishing.Fisherman_Diet_RankChange", 200); }
 
+    public int getIceFishingUnlockLevel() { return config.getInt("Skills.Fishing.Ice_Fishing_UnlockLevel", 50); }
+
     /* Shake */
     public int getShakeUnlockLevel() { return config.getInt("Skills.Fishing.Shake_UnlockLevel", 150); }
     public int getShakeChanceRank1() { return config.getInt("Skills.Fishing.Shake_Chance.Rank_1", 25); }
@@ -273,9 +279,17 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
     public double getWoodcuttingDoubleDropChance() { return config.getDouble("Skills.Woodcutting.DoubleDrops_ChanceMax", 100.0D); }
     public int getWoodcuttingDoubleDropMaxLevel() { return config.getInt("Skills.Woodcutting.DoubleDrops_MaxBonusLevel", 1000); }
 
-    /* SPOUT STUFF*/
-    public int getSpoutNotificationTier1() { return config.getInt("Spout.Notifications.Tier1", 200); }
-    public int getSpoutNotificationTier2() { return config.getInt("Spout.Notifications.Tier2", 400); }
-    public int getSpoutNotificationTier3() { return config.getInt("Spout.Notifications.Tier3", 600); }
-    public int getSpoutNotificationTier4() { return config.getInt("Spout.Notifications.Tier4", 800); }
+    /* KRAKEN STUFF */
+    public boolean getKrakenEnabled() { return config.getBoolean("Kraken.Enabled", true); }
+    public boolean getKrakenGlobalSoundsEnabled() { return config.getBoolean("Kraken.Global_Sounds", true); }
+    public boolean getKrakenEscapeAllowed() { return config.getBoolean("Kraken.Allow_Escaping", false); }
+    public int getKrakenTriesBeforeRelease() { return config.getInt("Kraken.Tries_Before_Release", 50); }
+    public int getKrakenHealth() { return config.getInt("Kraken.Health", 50); }
+    public String getKrakenName() { return config.getString("Kraken.Name", "The Kraken"); }
+    public String getServerUnleashMessage() { return config.getString("Kraken.Unleashed_Message.Server", "(PLAYER) has unleashed the kraken!"); }
+    public String getPlayerUnleashMessage() { return config.getString("Kraken.Unleashed_Message.Player", "THE KRAKEN HAS BEEN UNLEASHED!"); }
+    public String getPlayerDefeatMessage() { return config.getString("Kraken.Defeated_Message.Killed", "You have slain the kraken!"); }
+    public String getPlayerEscapeMessage() { return config.getString("Kraken.Defeated_Message.Escape", "You have escaped from the kraken!"); }
+    public int getKrakenAttackInterval() { return config.getInt("Kraken.Attack_Interval_Seconds", 1); }
+    public int getKrakenAttackDamage() { return config.getInt("Kraken.Attack_Damage", 1); }
 }

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

@@ -6,6 +6,7 @@ import org.bukkit.Material;
 import org.bukkit.configuration.ConfigurationSection;
 import org.bukkit.entity.EntityType;
 
+import com.gmail.nossr50.datatypes.MobHealthbarType;
 import com.gmail.nossr50.datatypes.skills.AbilityType;
 import com.gmail.nossr50.datatypes.skills.SkillType;
 import com.gmail.nossr50.util.StringUtils;
@@ -48,6 +49,36 @@ public class Config extends AutoUpdateConfigLoader {
     public boolean getPartyDisplayNames() { return config.getBoolean("Commands.p.Use_Display_Names", true); }
     public boolean getAdminDisplayNames() { return config.getBoolean("Commands.a.Use_Display_Names", true); }
 
+    /* Mob Healthbar */
+    public MobHealthbarType getMobHealthbarDefault() {
+        try {
+            return MobHealthbarType.valueOf(config.getString("Mob_Healthbar.Display_Type", "HEARTS").toUpperCase().trim());
+        }
+        catch (IllegalArgumentException ex) {
+            return MobHealthbarType.HEARTS;
+        }
+    }
+
+    public int getMobHealthbarTime() { return config.getInt("Mob_Healthbar.Display_Time", 3); }
+
+    /* Scoreboards */
+    public boolean getMcrankScoreboardEnabled() { return config.getBoolean("Scoreboards.Mcrank.Use", true); }
+    public int getMcrankScoreboardTime() { return config.getInt("Scoreboards.Mcrank.Display_Time", 10); }
+
+    public boolean getMcstatsScoreboardsEnabled() { return config.getBoolean("Scoreboards.Mcstats.Use", true); }
+    public int getMcstatsScoreboardTime() { return config.getInt("Scoreboards.Mcstats.Display_Time", 10); }
+
+    public boolean getMctopScoreboardEnabled() { return config.getBoolean("Scoreboards.Mctop.Use", true); }
+    public int getMctopScoreboardTime() { return config.getInt("Scoreboards.Mctop.Display_Time", 10); }
+
+    public boolean getInspectScoreboardEnabled() { return config.getBoolean("Scoreboards.Inspect.Use", true); }
+    public int getInspectScoreboardTime() { return config.getInt("Scoreboards.Inspect.Display_Time", 10); }
+
+    public boolean getSkillScoreboardEnabled() { return config.getBoolean("Scoreboards.Skillname.Use", true); }
+    public int getSkillScoreboardTime() { return config.getInt("Scoreboards.Skillname.Display_Time", 10); }
+
+    public boolean getPowerLevelsEnabled() { return config.getBoolean("Scoreboards.Power_Level.Use", 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); }
@@ -108,6 +139,7 @@ public class Config extends AutoUpdateConfigLoader {
     public boolean getChimaeraPreventUseUnderground() { return config.getBoolean("Items.Chimaera_Wing.Prevent_Use_Underground", true); }
     public int getChimaeraCooldown() { return config.getInt("Items.Chimaera_Wing.Cooldown", 240); }
     public int getChimaeraWarmup() { return config.getInt("Items.Chimaera_Wing.Warmup", 5); }
+    public int getChimaeraRecentlyHurtCooldown() { return config.getInt("Items.Chimaera_Wing.RecentlyHurt_Cooldown", 60); }
 
     /* Particles */
     public boolean getAbilityActivationEffectEnabled() { return config.getBoolean("Particles.Ability_Activation", true); }
@@ -117,6 +149,7 @@ public class Config extends AutoUpdateConfigLoader {
     public boolean getGreaterImpactEffectEnabled() { return config.getBoolean("Particles.Greater_Impact", true); }
     public boolean getLevelUpEffectsEnabled() { return config.getBoolean("Particles.LevelUp_Enabled", true); }
     public int getLevelUpEffectsTier() { return config.getInt("Particles.LevelUp_Tier", 100); }
+    public boolean getLargeFireworks() { return config.getBoolean("Particles.LargeFireworks", true); }
 
     /* PARTY SETTINGS */
     public int getAutoPartyKickInterval() { return config.getInt("Party.AutoKick_Interval", 12); }
@@ -129,11 +162,16 @@ public class Config extends AutoUpdateConfigLoader {
     public double getPartyShareRange() { return config.getDouble("Party.Sharing.Range", 75.0); }
 
     /* Party Teleport Settings */
-    public int getPTPCommandCooldown() { return config.getInt("Commands.ptp.Cooldown", 30); }
+    public int getPTPCommandCooldown() { return config.getInt("Commands.ptp.Cooldown", 120); }
+    public int getPTPCommandWarmup() { return config.getInt("Commands.ptp.Warmup", 5); }
+    public int getPTPCommandRecentlyHurtCooldown() { return config.getInt("Commands.ptp.RecentlyHurt_Cooldown", 60); }
     public int getPTPCommandTimeout() { return config.getInt("Commands.ptp.Request_Timeout", 300); }
     public boolean getPTPCommandConfirmRequired() { return config.getBoolean("Commands.ptp.Confirm_Required", true); }
     public boolean getPTPCommandWorldPermissions() { return config.getBoolean("Commands.ptp.World_Based_Permissions", false); }
 
+    /* Inspect command distance */
+    public double getInspectDistance() { return config.getDouble("Commands.inspect.Max_Distance", 30); }
+
     /*
      * ABILITY SETTINGS
      */
@@ -192,6 +230,7 @@ public class Config extends AutoUpdateConfigLoader {
     public int getSalvageAnvilId() { return config.getInt("Skills.Repair.Salvage_Anvil_ID", 41); }
     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); }
 
     /* Unarmed */
     public boolean getUnarmedBlockCrackerSmoothbrickToCracked() { return config.getBoolean("Skills.Unarmed.Block_Cracker.SmoothBrick_To_CrackedBrick", true); }
@@ -239,7 +278,6 @@ public class Config extends AutoUpdateConfigLoader {
      */
 
     /* General Settings */
-    public boolean getExperienceGainsMobspawnersEnabled() { return config.getBoolean("Experience.Gains.Mobspawners.Enabled", false); }
     public boolean getExperienceGainsPlayerVersusPlayerEnabled() { return config.getBoolean("Experience.PVP.Rewards", true); }
 
     public double getExperienceGainsGlobalMultiplier() { return config.getDouble("Experience.Gains.Multiplier.Global", 1.0); }
@@ -252,8 +290,9 @@ public class Config extends AutoUpdateConfigLoader {
     public double getAnimalsXP() { return config.getDouble("Experience.Combat.Multiplier.Animals", 1.0); }
     public double getWitherSkeletonXP() { return config.getDouble("Experience.Combat.Multiplier.Wither_Skeleton", 4.0); }
 
+    public double getSpawnedMobXpMultiplier() { return config.getDouble("Experience.Gains.Mobspawners.Multiplier", 0.0); }
 
     /* XP Formula Multiplier */
     public int getFormulaMultiplierCurve() { return config.getInt("Experience.Formula.Curve_Modifier", 20); }
-    public double getForumulaMultiplier(SkillType skill) { return config.getDouble("Experience.Formula.Modifier." + StringUtils.getCapitalized(skill.toString())); }
+    public double getFormulaSkillModifier(SkillType skill) { return config.getDouble("Experience.Formula.Modifier." + StringUtils.getCapitalized(skill.toString())); }
 }

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

@@ -1,7 +1,9 @@
 package com.gmail.nossr50.config;
 
 import java.io.File;
+import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
+import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 
@@ -30,11 +32,11 @@ public abstract class ConfigLoader {
 
     protected void loadFile() {
         if (!configFile.exists()) {
-            plugin.getLogger().info("Creating mcMMO " + fileName + " File...");
+            plugin.debug("Creating mcMMO " + fileName + " File...");
             createFile();
         }
         else {
-            plugin.getLogger().info("Loading mcMMO " + fileName + " File...");
+            plugin.debug("Loading mcMMO " + fileName + " File...");
         }
 
         config = YamlConfiguration.loadConfiguration(configFile);
@@ -43,38 +45,49 @@ public abstract class ConfigLoader {
     protected abstract void loadKeys();
 
     protected void createFile() {
-        if (configFile.exists()) {
-            return;
-        }
-
         configFile.getParentFile().mkdirs();
 
         InputStream inputStream = plugin.getResource(fileName);
 
-        if (inputStream != null) {
-            try {
-                copyStreamToFile(inputStream, configFile);
+        if (inputStream == null) {
+            plugin.getLogger().severe("Missing resource file: '" + fileName + "' please notify the plugin authors");
+            return;
+        }
+
+        OutputStream outputStream = null;
+
+        try {
+            outputStream = new FileOutputStream(configFile);
+
+            int read;
+            byte[] bytes = new byte[1024];
+
+            while ((read = inputStream.read(bytes)) != -1) {
+                outputStream.write(bytes, 0, read);
             }
-            catch (Exception e) {
+        }
+        catch (FileNotFoundException e) {
+            e.printStackTrace();
+        }
+        catch (IOException e) {
+            e.printStackTrace();
+        }
+        finally {
+            if (outputStream != null) {
+                try {
+                    outputStream.close();
+                }
+                catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+
+            try {
+                inputStream.close();
+            }
+            catch (IOException e) {
                 e.printStackTrace();
             }
         }
-        else {
-            plugin.getLogger().severe("Missing resource file: '" + fileName + "' please notify the plugin authors");
-        }
-    }
-
-    private static void copyStreamToFile(InputStream inputStream, File file) throws Exception {
-        OutputStream outputStream = new FileOutputStream(file);
-
-        int read = 0;
-        byte[] bytes = new byte[1024];
-
-        while ((read = inputStream.read(bytes)) != -1) {
-            outputStream.write(bytes, 0, read);
-        }
-
-        inputStream.close();
-        outputStream.close();
     }
 }

src/main/java/com/gmail/nossr50/config/party/ItemWeightConfig.java

@@ -1,5 +1,7 @@
 package com.gmail.nossr50.config.party;
 
+import java.util.HashSet;
+
 import org.bukkit.Material;
 
 import com.gmail.nossr50.config.ConfigLoader;
@@ -21,13 +23,20 @@ public class ItemWeightConfig extends ConfigLoader {
     }
 
     public int getItemWeight(Material material) {
-        String materialName = StringUtils.getPrettyItemString(material).replace(" ", "_");
-        int itemWeight = config.getInt("Item_Weights.Default");
+        return config.getInt("Item_Weights." + StringUtils.getPrettyItemString(material).replace(" ", "_"), config.getInt("Item_Weights.Default"));
+    }
 
-        if (config.getInt("Item_Weights." + materialName) > 0) {
-            itemWeight = config.getInt("Item_Weights." + materialName);
+    public HashSet<Material> getMiscItems() {
+        HashSet<Material> miscItems = new HashSet<Material>();
+
+        for (String item : config.getStringList("Party_Shareables.Misc_Items")) {
+            Material material = Material.getMaterial(item.toUpperCase());
+
+            if (material != null) {
+                miscItems.add(material);
+            }
         }
-        return itemWeight;
+        return miscItems;
     }
 
     @Override

src/main/java/com/gmail/nossr50/config/spout/SpoutConfig.java

@@ -1,16 +1,16 @@
 package com.gmail.nossr50.config.spout;
 
+import org.getspout.spoutapi.keyboard.Keyboard;
+
 import com.gmail.nossr50.config.ConfigLoader;
 import com.gmail.nossr50.datatypes.skills.SkillType;
 import com.gmail.nossr50.datatypes.spout.huds.HudType;
 
 public class SpoutConfig extends ConfigLoader {
     private static SpoutConfig instance;
-    public HudType defaultHudType;
 
     private SpoutConfig() {
         super("spout.yml");
-        loadKeys();
     }
 
     public static SpoutConfig getInstance() {
@@ -24,22 +24,26 @@ public class SpoutConfig extends ConfigLoader {
     @Override
     protected void loadKeys() {
         // Setup default HUD
-        String temp = config.getString("Spout.HUD.Default", "STANDARD");
+    }
 
-        for (HudType hudType : HudType.values()) {
-            if (hudType.toString().equalsIgnoreCase(temp)) {
-                defaultHudType = hudType;
-                break;
-            }
+    public HudType getDefaultHudType() {
+        try {
+            return HudType.valueOf(config.getString("Spout.HUD.Default", "STANDARD").toUpperCase().trim());
         }
-
-        if (defaultHudType == null) {
-            defaultHudType = HudType.STANDARD;
+        catch (IllegalArgumentException ex) {
+            return HudType.STANDARD;
         }
     }
 
     public boolean getShowPowerLevel() { return config.getBoolean("HUD.Show_Power_Level", true); }
-    public String getMenuKey() { return config.getString("Menu.Key", "KEY_M"); }
+    public Keyboard getMenuKey() { 
+        try {
+            return Keyboard.valueOf(config.getString("Menu.Key", "KEY_M").toUpperCase().trim());
+        }
+        catch (IllegalArgumentException ex) {
+            return Keyboard.KEY_M;
+        }
+    }
 
     /* XP Bar */
     public boolean getXPBarEnabled() { return config.getBoolean("XP.Bar.Enabled", true); }
@@ -62,4 +66,10 @@ public class SpoutConfig extends ConfigLoader {
     public double getRetroHUDRed(SkillType skill) { return config.getDouble("HUD.Retro.Colors." + skill.toString().toLowerCase() +".RED", 0.3); }
     public double getRetroHUDGreen(SkillType skill) { return config.getDouble("HUD.Retro.Colors." + skill.toString().toLowerCase() +".RED", 0.3); }
     public double getRetroHUDBlue(SkillType skill) { return config.getDouble("HUD.Retro.Colors." + skill.toString().toLowerCase() +".RED", 0.3); }
+
+    /* Notification Tiers */
+    public int getNotificationTier1() { return config.getInt("Notifications.Tier1", 200); }
+    public int getNotificationTier2() { return config.getInt("Notifications.Tier2", 400); }
+    public int getNotificationTier3() { return config.getInt("Notifications.Tier3", 600); }
+    public int getNotificationTier4() { return config.getInt("Notifications.Tier4", 800); }
 }

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

@@ -9,13 +9,17 @@ import java.util.Set;
 
 import org.bukkit.Material;
 import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.entity.EntityType;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.material.MaterialData;
+import org.bukkit.potion.Potion;
+import org.bukkit.potion.PotionType;
 
 import com.gmail.nossr50.config.ConfigLoader;
 import com.gmail.nossr50.datatypes.treasure.ExcavationTreasure;
 import com.gmail.nossr50.datatypes.treasure.FishingTreasure;
 import com.gmail.nossr50.datatypes.treasure.HylianTreasure;
+import com.gmail.nossr50.datatypes.treasure.ShakeTreasure;
 import com.gmail.nossr50.datatypes.treasure.Treasure;
 
 public class TreasureConfig extends ConfigLoader {
@@ -33,6 +37,27 @@ public class TreasureConfig extends ConfigLoader {
     public List<HylianTreasure> hylianFromFlowers = new ArrayList<HylianTreasure>();
     public List<HylianTreasure> hylianFromPots    = new ArrayList<HylianTreasure>();
 
+    public List<ShakeTreasure> shakeFromBlaze       = new ArrayList<ShakeTreasure>();
+    public List<ShakeTreasure> shakeFromCaveSpider  = new ArrayList<ShakeTreasure>();
+    public List<ShakeTreasure> shakeFromSpider      = new ArrayList<ShakeTreasure>();
+    public List<ShakeTreasure> shakeFromChicken     = new ArrayList<ShakeTreasure>();
+    public List<ShakeTreasure> shakeFromCow         = new ArrayList<ShakeTreasure>();
+    public List<ShakeTreasure> shakeFromCreeper     = new ArrayList<ShakeTreasure>();
+    public List<ShakeTreasure> shakeFromEnderman    = new ArrayList<ShakeTreasure>();
+    public List<ShakeTreasure> shakeFromGhast       = new ArrayList<ShakeTreasure>();
+    public List<ShakeTreasure> shakeFromIronGolem   = new ArrayList<ShakeTreasure>();
+    public List<ShakeTreasure> shakeFromMagmaCube   = new ArrayList<ShakeTreasure>();
+    public List<ShakeTreasure> shakeFromMushroomCow = new ArrayList<ShakeTreasure>();
+    public List<ShakeTreasure> shakeFromPig         = new ArrayList<ShakeTreasure>();
+    public List<ShakeTreasure> shakeFromPigZombie   = new ArrayList<ShakeTreasure>();
+    public List<ShakeTreasure> shakeFromSheep       = new ArrayList<ShakeTreasure>();
+    public List<ShakeTreasure> shakeFromSkeleton    = new ArrayList<ShakeTreasure>();
+    public List<ShakeTreasure> shakeFromSlime       = new ArrayList<ShakeTreasure>();
+    public List<ShakeTreasure> shakeFromSnowman     = new ArrayList<ShakeTreasure>();
+    public List<ShakeTreasure> shakeFromSquid       = new ArrayList<ShakeTreasure>();
+    public List<ShakeTreasure> shakeFromWitch       = new ArrayList<ShakeTreasure>();
+    public List<ShakeTreasure> shakeFromZombie      = new ArrayList<ShakeTreasure>();
+
     public List<FishingTreasure> fishingRewards = new ArrayList<FishingTreasure>();
 
     private TreasureConfig() {
@@ -92,7 +117,7 @@ public class TreasureConfig extends ConfigLoader {
                 reason.add("Invalid amount: " + amount);
             }
 
-            if (data > 127 || data < -128) {
+            if (id < 256 && (data > 127 || data < -128)) {
                 reason.add("Invalid data: " + data);
             }
 
@@ -128,15 +153,32 @@ public class TreasureConfig extends ConfigLoader {
                 reason.add("Invalid Drop_Level: " + dropLevel);
             }
 
+            /*
+             * Potions
+             */
+
+            ItemStack item = null;
+
+            if (config.contains("Treasures." + treasureName + ".Potion_Type")) {
+                String potionType = config.getString("Treasures." + treasureName + ".Potion_Type");
+                try {
+                    item = new Potion(PotionType.valueOf(potionType.toUpperCase())).toItemStack(amount);
+                }
+                catch (IllegalArgumentException ex) {
+                    reason.add("Invalid Potion_Type: " + potionType);
+                }
+            }
+            else {
+                item = (new MaterialData(id, (byte) data)).toItemStack(amount);
+            }
+
             /*
              * Drops From & Max Level
              */
 
-            ItemStack item = (new MaterialData(id, (byte) data)).toItemStack(amount);
-
             if (config.getBoolean("Treasures." + treasureName + ".Drops_From.Fishing", false)) {
                 if (config.getConfigurationSection("Treasures." + treasureName + ".Drops_From").getKeys(false).size() != 1) {
-                    reason.add("Fishing drops cannot also be excavation drops");
+                    reason.add("This can only be a fishing drop.");
                 }
 
                 if (!config.contains("Treasures." + treasureName + ".Max_Level")) {
@@ -150,6 +192,30 @@ public class TreasureConfig extends ConfigLoader {
                     treasures.put(treasureName, fTreasure);
                 }
             }
+            else if (config.getBoolean("Treasures." + treasureName + ".Drops_From.Shake", false)) {
+                if (config.getConfigurationSection("Treasures." + treasureName + ".Drops_From").getKeys(false).size() != 1) {
+                    reason.add("This can only be a shake drop.");
+                }
+
+                if (!config.contains("Treasures." + treasureName + ".Mob")) {
+                    reason.add("Missing Mob");
+                }
+
+                String mobType = config.getString("Treasures." + treasureName + ".Mob");
+                EntityType mob = null;
+
+                try {
+                     mob = EntityType.valueOf(mobType.toUpperCase().trim());
+                }
+                catch (IllegalArgumentException ex){
+                    reason.add("Invalid Mob: " + mobType);
+                }
+
+                if (noErrorsInTreasure(reason)) {
+                    ShakeTreasure sTreasure = new ShakeTreasure(item, xp, dropChance, dropLevel, mob);
+                    treasures.put(treasureName, sTreasure);
+                }
+            }
             else {
                 ExcavationTreasure eTreasure = new ExcavationTreasure(item, xp, dropChance, dropLevel);
                 HylianTreasure hTreasure = new HylianTreasure(item, xp, dropChance, dropLevel);
@@ -195,7 +261,11 @@ public class TreasureConfig extends ConfigLoader {
                 }
 
                 if (config.getBoolean("Treasures." + treasureName + ".Drops_From.Fishing", false)) {
-                    reason.add("Excavation drops cannot also be fishing drops");
+                    reason.add("This cannot also be a fishing drop.");
+                }
+
+                if (config.getBoolean("Treasures." + treasureName + ".Drops_From.Shake", false)) {
+                    reason.add("This cannot also be a shake drop.");
                 }
 
                 if (noErrorsInTreasure(reason) && hTreasure.getDropsFrom() == (byte) 0x0) {
@@ -210,6 +280,7 @@ public class TreasureConfig extends ConfigLoader {
         List<String> excavationTreasures = config.getStringList("Excavation.Treasure");
         List<String> fishingTreasures = config.getStringList("Fishing.Treasure");
         List<String> hylianTreasures = config.getStringList("Hylian_Luck.Treasure");
+        List<String> shakeTreasures = config.getStringList("Shake.Treasure");
 
         for (Entry<String, Treasure> nextEntry : treasures.entrySet()) {
             String treasureKey = nextEntry.getKey();
@@ -222,6 +293,97 @@ public class TreasureConfig extends ConfigLoader {
 
                 fishingRewards.add((FishingTreasure) treasure);
             }
+            else if (treasure instanceof ShakeTreasure) {
+                if (shakeTreasures == null || !shakeTreasures.contains(treasureKey)) {
+                    continue;
+                }
+
+                ShakeTreasure e = (ShakeTreasure) treasure;
+                switch (e.getMob()) {
+                    case BLAZE:
+                        shakeFromBlaze.add(e);
+                        break;
+
+                    case CAVE_SPIDER:
+                        shakeFromCaveSpider.add(e);
+                        break;
+
+                    case CHICKEN:
+                        shakeFromChicken.add(e);
+                        break;
+
+                    case COW:
+                        shakeFromCow.add(e);
+                        break;
+
+                    case CREEPER:
+                        shakeFromCreeper.add(e);
+                        break;
+
+                    case ENDERMAN:
+                        shakeFromEnderman.add(e);
+                        break;
+
+                    case GHAST:
+                        shakeFromGhast.add(e);
+                        break;
+
+                    case IRON_GOLEM:
+                        shakeFromIronGolem.add(e);
+                        break;
+
+                    case MAGMA_CUBE:
+                        shakeFromMagmaCube.add(e);
+                        break;
+
+                    case MUSHROOM_COW:
+                        shakeFromMushroomCow.add(e);
+                        break;
+
+                    case PIG:
+                        shakeFromPig.add(e);
+                        break;
+
+                    case PIG_ZOMBIE:
+                        shakeFromPigZombie.add(e);
+                        break;
+
+                    case SHEEP:
+                        shakeFromSheep.add(e);
+                        break;
+
+                    case SKELETON:
+                        shakeFromSkeleton.add(e);
+                        break;
+
+                    case SLIME:
+                        shakeFromSlime.add(e);
+                        break;
+
+                    case SPIDER:
+                        shakeFromSpider.add(e);
+                        break;
+
+                    case SNOWMAN:
+                        shakeFromSnowman.add(e);
+                        break;
+
+                    case SQUID:
+                        shakeFromSquid.add(e);
+                        break;
+
+                    case WITCH:
+                        shakeFromWitch.add(e);
+                        break;
+
+                    case ZOMBIE:
+                        shakeFromZombie.add(e);
+                        break;
+
+                    default:
+                        break;
+                }
+            }
             else if (treasure instanceof HylianTreasure) {
                 if (hylianTreasures == null || !hylianTreasures.contains(treasureKey)) {
                     continue;
@@ -280,13 +442,10 @@ public class TreasureConfig extends ConfigLoader {
     }
 
     private boolean noErrorsInTreasure(List<String> issues) {
-        if (issues.isEmpty()) {
-            return true;
-        }
-
         for (String issue : issues) {
             plugin.getLogger().warning(issue);
         }
-        return false;
+
+        return issues.isEmpty();
     }
 }

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

@@ -1,643 +1,79 @@
 package com.gmail.nossr50.database;
 
-import java.sql.Connection;
-import java.sql.DriverManager;
-import java.sql.PreparedStatement;
-import java.sql.ResultSet;
-import java.sql.SQLException;
-import java.util.ArrayList;
-import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
-import java.util.Properties;
 
-
-import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.config.Config;
-import com.gmail.nossr50.datatypes.database.DatabaseUpdateType;
-import com.gmail.nossr50.datatypes.skills.SkillType;
-import com.gmail.nossr50.runnables.database.SQLReconnectTask;
-import com.gmail.nossr50.util.Misc;
+import com.gmail.nossr50.datatypes.database.PlayerStat;
+import com.gmail.nossr50.datatypes.player.PlayerProfile;
 
-public final class DatabaseManager {
-    private static String connectionString;
-
-    private static String tablePrefix = Config.getInstance().getMySQLTablePrefix();
-    private static Connection connection = null;
-
-    // Scale waiting time by this much per failed attempt
-    private static final double SCALING_FACTOR = 40;
-
-    // Minimum wait in nanoseconds (default 500ms)
-    private static final long MIN_WAIT = 500L * 1000000L;
-
-    // Maximum time to wait between reconnects (default 5 minutes)
-    private static final long MAX_WAIT = 5L * 60L * 1000L * 1000000L;
-
-    // How long to wait when checking if connection is valid (default 3 seconds)
-    private static final int VALID_TIMEOUT = 3;
-
-    // When next to try connecting to Database in nanoseconds
-    private static long nextReconnectTimestamp = 0L;
-
-    // How many connection attempts have failed
-    private static int reconnectAttempt = 0;
-
-    private static final long ONE_MONTH = 2630000000L;
-
-    private DatabaseManager() {}
+public interface DatabaseManager {
+    public final long PURGE_TIME = 2630000000L * Config.getInstance().getOldUsersCutoff();
 
     /**
-     * Attempt to connect to the mySQL database.
+     * Purge users with 0 power level from the database.
      */
-    public static void connect() {
-        Config configInstance = Config.getInstance();
-        connectionString = "jdbc:mysql://" + configInstance.getMySQLServerName() + ":" + configInstance.getMySQLServerPort() + "/" + configInstance.getMySQLDatabaseName();
-
-        try {
-            mcMMO.p.getLogger().info("Attempting connection to MySQL...");
-
-            // Force driver to load if not yet loaded
-            Class.forName("com.mysql.jdbc.Driver");
-            Properties connectionProperties = new Properties();
-            connectionProperties.put("user", configInstance.getMySQLUserName());
-            connectionProperties.put("password", configInstance.getMySQLUserPassword());
-            connectionProperties.put("autoReconnect", "false");
-            connectionProperties.put("maxReconnects", "0");
-            connection = DriverManager.getConnection(connectionString, connectionProperties);
-
-            mcMMO.p.getLogger().info("Connection to MySQL was a success!");
-        }
-        catch (SQLException ex) {
-            connection = null;
-
-            if (reconnectAttempt == 0 || reconnectAttempt >= 11) {
-                mcMMO.p.getLogger().info("Connection to MySQL failed!");
-            }
-        }
-        catch (ClassNotFoundException ex) {
-            connection = null;
-
-            if (reconnectAttempt == 0 || reconnectAttempt >= 11) {
-                mcMMO.p.getLogger().info("MySQL database driver not found!");
-            }
-        }
-    }
+    public void purgePowerlessUsers();
 
     /**
-     * Attempt to create the database structure.
+     * Purge users who haven't logged on in over a certain time frame from the database.
      */
-    public static void createStructure() {
-        write("CREATE TABLE IF NOT EXISTS `" + tablePrefix + "users` ("
-                + "`id` int(10) unsigned NOT NULL AUTO_INCREMENT,"
-                + "`user` varchar(40) NOT NULL,"
-                + "`lastlogin` int(32) unsigned NOT NULL,"
-                + "PRIMARY KEY (`id`),"
-                + "UNIQUE KEY `user` (`user`)) ENGINE=MyISAM  DEFAULT CHARSET=latin1 AUTO_INCREMENT=1;");
-        write("CREATE TABLE IF NOT EXISTS `" + tablePrefix + "huds` ("
-                + "`user_id` int(10) unsigned NOT NULL,"
-                + "`hudtype` varchar(50) NOT NULL DEFAULT 'STANDARD',"
-                + "PRIMARY KEY (`user_id`),"
-                + "FOREIGN KEY (`user_id`) REFERENCES `" + tablePrefix + "users` (`id`) "
-                + "ON DELETE CASCADE) ENGINE=MyISAM DEFAULT CHARSET=latin1;");
-        write("CREATE TABLE IF NOT EXISTS `" + tablePrefix + "cooldowns` ("
-                + "`user_id` int(10) unsigned NOT NULL,"
-                + "`taming` int(32) unsigned NOT NULL DEFAULT '0',"
-                + "`mining` int(32) unsigned NOT NULL DEFAULT '0',"
-                + "`woodcutting` int(32) unsigned NOT NULL DEFAULT '0',"
-                + "`repair` int(32) unsigned NOT NULL DEFAULT '0',"
-                + "`unarmed` int(32) unsigned NOT NULL DEFAULT '0',"
-                + "`herbalism` int(32) unsigned NOT NULL DEFAULT '0',"
-                + "`excavation` int(32) unsigned NOT NULL DEFAULT '0',"
-                + "`archery` int(32) unsigned NOT NULL DEFAULT '0',"
-                + "`swords` int(32) unsigned NOT NULL DEFAULT '0',"
-                + "`axes` int(32) unsigned NOT NULL DEFAULT '0',"
-                + "`acrobatics` int(32) unsigned NOT NULL DEFAULT '0',"
-                + "`blast_mining` int(32) unsigned NOT NULL DEFAULT '0',"
-                + "PRIMARY KEY (`user_id`),"
-                + "FOREIGN KEY (`user_id`) REFERENCES `" + tablePrefix + "users` (`id`) "
-                + "ON DELETE CASCADE) ENGINE=MyISAM DEFAULT CHARSET=latin1;");
-        write("CREATE TABLE IF NOT EXISTS `" + tablePrefix + "skills` ("
-                + "`user_id` int(10) unsigned NOT NULL,"
-                + "`taming` int(10) unsigned NOT NULL DEFAULT '0',"
-                + "`mining` int(10) unsigned NOT NULL DEFAULT '0',"
-                + "`woodcutting` int(10) unsigned NOT NULL DEFAULT '0',"
-                + "`repair` int(10) unsigned NOT NULL DEFAULT '0',"
-                + "`unarmed` int(10) unsigned NOT NULL DEFAULT '0',"
-                + "`herbalism` int(10) unsigned NOT NULL DEFAULT '0',"
-                + "`excavation` int(10) unsigned NOT NULL DEFAULT '0',"
-                + "`archery` int(10) unsigned NOT NULL DEFAULT '0',"
-                + "`swords` int(10) unsigned NOT NULL DEFAULT '0',"
-                + "`axes` int(10) unsigned NOT NULL DEFAULT '0',"
-                + "`acrobatics` int(10) unsigned NOT NULL DEFAULT '0',"
-                + "PRIMARY KEY (`user_id`),"
-                + "FOREIGN KEY (`user_id`) REFERENCES `" + tablePrefix + "users` (`id`) "
-                + "ON DELETE CASCADE) ENGINE=MyISAM DEFAULT CHARSET=latin1;");
-        write("CREATE TABLE IF NOT EXISTS `" + tablePrefix + "experience` ("
-                + "`user_id` int(10) unsigned NOT NULL,"
-                + "`taming` int(10) unsigned NOT NULL DEFAULT '0',"
-                + "`mining` int(10) unsigned NOT NULL DEFAULT '0',"
-                + "`woodcutting` int(10) unsigned NOT NULL DEFAULT '0',"
-                + "`repair` int(10) unsigned NOT NULL DEFAULT '0',"
-                + "`unarmed` int(10) unsigned NOT NULL DEFAULT '0',"
-                + "`herbalism` int(10) unsigned NOT NULL DEFAULT '0',"
-                + "`excavation` int(10) unsigned NOT NULL DEFAULT '0',"
-                + "`archery` int(10) unsigned NOT NULL DEFAULT '0',"
-                + "`swords` int(10) unsigned NOT NULL DEFAULT '0',"
-                + "`axes` int(10) unsigned NOT NULL DEFAULT '0',"
-                + "`acrobatics` int(10) unsigned NOT NULL DEFAULT '0',"
-                + "PRIMARY KEY (`user_id`),"
-                + "FOREIGN KEY (`user_id`) REFERENCES `" + tablePrefix + "users` (`id`) "
-                + "ON DELETE CASCADE) ENGINE=MyISAM DEFAULT CHARSET=latin1;");
-
-        checkDatabaseStructure(DatabaseUpdateType.FISHING);
-        checkDatabaseStructure(DatabaseUpdateType.BLAST_MINING);
-        checkDatabaseStructure(DatabaseUpdateType.CASCADE_DELETE);
-        checkDatabaseStructure(DatabaseUpdateType.INDEX);
-    }
+    public void purgeOldUsers();
 
     /**
-     * Attempt to write the SQL query.
+     * Remove a user from the database.
      *
-     * @param sql Query to write.
-     * @return true if the query was successfully written, false otherwise.
+     * @param playerName The name of the user to remove
+     * @return true if the user was successfully removed, false otherwise
      */
-    public static boolean write(String sql) {
-        if (!checkConnected()) {
-            return false;
-        }
-
-        PreparedStatement statement = null;
-        try {
-            statement = connection.prepareStatement(sql);
-            statement.executeUpdate();
-            return true;
-        }
-        catch (SQLException ex) {
-            printErrors(ex);
-            return false;
-        }
-        finally {
-            if (statement != null) {
-                try {
-                    statement.close();
-                }
-                catch (SQLException e) {
-                    printErrors(e);
-                    return false;
-                }
-            }
-        }
-    }
+    public boolean removeUser(String playerName);
 
     /**
-     * Returns the number of rows affected by either a DELETE or UPDATE query
+     * Save a user to the database.
      *
-     * @param sql SQL query to execute
-     * @return the number of rows affected
+     * @param profile The profile of the player to save
      */
-    public static int update(String sql) {
-        int ret = 0;
-
-        if (checkConnected()) {
-            PreparedStatement statement = null;
-            try {
-                statement = connection.prepareStatement(sql);
-                ret = statement.executeUpdate();
-            }
-            catch (SQLException ex) {
-                printErrors(ex);
-            }
-            finally {
-                if (statement != null) {
-                    try {
-                        statement.close();
-                    }
-                    catch (SQLException e) {
-                        printErrors(e);
-                    }
-                }
-            }
-        }
-
-        return ret;
-    }
+    public void saveUser(PlayerProfile profile);
 
     /**
-     * Get the Integer. Only return first row / first field.
-     *
-     * @param sql SQL query to execute
-     * @return the value in the first row / first field
-     */
-    public static int getInt(String sql) {
-        ResultSet resultSet = null;
-        int result = 0;
-
-        if (checkConnected()) {
-            PreparedStatement statement = null;
-
-            try {
-                statement = connection.prepareStatement(sql);
-                resultSet = statement.executeQuery();
-
-                if (resultSet.next()) {
-                    result = resultSet.getInt(1);
-                }
-                else {
-                    result = 0;
-                }
-            }
-            catch (SQLException ex) {
-                printErrors(ex);
-            }
-            finally {
-                if (statement != null) {
-                    try {
-                        statement.close();
-                    }
-                    catch (SQLException e) {
-                        printErrors(e);
-                    }
-                }
-            }
-        }
-
-        return result;
-    }
+    * Retrieve leaderboard info.
+    *
+    * @param skillName The skill to retrieve info on
+    * @param pageNumber Which page in the leaderboards to retrieve
+    * @param statsPerPage The number of stats per page
+    * @return the requested leaderboard information
+    */
+    public List<PlayerStat> readLeaderboard(String skillName, int pageNumber, int statsPerPage);
 
     /**
-     * Check connection status and re-establish if dead or stale.
+     * Retrieve rank info.
      *
-     * If the very first immediate attempt fails, further attempts
-     * will be made in progressively larger intervals up to MAX_WAIT
-     * intervals.
-     *
-     * This allows for MySQL to time out idle connections as needed by
-     * server operator, without affecting McMMO, while still providing
-     * protection against a database outage taking down Bukkit's tick
-     * processing loop due to attemping a database connection each
-     * time McMMO needs the database.
-     *
-     * @return the boolean value for whether or not we are connected
+     * @param playerName The name of the user to retrieve the rankings for
+     * @return the requested rank information
      */
-    public static boolean checkConnected() {
-        boolean isClosed = true;
-        boolean isValid = false;
-        boolean exists = (connection != null);
-
-        // If we're waiting for server to recover then leave early
-        if (nextReconnectTimestamp > 0 && nextReconnectTimestamp > System.nanoTime()) {
-            return false;
-        }
-
-        if (exists) {
-            try {
-                isClosed = connection.isClosed();
-            }
-            catch (SQLException e) {
-                isClosed = true;
-                e.printStackTrace();
-                printErrors(e);
-            }
-
-            if (!isClosed) {
-                try {
-                    isValid = connection.isValid(VALID_TIMEOUT);
-                }
-                catch (SQLException e) {
-                    // Don't print stack trace because it's valid to lose idle connections to the server and have to restart them.
-                    isValid = false;
-                }
-            }
-        }
-
-        // Leave if all ok
-        if (exists && !isClosed && isValid) {
-            // Housekeeping
-            nextReconnectTimestamp = 0;
-            reconnectAttempt = 0;
-            return true;
-        }
-
-        // Cleanup after ourselves for GC and MySQL's sake
-        if (exists && !isClosed) {
-            try {
-                connection.close();
-            }
-            catch (SQLException ex) {
-                // This is a housekeeping exercise, ignore errors
-            }
-        }
-
-        // Try to connect again
-        connect();
-
-        // Leave if connection is good
-        try {
-            if (connection != null && !connection.isClosed()) {
-                // Schedule a database save if we really had an outage
-                if (reconnectAttempt > 1) {
-                    new SQLReconnectTask().runTaskLater(mcMMO.p, 5);
-                }
-                nextReconnectTimestamp = 0;
-                reconnectAttempt = 0;
-                return true;
-            }
-        }
-        catch (SQLException e) {
-            // Failed to check isClosed, so presume connection is bad and attempt later
-            e.printStackTrace();
-            printErrors(e);
-        }
-
-        reconnectAttempt++;
-        nextReconnectTimestamp = (long)(System.nanoTime() + Math.min(MAX_WAIT, (reconnectAttempt * SCALING_FACTOR * MIN_WAIT)));
-        return false;
-    }
+    public Map<String, Integer> readRank(String playerName);
 
     /**
-     * Read SQL query.
+     * Add a new user to the database.
      *
-     * @param sql SQL query to read
-     * @return the rows in this SQL query
+     * @param playerName The name of the player to be added to the database
      */
-    public static HashMap<Integer, ArrayList<String>> read(String sql) {
-        ResultSet resultSet;
-        HashMap<Integer, ArrayList<String>> rows = new HashMap<Integer, ArrayList<String>>();
-
-        if (checkConnected()) {
-            PreparedStatement statement = null;
-
-            try {
-                statement = connection.prepareStatement(sql);
-                resultSet = statement.executeQuery();
-
-                while (resultSet.next()) {
-                    ArrayList<String> column = new ArrayList<String>();
-
-                    for (int i = 1; i <= resultSet.getMetaData().getColumnCount(); i++) {
-                        column.add(resultSet.getString(i));
-                    }
-
-                    rows.put(resultSet.getRow(), column);
-                }
-            }
-            catch (SQLException ex) {
-                printErrors(ex);
-            }
-            finally {
-                if (statement != null) {
-                    try {
-                        statement.close();
-                    }
-                    catch (SQLException e) {
-                        printErrors(e);
-                    }
-                }
-            }
-        }
-
-        return rows;
-    }
-
-    public static Map<String, Integer> readSQLRank(String playerName) {
-        ResultSet resultSet;
-        Map<String, Integer> skills = new HashMap<String, Integer>();
-
-        if (checkConnected()) {
-            try {
-                for (SkillType skillType : SkillType.values()) {
-                    if (skillType.isChildSkill()) {
-                        continue;
-                    }
-
-                    String skillName = skillType.name().toLowerCase();
-                    String sql = "SELECT COUNT(*) AS rank FROM " + tablePrefix + "users JOIN " + tablePrefix + "skills ON user_id = id WHERE " + skillName + " > 0 " +
-                                 "AND " + skillName + " > (SELECT " + skillName + " FROM " + tablePrefix + "users JOIN " + tablePrefix + "skills ON user_id = id " +
-                                 "WHERE user = ?)";
-
-                    PreparedStatement statement = connection.prepareStatement(sql);
-                    statement.setString(1, playerName);
-                    resultSet = statement.executeQuery();
-
-                    resultSet.next();
-
-                    int rank = resultSet.getInt("rank");
-
-                    sql = "SELECT user, " + skillName + " FROM " + tablePrefix + "users JOIN " + tablePrefix + "skills ON user_id = id WHERE " + skillName + " > 0 " +
-                          "AND " + skillName + " = (SELECT " + skillName + " FROM " + tablePrefix + "users JOIN " + tablePrefix + "skills ON user_id = id " +
-                          "WHERE user = '" + playerName + "') ORDER BY user";
-
-                    statement = connection.prepareStatement(sql);
-                    resultSet = statement.executeQuery();
-
-                    while (resultSet.next()) {
-                        if (resultSet.getString("user").equalsIgnoreCase(playerName)) {
-                            skills.put(skillType.name(), rank + resultSet.getRow());
-                            break;
-                        }
-                    }
-
-                    statement.close();
-                }
-
-                String sql = "SELECT COUNT(*) AS rank FROM " + tablePrefix + "users JOIN " + tablePrefix + "skills ON user_id = id " +
-                             "WHERE taming+mining+woodcutting+repair+unarmed+herbalism+excavation+archery+swords+axes+acrobatics+fishing > 0 " +
-                             "AND taming+mining+woodcutting+repair+unarmed+herbalism+excavation+archery+swords+axes+acrobatics+fishing > " +
-                             "(SELECT taming+mining+woodcutting+repair+unarmed+herbalism+excavation+archery+swords+axes+acrobatics+fishing " +
-                             "FROM " + tablePrefix + "users JOIN " + tablePrefix + "skills ON user_id = id WHERE user = ?)";
-
-                PreparedStatement statement = connection.prepareStatement(sql);
-                statement.setString(1, playerName);
-                resultSet = statement.executeQuery();
-
-                resultSet.next();
-
-                int rank = resultSet.getInt("rank");
-
-                sql = "SELECT user, taming+mining+woodcutting+repair+unarmed+herbalism+excavation+archery+swords+axes+acrobatics+fishing " +
-                      "FROM " + tablePrefix + "users JOIN " + tablePrefix + "skills ON user_id = id " +
-                      "WHERE taming+mining+woodcutting+repair+unarmed+herbalism+excavation+archery+swords+axes+acrobatics+fishing > 0 " +
-                      "AND taming+mining+woodcutting+repair+unarmed+herbalism+excavation+archery+swords+axes+acrobatics+fishing = " +
-                      "(SELECT taming+mining+woodcutting+repair+unarmed+herbalism+excavation+archery+swords+axes+acrobatics+fishing " +
-                      "FROM " + tablePrefix + "users JOIN " + tablePrefix + "skills ON user_id = id WHERE user = ?) ORDER BY user";
-
-                statement = connection.prepareStatement(sql);
-                statement.setString(1, playerName);
-                resultSet = statement.executeQuery();
-
-                while (resultSet.next()) {
-                    if (resultSet.getString("user").equalsIgnoreCase(playerName)) {
-                        skills.put("ALL", rank + resultSet.getRow());
-                        break;
-                    }
-                }
-
-                statement.close();
-            }
-            catch (SQLException ex) {
-                printErrors(ex);
-            }
-        }
-
-        return skills;
-    }
-
-    public static void purgePowerlessSQL() {
-        mcMMO.p.getLogger().info("Purging powerless users...");
-        HashMap<Integer, ArrayList<String>> usernames;
-
-        usernames = read("SELECT u.user FROM " + tablePrefix + "skills AS s, " + tablePrefix + "users AS u " + "WHERE s.user_id = u.id AND " +
-                "(s.taming+s.mining+s.woodcutting+s.repair+s.unarmed+s.herbalism+s.excavation+s.archery+s.swords+s.axes+s.acrobatics+s.fishing) = 0");
-
-        write("DELETE FROM " + tablePrefix + "users WHERE " + tablePrefix + "users.id IN (SELECT * FROM " +
-                "(SELECT u.id FROM " + tablePrefix + "skills AS s, " + tablePrefix + "users AS u " + "WHERE s.user_id = u.id " +
-                "AND (s.taming+s.mining+s.woodcutting+s.repair+s.unarmed+s.herbalism+s.excavation+s.archery+s.swords+s.axes+s.acrobatics+s.fishing) = 0) AS p)");
-
-        int purgedUsers = 0;
-        for (int i = 1; i <= usernames.size(); i++) {
-            String playerName = usernames.get(i).get(0);
-
-            if (playerName == null || mcMMO.p.getServer().getOfflinePlayer(playerName).isOnline()) {
-                continue;
-            }
-
-            Misc.profileCleanup(playerName);
-            purgedUsers++;
-        }
-
-        mcMMO.p.getLogger().info("Purged " + purgedUsers + " users from the database.");
-    }
-
-    public static void purgeOldSQL() {
-        mcMMO.p.getLogger().info("Purging old users...");
-        long currentTime = System.currentTimeMillis();
-        long purgeTime = ONE_MONTH * Config.getInstance().getOldUsersCutoff();
-        HashMap<Integer, ArrayList<String>> usernames = read("SELECT user FROM " + tablePrefix + "users WHERE ((" + currentTime + " - lastlogin*1000) > " + purgeTime + ")");
-        write("DELETE FROM " + tablePrefix + "users WHERE " + tablePrefix + "users.id IN (SELECT * FROM (SELECT id FROM " + tablePrefix + "users WHERE ((" + currentTime + " - lastlogin*1000) > " + purgeTime + ")) AS p)");
-
-        int purgedUsers = 0;
-        for (int i = 1; i <= usernames.size(); i++) {
-            String playerName = usernames.get(i).get(0);
-
-            if (playerName == null) {
-                continue;
-            }
-
-            Misc.profileCleanup(playerName);
-            purgedUsers++;
-        }
-
-        mcMMO.p.getLogger().info("Purged " + purgedUsers + " users from the database.");
-    }
+    public void newUser(String playerName);
 
     /**
-     * Check database structure for missing values.
+     * Load a player from the database.
      *
-     * @param update Type of data to check updates for
+     * @param playerName The name of the player to load from the database
+     * @return The player's data
      */
-    private static void checkDatabaseStructure(DatabaseUpdateType update) {
-        String sql = null;
-        ResultSet resultSet = null;
-        HashMap<Integer, ArrayList<String>> rows = new HashMap<Integer, ArrayList<String>>();
+    public List<String> loadPlayerData(String playerName);
 
-        switch (update) {
-            case BLAST_MINING:
-                sql = "SELECT * FROM  `" + tablePrefix + "cooldowns` ORDER BY  `" + tablePrefix + "cooldowns`.`blast_mining` ASC LIMIT 0 , 30";
-                break;
-
-            case CASCADE_DELETE:
-                write("ALTER TABLE `" + tablePrefix + "huds` ADD FOREIGN KEY (`user_id`) REFERENCES `users`(`id`) ON DELETE CASCADE;");
-                write("ALTER TABLE `" + tablePrefix + "experience` ADD FOREIGN KEY (`user_id`) REFERENCES `users`(`id`) ON DELETE CASCADE;");
-                write("ALTER TABLE `" + tablePrefix + "cooldowns` ADD FOREIGN KEY (`user_id`) REFERENCES `users`(`id`) ON DELETE CASCADE;");
-                write("ALTER TABLE `" + tablePrefix + "skills` ADD FOREIGN KEY (`user_id`) REFERENCES `users`(`id`) ON DELETE CASCADE;");
-                break;
-
-            case FISHING:
-                sql = "SELECT * FROM  `" + tablePrefix + "experience` ORDER BY  `" + tablePrefix + "experience`.`fishing` ASC LIMIT 0 , 30";
-                break;
-
-            case INDEX:
-                if (read("SHOW INDEX FROM " + tablePrefix + "skills").size() != 13 && checkConnected()) {
-                    mcMMO.p.getLogger().info("Indexing tables, this may take a while on larger databases");
-                    write("ALTER TABLE `" + tablePrefix + "skills` ADD INDEX `idx_taming` (`taming`) USING BTREE, "
-                            + "ADD INDEX `idx_mining` (`mining`) USING BTREE, "
-                            + "ADD INDEX `idx_woodcutting` (`woodcutting`) USING BTREE, "
-                            + "ADD INDEX `idx_repair` (`repair`) USING BTREE, "
-                            + "ADD INDEX `idx_unarmed` (`unarmed`) USING BTREE, "
-                            + "ADD INDEX `idx_herbalism` (`herbalism`) USING BTREE, "
-                            + "ADD INDEX `idx_excavation` (`excavation`) USING BTREE, "
-                            + "ADD INDEX `idx_archery` (`archery`) USING BTREE, "
-                            + "ADD INDEX `idx_swords` (`swords`) USING BTREE, "
-                            + "ADD INDEX `idx_axes` (`axes`) USING BTREE, "
-                            + "ADD INDEX `idx_acrobatics` (`acrobatics`) USING BTREE, "
-                            + "ADD INDEX `idx_fishing` (`fishing`) USING BTREE;");
-                }
-                break;
-
-            default:
-                break;
-        }
-
-        PreparedStatement statement = null;
-        try {
-            if (!checkConnected()) {
-                return;
-            }
-
-            statement = connection.prepareStatement(sql);
-            resultSet = statement.executeQuery();
-
-            while (resultSet.next()) {
-                ArrayList<String> column = new ArrayList<String>();
-
-                for (int i = 1; i <= resultSet.getMetaData().getColumnCount(); i++) {
-                    column.add(resultSet.getString(i));
-                }
-
-                rows.put(resultSet.getRow(), column);
-            }
-        }
-        catch (SQLException ex) {
-            switch (update) {
-                case BLAST_MINING:
-                    mcMMO.p.getLogger().info("Updating mcMMO MySQL tables for Blast Mining...");
-                    write("ALTER TABLE `"+tablePrefix + "cooldowns` ADD `blast_mining` int(32) NOT NULL DEFAULT '0' ;");
-                    break;
-
-                case FISHING:
-                    mcMMO.p.getLogger().info("Updating mcMMO MySQL tables for Fishing...");
-                    write("ALTER TABLE `"+tablePrefix + "skills` ADD `fishing` int(10) NOT NULL DEFAULT '0' ;");
-                    write("ALTER TABLE `"+tablePrefix + "experience` ADD `fishing` int(10) NOT NULL DEFAULT '0' ;");
-                    break;
-
-                default:
-                    break;
-            }
-        }
-        finally {
-            if (resultSet != null) {
-                try {
-                    resultSet.close();
-                }
-                catch (SQLException e) {
-                    // Ignore the error, we're leaving
-                }
-            }
-
-            if (statement != null) {
-                try {
-                    statement.close();
-                }
-                catch (SQLException e) {
-                    // Ignore the error, we're leaving
-                }
-            }
-        }
-    }
-
-    private static void printErrors(SQLException ex) {
-        mcMMO.p.getLogger().severe("SQLException: " + ex.getMessage());
-        mcMMO.p.getLogger().severe("SQLState: " + ex.getSQLState());
-        mcMMO.p.getLogger().severe("VendorError: " + ex.getErrorCode());
-    }
+    /**
+     * Convert player data to a different storage format.
+     *
+     * @param data The player's data
+     * @return true if the conversion was successful, false otherwise
+     * @throws Exception
+     */
+    public boolean convert(String[] data) throws Exception;
 }

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

@@ -0,0 +1,9 @@
+package com.gmail.nossr50.database;
+
+import com.gmail.nossr50.config.Config;
+
+public class DatabaseManagerFactory {
+    public static DatabaseManager getDatabaseManager() {
+        return Config.getInstance().getUseMySQL() ? new SQLDatabaseManager() : new FlatfileDatabaseManager();
+    }
+}

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

@@ -0,0 +1,525 @@
+package com.gmail.nossr50.database;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.bukkit.OfflinePlayer;
+
+import com.gmail.nossr50.mcMMO;
+import com.gmail.nossr50.config.Config;
+import com.gmail.nossr50.datatypes.MobHealthbarType;
+import com.gmail.nossr50.datatypes.database.PlayerStat;
+import com.gmail.nossr50.datatypes.player.PlayerProfile;
+import com.gmail.nossr50.datatypes.skills.AbilityType;
+import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.datatypes.spout.huds.HudType;
+import com.gmail.nossr50.util.Misc;
+
+public final class FlatfileDatabaseManager implements DatabaseManager {
+    private final HashMap<SkillType, List<PlayerStat>> playerStatHash = new HashMap<SkillType, List<PlayerStat>>();
+    private final List<PlayerStat> powerLevels = new ArrayList<PlayerStat>();
+    private long lastUpdate = 0;
+
+    private final long UPDATE_WAIT_TIME = 600000L; // 10 minutes
+    private final File usersFile;
+
+    protected FlatfileDatabaseManager() {
+        usersFile = new File(mcMMO.getUsersFilePath());
+        createDatabase();
+        updateLeaderboards();
+    }
+
+    public void purgePowerlessUsers() {
+        int purgedUsers = 0;
+
+        mcMMO.p.getLogger().info("Purging powerless users...");
+
+        for (PlayerStat stat : powerLevels) {
+            if (stat.statVal == 0 && mcMMO.p.getServer().getPlayerExact(stat.name) == null && removeUser(stat.name)) {
+                purgedUsers++;
+            }
+        }
+
+        mcMMO.p.getLogger().info("Purged " + purgedUsers + " users from the database.");
+    }
+
+    public void purgeOldUsers() {
+        int removedPlayers = 0;
+        long currentTime = System.currentTimeMillis();
+
+        mcMMO.p.getLogger().info("Purging old users...");
+
+        for (OfflinePlayer player : mcMMO.p.getServer().getOfflinePlayers()) {
+            if (!player.isOnline() && (currentTime - player.getLastPlayed() > PURGE_TIME && removeUser(player.getName()))) {
+                removedPlayers++;
+            }
+        }
+
+        mcMMO.p.getLogger().info("Purged " + removedPlayers + " users from the database.");
+    }
+
+    public boolean removeUser(String playerName) {
+        boolean worked = false;
+
+        BufferedReader in = null;
+        FileWriter out = null;
+        String usersFilePath = mcMMO.getUsersFilePath();
+
+        try {
+            in = new BufferedReader(new FileReader(usersFilePath));
+            StringBuilder writer = new StringBuilder();
+            String line = "";
+
+            while ((line = in.readLine()) != null) {
+                // Write out the same file but when we get to the player we want to remove, we skip his line.
+                if (!worked && line.split(":")[0].equalsIgnoreCase(playerName)) {
+                    mcMMO.p.getLogger().info("User found, removing...");
+                    worked = true;
+                    continue; // Skip the player
+                }
+
+                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 ex) {
+                    ex.printStackTrace();
+                }
+            }
+
+            if (out != null) {
+                try {
+                    out.close();
+                }
+                catch (IOException ex) {
+                    ex.printStackTrace();
+                }
+            }
+        }
+
+        Misc.profileCleanup(playerName);
+
+        return worked;
+    }
+
+    public void saveUser(PlayerProfile profile) {
+        String playerName = profile.getPlayerName();
+
+        BufferedReader in = null;
+        FileWriter out = null;
+        String usersFilePath = mcMMO.getUsersFilePath();
+
+        try {
+            // Open the file
+            in = new BufferedReader(new FileReader(usersFilePath));
+            StringBuilder writer = new StringBuilder();
+            String line;
+
+            // 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)) {
+                    writer.append(line).append("\r\n");
+                }
+                else {
+                    // Otherwise write the new player information
+                    writer.append(playerName).append(":");
+                    writer.append(profile.getSkillLevel(SkillType.MINING)).append(":");
+                    writer.append(":");
+                    writer.append(":");
+                    writer.append(profile.getSkillXpLevel(SkillType.MINING)).append(":");
+                    writer.append(profile.getSkillLevel(SkillType.WOODCUTTING)).append(":");
+                    writer.append(profile.getSkillXpLevel(SkillType.WOODCUTTING)).append(":");
+                    writer.append(profile.getSkillLevel(SkillType.REPAIR)).append(":");
+                    writer.append(profile.getSkillLevel(SkillType.UNARMED)).append(":");
+                    writer.append(profile.getSkillLevel(SkillType.HERBALISM)).append(":");
+                    writer.append(profile.getSkillLevel(SkillType.EXCAVATION)).append(":");
+                    writer.append(profile.getSkillLevel(SkillType.ARCHERY)).append(":");
+                    writer.append(profile.getSkillLevel(SkillType.SWORDS)).append(":");
+                    writer.append(profile.getSkillLevel(SkillType.AXES)).append(":");
+                    writer.append(profile.getSkillLevel(SkillType.ACROBATICS)).append(":");
+                    writer.append(profile.getSkillXpLevel(SkillType.REPAIR)).append(":");
+                    writer.append(profile.getSkillXpLevel(SkillType.UNARMED)).append(":");
+                    writer.append(profile.getSkillXpLevel(SkillType.HERBALISM)).append(":");
+                    writer.append(profile.getSkillXpLevel(SkillType.EXCAVATION)).append(":");
+                    writer.append(profile.getSkillXpLevel(SkillType.ARCHERY)).append(":");
+                    writer.append(profile.getSkillXpLevel(SkillType.SWORDS)).append(":");
+                    writer.append(profile.getSkillXpLevel(SkillType.AXES)).append(":");
+                    writer.append(profile.getSkillXpLevel(SkillType.ACROBATICS)).append(":");
+                    writer.append(":");
+                    writer.append(profile.getSkillLevel(SkillType.TAMING)).append(":");
+                    writer.append(profile.getSkillXpLevel(SkillType.TAMING)).append(":");
+                    writer.append((int) profile.getSkillDATS(AbilityType.BERSERK)).append(":");
+                    writer.append((int) profile.getSkillDATS(AbilityType.GIGA_DRILL_BREAKER)).append(":");
+                    writer.append((int) profile.getSkillDATS(AbilityType.TREE_FELLER)).append(":");
+                    writer.append((int) profile.getSkillDATS(AbilityType.GREEN_TERRA)).append(":");
+                    writer.append((int) profile.getSkillDATS(AbilityType.SERRATED_STRIKES)).append(":");
+                    writer.append((int) profile.getSkillDATS(AbilityType.SKULL_SPLITTER)).append(":");
+                    writer.append((int) profile.getSkillDATS(AbilityType.SUPER_BREAKER)).append(":");
+                    HudType hudType = profile.getHudType();
+                    writer.append(hudType == null ? "STANDARD" : hudType.toString()).append(":");
+                    writer.append(profile.getSkillLevel(SkillType.FISHING)).append(":");
+                    writer.append(profile.getSkillXpLevel(SkillType.FISHING)).append(":");
+                    writer.append((int) profile.getSkillDATS(AbilityType.BLAST_MINING)).append(":");
+                    writer.append(System.currentTimeMillis() / Misc.TIME_CONVERSION_FACTOR).append(":");
+                    MobHealthbarType mobHealthbarType = profile.getMobHealthbarType();
+                    writer.append(mobHealthbarType == null ? Config.getInstance().getMobHealthbarDefault().toString() : mobHealthbarType.toString()).append(":");
+                    writer.append("\r\n");
+                }
+            }
+
+            // Write the new file
+            out = new FileWriter(usersFilePath);
+            out.write(writer.toString());
+        }
+        catch (Exception e) {
+            e.printStackTrace();
+        }
+        finally {
+            if (in != null) {
+                try {
+                    in.close();
+                }
+                catch (IOException ex) {
+                    ex.printStackTrace();
+                }
+            }
+
+            if (out != null) {
+                try {
+                    out.close();
+                }
+                catch (IOException ex) {
+                    ex.printStackTrace();
+                }
+            }
+        }
+    }
+
+    public List<PlayerStat> readLeaderboard(String skillName, int pageNumber, int statsPerPage) {
+        updateLeaderboards();
+        List<PlayerStat> statsList = skillName.equalsIgnoreCase("all") ? powerLevels : playerStatHash.get(SkillType.getSkill(skillName));
+        int fromIndex = (Math.max(pageNumber, 1) - 1) * statsPerPage;
+
+        return statsList.subList(Math.min(fromIndex, statsList.size()), Math.min(fromIndex + statsPerPage, statsList.size()));
+    }
+
+    public Map<String, Integer> readRank(String playerName) {
+        updateLeaderboards();
+
+        Map<String, Integer> skills = new HashMap<String, Integer>();
+
+        for (SkillType skill : SkillType.nonChildSkills()) {
+            skills.put(skill.name(), getPlayerRank(playerName, playerStatHash.get(skill)));
+        }
+
+        skills.put("ALL", getPlayerRank(playerName, powerLevels));
+
+        return skills;
+    }
+
+    public void newUser(String playerName) {
+        try {
+            // Open the file to write the player
+            BufferedWriter out = new BufferedWriter(new FileWriter(mcMMO.getUsersFilePath(), true));
+
+            // Add the player to the end
+            out.append(playerName).append(":");
+            out.append("0:"); // Mining
+            out.append(":");
+            out.append(":");
+            out.append("0:"); // Xp
+            out.append("0:"); // Woodcutting
+            out.append("0:"); // WoodCuttingXp
+            out.append("0:"); // Repair
+            out.append("0:"); // Unarmed
+            out.append("0:"); // Herbalism
+            out.append("0:"); // Excavation
+            out.append("0:"); // Archery
+            out.append("0:"); // Swords
+            out.append("0:"); // Axes
+            out.append("0:"); // Acrobatics
+            out.append("0:"); // RepairXp
+            out.append("0:"); // UnarmedXp
+            out.append("0:"); // HerbalismXp
+            out.append("0:"); // ExcavationXp
+            out.append("0:"); // ArcheryXp
+            out.append("0:"); // SwordsXp
+            out.append("0:"); // AxesXp
+            out.append("0:"); // AcrobaticsXp
+            out.append(":");
+            out.append("0:"); // Taming
+            out.append("0:"); // TamingXp
+            out.append("0:"); // DATS
+            out.append("0:"); // DATS
+            out.append("0:"); // DATS
+            out.append("0:"); // DATS
+            out.append("0:"); // DATS
+            out.append("0:"); // DATS
+            out.append("0:"); // DATS
+            out.append("STANDARD").append(":"); // HUD
+            out.append("0:"); // Fishing
+            out.append("0:"); // FishingXp
+            out.append("0:"); // Blast Mining
+            out.append(String.valueOf(System.currentTimeMillis() / Misc.TIME_CONVERSION_FACTOR)).append(":"); // LastLogin
+            out.append(Config.getInstance().getMobHealthbarDefault().toString()).append(":"); // Mob Healthbar HUD
+
+            // Add more in the same format as the line above
+
+            out.newLine();
+            out.close();
+        }
+        catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    public List<String> loadPlayerData(String playerName) {
+        List<String> playerData = new ArrayList<String>();
+        try {
+            // Open the user file
+            FileReader file = new FileReader(mcMMO.getUsersFilePath());
+            BufferedReader in = new BufferedReader(file);
+            String line;
+
+            while ((line = in.readLine()) != null) {
+                // Find if the line contains the player we want.
+                String[] character = line.split(":");
+
+                if (!character[0].equalsIgnoreCase(playerName)) {
+                    continue;
+                }
+
+                // Skill levels
+                playerData.add(character[24]); // Taming
+                playerData.add(character[1]); // Mining
+                playerData.add(character[7]); // Repair
+                playerData.add(character[5]); // Woodcutting
+                playerData.add(character[8]); // Unarmed
+                playerData.add(character[9]); // Herbalism
+                playerData.add(character[10]); // Excavation
+                playerData.add(character[11]); // Archery
+                playerData.add(character[12]); // Swords
+                playerData.add(character[13]); // Axes
+                playerData.add(character[14]); // Acrobatics
+                playerData.add(character[34]); // Fishing
+
+                // Experience
+                playerData.add(character[25]); // Taming
+                playerData.add(character[4]); // Mining
+                playerData.add(character[15]); // Repair
+                playerData.add(character[6]); // Woodcutting
+                playerData.add(character[16]); // Unarmed
+                playerData.add(character[17]); // Herbalism
+                playerData.add(character[18]); // Excavation
+                playerData.add(character[19]); // Archery
+                playerData.add(character[20]); // Swords
+                playerData.add(character[21]); // Axes
+                playerData.add(character[22]); // Acrobatics
+                playerData.add(character[35]); // Fishing
+
+                // Cooldowns
+                playerData.add(null); // Taming
+                playerData.add(character[32]); // SuperBreaker
+                playerData.add(null); // Repair
+                playerData.add(character[28]); // Tree Feller
+                playerData.add(character[26]); // Beserk
+                playerData.add(character[29]); // Green Terra
+                playerData.add(character[27]); // Giga Drill Breaker
+                playerData.add(null); // Archery
+                playerData.add(character[30]); // Serrated Strikes
+                playerData.add(character[31]); // Skull Splitter
+                playerData.add(null); // Acrobatics
+                playerData.add(character[36]); // Blast Mining
+
+                playerData.add(character.length > 33 ? character[33] : null); // HudType
+                playerData.add(character.length > 38 ? character[38] : null); // MobHealthBar
+            }
+
+            in.close();
+        }
+        catch (Exception e) {
+            e.printStackTrace();
+        }
+
+        return playerData;
+    }
+
+    public boolean convert(String[] character) throws Exception {
+        // Not implemented
+        return false;
+    }
+
+    public boolean checkConnected() {
+        // Not implemented
+        return false;
+    }
+
+    /**
+* Update the leader boards.
+*/
+    private void updateLeaderboards() {
+        // Only update FFS leaderboards every 10 minutes.. this puts a lot of strain on the server (depending on the size of the database) and should not be done frequently
+        if (System.currentTimeMillis() < lastUpdate + UPDATE_WAIT_TIME) {
+            return;
+        }
+
+        String usersFilePath = mcMMO.getUsersFilePath();
+        lastUpdate = System.currentTimeMillis(); // Log when the last update was run
+        powerLevels.clear(); // Clear old values from the power levels
+
+        // Initialize lists
+        List<PlayerStat> mining = new ArrayList<PlayerStat>();
+        List<PlayerStat> woodcutting = new ArrayList<PlayerStat>();
+        List<PlayerStat> herbalism = new ArrayList<PlayerStat>();
+        List<PlayerStat> excavation = new ArrayList<PlayerStat>();
+        List<PlayerStat> acrobatics = new ArrayList<PlayerStat>();
+        List<PlayerStat> repair = new ArrayList<PlayerStat>();
+        List<PlayerStat> swords = new ArrayList<PlayerStat>();
+        List<PlayerStat> axes = new ArrayList<PlayerStat>();
+        List<PlayerStat> archery = new ArrayList<PlayerStat>();
+        List<PlayerStat> unarmed = new ArrayList<PlayerStat>();
+        List<PlayerStat> taming = new ArrayList<PlayerStat>();
+        List<PlayerStat> fishing = new ArrayList<PlayerStat>();
+
+        // Read from the FlatFile database and fill our arrays with information
+        try {
+            BufferedReader in = new BufferedReader(new FileReader(usersFilePath));
+            String line = "";
+            ArrayList<String> players = new ArrayList<String>();
+
+            while ((line = in.readLine()) != null) {
+                String[] data = line.split(":");
+                String playerName = data[0];
+                int powerLevel = 0;
+
+                // Prevent the same player from being added multiple times (I'd like to note that this shouldn't happen...)
+                if (players.contains(playerName)) {
+                    continue;
+                }
+
+                players.add(playerName);
+
+                powerLevel += loadStat(mining, playerName, data, 1);
+                powerLevel += loadStat(woodcutting, playerName, data, 5);
+                powerLevel += loadStat(repair, playerName, data, 7);
+                powerLevel += loadStat(unarmed, playerName, data, 8);
+                powerLevel += loadStat(herbalism, playerName, data, 9);
+                powerLevel += loadStat(excavation, playerName, data, 10);
+                powerLevel += loadStat(archery, playerName, data, 11);
+                powerLevel += loadStat(swords, playerName, data, 12);
+                powerLevel += loadStat(axes, playerName, data, 13);
+                powerLevel += loadStat(acrobatics, playerName, data, 14);
+                powerLevel += loadStat(taming, playerName, data, 24);
+                powerLevel += loadStat(fishing, playerName, data, 34);
+
+                powerLevels.add(new PlayerStat(playerName, powerLevel));
+            }
+            in.close();
+        }
+        catch (Exception e) {
+            mcMMO.p.getLogger().severe("Exception while reading " + usersFilePath + " (Are you sure you formatted it correctly?)" + e.toString());
+        }
+
+        SkillComparator c = new SkillComparator();
+
+        Collections.sort(mining, c);
+        Collections.sort(woodcutting, c);
+        Collections.sort(repair, c);
+        Collections.sort(unarmed, c);
+        Collections.sort(herbalism, c);
+        Collections.sort(excavation, c);
+        Collections.sort(archery, c);
+        Collections.sort(swords, c);
+        Collections.sort(axes, c);
+        Collections.sort(acrobatics, c);
+        Collections.sort(taming, c);
+        Collections.sort(fishing, c);
+        Collections.sort(powerLevels, c);
+
+        playerStatHash.put(SkillType.MINING, mining);
+        playerStatHash.put(SkillType.WOODCUTTING, woodcutting);
+        playerStatHash.put(SkillType.REPAIR, repair);
+        playerStatHash.put(SkillType.UNARMED, unarmed);
+        playerStatHash.put(SkillType.HERBALISM, herbalism);
+        playerStatHash.put(SkillType.EXCAVATION, excavation);
+        playerStatHash.put(SkillType.ARCHERY, archery);
+        playerStatHash.put(SkillType.SWORDS, swords);
+        playerStatHash.put(SkillType.AXES, axes);
+        playerStatHash.put(SkillType.ACROBATICS, acrobatics);
+        playerStatHash.put(SkillType.TAMING, taming);
+        playerStatHash.put(SkillType.FISHING, fishing);
+    }
+
+    private void createDatabase() {
+        if (usersFile.exists()) {
+            return;
+        }
+
+        usersFile.getParentFile().mkdir();
+
+        try {
+            mcMMO.p.debug("Creating mcmmo.users file...");
+            new File(mcMMO.getUsersFilePath()).createNewFile();
+        }
+        catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private Integer getPlayerRank(String playerName, List<PlayerStat> statsList) {
+        if (statsList == null) {
+            return null;
+        }
+
+        int currentPos = 1;
+
+        for (PlayerStat stat : statsList) {
+            if (stat.name.equalsIgnoreCase(playerName)) {
+                return currentPos;
+            }
+
+            currentPos++;
+        }
+
+        return null;
+    }
+
+    private int loadStat(List<PlayerStat> statList, String playerName, String[] data, int dataIndex) {
+        if (data.length <= dataIndex) {
+            return 0;
+        }
+
+        int statValue = Integer.parseInt(data[dataIndex]);
+        statList.add(new PlayerStat(playerName, statValue));
+
+        return statValue;
+    }
+
+    private class SkillComparator implements Comparator<PlayerStat> {
+        @Override
+        public int compare(PlayerStat o1, PlayerStat o2) {
+            return (o2.statVal - o1.statVal);
+        }
+    }
+}

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

@@ -1,377 +0,0 @@
-package com.gmail.nossr50.database;
-
-import java.io.BufferedReader;
-import java.io.FileReader;
-import java.io.FileWriter;
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.HashMap;
-import java.util.List;
-
-import com.gmail.nossr50.mcMMO;
-import com.gmail.nossr50.config.Config;
-import com.gmail.nossr50.datatypes.database.PlayerStat;
-import com.gmail.nossr50.datatypes.skills.SkillType;
-import com.gmail.nossr50.util.StringUtils;
-
-public final class LeaderboardManager {
-    private static HashMap<SkillType, List<PlayerStat>> playerStatHash = new HashMap<SkillType, List<PlayerStat>>();
-    private static List<PlayerStat> powerLevels = new ArrayList<PlayerStat>();
-    private static long lastUpdate = 0;
-
-    private static final long UPDATE_WAIT_TIME = 600000L; // 10 minutes
-    private static final long ONE_MONTH = 2630000000L;
-
-    private LeaderboardManager() {}
-
-    /**
-     * Update the leader boards.
-     */
-    public static void updateLeaderboards() {
-        // Only update FFS leaderboards every 10 minutes.. this puts a lot of strain on the server (depending on the size of the database) and should not be done frequently
-        if (System.currentTimeMillis() < lastUpdate + UPDATE_WAIT_TIME) {
-            return;
-        }
-
-        lastUpdate = System.currentTimeMillis(); // Log when the last update was run
-        powerLevels.clear(); // Clear old values from the power levels
-
-        // Initialize lists
-        List<PlayerStat> mining      = new ArrayList<PlayerStat>();
-        List<PlayerStat> woodcutting = new ArrayList<PlayerStat>();
-        List<PlayerStat> herbalism   = new ArrayList<PlayerStat>();
-        List<PlayerStat> excavation  = new ArrayList<PlayerStat>();
-        List<PlayerStat> acrobatics  = new ArrayList<PlayerStat>();
-        List<PlayerStat> repair      = new ArrayList<PlayerStat>();
-        List<PlayerStat> swords      = new ArrayList<PlayerStat>();
-        List<PlayerStat> axes        = new ArrayList<PlayerStat>();
-        List<PlayerStat> archery     = new ArrayList<PlayerStat>();
-        List<PlayerStat> unarmed     = new ArrayList<PlayerStat>();
-        List<PlayerStat> taming      = new ArrayList<PlayerStat>();
-        List<PlayerStat> fishing     = new ArrayList<PlayerStat>();
-
-        // Read from the FlatFile database and fill our arrays with information
-        try {
-            FileReader file = new FileReader(mcMMO.getUsersFilePath());
-            BufferedReader in = new BufferedReader(file);
-            String line = "";
-            ArrayList<String> players = new ArrayList<String>();
-
-            while ((line = in.readLine()) != null) {
-                String[] data = line.split(":");
-
-                String playerName = data[0];
-                int powerLevel = 0;
-
-                // Prevent the same player from being added multiple times (I'd like to note that this shouldn't happen...)
-                if (players.contains(playerName)) {
-                    continue;
-                }
-
-                players.add(playerName);
-
-                if (data.length > 1 && StringUtils.isInt(data[1])) {
-                    mining.add(new PlayerStat(playerName, Integer.parseInt(data[1])));
-                    powerLevel += Integer.parseInt(data[1]);
-                }
-
-                if (data.length > 5 && StringUtils.isInt(data[5])) {
-                    woodcutting.add(new PlayerStat(playerName, Integer.parseInt(data[5])));
-                    powerLevel += Integer.parseInt(data[5]);
-                }
-
-                if (data.length > 7 && StringUtils.isInt(data[7])) {
-                    repair.add(new PlayerStat(playerName, Integer.parseInt(data[7])));
-                    powerLevel += Integer.parseInt(data[7]);
-                }
-
-                if (data.length > 8 && StringUtils.isInt(data[8])) {
-                    unarmed.add(new PlayerStat(playerName, Integer.parseInt(data[8])));
-                    powerLevel += Integer.parseInt(data[8]);
-                }
-
-                if (data.length > 9 && StringUtils.isInt(data[9])) {
-                    herbalism.add(new PlayerStat(playerName, Integer.parseInt(data[9])));
-                    powerLevel += Integer.parseInt(data[9]);
-                }
-
-                if (data.length > 10 && StringUtils.isInt(data[10])) {
-                    excavation.add(new PlayerStat(playerName, Integer.parseInt(data[10])));
-                    powerLevel += Integer.parseInt(data[10]);
-                }
-
-                if (data.length > 11 && StringUtils.isInt(data[11])) {
-                    archery.add(new PlayerStat(playerName, Integer.parseInt(data[11])));
-                    powerLevel += Integer.parseInt(data[11]);
-                }
-
-                if (data.length > 12 && StringUtils.isInt(data[12])) {
-                    swords.add(new PlayerStat(playerName, Integer.parseInt(data[12])));
-                    powerLevel += Integer.parseInt(data[12]);
-                }
-
-                if (data.length > 13 && StringUtils.isInt(data[13])) {
-                    axes.add(new PlayerStat(playerName, Integer.parseInt(data[13])));
-                    powerLevel += Integer.parseInt(data[13]);
-                }
-
-                if (data.length > 14 && StringUtils.isInt(data[14])) {
-                    acrobatics.add(new PlayerStat(playerName, Integer.parseInt(data[14])));
-                    powerLevel += Integer.parseInt(data[14]);
-                }
-
-                if (data.length > 24 && StringUtils.isInt(data[24])) {
-                    taming.add(new PlayerStat(playerName, Integer.parseInt(data[24])));
-                    powerLevel += Integer.parseInt(data[24]);
-                }
-
-                if (data.length > 34 && StringUtils.isInt(data[34])) {
-                    fishing.add(new PlayerStat(playerName, Integer.parseInt(data[34])));
-                    powerLevel += Integer.parseInt(data[34]);
-                }
-
-                powerLevels.add(new PlayerStat(playerName, powerLevel));
-            }
-            in.close();
-        }
-        catch (Exception e) {
-            mcMMO.p.getLogger().severe("Exception while reading " + mcMMO.getUsersFilePath() + " (Are you sure you formatted it correctly?)" + e.toString());
-        }
-
-        SkillComparator c = new SkillComparator();
-
-        Collections.sort(mining, c);
-        Collections.sort(woodcutting, c);
-        Collections.sort(repair, c);
-        Collections.sort(unarmed, c);
-        Collections.sort(herbalism, c);
-        Collections.sort(excavation, c);
-        Collections.sort(archery, c);
-        Collections.sort(swords, c);
-        Collections.sort(axes, c);
-        Collections.sort(acrobatics, c);
-        Collections.sort(taming, c);
-        Collections.sort(fishing, c);
-        Collections.sort(powerLevels, c);
-
-        playerStatHash.put(SkillType.MINING, mining);
-        playerStatHash.put(SkillType.WOODCUTTING, woodcutting);
-        playerStatHash.put(SkillType.REPAIR, repair);
-        playerStatHash.put(SkillType.UNARMED, unarmed);
-        playerStatHash.put(SkillType.HERBALISM, herbalism);
-        playerStatHash.put(SkillType.EXCAVATION, excavation);
-        playerStatHash.put(SkillType.ARCHERY, archery);
-        playerStatHash.put(SkillType.SWORDS, swords);
-        playerStatHash.put(SkillType.AXES, axes);
-        playerStatHash.put(SkillType.ACROBATICS, acrobatics);
-        playerStatHash.put(SkillType.TAMING, taming);
-        playerStatHash.put(SkillType.FISHING, fishing);
-    }
-
-    /**
-     * Retrieve leaderboard info.
-     *
-     * @param skillType Skill to retrieve info on.
-     * @param pageNumber Which page in the leaderboards to retrieve
-     * @return the requested leaderboard information
-     */
-    public static String[] retrieveInfo(String skillType, int pageNumber) {
-        String[] info = new String[10];
-        List<PlayerStat> statsList;
-
-        if (skillType.equalsIgnoreCase("all")) {
-            statsList = powerLevels;
-        }
-        else {
-            statsList = playerStatHash.get(SkillType.getSkill(skillType));
-        }
-
-        if (pageNumber < 1) {
-            pageNumber = 1;
-        }
-        int destination = (pageNumber - 1) * 10;
-
-        for (int i = 0; i < 10; i++) {
-            if (destination + i < statsList.size()) {
-                PlayerStat ps = statsList.get(destination + i);
-                info[i] = ps.name + ":" + ps.statVal;
-            }
-        }
-
-        return info;
-    }
-
-    public static int[] getPlayerRank(String playerName) {
-        return getPlayerRank(playerName, powerLevels);
-    }
-
-    public static int[] getPlayerRank(String playerName, SkillType skillType) {
-        return getPlayerRank(playerName, playerStatHash.get(skillType));
-    }
-
-    public static boolean removeFlatFileUser(String playerName) {
-        boolean worked = false;
-
-        BufferedReader in = null;
-        FileWriter out = null;
-        String usersFilePath = mcMMO.getUsersFilePath();
-
-        try {
-            FileReader file = new FileReader(usersFilePath);
-            in = new BufferedReader(file);
-            StringBuilder writer = new StringBuilder();
-            String line = "";
-
-            while ((line = in.readLine()) != null) {
-
-                // Write out the same file but when we get to the player we want to remove, we skip his line.
-                if (!line.split(":")[0].equalsIgnoreCase(playerName)) {
-                    writer.append(line).append("\r\n");
-                }
-                else {
-                    mcMMO.p.getLogger().info("User found, removing...");
-                    worked = true;
-                    continue; // Skip the player
-                }
-            }
-
-            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 ex) {
-                    ex.printStackTrace();
-                }
-            }
-
-            if (out != null) {
-                try {
-                    out.close();
-                }
-                catch (IOException ex) {
-                    ex.printStackTrace();
-                }
-            }
-        }
-
-        return worked;
-    }
-
-    public static void purgePowerlessFlatfile() {
-        mcMMO.p.getLogger().info("Purging powerless users...");
-
-        int purgedUsers = 0;
-
-        for (PlayerStat stat : powerLevels) {
-            if (stat.statVal == 0 && !mcMMO.p.getServer().getOfflinePlayer(stat.name).isOnline() && removeFlatFileUser(stat.name)) {
-                purgedUsers++;
-            }
-        }
-
-        mcMMO.p.getLogger().info("Purged " + purgedUsers + " users from the database.");
-    }
-
-    public static void purgeOldFlatfile() {
-        mcMMO.p.getLogger().info("Purging old users...");
-        int purgedUsers = removeOldFlatfileUsers();
-        mcMMO.p.getLogger().info("Purged " + purgedUsers + " users from the database.");
-    }
-
-    private static int removeOldFlatfileUsers() {
-        int removedPlayers = 0;
-        long currentTime = System.currentTimeMillis();
-        long purgeTime = ONE_MONTH * Config.getInstance().getOldUsersCutoff();
-
-        BufferedReader in = null;
-        FileWriter out = null;
-        String usersFilePath = mcMMO.getUsersFilePath();
-
-        try {
-            FileReader file = new FileReader(usersFilePath);
-            in = new BufferedReader(file);
-            StringBuilder writer = new StringBuilder();
-            String line = "";
-
-            while ((line = in.readLine()) != null) {
-
-                // Write out the same file but when we get to the player we want to remove, we skip his line.
-                String[] splitLine = line.split(":");
-
-                if (splitLine.length > 37) {
-                    if (currentTime - (StringUtils.getLong(line.split(":")[37]) * 1000) <= purgeTime) {
-                        writer.append(line).append("\r\n");
-                    }
-                    else {
-                        mcMMO.p.getLogger().info("User found, removing...");
-                        removedPlayers++;
-                        continue; // Skip the player
-                    }
-                }
-                else {
-                    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 ex) {
-                    ex.printStackTrace();
-                }
-            }
-
-            if (out != null) {
-                try {
-                    out.close();
-                }
-                catch (IOException ex) {
-                    ex.printStackTrace();
-                }
-            }
-        }
-
-        return removedPlayers;
-    }
-
-    private static int[] getPlayerRank(String playerName, List<PlayerStat> statsList) {
-        int currentPos = 1;
-
-        if (statsList == null) {
-            return new int[] {0, 0};
-        }
-
-        for (PlayerStat stat : statsList) {
-            if (stat.name.equalsIgnoreCase(playerName)) {
-                return new int[] {currentPos, stat.statVal};
-            }
-
-            currentPos++;
-        }
-
-        return new int[] {0, 0};
-    }
-
-    private static class SkillComparator implements Comparator<PlayerStat> {
-        @Override
-        public int compare(PlayerStat o1, PlayerStat o2) {
-            return (o2.statVal - o1.statVal);
-        }
-    }
-}

src/main/java/com/gmail/nossr50/datatypes/MobHealthbarType.java

@@ -0,0 +1,7 @@
+package com.gmail.nossr50.datatypes;
+
+public enum MobHealthbarType {
+    HEARTS,
+    BAR,
+    DISABLED;
+}

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

@@ -3,6 +3,9 @@ package com.gmail.nossr50.datatypes.database;
 public enum DatabaseUpdateType {
     FISHING,
     BLAST_MINING,
-    CASCADE_DELETE,
-    INDEX;
+    INDEX,
+    MOB_HEALTHBARS,
+    PARTY_NAMES, 
+    KILL_ORPHANS,
+    ;
 }

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

@@ -0,0 +1,33 @@
+package com.gmail.nossr50.datatypes.party;
+
+import org.bukkit.inventory.ItemStack;
+
+import com.gmail.nossr50.util.ItemUtils;
+
+public enum ItemShareType {
+    LOOT,
+    MINING,
+    HERBALISM,
+    WOODCUTTING,
+    MISC;
+
+    public static ItemShareType getShareType(ItemStack itemStack) {
+        if (ItemUtils.isMobDrop(itemStack)) {
+            return LOOT;
+        }
+        else if (ItemUtils.isMiningDrop(itemStack)) {
+            return MINING;
+        }
+        else if (ItemUtils.isHerbalismDrop(itemStack)) {
+            return HERBALISM;
+        }
+        else if (ItemUtils.isWoodcuttingDrop(itemStack)) {
+            return WOODCUTTING;
+        }
+        else if (ItemUtils.isMiscDrop(itemStack)) {
+            return MISC;
+        }
+
+        return null;
+    }
+}

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

@@ -1,38 +1,68 @@
 package com.gmail.nossr50.datatypes.party;
 
 import java.util.ArrayList;
+import java.util.LinkedHashSet;
 import java.util.List;
 
-import org.bukkit.OfflinePlayer;
 import org.bukkit.entity.Player;
 
-import com.gmail.nossr50.party.ShareHandler;
+import com.gmail.nossr50.mcMMO;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.party.ShareHandler.ShareMode;
 
 public class Party {
-    private List<OfflinePlayer> members = new ArrayList<OfflinePlayer>();
+    private final LinkedHashSet<String> members = new LinkedHashSet<String>();
+
     private String leader;
     private String name;
     private String password;
     private boolean locked;
 
-    private ShareHandler.ShareMode xpShareMode   = ShareHandler.ShareMode.NONE;
-    private ShareHandler.ShareMode itemShareMode = ShareHandler.ShareMode.NONE;
+    private ShareMode xpShareMode   = ShareMode.NONE;
+    private ShareMode itemShareMode = ShareMode.NONE;
 
     private boolean shareLootDrops        = true;
     private boolean shareMiningDrops      = true;
     private boolean shareHerbalismDrops   = true;
     private boolean shareWoodcuttingDrops = true;
+    private boolean shareMiscDrops        = true;
 
-    public List<OfflinePlayer> getMembers() {
+    public Party(String name) {
+        this.name = name;
+    }
+
+    public Party(String leader, String name) {
+        this.leader = leader;
+        this.name = name;
+        this.locked = true;
+    }
+
+    public Party(String leader, String name, String password) {
+        this.leader = leader;
+        this.name = name;
+        this.password = password;
+        this.locked = true;
+    }
+
+    public Party(String leader, String name, String password, boolean locked) {
+        this.leader = leader;
+        this.name = name;
+        this.password = password;
+        this.locked = locked;
+    }
+
+    public LinkedHashSet<String> getMembers() {
         return members;
     }
 
     public List<Player> getOnlineMembers() {
         List<Player> onlineMembers = new ArrayList<Player>();
 
-        for (OfflinePlayer member : members) {
-            if (member.isOnline()) {
-                onlineMembers.add(member.getPlayer());
+        for (String memberName : members) {
+            Player member = mcMMO.p.getServer().getPlayerExact(memberName);
+
+            if (member != null) {
+                onlineMembers.add(member);
             }
         }
 
@@ -55,40 +85,27 @@ public class Party {
         return locked;
     }
 
-    public boolean sharingLootDrops() {
-        return shareLootDrops;
-    }
-
-    public boolean sharingMiningDrops() {
-        return shareMiningDrops;
-    }
-
-    public boolean sharingHerbalismDrops() {
-        return shareHerbalismDrops;
-    }
-
-    public boolean sharingWoodcuttingDrops() {
-        return shareWoodcuttingDrops;
-    }
-
     public List<String> getItemShareCategories() {
         List<String> shareCategories = new ArrayList<String>();
 
-        // TODO Locale the category names!
-        if (sharingLootDrops()) {
-            shareCategories.add("Loot");
+        if (shareLootDrops) {
+            shareCategories.add(LocaleLoader.getString("Party.ItemShare.Category.Loot"));
         }
 
-        if (sharingMiningDrops()) {
-            shareCategories.add("Mining");
+        if (shareMiningDrops) {
+            shareCategories.add(LocaleLoader.getString("Party.ItemShare.Category.Mining"));
         }
 
-        if (sharingHerbalismDrops()) {
-            shareCategories.add("Herbalism");
+        if (shareHerbalismDrops) {
+            shareCategories.add(LocaleLoader.getString("Party.ItemShare.Category.Herbalism"));
         }
 
-        if (sharingWoodcuttingDrops()) {
-            shareCategories.add("Woodcutting");
+        if (shareWoodcuttingDrops) {
+            shareCategories.add(LocaleLoader.getString("Party.ItemShare.Category.Woodcutting"));
+        }
+
+        if (shareMiscDrops) {
+            shareCategories.add(LocaleLoader.getString("Party.ItemShare.Category.Misc"));
         }
 
         return shareCategories;
@@ -110,35 +127,92 @@ public class Party {
         this.locked = locked;
     }
 
-    public void setXpShareMode(ShareHandler.ShareMode xpShareMode) {
+    public void setXpShareMode(ShareMode xpShareMode) {
         this.xpShareMode = xpShareMode;
     }
 
-    public ShareHandler.ShareMode getXpShareMode() {
+    public ShareMode getXpShareMode() {
         return xpShareMode;
     }
 
-    public void setItemShareMode(ShareHandler.ShareMode itemShareMode) {
+    public void setItemShareMode(ShareMode itemShareMode) {
         this.itemShareMode = itemShareMode;
     }
 
-    public ShareHandler.ShareMode getItemShareMode() {
+    public ShareMode getItemShareMode() {
         return itemShareMode;
     }
 
-    public void setSharingLootDrops(boolean enabled) {
-        shareLootDrops = enabled;
+    public boolean sharingDrops(ItemShareType shareType) {
+        switch (shareType) {
+            case HERBALISM:
+                return shareHerbalismDrops;
+
+            case LOOT:
+                return shareLootDrops;
+
+            case MINING:
+                return shareMiningDrops;
+
+            case MISC:
+                return shareMiscDrops;
+
+            case WOODCUTTING:
+                return shareWoodcuttingDrops;
+
+            default:
+                return false;
+        }
     }
 
-    public void setSharingMiningDrops(boolean enabled) {
-        shareMiningDrops = enabled;
+    public void setSharingDrops(ItemShareType shareType, boolean enabled) {
+        switch (shareType) {
+            case HERBALISM:
+                shareHerbalismDrops = enabled;
+                break;
+
+            case LOOT:
+                shareLootDrops = enabled;
+                break;
+
+            case MINING:
+                shareMiningDrops = enabled;
+                break;
+
+            case MISC:
+                shareMiscDrops = enabled;
+                break;
+
+            case WOODCUTTING:
+                shareWoodcuttingDrops = enabled;
+                break;
+
+            default:
+                return;
+        }
     }
 
-    public void setSharingHerbalismDrops(boolean enabled) {
-        shareHerbalismDrops = enabled;
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == null) {
+            return false;
+        }
+
+        if (!(obj instanceof Party)) {
+            return false;
+        }
+
+        Party other = (Party) obj;
+
+        if ((this.getName() == null) || (other.getName() == null)) {
+            return false;
+        }
+
+        return this.getName().equals(other.getName());
     }
 
-    public void setSharingWoodcuttingDrops(boolean enabled) {
-        shareWoodcuttingDrops = enabled;
+    @Override
+    public int hashCode() {
+        return super.hashCode();
     }
 }

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

@@ -7,7 +7,6 @@ import java.util.Set;
 import org.bukkit.GameMode;
 import org.bukkit.Location;
 import org.bukkit.entity.Player;
-import org.bukkit.inventory.ItemStack;
 
 import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.config.Config;
@@ -20,6 +19,7 @@ import com.gmail.nossr50.datatypes.spout.huds.McMMOHud;
 import com.gmail.nossr50.events.experience.McMMOPlayerXpGainEvent;
 import com.gmail.nossr50.party.PartyManager;
 import com.gmail.nossr50.party.ShareHandler;
+import com.gmail.nossr50.runnables.skills.AbilityDisableTask;
 import com.gmail.nossr50.skills.SkillManager;
 import com.gmail.nossr50.skills.acrobatics.AcrobaticsManager;
 import com.gmail.nossr50.skills.archery.ArcheryManager;
@@ -53,7 +53,7 @@ public class McMMOPlayer {
      * we make sure that all class inheriting from SkillManager are instanced.
      * Which solution is better, I let you decide. - bm01
      */
-    private Map<SkillType, SkillManager> skillManagers = new HashMap<SkillType, SkillManager>();
+    private final Map<SkillType, SkillManager> skillManagers = new HashMap<SkillType, SkillManager>();
 
     private Party   party;
     private Party   invite;
@@ -70,20 +70,23 @@ public class McMMOPlayer {
 
     private boolean abilityUse = true;
     private boolean placedRepairAnvil;
+    private int     lastRepairClick;
     private boolean placedSalvageAnvil;
+    private int     lastSalvageClick;
     private boolean godMode;
 
-    private Map<AbilityType, Boolean> abilityMode     = new HashMap<AbilityType, Boolean>();
-    private Map<AbilityType, Boolean> abilityInformed = new HashMap<AbilityType, Boolean>();
+    private final Map<AbilityType, Boolean> abilityMode     = new HashMap<AbilityType, Boolean>();
+    private final Map<AbilityType, Boolean> abilityInformed = new HashMap<AbilityType, Boolean>();
 
-    private Map<ToolType, Boolean> toolMode = new HashMap<ToolType, Boolean>();
-    private Map<ToolType, Integer> toolATS  = new HashMap<ToolType, Integer>();
-
-    private int chimaeraWing;
-    private Location chimaeraWingCommence;
+    private final Map<ToolType, Boolean> toolMode = new HashMap<ToolType, Boolean>();
+    private final Map<ToolType, Integer> toolATS  = new HashMap<ToolType, Integer>();
 
     private int recentlyHurt;
     private int respawnATS;
+    private int teleportLastUse;
+    private Location teleportCommence;
+
+    private boolean isUsingUnarmed;
 
     public McMMOPlayer(Player player) {
         String playerName = player.getName();
@@ -179,7 +182,8 @@ public class McMMOPlayer {
      */
     public void resetAbilityMode() {
         for (AbilityType ability : AbilityType.values()) {
-            setAbilityMode(ability, false);
+            // Correctly disable and handle any special deactivate code
+            new AbilityDisableTask(this, ability).run();
         }
     }
 
@@ -197,10 +201,10 @@ public class McMMOPlayer {
      * Set the mode of an ability.
      *
      * @param ability The ability to check
-     * @param bool True if the ability is active, false otherwise
+     * @param isActive True if the ability is active, false otherwise
      */
-    public void setAbilityMode(AbilityType ability, boolean bool) {
-        abilityMode.put(ability, bool);
+    public void setAbilityMode(AbilityType ability, boolean isActive) {
+        abilityMode.put(ability, isActive);
     }
 
     /**
@@ -217,10 +221,10 @@ public class McMMOPlayer {
      * Set the informed state of an ability.
      *
      * @param ability The ability to check
-     * @param bool True if the ability is informed, false otherwise
+     * @param isInformed True if the ability is informed, false otherwise
      */
-    public void setAbilityInformed(AbilityType ability, boolean bool) {
-        abilityInformed.put(ability, bool);
+    public void setAbilityInformed(AbilityType ability, boolean isInformed) {
+        abilityInformed.put(ability, isInformed);
     }
 
     /**
@@ -258,10 +262,10 @@ public class McMMOPlayer {
      * Set the current prep mode of a tool.
      *
      * @param tool Tool to set the mode for
-     * @param bool true if the tool should be prepped, false otherwise
+     * @param isPrepared true if the tool should be prepped, false otherwise
      */
-    public void setToolPreparationMode(ToolType tool, boolean bool) {
-        toolMode.put(tool, bool);
+    public void setToolPreparationMode(ToolType tool, boolean isPrepared) {
+        toolMode.put(tool, isPrepared);
     }
 
     /**
@@ -303,31 +307,31 @@ public class McMMOPlayer {
     }
 
     /*
-     * Chimaera Wing
+     * Teleportation cooldown & warmup
      */
 
-    public int getLastChimaeraTeleport() {
-        return chimaeraWing;
+    public int getLastTeleport() {
+        return teleportLastUse;
     }
 
-    public void setLastChimaeraTeleport(int value) {
-        chimaeraWing = value;
+    public void setLastTeleport(int value) {
+        teleportLastUse = value;
     }
 
-    public void actualizeLastChimaeraTeleport() {
-        chimaeraWing = (int) (System.currentTimeMillis() / Misc.TIME_CONVERSION_FACTOR);
+    public void actualizeLastTeleport() {
+        teleportLastUse = (int) (System.currentTimeMillis() / Misc.TIME_CONVERSION_FACTOR);
     }
 
-    public Location getChimaeraCommenceLocation() {
-        return chimaeraWingCommence;
+    public Location getTeleportCommenceLocation() {
+        return teleportCommence;
     }
 
-    public void setChimaeraCommenceLocation(Location location) {
-        chimaeraWingCommence = location;
+    public void setTeleportCommenceLocation(Location location) {
+        teleportCommence = location;
     }
 
-    public void actualizeChimaeraCommenceLocation(Player player) {
-        setChimaeraCommenceLocation(player.getLocation());
+    public void actualizeTeleportCommenceLocation(Player player) {
+        teleportCommence = player.getLocation();
     }
 
     /*
@@ -368,6 +372,42 @@ public class McMMOPlayer {
         }
     }
 
+    /*
+     * Repair Anvil Usage
+     */
+
+    public int getLastAnvilUse(int anvilId) {
+        if (anvilId == Repair.repairAnvilId) {
+            return lastRepairClick;
+        }
+
+        if (anvilId == Repair.salvageAnvilId) {
+            return lastSalvageClick;
+        }
+
+        return 0;
+    }
+
+    public void setLastAnvilUse(int anvilId, int value) {
+        if (anvilId == Repair.repairAnvilId) {
+            lastRepairClick = value;
+        }
+
+        if (anvilId == Repair.salvageAnvilId) {
+            lastSalvageClick = value;
+        }
+    }
+
+    public void actualizeLastAnvilUse(int anvilId) {
+        if (anvilId == Repair.repairAnvilId) {
+            lastRepairClick = (int) (System.currentTimeMillis() / Misc.TIME_CONVERSION_FACTOR);
+        }
+
+        if (anvilId == Repair.salvageAnvilId) {
+            lastSalvageClick = (int) (System.currentTimeMillis() / Misc.TIME_CONVERSION_FACTOR);
+        }
+    }
+
     /*
      * God Mode
      */
@@ -400,11 +440,7 @@ public class McMMOPlayer {
     public int getPowerLevel() {
         int powerLevel = 0;
 
-        for (SkillType type : SkillType.values()) {
-            if (type.isChildSkill()) {
-                continue;
-            }
-
+        for (SkillType type : SkillType.nonChildSkills()) {
             if (Permissions.skillEnabled(player, type)) {
                 powerLevel += profile.getSkillLevel(type);
             }
@@ -419,7 +455,7 @@ public class McMMOPlayer {
      * @param skillType Skill being used
      * @param xp Experience amount to process
      */
-    public void beginXpGain(SkillType skillType, int xp) {
+    public void beginXpGain(SkillType skillType, float xp) {
         if (xp == 0) {
             return;
         }
@@ -450,7 +486,7 @@ public class McMMOPlayer {
      * @param skillType Skill being used
      * @param xp Experience amount to process
      */
-    public void beginUnsharedXpGain(SkillType skillType, int xp) {
+    public void beginUnsharedXpGain(SkillType skillType, float xp) {
         xp = modifyXpGain(skillType, xp);
 
         applyXpGain(skillType, xp);
@@ -462,20 +498,21 @@ public class McMMOPlayer {
      * @param skillType Skill being used
      * @param xp Experience amount to add
      */
-    public void applyXpGain(SkillType skillType, int xp) {
+    public void applyXpGain(SkillType skillType, float xp) {
+        if (!Permissions.skillEnabled(player, skillType)) {
+            return;
+        }
+
         if (skillType.isChildSkill()) {
             Set<SkillType> parentSkills = FamilyTree.getParents(skillType);
 
             for (SkillType parentSkill : parentSkills) {
-                if (Permissions.skillEnabled(player, parentSkill)) {
-                    applyXpGain(parentSkill, xp / parentSkills.size());
-                }
+                applyXpGain(parentSkill, xp / parentSkills.size());
             }
 
             return;
         }
 
-
         McMMOPlayerXpGainEvent event = new McMMOPlayerXpGainEvent(player, skillType, xp);
         mcMMO.p.getServer().getPluginManager().callEvent(event);
 
@@ -483,7 +520,7 @@ public class McMMOPlayer {
             return;
         }
 
-        profile.setSkillXpLevel(skillType, profile.getSkillXpLevel(skillType) + event.getXpGained());
+        profile.setSkillXpLevel(skillType, profile.getSkillXpLevelRaw(skillType) + event.getRawXpGained());
 
         McMMOHud spoutHud = profile.getSpoutHud();
 
@@ -491,6 +528,7 @@ public class McMMOPlayer {
             spoutHud.setLastGained(skillType);
         }
 
+        isUsingUnarmed = (skillType == SkillType.UNARMED);
         SkillUtils.xpCheckSkill(skillType, player, profile);
     }
 
@@ -523,11 +561,7 @@ public class McMMOPlayer {
     }
 
     public boolean hasPartyInvite() {
-        if (invite != null) {
-            return true;
-        }
-
-        return false;
+        return (invite != null);
     }
 
     public void setParty(Party party) {
@@ -539,11 +573,7 @@ public class McMMOPlayer {
     }
 
     public boolean inParty() {
-        if (party != null) {
-            return true;
-        }
-
-        return false;
+        return (party != null);
     }
 
     public void removeParty() {
@@ -571,11 +601,7 @@ public class McMMOPlayer {
     }
 
     public boolean hasPtpRequest() {
-        if (ptpRequest != null) {
-            return true;
-        }
-
-        return false;
+        return (ptpRequest != null);
     }
 
     public void removePtpRequest() {
@@ -607,11 +633,7 @@ public class McMMOPlayer {
     }
 
     public void setItemShareModifier(int modifier) {
-        if (modifier < 10) {
-            modifier = 10;
-        }
-
-        itemShareModifier = modifier;
+        itemShareModifier = Math.max(10, modifier);
     }
 
     /*
@@ -642,6 +664,10 @@ public class McMMOPlayer {
         partyChatMode = !partyChatMode;
     }
 
+    public boolean isUsingUnarmed() {
+        return isUsingUnarmed;
+    }
+
     /**
      * Modifies an experience gain using skill modifiers, global rate and perks
      *
@@ -649,16 +675,15 @@ public class McMMOPlayer {
      * @param xp Experience amount to process
      * @return Modified experience
      */
-    private int modifyXpGain(SkillType skillType, int xp) {
-        if (player.getGameMode() == GameMode.CREATIVE || (skillType.getMaxLevel() < profile.getSkillLevel(skillType) + 1) || (Config.getInstance().getPowerLevelCap() < getPowerLevel() + 1)) {
+    private float modifyXpGain(SkillType skillType, float xp) {
+        if (player.getGameMode() == GameMode.CREATIVE || (skillType.getMaxLevel() <= profile.getSkillLevel(skillType)) || (Config.getInstance().getPowerLevelCap() <= getPowerLevel())) {
             return 0;
         }
 
-        xp = (int) (xp / skillType.getXpModifier() * Config.getInstance().getExperienceGainsGlobalMultiplier());
+        xp = (float) (xp / skillType.getXpModifier() * Config.getInstance().getExperienceGainsGlobalMultiplier());
 
         if (Config.getInstance().getToolModsEnabled()) {
-            ItemStack item = player.getItemInHand();
-            CustomTool tool = ModUtils.getToolFromItemStack(item);
+            CustomTool tool = ModUtils.getToolFromItemStack(player.getItemInHand());
 
             if (tool != null) {
                 xp *= tool.getXpMultiplier();

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

@@ -1,530 +1,66 @@
 package com.gmail.nossr50.datatypes.player;
 
-import java.io.BufferedReader;
-import java.io.BufferedWriter;
-import java.io.FileReader;
-import java.io.FileWriter;
-import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
+import org.bukkit.scoreboard.Scoreboard;
+
 import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.config.Config;
 import com.gmail.nossr50.config.spout.SpoutConfig;
-import com.gmail.nossr50.database.DatabaseManager;
+import com.gmail.nossr50.datatypes.MobHealthbarType;
 import com.gmail.nossr50.datatypes.skills.AbilityType;
 import com.gmail.nossr50.datatypes.skills.SkillType;
 import com.gmail.nossr50.datatypes.spout.huds.HudType;
 import com.gmail.nossr50.datatypes.spout.huds.McMMOHud;
 import com.gmail.nossr50.skills.child.FamilyTree;
-import com.gmail.nossr50.util.Misc;
-import com.gmail.nossr50.util.StringUtils;
 
 public class PlayerProfile {
-    private String playerName;
-
-    // HUD
-    private McMMOHud spoutHud;
-    private HudType  hudType;
-
-    // mySQL Stuff
-    private int userId;
-
+    private final String playerName;
     private boolean loaded;
 
-    private Map<SkillType, Integer>   skills     = new HashMap<SkillType, Integer>(); // Skills and Levels
-    private Map<SkillType, Integer>   skillsXp   = new HashMap<SkillType, Integer>(); // Skills and Xp
-    private Map<AbilityType, Integer> skillsDATS = new HashMap<AbilityType, Integer>();
+    /* HUDs */
+    private HudType hudType;
+    private MobHealthbarType mobHealthbarType;
+    private McMMOHud spoutHud;
+    private Scoreboard playerStatsScoreboard;
 
-    private final static String location = mcMMO.getUsersFilePath();
+    /* Skill Data */
+    private final Map<SkillType, Integer>   skills     = new HashMap<SkillType, Integer>();   // Skill & Level
+    private final Map<SkillType, Float>     skillsXp   = new HashMap<SkillType, Float>();     // Skill & XP
+    private final Map<AbilityType, Integer> skillsDATS = new HashMap<AbilityType, Integer>(); // Ability & Cooldown
 
     public PlayerProfile(String playerName, boolean addNew) {
         this.playerName = playerName;
 
-        if (mcMMO.spoutEnabled) {
-            hudType = SpoutConfig.getInstance().defaultHudType;
-        }
-        else {
-            hudType = HudType.DISABLED;
-        }
+        hudType = mcMMO.isSpoutEnabled() ? SpoutConfig.getInstance().getDefaultHudType() : HudType.DISABLED;
+        mobHealthbarType = Config.getInstance().getMobHealthbarDefault();
 
         for (AbilityType abilityType : AbilityType.values()) {
             skillsDATS.put(abilityType, 0);
         }
 
-        for (SkillType skillType : SkillType.values()) {
-            if (!skillType.isChildSkill()) {
-                skills.put(skillType, 0);
-                skillsXp.put(skillType, 0);
-            }
+        for (SkillType skillType : SkillType.nonChildSkills()) {
+            skills.put(skillType, 0);
+            skillsXp.put(skillType, 0F);
         }
 
-        if (Config.getInstance().getUseMySQL()) {
-            if (!loadMySQL() && addNew) {
-                addMySQLPlayer();
-                loaded = true;
-            }
-        }
-        else if (!load() && addNew) {
-            addPlayer();
+        if (!loadPlayer() && addNew) {
+            mcMMO.getDatabaseManager().newUser(playerName);
             loaded = true;
         }
     }
 
+    public void save() {
+        mcMMO.getDatabaseManager().saveUser(this);
+    }
+
     public String getPlayerName() {
         return playerName;
     }
 
-    public boolean loadMySQL() {
-        String tablePrefix = Config.getInstance().getMySQLTablePrefix();
-
-        userId = DatabaseManager.getInt("SELECT id FROM " + tablePrefix + "users WHERE user = '" + playerName + "'");
-
-        if (userId == 0) {
-            return false;
-        }
-
-        HashMap<Integer, ArrayList<String>> huds = DatabaseManager.read("SELECT hudtype FROM " + tablePrefix + "huds WHERE user_id = " + userId);
-
-        if (huds.get(1) == null) {
-            DatabaseManager.write("INSERT INTO " + tablePrefix + "huds (user_id) VALUES (" + userId + ")");
-        }
-        else {
-            for (HudType type : HudType.values()) {
-                if (type.toString().equalsIgnoreCase(huds.get(1).get(0))) {
-                    hudType = type;
-                }
-            }
-        }
-
-        HashMap<Integer, ArrayList<String>> cooldowns = DatabaseManager.read("SELECT mining, woodcutting, unarmed, herbalism, excavation, swords, axes, blast_mining FROM " + tablePrefix + "cooldowns WHERE user_id = " + userId);
-        ArrayList<String> cooldownValues = cooldowns.get(1);
-
-        if (cooldownValues == null) {
-            DatabaseManager.write("INSERT INTO " + tablePrefix + "cooldowns (user_id) VALUES (" + userId + ")");
-            mcMMO.p.getLogger().warning(playerName + "does not exist in the cooldown table. Their cooldowns will be reset.");
-        }
-        else {
-            skillsDATS.put(AbilityType.SUPER_BREAKER, Integer.valueOf(cooldownValues.get(0)));
-            skillsDATS.put(AbilityType.TREE_FELLER, Integer.valueOf(cooldownValues.get(1)));
-            skillsDATS.put(AbilityType.BERSERK, Integer.valueOf(cooldownValues.get(2)));
-            skillsDATS.put(AbilityType.GREEN_TERRA, Integer.valueOf(cooldownValues.get(3)));
-            skillsDATS.put(AbilityType.GIGA_DRILL_BREAKER, Integer.valueOf(cooldownValues.get(4)));
-            skillsDATS.put(AbilityType.SERRATED_STRIKES, Integer.valueOf(cooldownValues.get(5)));
-            skillsDATS.put(AbilityType.SKULL_SPLITTER, Integer.valueOf(cooldownValues.get(6)));
-            skillsDATS.put(AbilityType.BLAST_MINING, Integer.valueOf(cooldownValues.get(7)));
-        }
-
-        HashMap<Integer, ArrayList<String>> stats = DatabaseManager.read("SELECT taming, mining, repair, woodcutting, unarmed, herbalism, excavation, archery, swords, axes, acrobatics, fishing FROM " + tablePrefix + "skills WHERE user_id = " + userId);
-        ArrayList<String> statValues = stats.get(1);
-
-        if (statValues == null) {
-            DatabaseManager.write("INSERT INTO " + tablePrefix + "skills (user_id) VALUES (" + userId + ")");
-            mcMMO.p.getLogger().warning(playerName + "does not exist in the skills table. Their stats will be reset.");
-        }
-        else {
-            skills.put(SkillType.TAMING, Integer.valueOf(statValues.get(0)));
-            skills.put(SkillType.MINING, Integer.valueOf(statValues.get(1)));
-            skills.put(SkillType.REPAIR, Integer.valueOf(statValues.get(2)));
-            skills.put(SkillType.WOODCUTTING, Integer.valueOf(statValues.get(3)));
-            skills.put(SkillType.UNARMED, Integer.valueOf(statValues.get(4)));
-            skills.put(SkillType.HERBALISM, Integer.valueOf(statValues.get(5)));
-            skills.put(SkillType.EXCAVATION, Integer.valueOf(statValues.get(6)));
-            skills.put(SkillType.ARCHERY, Integer.valueOf(statValues.get(7)));
-            skills.put(SkillType.SWORDS, Integer.valueOf(statValues.get(8)));
-            skills.put(SkillType.AXES, Integer.valueOf(statValues.get(9)));
-            skills.put(SkillType.ACROBATICS, Integer.valueOf(statValues.get(10)));
-            skills.put(SkillType.FISHING, Integer.valueOf(statValues.get(11)));
-        }
-
-        HashMap<Integer, ArrayList<String>> experience = DatabaseManager.read("SELECT taming, mining, repair, woodcutting, unarmed, herbalism, excavation, archery, swords, axes, acrobatics, fishing FROM " + tablePrefix + "experience WHERE user_id = " + userId);
-        ArrayList<String> experienceValues = experience.get(1);
-
-        if (experienceValues == null) {
-            DatabaseManager.write("INSERT INTO " + tablePrefix + "experience (user_id) VALUES (" + userId + ")");
-            mcMMO.p.getLogger().warning(playerName + "does not exist in the experience table. Their experience will be reset.");
-        }
-        else {
-            skillsXp.put(SkillType.TAMING, Integer.valueOf(experienceValues.get(0)));
-            skillsXp.put(SkillType.MINING, Integer.valueOf(experienceValues.get(1)));
-            skillsXp.put(SkillType.REPAIR, Integer.valueOf(experienceValues.get(2)));
-            skillsXp.put(SkillType.WOODCUTTING, Integer.valueOf(experienceValues.get(3)));
-            skillsXp.put(SkillType.UNARMED, Integer.valueOf(experienceValues.get(4)));
-            skillsXp.put(SkillType.HERBALISM, Integer.valueOf(experienceValues.get(5)));
-            skillsXp.put(SkillType.EXCAVATION, Integer.valueOf(experienceValues.get(6)));
-            skillsXp.put(SkillType.ARCHERY, Integer.valueOf(experienceValues.get(7)));
-            skillsXp.put(SkillType.SWORDS, Integer.valueOf(experienceValues.get(8)));
-            skillsXp.put(SkillType.AXES, Integer.valueOf(experienceValues.get(9)));
-            skillsXp.put(SkillType.ACROBATICS, Integer.valueOf(experienceValues.get(10)));
-            skillsXp.put(SkillType.FISHING, Integer.valueOf(experienceValues.get(11)));
-        }
-
-        loaded = true;
-        return true;
-    }
-
-    public void addMySQLPlayer() {
-        String tablePrefix = Config.getInstance().getMySQLTablePrefix();
-
-        DatabaseManager.write("INSERT INTO " + tablePrefix + "users (user, lastlogin) VALUES ('" + playerName + "'," + System.currentTimeMillis() / Misc.TIME_CONVERSION_FACTOR + ")");
-        userId = DatabaseManager.getInt("SELECT id FROM " + tablePrefix + "users WHERE user = '" + playerName + "'");
-
-        DatabaseManager.write("INSERT INTO " + tablePrefix + "cooldowns (user_id) VALUES (" + userId + ")");
-        DatabaseManager.write("INSERT INTO " + tablePrefix + "skills (user_id) VALUES (" + userId + ")");
-        DatabaseManager.write("INSERT INTO " + tablePrefix + "experience (user_id) VALUES (" + userId + ")");
-    }
-
-    public boolean load() {
-        try {
-            // Open the user file
-            FileReader file = new FileReader(location);
-            BufferedReader in = new BufferedReader(file);
-            String line;
-
-            while ((line = in.readLine()) != null) {
-                // Find if the line contains the player we want.
-                String[] character = line.split(":");
-
-                if (!character[0].equalsIgnoreCase(playerName)) {
-                    continue;
-                }
-
-                if (character.length > 1 && StringUtils.isInt(character[1])) {
-                    skills.put(SkillType.MINING, Integer.valueOf(character[1]));
-                }
-
-                if (character.length > 4 && StringUtils.isInt(character[4])) {
-                    skillsXp.put(SkillType.MINING, Integer.valueOf(character[4]));
-                }
-
-                if (character.length > 5 && StringUtils.isInt(character[5])) {
-                    skills.put(SkillType.WOODCUTTING, Integer.valueOf(character[5]));
-                }
-
-                if (character.length > 6 && StringUtils.isInt(character[6])) {
-                    skillsXp.put(SkillType.WOODCUTTING, Integer.valueOf(character[6]));
-                }
-
-                if (character.length > 7 && StringUtils.isInt(character[7])) {
-                    skills.put(SkillType.REPAIR, Integer.valueOf(character[7]));
-                }
-
-                if (character.length > 8 && StringUtils.isInt(character[8])) {
-                    skills.put(SkillType.UNARMED,  Integer.valueOf(character[8]));
-                }
-
-                if (character.length > 9 && StringUtils.isInt(character[9])) {
-                    skills.put(SkillType.HERBALISM, Integer.valueOf(character[9]));
-                }
-
-                if (character.length > 10 && StringUtils.isInt(character[10])) {
-                    skills.put(SkillType.EXCAVATION, Integer.valueOf(character[10]));
-                }
-
-                if (character.length > 11 && StringUtils.isInt(character[11])) {
-                    skills.put(SkillType.ARCHERY, Integer.valueOf(character[11]));
-                }
-
-                if (character.length > 12 && StringUtils.isInt(character[12])) {
-                    skills.put(SkillType.SWORDS, Integer.valueOf(character[12]));
-                }
-
-                if (character.length > 13 && StringUtils.isInt(character[13])) {
-                    skills.put(SkillType.AXES, Integer.valueOf(character[13]));
-                }
-
-                if (character.length > 14 && StringUtils.isInt(character[14])) {
-                    skills.put(SkillType.ACROBATICS, Integer.valueOf(character[14]));
-                }
-
-                if (character.length > 15 && StringUtils.isInt(character[15])) {
-                    skillsXp.put(SkillType.REPAIR, Integer.valueOf(character[15]));
-                }
-
-                if (character.length > 16 && StringUtils.isInt(character[16])) {
-                    skillsXp.put(SkillType.UNARMED, Integer.valueOf(character[16]));
-                }
-
-                if (character.length > 17 && StringUtils.isInt(character[17])) {
-                    skillsXp.put(SkillType.HERBALISM, Integer.valueOf(character[17]));
-                }
-
-                if (character.length > 18 && StringUtils.isInt(character[18])) {
-                    skillsXp.put(SkillType.EXCAVATION, Integer.valueOf(character[18]));
-                }
-
-                if (character.length > 19 && StringUtils.isInt(character[19])) {
-                    skillsXp.put(SkillType.ARCHERY, Integer.valueOf(character[19]));
-                }
-
-                if (character.length > 20 && StringUtils.isInt(character[20])) {
-                    skillsXp.put(SkillType.SWORDS, Integer.valueOf(character[20]));
-                }
-
-                if (character.length > 21 && StringUtils.isInt(character[21])) {
-                    skillsXp.put(SkillType.AXES, Integer.valueOf(character[21]));
-                }
-
-                if (character.length > 22 && StringUtils.isInt(character[22])) {
-                    skillsXp.put(SkillType.ACROBATICS, Integer.valueOf(character[22]));
-                }
-
-                if (character.length > 24 && StringUtils.isInt(character[24])) {
-                    skills.put(SkillType.TAMING, Integer.valueOf(character[24]));
-                }
-
-                if (character.length > 25 && StringUtils.isInt(character[25])) {
-                    skillsXp.put(SkillType.TAMING, Integer.valueOf(character[25]));
-                }
-
-                if (character.length > 26) {
-                    skillsDATS.put(AbilityType.BERSERK, Integer.valueOf(character[26]));
-                }
-
-                if (character.length > 27) {
-                    skillsDATS.put(AbilityType.GIGA_DRILL_BREAKER, Integer.valueOf(character[27]));
-                }
-
-                if (character.length > 28) {
-                    skillsDATS.put(AbilityType.TREE_FELLER, Integer.valueOf(character[28]));
-                }
-
-                if (character.length > 29) {
-                    skillsDATS.put(AbilityType.GREEN_TERRA, Integer.valueOf(character[29]));
-                }
-
-                if (character.length > 30) {
-                    skillsDATS.put(AbilityType.SERRATED_STRIKES, Integer.valueOf(character[30]));
-                }
-
-                if (character.length > 31) {
-                    skillsDATS.put(AbilityType.SKULL_SPLITTER, Integer.valueOf(character[31]));
-                }
-
-                if (character.length > 32) {
-                    skillsDATS.put(AbilityType.SUPER_BREAKER, Integer.valueOf(character[32]));
-                }
-
-                if (character.length > 33) {
-                    for (HudType type : HudType.values()) {
-                        if (type.toString().equalsIgnoreCase(character[33])) {
-                            hudType = type;
-                        }
-                    }
-                }
-
-                if (character.length > 34) {
-                    skills.put(SkillType.FISHING, Integer.valueOf(character[34]));
-                }
-
-                if (character.length > 35) {
-                    skillsXp.put(SkillType.FISHING, Integer.valueOf(character[35]));
-                }
-
-                if (character.length > 36) {
-                    skillsDATS.put(AbilityType.BLAST_MINING, Integer.valueOf(character[36]));
-                }
-
-                loaded = true;
-
-                in.close();
-                return true;
-            }
-
-            in.close();
-        }
-        catch (Exception e) {
-            e.printStackTrace();
-        }
-        return false;
-    }
-
-    public void save() {
-        Long timestamp = System.currentTimeMillis();
-
-        // If we are using mysql save to database
-        if (Config.getInstance().getUseMySQL()) {
-            String tablePrefix = Config.getInstance().getMySQLTablePrefix();
-
-            DatabaseManager.write("UPDATE " + tablePrefix + "huds SET hudtype = '" + hudType.toString() + "' WHERE user_id = " + userId);
-            DatabaseManager.write("UPDATE " + tablePrefix + "users SET lastlogin = " + ((int) (timestamp / Misc.TIME_CONVERSION_FACTOR)) + " WHERE id = " + userId);
-            DatabaseManager.write("UPDATE " + tablePrefix + "cooldowns SET "
-                    + " mining = " + skillsDATS.get(AbilityType.SUPER_BREAKER)
-                    + ", woodcutting = " + skillsDATS.get(AbilityType.TREE_FELLER)
-                    + ", unarmed = " + skillsDATS.get(AbilityType.BERSERK)
-                    + ", herbalism = " + skillsDATS.get(AbilityType.GREEN_TERRA)
-                    + ", excavation = " + skillsDATS.get(AbilityType.GIGA_DRILL_BREAKER)
-                    + ", swords = " + skillsDATS.get(AbilityType.SERRATED_STRIKES)
-                    + ", axes = " + skillsDATS.get(AbilityType.SKULL_SPLITTER)
-                    + ", blast_mining = " + skillsDATS.get(AbilityType.BLAST_MINING)
-                    + " WHERE user_id = " + userId);
-            DatabaseManager.write("UPDATE " + tablePrefix + "skills SET "
-                    + " taming = " + skills.get(SkillType.TAMING)
-                    + ", mining = " + skills.get(SkillType.MINING)
-                    + ", repair = " + skills.get(SkillType.REPAIR)
-                    + ", woodcutting = " + skills.get(SkillType.WOODCUTTING)
-                    + ", unarmed = " + skills.get(SkillType.UNARMED)
-                    + ", herbalism = " + skills.get(SkillType.HERBALISM)
-                    + ", excavation = " + skills.get(SkillType.EXCAVATION)
-                    + ", archery = " + skills.get(SkillType.ARCHERY)
-                    + ", swords = " + skills.get(SkillType.SWORDS)
-                    + ", axes = " + skills.get(SkillType.AXES)
-                    + ", acrobatics = " + skills.get(SkillType.ACROBATICS)
-                    + ", fishing = " + skills.get(SkillType.FISHING)
-                    + " WHERE user_id = " + userId);
-            DatabaseManager.write("UPDATE " + tablePrefix + "experience SET "
-                    + "  taming = " + skillsXp.get(SkillType.TAMING)
-                    + ", mining = " + skillsXp.get(SkillType.MINING)
-                    + ", repair = " + skillsXp.get(SkillType.REPAIR)
-                    + ", woodcutting = " + skillsXp.get(SkillType.WOODCUTTING)
-                    + ", unarmed = " + skillsXp.get(SkillType.UNARMED)
-                    + ", herbalism = " + skillsXp.get(SkillType.HERBALISM)
-                    + ", excavation = " + skillsXp.get(SkillType.EXCAVATION)
-                    + ", archery = " + skillsXp.get(SkillType.ARCHERY)
-                    + ", swords = " + skillsXp.get(SkillType.SWORDS)
-                    + ", axes = " + skillsXp.get(SkillType.AXES)
-                    + ", acrobatics = " + skillsXp.get(SkillType.ACROBATICS)
-                    + ", fishing = " + skillsXp.get(SkillType.FISHING)
-                    + " WHERE user_id = " + userId);
-        }
-        else {
-            // Otherwise save to flatfile
-            try {
-                // Open the file
-                FileReader file = new FileReader(location);
-                BufferedReader in = new BufferedReader(file);
-                StringBuilder writer = new StringBuilder();
-                String line;
-
-                // 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)) {
-                        writer.append(line).append("\r\n");
-                    }
-                    else {
-                        // Otherwise write the new player information
-                        writer.append(playerName).append(":");
-                        writer.append(skills.get(SkillType.MINING)).append(":");
-                        writer.append(":");
-                        writer.append(":");
-                        writer.append(skillsXp.get(SkillType.MINING)).append(":");
-                        writer.append(skills.get(SkillType.WOODCUTTING)).append(":");
-                        writer.append(skillsXp.get(SkillType.WOODCUTTING)).append(":");
-                        writer.append(skills.get(SkillType.REPAIR)).append(":");
-                        writer.append(skills.get(SkillType.UNARMED)).append(":");
-                        writer.append(skills.get(SkillType.HERBALISM)).append(":");
-                        writer.append(skills.get(SkillType.EXCAVATION)).append(":");
-                        writer.append(skills.get(SkillType.ARCHERY)).append(":");
-                        writer.append(skills.get(SkillType.SWORDS)).append(":");
-                        writer.append(skills.get(SkillType.AXES)).append(":");
-                        writer.append(skills.get(SkillType.ACROBATICS)).append(":");
-                        writer.append(skillsXp.get(SkillType.REPAIR)).append(":");
-                        writer.append(skillsXp.get(SkillType.UNARMED)).append(":");
-                        writer.append(skillsXp.get(SkillType.HERBALISM)).append(":");
-                        writer.append(skillsXp.get(SkillType.EXCAVATION)).append(":");
-                        writer.append(skillsXp.get(SkillType.ARCHERY)).append(":");
-                        writer.append(skillsXp.get(SkillType.SWORDS)).append(":");
-                        writer.append(skillsXp.get(SkillType.AXES)).append(":");
-                        writer.append(skillsXp.get(SkillType.ACROBATICS)).append(":");
-                        writer.append(":");
-                        writer.append(skills.get(SkillType.TAMING)).append(":");
-                        writer.append(skillsXp.get(SkillType.TAMING)).append(":");
-                        writer.append(skillsDATS.get(AbilityType.BERSERK)).append(":");
-                        writer.append(skillsDATS.get(AbilityType.GIGA_DRILL_BREAKER)).append(":");
-                        writer.append(skillsDATS.get(AbilityType.TREE_FELLER)).append(":");
-                        writer.append(skillsDATS.get(AbilityType.GREEN_TERRA)).append(":");
-                        writer.append(skillsDATS.get(AbilityType.SERRATED_STRIKES)).append(":");
-                        writer.append(skillsDATS.get(AbilityType.SKULL_SPLITTER)).append(":");
-                        writer.append(skillsDATS.get(AbilityType.SUPER_BREAKER)).append(":");
-                        writer.append(hudType.toString()).append(":");
-                        writer.append(skills.get(SkillType.FISHING)).append(":");
-                        writer.append(skillsXp.get(SkillType.FISHING)).append(":");
-                        writer.append(skillsDATS.get(AbilityType.BLAST_MINING)).append(":");
-                        writer.append(System.currentTimeMillis() / Misc.TIME_CONVERSION_FACTOR).append(":");
-                        writer.append("\r\n");
-                    }
-                }
-
-                in.close();
-
-                // Write the new file
-                FileWriter out = new FileWriter(location);
-                out.write(writer.toString());
-                out.flush();
-                out.close();
-            }
-            catch (Exception e) {
-                e.printStackTrace();
-            }
-        }
-    }
-
-    public void addPlayer() {
-        try {
-            // Open the file to write the player
-            FileWriter file = new FileWriter(location, true);
-            BufferedWriter out = new BufferedWriter(file);
-
-            // Add the player to the end
-            out.append(playerName).append(":");
-            out.append("0:"); // Mining
-            out.append(":");
-            out.append(":");
-            out.append("0:"); // Xp
-            out.append("0:"); // Woodcutting
-            out.append("0:"); // WoodCuttingXp
-            out.append("0:"); // Repair
-            out.append("0:"); // Unarmed
-            out.append("0:"); // Herbalism
-            out.append("0:"); // Excavation
-            out.append("0:"); // Archery
-            out.append("0:"); // Swords
-            out.append("0:"); // Axes
-            out.append("0:"); // Acrobatics
-            out.append("0:"); // RepairXp
-            out.append("0:"); // UnarmedXp
-            out.append("0:"); // HerbalismXp
-            out.append("0:"); // ExcavationXp
-            out.append("0:"); // ArcheryXp
-            out.append("0:"); // SwordsXp
-            out.append("0:"); // AxesXp
-            out.append("0:"); // AcrobaticsXp
-            out.append(":");
-            out.append("0:"); // Taming
-            out.append("0:"); // TamingXp
-            out.append("0:"); // DATS
-            out.append("0:"); // DATS
-            out.append("0:"); // DATS
-            out.append("0:"); // DATS
-            out.append("0:"); // DATS
-            out.append("0:"); // DATS
-            out.append("0:"); // DATS
-            out.append(hudType.toString()).append(":"); // HUD
-            out.append("0:"); // Fishing
-            out.append("0:"); // FishingXp
-            out.append("0:"); // Blast Mining
-            out.append(String.valueOf(System.currentTimeMillis() / Misc.TIME_CONVERSION_FACTOR)).append(":"); // LastLogin
-
-            // Add more in the same format as the line above
-
-            out.newLine();
-            out.close();
-        }
-        catch (Exception e) {
-            e.printStackTrace();
-        }
-    }
-
-    /*
-     * mySQL Stuff
-     */
-
-    public int getMySQLuserId() {
-        return userId;
-    }
-
     public boolean isLoaded() {
         return loaded;
     }
@@ -549,6 +85,30 @@ public class PlayerProfile {
         this.hudType = hudType;
     }
 
+    /*
+     * Mob Healthbars
+     */
+
+    public MobHealthbarType getMobHealthbarType() {
+        return mobHealthbarType;
+    }
+
+    public void setMobHealthbarType(MobHealthbarType mobHealthbarType) {
+        this.mobHealthbarType = mobHealthbarType;
+    }
+
+    /*
+     * Scoreboards
+     */
+
+    public Scoreboard getPlayerStatsScoreboard() {
+        return playerStatsScoreboard;
+    }
+
+    public void setPlayerStatsScoreboard(Scoreboard statsScoreboard) {
+        this.playerStatsScoreboard = statsScoreboard;
+    }
+
     /*
      * Cooldowns
      */
@@ -566,7 +126,7 @@ public class PlayerProfile {
     /**
      * Set the current DATS of a skill.
      *
-     * @param abilityType Ability to set the DATS for
+     *  @param abilityType Ability to set the DATS for
      * @param DATS the DATS of the ability
      */
     public void setSkillDATS(AbilityType abilityType, long DATS) {
@@ -579,8 +139,8 @@ public class PlayerProfile {
      * Reset all skill cooldowns.
      */
     public void resetCooldowns() {
-        for (AbilityType x : skillsDATS.keySet()) {
-            skillsDATS.put(x, 0);
+        for (AbilityType ability : skillsDATS.keySet()) {
+            skillsDATS.put(ability, 0);
         }
     }
 
@@ -596,22 +156,15 @@ public class PlayerProfile {
         return skills.get(skillType);
     }
 
-    public int getChildSkillLevel(SkillType skillType) {
-        Set<SkillType> parents = FamilyTree.getParents(skillType);
-        int sum = 0;
-
-        for (SkillType parent : parents) {
-            sum += Math.min(getSkillLevel(parent), 1000);
-        }
-
-        return sum / parents.size();
-    }
-
-    public int getSkillXpLevel(SkillType skillType) {
+    public float getSkillXpLevelRaw(SkillType skillType) {
         return skillsXp.get(skillType);
     }
 
-    public void setSkillXpLevel(SkillType skillType, int newValue) {
+    public int getSkillXpLevel(SkillType skillType) {
+        return (int) Math.floor(getSkillXpLevelRaw(skillType));
+    }
+
+    public void setSkillXpLevel(SkillType skillType, float newValue) {
         if (skillType.isChildSkill()) {
             return;
         }
@@ -649,7 +202,7 @@ public class PlayerProfile {
         }
 
         skills.put(skillType, newValue);
-        skillsXp.put(skillType, 0);
+        skillsXp.put(skillType, 0F);
     }
 
     /**
@@ -664,7 +217,7 @@ public class PlayerProfile {
         }
 
         skills.put(skillType, skills.get(skillType) + levels);
-        skillsXp.put(skillType, 0);
+        skillsXp.put(skillType, 0F);
     }
 
     /**
@@ -688,6 +241,81 @@ public class PlayerProfile {
      * @return the Xp remaining until next level
      */
     public int getXpToLevel(SkillType skillType) {
-        return 1020 + (skills.get(skillType) *  Config.getInstance().getFormulaMultiplierCurve());
+        return 1020 + (skills.get(skillType) * Config.getInstance().getFormulaMultiplierCurve());
+    }
+
+    private int getChildSkillLevel(SkillType skillType) {
+        Set<SkillType> parents = FamilyTree.getParents(skillType);
+        int sum = 0;
+
+        for (SkillType parent : parents) {
+            sum += Math.min(getSkillLevel(parent), 1000);
+        }
+
+        return sum / parents.size();
+    }
+
+    private boolean loadPlayer() {
+        List<String> playerData = mcMMO.getDatabaseManager().loadPlayerData(playerName);
+        
+        if (playerData == null || playerData.isEmpty()) {
+            return false;
+        }
+
+        skills.put(SkillType.TAMING, Integer.valueOf(playerData.get(0)));
+        skills.put(SkillType.MINING, Integer.valueOf(playerData.get(1)));
+        skills.put(SkillType.REPAIR, Integer.valueOf(playerData.get(2)));
+        skills.put(SkillType.WOODCUTTING, Integer.valueOf(playerData.get(3)));
+        skills.put(SkillType.UNARMED, Integer.valueOf(playerData.get(4)));
+        skills.put(SkillType.HERBALISM, Integer.valueOf(playerData.get(5)));
+        skills.put(SkillType.EXCAVATION, Integer.valueOf(playerData.get(6)));
+        skills.put(SkillType.ARCHERY, Integer.valueOf(playerData.get(7)));
+        skills.put(SkillType.SWORDS, Integer.valueOf(playerData.get(8)));
+        skills.put(SkillType.AXES, Integer.valueOf(playerData.get(9)));
+        skills.put(SkillType.ACROBATICS, Integer.valueOf(playerData.get(10)));
+        skills.put(SkillType.FISHING, Integer.valueOf(playerData.get(11)));
+
+        skillsXp.put(SkillType.TAMING, (float) Integer.valueOf(playerData.get(12)));
+        skillsXp.put(SkillType.MINING, (float) Integer.valueOf(playerData.get(13)));
+        skillsXp.put(SkillType.REPAIR, (float) Integer.valueOf(playerData.get(14)));
+        skillsXp.put(SkillType.WOODCUTTING, (float) Integer.valueOf(playerData.get(15)));
+        skillsXp.put(SkillType.UNARMED, (float) Integer.valueOf(playerData.get(16)));
+        skillsXp.put(SkillType.HERBALISM, (float) Integer.valueOf(playerData.get(17)));
+        skillsXp.put(SkillType.EXCAVATION, (float) Integer.valueOf(playerData.get(18)));
+        skillsXp.put(SkillType.ARCHERY, (float) Integer.valueOf(playerData.get(19)));
+        skillsXp.put(SkillType.SWORDS, (float) Integer.valueOf(playerData.get(20)));
+        skillsXp.put(SkillType.AXES, (float) Integer.valueOf(playerData.get(21)));
+        skillsXp.put(SkillType.ACROBATICS, (float) Integer.valueOf(playerData.get(22)));
+        skillsXp.put(SkillType.FISHING, (float) Integer.valueOf(playerData.get(23)));
+
+        // Taming 24 - Unused
+        skillsDATS.put(AbilityType.SUPER_BREAKER, Integer.valueOf(playerData.get(25)));
+        // Repair 26 - Unused
+        skillsDATS.put(AbilityType.TREE_FELLER, Integer.valueOf(playerData.get(27)));
+        skillsDATS.put(AbilityType.BERSERK, Integer.valueOf(playerData.get(28)));
+        skillsDATS.put(AbilityType.GREEN_TERRA, Integer.valueOf(playerData.get(29)));
+        skillsDATS.put(AbilityType.GIGA_DRILL_BREAKER, Integer.valueOf(playerData.get(30)));
+        // Archery 31 - Unused
+        skillsDATS.put(AbilityType.SERRATED_STRIKES, Integer.valueOf(playerData.get(32)));
+        skillsDATS.put(AbilityType.SKULL_SPLITTER, Integer.valueOf(playerData.get(33)));
+        // Acrobatics 34 - Unused
+        skillsDATS.put(AbilityType.BLAST_MINING, Integer.valueOf(playerData.get(35)));
+
+        try {
+            hudType = HudType.valueOf(playerData.get(36));
+        }
+        catch (Exception e) {
+            hudType = HudType.STANDARD; // Shouldn't happen unless database is being tampered with
+        }
+
+        try {
+            mobHealthbarType = MobHealthbarType.valueOf(playerData.get(37));
+        }
+        catch (Exception e) {
+            mobHealthbarType = Config.getInstance().getMobHealthbarDefault();
+        }
+
+        loaded = true;
+        return true;
     }
 }

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

@@ -68,6 +68,13 @@ public enum AbilityType {
             null),
 
     LEAF_BLOWER(
+            null,
+            null,
+            null,
+            null,
+            null),
+
+    BLOCK_CRACKER(
             null,
             null,
             null,
@@ -144,7 +151,6 @@ public enum AbilityType {
      * @return true if the player has permissions, false otherwise
      */
     public boolean getPermissions(Player player) {
-
         switch (this) {
             case BERSERK:
                 return Permissions.berserk(player);
@@ -152,6 +158,9 @@ public enum AbilityType {
             case BLAST_MINING:
                 return Permissions.remoteDetonation(player);
 
+            case BLOCK_CRACKER:
+                return Permissions.blockCracker(player);
+
             case GIGA_DRILL_BREAKER:
                 return Permissions.gigaDrillBreaker(player);
 
@@ -189,6 +198,9 @@ public enum AbilityType {
             case BERSERK:
                 return (BlockUtils.affectedByGigaDrillBreaker(blockState) || blockState.getType() == Material.SNOW);
 
+            case BLOCK_CRACKER:
+                return BlockUtils.affectedByBlockCracker(blockState);
+
             case GIGA_DRILL_BREAKER:
                 return BlockUtils.affectedByGigaDrillBreaker(blockState);
 

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

@@ -1,5 +1,9 @@
 package com.gmail.nossr50.datatypes.skills;
 
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
 import org.bukkit.Color;
 
 import com.gmail.nossr50.mcMMO;
@@ -20,6 +24,8 @@ import com.gmail.nossr50.skills.taming.TamingManager;
 import com.gmail.nossr50.skills.unarmed.UnarmedManager;
 import com.gmail.nossr50.skills.woodcutting.WoodcuttingManager;
 import com.gmail.nossr50.util.StringUtils;
+import com.gmail.nossr50.util.skills.SkillUtils;
+import com.google.common.collect.ImmutableList;
 
 public enum SkillType {
     ACROBATICS(AcrobaticsManager.class, Color.WHITE),
@@ -41,6 +47,19 @@ public enum SkillType {
     private AbilityType ability;
     private ToolType tool;
 
+    public static final List<String> SKILL_NAMES;
+
+    static {
+        ArrayList<String> names = new ArrayList<String>();
+
+        for (SkillType skill : values()) {
+            names.add(SkillUtils.getSkillName(skill));
+        }
+
+        Collections.sort(names);
+        SKILL_NAMES = ImmutableList.copyOf(names);
+    }
+
     private SkillType(Class<? extends SkillManager> managerClass, Color runescapeColor) {
         this.managerClass = managerClass;
         this.runescapeColor = runescapeColor;
@@ -89,7 +108,7 @@ public enum SkillType {
     }
 
     public double getXpModifier() {
-        return Config.getInstance().getForumulaMultiplier(this);
+        return Config.getInstance().getFormulaSkillModifier(this);
     }
 
     public static SkillType getSkill(String skillName) {
@@ -122,7 +141,36 @@ public enum SkillType {
         }
     }
 
+    public static SkillType[] nonChildSkills() {
+        return new SkillType[] {SkillType.ACROBATICS,
+                SkillType.ARCHERY,
+                SkillType.AXES,
+                SkillType.EXCAVATION,
+                SkillType.FISHING,
+                SkillType.HERBALISM,
+                SkillType.MINING,
+                SkillType.REPAIR,
+                SkillType.SWORDS,
+                SkillType.TAMING,
+                SkillType.UNARMED,
+                SkillType.WOODCUTTING };
+    }
+
+    public static SkillType[] childSkills() {
+        return new SkillType[] { SkillType.SMELTING };
+    }
+
     public Color getRunescapeModeColor() {
         return runescapeColor;
     }
+
+    public static SkillType byAbility(AbilityType ability) {
+        for (SkillType type : values()) {
+            if (type.getAbility() == ability) {
+                return type;
+            }
+        }
+
+        return null;
+    }
 }

src/main/java/com/gmail/nossr50/datatypes/spout/huds/McMMOHud.java

@@ -56,11 +56,7 @@ public class McMMOHud {
     }
 
     public boolean isMenuOpened() {
-        if (menu != null) {
-            return true;
-        }
-
-        return false;
+        return (menu != null);
     }
 
     public void openMenu() {

src/main/java/com/gmail/nossr50/datatypes/treasure/ShakeTreasure.java

@@ -0,0 +1,21 @@
+package com.gmail.nossr50.datatypes.treasure;
+
+import org.bukkit.entity.EntityType;
+import org.bukkit.inventory.ItemStack;
+
+public class ShakeTreasure extends Treasure {
+    private EntityType mob;
+
+    public ShakeTreasure(ItemStack drop, int xp, double dropChance, int dropLevel, EntityType mob) {
+        super(drop, xp, dropChance, dropLevel);
+        this.mob = mob;
+    }
+
+    public EntityType getMob() {
+        return mob;
+    }
+
+    public void setMob(EntityType mob) {
+        this.mob = mob;
+    }
+}

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

@@ -20,6 +20,14 @@ public class McMMOPlayerLevelUpEvent extends McMMOPlayerExperienceEvent {
         this.levelsGained = levelsGained;
     }
 
+    /**
+     * @param levelsGained 
+     * @return Set the number of levels gained in this event
+     */
+    public void setLevelsGained(int levelsGained) {
+        this.levelsGained = levelsGained;
+    }
+
     /**
      * @return The number of levels gained in this event
      */

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

@@ -8,9 +8,9 @@ import com.gmail.nossr50.datatypes.skills.SkillType;
  * Called when a player gains XP in a skill
  */
 public class McMMOPlayerXpGainEvent extends McMMOPlayerExperienceEvent {
-    private int xpGained;
+    private float xpGained;
 
-    public McMMOPlayerXpGainEvent(Player player, SkillType skill, int xpGained) {
+    public McMMOPlayerXpGainEvent(Player player, SkillType skill, float xpGained) {
         super(player, skill);
         this.xpGained = xpGained;
     }
@@ -18,13 +18,29 @@ public class McMMOPlayerXpGainEvent extends McMMOPlayerExperienceEvent {
     /**
      * @return The amount of experience gained in this event
      */
-    public int getXpGained() {
+    public float getRawXpGained() {
         return xpGained;
     }
 
     /**
      * @param xpGained int amount of experience gained in this event
      */
+    @Deprecated
+    public int getXpGained() {
+        return (int) xpGained;
+    }
+
+    /**
+     * @param xpGained int amount of experience gained in this event
+     */
+    public void setRawXpGained(float xpGained) {
+        this.xpGained = xpGained;
+    }
+
+    /**
+     * @param xpGained int amount of experience gained in this event
+     */
+    @Deprecated
     public void setXpGained(int xpGained) {
         this.xpGained = xpGained;
     }

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

@@ -0,0 +1,12 @@
+package com.gmail.nossr50.events.fake;
+
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Fish;
+import org.bukkit.entity.Player;
+import org.bukkit.event.player.PlayerFishEvent;
+
+public class FakePlayerFishEvent extends PlayerFishEvent {
+    public FakePlayerFishEvent(Player player, Entity entity, Fish hookEntity, State state) {
+        super(player, entity, hookEntity, state);
+    }
+}

src/main/java/com/gmail/nossr50/events/skills/abilities/McMMOPlayerAbilityActivateEvent.java

@@ -0,0 +1,35 @@
+package com.gmail.nossr50.events.skills.abilities;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.Cancellable;
+
+import com.gmail.nossr50.datatypes.skills.AbilityType;
+import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.events.skills.McMMOPlayerSkillEvent;
+
+public class McMMOPlayerAbilityActivateEvent extends McMMOPlayerSkillEvent implements Cancellable {
+
+    private AbilityType abilityType;
+    private boolean cancelled;
+
+    public McMMOPlayerAbilityActivateEvent(Player player, SkillType skill) {
+        super(player, skill);
+        abilityType = skill.getAbility();
+        cancelled = false;
+    }
+
+    /**
+     * @return The ability type involved in this event
+     */
+    public AbilityType getAbilityType() {
+        return abilityType;
+    }
+
+    public boolean isCancelled() {
+        return cancelled;
+    }
+
+    public void setCancelled(boolean value) {
+        this.cancelled = value;
+    }
+}

src/main/java/com/gmail/nossr50/events/skills/abilities/McMMOPlayerAbilityDeactivateEvent.java

@@ -0,0 +1,22 @@
+package com.gmail.nossr50.events.skills.abilities;
+
+import org.bukkit.entity.Player;
+
+import com.gmail.nossr50.datatypes.skills.AbilityType;
+import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.events.skills.McMMOPlayerSkillEvent;
+
+public class McMMOPlayerAbilityDeactivateEvent extends McMMOPlayerSkillEvent {
+
+    private AbilityType ability;
+
+    public McMMOPlayerAbilityDeactivateEvent(Player player, SkillType skill) {
+        super(player, skill);
+        this.ability = skill.getAbility();
+    }
+
+    public AbilityType getAbility() {
+        return ability;
+    }
+
+}

src/main/java/com/gmail/nossr50/events/skills/fishing/McMMOPlayerFishingTreasureEvent.java

@@ -0,0 +1,45 @@
+package com.gmail.nossr50.events.skills.fishing;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.Cancellable;
+import org.bukkit.inventory.ItemStack;
+
+import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.events.skills.McMMOPlayerSkillEvent;
+
+public class McMMOPlayerFishingTreasureEvent extends McMMOPlayerSkillEvent implements Cancellable {
+
+    private boolean cancelled = false;
+    private ItemStack treasure;
+    private int xp;
+
+    public McMMOPlayerFishingTreasureEvent(Player player, ItemStack treasure, int xp) {
+        super(player, SkillType.FISHING);
+        this.treasure = treasure;
+        this.xp = xp;
+    }
+
+    public ItemStack getTreasure() {
+        return treasure;
+    }
+
+    public void setTreasure(ItemStack item) {
+        this.treasure = item;
+    }
+
+    public boolean isCancelled() {
+        return cancelled;
+    }
+
+    public void setCancelled(boolean newValue) {
+        this.cancelled = newValue;
+    }
+
+    public int getXp() {
+        return xp;
+    }
+
+    public void setXp(int xp) {
+        this.xp = xp;
+    }
+}

src/main/java/com/gmail/nossr50/events/skills/fishing/McMMOPlayerMagicHunterEvent.java

@@ -0,0 +1,21 @@
+package com.gmail.nossr50.events.skills.fishing;
+
+import java.util.Map;
+
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+
+public class McMMOPlayerMagicHunterEvent extends McMMOPlayerFishingTreasureEvent {
+
+    private Map<Enchantment, Integer> enchants;
+
+    public McMMOPlayerMagicHunterEvent(Player player, ItemStack treasure, int xp, Map<Enchantment, Integer> enchants) {
+        super(player, treasure, xp);
+        this.enchants = enchants;
+    }
+
+    public Map<Enchantment, Integer> getEnchantments() {
+        return enchants;
+    }
+}

src/main/java/com/gmail/nossr50/events/skills/fishing/McMMOPlayerShakeEvent.java

@@ -0,0 +1,36 @@
+package com.gmail.nossr50.events.skills.fishing;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.Cancellable;
+import org.bukkit.inventory.ItemStack;
+
+import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.events.skills.McMMOPlayerSkillEvent;
+
+public class McMMOPlayerShakeEvent extends McMMOPlayerSkillEvent implements Cancellable {
+
+    private boolean cancelled = false;
+    private ItemStack drop;
+
+    public McMMOPlayerShakeEvent(Player player, ItemStack drop) {
+        super(player, SkillType.FISHING);
+        this.drop = drop;
+    }
+
+    public boolean isCancelled() {
+        return cancelled;
+    }
+
+    public void setCancelled(boolean newValue) {
+        this.cancelled = newValue;
+    }
+
+    public ItemStack getDrop() {
+        return drop;
+    }
+
+    public void setDrop(ItemStack drop) {
+        this.drop = drop;
+    }
+
+}

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

@@ -28,14 +28,12 @@ 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.events.fake.FakePlayerAnimationEvent;
 import com.gmail.nossr50.runnables.StickyPistonTrackerTask;
 import com.gmail.nossr50.skills.excavation.ExcavationManager;
 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.smelting.SmeltingManager;
-import com.gmail.nossr50.skills.unarmed.UnarmedManager;
 import com.gmail.nossr50.skills.woodcutting.WoodcuttingManager;
 import com.gmail.nossr50.util.BlockUtils;
 import com.gmail.nossr50.util.ItemUtils;
@@ -63,18 +61,20 @@ public class BlockListener implements Listener {
         Block futureEmptyBlock = event.getBlock().getRelative(direction); // Block that would be air after piston is finished
 
         for (Block b : blocks) {
-            if (BlockUtils.shouldBeWatched(b.getState()) && mcMMO.placeStore.isTrue(b)) {
+            if (BlockUtils.shouldBeWatched(b.getState()) && mcMMO.getPlaceStore().isTrue(b)) {
                 b.getRelative(direction).setMetadata(mcMMO.blockMetadataKey, mcMMO.metadataValue);
                 if (b.equals(futureEmptyBlock)) {
-                    mcMMO.placeStore.setFalse(b);
+                    mcMMO.getPlaceStore().setFalse(b);
                 }
             }
         }
 
         for (Block b : blocks) {
-            if (b.getRelative(direction).hasMetadata(mcMMO.blockMetadataKey)) {
-                mcMMO.placeStore.setTrue(b.getRelative(direction));
-                b.getRelative(direction).removeMetadata(mcMMO.blockMetadataKey, plugin);
+            Block nextBlock = b.getRelative(direction);
+
+            if (nextBlock.hasMetadata(mcMMO.blockMetadataKey)) {
+                mcMMO.getPlaceStore().setTrue(nextBlock);
+                nextBlock.removeMetadata(mcMMO.blockMetadataKey, plugin);
             }
         }
     }
@@ -106,15 +106,14 @@ public class BlockListener implements Listener {
         }
 
         BlockState blockState = event.getBlock().getState();
-        int blockId = blockState.getTypeId();
 
         /* Check if the blocks placed should be monitored so they do not give out XP in the future */
         if (BlockUtils.shouldBeWatched(blockState)) {
-            mcMMO.placeStore.setTrue(blockState);
+            mcMMO.getPlaceStore().setTrue(blockState);
         }
 
-        if (Repair.anvilMessagesEnabled && (blockId == Repair.repairAnvilId || blockId == Repair.salvageAnvilId)) {
-            UserManager.getPlayer(player).getRepairManager().placedAnvilCheck(blockId);
+        if (Repair.anvilMessagesEnabled && BlockUtils.isMcMMOAnvil(blockState)) {
+            UserManager.getPlayer(player).getRepairManager().placedAnvilCheck(blockState.getTypeId());
         }
     }
 
@@ -163,13 +162,13 @@ public class BlockListener implements Listener {
         }
 
         /* MINING */
-        else if (BlockUtils.affectedBySuperBreaker(blockState) && ItemUtils.isPickaxe(heldItem) && Permissions.skillEnabled(player, SkillType.MINING) && !mcMMO.placeStore.isTrue(blockState)) {
+        else if (BlockUtils.affectedBySuperBreaker(blockState) && ItemUtils.isPickaxe(heldItem) && Permissions.skillEnabled(player, SkillType.MINING) && !mcMMO.getPlaceStore().isTrue(blockState)) {
             MiningManager miningManager = mcMMOPlayer.getMiningManager();
             miningManager.miningBlockCheck(blockState);
         }
 
         /* WOOD CUTTING */
-        else if (BlockUtils.isLog(blockState) && Permissions.skillEnabled(player, SkillType.WOODCUTTING) && !mcMMO.placeStore.isTrue(blockState)) {
+        else if (BlockUtils.isLog(blockState) && Permissions.skillEnabled(player, SkillType.WOODCUTTING) && !mcMMO.getPlaceStore().isTrue(blockState)) {
             WoodcuttingManager woodcuttingManager = mcMMOPlayer.getWoodcuttingManager();
 
             if (woodcuttingManager.canUseTreeFeller(heldItem)) {
@@ -181,7 +180,7 @@ public class BlockListener implements Listener {
         }
 
         /* EXCAVATION */
-        else if (BlockUtils.affectedByGigaDrillBreaker(blockState) && ItemUtils.isShovel(heldItem) && Permissions.skillEnabled(player, SkillType.EXCAVATION) && !mcMMO.placeStore.isTrue(blockState)) {
+        else if (BlockUtils.affectedByGigaDrillBreaker(blockState) && ItemUtils.isShovel(heldItem) && Permissions.skillEnabled(player, SkillType.EXCAVATION) && !mcMMO.getPlaceStore().isTrue(blockState)) {
             ExcavationManager excavationManager = mcMMOPlayer.getExcavationManager();
             excavationManager.excavationBlockCheck(blockState);
 
@@ -191,7 +190,7 @@ public class BlockListener implements Listener {
         }
 
         /* Remove metadata from placed watched blocks */
-        mcMMO.placeStore.setFalse(blockState);
+        mcMMO.getPlaceStore().setFalse(blockState);
     }
 
     /**
@@ -298,7 +297,7 @@ public class BlockListener implements Listener {
          * We don't need to check permissions here because they've already been checked for the ability to even activate.
          */
         if (mcMMOPlayer.getAbilityMode(AbilityType.TREE_FELLER) && BlockUtils.isLog(blockState)) {
-            player.playSound(blockState.getLocation(), Sound.FIZZ, Misc.FIZZ_VOLUME, Misc.FIZZ_PITCH);
+            player.playSound(blockState.getLocation(), Sound.FIZZ, Misc.FIZZ_VOLUME, Misc.getFizzPitch());
         }
     }
 
@@ -323,41 +322,31 @@ public class BlockListener implements Listener {
         ItemStack heldItem = player.getItemInHand();
         Block block = event.getBlock();
         BlockState blockState = block.getState();
-        HerbalismManager herbalismManager = mcMMOPlayer.getHerbalismManager();
 
         /*
          * ABILITY TRIGGER CHECKS
          *
          * We don't need to check permissions here because they've already been checked for the ability to even activate.
          */
-        if (herbalismManager.canGreenTerraBlock(blockState)) {
-            if (herbalismManager.processGreenTerra(blockState)) {
+        if (mcMMOPlayer.getAbilityMode(AbilityType.GREEN_TERRA) && BlockUtils.canMakeMossy(blockState)) {
+            if (mcMMOPlayer.getHerbalismManager().processGreenTerra(blockState)) {
                 blockState.update(true);
             }
         }
-        else if (mcMMOPlayer.getAbilityMode(AbilityType.BERSERK)) {
+        else if (mcMMOPlayer.getAbilityMode(AbilityType.BERSERK) && heldItem.getType() == Material.AIR) {
             if (SkillUtils.triggerCheck(player, block, AbilityType.BERSERK)) {
-                if (heldItem.getType() == Material.AIR) {
-                    plugin.getServer().getPluginManager().callEvent(new FakePlayerAnimationEvent(player));
-
-                    event.setInstaBreak(true);
-                    player.playSound(block.getLocation(), Sound.ITEM_PICKUP, Misc.POP_VOLUME, Misc.POP_PITCH);
-                }
+                event.setInstaBreak(true);
+                player.playSound(block.getLocation(), Sound.ITEM_PICKUP, Misc.POP_VOLUME, Misc.getPopPitch());
             }
-            // Another perm check for the cracked blocks activation
-            else if (BlockUtils.affectedByBlockCracker(blockState)) {
-                UnarmedManager unarmedManager = mcMMOPlayer.getUnarmedManager();
-
-                if (unarmedManager.canUseBlockCracker() && SkillUtils.blockBreakSimulate(block, player, false) && unarmedManager.blockCrackerCheck(blockState)) {
+            else if (Permissions.blockCracker(player) && SkillUtils.triggerCheck(player, block, AbilityType.BLOCK_CRACKER)) {
+                if (mcMMOPlayer.getUnarmedManager().blockCrackerCheck(blockState)) {
                     blockState.update();
                 }
             }
         }
-        else if (BlockUtils.isLeaves(blockState)) {
-            if (mcMMOPlayer.getWoodcuttingManager().canUseLeafBlower(heldItem) && SkillUtils.blockBreakSimulate(block, player, true)) {
-                event.setInstaBreak(true);
-                player.playSound(blockState.getLocation(), Sound.ITEM_PICKUP, Misc.POP_VOLUME, Misc.POP_PITCH);
-            }
+        else if (mcMMOPlayer.getWoodcuttingManager().canUseLeafBlower(heldItem) && SkillUtils.triggerCheck(player, block, AbilityType.LEAF_BLOWER)) {
+            event.setInstaBreak(true);
+            player.playSound(blockState.getLocation(), Sound.ITEM_PICKUP, Misc.POP_VOLUME, Misc.getPopPitch());
         }
     }
 }

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

@@ -2,7 +2,9 @@ package com.gmail.nossr50.listeners;
 
 import org.bukkit.OfflinePlayer;
 import org.bukkit.block.Block;
+import org.bukkit.enchantments.Enchantment;
 import org.bukkit.entity.AnimalTamer;
+import org.bukkit.entity.Arrow;
 import org.bukkit.entity.Entity;
 import org.bukkit.entity.FallingBlock;
 import org.bukkit.entity.LivingEntity;
@@ -15,19 +17,23 @@ import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
 import org.bukkit.event.Listener;
 import org.bukkit.event.entity.CreatureSpawnEvent;
-import org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason;
 import org.bukkit.event.entity.EntityChangeBlockEvent;
 import org.bukkit.event.entity.EntityDamageByEntityEvent;
 import org.bukkit.event.entity.EntityDamageEvent;
 import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
 import org.bukkit.event.entity.EntityDeathEvent;
 import org.bukkit.event.entity.EntityExplodeEvent;
+import org.bukkit.event.entity.EntityShootBowEvent;
 import org.bukkit.event.entity.EntityTameEvent;
 import org.bukkit.event.entity.EntityTargetEvent;
 import org.bukkit.event.entity.ExplosionPrimeEvent;
 import org.bukkit.event.entity.FoodLevelChangeEvent;
+import org.bukkit.event.entity.ProjectileLaunchEvent;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.metadata.FixedMetadataValue;
 
 import com.gmail.nossr50.mcMMO;
+import com.gmail.nossr50.config.AdvancedConfig;
 import com.gmail.nossr50.datatypes.player.McMMOPlayer;
 import com.gmail.nossr50.events.fake.FakeEntityDamageByEntityEvent;
 import com.gmail.nossr50.events.fake.FakeEntityDamageEvent;
@@ -52,13 +58,43 @@ public class EntityListener implements Listener {
         this.plugin = plugin;
     }
 
+    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+    public void onEntityShootBow(EntityShootBowEvent event) {
+        Entity projectile = event.getProjectile();
+
+        if (!(projectile instanceof Arrow)) {
+            return;
+        }
+
+        ItemStack bow = event.getBow();
+
+        if (bow != null && bow.containsEnchantment(Enchantment.ARROW_INFINITE)) {
+            projectile.setMetadata(mcMMO.infiniteArrowKey, mcMMO.metadataValue);
+        }
+
+        projectile.setMetadata(mcMMO.bowForceKey, new FixedMetadataValue(plugin, Math.min(event.getForce() * AdvancedConfig.getInstance().getForceMultiplier(), 1.0)));
+        projectile.setMetadata(mcMMO.arrowDistanceKey, new FixedMetadataValue(plugin, Archery.locationToString(projectile.getLocation())));
+    }
+
+    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+    public void onProjectileLaunch(ProjectileLaunchEvent event) {
+        Projectile projectile = event.getEntity();
+
+        if (!(projectile instanceof Arrow) || projectile.hasMetadata(mcMMO.bowForceKey)) {
+            return;
+        }
+
+        projectile.setMetadata(mcMMO.bowForceKey, new FixedMetadataValue(plugin, 1.0));
+        projectile.setMetadata(mcMMO.arrowDistanceKey, new FixedMetadataValue(plugin, Archery.locationToString(projectile.getLocation())));
+    }
+
     /**
      * Monitor EntityChangeBlock events.
      *
      * @param event The event to watch
      */
     @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
-    public void onEntityChangeBlockEvent(EntityChangeBlockEvent event) {
+    public void onEntityChangeBlock(EntityChangeBlockEvent event) {
         Entity entity = event.getEntity();
 
         if (!(entity instanceof FallingBlock)) {
@@ -68,12 +104,12 @@ public class EntityListener implements Listener {
         Block block = event.getBlock();
         boolean isTracked = entity.hasMetadata(mcMMO.entityMetadataKey);
 
-        if (mcMMO.placeStore.isTrue(block) && !isTracked) {
-            mcMMO.placeStore.setFalse(block);
+        if (mcMMO.getPlaceStore().isTrue(block) && !isTracked) {
+            mcMMO.getPlaceStore().setFalse(block);
             entity.setMetadata(mcMMO.entityMetadataKey, mcMMO.metadataValue);
         }
         else if (isTracked) {
-            mcMMO.placeStore.setTrue(block);
+            mcMMO.getPlaceStore().setTrue(block);
         }
     }
 
@@ -84,7 +120,13 @@ public class EntityListener implements Listener {
      */
     @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
     public void onEntityDamageByEntity(EntityDamageByEntityEvent event) {
-        if (event instanceof FakeEntityDamageByEntityEvent || event.getDamage() <= 0) {
+        if (event instanceof FakeEntityDamageByEntityEvent) {
+            return;
+        }
+
+        int damage = event.getDamage();
+
+        if (damage <= 0) {
             return;
         }
 
@@ -94,13 +136,14 @@ public class EntityListener implements Listener {
             return;
         }
 
-        Entity attacker = event.getDamager();
         LivingEntity target = (LivingEntity) defender;
 
-        if (CombatUtils.isInvincible(target, event.getDamage())) {
+        if (CombatUtils.isInvincible(target, damage)) {
             return;
         }
 
+        Entity attacker = event.getDamager();
+
         if (attacker instanceof Projectile) {
             attacker = ((Projectile) attacker).getShooter();
         }
@@ -127,7 +170,7 @@ public class EntityListener implements Listener {
             }
         }
 
-        CombatUtils.combatChecks(event, attacker, target);
+        CombatUtils.processCombatAttack(event, attacker, target);
     }
 
     /**
@@ -137,7 +180,13 @@ public class EntityListener implements Listener {
      */
     @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
     public void onEntityDamage(EntityDamageEvent event) {
-        if (event instanceof FakeEntityDamageEvent || event.getDamage() <= 0) {
+        if (event instanceof FakeEntityDamageEvent) {
+            return;
+        }
+
+        int damage = event.getDamage();
+
+        if (damage <= 0) {
             return;
         }
 
@@ -147,13 +196,14 @@ public class EntityListener implements Listener {
             return;
         }
 
-        DamageCause cause = event.getCause();
         LivingEntity livingEntity = (LivingEntity) entity;
 
-        if (CombatUtils.isInvincible(livingEntity, event.getDamage())) {
+        if (CombatUtils.isInvincible(livingEntity, damage)) {
             return;
         }
 
+        DamageCause cause = event.getCause();
+
         if (livingEntity instanceof Player) {
             Player player = (Player) entity;
 
@@ -273,6 +323,30 @@ public class EntityListener implements Listener {
         }
     }
 
+    /**
+     * Monitor EntityDeath events.
+     *
+     * @param event The event to watch
+     */
+    @EventHandler(priority = EventPriority.LOWEST)
+    public void onEntityDeathLowest(EntityDeathEvent event) {
+        LivingEntity entity = event.getEntity();
+
+        if (Misc.isNPCEntity(entity)) {
+            return;
+        }
+
+        if (entity.hasMetadata(mcMMO.customNameKey)) {
+            entity.setCustomName(entity.getMetadata(mcMMO.customNameKey).get(0).asString());
+            entity.removeMetadata(mcMMO.customNameKey, mcMMO.p);
+        }
+
+        if (entity.hasMetadata(mcMMO.customVisibleKey)) {
+            entity.setCustomNameVisible(entity.getMetadata(mcMMO.customVisibleKey).get(0).asBoolean());
+            entity.removeMetadata(mcMMO.customVisibleKey, mcMMO.p);
+        }
+    }
+
     /**
      * Monitor EntityDeath events.
      *
@@ -286,7 +360,6 @@ public class EntityListener implements Listener {
             return;
         }
 
-        entity.setFireTicks(0);
         BleedTimerTask.remove(entity);
         Archery.arrowRetrievalCheck(entity);
     }
@@ -298,14 +371,21 @@ public class EntityListener implements Listener {
      */
     @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
     public void onCreatureSpawn(CreatureSpawnEvent event) {
-        if (Misc.isSpawnerXPEnabled) {
-            return;
-        }
+        switch (event.getSpawnReason()) {
+            case SPAWNER:
+            case SPAWNER_EGG:
+                LivingEntity entity = event.getEntity();
+                Entity passenger = entity.getPassenger();
 
-        SpawnReason reason = event.getSpawnReason();
+                entity.setMetadata(mcMMO.entityMetadataKey, mcMMO.metadataValue);
 
-        if (reason == SpawnReason.SPAWNER || reason == SpawnReason.SPAWNER_EGG) {
-            event.getEntity().setMetadata(mcMMO.entityMetadataKey, mcMMO.metadataValue);
+                if (passenger != null) {
+                    passenger.setMetadata(mcMMO.entityMetadataKey, mcMMO.metadataValue);
+                }
+                return;
+
+            default:
+                return;
         }
     }
 
@@ -318,19 +398,21 @@ public class EntityListener implements Listener {
     public void onExplosionPrime(ExplosionPrimeEvent event) {
         Entity entity = event.getEntity();
 
-        if (entity instanceof TNTPrimed && entity.hasMetadata(mcMMO.tntMetadataKey)) {
-            // We can make this assumption because we (should) be the only ones using this exact metadata
-            Player player = plugin.getServer().getPlayer(entity.getMetadata(mcMMO.tntMetadataKey).get(0).asString());
+        if (!(entity instanceof TNTPrimed) || !entity.hasMetadata(mcMMO.tntMetadataKey)) {
+            return;
+        }
 
-            if (Misc.isNPCEntity(player)) {
-                return;
-            }
+        // We can make this assumption because we (should) be the only ones using this exact metadata
+        Player player = plugin.getServer().getPlayer(entity.getMetadata(mcMMO.tntMetadataKey).get(0).asString());
 
-            MiningManager miningManager = UserManager.getPlayer(player).getMiningManager();
+        if (Misc.isNPCEntity(player)) {
+            return;
+        }
 
-            if (miningManager.canUseBiggerBombs()) {
-                event.setRadius(miningManager.biggerBombs(event.getRadius()));
-            }
+        MiningManager miningManager = UserManager.getPlayer(player).getMiningManager();
+
+        if (miningManager.canUseBiggerBombs()) {
+            event.setRadius(miningManager.biggerBombs(event.getRadius()));
         }
     }
 
@@ -343,20 +425,22 @@ public class EntityListener implements Listener {
     public void onEnitityExplode(EntityExplodeEvent event) {
         Entity entity = event.getEntity();
 
-        if (entity instanceof TNTPrimed && entity.hasMetadata(mcMMO.tntMetadataKey)) {
-            // We can make this assumption because we (should) be the only ones using this exact metadata
-            Player player = plugin.getServer().getPlayer(entity.getMetadata(mcMMO.tntMetadataKey).get(0).asString());
+        if (!(entity instanceof TNTPrimed) || !entity.hasMetadata(mcMMO.tntMetadataKey)) {
+            return;
+        }
 
-            if (Misc.isNPCEntity(player)) {
-                return;
-            }
+        // We can make this assumption because we (should) be the only ones using this exact metadata
+        Player player = plugin.getServer().getPlayer(entity.getMetadata(mcMMO.tntMetadataKey).get(0).asString());
 
-            MiningManager miningManager = UserManager.getPlayer(player).getMiningManager();
+        if (Misc.isNPCEntity(player)) {
+            return;
+        }
 
-            if (miningManager.canUseBlastMining()) {
-                miningManager.blastMiningDropProcessing(event.getYield(), event.blockList());
-                event.setYield(0);
-            }
+        MiningManager miningManager = UserManager.getPlayer(player).getMiningManager();
+
+        if (miningManager.canUseBlastMining()) {
+            miningManager.blastMiningDropProcessing(event.getYield(), event.blockList());
+            event.setYield(0);
         }
     }
 
@@ -369,63 +453,65 @@ public class EntityListener implements Listener {
     public void onFoodLevelChange(FoodLevelChangeEvent event) {
         Entity entity = event.getEntity();
 
-        if (entity instanceof Player) {
-            Player player = (Player) entity;
+        if (!(entity instanceof Player)) {
+            return;
+        }
 
-            if (Misc.isNPCEntity(player)) {
+        Player player = (Player) entity;
+
+        if (Misc.isNPCEntity(player)) {
+            return;
+        }
+
+        int currentFoodLevel = player.getFoodLevel();
+        int newFoodLevel = event.getFoodLevel();
+        int foodChange = newFoodLevel - currentFoodLevel;
+
+        if (foodChange <= 0) {
+            return;
+        }
+
+        /*
+         * Some foods have 3 ranks
+         * Some foods have 5 ranks
+         * The number of ranks is based on how 'common' the item is
+         * We can adjust this quite easily if we find something is giving too much of a bonus
+         */
+        switch (player.getItemInHand().getType()) {
+            case BAKED_POTATO:  /* RESTORES 3 HUNGER - RESTORES 5 1/2 HUNGER @ 1000 */
+            case BREAD:         /* RESTORES 2 1/2 HUNGER - RESTORES 5 HUNGER @ 1000 */
+            case CARROT_ITEM:   /* RESTORES 2 HUNGER - RESTORES 4 1/2 HUNGER @ 1000 */
+            case GOLDEN_CARROT: /* RESTORES 3 HUNGER - RESTORES 5 1/2 HUNGER @ 1000 */
+            case MUSHROOM_SOUP: /* RESTORES 4 HUNGER - RESTORES 6 1/2 HUNGER @ 1000 */
+            case PUMPKIN_PIE:   /* RESTORES 4 HUNGER - RESTORES 6 1/2 HUNGER @ 1000 */
+                if (Permissions.farmersDiet(player)) {
+                    event.setFoodLevel(UserManager.getPlayer(player).getHerbalismManager().farmersDiet(Herbalism.farmersDietRankLevel1, newFoodLevel));
+                }
                 return;
-            }
 
-            int currentFoodLevel = player.getFoodLevel();
-            int newFoodLevel = event.getFoodLevel();
-            int foodChange = newFoodLevel - currentFoodLevel;
-
-            if (foodChange <= 0) {
+            case COOKIE:           /* RESTORES 1/2 HUNGER - RESTORES 2 HUNGER @ 1000 */
+            case MELON:            /* RESTORES 1 HUNGER - RESTORES 2 1/2 HUNGER @ 1000 */
+            case POISONOUS_POTATO: /* RESTORES 1 HUNGER - RESTORES 2 1/2 HUNGER @ 1000 */
+            case POTATO_ITEM:      /* RESTORES 1/2 HUNGER - RESTORES 2 HUNGER @ 1000 */
+                if (Permissions.farmersDiet(player)) {
+                    event.setFoodLevel(UserManager.getPlayer(player).getHerbalismManager().farmersDiet(Herbalism.farmersDietRankLevel2, newFoodLevel));
+                }
                 return;
-            }
 
-            /*
-             * Some foods have 3 ranks
-             * Some foods have 5 ranks
-             * The number of ranks is based on how 'common' the item is
-             * We can adjust this quite easily if we find something is giving too much of a bonus
-             */
-            switch (player.getItemInHand().getType()) {
-                case BAKED_POTATO:  /* RESTORES 3 HUNGER - RESTORES 5 1/2 HUNGER @ 1000 */
-                case BREAD:         /* RESTORES 2 1/2 HUNGER - RESTORES 5 HUNGER @ 1000 */
-                case CARROT_ITEM:   /* RESTORES 2 HUNGER - RESTORES 4 1/2 HUNGER @ 1000 */
-                case GOLDEN_CARROT: /* RESTORES 3 HUNGER - RESTORES 5 1/2 HUNGER @ 1000 */
-                case MUSHROOM_SOUP: /* RESTORES 4 HUNGER - RESTORES 6 1/2 HUNGER @ 1000 */
-                case PUMPKIN_PIE:   /* RESTORES 4 HUNGER - RESTORES 6 1/2 HUNGER @ 1000 */
-                    if (Permissions.farmersDiet(player)) {
-                        event.setFoodLevel(UserManager.getPlayer(player).getHerbalismManager().farmersDiet(Herbalism.farmersDietRankLevel1, newFoodLevel));
-                    }
-                    return;
+            case COOKED_FISH: /* RESTORES 2 1/2 HUNGER - RESTORES 5 HUNGER @ 1000 */
+                if (Permissions.fishermansDiet(player)) {
+                    event.setFoodLevel(UserManager.getPlayer(player).getFishingManager().handleFishermanDiet(Fishing.fishermansDietRankLevel1, newFoodLevel));
+                }
+                return;
 
-                case COOKIE:           /* RESTORES 1/2 HUNGER - RESTORES 2 HUNGER @ 1000 */
-                case MELON:            /* RESTORES 1 HUNGER - RESTORES 2 1/2 HUNGER @ 1000 */
-                case POISONOUS_POTATO: /* RESTORES 1 HUNGER - RESTORES 2 1/2 HUNGER @ 1000 */
-                case POTATO_ITEM:      /* RESTORES 1/2 HUNGER - RESTORES 2 HUNGER @ 1000 */
-                    if (Permissions.farmersDiet(player)) {
-                        event.setFoodLevel(UserManager.getPlayer(player).getHerbalismManager().farmersDiet(Herbalism.farmersDietRankLevel2, newFoodLevel));
-                    }
-                    return;
+            case RAW_FISH:    /* RESTORES 1 HUNGER - RESTORES 2 1/2 HUNGER @ 1000 */
+                if (Permissions.fishermansDiet(player)) {
+                    event.setFoodLevel(UserManager.getPlayer(player).getFishingManager().handleFishermanDiet(Fishing.fishermansDietRankLevel2, newFoodLevel));
+                }
+                return;
 
-                case COOKED_FISH: /* RESTORES 2 1/2 HUNGER - RESTORES 5 HUNGER @ 1000 */
-                    if (Permissions.fishermansDiet(player)) {
-                        event.setFoodLevel(UserManager.getPlayer(player).getFishingManager().handleFishermanDiet(Fishing.fishermansDietRankLevel1, newFoodLevel));
-                    }
-                    return;
-
-                case RAW_FISH:    /* RESTORES 1 HUNGER - RESTORES 2 1/2 HUNGER @ 1000 */
-                    if (Permissions.fishermansDiet(player)) {
-                        event.setFoodLevel(UserManager.getPlayer(player).getFishingManager().handleFishermanDiet(Fishing.fishermansDietRankLevel2, newFoodLevel));
-                    }
-                    return;
-
-                default:
-                    return;
-            }
+            default:
+                return;
         }
     }
 
@@ -456,20 +542,21 @@ public class EntityListener implements Listener {
         Entity entity = event.getEntity();
         Entity target = event.getTarget();
 
-        if (entity instanceof Tameable && target instanceof Player) {
-            Player player = (Player) target;
-            Tameable tameable = (Tameable) entity;
+        if (!(entity instanceof Tameable) || !(target instanceof Player)) {
+            return;
+        }
 
-            if (!CombatUtils.isFriendlyPet(player, tameable)) {
-                return;
-            }
+        Player player = (Player) target;
+        Tameable tameable = (Tameable) entity;
 
-            // isFriendlyPet ensures that the Tameable is: Tamed, owned by a player, and the owner is in the same party
-            // So we can make some assumptions here, about our casting and our check
-            if (!(Permissions.friendlyFire(player) && Permissions.friendlyFire((Player) tameable.getOwner()))) {
-                event.setCancelled(true);
-                return;
-            }
+        if (!CombatUtils.isFriendlyPet(player, tameable)) {
+            return;
+        }
+
+        // isFriendlyPet ensures that the Tameable is: Tamed, owned by a player, and the owner is in the same party
+        // So we can make some assumptions here, about our casting and our check
+        if (!(Permissions.friendlyFire(player) && Permissions.friendlyFire((Player) tameable.getOwner()))) {
+            event.setCancelled(true);
         }
     }
 }

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

@@ -1,8 +1,6 @@
 package com.gmail.nossr50.listeners;
 
 import org.bukkit.block.Block;
-import org.bukkit.block.BlockState;
-import org.bukkit.block.Furnace;
 import org.bukkit.entity.HumanEntity;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
@@ -15,14 +13,12 @@ import org.bukkit.event.inventory.FurnaceSmeltEvent;
 import org.bukkit.event.inventory.InventoryClickEvent;
 import org.bukkit.event.inventory.InventoryCloseEvent;
 import org.bukkit.event.inventory.InventoryOpenEvent;
-import org.bukkit.inventory.FurnaceInventory;
-import org.bukkit.inventory.Inventory;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.metadata.FixedMetadataValue;
 
 import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.datatypes.skills.SkillType;
-import com.gmail.nossr50.skills.smelting.SmeltingManager;
+import com.gmail.nossr50.runnables.PlayerUpdateInventoryTask;
 import com.gmail.nossr50.util.ItemUtils;
 import com.gmail.nossr50.util.Misc;
 import com.gmail.nossr50.util.Permissions;
@@ -36,7 +32,7 @@ public class InventoryListener implements Listener {
         this.plugin = plugin;
     }
 
-    @EventHandler(priority = EventPriority.MONITOR)
+    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
     public void onInventoryOpen(InventoryOpenEvent event) {
         HumanEntity player = event.getPlayer();
 
@@ -44,25 +40,14 @@ public class InventoryListener implements Listener {
             return;
         }
 
-        Inventory inventory = event.getInventory();
+        Block furnaceBlock = Misc.processInventoryOpenorCloseEvent(event);
 
-        if (inventory instanceof FurnaceInventory) {
-            Furnace furnace = (Furnace) inventory.getHolder();
-
-            if (furnace == null) {
-                return;
-            }
-            if (furnace.getBurnTime() == 0) {
-                Block furnaceBlock = furnace.getBlock();
-
-                if (!furnaceBlock.hasMetadata(mcMMO.furnaceMetadataKey)) {
-                    furnaceBlock.setMetadata(mcMMO.furnaceMetadataKey, new FixedMetadataValue(plugin, player.getName()));
-                }
-            }
+        if (furnaceBlock != null && !furnaceBlock.hasMetadata(mcMMO.furnaceMetadataKey)) {
+            furnaceBlock.setMetadata(mcMMO.furnaceMetadataKey, new FixedMetadataValue(plugin, player.getName()));
         }
     }
 
-    @EventHandler(priority = EventPriority.MONITOR)
+    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
     public void onInventoryClose(InventoryCloseEvent event) {
         HumanEntity player = event.getPlayer();
 
@@ -70,90 +55,65 @@ public class InventoryListener implements Listener {
             return;
         }
 
-        Inventory inventory = event.getInventory();
+        Block furnaceBlock = Misc.processInventoryOpenorCloseEvent(event);
 
-        if (inventory instanceof FurnaceInventory) {
-            Furnace furnace = (Furnace) inventory.getHolder();
-
-            if (furnace == null) {
-                return;
-            }
-
-            if (furnace.getBurnTime() == 0) {
-                Block furnaceBlock = furnace.getBlock();
-
-                if (furnaceBlock.hasMetadata(mcMMO.furnaceMetadataKey)) {
-                    furnaceBlock.removeMetadata(mcMMO.furnaceMetadataKey, plugin);
-                }
-            }
+        if (furnaceBlock != null && furnaceBlock.hasMetadata(mcMMO.furnaceMetadataKey)) {
+            furnaceBlock.removeMetadata(mcMMO.furnaceMetadataKey, plugin);
         }
     }
 
     @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
     public void onFurnaceBurnEvent(FurnaceBurnEvent event) {
         Block furnaceBlock = event.getBlock();
-        BlockState furnaceState = furnaceBlock.getState();
+        ItemStack smelting = Misc.getSmeltingFromFurnace(furnaceBlock);
 
-        if (furnaceState instanceof Furnace) {
-            ItemStack smelting = ((Furnace) furnaceState).getInventory().getSmelting();
-
-            if (furnaceBlock.hasMetadata(mcMMO.furnaceMetadataKey) && smelting != null && ItemUtils.isSmeltable(smelting)) {
-                // We can make this assumption because we (should) be the only ones using this exact metadata
-                Player player = plugin.getServer().getPlayer(furnaceBlock.getMetadata(mcMMO.furnaceMetadataKey).get(0).asString());
-
-                if (Misc.isNPCEntity(player) || !Permissions.fuelEfficiency(player)) {
-                    return;
-                }
-
-                event.setBurnTime(UserManager.getPlayer(player).getSmeltingManager().fuelEfficiency(event.getBurnTime()));
-            }
+        if (!ItemUtils.isSmeltable(smelting)) {
+            return;
         }
+
+        Player player = Misc.getPlayerFromFurnace(furnaceBlock);
+
+        if (Misc.isNPCEntity(player) || !Permissions.fuelEfficiency(player)) {
+            return;
+        }
+
+        event.setBurnTime(UserManager.getPlayer(player).getSmeltingManager().fuelEfficiency(event.getBurnTime()));
     }
 
     @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
     public void onFurnaceSmeltEvent(FurnaceSmeltEvent event) {
         Block furnaceBlock = event.getBlock();
-        BlockState furnaceState = furnaceBlock.getState();
+        ItemStack smelting = Misc.getSmeltingFromFurnace(furnaceBlock);
 
-        if (furnaceState instanceof Furnace) {
-            ItemStack smelting = ((Furnace) furnaceState).getInventory().getSmelting();
-
-            if (furnaceBlock.hasMetadata(mcMMO.furnaceMetadataKey) && smelting != null && ItemUtils.isSmeltable(smelting)) {
-                // We can make this assumption because we (should) be the only ones using this exact metadata
-                Player player = plugin.getServer().getPlayer(furnaceBlock.getMetadata(mcMMO.furnaceMetadataKey).get(0).asString());
-
-                if (Misc.isNPCEntity(player) || !Permissions.skillEnabled(player, SkillType.SMELTING)) {
-                    return;
-                }
-
-                event.setResult(UserManager.getPlayer(player).getSmeltingManager().smeltProcessing(event.getSource().getType(), event.getResult()));
-            }
+        if (!ItemUtils.isSmeltable(smelting)) {
+            return;
         }
+
+        Player player = Misc.getPlayerFromFurnace(furnaceBlock);
+
+        if (Misc.isNPCEntity(player) || !Permissions.skillEnabled(player, SkillType.SMELTING)) {
+            return;
+        }
+
+        event.setResult(UserManager.getPlayer(player).getSmeltingManager().smeltProcessing(smelting.getType(), event.getResult()));
     }
 
     @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
     public void onFurnaceExtractEvent(FurnaceExtractEvent event) {
         Block furnaceBlock = event.getBlock();
-        BlockState furnaceState = furnaceBlock.getState();
+        ItemStack result = Misc.getResultFromFurnace(furnaceBlock);
 
-        if (furnaceState instanceof Furnace) {
-            ItemStack result = ((Furnace) furnaceState).getInventory().getResult();
-
-            if (furnaceBlock.hasMetadata(mcMMO.furnaceMetadataKey) && result != null && ItemUtils.isSmelted(result)) {
-                // We can make this assumption because we (should) be the only ones using this exact metadata
-                Player player = plugin.getServer().getPlayer(furnaceBlock.getMetadata(mcMMO.furnaceMetadataKey).get(0).asString());
-
-                if (Misc.isNPCEntity(player)) {
-                    return;
-                }
-
-                SmeltingManager smeltingManager = UserManager.getPlayer(player).getSmeltingManager();
-
-                if (smeltingManager.canUseVanillaXpBoost()) {
-                    event.setExpToDrop(smeltingManager.vanillaXPBoost(event.getExpToDrop()));
-                }
-            }
+        if (!ItemUtils.isSmelted(result)) {
+            return;
         }
+
+        Player player = Misc.getPlayerFromFurnace(furnaceBlock);
+
+        if (Misc.isNPCEntity(player) || !Permissions.vanillaXpBoost(player, SkillType.SMELTING)) {
+            return;
+        }
+
+        event.setExpToDrop(UserManager.getPlayer(player).getSmeltingManager().vanillaXPBoost(event.getExpToDrop()));
     }
 
     @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
@@ -163,26 +123,18 @@ public class InventoryListener implements Listener {
 
     @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
     public void onCraftItem(CraftItemEvent event) {
-        if (event.getRecipe().getResult() == null) {
-            return;
-        }
-        else if (!ItemUtils.isMcMMOItem(event.getRecipe().getResult())) {
-            return;
-        }
-        else if (event.getWhoClicked() == null) {
-            return;
-        }
-        else if (!(event.getWhoClicked() instanceof Player)) {
+        final HumanEntity whoClicked = event.getWhoClicked();
+
+        if (Misc.isNPCEntity(whoClicked) || !(whoClicked instanceof Player)) {
             return;
         }
 
-        final Player player = (Player) event.getWhoClicked();
+        ItemStack result = event.getRecipe().getResult();
 
-        mcMMO.p.getServer().getScheduler().scheduleSyncDelayedTask(mcMMO.p, new Runnable() {
-            @Override
-            public void run() {
-                player.updateInventory();
-            }
-        });
+        if (!ItemUtils.isMcMMOItem(result)) {
+            return;
+        }
+
+        new PlayerUpdateInventoryTask((Player) whoClicked).runTaskLater(plugin, 0);
     }
 }

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

@@ -2,9 +2,11 @@ package com.gmail.nossr50.listeners;
 
 import org.bukkit.GameMode;
 import org.bukkit.Material;
+import org.bukkit.Sound;
 import org.bukkit.block.Block;
 import org.bukkit.block.BlockState;
 import org.bukkit.entity.Entity;
+import org.bukkit.entity.Fish;
 import org.bukkit.entity.Item;
 import org.bukkit.entity.LivingEntity;
 import org.bukkit.entity.Player;
@@ -19,8 +21,6 @@ import org.bukkit.event.player.PlayerDropItemEvent;
 import org.bukkit.event.player.PlayerFishEvent;
 import org.bukkit.event.player.PlayerInteractEvent;
 import org.bukkit.event.player.PlayerJoinEvent;
-import org.bukkit.event.player.PlayerLoginEvent;
-import org.bukkit.event.player.PlayerLoginEvent.Result;
 import org.bukkit.event.player.PlayerPickupItemEvent;
 import org.bukkit.event.player.PlayerQuitEvent;
 import org.bukkit.event.player.PlayerRespawnEvent;
@@ -28,6 +28,9 @@ import org.bukkit.inventory.ItemStack;
 
 import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.chat.ChatManager;
+import com.gmail.nossr50.chat.ChatManagerFactory;
+import com.gmail.nossr50.chat.ChatMode;
+import com.gmail.nossr50.chat.PartyChatManager;
 import com.gmail.nossr50.config.Config;
 import com.gmail.nossr50.datatypes.party.Party;
 import com.gmail.nossr50.datatypes.player.McMMOPlayer;
@@ -40,15 +43,19 @@ 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.taming.TamingManager;
+import com.gmail.nossr50.skills.unarmed.Unarmed;
 import com.gmail.nossr50.util.BlockUtils;
 import com.gmail.nossr50.util.ChimaeraWing;
 import com.gmail.nossr50.util.HardcoreManager;
 import com.gmail.nossr50.util.ItemUtils;
 import com.gmail.nossr50.util.Misc;
+import com.gmail.nossr50.util.MobHealthbarUtils;
 import com.gmail.nossr50.util.Motd;
 import com.gmail.nossr50.util.Permissions;
 import com.gmail.nossr50.util.player.UserManager;
+import com.gmail.nossr50.util.scoreboards.ScoreboardManager;
 import com.gmail.nossr50.util.skills.SkillUtils;
 
 public class PlayerListener implements Listener {
@@ -58,32 +65,41 @@ public class PlayerListener implements Listener {
         this.plugin = plugin;
     }
 
+    @EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
+    public void onPlayerDeathLowest(PlayerDeathEvent event) {
+        String deathMessage = event.getDeathMessage();
+
+        if (deathMessage == null) {
+            return;
+        }
+
+        event.setDeathMessage(MobHealthbarUtils.fixDeathMessage(deathMessage, event.getEntity()));
+    }
+
     /**
      * Monitor PlayerDeath events.
      *
      * @param event The event to watch
      */
     @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
-    public void onPlayerDeath(PlayerDeathEvent event) {
+    public void onPlayerDeathMonitor(PlayerDeathEvent event) {
         if (!Config.getInstance().getHardcoreEnabled()) {
             return;
         }
 
         Player player = event.getEntity();
 
-        if (Misc.isNPCEntity(player)) {
+        if (Misc.isNPCEntity(player) || Permissions.hardcoreBypass(player)) {
             return;
         }
 
-        if (!Permissions.hardcoreBypass(player)) {
-            Player killer = player.getKiller();
+        Player killer = player.getKiller();
 
-            if (killer != null && Config.getInstance().getHardcoreVampirismEnabled()) {
-                HardcoreManager.invokeVampirism(killer, player);
-            }
-
-            HardcoreManager.invokeStatPenalty(player);
+        if (killer != null && Config.getInstance().getHardcoreVampirismEnabled()) {
+            HardcoreManager.invokeVampirism(killer, player);
         }
+
+        HardcoreManager.invokeStatPenalty(player);
     }
 
     /**
@@ -92,7 +108,7 @@ public class PlayerListener implements Listener {
      * @param event The event to watch
      */
     @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
-    public void onPlayerWorldChangeEvent(PlayerChangedWorldEvent event) {
+    public void onPlayerWorldChange(PlayerChangedWorldEvent event) {
         Player player = event.getPlayer();
 
         if (Misc.isNPCEntity(player)) {
@@ -112,40 +128,17 @@ public class PlayerListener implements Listener {
         }
     }
 
-    /**
-     * Monitor PlayerLogin events.
-     *
-     * @param event The event to watch
-     */
-    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
-    public void onPlayerLoginEvent(PlayerLoginEvent event) {
-        if (event.getResult() == Result.ALLOWED) {
-            Player player = event.getPlayer();
-
-            if (Misc.isNPCEntity(player)) {
-                return;
-            }
-
-            UserManager.addUser(player).actualizeRespawnATS();
-        }
-    }
-
     /**
      * Handle PlayerDropItem events that involve modifying the event.
      *
      * @param event The event to modify
      */
     @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
-    public void onPlayerDropItemEvent(PlayerDropItemEvent event) {
-        Player player = event.getPlayer();
-        McMMOPlayer mcMMOPlayer = UserManager.getPlayer(player);
+    public void onPlayerDropItem(PlayerDropItemEvent event) {
+        Item drop = event.getItemDrop();
 
-        if (mcMMOPlayer.getAbilityMode(AbilityType.GIGA_DRILL_BREAKER) || mcMMOPlayer.getAbilityMode(AbilityType.SUPER_BREAKER)) {
-            event.setCancelled(true);
-            return;
-        }
-
-        SkillUtils.removeAbilityBuff(event.getItemDrop().getItemStack());
+        drop.setMetadata(mcMMO.droppedItemKey, mcMMO.metadataValue);
+        SkillUtils.removeAbilityBuff(drop.getItemStack());
     }
 
     /**
@@ -164,6 +157,20 @@ public class PlayerListener implements Listener {
         FishingManager fishingManager = UserManager.getPlayer(player).getFishingManager();
 
         switch (event.getState()) {
+            case FISHING:
+                if (!Permissions.krakenBypass(player)) {
+                    event.setCancelled(fishingManager.exploitPrevention());
+
+                    if (event.isCancelled()) {
+                        return;
+                    }
+                }
+
+                if (fishingManager.canMasterAngler()) {
+                    fishingManager.masterAngler(event.getHook());
+                }
+                break;
+
             case CAUGHT_FISH:
                 fishingManager.handleFishing((Item) event.getCaught());
 
@@ -178,8 +185,18 @@ public class PlayerListener implements Listener {
                 if (fishingManager.canShake(entity)) {
                     fishingManager.shakeCheck((LivingEntity) entity);
                 }
-
                 break;
+
+            case IN_GROUND:
+                Fish hook = event.getHook();
+                Block block = event.getPlayer().getTargetBlock(null, 100);
+
+                if (fishingManager.canIceFish(block)) {
+                    event.setCancelled(true);
+                    fishingManager.iceFishing(hook, block);
+                }
+                break;
+
             default:
                 break;
         }
@@ -193,16 +210,32 @@ public class PlayerListener implements Listener {
     @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
     public void onPlayerPickupItem(PlayerPickupItemEvent event) {
         Player player = event.getPlayer();
-        Item item = event.getItem();
 
         if (Misc.isNPCEntity(player)) {
             return;
         }
 
         McMMOPlayer mcMMOPlayer = UserManager.getPlayer(player);
+        Item drop = event.getItem();
+        ItemStack dropStack = drop.getItemStack();
 
-        if (mcMMOPlayer.inParty() && ItemUtils.isShareable(item.getItemStack())) {
-            ShareHandler.handleItemShare(event, mcMMOPlayer);
+        if (!drop.hasMetadata(mcMMO.droppedItemKey) && mcMMOPlayer.inParty() && ItemUtils.isShareable(dropStack)) {
+            event.setCancelled(ShareHandler.handleItemShare(drop, mcMMOPlayer));
+
+            if (event.isCancelled()) {
+                player.playSound(player.getLocation(), Sound.ITEM_PICKUP, Misc.POP_VOLUME, Misc.getPopPitch());
+                return;
+            }
+        }
+
+        if ((mcMMOPlayer.isUsingUnarmed() && ItemUtils.isShareable(dropStack)) || mcMMOPlayer.getAbilityMode(AbilityType.BERSERK)) {
+            event.setCancelled(Unarmed.handleItemPickup(player.getInventory(), drop));
+
+            if (event.isCancelled()) {
+                player.playSound(player.getLocation(), Sound.ITEM_PICKUP, Misc.POP_VOLUME, Misc.getPopPitch());
+                player.updateInventory();
+                return;
+            }
         }
     }
 
@@ -219,10 +252,6 @@ public class PlayerListener implements Listener {
             return;
         }
 
-        if (UserManager.getPlayer(player).getAbilityMode(AbilityType.BERSERK)) {
-            player.setCanPickupItems(true);
-        }
-
         /* GARBAGE COLLECTION */
         BleedTimerTask.bleedOut(player); // Bleed it out
     }
@@ -236,10 +265,13 @@ public class PlayerListener implements Listener {
     public void onPlayerJoin(PlayerJoinEvent event) {
         Player player = event.getPlayer();
 
-        if (UserManager.getPlayer(player).getAbilityMode(AbilityType.BERSERK)) {
-            player.setCanPickupItems(false);
+        if (Misc.isNPCEntity(player)) {
+            return;
         }
 
+        UserManager.addUser(player).actualizeRespawnATS();
+        ScoreboardManager.enablePowerLevelDisplay(player);
+
         if (Config.getInstance().getMOTDEnabled() && Permissions.motd(player)) {
             Motd.displayAll(player);
         }
@@ -248,7 +280,7 @@ public class PlayerListener implements Listener {
             player.sendMessage(LocaleLoader.getString("XPRate.Event", Config.getInstance().getExperienceGainsGlobalMultiplier()));
         }
 
-        if (Permissions.updateNotifications(player) && mcMMO.p.updateAvailable) {
+        if (Permissions.updateNotifications(player) && plugin.isUpdateAvailable()) {
             player.sendMessage(LocaleLoader.getString("UpdateChecker.outdated"));
             player.sendMessage(LocaleLoader.getString("UpdateChecker.newavailable"));
         }
@@ -278,31 +310,49 @@ public class PlayerListener implements Listener {
     @EventHandler(priority = EventPriority.LOWEST)
     public void onPlayerInteractLowest(PlayerInteractEvent event) {
         Player player = event.getPlayer();
+        Block block = event.getClickedBlock();
 
         if (Misc.isNPCEntity(player) || player.getGameMode() == GameMode.CREATIVE) {
             return;
         }
 
-        Block block = event.getClickedBlock();
         ItemStack heldItem = player.getItemInHand();
         McMMOPlayer mcMMOPlayer = UserManager.getPlayer(player);
+
+        // This shouldn't be possible - this is probably a band-aid for a larger issue somewhere else.
+        if (mcMMOPlayer == null) {
+            return;
+        }
+
         MiningManager miningManager = mcMMOPlayer.getMiningManager();
 
         switch (event.getAction()) {
             case RIGHT_CLICK_BLOCK:
                 int blockID = block.getTypeId();
 
-                /* REPAIR CHECKS */
-                if (blockID == Repair.repairAnvilId && Permissions.skillEnabled(player, SkillType.REPAIR) && mcMMO.repairableManager.isRepairable(heldItem)) {
-                    UserManager.getPlayer(player).getRepairManager().handleRepair(heldItem);
-                    event.setCancelled(true);
-                    player.updateInventory();
-                }
-                /* SALVAGE CHECKS */
-                else if (blockID == Repair.salvageAnvilId && Permissions.salvage(player) && Repair.isSalvageable(heldItem)) {
-                    UserManager.getPlayer(player).getRepairManager().handleSalvage(block.getLocation(), heldItem);
-                    event.setCancelled(true);
-                    player.updateInventory();
+                if ((Config.getInstance().getAbilitiesOnlyActivateWhenSneaking() && player.isSneaking()) || !Config.getInstance().getAbilitiesOnlyActivateWhenSneaking()) {
+                    /* REPAIR CHECKS */
+                    if (blockID == Repair.repairAnvilId && Permissions.skillEnabled(player, SkillType.REPAIR) && 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(blockID, true)) {
+                            repairManager.handleRepair(heldItem);
+                            player.updateInventory();
+                        }
+                    }
+                    /* SALVAGE CHECKS */
+                    else if (blockID == Repair.salvageAnvilId && Permissions.salvage(player) && Repair.isSalvageable(heldItem)) {
+                        RepairManager repairManager = mcMMOPlayer.getRepairManager();
+                        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(blockID, true)) {
+                            repairManager.handleSalvage(block.getLocation(), heldItem);
+                            player.updateInventory();
+                        }
+                    }
                 }
                 /* BLAST MINING CHECK */
                 else if (miningManager.canDetonate()) {
@@ -316,6 +366,34 @@ public class PlayerListener implements Listener {
 
                 break;
 
+            case LEFT_CLICK_BLOCK:
+                blockID = block.getTypeId();
+
+                if ((Config.getInstance().getAbilitiesOnlyActivateWhenSneaking() && player.isSneaking()) || !Config.getInstance().getAbilitiesOnlyActivateWhenSneaking()) {
+                    /* REPAIR CHECKS */
+                    if (blockID == Repair.repairAnvilId && Permissions.skillEnabled(player, SkillType.REPAIR) && mcMMO.getRepairableManager().isRepairable(heldItem)) {
+                        RepairManager repairManager = mcMMOPlayer.getRepairManager();
+
+                        // Cancel repairing an enchanted item
+                        if (repairManager.checkConfirmation(blockID, false) && Config.getInstance().getRepairConfirmRequired()) {
+                            mcMMOPlayer.setLastAnvilUse(Repair.repairAnvilId, 0);
+                            player.sendMessage(LocaleLoader.getString("Skills.Cancelled", LocaleLoader.getString("Repair.Pretty.Name")));
+                        }
+                    }
+                    /* SALVAGE CHECKS */
+                    else if (blockID == Repair.salvageAnvilId && Permissions.salvage(player) && Repair.isSalvageable(heldItem)) {
+                        RepairManager repairManager = mcMMOPlayer.getRepairManager();
+
+                        // Cancel salvaging an enchanted item
+                        if (repairManager.checkConfirmation(blockID, false) && Config.getInstance().getRepairConfirmRequired()) {
+                            mcMMOPlayer.setLastAnvilUse(Repair.salvageAnvilId, 0);
+                            player.sendMessage(LocaleLoader.getString("Skills.Cancelled", LocaleLoader.getString("Salvage.Pretty.Name")));
+                        }
+                    }
+                }
+
+                break;
+
             case RIGHT_CLICK_AIR:
                 /* BLAST MINING CHECK */
                 if (miningManager.canDetonate()) {
@@ -345,6 +423,11 @@ public class PlayerListener implements Listener {
         ItemStack heldItem = player.getItemInHand();
         McMMOPlayer mcMMOPlayer = UserManager.getPlayer(player);
 
+        // This shouldn't be possible - this is probably a band-aid for a larger issue somewhere else.
+        if (mcMMOPlayer == null) {
+            return;
+        }
+
         switch (event.getAction()) {
             case RIGHT_CLICK_BLOCK:
                 Block block = event.getClickedBlock();
@@ -441,22 +524,33 @@ public class PlayerListener implements Listener {
             return;
         }
 
-        boolean isAsync = event.isAsynchronous();
         McMMOPlayer mcMMOPlayer = UserManager.getPlayer(player);
 
+        if (mcMMOPlayer == null) {
+            mcMMO.p.debug(player.getName() + " is currently chatting, but has never logged on to the server.");
+            return;
+        }
+
+        ChatManager chatManager = null;
+
         if (mcMMOPlayer.getPartyChatMode()) {
             Party party = mcMMOPlayer.getParty();
 
             if (party == null) {
+                mcMMOPlayer.togglePartyChat();
                 player.sendMessage(LocaleLoader.getString("Commands.Party.None"));
                 return;
             }
 
-            ChatManager.handlePartyChat(plugin, party, player.getName(), player.getDisplayName(), event.getMessage(), isAsync);
-            event.setCancelled(true);
+            chatManager = ChatManagerFactory.getChatManager(plugin, ChatMode.PARTY);
+            ((PartyChatManager) chatManager).setParty(party);
         }
         else if (mcMMOPlayer.getAdminChatMode()) {
-            ChatManager.handleAdminChat(plugin, player.getName(), player.getDisplayName(), event.getMessage(), isAsync);
+            chatManager = ChatManagerFactory.getChatManager(plugin, ChatMode.ADMIN);
+        }
+
+        if (chatManager != null) {
+            chatManager.handleChat(player, event.getMessage(), event.isAsynchronous());
             event.setCancelled(true);
         }
     }

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

@@ -10,10 +10,6 @@ import com.gmail.nossr50.events.experience.McMMOPlayerLevelUpEvent;
 import com.gmail.nossr50.util.skills.ParticleEffectUtils;
 
 public class SelfListener implements Listener {
-    protected Player player;
-
-    protected float skillValue;
-
     @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
     public void onPlayerLevelUp(McMMOPlayerLevelUpEvent event) {
         if (!Config.getInstance().getLevelUpEffectsEnabled()) {
@@ -26,8 +22,8 @@ public class SelfListener implements Listener {
             return;
         }
 
-        player = event.getPlayer();
-        skillValue = event.getSkillLevel();
+        Player player = event.getPlayer();
+        float skillValue = event.getSkillLevel();
 
         if ((skillValue % tier) == 0) {
             ParticleEffectUtils.runescapeModeCelebration(player, event.getSkill());

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

@@ -11,13 +11,13 @@ import org.getspout.spoutapi.gui.Button;
 import org.getspout.spoutapi.gui.ScreenType;
 import org.getspout.spoutapi.player.SpoutPlayer;
 
+import com.gmail.nossr50.config.spout.SpoutConfig;
 import com.gmail.nossr50.datatypes.player.McMMOPlayer;
 import com.gmail.nossr50.datatypes.spout.buttons.McMMOButton;
 import com.gmail.nossr50.datatypes.spout.huds.McMMOHud;
 import com.gmail.nossr50.datatypes.spout.popups.McMMOMenu;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.util.player.UserManager;
-import com.gmail.nossr50.util.spout.SpoutUtils;
 
 public class SpoutListener implements Listener {
 
@@ -32,8 +32,8 @@ public class SpoutListener implements Listener {
         McMMOPlayer mcMMOPlayer = UserManager.getPlayer(spoutPlayer);
 
         // TODO: Add custom titles based on skills
-        if (SpoutUtils.showPowerLevel) {
-            spoutPlayer.setTitle(LocaleLoader.getString("Spout.Title", spoutPlayer.getName(), mcMMOPlayer.getPowerLevel()));
+        if (SpoutConfig.getInstance().getShowPowerLevel()) {
+            spoutPlayer.setTitle(LocaleLoader.getString("Spout.Title", spoutPlayer.getTitle(), mcMMOPlayer.getPowerLevel()));
         }
 
         mcMMOPlayer.getProfile().setSpoutHud(new McMMOHud(mcMMOPlayer)); // Setup Party HUD stuff
@@ -81,7 +81,7 @@ public class SpoutListener implements Listener {
             return;
         }
 
-        if (event.getKey() == SpoutUtils.menuKey) {
+        if (event.getKey() == SpoutConfig.getInstance().getMenuKey()) {
             McMMOHud spoutHud = UserManager.getPlayer(spoutPlayer).getProfile().getSpoutHud();
 
             if (!spoutHud.isMenuOpened()) {

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

@@ -4,7 +4,6 @@ import java.io.File;
 import java.util.ArrayList;
 
 import org.bukkit.Chunk;
-import org.bukkit.Location;
 import org.bukkit.World;
 import org.bukkit.block.BlockState;
 import org.bukkit.event.EventHandler;
@@ -19,7 +18,12 @@ import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.util.blockmeta.conversion.BlockStoreConversionMain;
 
 public class WorldListener implements Listener {
-    private ArrayList<BlockStoreConversionMain> converters = new ArrayList<BlockStoreConversionMain>();
+    private final ArrayList<BlockStoreConversionMain> converters = new ArrayList<BlockStoreConversionMain>();
+    private final mcMMO plugin;
+
+    public WorldListener(final mcMMO plugin) {
+        this.plugin = plugin;
+    }
 
     /**
      * Monitor StructureGrow events.
@@ -28,12 +32,12 @@ public class WorldListener implements Listener {
      */
     @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
     public void onStructureGrow(StructureGrowEvent event) {
-        Location location = event.getLocation();
+        if (!mcMMO.getPlaceStore().isTrue(event.getLocation().getBlock())) {
+            return;
+        }
 
-        if (mcMMO.placeStore.isTrue(location.getBlockX(), location.getBlockY(), location.getBlockZ(), location.getWorld())) {
-            for (BlockState blockState : event.getBlocks()) {
-                mcMMO.placeStore.setFalse(blockState);
-            }
+        for (BlockState blockState : event.getBlocks()) {
+            mcMMO.getPlaceStore().setFalse(blockState);
         }
     }
 
@@ -45,13 +49,12 @@ public class WorldListener implements Listener {
     @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
     public void onWorldInit(WorldInitEvent event) {
         World world = event.getWorld();
-        File dataDir = new File(world.getWorldFolder(), "mcmmo_data");
 
-        if (!dataDir.exists() || mcMMO.p == null) {
+        if (!new File(world.getWorldFolder(), "mcmmo_data").exists() || plugin == null) {
             return;
         }
 
-        mcMMO.p.getLogger().info("Converting block storage for " + world.getName() + " to a new format.");
+        plugin.getLogger().info("Converting block storage for " + world.getName() + " to a new format.");
 
         BlockStoreConversionMain converter = new BlockStoreConversionMain(world);
         converter.run();
@@ -65,7 +68,7 @@ public class WorldListener implements Listener {
      */
     @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
     public void onWorldUnload(WorldUnloadEvent event) {
-        mcMMO.placeStore.unloadWorld(event.getWorld());
+        mcMMO.getPlaceStore().unloadWorld(event.getWorld());
     }
 
     /**
@@ -77,6 +80,6 @@ public class WorldListener implements Listener {
     public void onChunkUnload(ChunkUnloadEvent event) {
         Chunk chunk = event.getChunk();
 
-        mcMMO.placeStore.chunkUnloaded(chunk.getX(), chunk.getZ(), event.getWorld());
+        mcMMO.getPlaceStore().chunkUnloaded(chunk.getX(), chunk.getZ(), event.getWorld());
     }
 }

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

@@ -23,14 +23,13 @@ import com.gmail.nossr50.config.mods.CustomToolConfig;
 import com.gmail.nossr50.config.spout.SpoutConfig;
 import com.gmail.nossr50.config.treasure.TreasureConfig;
 import com.gmail.nossr50.database.DatabaseManager;
-import com.gmail.nossr50.database.LeaderboardManager;
-import com.gmail.nossr50.datatypes.player.McMMOPlayer;
-import com.gmail.nossr50.datatypes.skills.AbilityType;
+import com.gmail.nossr50.database.DatabaseManagerFactory;
 import com.gmail.nossr50.listeners.BlockListener;
 import com.gmail.nossr50.listeners.EntityListener;
 import com.gmail.nossr50.listeners.InventoryListener;
 import com.gmail.nossr50.listeners.PlayerListener;
 import com.gmail.nossr50.listeners.SelfListener;
+import com.gmail.nossr50.listeners.SpoutListener;
 import com.gmail.nossr50.listeners.WorldListener;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.metrics.MetricsManager;
@@ -39,7 +38,6 @@ import com.gmail.nossr50.runnables.SaveTimerTask;
 import com.gmail.nossr50.runnables.database.UserPurgeTask;
 import com.gmail.nossr50.runnables.party.PartyAutoKickTask;
 import com.gmail.nossr50.runnables.skills.BleedTimerTask;
-import com.gmail.nossr50.runnables.skills.SkillMonitorTask;
 import com.gmail.nossr50.skills.child.ChildConfig;
 import com.gmail.nossr50.skills.repair.Repairable;
 import com.gmail.nossr50.skills.repair.RepairableManager;
@@ -47,6 +45,7 @@ import com.gmail.nossr50.skills.repair.RepairableManagerFactory;
 import com.gmail.nossr50.skills.repair.config.RepairConfigManager;
 import com.gmail.nossr50.util.ChimaeraWing;
 import com.gmail.nossr50.util.LogFilter;
+import com.gmail.nossr50.util.Misc;
 import com.gmail.nossr50.util.Permissions;
 import com.gmail.nossr50.util.UpdateChecker;
 import com.gmail.nossr50.util.blockmeta.chunkmeta.ChunkManager;
@@ -56,41 +55,43 @@ import com.gmail.nossr50.util.player.UserManager;
 import com.gmail.nossr50.util.spout.SpoutUtils;
 
 public class mcMMO extends JavaPlugin {
-    private final PlayerListener    playerListener    = new PlayerListener(this);
-    private final BlockListener     blockListener     = new BlockListener(this);
-    private final EntityListener    entityListener    = new EntityListener(this);
-    private final InventoryListener inventoryListener = new InventoryListener(this);
-    private final SelfListener      selfListener      = new SelfListener();
-    private final WorldListener     worldListener     = new WorldListener();
+    /* Managers */
+    private static ChunkManager      placeStore;
+    private static RepairableManager repairableManager;
+    private static DatabaseManager   databaseManager;
 
-    public static mcMMO p;
-
-    public static ChunkManager  placeStore;
-    public static RepairableManager repairableManager;
-
-    // Jar Stuff
-    public static File mcmmo;
-
-    // File Paths
+    /* File Paths */
     private static String mainDirectory;
     private static String flatFileDirectory;
     private static String usersFile;
     private static String modDirectory;
 
-    // Update Check
-    public boolean updateAvailable;
+    public static mcMMO p;
 
-    // Spout Check
-    public static boolean spoutEnabled = false;
+    // Jar Stuff
+    public static File mcmmo;
+
+    // Update Check
+    private boolean updateAvailable;
+
+    /* Plugin Checks */
+    private static boolean spoutEnabled;
+    private static boolean combatTagEnabled;
 
     // XP Event Check
-    private boolean xpEventEnabled = false;
+    private boolean xpEventEnabled;
 
-    // Metadata Values
+    /* Metadata Values */
     public final static String entityMetadataKey   = "mcMMO: Spawned Entity";
     public final static String blockMetadataKey    = "mcMMO: Piston Tracking";
     public final static String furnaceMetadataKey  = "mcMMO: Tracked Furnace";
     public final static String tntMetadataKey      = "mcMMO: Tracked TNT";
+    public final static String customNameKey       = "mcMMO: Custom Name";
+    public final static String customVisibleKey    = "mcMMO: Name Visibility";
+    public final static String droppedItemKey      = "mcMMO: Tracked Item";
+    public final static String infiniteArrowKey    = "mcMMO: Infinite Arrow";
+    public final static String bowForceKey         = "mcMMO: Bow Force";
+    public final static String arrowDistanceKey    = "mcMMO: Arrow Distance";
 
     public static FixedMetadataValue metadataValue;
 
@@ -108,33 +109,23 @@ public class mcMMO extends JavaPlugin {
             setupSpout();
             loadConfigFiles();
 
-            if (!Config.getInstance().getUseMySQL()) {
-                UserManager.loadUsers();
-            }
+            combatTagEnabled = getServer().getPluginManager().getPlugin("CombatTag") != null;
+
+            databaseManager = DatabaseManagerFactory.getDatabaseManager();
 
             registerEvents();
             registerCustomRecipes();
 
             PartyManager.loadParties();
 
-            // Setup the leader boards
-            if (Config.getInstance().getUseMySQL()) {
-                // TODO: Why do we have to check for a connection that hasn't be made yet?
-                DatabaseManager.checkConnected();
-                DatabaseManager.createStructure();
-            }
-            else {
-                LeaderboardManager.updateLeaderboards();
-            }
-
             for (Player player : getServer().getOnlinePlayers()) {
                 UserManager.addUser(player); // In case of reload add all users back into UserManager
             }
 
-            getLogger().info("Version " + getDescription().getVersion() + " is enabled!");
+            debug("Version " + getDescription().getVersion() + " is enabled!");
 
             scheduleTasks();
-            registerCommands();
+            CommandRegistrationManager.registerCommands();
 
             MetricsManager.setup();
 
@@ -166,7 +157,6 @@ public class mcMMO extends JavaPlugin {
     @Override
     public void onDisable() {
         try {
-            reloadDisableHelper();      // Prevent Berserk from getting "stuck"
             UserManager.saveAll();      // Make sure to save player information if the server shuts down
             PartyManager.saveParties(); // Save our parties
             placeStore.saveAll();       // Save our metadata
@@ -196,7 +186,7 @@ public class mcMMO extends JavaPlugin {
             }
         }
 
-        getLogger().info("Was disabled."); // How informative!
+        debug("Was disabled."); // How informative!
     }
 
     public static String getMainDirectory() {
@@ -215,6 +205,10 @@ public class mcMMO extends JavaPlugin {
         return modDirectory;
     }
 
+    public boolean isUpdateAvailable() {
+        return updateAvailable;
+    }
+
     public boolean isXPEventEnabled() {
         return xpEventEnabled;
     }
@@ -231,6 +225,31 @@ public class mcMMO extends JavaPlugin {
         getLogger().info("[Debug] " + message);
     }
 
+    public static ChunkManager getPlaceStore() {
+        return placeStore;
+    }
+
+    public static RepairableManager getRepairableManager() {
+        return repairableManager;
+    }
+
+    public static DatabaseManager getDatabaseManager() {
+        return databaseManager;
+    }
+
+    @Deprecated
+    public static void setDatabaseManager(DatabaseManager databaseManager) {
+        mcMMO.databaseManager = databaseManager;
+    }
+
+    public static boolean isSpoutEnabled() {
+        return spoutEnabled;
+    }
+
+    public static boolean isCombatTagEnabled() {
+        return combatTagEnabled;
+    }
+
     /**
      * Setup the various storage file paths
      */
@@ -243,24 +262,25 @@ public class mcMMO extends JavaPlugin {
     }
 
     private void checkForUpdates() {
-        if (Config.getInstance().getUpdateCheckEnabled()) {
-            try {
-                updateAvailable = UpdateChecker.updateAvailable();
-            }
-            catch (Exception e) {
-                updateAvailable = false;
-            }
+        if (!Config.getInstance().getUpdateCheckEnabled()) {
+            return;
+        }
 
-            if (updateAvailable) {
-                getLogger().info(LocaleLoader.getString("UpdateChecker.outdated"));
-                getLogger().info(LocaleLoader.getString("UpdateChecker.newavailable"));
-            }
+        try {
+            updateAvailable = UpdateChecker.updateAvailable();
+        }
+        catch (Exception e) {
+            updateAvailable = false;
+        }
+
+        if (updateAvailable) {
+            getLogger().info(LocaleLoader.getString("UpdateChecker.outdated"));
+            getLogger().info(LocaleLoader.getString("UpdateChecker.newavailable"));
         }
     }
 
     private void loadConfigFiles() {
         // Force the loading of config files
-        Config configInstance = Config.getInstance();
         TreasureConfig.getInstance();
         HiddenConfig.getInstance();
         AdvancedConfig.getInstance();
@@ -268,19 +288,19 @@ public class mcMMO extends JavaPlugin {
 
         List<Repairable> repairables = new ArrayList<Repairable>();
 
-        if (configInstance.getToolModsEnabled()) {
+        if (Config.getInstance().getToolModsEnabled()) {
             repairables.addAll(CustomToolConfig.getInstance().getLoadedRepairables());
         }
 
-        if (configInstance.getArmorModsEnabled()) {
+        if (Config.getInstance().getArmorModsEnabled()) {
             repairables.addAll(CustomArmorConfig.getInstance().getLoadedRepairables());
         }
 
-        if (configInstance.getBlockModsEnabled()) {
+        if (Config.getInstance().getBlockModsEnabled()) {
             CustomBlockConfig.getInstance();
         }
 
-        if (configInstance.getEntityModsEnabled()) {
+        if (Config.getInstance().getEntityModsEnabled()) {
             CustomEntityConfig.getInstance();
         }
 
@@ -291,74 +311,34 @@ public class mcMMO extends JavaPlugin {
         repairableManager.registerRepairables(repairables);
 
         // Check if Repair Anvil and Salvage Anvil have different itemID's
-        if (configInstance.getSalvageAnvilId() == configInstance.getRepairAnvilId()) {
+        if (Config.getInstance().getSalvageAnvilId() == Config.getInstance().getRepairAnvilId()) {
             getLogger().warning("Can't use the same itemID for Repair/Salvage Anvils!");
         }
     }
 
     private void setupSpout() {
-        // Check for Spout
-        if (getServer().getPluginManager().isPluginEnabled("Spout")) {
-            spoutEnabled = true;
-
-            SpoutConfig.getInstance();
-            SpoutUtils.setupSpoutConfigs();
-            SpoutUtils.registerCustomEvent();
-            SpoutUtils.preCacheFiles();
-            SpoutUtils.reloadSpoutPlayers(); // Handle spout players after a /reload
+        if (!getServer().getPluginManager().isPluginEnabled("Spout")) {
+            return;
         }
+
+        spoutEnabled = true;
+
+        SpoutConfig.getInstance();
+        getServer().getPluginManager().registerEvents(new SpoutListener(), this);
+        SpoutUtils.preCacheFiles();
+        SpoutUtils.reloadSpoutPlayers(); // Handle spout players after a /reload
     }
 
     private void registerEvents() {
         PluginManager pluginManager = getServer().getPluginManager();
 
         // Register events
-        pluginManager.registerEvents(playerListener, this);
-        pluginManager.registerEvents(blockListener, this);
-        pluginManager.registerEvents(entityListener, this);
-        pluginManager.registerEvents(inventoryListener, this);
-        pluginManager.registerEvents(selfListener, this);
-        pluginManager.registerEvents(worldListener, this);
-    }
-
-    /**
-     * Register the commands.
-     */
-    private void registerCommands() {
-        CommandRegistrationManager.registerSkillCommands();
-
-        // mc* commands
-        CommandRegistrationManager.registerMcpurgeCommand();
-        CommandRegistrationManager.registerMcremoveCommand();
-        CommandRegistrationManager.registerMcabilityCommand();
-        CommandRegistrationManager.registerMcgodCommand();
-        CommandRegistrationManager.registerMcmmoCommand();
-        CommandRegistrationManager.registerMcrefreshCommand();
-        CommandRegistrationManager.registerMctopCommand();
-        CommandRegistrationManager.registerMcrankCommand();
-        CommandRegistrationManager.registerMcstatsCommand();
-
-        // Party commands
-        CommandRegistrationManager.registerAdminChatCommand();
-        CommandRegistrationManager.registerPartyCommand();
-        CommandRegistrationManager.registerPartyChatCommand();
-        CommandRegistrationManager.registerPtpCommand();
-
-        // Other commands
-        CommandRegistrationManager.registerAddxpCommand();
-        CommandRegistrationManager.registerAddlevelsCommand();
-        CommandRegistrationManager.registerMmoeditCommand();
-        CommandRegistrationManager.registerInspectCommand();
-        CommandRegistrationManager.registerXprateCommand();
-        CommandRegistrationManager.registerMmoupdateCommand();
-        CommandRegistrationManager.registerSkillresetCommand();
-        CommandRegistrationManager.registerHardcoreCommand();
-        CommandRegistrationManager.registerVampirismCommand();
-        CommandRegistrationManager.registerMcnotifyCommand();
-
-        // Spout commands
-        CommandRegistrationManager.registerXplockCommand();
-        CommandRegistrationManager.registerMchudCommand();
+        pluginManager.registerEvents(new PlayerListener(this), this);
+        pluginManager.registerEvents(new BlockListener(this), this);
+        pluginManager.registerEvents(new EntityListener(this), this);
+        pluginManager.registerEvents(new InventoryListener(this), this);
+        pluginManager.registerEvents(new SelfListener(), this);
+        pluginManager.registerEvents(new WorldListener(this), this);
     }
 
     private void registerCustomRecipes() {
@@ -370,52 +350,29 @@ public class mcMMO extends JavaPlugin {
     private void scheduleTasks() {
         // Periodic save timer (Saves every 10 minutes by default)
         long saveIntervalTicks = Config.getInstance().getSaveInterval() * 1200;
-
         new SaveTimerTask().runTaskTimer(this, saveIntervalTicks, saveIntervalTicks);
 
-        // Regen & Cooldown timer (Runs every second)
-        new SkillMonitorTask().runTaskTimer(this, 20, 20);
-
         // Bleed timer (Runs every two seconds)
-        new BleedTimerTask().runTaskTimer(this, 40, 40);
+        new BleedTimerTask().runTaskTimer(this, 2 * Misc.TICK_CONVERSION_FACTOR, 2 * Misc.TICK_CONVERSION_FACTOR);
 
         // Old & Powerless User remover
-        int purgeInterval = Config.getInstance().getPurgeInterval();
-        UserPurgeTask userPurgeTask = new UserPurgeTask();
+        long purgeIntervalTicks = Config.getInstance().getPurgeInterval() * 60 * 60 * Misc.TICK_CONVERSION_FACTOR;
 
-        if (purgeInterval == 0) {
-            userPurgeTask.runTaskLater(this, 40);
+        if (purgeIntervalTicks == 0) {
+            new UserPurgeTask().runTaskLater(this, 2 * Misc.TICK_CONVERSION_FACTOR); // Start 2 seconds after startup.
         }
-        else if (purgeInterval > 0) {
-            long purgeIntervalTicks = purgeInterval * 60 * 60 * 20;
-
-            userPurgeTask.runTaskTimer(this, purgeIntervalTicks, purgeIntervalTicks);
+        else if (purgeIntervalTicks > 0) {
+            new UserPurgeTask().runTaskTimer(this, purgeIntervalTicks, purgeIntervalTicks);
         }
 
         // Automatically remove old members from parties
-        long kickInterval = Config.getInstance().getAutoPartyKickInterval();
-        PartyAutoKickTask partyAutoKickTask = new PartyAutoKickTask();
+        long kickIntervalTicks = Config.getInstance().getAutoPartyKickInterval() * 60 * 60 * Misc.TICK_CONVERSION_FACTOR;
 
-        if (kickInterval == 0) {
-            partyAutoKickTask.runTaskLater(this, 40); // Start 2 seconds after startup.
+        if (kickIntervalTicks == 0) {
+            new PartyAutoKickTask().runTaskLater(this, 2 * Misc.TICK_CONVERSION_FACTOR); // Start 2 seconds after startup.
         }
-        else if (kickInterval > 0) {
-            long kickIntervalTicks = kickInterval * 60 * 60 * 20;
-
-            partyAutoKickTask.runTaskTimer(this, kickIntervalTicks, kickIntervalTicks);
-        }
-    }
-
-    /**
-     * Because /reload is the biggest piece of garbage in existence,
-     * we have to do some special checks to keep it from breaking everything.
-     */
-    private void reloadDisableHelper() {
-        for (McMMOPlayer mcMMOPlayer : UserManager.getPlayers().values()) {
-            if (mcMMOPlayer.getAbilityMode(AbilityType.BERSERK)) {
-                mcMMOPlayer.setAbilityMode(AbilityType.BERSERK, false);
-                mcMMOPlayer.getPlayer().setCanPickupItems(true);
-            }
+        else if (kickIntervalTicks > 0) {
+            new PartyAutoKickTask().runTaskTimer(this, kickIntervalTicks, kickIntervalTicks);
         }
     }
 }