Converting mcMMO to gradle (NOT DONE YET)

mcMMO-core/.gradle/buildOutputCleanup/cache.properties

@@ -0,0 +1,2 @@
+#Wed Feb 06 17:16:15 PST 2019
+gradle.version=4.10

mcMMO-core/build.gradle

@@ -0,0 +1,16 @@
+plugins {
+    id 'java'
+}
+
+group 'com.com.gmail.com.gmail.nossr50.mcmmo'
+version '2.2.0-SNAPSHOT'
+
+sourceCompatibility = 1.8
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    testCompile group: 'junit', name: 'junit', version: '4.12'
+}

mcMMO-core/gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,6 @@
+#Wed Feb 06 17:16:30 PST 2019
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-4.10-all.zip

mcMMO-core/gradlew

@@ -0,0 +1,172 @@
+#!/usr/bin/env sh
+
+##############################################################################
+##
+##  Gradle start up script for UN*X
+##
+##############################################################################
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS=""
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn () {
+    echo "$*"
+}
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+  NONSTOP* )
+    nonstop=true
+    ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+        JAVACMD="$JAVA_HOME/bin/java"
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD="java"
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
+    MAX_FD_LIMIT=`ulimit -H -n`
+    if [ $? -eq 0 ] ; then
+        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+            MAX_FD="$MAX_FD_LIMIT"
+        fi
+        ulimit -n $MAX_FD
+        if [ $? -ne 0 ] ; then
+            warn "Could not set maximum file descriptor limit: $MAX_FD"
+        fi
+    else
+        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+    fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
+    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+    JAVACMD=`cygpath --unix "$JAVACMD"`
+
+    # We build the pattern for arguments to be converted via cygpath
+    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+    SEP=""
+    for dir in $ROOTDIRSRAW ; do
+        ROOTDIRS="$ROOTDIRS$SEP$dir"
+        SEP="|"
+    done
+    OURCYGPATTERN="(^($ROOTDIRS))"
+    # Add a user-defined pattern to the cygpath arguments
+    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+    fi
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    i=0
+    for arg in "$@" ; do
+        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
+
+        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
+            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+        else
+            eval `echo args$i`="\"$arg\""
+        fi
+        i=$((i+1))
+    done
+    case $i in
+        (0) set -- ;;
+        (1) set -- "$args0" ;;
+        (2) set -- "$args0" "$args1" ;;
+        (3) set -- "$args0" "$args1" "$args2" ;;
+        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+    esac
+fi
+
+# Escape application args
+save () {
+    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+    echo " "
+}
+APP_ARGS=$(save "$@")
+
+# Collect all arguments for the java command, following the shell quoting and substitution rules
+eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+
+# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
+if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
+  cd "$(dirname "$0")"
+fi
+
+exec "$JAVACMD" "$@"

mcMMO-core/gradlew.bat

@@ -0,0 +1,84 @@
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS=
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto init
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto init
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:init
+@rem Get command-line arguments, handling Windows variants
+
+if not "%OS%" == "Windows_NT" goto win9xME_args
+
+:win9xME_args
+@rem Slurp the command line arguments.
+set CMD_LINE_ARGS=
+set _SKIP=2
+
+:win9xME_args_slurp
+if "x%~1" == "x" goto execute
+
+set CMD_LINE_ARGS=%*
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

mcMMO-core/settings.gradle

@@ -0,0 +1,2 @@
+rootProject.name = 'mcMMO'
+

mcMMO-core/src/main/java/META-INF/MANIFEST.MF

@@ -0,0 +1,3 @@
+Manifest-Version: 1.0
+Main-Class: com.gmail.nossr50.mcMMO
+

mcMMO-core/src/main/java/com/gmail/nossr50/api/AbilityAPI.java

@@ -0,0 +1,88 @@
+package com.gmail.nossr50.api;
+
+import com.gmail.nossr50.datatypes.player.McMMOPlayer;
+import com.gmail.nossr50.datatypes.skills.SuperAbilityType;
+import com.gmail.nossr50.runnables.skills.BleedTimerTask;
+import com.gmail.nossr50.util.player.UserManager;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+
+public final class AbilityAPI {
+    private AbilityAPI() {}
+
+    public static boolean berserkEnabled(Player player) {
+        return UserManager.getPlayer(player).getAbilityMode(SuperAbilityType.BERSERK);
+    }
+
+    public static boolean gigaDrillBreakerEnabled(Player player) {
+        return UserManager.getPlayer(player).getAbilityMode(SuperAbilityType.GIGA_DRILL_BREAKER);
+    }
+
+    public static boolean greenTerraEnabled(Player player) {
+        return UserManager.getPlayer(player).getAbilityMode(SuperAbilityType.GREEN_TERRA);
+    }
+
+    public static boolean serratedStrikesEnabled(Player player) {
+        return UserManager.getPlayer(player).getAbilityMode(SuperAbilityType.SERRATED_STRIKES);
+    }
+
+    public static boolean skullSplitterEnabled(Player player) {
+        return UserManager.getPlayer(player).getAbilityMode(SuperAbilityType.SKULL_SPLITTER);
+    }
+
+    public static boolean superBreakerEnabled(Player player) {
+        return UserManager.getPlayer(player).getAbilityMode(SuperAbilityType.SUPER_BREAKER);
+    }
+
+    public static boolean treeFellerEnabled(Player player) {
+        return UserManager.getPlayer(player).getAbilityMode(SuperAbilityType.TREE_FELLER);
+    }
+
+    public static boolean isAnyAbilityEnabled(Player player) {
+        McMMOPlayer mcMMOPlayer = UserManager.getPlayer(player);
+
+        for (SuperAbilityType ability : SuperAbilityType.values()) {
+            if (mcMMOPlayer.getAbilityMode(ability)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public static void resetCooldowns(Player player) {
+        UserManager.getPlayer(player).resetCooldowns();
+    }
+
+    public static void setBerserkCooldown(Player player, long cooldown) {
+        UserManager.getPlayer(player).setAbilityDATS(SuperAbilityType.BERSERK, cooldown);
+    }
+
+    public static void setGigaDrillBreakerCooldown(Player player, long cooldown) {
+        UserManager.getPlayer(player).setAbilityDATS(SuperAbilityType.GIGA_DRILL_BREAKER, cooldown);
+    }
+
+    public static void setGreenTerraCooldown(Player player, long cooldown) {
+        UserManager.getPlayer(player).setAbilityDATS(SuperAbilityType.GREEN_TERRA, cooldown);
+    }
+
+    public static void setSerratedStrikesCooldown(Player player, long cooldown) {
+        UserManager.getPlayer(player).setAbilityDATS(SuperAbilityType.SERRATED_STRIKES, cooldown);
+    }
+
+    public static void setSkullSplitterCooldown(Player player, long cooldown) {
+        UserManager.getPlayer(player).setAbilityDATS(SuperAbilityType.SKULL_SPLITTER, cooldown);
+    }
+
+    public static void setSuperBreakerCooldown(Player player, long cooldown) {
+        UserManager.getPlayer(player).setAbilityDATS(SuperAbilityType.SUPER_BREAKER, cooldown);
+    }
+
+    public static void setTreeFellerCooldown(Player player, long cooldown) {
+        UserManager.getPlayer(player).setAbilityDATS(SuperAbilityType.TREE_FELLER, cooldown);
+    }
+
+    public static boolean isBleeding(LivingEntity entity) {
+        return BleedTimerTask.isBleeding(entity);
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/api/ChatAPI.java

@@ -0,0 +1,153 @@
+package com.gmail.nossr50.api;
+
+import com.gmail.nossr50.chat.ChatManager;
+import com.gmail.nossr50.chat.ChatManagerFactory;
+import com.gmail.nossr50.chat.PartyChatManager;
+import com.gmail.nossr50.datatypes.chat.ChatMode;
+import com.gmail.nossr50.party.PartyManager;
+import com.gmail.nossr50.util.player.UserManager;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.Plugin;
+
+public final class ChatAPI {
+    private ChatAPI() {}
+
+    /**
+     * Send a message to all members of a party
+     * </br>
+     * This function is designed for API usage.
+     *
+     * @param plugin The plugin sending the message
+     * @param sender The name of the sender
+     * @param displayName The display name of the sender
+     * @param party The name of the party to send to
+     * @param message The message to send
+     */
+    public static void sendPartyChat(Plugin plugin, String sender, String displayName, String party, String message) {
+        getPartyChatManager(plugin, party).handleChat(sender, displayName, message);
+    }
+
+    /**
+     * Send a message to all members of a party
+     * </br>
+     * This function is designed for API usage.
+     *
+     * @param plugin The plugin sending the message
+     * @param sender The name of the sender to display in the chat
+     * @param party The name of the party to send to
+     * @param message The message to send
+     */
+    public static void sendPartyChat(Plugin plugin, String sender, String party, String message) {
+        getPartyChatManager(plugin, party).handleChat(sender, message);
+    }
+
+    /**
+     * Send a message to administrators
+     * </br>
+     * This function is designed for API usage.
+     *
+     * @param plugin The plugin sending the message
+     * @param sender The name of the sender
+     * @param displayName The display name of the sender
+     * @param message The message to send
+     */
+    public static void sendAdminChat(Plugin plugin, String sender, String displayName, String message) {
+        ChatManagerFactory.getChatManager(plugin, ChatMode.ADMIN).handleChat(sender, displayName, message);
+    }
+
+    /**
+     * Send a message to administrators
+     * </br>
+     * This function is designed for API usage.
+     *
+     * @param plugin The plugin sending the message
+     * @param sender The name of the sender to display in the chat
+     * @param message The message to send
+     */
+    public static void sendAdminChat(Plugin plugin, String sender, String message) {
+        ChatManagerFactory.getChatManager(plugin, ChatMode.ADMIN).handleChat(sender, message);
+    }
+
+    /**
+     * Check if a player is currently talking in party chat.
+     *
+     * @param player The player to check
+     * @return true if the player is using party chat, false otherwise
+     */
+    public static boolean isUsingPartyChat(Player player) {
+        return UserManager.getPlayer(player).isChatEnabled(ChatMode.PARTY);
+    }
+
+    /**
+     * Check if a player is currently talking in party chat.
+     *
+     * @param playerName The name of the player to check
+     * @return true if the player is using party chat, false otherwise
+     */
+    public static boolean isUsingPartyChat(String playerName) {
+        return UserManager.getPlayer(playerName).isChatEnabled(ChatMode.PARTY);
+    }
+
+    /**
+     * Check if a player is currently talking in admin chat.
+     *
+     * @param player The player to check
+     * @return true if the player is using admin chat, false otherwise
+     */
+    public static boolean isUsingAdminChat(Player player) {
+        return UserManager.getPlayer(player).isChatEnabled(ChatMode.ADMIN);
+    }
+
+    /**
+     * Check if a player is currently talking in admin chat.
+     *
+     * @param playerName The name of the player to check
+     * @return true if the player is using admin chat, false otherwise
+     */
+    public static boolean isUsingAdminChat(String playerName) {
+        return UserManager.getPlayer(playerName).isChatEnabled(ChatMode.ADMIN);
+    }
+
+    /**
+     * Toggle the party chat mode of a player.
+     *
+     * @param player The player to toggle party chat on.
+     */
+    public static void togglePartyChat(Player player) {
+        UserManager.getPlayer(player).toggleChat(ChatMode.PARTY);
+    }
+
+    /**
+     * Toggle the party chat mode of a player.
+     *
+     * @param playerName The name of the player to toggle party chat on.
+     */
+    public static void togglePartyChat(String playerName) {
+        UserManager.getPlayer(playerName).toggleChat(ChatMode.PARTY);
+    }
+
+    /**
+     * Toggle the admin chat mode of a player.
+     *
+     * @param player The player to toggle admin chat on.
+     */
+    public static void toggleAdminChat(Player player) {
+        UserManager.getPlayer(player).toggleChat(ChatMode.ADMIN);
+    }
+
+    /**
+     * Toggle the admin chat mode of a player.
+     *
+     * @param playerName The name of the player to toggle party chat on.
+     */
+    public static void toggleAdminChat(String playerName) {
+        UserManager.getPlayer(playerName).toggleChat(ChatMode.ADMIN);
+    }
+
+    private static ChatManager getPartyChatManager(Plugin plugin, String party) {
+        ChatManager chatManager = ChatManagerFactory.getChatManager(plugin, ChatMode.PARTY);
+        ((PartyChatManager) chatManager).setParty(PartyManager.getParty(party));
+
+        return chatManager;
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/api/PartyAPI.java

@@ -0,0 +1,242 @@
+package com.gmail.nossr50.api;
+
+import com.gmail.nossr50.config.Config;
+import com.gmail.nossr50.datatypes.interactions.NotificationType;
+import com.gmail.nossr50.datatypes.party.Party;
+import com.gmail.nossr50.datatypes.party.PartyLeader;
+import com.gmail.nossr50.mcMMO;
+import com.gmail.nossr50.party.PartyManager;
+import com.gmail.nossr50.util.player.NotificationManager;
+import com.gmail.nossr50.util.player.UserManager;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.entity.Player;
+
+import java.util.*;
+
+public final class PartyAPI {
+    private PartyAPI() {}
+
+    /**
+     * Get the name of the party a player is in.
+     * </br>
+     * This function is designed for API usage.
+     *
+     * @param player The player to check the party name of
+     * @return the name of the player's party, or null if not in a party
+     */
+    public static String getPartyName(Player player) {
+        if (!inParty(player)) {
+            return null;
+        }
+
+        return UserManager.getPlayer(player).getParty().getName();
+    }
+
+    /**
+     * Checks if a player is in a party.
+     * </br>
+     * This function is designed for API usage.
+     *
+     * @param player The player to check
+     * @return true if the player is in a party, false otherwise
+     */
+    public static boolean inParty(Player player) {
+        return UserManager.getPlayer(player).inParty();
+    }
+
+    /**
+     * Check if two players are in the same party.
+     * </br>
+     * This function is designed for API usage.
+     *
+     * @param playera The first player to check
+     * @param playerb The second player to check
+     * @return true if the two players are in the same party, false otherwise
+     */
+    public static boolean inSameParty(Player playera, Player playerb) {
+        return PartyManager.inSameParty(playera, playerb);
+    }
+
+    /**
+     * Get a list of all current parties.
+     * </br>
+     * This function is designed for API usage.
+     *
+     * @return the list of parties.
+     */
+    public static List<Party> getParties() {
+        return PartyManager.getParties();
+    }
+
+    /**
+     * Add a player to a party.
+     * </br>
+     * This function is designed for API usage.
+     *
+     * @param player The player to add to the party
+     * @param partyName The party to add the player to
+     * @deprecated parties can have limits, use the other method
+     */
+    @Deprecated
+    public static void addToParty(Player player, String partyName) {
+        Party party = PartyManager.getParty(partyName);
+
+        if (party == null) {
+            party = new Party(new PartyLeader(player.getUniqueId(), player.getName()), partyName);
+        } else {
+            if(PartyManager.isPartyFull(player, party))
+            {
+                NotificationManager.sendPlayerInformation(player, NotificationType.PARTY_MESSAGE, "Commands.Party.PartyFull", party.toString());
+                return;
+            }
+        }
+
+        PartyManager.addToParty(UserManager.getPlayer(player), party);
+    }
+
+    /**
+     * The max party size of the server
+     * 0 or less for no size limit
+     * @return the max party size on this server
+     */
+    public static int getMaxPartySize()
+    {
+        return Config.getInstance().getPartyMaxSize();
+    }
+
+    /**
+     * Add a player to a party.
+     * </br>
+     * This function is designed for API usage.
+     *
+     * @param player The player to add to the party
+     * @param partyName The party to add the player to
+     * @param bypassLimit if true bypasses party size limits
+     */
+    public static void addToParty(Player player, String partyName, boolean bypassLimit) {
+        Party party = PartyManager.getParty(partyName);
+
+        if (party == null) {
+            party = new Party(new PartyLeader(player.getUniqueId(), player.getName()), partyName);
+        }
+
+        PartyManager.addToParty(UserManager.getPlayer(player), party);
+    }
+
+    /**
+     * Remove a player from a party.
+     * </br>
+     * This function is designed for API usage.
+     *
+     * @param player The player to remove
+     */
+    public static void removeFromParty(Player player) {
+        PartyManager.removeFromParty(UserManager.getPlayer(player));
+    }
+
+    /**
+     * Get the leader of a party.
+     * </br>
+     * This function is designed for API usage.
+     *
+     * @param partyName The party name
+     * @return the leader of the party
+     */
+    public static String getPartyLeader(String partyName) {
+        return PartyManager.getPartyLeaderName(partyName);
+    }
+
+    /**
+     * Set the leader of a party.
+     * </br>
+     * This function is designed for API usage.
+     *
+     * @param partyName The name of the party to set the leader of
+     * @param playerName The playerName to set as leader
+     */
+    @Deprecated
+    public static void setPartyLeader(String partyName, String playerName) {
+        PartyManager.setPartyLeader(mcMMO.p.getServer().getOfflinePlayer(playerName).getUniqueId(), PartyManager.getParty(partyName));
+    }
+
+    /**
+     * Get a list of all players in this player's party.
+     * </br>
+     * This function is designed for API usage.
+     *
+     * @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 (UUID memberUniqueId : PartyManager.getAllMembers(player).keySet()) {
+            OfflinePlayer member = mcMMO.p.getServer().getOfflinePlayer(memberUniqueId);
+            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
+     */
+    @Deprecated
+    public static LinkedHashSet<String> getMembers(Player player) {
+        return (LinkedHashSet<String>) PartyManager.getAllMembers(player).values();
+    }
+
+    /**
+     * Get a list of all player names and uuids in this player's party.
+     * </br>
+     * This function is designed for API usage.
+     *
+     * @param player The player to check
+     * @return all the player names and uuids in the player's party
+     */
+    public static LinkedHashMap<UUID, String> getMembersMap(Player player) {
+        return PartyManager.getAllMembers(player);
+    }
+
+    /**
+     * Get a list of all online players in this party.
+     * </br>
+     * This function is designed for API usage.
+     *
+     * @param partyName The party to check
+     * @return all online players in this party
+     */
+    public static List<Player> getOnlineMembers(String partyName) {
+        return PartyManager.getOnlineMembers(partyName);
+    }
+
+    /**
+     * Get a list of all online players in this player's party.
+     * </br>
+     * This function is designed for API usage.
+     *
+     * @param player The player to check
+     * @return all online players in the player's party
+     */
+    public static List<Player> getOnlineMembers(Player player) {
+        return PartyManager.getOnlineMembers(player);
+    }
+
+    public static boolean hasAlly(String partyName) {
+        return getAllyName(partyName) != null;
+    }
+
+    public static String getAllyName(String partyName) {
+        Party ally = PartyManager.getParty(partyName).getAlly();
+        if (ally != null) {
+            return ally.getName();
+        }
+
+        return null;
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/api/SkillAPI.java

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

mcMMO-core/src/main/java/com/gmail/nossr50/api/exceptions/InvalidFormulaTypeException.java

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

mcMMO-core/src/main/java/com/gmail/nossr50/api/exceptions/InvalidPlayerException.java

@@ -0,0 +1,9 @@
+package com.gmail.nossr50.api.exceptions;
+
+public class InvalidPlayerException extends RuntimeException {
+    private static final long serialVersionUID = 907213002618581385L;
+
+    public InvalidPlayerException() {
+        super("That player does not exist in the database.");
+    }
+}

mcMMO-core/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.");
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/api/exceptions/InvalidXPGainReasonException.java

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

mcMMO-core/src/main/java/com/gmail/nossr50/api/exceptions/McMMOPlayerNotFoundException.java

@@ -0,0 +1,11 @@
+package com.gmail.nossr50.api.exceptions;
+
+import org.bukkit.entity.Player;
+
+public class McMMOPlayerNotFoundException extends RuntimeException {
+    private static final long serialVersionUID = 761917904993202836L;
+
+    public McMMOPlayerNotFoundException(Player player) {
+        super("McMMOPlayer object was not found for: " + player.getName() + " " + player.getUniqueId());
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/chat/AdminChatManager.java

@@ -0,0 +1,21 @@
+package com.gmail.nossr50.chat;
+
+import com.gmail.nossr50.config.Config;
+import com.gmail.nossr50.events.chat.McMMOAdminChatEvent;
+import org.bukkit.plugin.Plugin;
+
+public class AdminChatManager extends ChatManager {
+    protected AdminChatManager(Plugin plugin) {
+        super(plugin, Config.getInstance().getAdminDisplayNames(), Config.getInstance().getAdminChatPrefix());
+    }
+
+    @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");
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/chat/ChatManager.java

@@ -0,0 +1,85 @@
+package com.gmail.nossr50.chat;
+
+import com.gmail.nossr50.datatypes.party.Party;
+import com.gmail.nossr50.events.chat.McMMOChatEvent;
+import com.gmail.nossr50.events.chat.McMMOPartyChatEvent;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.util.player.UserManager;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.Plugin;
+
+public abstract class ChatManager {
+    protected Plugin plugin;
+    protected boolean useDisplayNames;
+    protected String chatPrefix;
+
+    protected String senderName;
+    protected String displayName;
+    protected String message;
+
+    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;
+        }
+
+        senderName = event.getSender();
+        displayName = useDisplayNames ? event.getDisplayName() : senderName;
+        message = LocaleLoader.formatString(chatPrefix, displayName) + " " + event.getMessage();
+
+        sendMessage();
+
+        /*
+         * Party Chat Spying
+         * Party messages will be copied to people with the mcmmo.admin.chatspy permission node
+         */
+        if(event instanceof McMMOPartyChatEvent)
+        {
+            //We need to grab the party chat name
+            McMMOPartyChatEvent partyChatEvent = (McMMOPartyChatEvent) event;
+
+            //Find the people with permissions
+            for(Player player : event.getPlugin().getServer().getOnlinePlayers())
+            {
+                //Check for toggled players
+                if(UserManager.getPlayer(player).isPartyChatSpying())
+                {
+                    Party adminParty = UserManager.getPlayer(player).getParty();
+
+                    //Only message admins not part of this party
+                    if(adminParty != null)
+                    {
+                        //TODO: Incorporate JSON
+                        if(!adminParty.getName().equalsIgnoreCase(partyChatEvent.getParty()))
+                            player.sendMessage(LocaleLoader.getString("Commands.AdminChatSpy.Chat", partyChatEvent.getParty(), message));
+                    } else {
+                        player.sendMessage(LocaleLoader.getString("Commands.AdminChatSpy.Chat", partyChatEvent.getParty(), message));
+                    }
+                }
+            }
+        }
+    }
+
+    public void handleChat(String senderName, String message) {
+        handleChat(senderName, senderName, message, false);
+    }
+
+    public void handleChat(Player player, String message, boolean isAsync) {
+        handleChat(player.getName(), player.getDisplayName(), message, isAsync);
+    }
+
+    public void handleChat(String senderName, String displayName, String message) {
+        handleChat(senderName, displayName, message, false);
+    }
+
+    public abstract void handleChat(String senderName, String displayName, String message, boolean isAsync);
+
+    protected abstract void sendMessage();
+}

mcMMO-core/src/main/java/com/gmail/nossr50/chat/ChatManagerFactory.java

@@ -0,0 +1,30 @@
+package com.gmail.nossr50.chat;
+
+import com.gmail.nossr50.datatypes.chat.ChatMode;
+import org.bukkit.plugin.Plugin;
+
+import java.util.HashMap;
+
+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;
+        }
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/chat/PartyChatManager.java

@@ -0,0 +1,29 @@
+package com.gmail.nossr50.chat;
+
+import com.gmail.nossr50.config.Config;
+import com.gmail.nossr50.datatypes.party.Party;
+import com.gmail.nossr50.events.chat.McMMOPartyChatEvent;
+import com.gmail.nossr50.runnables.party.PartyChatTask;
+import org.bukkit.plugin.Plugin;
+
+public class PartyChatManager extends ChatManager {
+    private Party party;
+
+    protected PartyChatManager(Plugin plugin) {
+        super(plugin, Config.getInstance().getPartyDisplayNames(), Config.getInstance().getPartyChatPrefix());
+    }
+
+    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() {
+        new PartyChatTask(plugin, party, senderName, displayName, message).runTask(plugin);
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/MHDCommand.java

@@ -0,0 +1,45 @@
+package com.gmail.nossr50.commands;
+
+import com.gmail.nossr50.config.Config;
+import com.gmail.nossr50.database.FlatfileDatabaseManager;
+import com.gmail.nossr50.database.SQLDatabaseManager;
+import com.gmail.nossr50.datatypes.player.McMMOPlayer;
+import com.gmail.nossr50.mcMMO;
+import com.gmail.nossr50.util.player.UserManager;
+import com.google.common.collect.ImmutableList;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
+
+import java.util.List;
+
+public class MHDCommand implements TabExecutor {
+
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        if (mcMMO.getDatabaseManager() instanceof SQLDatabaseManager) {
+            SQLDatabaseManager m = (SQLDatabaseManager) mcMMO.getDatabaseManager();
+            m.resetMobHealthSettings();
+            for (McMMOPlayer player : UserManager.getPlayers()) {
+                player.getProfile().setMobHealthbarType(Config.getInstance().getMobHealthbarDefault());
+            }
+            sender.sendMessage("Mob health reset");
+            return true;
+        }
+        if (mcMMO.getDatabaseManager() instanceof FlatfileDatabaseManager) {
+            FlatfileDatabaseManager m = (FlatfileDatabaseManager) mcMMO.getDatabaseManager();
+            m.resetMobHealthSettings();
+            for (McMMOPlayer player : UserManager.getPlayers()) {
+                player.getProfile().setMobHealthbarType(Config.getInstance().getMobHealthbarDefault());
+            }
+            sender.sendMessage("Mob health reset");
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) {
+        return ImmutableList.of();
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/McImportCommand.java

@@ -0,0 +1,344 @@
+package com.gmail.nossr50.commands;
+
+import com.gmail.nossr50.datatypes.skills.ModConfigType;
+import com.gmail.nossr50.mcMMO;
+import com.gmail.nossr50.util.Misc;
+import org.bukkit.Material;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+
+import java.io.*;
+import java.util.ArrayList;
+import java.util.HashMap;
+
+public class McImportCommand implements CommandExecutor {
+    int fileAmount;
+
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        switch (args.length) {
+            case 0:
+                importModConfig();
+                return true;
+
+            default:
+                return false;
+        }
+    }
+
+    public boolean importModConfig() {
+        String importFilePath = mcMMO.getModDirectory() + File.separator + "import";
+        File importFile = new File(importFilePath, "import.log");
+        mcMMO.p.getLogger().info("Starting import of mod materials...");
+        fileAmount = 0;
+
+        HashMap<ModConfigType, ArrayList<String>> materialNames = new HashMap<ModConfigType, ArrayList<String>>();
+
+        BufferedReader in = null;
+
+        try {
+            // Open the file
+            in = new BufferedReader(new FileReader(importFile));
+
+            String line;
+            String materialName;
+            String modName;
+
+            // While not at the end of the file
+            while ((line = in.readLine()) != null) {
+                String[] split1 = line.split("material ");
+
+                if (split1.length != 2) {
+                    continue;
+                }
+
+                String[] split2 = split1[1].split(" with");
+
+                if (split2.length != 2) {
+                    continue;
+                }
+
+                materialName = split2[0];
+
+                // Categorise each material under a mod config type
+                ModConfigType type = ModConfigType.getModConfigType(materialName);
+
+                if (!materialNames.containsKey(type)) {
+                    materialNames.put(type, new ArrayList<String>());
+                }
+
+                materialNames.get(type).add(materialName);
+                continue;
+            }
+        }
+        catch (FileNotFoundException e) {
+            mcMMO.p.getLogger().warning("Could not find " + importFile.getAbsolutePath() + " ! (No such file or directory)");
+            mcMMO.p.getLogger().warning("Copy and paste latest.log to " + importFile.getParentFile().getAbsolutePath() + " and rename it to import.log");
+            return false;
+        }
+        catch (Exception e) {
+            e.printStackTrace();
+            return false;
+        }
+        finally {
+            tryClose(in);
+        }
+
+        createOutput(materialNames);
+
+        mcMMO.p.getLogger().info("Import finished! Created " + fileAmount + " files!");
+        return true;
+    }
+
+    private void createOutput(HashMap<ModConfigType, ArrayList<String>> materialNames) {
+        for (ModConfigType modConfigType : materialNames.keySet()) {
+            HashMap<String, ArrayList<String>> materialNamesType = new HashMap<String, ArrayList<String>>();
+
+            for (String materialName : materialNames.get(modConfigType)) {
+                String modName = Misc.getModName(materialName);
+
+                if (!materialNamesType.containsKey(modName)) {
+                    materialNamesType.put(modName, new ArrayList<String>());
+                }
+
+                materialNamesType.get(modName).add(materialName);
+            }
+
+            createOutput(modConfigType, materialNamesType);
+        }
+
+    }
+
+    private void tryClose(Closeable c) {
+        if (c == null) {
+            return;
+        }
+        try {
+            c.close();
+        }
+        catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private void createOutput(ModConfigType modConfigType, HashMap<String, ArrayList<String>> materialNames) {
+        File outputFilePath = new File(mcMMO.getModDirectory() + File.separator + "output");
+        if (!outputFilePath.exists() && !outputFilePath.mkdirs()) {
+            mcMMO.p.getLogger().severe("Could not create output directory! " + outputFilePath.getAbsolutePath());
+        }
+
+        FileWriter out = null;
+        String type = modConfigType.name().toLowerCase();
+
+        for (String modName : materialNames.keySet()) {
+            File outputFile = new File(outputFilePath, modName + "." + type + ".yml");
+            mcMMO.p.getLogger().info("Creating " + outputFile.getName());
+            try {
+                if (outputFile.exists() && !outputFile.delete()) {
+                    mcMMO.p.getLogger().severe("Not able to delete old output file! " + outputFile.getAbsolutePath());
+                }
+
+                if (!outputFile.createNewFile()) {
+                    mcMMO.p.getLogger().severe("Could not create output file! " + outputFile.getAbsolutePath());
+                    continue;
+                }
+
+                StringBuilder writer = new StringBuilder();
+                HashMap<String, ArrayList<String>> configSections = getConfigSections(modConfigType, modName, materialNames);
+
+                if (configSections == null) {
+                    mcMMO.p.getLogger().severe("Something went wrong!! type is " + type);
+                    return;
+                }
+
+                // Write the file, go through each skill and write all the materials
+                for (String configSection : configSections.keySet()) {
+                    if (configSection.equals("UNIDENTIFIED")) {
+                        writer.append("# This isn't a valid config section and all materials in this category need to be").append("\r\n");
+                        writer.append("# copy and pasted to a valid section of this config file.").append("\r\n");
+                    }
+                    writer.append(configSection).append(":").append("\r\n");
+
+                    for (String line : configSections.get(configSection)) {
+                        writer.append(line).append("\r\n");
+                    }
+
+                    writer.append("\r\n");
+                }
+
+                out = new FileWriter(outputFile);
+                out.write(writer.toString());
+            }
+            catch (IOException e) {
+                e.printStackTrace();
+                return;
+            }
+            catch (Exception e) {
+                e.printStackTrace();
+                return;
+            }
+            finally {
+                tryClose(out);
+                fileAmount++;
+            }
+        }
+    }
+
+    private HashMap<String, ArrayList<String>> getConfigSections(ModConfigType type, String modName, HashMap<String, ArrayList<String>> materialNames) {
+        switch (type) {
+            case BLOCKS:
+                return getConfigSectionsBlocks(modName, materialNames);
+            case TOOLS:
+                return getConfigSectionsTools(modName, materialNames);
+            case ARMOR:
+                return getConfigSectionsArmor(modName, materialNames);
+            case UNKNOWN:
+                return getConfigSectionsUnknown(modName, materialNames);
+        }
+
+        return null;
+    }
+
+    private HashMap<String, ArrayList<String>> getConfigSectionsBlocks(String modName, HashMap<String, ArrayList<String>> materialNames) {
+        HashMap<String, ArrayList<String>> configSections = new HashMap<String, ArrayList<String>>();
+
+        // Go through all the materials and categorise them under a skill
+        for (String materialName : materialNames.get(modName)) {
+            String skillName = "UNIDENTIFIED";
+            if (materialName.contains("ORE")) {
+                skillName = "Mining";
+            }
+            else if (materialName.contains("LOG") || materialName.contains("LEAVES")) {
+                skillName = "Woodcutting";
+            }
+            else if (materialName.contains("GRASS") || materialName.contains("FLOWER") || materialName.contains("CROP")) {
+                skillName = "Herbalism";
+            }
+            else if (materialName.contains("DIRT") || materialName.contains("SAND")) {
+                skillName = "Excavation";
+            }
+
+            if (!configSections.containsKey(skillName)) {
+                configSections.put(skillName, new ArrayList<String>());
+            }
+
+            ArrayList<String> skillContents = configSections.get(skillName);
+            skillContents.add("    " + materialName + "|0:");
+            skillContents.add("    " + "    " + "XP_Gain: 99");
+            skillContents.add("    " + "    " + "Double_Drops_Enabled: true");
+
+            if (skillName.equals("Mining")) {
+                skillContents.add("    " + "    " + "Smelting_XP_Gain: 9");
+            }
+            else if (skillName.equals("Woodcutting")) {
+                skillContents.add("    " + "    " + "Is_Log: " + materialName.contains("LOG"));
+            }
+        }
+
+        return configSections;
+    }
+
+    private HashMap<String, ArrayList<String>> getConfigSectionsTools(String modName, HashMap<String, ArrayList<String>> materialNames) {
+        HashMap<String, ArrayList<String>> configSections = new HashMap<String, ArrayList<String>>();
+
+        // Go through all the materials and categorise them under a tool type
+        for (String materialName : materialNames.get(modName)) {
+            String toolType = "UNIDENTIFIED";
+            if (materialName.contains("PICKAXE")) {
+                toolType = "Pickaxes";
+            }
+            else if (materialName.contains("AXE")) {
+                toolType = "Axes";
+            }
+            else if (materialName.contains("BOW")) {
+                toolType = "Bows";
+            }
+            else if (materialName.contains("HOE")) {
+                toolType = "Hoes";
+            }
+            else if (materialName.contains("SHOVEL") || materialName.contains("SPADE")) {
+                toolType = "Shovels";
+            }
+            else if (materialName.contains("SWORD")) {
+                toolType = "Swords";
+            }
+
+            if (!configSections.containsKey(toolType)) {
+                configSections.put(toolType, new ArrayList<String>());
+            }
+
+            ArrayList<String> skillContents = configSections.get(toolType);
+            skillContents.add("    " + materialName + ":");
+            skillContents.add("    " + "    " + "XP_Modifier: 1.0");
+            skillContents.add("    " + "    " + "Tier: 1");
+            skillContents.add("    " + "    " + "Ability_Enabled: true");
+            addRepairableLines(materialName, skillContents);
+        }
+
+        return configSections;
+    }
+
+    private HashMap<String, ArrayList<String>> getConfigSectionsArmor(String modName, HashMap<String, ArrayList<String>> materialNames) {
+        HashMap<String, ArrayList<String>> configSections = new HashMap<String, ArrayList<String>>();
+
+        // Go through all the materials and categorise them under an armor type
+        for (String materialName : materialNames.get(modName)) {
+            String toolType = "UNIDENTIFIED";
+            if (materialName.contains("BOOT") || materialName.contains("SHOE")) {
+                toolType = "Boots";
+            }
+            else if (materialName.contains("CHESTPLATE") || materialName.contains("CHEST")) {
+                toolType = "Chestplates";
+            }
+            else if (materialName.contains("HELM") || materialName.contains("HAT")) {
+                toolType = "Helmets";
+            }
+            else if (materialName.contains("LEGGINGS") || materialName.contains("LEGS") || materialName.contains("PANTS")) {
+                toolType = "Leggings";
+            }
+
+            if (!configSections.containsKey(toolType)) {
+                configSections.put(toolType, new ArrayList<String>());
+            }
+
+            ArrayList<String> skillContents = configSections.get(toolType);
+            skillContents.add("    " + materialName + ":");
+            addRepairableLines(materialName, skillContents);
+        }
+
+        return configSections;
+    }
+
+    private void addRepairableLines(String materialName, ArrayList<String> skillContents) {
+        skillContents.add("    " + "    " + "Repairable: true");
+        skillContents.add("    " + "    " + "Repair_Material: REPAIR_MATERIAL_NAME");
+        skillContents.add("    " + "    " + "Repair_Material_Data_Value: 0");
+        skillContents.add("    " + "    " + "Repair_Material_Quantity: 9");
+        skillContents.add("    " + "    " + "Repair_Material_Pretty_Name: Repair Item Name");
+        skillContents.add("    " + "    " + "Repair_MinimumLevel: 0");
+        skillContents.add("    " + "    " + "Repair_XpMultiplier: 1.0");
+
+        Material material = Material.matchMaterial(materialName);
+        short durability = (material == null) ? (short) 9999 : material.getMaxDurability();
+        skillContents.add("    " + "    " + "Durability: " + ((durability > 0) ? durability : (short) 9999));
+    }
+
+    private HashMap<String, ArrayList<String>> getConfigSectionsUnknown(String modName, HashMap<String, ArrayList<String>> materialNames) {
+        HashMap<String, ArrayList<String>> configSections = new HashMap<String, ArrayList<String>>();
+
+        // Go through all the materials and print them
+        for (String materialName : materialNames.get(modName)) {
+            String configKey = "UNIDENTIFIED";
+
+            if (!configSections.containsKey(configKey)) {
+                configSections.put(configKey, new ArrayList<String>());
+            }
+
+            ArrayList<String> skillContents = configSections.get(configKey);
+            skillContents.add("    " + materialName);
+        }
+
+        return configSections;
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/McabilityCommand.java

@@ -0,0 +1,29 @@
+package com.gmail.nossr50.commands;
+
+import com.gmail.nossr50.datatypes.player.McMMOPlayer;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.util.Permissions;
+import org.bukkit.command.CommandSender;
+
+public class McabilityCommand extends ToggleCommand {
+    @Override
+    protected boolean hasOtherPermission(CommandSender sender) {
+        return Permissions.mcabilityOthers(sender);
+    }
+
+    @Override
+    protected boolean hasSelfPermission(CommandSender sender) {
+        return Permissions.mcability(sender);
+    }
+
+    @Override
+    protected void applyCommandAction(McMMOPlayer mcMMOPlayer) {
+        mcMMOPlayer.getPlayer().sendMessage(LocaleLoader.getString("Commands.Ability." + (mcMMOPlayer.getAbilityUse() ? "Off" : "On")));
+        mcMMOPlayer.toggleAbilityUse();
+    }
+
+    @Override
+    protected void sendSuccessMessage(CommandSender sender, String playerName) {
+        sender.sendMessage(LocaleLoader.getString("Commands.Ability.Toggle", playerName));
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/McconvertCommand.java

@@ -0,0 +1,91 @@
+package com.gmail.nossr50.commands;
+
+import com.gmail.nossr50.commands.database.ConvertDatabaseCommand;
+import com.gmail.nossr50.commands.experience.ConvertExperienceCommand;
+import com.gmail.nossr50.database.DatabaseManagerFactory;
+import com.gmail.nossr50.datatypes.database.DatabaseType;
+import com.gmail.nossr50.datatypes.experience.FormulaType;
+import com.gmail.nossr50.mcMMO;
+import com.google.common.collect.ImmutableList;
+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 java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class McconvertCommand implements TabExecutor {
+    private static final List<String> FORMULA_TYPES;
+    private static final List<String> DATABASE_TYPES;
+    private static final List<String> SUBCOMMANDS = ImmutableList.of("database", "experience");
+
+    private CommandExecutor databaseConvertCommand = new ConvertDatabaseCommand();
+    private CommandExecutor experienceConvertCommand = new ConvertExperienceCommand();
+
+    static {
+        ArrayList<String> formulaTypes = new ArrayList<String>();
+        ArrayList<String> databaseTypes = new ArrayList<String>();
+
+        for (FormulaType type : FormulaType.values()) {
+            formulaTypes.add(type.toString());
+        }
+
+        for (DatabaseType type : DatabaseType.values()) {
+            databaseTypes.add(type.toString());
+        }
+
+        // Custom stuff
+        databaseTypes.remove(DatabaseType.CUSTOM.toString());
+
+        if (mcMMO.getDatabaseManager().getDatabaseType() == DatabaseType.CUSTOM) {
+            databaseTypes.add(DatabaseManagerFactory.getCustomDatabaseManagerClass().getName());
+        }
+
+        Collections.sort(formulaTypes);
+        Collections.sort(databaseTypes);
+
+        FORMULA_TYPES = ImmutableList.copyOf(formulaTypes);
+        DATABASE_TYPES = ImmutableList.copyOf(databaseTypes);
+
+    }
+
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        switch (args.length) {
+            case 2:
+                if (args[0].equalsIgnoreCase("database") || args[0].equalsIgnoreCase("db")) {
+                    return databaseConvertCommand.onCommand(sender, command, label, args);
+                }
+                else if (args[0].equalsIgnoreCase("experience") || args[0].equalsIgnoreCase("xp") || args[1].equalsIgnoreCase("exp")) {
+                    return experienceConvertCommand.onCommand(sender, command, label, args);
+                }
+
+                return false;
+            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], SUBCOMMANDS, new ArrayList<String>(SUBCOMMANDS.size()));
+            case 2:
+                if (args[0].equalsIgnoreCase("database") || args[0].equalsIgnoreCase("db")) {
+                    return StringUtil.copyPartialMatches(args[0], DATABASE_TYPES, new ArrayList<String>(DATABASE_TYPES.size()));
+                }
+
+                if (args[0].equalsIgnoreCase("experience") || args[0].equalsIgnoreCase("xp") || args[0].equalsIgnoreCase("exp")) {
+                    return StringUtil.copyPartialMatches(args[0], FORMULA_TYPES, new ArrayList<String>(FORMULA_TYPES.size()));
+                }
+
+                return ImmutableList.of();
+            default:
+                return ImmutableList.of();
+        }
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/McgodCommand.java

@@ -0,0 +1,29 @@
+package com.gmail.nossr50.commands;
+
+import com.gmail.nossr50.datatypes.player.McMMOPlayer;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.util.Permissions;
+import org.bukkit.command.CommandSender;
+
+public class McgodCommand extends ToggleCommand {
+    @Override
+    protected boolean hasOtherPermission(CommandSender sender) {
+        return Permissions.mcgodOthers(sender);
+    }
+
+    @Override
+    protected boolean hasSelfPermission(CommandSender sender) {
+        return Permissions.mcgod(sender);
+    }
+
+    @Override
+    protected void applyCommandAction(McMMOPlayer mcMMOPlayer) {
+        mcMMOPlayer.getPlayer().sendMessage(LocaleLoader.getString("Commands.GodMode." + (mcMMOPlayer.getGodMode() ? "Disabled" : "Enabled")));
+        mcMMOPlayer.toggleGodMode();
+    }
+
+    @Override
+    protected void sendSuccessMessage(CommandSender sender, String playerName) {
+        sender.sendMessage(LocaleLoader.getString("Commands.GodMode.Toggle", playerName));
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/McmmoCommand.java

@@ -0,0 +1,115 @@
+package com.gmail.nossr50.commands;
+
+import com.gmail.nossr50.commands.party.PartySubcommandType;
+import com.gmail.nossr50.config.Config;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.mcMMO;
+import com.gmail.nossr50.util.Permissions;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+
+public class McmmoCommand implements CommandExecutor {
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        switch (args.length) {
+            case 0:
+                if (!Permissions.mcmmoDescription(sender)) {
+                    sender.sendMessage(command.getPermissionMessage());
+                    return true;
+                }
+
+                String description = LocaleLoader.getString("mcMMO.Description");
+                String[] mcSplit = description.split(",");
+                sender.sendMessage(mcSplit);
+
+                if (Config.getInstance().getDonateMessageEnabled()) {
+                    sender.sendMessage(LocaleLoader.getString("MOTD.Donate"));
+                    sender.sendMessage(ChatColor.GOLD + " - " + ChatColor.GREEN + "com.gmail.nossr50@com.gmail.com" + ChatColor.GOLD + " Paypal");
+                }
+
+                if (Permissions.showversion(sender)) {
+                    sender.sendMessage(LocaleLoader.getString("MOTD.Version", mcMMO.p.getDescription().getVersion()));
+                }
+
+                mcMMO.getHolidayManager().anniversaryCheck(sender);
+                return true;
+
+            case 1:
+                if (args[0].equalsIgnoreCase("?") || args[0].equalsIgnoreCase("help") || args[0].equalsIgnoreCase("commands")) {
+                    if (!Permissions.mcmmoHelp(sender)) {
+                        sender.sendMessage(command.getPermissionMessage());
+                        return true;
+                    }
+
+                    sender.sendMessage(LocaleLoader.getString("Commands.mcc.Header"));
+                    displayGeneralCommands(sender);
+                    displayOtherCommands(sender);
+                    displayPartyCommands(sender);
+                }
+                return true;
+
+            default:
+                return false;
+        }
+    }
+
+    private void displayGeneralCommands(CommandSender sender) {
+        sender.sendMessage(ChatColor.DARK_AQUA + " /mcstats " + LocaleLoader.getString("Commands.Stats"));
+        sender.sendMessage(ChatColor.DARK_AQUA + " /<skill>" + LocaleLoader.getString("Commands.SkillInfo"));
+        sender.sendMessage(ChatColor.DARK_AQUA + " /mctop " + LocaleLoader.getString("Commands.Leaderboards"));
+
+        if (Permissions.inspect(sender)) {
+            sender.sendMessage(ChatColor.DARK_AQUA + " /inspect " + LocaleLoader.getString("Commands.Inspect"));
+        }
+
+        if (Permissions.mcability(sender)) {
+            sender.sendMessage(ChatColor.DARK_AQUA + " /mcability " + LocaleLoader.getString("Commands.ToggleAbility"));
+        }
+    }
+
+    private void displayOtherCommands(CommandSender sender) {
+        //Don't show them this category if they have none of the permissions
+        if(!Permissions.skillreset(sender) && !Permissions.mmoedit(sender) && !Permissions.adminChat(sender) && !Permissions.mcgod(sender))
+            return;
+
+        sender.sendMessage(LocaleLoader.getString("Commands.Other"));
+
+        if (Permissions.skillreset(sender)) {
+            sender.sendMessage(ChatColor.DARK_AQUA + " /skillreset <skill|all> " + LocaleLoader.getString("Commands.Reset"));
+        }
+
+        if (Permissions.mmoedit(sender)) {
+            sender.sendMessage(ChatColor.DARK_AQUA + " /mmoedit " + LocaleLoader.getString("Commands.mmoedit"));
+        }
+
+        if (Permissions.adminChat(sender)) {
+            sender.sendMessage(ChatColor.DARK_AQUA + " /adminchat " + LocaleLoader.getString("Commands.AdminToggle"));
+        }
+
+        if (Permissions.mcgod(sender)) {
+            sender.sendMessage(ChatColor.DARK_AQUA + " /mcgod " + LocaleLoader.getString("Commands.mcgod"));
+        }
+    }
+
+    private void displayPartyCommands(CommandSender sender) {
+        if (Permissions.party(sender)) {
+            sender.sendMessage(LocaleLoader.getString("Commands.Party.Commands"));
+            sender.sendMessage(ChatColor.DARK_AQUA + " /party create <" + LocaleLoader.getString("Commands.Usage.PartyName") + "> " + LocaleLoader.getString("Commands.Party1"));
+            sender.sendMessage(ChatColor.DARK_AQUA + " /party join <" + LocaleLoader.getString("Commands.Usage.Player") + "> " + LocaleLoader.getString("Commands.Party2"));
+            sender.sendMessage(ChatColor.DARK_AQUA + " /party quit " + LocaleLoader.getString("Commands.Party.Quit"));
+
+            if (Permissions.partyChat(sender)) {
+                sender.sendMessage(ChatColor.DARK_AQUA + " /party chat " + LocaleLoader.getString("Commands.Party.Toggle"));
+            }
+
+            sender.sendMessage(ChatColor.DARK_AQUA + " /party invite <" + LocaleLoader.getString("Commands.Usage.Player") + "> " + LocaleLoader.getString("Commands.Party.Invite"));
+            sender.sendMessage(ChatColor.DARK_AQUA + " /party accept " + LocaleLoader.getString("Commands.Party.Accept"));
+
+            if (Permissions.partySubcommand(sender, PartySubcommandType.TELEPORT)) {
+                sender.sendMessage(ChatColor.DARK_AQUA + " /party teleport <" + LocaleLoader.getString("Commands.Usage.Player") + "> " + LocaleLoader.getString("Commands.Party.Teleport"));
+            }
+        }
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/McnotifyCommand.java

@@ -0,0 +1,34 @@
+package com.gmail.nossr50.commands;
+
+import com.gmail.nossr50.datatypes.player.McMMOPlayer;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.util.player.UserManager;
+import com.google.common.collect.ImmutableList;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
+import org.bukkit.entity.Player;
+
+import java.util.List;
+
+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((Player) sender);
+
+                sender.sendMessage(LocaleLoader.getString("Commands.Notifications." + (mcMMOPlayer.useChatNotifications() ? "Off" : "On")));
+                mcMMOPlayer.toggleChatNotifications();
+                return true;
+
+            default:
+                return false;
+        }
+    }
+
+    @Override
+    public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) {
+        return ImmutableList.of();
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/McrefreshCommand.java

@@ -0,0 +1,33 @@
+package com.gmail.nossr50.commands;
+
+import com.gmail.nossr50.datatypes.player.McMMOPlayer;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.util.Permissions;
+import org.bukkit.command.CommandSender;
+
+public class McrefreshCommand extends ToggleCommand {
+    @Override
+    protected boolean hasOtherPermission(CommandSender sender) {
+        return Permissions.mcrefreshOthers(sender);
+    }
+
+    @Override
+    protected boolean hasSelfPermission(CommandSender sender) {
+        return Permissions.mcrefresh(sender);
+    }
+
+    @Override
+    protected void applyCommandAction(McMMOPlayer mcMMOPlayer) {
+        mcMMOPlayer.setRecentlyHurt(0);
+        mcMMOPlayer.resetCooldowns();
+        mcMMOPlayer.resetToolPrepMode();
+        mcMMOPlayer.resetAbilityMode();
+
+        mcMMOPlayer.getPlayer().sendMessage(LocaleLoader.getString("Ability.Generic.Refresh"));
+    }
+
+    @Override
+    protected void sendSuccessMessage(CommandSender sender, String playerName) {
+        sender.sendMessage(LocaleLoader.getString("Commands.mcrefresh.Success", playerName));
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/McscoreboardCommand.java

@@ -0,0 +1,88 @@
+package com.gmail.nossr50.commands;
+
+import com.gmail.nossr50.config.Config;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.util.commands.CommandUtils;
+import com.gmail.nossr50.util.scoreboards.ScoreboardManager;
+import com.google.common.collect.ImmutableList;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
+import org.bukkit.util.StringUtil;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class McscoreboardCommand implements TabExecutor {
+    private static final List<String> FIRST_ARGS = ImmutableList.of("keep", "time", "clear");
+
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        if (CommandUtils.noConsoleUsage(sender)) {
+            return true;
+        }
+
+        switch (args.length) {
+            case 1:
+                if (args[0].equalsIgnoreCase("clear") || args[0].equalsIgnoreCase("reset")) {
+                    ScoreboardManager.clearBoard(sender.getName());
+                    sender.sendMessage(LocaleLoader.getString("Commands.Scoreboard.Clear"));
+                    return true;
+                }
+
+                if (args[0].equalsIgnoreCase("keep")) {
+                    if (!Config.getInstance().getAllowKeepBoard() || !Config.getInstance().getScoreboardsEnabled()) {
+                        sender.sendMessage(LocaleLoader.getString("Commands.Disabled"));
+                        return true;
+                    }
+
+                    if (!ScoreboardManager.isBoardShown(sender.getName())) {
+                        sender.sendMessage(LocaleLoader.getString("Commands.Scoreboard.NoBoard"));
+                        return true;
+                    }
+
+                    ScoreboardManager.keepBoard(sender.getName());
+                    sender.sendMessage(LocaleLoader.getString("Commands.Scoreboard.Keep"));
+                    return true;
+                }
+
+                return help(sender);
+
+            case 2:
+                if (args[0].equalsIgnoreCase("time") || args[0].equalsIgnoreCase("timer")) {
+                    if (CommandUtils.isInvalidInteger(sender, args[1])) {
+                        return true;
+                    }
+
+                    int time = Math.abs(Integer.parseInt(args[1]));
+
+                    ScoreboardManager.setRevertTimer(sender.getName(), time);
+                    sender.sendMessage(LocaleLoader.getString("Commands.Scoreboard.Timer", time));
+                    return true;
+                }
+
+                return help(sender);
+
+            default:
+                return help(sender);
+        }
+    }
+
+    @Override
+    public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) {
+        switch (args.length) {
+            case 1:
+                return StringUtil.copyPartialMatches(args[0], FIRST_ARGS, new ArrayList<String>(FIRST_ARGS.size()));
+            default:
+                return ImmutableList.of();
+        }
+    }
+
+    private boolean help(CommandSender sender) {
+        sender.sendMessage(LocaleLoader.getString("Commands.Scoreboard.Help.0"));
+        sender.sendMessage(LocaleLoader.getString("Commands.Scoreboard.Help.1"));
+        sender.sendMessage(LocaleLoader.getString("Commands.Scoreboard.Help.2"));
+        sender.sendMessage(LocaleLoader.getString("Commands.Scoreboard.Help.3"));
+        return true;
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/ToggleCommand.java

@@ -0,0 +1,77 @@
+package com.gmail.nossr50.commands;
+
+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;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
+import org.bukkit.util.StringUtil;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public abstract class ToggleCommand 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 (!hasSelfPermission(sender)) {
+                    sender.sendMessage(command.getPermissionMessage());
+                    return true;
+                }
+
+                if (!CommandUtils.hasPlayerDataKey(sender)) {
+                    return true;
+                }
+
+                applyCommandAction(UserManager.getPlayer(sender.getName()));
+                return true;
+
+            case 1:
+                if (!hasOtherPermission(sender)) {
+                    sender.sendMessage(command.getPermissionMessage());
+                    return true;
+                }
+
+                String playerName = CommandUtils.getMatchedPlayerName(args[0]);
+                McMMOPlayer mcMMOPlayer = UserManager.getPlayer(playerName);
+
+                if (!CommandUtils.checkPlayerExistence(sender, playerName, mcMMOPlayer)) {
+                    return true;
+                }
+
+                if (CommandUtils.isOffline(sender, mcMMOPlayer.getPlayer())) {
+                    return true;
+                }
+
+                applyCommandAction(mcMMOPlayer);
+                sendSuccessMessage(sender, playerName);
+                return true;
+
+            default:
+                return false;
+        }
+    }
+
+    @Override
+    public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) {
+        switch (args.length) {
+            case 1:
+                List<String> playerNames = CommandUtils.getOnlinePlayerNames(sender);
+                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(McMMOPlayer mcMMOPlayer);
+    protected abstract void sendSuccessMessage(CommandSender sender, String playerName);
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/XprateCommand.java

@@ -0,0 +1,123 @@
+package com.gmail.nossr50.commands;
+
+import com.gmail.nossr50.config.AdvancedConfig;
+import com.gmail.nossr50.config.experience.ExperienceConfig;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.mcMMO;
+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.NotificationManager;
+import com.google.common.collect.ImmutableList;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
+import org.bukkit.util.StringUtil;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class XprateCommand implements TabExecutor {
+    private final double ORIGINAL_XP_RATE = ExperienceConfig.getInstance().getExperienceGainsGlobalMultiplier();
+
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        switch (args.length) {
+            case 1:
+                if (!args[0].equalsIgnoreCase("reset") &&  !args[0].equalsIgnoreCase("clear")) {
+                    return false;
+                }
+
+                if (!Permissions.xprateReset(sender)) {
+                    sender.sendMessage(command.getPermissionMessage());
+                    return true;
+                }
+
+                if (mcMMO.p.isXPEventEnabled()) {
+
+                    if(AdvancedConfig.getInstance().useTitlesForXPEvent())
+                    {
+                        NotificationManager.broadcastTitle(mcMMO.p.getServer(),
+                                LocaleLoader.getString("Commands.Event.Stop"),
+                                LocaleLoader.getString("Commands.Event.Stop.Subtitle"),
+                                10, 10*20, 20);
+                    }
+
+                    mcMMO.p.getServer().broadcastMessage(LocaleLoader.getString("Commands.Event.Stop"));
+                    mcMMO.p.getServer().broadcastMessage(LocaleLoader.getString("Commands.Event.Stop.Subtitle"));
+
+                    mcMMO.p.toggleXpEventEnabled();
+                }
+
+                ExperienceConfig.getInstance().setExperienceGainsGlobalMultiplier(ORIGINAL_XP_RATE);
+                return true;
+
+            case 2:
+                if (CommandUtils.isInvalidInteger(sender, args[0])) {
+                    return true;
+                }
+
+                if (!Permissions.xprateSet(sender)) {
+                    sender.sendMessage(command.getPermissionMessage());
+                    return true;
+                }
+
+                if (CommandUtils.shouldDisableToggle(args[1])) {
+                    mcMMO.p.setXPEventEnabled(false);
+                }
+                else if (CommandUtils.shouldEnableToggle(args[1])) {
+                    mcMMO.p.setXPEventEnabled(true);
+                }
+                else {
+                    return false;
+                }
+
+                int newXpRate = Integer.parseInt(args[0]);
+
+                if(newXpRate < 0)
+                {
+                    sender.sendMessage(ChatColor.RED+LocaleLoader.getString("Commands.NegativeNumberWarn"));
+                    return true;
+                }
+
+                ExperienceConfig.getInstance().setExperienceGainsGlobalMultiplier(newXpRate);
+
+                if (mcMMO.p.isXPEventEnabled()) {
+                    if(AdvancedConfig.getInstance().useTitlesForXPEvent())
+                    {
+                        NotificationManager.broadcastTitle(mcMMO.p.getServer(),
+                                LocaleLoader.getString("Commands.Event.Start"),
+                                LocaleLoader.getString("Commands.Event.XP", newXpRate),
+                                10, 10*20, 20);
+                    }
+                    mcMMO.p.getServer().broadcastMessage(LocaleLoader.getString("Commands.Event.Start"));
+                    mcMMO.p.getServer().broadcastMessage(LocaleLoader.getString("Commands.Event.XP", newXpRate));
+                }
+                else {
+                    sender.sendMessage(LocaleLoader.getString("Commands.xprate.modified", newXpRate));
+                }
+
+                return true;
+
+            default:
+                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();
+        }
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/chat/AdminChatCommand.java

@@ -0,0 +1,15 @@
+package com.gmail.nossr50.commands.chat;
+
+import com.gmail.nossr50.datatypes.chat.ChatMode;
+import org.bukkit.command.CommandSender;
+
+public class AdminChatCommand extends ChatCommand {
+    public AdminChatCommand() {
+        super(ChatMode.ADMIN);
+    }
+
+    @Override
+    protected void handleChatSending(CommandSender sender, String[] args) {
+        chatManager.handleChat(sender.getName(), getDisplayName(sender), buildChatMessage(args, 0));
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/chat/ChatCommand.java

@@ -0,0 +1,140 @@
+package com.gmail.nossr50.commands.chat;
+
+import com.gmail.nossr50.chat.ChatManager;
+import com.gmail.nossr50.chat.ChatManagerFactory;
+import com.gmail.nossr50.config.Config;
+import com.gmail.nossr50.datatypes.chat.ChatMode;
+import com.gmail.nossr50.datatypes.party.PartyFeature;
+import com.gmail.nossr50.datatypes.player.McMMOPlayer;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.mcMMO;
+import com.gmail.nossr50.util.commands.CommandUtils;
+import com.gmail.nossr50.util.player.UserManager;
+import com.google.common.collect.ImmutableList;
+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 java.util.ArrayList;
+import java.util.List;
+
+public abstract class ChatCommand implements TabExecutor {
+    private ChatMode chatMode;
+    protected ChatManager chatManager;
+
+    public ChatCommand(ChatMode chatMode) {
+        this.chatMode = chatMode;
+        this.chatManager = ChatManagerFactory.getChatManager(mcMMO.p, chatMode);
+    }
+
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        McMMOPlayer mcMMOPlayer;
+
+        switch (args.length) {
+            case 0:
+                if (CommandUtils.noConsoleUsage(sender)) {
+                    return true;
+                }
+
+                if (!CommandUtils.hasPlayerDataKey(sender)) {
+                    return true;
+                }
+
+                mcMMOPlayer = UserManager.getPlayer(sender.getName());
+
+                if (mcMMOPlayer.isChatEnabled(chatMode)) {
+                    disableChatMode(mcMMOPlayer, sender);
+                }
+                else {
+                    enableChatMode(mcMMOPlayer, sender);
+                }
+
+                return true;
+
+            case 1:
+                if (!CommandUtils.hasPlayerDataKey(sender)) {
+                    return true;
+                }
+
+                if (CommandUtils.shouldEnableToggle(args[0])) {
+                    if (CommandUtils.noConsoleUsage(sender)) {
+                        return true;
+                    }
+
+                    enableChatMode(UserManager.getPlayer(sender.getName()), sender);
+                    return true;
+                }
+
+                if (CommandUtils.shouldDisableToggle(args[0])) {
+                    if (CommandUtils.noConsoleUsage(sender)) {
+                        return true;
+                    }
+
+                    disableChatMode(UserManager.getPlayer(sender.getName()), sender);
+                    return true;
+                }
+
+                // Fallthrough
+
+            default:
+                handleChatSending(sender, args);
+                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], 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]);
+
+        for (int i = index + 1; i < args.length; i++) {
+            builder.append(" ");
+            builder.append(args[i]);
+        }
+
+        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(McMMOPlayer mcMMOPlayer, CommandSender sender) {
+        if (chatMode == ChatMode.PARTY && mcMMOPlayer.getParty() == null) {
+            sender.sendMessage(LocaleLoader.getString("Commands.Party.None"));
+            return;
+        }
+
+        if (chatMode == ChatMode.PARTY && (mcMMOPlayer.getParty().getLevel() < Config.getInstance().getPartyFeatureUnlockLevel(PartyFeature.CHAT))) {
+            sender.sendMessage(LocaleLoader.getString("Party.Feature.Disabled.1"));
+            return;
+        }
+
+        mcMMOPlayer.enableChat(chatMode);
+        sender.sendMessage(chatMode.getEnabledMessage());
+    }
+
+    private void disableChatMode(McMMOPlayer mcMMOPlayer, CommandSender sender) {
+        if (chatMode == ChatMode.PARTY && mcMMOPlayer.getParty() == null) {
+            sender.sendMessage(LocaleLoader.getString("Commands.Party.None"));
+            return;
+        }
+
+        mcMMOPlayer.disableChat(chatMode);
+        sender.sendMessage(chatMode.getDisabledMessage());
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/chat/McChatSpy.java

@@ -0,0 +1,30 @@
+package com.gmail.nossr50.commands.chat;
+
+import com.gmail.nossr50.commands.ToggleCommand;
+import com.gmail.nossr50.datatypes.player.McMMOPlayer;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.util.Permissions;
+import org.bukkit.command.CommandSender;
+
+public class McChatSpy extends ToggleCommand {
+    @Override
+    protected boolean hasOtherPermission(CommandSender sender) {
+        return Permissions.adminChatSpyOthers(sender);
+    }
+
+    @Override
+    protected boolean hasSelfPermission(CommandSender sender) {
+        return Permissions.adminChatSpy(sender);
+    }
+
+    @Override
+    protected void applyCommandAction(McMMOPlayer mcMMOPlayer) {
+        mcMMOPlayer.getPlayer().sendMessage(LocaleLoader.getString("Commands.AdminChatSpy." + (mcMMOPlayer.isPartyChatSpying() ? "Disabled" : "Enabled")));
+        mcMMOPlayer.togglePartyChatSpying();
+    }
+
+    @Override
+    protected void sendSuccessMessage(CommandSender sender, String playerName) {
+        sender.sendMessage(LocaleLoader.getString("Commands.AdminChatSpy.Toggle", playerName));
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/chat/PartyChatCommand.java

@@ -0,0 +1,58 @@
+package com.gmail.nossr50.commands.chat;
+
+import com.gmail.nossr50.chat.PartyChatManager;
+import com.gmail.nossr50.config.Config;
+import com.gmail.nossr50.datatypes.chat.ChatMode;
+import com.gmail.nossr50.datatypes.party.Party;
+import com.gmail.nossr50.datatypes.party.PartyFeature;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.party.PartyManager;
+import com.gmail.nossr50.util.player.UserManager;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class PartyChatCommand extends ChatCommand {
+    public PartyChatCommand() {
+        super(ChatMode.PARTY);
+    }
+
+    @Override
+    protected void handleChatSending(CommandSender sender, String[] args) {
+        Party party;
+        String message;
+
+        if (sender instanceof Player) {
+            party = UserManager.getPlayer((Player) sender).getParty();
+
+            if (party == null) {
+                sender.sendMessage(LocaleLoader.getString("Commands.Party.None"));
+                return;
+            }
+
+            if (party.getLevel() < Config.getInstance().getPartyFeatureUnlockLevel(PartyFeature.CHAT)) {
+                sender.sendMessage(LocaleLoader.getString("Party.Feature.Disabled.1"));
+                return;
+            }
+
+            message = buildChatMessage(args, 0);
+        }
+        else {
+            if (args.length < 2) {
+                sender.sendMessage(LocaleLoader.getString("Party.Specify"));
+                return;
+            }
+
+            party = PartyManager.getParty(args[0]);
+
+            if (party == null) {
+                sender.sendMessage(LocaleLoader.getString("Party.InvalidName"));
+                return;
+            }
+
+            message = buildChatMessage(args, 1);
+        }
+
+        ((PartyChatManager) chatManager).setParty(party);
+        chatManager.handleChat(sender.getName(), getDisplayName(sender), message);
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/database/ConvertDatabaseCommand.java

@@ -0,0 +1,74 @@
+package com.gmail.nossr50.commands.database;
+
+import com.gmail.nossr50.database.DatabaseManager;
+import com.gmail.nossr50.database.DatabaseManagerFactory;
+import com.gmail.nossr50.datatypes.database.DatabaseType;
+import com.gmail.nossr50.datatypes.player.PlayerProfile;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.mcMMO;
+import com.gmail.nossr50.runnables.database.DatabaseConversionTask;
+import com.gmail.nossr50.runnables.player.PlayerProfileLoadingTask;
+import com.gmail.nossr50.util.player.UserManager;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class ConvertDatabaseCommand implements CommandExecutor {
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        switch (args.length) {
+            case 2:
+                DatabaseType previousType = DatabaseType.getDatabaseType(args[1]);
+                DatabaseType newType = mcMMO.getDatabaseManager().getDatabaseType();
+
+                if (previousType == newType || (newType == DatabaseType.CUSTOM && DatabaseManagerFactory.getCustomDatabaseManagerClass().getSimpleName().equalsIgnoreCase(args[1]))) {
+                    sender.sendMessage(LocaleLoader.getString("Commands.mcconvert.Database.Same", newType.toString()));
+                    return true;
+                }
+
+                DatabaseManager oldDatabase = DatabaseManagerFactory.createDatabaseManager(previousType);
+
+                if (previousType == DatabaseType.CUSTOM) {
+                    Class<?> clazz;
+
+                    try {
+                        clazz = Class.forName(args[1]);
+
+                        if (!DatabaseManager.class.isAssignableFrom(clazz)) {
+                            sender.sendMessage(LocaleLoader.getString("Commands.mcconvert.Database.InvalidType", args[1]));
+                            return true;
+                        }
+
+                        oldDatabase = DatabaseManagerFactory.createCustomDatabaseManager((Class<? extends DatabaseManager>) clazz);
+                    }
+                    catch (Throwable e) {
+                        e.printStackTrace();
+                        sender.sendMessage(LocaleLoader.getString("Commands.mcconvert.Database.InvalidType", args[1]));
+                        return true;
+                    }
+                }
+
+                sender.sendMessage(LocaleLoader.getString("Commands.mcconvert.Database.Start", previousType.toString(), newType.toString()));
+
+                UserManager.saveAll();
+                UserManager.clearAll();
+
+                for (Player player : mcMMO.p.getServer().getOnlinePlayers()) {
+                    PlayerProfile profile = oldDatabase.loadPlayerProfile(player.getUniqueId());
+
+                    if (profile.isLoaded()) {
+                        mcMMO.getDatabaseManager().saveUser(profile);
+                    }
+
+                    new PlayerProfileLoadingTask(player).runTaskLaterAsynchronously(mcMMO.p, 1); // 1 Tick delay to ensure the player is marked as online before we begin loading
+                }
+
+                new DatabaseConversionTask(oldDatabase, sender, previousType.toString(), newType.toString()).runTaskAsynchronously(mcMMO.p);
+                return true;
+
+            default:
+                return false;
+        }
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/database/McpurgeCommand.java

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

mcMMO-core/src/main/java/com/gmail/nossr50/commands/database/McremoveCommand.java

@@ -0,0 +1,51 @@
+package com.gmail.nossr50.commands.database;
+
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.mcMMO;
+import com.gmail.nossr50.util.commands.CommandUtils;
+import com.gmail.nossr50.util.player.UserManager;
+import com.google.common.collect.ImmutableList;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
+import org.bukkit.util.StringUtil;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class McremoveCommand implements TabExecutor {
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        switch (args.length) {
+            case 1:
+                String playerName = CommandUtils.getMatchedPlayerName(args[0]);
+
+                if (UserManager.getOfflinePlayer(playerName) == null && CommandUtils.unloadedProfile(sender, mcMMO.getDatabaseManager().loadPlayerProfile(playerName, false))) {
+                    return true;
+                }
+
+                if (mcMMO.getDatabaseManager().removeUser(playerName)) {
+                    sender.sendMessage(LocaleLoader.getString("Commands.mcremove.Success", playerName));
+                }
+                else {
+                    sender.sendMessage(playerName + " could not be removed from the database."); // Pretty sure this should NEVER happen.
+                }
+
+                return true;
+
+            default:
+                return false;
+        }
+    }
+
+    @Override
+    public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) {
+        switch (args.length) {
+            case 1:
+                List<String> playerNames = CommandUtils.getOnlinePlayerNames(sender);
+                return StringUtil.copyPartialMatches(args[0], playerNames, new ArrayList<String>(playerNames.size()));
+            default:
+                return ImmutableList.of();
+        }
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/database/MmoshowdbCommand.java

@@ -0,0 +1,37 @@
+package com.gmail.nossr50.commands.database;
+
+import com.gmail.nossr50.config.Config;
+import com.gmail.nossr50.database.DatabaseManagerFactory;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.google.common.collect.ImmutableList;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
+
+import java.util.List;
+
+public class MmoshowdbCommand implements TabExecutor {
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        switch (args.length) {
+            case 0:
+                Class<?> clazz = DatabaseManagerFactory.getCustomDatabaseManagerClass();
+
+                if (clazz != null) {
+                    sender.sendMessage(LocaleLoader.getString("Commands.mmoshowdb", clazz.getName()));
+                    return true;
+                }
+
+                sender.sendMessage(LocaleLoader.getString("Commands.mmoshowdb", (Config.getInstance().getUseMySQL() ? "sql" : "flatfile")));
+                return true;
+
+            default:
+                return false;
+        }
+    }
+
+    @Override
+    public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) {
+        return ImmutableList.of();
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/experience/AddlevelsCommand.java

@@ -0,0 +1,45 @@
+package com.gmail.nossr50.commands.experience;
+
+import com.gmail.nossr50.datatypes.experience.XPGainReason;
+import com.gmail.nossr50.datatypes.player.PlayerProfile;
+import com.gmail.nossr50.datatypes.skills.PrimarySkillType;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.util.EventUtils;
+import com.gmail.nossr50.util.Permissions;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class AddlevelsCommand extends ExperienceCommand {
+    @Override
+    protected boolean permissionsCheckSelf(CommandSender sender) {
+        return Permissions.addlevels(sender);
+    }
+
+    @Override
+    protected boolean permissionsCheckOthers(CommandSender sender) {
+        return Permissions.addlevelsOthers(sender);
+    }
+
+    @Override
+    protected void handleCommand(Player player, PlayerProfile profile, PrimarySkillType skill, int value) {
+        float xpRemoved = profile.getSkillXpLevelRaw(skill);
+        profile.addLevels(skill, value);
+
+        if (player == null) {
+            profile.scheduleAsyncSave();
+            return;
+        }
+
+        EventUtils.handleLevelChangeEvent(player, skill, value, xpRemoved, true, XPGainReason.COMMAND);
+    }
+
+    @Override
+    protected void handlePlayerMessageAll(Player player, int value) {
+        player.sendMessage(LocaleLoader.getString("Commands.addlevels.AwardAll.1", value));
+    }
+
+    @Override
+    protected void handlePlayerMessageSkill(Player player, int value, PrimarySkillType skill) {
+        player.sendMessage(LocaleLoader.getString("Commands.addlevels.AwardSkill.1", value, skill.getName()));
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/experience/AddxpCommand.java

@@ -0,0 +1,44 @@
+package com.gmail.nossr50.commands.experience;
+
+import com.gmail.nossr50.datatypes.experience.XPGainReason;
+import com.gmail.nossr50.datatypes.experience.XPGainSource;
+import com.gmail.nossr50.datatypes.player.PlayerProfile;
+import com.gmail.nossr50.datatypes.skills.PrimarySkillType;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.util.Permissions;
+import com.gmail.nossr50.util.player.UserManager;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class AddxpCommand extends ExperienceCommand {
+    @Override
+    protected boolean permissionsCheckSelf(CommandSender sender) {
+        return Permissions.addxp(sender);
+    }
+
+    @Override
+    protected boolean permissionsCheckOthers(CommandSender sender) {
+        return Permissions.addxpOthers(sender);
+    }
+
+    @Override
+    protected void handleCommand(Player player, PlayerProfile profile, PrimarySkillType skill, int value) {
+        if (player != null) {
+            UserManager.getPlayer(player).applyXpGain(skill, value, XPGainReason.COMMAND, XPGainSource.COMMAND);
+        }
+        else {
+            profile.addXp(skill, value);
+            profile.scheduleAsyncSave();
+        }
+    }
+
+    @Override
+    protected void handlePlayerMessageAll(Player player, int value) {
+        player.sendMessage(LocaleLoader.getString("Commands.addxp.AwardAll", value));
+    }
+
+    @Override
+    protected void handlePlayerMessageSkill(Player player, int value, PrimarySkillType skill) {
+        player.sendMessage(LocaleLoader.getString("Commands.addxp.AwardSkill", value, skill.getName()));
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/experience/ConvertExperienceCommand.java

@@ -0,0 +1,49 @@
+package com.gmail.nossr50.commands.experience;
+
+import com.gmail.nossr50.datatypes.experience.FormulaType;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.mcMMO;
+import com.gmail.nossr50.runnables.database.FormulaConversionTask;
+import com.gmail.nossr50.runnables.player.PlayerProfileLoadingTask;
+import com.gmail.nossr50.util.player.UserManager;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class ConvertExperienceCommand implements CommandExecutor {
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        switch (args.length) {
+            case 2:
+                FormulaType previousType = mcMMO.getFormulaManager().getPreviousFormulaType();
+                FormulaType newType = FormulaType.getFormulaType(args[1].toUpperCase());
+
+                if (newType == FormulaType.UNKNOWN) {
+                    sender.sendMessage(LocaleLoader.getString("Commands.mcconvert.Experience.Invalid"));
+                    return true;
+                }
+
+                if (previousType == newType) {
+                    sender.sendMessage(LocaleLoader.getString("Commands.mcconvert.Experience.Same", newType.toString()));
+                    return true;
+                }
+
+                sender.sendMessage(LocaleLoader.getString("Commands.mcconvert.Experience.Start", previousType.toString(), newType.toString()));
+
+                UserManager.saveAll();
+                UserManager.clearAll();
+
+                new FormulaConversionTask(sender, newType).runTaskLater(mcMMO.p, 1);
+
+                for (Player player : mcMMO.p.getServer().getOnlinePlayers()) {
+                    new PlayerProfileLoadingTask(player).runTaskLaterAsynchronously(mcMMO.p, 1); // 1 Tick delay to ensure the player is marked as online before we begin loading
+                }
+
+                return true;
+
+            default:
+                return false;
+        }
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/experience/ExperienceCommand.java

@@ -0,0 +1,161 @@
+package com.gmail.nossr50.commands.experience;
+
+import com.gmail.nossr50.datatypes.player.McMMOPlayer;
+import com.gmail.nossr50.datatypes.player.PlayerProfile;
+import com.gmail.nossr50.datatypes.skills.PrimarySkillType;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.mcMMO;
+import com.gmail.nossr50.util.commands.CommandUtils;
+import com.gmail.nossr50.util.player.UserManager;
+import com.google.common.collect.ImmutableList;
+import org.bukkit.OfflinePlayer;
+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 java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+
+public abstract class ExperienceCommand implements TabExecutor {
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        PrimarySkillType skill;
+
+        switch (args.length) {
+            case 2:
+                if (CommandUtils.noConsoleUsage(sender)) {
+                    return true;
+                }
+
+                if (!permissionsCheckSelf(sender)) {
+                    sender.sendMessage(command.getPermissionMessage());
+                    return true;
+                }
+
+                if (!validateArguments(sender, args[0], args[1])) {
+                    return true;
+                }
+
+                skill = PrimarySkillType.getSkill(args[0]);
+
+                if (args[1].equalsIgnoreCase("all")) {
+                    skill = null;
+                }
+
+                if (skill != null && skill.isChildSkill())
+                {
+                    sender.sendMessage(LocaleLoader.getString("Commands.Skill.ChildSkill"));
+                    return true;
+                }
+
+                editValues((Player) sender, UserManager.getPlayer(sender.getName()).getProfile(), skill, Integer.parseInt(args[1]));
+                return true;
+
+            case 3:
+                if (!permissionsCheckOthers(sender)) {
+                    sender.sendMessage(command.getPermissionMessage());
+                    return true;
+                }
+
+                if (!validateArguments(sender, args[1], args[2])) {
+                    return true;
+                }
+
+                skill = PrimarySkillType.getSkill(args[1]);
+
+                if (args[1].equalsIgnoreCase("all")) {
+                    skill = null;
+                }
+
+                if (skill != null && skill.isChildSkill())
+                {
+                    sender.sendMessage(LocaleLoader.getString("Commands.Skill.ChildSkill"));
+                    return true;
+                }
+
+                int value = Integer.parseInt(args[2]);
+
+                String playerName = CommandUtils.getMatchedPlayerName(args[0]);
+                McMMOPlayer mcMMOPlayer = UserManager.getOfflinePlayer(playerName);
+
+                // 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) {
+                    UUID uuid = null;
+                    OfflinePlayer player = mcMMO.p.getServer().getOfflinePlayer(playerName);
+                    if (player != null) {
+                        uuid = player.getUniqueId();
+                    }
+                    PlayerProfile profile = mcMMO.getDatabaseManager().loadPlayerProfile(playerName, uuid, false);
+
+                    if (CommandUtils.unloadedProfile(sender, profile)) {
+                        return true;
+                    }
+
+                    editValues(null, profile, skill, value);
+                }
+                else {
+                    editValues(mcMMOPlayer.getPlayer(), mcMMOPlayer.getProfile(), skill, value);
+                }
+
+                handleSenderMessage(sender, playerName, skill);
+                return true;
+
+            default:
+                return false;
+        }
+    }
+
+    @Override
+    public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) {
+        switch (args.length) {
+            case 1:
+                List<String> playerNames = CommandUtils.getOnlinePlayerNames(sender);
+                return StringUtil.copyPartialMatches(args[0], playerNames, new ArrayList<String>(playerNames.size()));
+            case 2:
+                return StringUtil.copyPartialMatches(args[1], PrimarySkillType.SKILL_NAMES, new ArrayList<String>(PrimarySkillType.SKILL_NAMES.size()));
+            default:
+                return ImmutableList.of();
+        }
+    }
+
+    protected abstract boolean permissionsCheckSelf(CommandSender sender);
+    protected abstract boolean permissionsCheckOthers(CommandSender sender);
+    protected abstract void handleCommand(Player player, PlayerProfile profile, PrimarySkillType skill, int value);
+    protected abstract void handlePlayerMessageAll(Player player, int value);
+    protected abstract void handlePlayerMessageSkill(Player player, int value, PrimarySkillType skill);
+
+    private boolean validateArguments(CommandSender sender, String skillName, String value) {
+        return !(CommandUtils.isInvalidInteger(sender, value) || (!skillName.equalsIgnoreCase("all") && CommandUtils.isInvalidSkill(sender, skillName)));
+    }
+
+    protected static void handleSenderMessage(CommandSender sender, String playerName, PrimarySkillType skill) {
+        if (skill == null) {
+            sender.sendMessage(LocaleLoader.getString("Commands.addlevels.AwardAll.2", playerName));
+        }
+        else {
+            sender.sendMessage(LocaleLoader.getString("Commands.addlevels.AwardSkill.2", skill.getName(), playerName));
+        }
+    }
+
+    protected void editValues(Player player, PlayerProfile profile, PrimarySkillType skill, int value) {
+        if (skill == null) {
+            for (PrimarySkillType primarySkillType : PrimarySkillType.NON_CHILD_SKILLS) {
+                handleCommand(player, profile, primarySkillType, value);
+            }
+
+            if (player != null) {
+                handlePlayerMessageAll(player, value);
+            }
+        }
+        else {
+            handleCommand(player, profile, skill, value);
+
+            if (player != null) {
+                handlePlayerMessageSkill(player, value, skill);
+            }
+        }
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/experience/MmoeditCommand.java

@@ -0,0 +1,51 @@
+package com.gmail.nossr50.commands.experience;
+
+import com.gmail.nossr50.datatypes.experience.XPGainReason;
+import com.gmail.nossr50.datatypes.player.PlayerProfile;
+import com.gmail.nossr50.datatypes.skills.PrimarySkillType;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.util.EventUtils;
+import com.gmail.nossr50.util.Permissions;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class MmoeditCommand extends ExperienceCommand {
+    @Override
+    protected boolean permissionsCheckSelf(CommandSender sender) {
+        return Permissions.mmoedit(sender);
+    }
+
+    @Override
+    protected boolean permissionsCheckOthers(CommandSender sender) {
+        return Permissions.mmoeditOthers(sender);
+    }
+
+    @Override
+    protected void handleCommand(Player player, PlayerProfile profile, PrimarySkillType skill, int value) {
+        int skillLevel = profile.getSkillLevel(skill);
+        float xpRemoved = profile.getSkillXpLevelRaw(skill);
+
+        profile.modifySkill(skill, value);
+
+        if (player == null) {
+            profile.scheduleAsyncSave();
+            return;
+        }
+
+        if (value == skillLevel) {
+            return;
+        }
+
+        EventUtils.handleLevelChangeEvent(player, skill, value, xpRemoved, value > skillLevel, XPGainReason.COMMAND);
+    }
+
+    @Override
+    protected void handlePlayerMessageAll(Player player, int value) {
+        player.sendMessage(LocaleLoader.getString("Commands.mmoedit.AllSkills.1", value));
+    }
+
+    @Override
+    protected void handlePlayerMessageSkill(Player player, int value, PrimarySkillType skill) {
+        player.sendMessage(LocaleLoader.getString("Commands.mmoedit.Modified.1", skill.getName(), value));
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/experience/SkillresetCommand.java

@@ -0,0 +1,179 @@
+package com.gmail.nossr50.commands.experience;
+
+import com.gmail.nossr50.datatypes.experience.XPGainReason;
+import com.gmail.nossr50.datatypes.player.McMMOPlayer;
+import com.gmail.nossr50.datatypes.player.PlayerProfile;
+import com.gmail.nossr50.datatypes.skills.PrimarySkillType;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.mcMMO;
+import com.gmail.nossr50.util.EventUtils;
+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;
+import org.bukkit.OfflinePlayer;
+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 java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+
+/**
+ * This class mirrors the structure of ExperienceCommand, except the
+ * value/quantity argument is removed.
+ */
+public class SkillresetCommand implements TabExecutor {
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        PrimarySkillType skill;
+        switch (args.length) {
+            case 1:
+                if (CommandUtils.noConsoleUsage(sender)) {
+                    return true;
+                }
+
+                if (!permissionsCheckSelf(sender)) {
+                    sender.sendMessage(command.getPermissionMessage());
+                    return true;
+                }
+
+                if (!validateArguments(sender, args[0])) {
+                    return true;
+                }
+
+                if (args[0].equalsIgnoreCase("all")) {
+                    skill = null;
+                }
+                else {
+                    skill = PrimarySkillType.getSkill(args[1]);
+                }
+
+                editValues((Player) sender, UserManager.getPlayer(sender.getName()).getProfile(), skill);
+                return true;
+
+            case 2:
+                if (!permissionsCheckOthers(sender)) {
+                    sender.sendMessage(command.getPermissionMessage());
+                    return true;
+                }
+
+                if (!validateArguments(sender, args[1])) {
+                    return true;
+                }
+
+                if (args[1].equalsIgnoreCase("all")) {
+                    skill = null;
+                }
+                else {
+                    skill = PrimarySkillType.getSkill(args[1]);
+                }
+
+                String playerName = CommandUtils.getMatchedPlayerName(args[0]);
+                McMMOPlayer mcMMOPlayer = UserManager.getOfflinePlayer(playerName);
+
+                // 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) {
+                    UUID uuid = null;
+                    OfflinePlayer player = mcMMO.p.getServer().getOfflinePlayer(playerName);
+                    if (player != null) {
+                        uuid = player.getUniqueId();
+                    }
+                    PlayerProfile profile = mcMMO.getDatabaseManager().loadPlayerProfile(playerName, uuid, false);
+
+                    if (CommandUtils.unloadedProfile(sender, profile)) {
+                        return true;
+                    }
+
+                    editValues(null, profile, skill);
+                }
+                else {
+                    editValues(mcMMOPlayer.getPlayer(), mcMMOPlayer.getProfile(), skill);
+                }
+
+                handleSenderMessage(sender, playerName, skill);
+                return true;
+
+            default:
+                return false;
+        }
+    }
+
+    @Override
+    public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) {
+        switch (args.length) {
+            case 1:
+                List<String> playerNames = CommandUtils.getOnlinePlayerNames(sender);
+                return StringUtil.copyPartialMatches(args[0], playerNames, new ArrayList<String>(playerNames.size()));
+            case 2:
+                return StringUtil.copyPartialMatches(args[1], PrimarySkillType.SKILL_NAMES, new ArrayList<String>(PrimarySkillType.SKILL_NAMES.size()));
+            default:
+                return ImmutableList.of();
+        }
+    }
+
+    protected void handleCommand(Player player, PlayerProfile profile, PrimarySkillType skill) {
+        int levelsRemoved = profile.getSkillLevel(skill);
+        float xpRemoved = profile.getSkillXpLevelRaw(skill);
+
+        profile.modifySkill(skill, 0);
+
+        if (player == null) {
+            profile.scheduleAsyncSave();
+            return;
+        }
+
+        EventUtils.handleLevelChangeEvent(player, skill, levelsRemoved, xpRemoved, false, XPGainReason.COMMAND);
+    }
+
+    protected boolean permissionsCheckSelf(CommandSender sender) {
+        return Permissions.skillreset(sender);
+    }
+
+    protected boolean permissionsCheckOthers(CommandSender sender) {
+        return Permissions.skillresetOthers(sender);
+    }
+
+    protected void handlePlayerMessageAll(Player player) {
+        player.sendMessage(LocaleLoader.getString("Commands.Reset.All"));
+    }
+
+    protected void handlePlayerMessageSkill(Player player, PrimarySkillType skill) {
+        player.sendMessage(LocaleLoader.getString("Commands.Reset.Single", skill.getName()));
+    }
+
+    private boolean validateArguments(CommandSender sender, String skillName) {
+        return skillName.equalsIgnoreCase("all") || !CommandUtils.isInvalidSkill(sender, skillName);
+    }
+
+    protected static void handleSenderMessage(CommandSender sender, String playerName, PrimarySkillType skill) {
+        if (skill == null) {
+            sender.sendMessage(LocaleLoader.getString("Commands.addlevels.AwardAll.2", playerName));
+        }
+        else {
+            sender.sendMessage(LocaleLoader.getString("Commands.addlevels.AwardSkill.2", skill.getName(), playerName));
+        }
+    }
+
+    protected void editValues(Player player, PlayerProfile profile, PrimarySkillType skill) {
+        if (skill == null) {
+            for (PrimarySkillType primarySkillType : PrimarySkillType.NON_CHILD_SKILLS) {
+                handleCommand(player, profile, primarySkillType);
+            }
+
+            if (player != null) {
+                handlePlayerMessageAll(player);
+            }
+        }
+        else {
+            handleCommand(player, profile, skill);
+
+            if (player != null) {
+                handlePlayerMessageSkill(player, skill);
+            }
+        }
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/hardcore/HardcoreCommand.java

@@ -0,0 +1,64 @@
+package com.gmail.nossr50.commands.hardcore;
+
+import com.gmail.nossr50.config.Config;
+import com.gmail.nossr50.datatypes.skills.PrimarySkillType;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.mcMMO;
+import com.gmail.nossr50.util.Permissions;
+import org.bukkit.command.CommandSender;
+
+public class HardcoreCommand extends HardcoreModeCommand {
+    @Override
+    protected boolean checkTogglePermissions(CommandSender sender) {
+        return Permissions.hardcoreToggle(sender);
+    }
+
+    @Override
+    protected boolean checkModifyPermissions(CommandSender sender) {
+        return Permissions.hardcoreModify(sender);
+    }
+
+    @Override
+    protected boolean checkEnabled(PrimarySkillType skill) {
+        if (skill == null) {
+            for (PrimarySkillType primarySkillType : PrimarySkillType.values()) {
+                if (!primarySkillType.getHardcoreStatLossEnabled()) {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        return skill.getHardcoreStatLossEnabled();
+    }
+
+    @Override
+    protected void enable(PrimarySkillType skill) {
+        toggle(true, skill);
+    }
+
+    @Override
+    protected void disable(PrimarySkillType skill) {
+        toggle(false, skill);
+    }
+
+    @Override
+    protected void modify(CommandSender sender, double newPercentage) {
+        Config.getInstance().setHardcoreDeathStatPenaltyPercentage(newPercentage);
+        sender.sendMessage(LocaleLoader.getString("Hardcore.DeathStatLoss.PercentageChanged", percent.format(newPercentage / 100.0D)));
+    }
+
+    private void toggle(boolean enable, PrimarySkillType skill) {
+        if (skill == null) {
+            for (PrimarySkillType primarySkillType : PrimarySkillType.NON_CHILD_SKILLS) {
+                primarySkillType.setHardcoreStatLossEnabled(enable);
+            }
+        }
+        else {
+            skill.setHardcoreStatLossEnabled(enable);
+        }
+
+        mcMMO.p.getServer().broadcastMessage(LocaleLoader.getString("Hardcore.Mode." + (enable ? "Enabled" : "Disabled"), LocaleLoader.getString("Hardcore.DeathStatLoss.Name"), (skill == null ? "all skills" : skill.getName())));
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/hardcore/HardcoreModeCommand.java

@@ -0,0 +1,130 @@
+package com.gmail.nossr50.commands.hardcore;
+
+import com.gmail.nossr50.datatypes.skills.PrimarySkillType;
+import com.gmail.nossr50.util.Permissions;
+import com.gmail.nossr50.util.StringUtils;
+import com.gmail.nossr50.util.commands.CommandUtils;
+import com.google.common.collect.ImmutableList;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
+import org.bukkit.util.StringUtil;
+
+import java.text.DecimalFormat;
+import java.util.ArrayList;
+import java.util.List;
+
+public abstract class HardcoreModeCommand implements TabExecutor {
+    protected final DecimalFormat percent = new DecimalFormat("##0.00%");
+
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        switch (args.length) {
+            case 0:
+                if (!checkTogglePermissions(sender)) {
+                    sender.sendMessage(command.getPermissionMessage());
+                    return true;
+                }
+
+                if (checkEnabled(null)) {
+                    disable(null);
+                }
+                else {
+                    enable(null);
+                }
+
+                return true;
+
+            case 1:
+                if (CommandUtils.shouldEnableToggle(args[0])) {
+                    if (!Permissions.hardcoreToggle(sender)) {
+                        sender.sendMessage(command.getPermissionMessage());
+                        return true;
+                    }
+
+                    enable(null);
+                    return true;
+                }
+
+                if (CommandUtils.shouldDisableToggle(args[0])) {
+                    if (!Permissions.hardcoreToggle(sender)) {
+                        sender.sendMessage(command.getPermissionMessage());
+                        return true;
+                    }
+
+                    disable(null);
+                    return true;
+                }
+
+                if (CommandUtils.isInvalidDouble(sender, args[0])) {
+                    return true;
+                }
+
+                if (!Permissions.hardcoreModify(sender)) {
+                    sender.sendMessage(command.getPermissionMessage());
+                    return true;
+                }
+
+                modify(sender, Double.parseDouble(args[0]));
+                return true;
+
+
+            case 2:
+                if (CommandUtils.isInvalidSkill(sender, args[0])) {
+                    return true;
+                }
+
+                PrimarySkillType skill = PrimarySkillType.getSkill(args[0]);
+
+                if (!CommandUtils.isChildSkill(sender, skill)) {
+                    return true;
+                }
+
+                if (CommandUtils.shouldEnableToggle(args[1])) {
+                    if (!Permissions.hardcoreToggle(sender)) {
+                        sender.sendMessage(command.getPermissionMessage());
+                        return true;
+                    }
+
+                    enable(skill);
+                    return true;
+                }
+
+                if (CommandUtils.shouldDisableToggle(args[1])) {
+                    if (!Permissions.hardcoreToggle(sender)) {
+                        sender.sendMessage(command.getPermissionMessage());
+                        return true;
+                    }
+
+                    enable(skill);
+                    return true;
+                }
+
+                return true;
+
+            default:
+                return false;
+        }
+    }
+
+    @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(CommandSender sender);
+    protected abstract boolean checkModifyPermissions(CommandSender sender);
+    protected abstract boolean checkEnabled(PrimarySkillType skill);
+    protected abstract void enable(PrimarySkillType skill);
+    protected abstract void disable(PrimarySkillType skill);
+    protected abstract void modify(CommandSender sender, double newPercentage);
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/hardcore/VampirismCommand.java

@@ -0,0 +1,64 @@
+package com.gmail.nossr50.commands.hardcore;
+
+import com.gmail.nossr50.config.Config;
+import com.gmail.nossr50.datatypes.skills.PrimarySkillType;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.mcMMO;
+import com.gmail.nossr50.util.Permissions;
+import org.bukkit.command.CommandSender;
+
+public class VampirismCommand extends HardcoreModeCommand {
+    @Override
+    protected boolean checkTogglePermissions(CommandSender sender) {
+        return Permissions.vampirismToggle(sender);
+    }
+
+    @Override
+    protected boolean checkModifyPermissions(CommandSender sender) {
+        return Permissions.vampirismModify(sender);
+    }
+
+    @Override
+    protected boolean checkEnabled(PrimarySkillType skill) {
+        if (skill == null) {
+            for (PrimarySkillType primarySkillType : PrimarySkillType.values()) {
+                if (!primarySkillType.getHardcoreVampirismEnabled()) {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        return skill.getHardcoreVampirismEnabled();
+    }
+
+    @Override
+    protected void enable(PrimarySkillType skill) {
+        toggle(true, skill);
+    }
+
+    @Override
+    protected void disable(PrimarySkillType skill) {
+        toggle(false, skill);
+    }
+
+    @Override
+    protected void modify(CommandSender sender, double newPercentage) {
+        Config.getInstance().setHardcoreVampirismStatLeechPercentage(newPercentage);
+        sender.sendMessage(LocaleLoader.getString("Hardcore.Vampirism.PercentageChanged", percent.format(newPercentage / 100.0D)));
+    }
+
+    private void toggle(boolean enable, PrimarySkillType skill) {
+        if (skill == null) {
+            for (PrimarySkillType primarySkillType : PrimarySkillType.NON_CHILD_SKILLS) {
+                primarySkillType.setHardcoreVampirismEnabled(enable);
+            }
+        }
+        else {
+            skill.setHardcoreVampirismEnabled(enable);
+        }
+
+        mcMMO.p.getServer().broadcastMessage(LocaleLoader.getString("Hardcore.Mode." + (enable ? "Enabled" : "Disabled"), LocaleLoader.getString("Hardcore.Vampirism.Name"), (skill == null ? "all skills" : skill)));
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/party/PartyAcceptCommand.java

@@ -0,0 +1,38 @@
+package com.gmail.nossr50.commands.party;
+
+import com.gmail.nossr50.datatypes.player.McMMOPlayer;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.party.PartyManager;
+import com.gmail.nossr50.util.player.UserManager;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class PartyAcceptCommand implements CommandExecutor {
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        switch (args.length) {
+            case 1:
+                Player player = (Player) sender;
+                McMMOPlayer mcMMOPlayer = UserManager.getPlayer(player);
+
+                if (!mcMMOPlayer.hasPartyInvite()) {
+                    sender.sendMessage(LocaleLoader.getString("mcMMO.NoInvites"));
+                    return true;
+                }
+
+                // Changing parties
+                if (!PartyManager.changeOrJoinParty(mcMMOPlayer, mcMMOPlayer.getPartyInvite().getName())) {
+                    return true;
+                }
+
+                PartyManager.joinInvitedParty(mcMMOPlayer);
+                return true;
+
+            default:
+                sender.sendMessage(LocaleLoader.getString("Commands.Usage.1", "party", "accept"));
+                return true;
+        }
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/party/PartyChangeOwnerCommand.java

@@ -0,0 +1,37 @@
+package com.gmail.nossr50.commands.party;
+
+import com.gmail.nossr50.datatypes.party.Party;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.mcMMO;
+import com.gmail.nossr50.party.PartyManager;
+import com.gmail.nossr50.util.commands.CommandUtils;
+import com.gmail.nossr50.util.player.UserManager;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class PartyChangeOwnerCommand implements CommandExecutor {
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        switch (args.length) {
+            case 2:
+                Party playerParty = UserManager.getPlayer((Player) sender).getParty();
+                String targetName = CommandUtils.getMatchedPlayerName(args[1]);
+                OfflinePlayer target = mcMMO.p.getServer().getOfflinePlayer(targetName);
+
+                if (!playerParty.hasMember(target.getUniqueId())) {
+                    sender.sendMessage(LocaleLoader.getString("Party.NotInYourParty", targetName));
+                    return true;
+                }
+
+                PartyManager.setPartyLeader(target.getUniqueId(), playerParty);
+                return true;
+
+            default:
+                sender.sendMessage(LocaleLoader.getString("Commands.Usage.2", "party", "owner", "<" + LocaleLoader.getString("Commands.Usage.Player") + ">"));
+                return true;
+        }
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/party/PartyChangePasswordCommand.java

@@ -0,0 +1,48 @@
+package com.gmail.nossr50.commands.party;
+
+import com.gmail.nossr50.datatypes.party.Party;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.util.player.UserManager;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class PartyChangePasswordCommand implements CommandExecutor {
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        Party party = UserManager.getPlayer((Player) sender).getParty();
+
+        switch (args.length) {
+            case 1:
+                unprotectParty(party, sender);
+                return true;
+
+            case 2:
+                if (args[1].equalsIgnoreCase("clear") || args[1].equalsIgnoreCase("reset")) {
+                    unprotectParty(party, sender);
+                    return true;
+                }
+
+                protectParty(party, sender, args[1]);
+                return true;
+
+            default:
+                sender.sendMessage(LocaleLoader.getString("Commands.Usage.2", "party", "password", "[clear|reset]"));
+                sender.sendMessage(LocaleLoader.getString("Commands.Usage.2", "party", "password", "<" + LocaleLoader.getString("Commands.Usage.Password") + ">"));
+                return true;
+        }
+    }
+
+    private void unprotectParty(Party party, CommandSender sender) {
+        party.setLocked(true);
+        party.setPassword(null);
+        sender.sendMessage(LocaleLoader.getString("Party.Password.Removed"));
+    }
+
+    private void protectParty(Party party, CommandSender sender, String password) {
+        party.setLocked(true);
+        party.setPassword(password);
+        sender.sendMessage(LocaleLoader.getString("Party.Password.Set", password));
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/party/PartyCommand.java

@@ -0,0 +1,236 @@
+package com.gmail.nossr50.commands.party;
+
+import com.gmail.nossr50.commands.chat.PartyChatCommand;
+import com.gmail.nossr50.commands.party.alliance.PartyAllianceCommand;
+import com.gmail.nossr50.commands.party.teleport.PtpCommand;
+import com.gmail.nossr50.datatypes.party.Party;
+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;
+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 java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+public class PartyCommand implements TabExecutor {
+    private static final List<String> PARTY_SUBCOMMANDS;
+    private static final List<String> XPSHARE_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();
+    private CommandExecutor partyQuitCommand           = new PartyQuitCommand();
+    private CommandExecutor partyXpShareCommand        = new PartyXpShareCommand();
+    private CommandExecutor partyItemShareCommand      = new PartyItemShareCommand();
+    private CommandExecutor partyInviteCommand         = new PartyInviteCommand();
+    private CommandExecutor partyKickCommand           = new PartyKickCommand();
+    private CommandExecutor partyDisbandCommand        = new PartyDisbandCommand();
+    private CommandExecutor partyChangeOwnerCommand    = new PartyChangeOwnerCommand();
+    private CommandExecutor partyLockCommand           = new PartyLockCommand();
+    private CommandExecutor partyChangePasswordCommand = new PartyChangePasswordCommand();
+    private CommandExecutor partyRenameCommand         = new PartyRenameCommand();
+    private CommandExecutor partyInfoCommand           = new PartyInfoCommand();
+    private CommandExecutor partyHelpCommand           = new PartyHelpCommand();
+    private CommandExecutor partyTeleportCommand       = new PtpCommand();
+    private CommandExecutor partyChatCommand           = new PartyChatCommand();
+    private CommandExecutor partyAllianceCommand       = new PartyAllianceCommand();
+
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        if (CommandUtils.noConsoleUsage(sender)) {
+            return true;
+        }
+
+        if (!Permissions.party(sender)) {
+            sender.sendMessage(command.getPermissionMessage());
+            return true;
+        }
+
+        Player player = (Player) sender;
+
+        if (!UserManager.hasPlayerDataKey(player)) {
+            return true;
+        }
+
+        McMMOPlayer mcMMOPlayer = UserManager.getPlayer(player);
+
+        if (args.length < 1) {
+            if (!mcMMOPlayer.inParty()) {
+                sender.sendMessage(LocaleLoader.getString("Commands.Party.None"));
+                return printUsage(player);
+            }
+
+            return partyInfoCommand.onCommand(sender, command, label, args);
+        }
+
+        PartySubcommandType subcommand = PartySubcommandType.getSubcommand(args[0]);
+
+        if (subcommand == null) {
+            return printUsage(player);
+        }
+
+        // Can't use this for lock/unlock since they're handled by the same command
+        if (subcommand != PartySubcommandType.LOCK && subcommand != PartySubcommandType.UNLOCK && !Permissions.partySubcommand(sender, subcommand)) {
+            sender.sendMessage(command.getPermissionMessage());
+            return true;
+        }
+
+        switch (subcommand) {
+            case JOIN:
+                return partyJoinCommand.onCommand(sender, command, label, args);
+            case ACCEPT:
+                return partyAcceptCommand.onCommand(sender, command, label, args);
+            case CREATE:
+                return partyCreateCommand.onCommand(sender, command, label, args);
+            case HELP:
+                return partyHelpCommand.onCommand(sender, command, label, args);
+            default:
+                break;
+        }
+
+        // Party member commands
+        if (!mcMMOPlayer.inParty()) {
+            sender.sendMessage(LocaleLoader.getString("Commands.Party.None"));
+            return printUsage(player);
+        }
+
+        switch (subcommand) {
+            case INFO:
+                return partyInfoCommand.onCommand(sender, command, label, args);
+            case QUIT:
+                return partyQuitCommand.onCommand(sender, command, label, args);
+            case INVITE:
+                return partyInviteCommand.onCommand(sender, command, label, args);
+            case TELEPORT:
+                return partyTeleportCommand.onCommand(sender, command, label, extractArgs(args));
+            case CHAT:
+                return partyChatCommand.onCommand(sender, command, label, extractArgs(args));
+            default:
+                break;
+        }
+
+        // Party leader commands
+        if (!mcMMOPlayer.getParty().getLeader().getUniqueId().equals(player.getUniqueId())) {
+            sender.sendMessage(LocaleLoader.getString("Party.NotOwner"));
+            return true;
+        }
+
+        switch (subcommand) {
+            case XPSHARE:
+                return partyXpShareCommand.onCommand(sender, command, label, args);
+            case ITEMSHARE:
+                return partyItemShareCommand.onCommand(sender, command, label, args);
+            case KICK:
+                return partyKickCommand.onCommand(sender, command, label, args);
+            case DISBAND:
+                return partyDisbandCommand.onCommand(sender, command, label, args);
+            case OWNER:
+                return partyChangeOwnerCommand.onCommand(sender, command, label, args);
+            case LOCK:
+            case UNLOCK:
+                return partyLockCommand.onCommand(sender, command, label, args);
+            case PASSWORD:
+                return partyChangePasswordCommand.onCommand(sender, command, label, args);
+            case RENAME:
+                return partyRenameCommand.onCommand(sender, command, label, args);
+            case ALLIANCE:
+                return partyAllianceCommand.onCommand(sender, command, label, args);
+            default:
+                break;
+        }
+
+        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:
+                        List<String> playerNames = CommandUtils.getOnlinePlayerNames(sender);
+                        return StringUtil.copyPartialMatches(args[1], playerNames, new ArrayList<String>(playerNames.size()));
+                    case XPSHARE:
+                        return StringUtil.copyPartialMatches(args[1], XPSHARE_COMPLETIONS, new ArrayList<String>(XPSHARE_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) {
+                            Player player = (Player) sender;
+                            Party party = UserManager.getPlayer(player).getParty();
+
+                            playerNames = party.getOnlinePlayerNames(player);
+                            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 player) {
+        player.sendMessage(LocaleLoader.getString("Party.Help.0", "/party join"));
+        player.sendMessage(LocaleLoader.getString("Party.Help.1", "/party create"));
+        player.sendMessage(LocaleLoader.getString("Party.Help.2", "/party ?"));
+        return true;
+    }
+
+    private String[] extractArgs(String[] args) {
+        return Arrays.copyOfRange(args, 1, args.length);
+    }
+
+    private boolean isItemShareCategory(String category) {
+        return category.equalsIgnoreCase("loot") || category.equalsIgnoreCase("mining") || category.equalsIgnoreCase("herbalism") || category.equalsIgnoreCase("woodcutting") || category.equalsIgnoreCase("misc");
+    }
+}
+

mcMMO-core/src/main/java/com/gmail/nossr50/commands/party/PartyCreateCommand.java

@@ -0,0 +1,47 @@
+package com.gmail.nossr50.commands.party;
+
+import com.gmail.nossr50.datatypes.player.McMMOPlayer;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.party.PartyManager;
+import com.gmail.nossr50.util.player.UserManager;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class PartyCreateCommand implements CommandExecutor {
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        switch (args.length) {
+            case 2:
+            case 3:
+                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, args[1])) {
+                    return true;
+                }
+
+                // Changing parties
+                if (!PartyManager.changeOrJoinParty(mcMMOPlayer, args[1])) {
+                    return true;
+                }
+
+                PartyManager.createParty(mcMMOPlayer, args[1], getPassword(args));
+                return true;
+
+            default:
+                sender.sendMessage(LocaleLoader.getString("Commands.Usage.3", "party", "create", "<" + LocaleLoader.getString("Commands.Usage.PartyName") + ">", "[" + LocaleLoader.getString("Commands.Usage.Password") + "]"));
+                return true;
+        }
+    }
+
+    private String getPassword(String[] args) {
+        if (args.length == 3) {
+            return args[2];
+        }
+
+        return null;
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/party/PartyDisbandCommand.java

@@ -0,0 +1,37 @@
+package com.gmail.nossr50.commands.party;
+
+import com.gmail.nossr50.datatypes.party.Party;
+import com.gmail.nossr50.events.party.McMMOPartyChangeEvent.EventReason;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.party.PartyManager;
+import com.gmail.nossr50.util.player.UserManager;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class PartyDisbandCommand implements CommandExecutor {
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        switch (args.length) {
+            case 1:
+                Party playerParty = UserManager.getPlayer((Player) sender).getParty();
+                String partyName = playerParty.getName();
+
+                for (Player member : playerParty.getOnlineMembers()) {
+                    if (!PartyManager.handlePartyChangeEvent(member, partyName, null, EventReason.KICKED_FROM_PARTY)) {
+                        return true;
+                    }
+
+                    member.sendMessage(LocaleLoader.getString("Party.Disband"));
+                }
+
+                PartyManager.disbandParty(playerParty);
+                return true;
+
+            default:
+                sender.sendMessage(LocaleLoader.getString("Commands.Usage.1", "party", "disband"));
+                return true;
+        }
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/party/PartyHelpCommand.java

@@ -0,0 +1,30 @@
+package com.gmail.nossr50.commands.party;
+
+import com.gmail.nossr50.locale.LocaleLoader;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+
+public class PartyHelpCommand implements CommandExecutor {
+
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        switch (args.length) {
+            case 1:
+                sender.sendMessage(LocaleLoader.getString("Party.Help.3", "/party join", "/party quit"));
+                sender.sendMessage(LocaleLoader.getString("Party.Help.1", "/party create"));
+                sender.sendMessage(LocaleLoader.getString("Party.Help.4", "/party <lock|unlock>"));
+                sender.sendMessage(LocaleLoader.getString("Party.Help.5", "/party password"));
+                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 xpshare"));
+                return true;
+
+            default:
+                sender.sendMessage(LocaleLoader.getString("Commands.Usage.1", "party", "help"));
+                return true;
+        }
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/party/PartyInfoCommand.java

@@ -0,0 +1,129 @@
+package com.gmail.nossr50.commands.party;
+
+import com.gmail.nossr50.config.Config;
+import com.gmail.nossr50.datatypes.party.Party;
+import com.gmail.nossr50.datatypes.party.PartyFeature;
+import com.gmail.nossr50.datatypes.party.ShareMode;
+import com.gmail.nossr50.datatypes.player.McMMOPlayer;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.party.PartyManager;
+import com.gmail.nossr50.util.player.UserManager;
+import org.bukkit.ChatColor;
+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;
+
+public class PartyInfoCommand implements CommandExecutor {
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        switch (args.length) {
+            case 0:
+            case 1:
+                Player player = (Player) sender;
+                McMMOPlayer mcMMOPlayer = UserManager.getPlayer(player);
+                Party party = mcMMOPlayer.getParty();
+
+                displayPartyHeader(player, party);
+                displayShareModeInfo(player, party);
+                displayPartyFeatures(player, party);
+                displayMemberInfo(player, mcMMOPlayer, party);
+                return true;
+
+            default:
+                sender.sendMessage(LocaleLoader.getString("Commands.Usage.1", "party", "info"));
+                return true;
+        }
+    }
+
+    private void displayPartyHeader(Player player, Party party) {
+        player.sendMessage(LocaleLoader.getString("Commands.Party.Header"));
+
+        StringBuilder status = new StringBuilder();
+        status.append(LocaleLoader.getString("Commands.Party.Status", party.getName(), LocaleLoader.getString("Party.Status." + (party.isLocked() ? "Locked" : "Unlocked")), party.getLevel()));
+
+        if (!party.hasReachedLevelCap()) {
+            status.append(" (").append(party.getXpToLevelPercentage()).append(")");
+        }
+
+        player.sendMessage(status.toString());
+    }
+
+    private void displayPartyFeatures(Player player, Party party) {
+        player.sendMessage(LocaleLoader.getString("Commands.Party.Features.Header"));
+
+        List<String> unlockedPartyFeatures = new ArrayList<String>();
+        List<String> lockedPartyFeatures = new ArrayList<String>();
+
+        for (PartyFeature partyFeature : PartyFeature.values()) {
+            if (!partyFeature.hasPermission(player)) {
+                continue;
+            }
+
+            if (isUnlockedFeature(party, partyFeature)) {
+                unlockedPartyFeatures.add(partyFeature.getLocaleString());
+            }
+            else {
+                lockedPartyFeatures.add(partyFeature.getFeatureLockedLocaleString());
+            }
+        }
+
+        player.sendMessage(LocaleLoader.getString("Commands.Party.UnlockedFeatures", unlockedPartyFeatures.isEmpty() ? "None" : unlockedPartyFeatures));
+
+        for (String message : lockedPartyFeatures) {
+            player.sendMessage(message);
+        }
+    }
+
+    private boolean isUnlockedFeature(Party party, PartyFeature partyFeature) {
+        return party.getLevel() >= Config.getInstance().getPartyFeatureUnlockLevel(partyFeature);
+    }
+
+    private void displayShareModeInfo(Player player, Party party) {
+        boolean xpShareEnabled = isUnlockedFeature(party, PartyFeature.XP_SHARE);
+        boolean itemShareEnabled = isUnlockedFeature(party, PartyFeature.ITEM_SHARE);
+        boolean itemSharingActive = (party.getItemShareMode() != ShareMode.NONE);
+
+        if (!xpShareEnabled && !itemShareEnabled) {
+            return;
+        }
+
+        String expShareInfo = "";
+        String itemShareInfo = "";
+        String separator = "";
+
+        if (xpShareEnabled) {
+            expShareInfo = LocaleLoader.getString("Commands.Party.ExpShare", party.getXpShareMode().toString());
+        }
+
+        if (itemShareEnabled) {
+            itemShareInfo = LocaleLoader.getString("Commands.Party.ItemShare", party.getItemShareMode().toString());
+        }
+
+        if (xpShareEnabled && itemShareEnabled) {
+            separator = ChatColor.DARK_GRAY + " || ";
+        }
+
+        player.sendMessage(LocaleLoader.getString("Commands.Party.ShareMode") + expShareInfo + separator + itemShareInfo);
+
+        if (itemSharingActive) {
+            player.sendMessage(LocaleLoader.getString("Commands.Party.ItemShareCategories", party.getItemShareCategories()));
+        }
+    }
+
+    private void displayMemberInfo(Player player, McMMOPlayer mcMMOPlayer, Party party) {
+        /*
+         * Only show members of the party that this member can see
+         */
+
+        List<Player> nearMembers = PartyManager.getNearVisibleMembers(mcMMOPlayer);
+        int membersOnline = party.getVisibleMembers(player).size();
+
+        player.sendMessage(LocaleLoader.getString("Commands.Party.Members.Header"));
+        player.sendMessage(LocaleLoader.getString("Commands.Party.MembersNear", nearMembers.size()+1, membersOnline));
+        player.sendMessage(party.createMembersList(player));
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/party/PartyInviteCommand.java

@@ -0,0 +1,67 @@
+package com.gmail.nossr50.commands.party;
+
+import com.gmail.nossr50.config.Config;
+import com.gmail.nossr50.datatypes.party.Party;
+import com.gmail.nossr50.datatypes.player.McMMOPlayer;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.party.PartyManager;
+import com.gmail.nossr50.util.commands.CommandUtils;
+import com.gmail.nossr50.util.player.UserManager;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class PartyInviteCommand implements CommandExecutor {
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        switch (args.length) {
+            case 2:
+                String targetName = CommandUtils.getMatchedPlayerName(args[1]);
+                McMMOPlayer mcMMOTarget = UserManager.getOfflinePlayer(targetName);
+
+                if (!CommandUtils.checkPlayerExistence(sender, targetName, mcMMOTarget)) {
+                    return false;
+                }
+
+                Player target = mcMMOTarget.getPlayer();
+                Player player = (Player) sender;
+                McMMOPlayer mcMMOPlayer = UserManager.getPlayer(player);
+                String playerName = player.getName();
+
+                if (player.equals(target)) {
+                    sender.sendMessage(LocaleLoader.getString("Party.Invite.Self"));
+                    return true;
+                }
+
+                if (PartyManager.inSameParty(player, target)) {
+                    sender.sendMessage(LocaleLoader.getString("Party.Player.InSameParty", targetName));
+                    return true;
+                }
+
+                if (!PartyManager.canInvite(mcMMOPlayer)) {
+                    player.sendMessage(LocaleLoader.getString("Party.Locked"));
+                    return true;
+                }
+
+                Party playerParty = mcMMOPlayer.getParty();
+
+                if(PartyManager.isPartyFull(target, playerParty))
+                {
+                    player.sendMessage(LocaleLoader.getString("Commands.Party.PartyFull.Invite", target.getName(), playerParty.toString(), Config.getInstance().getPartyMaxSize()));
+                    return true;
+                }
+
+                mcMMOTarget.setPartyInvite(playerParty);
+
+                sender.sendMessage(LocaleLoader.getString("Commands.Invite.Success"));
+                target.sendMessage(LocaleLoader.getString("Commands.Party.Invite.0", playerParty.getName(), playerName));
+                target.sendMessage(LocaleLoader.getString("Commands.Party.Invite.1"));
+                return true;
+
+            default:
+                sender.sendMessage(LocaleLoader.getString("Commands.Usage.2", "party", "invite", "<" + LocaleLoader.getString("Commands.Usage.Player") + ">"));
+                return true;
+        }
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/party/PartyItemShareCommand.java

@@ -0,0 +1,88 @@
+package com.gmail.nossr50.commands.party;
+
+import com.gmail.nossr50.config.Config;
+import com.gmail.nossr50.datatypes.party.ItemShareType;
+import com.gmail.nossr50.datatypes.party.Party;
+import com.gmail.nossr50.datatypes.party.PartyFeature;
+import com.gmail.nossr50.datatypes.party.ShareMode;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.util.StringUtils;
+import com.gmail.nossr50.util.commands.CommandUtils;
+import com.gmail.nossr50.util.player.UserManager;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class PartyItemShareCommand implements CommandExecutor {
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        Party party = UserManager.getPlayer((Player) sender).getParty();
+
+        if (party.getLevel() < Config.getInstance().getPartyFeatureUnlockLevel(PartyFeature.ITEM_SHARE)) {
+            sender.sendMessage(LocaleLoader.getString("Party.Feature.Disabled.4"));
+            return true;
+        }
+
+        switch (args.length) {
+            case 2:
+                ShareMode mode = ShareMode.getShareMode(args[1].toUpperCase());
+
+                if (mode == null) {
+                    sender.sendMessage(LocaleLoader.getString("Commands.Usage.2", "party", "itemshare", "<NONE | EQUAL | RANDOM>"));
+                    return true;
+                }
+
+                handleChangingShareMode(party, mode);
+                return true;
+
+            case 3:
+                boolean toggle;
+
+                if (CommandUtils.shouldEnableToggle(args[2])) {
+                    toggle = true;
+                }
+                else if (CommandUtils.shouldDisableToggle(args[2])) {
+                    toggle = false;
+                }
+                else {
+                    sender.sendMessage(LocaleLoader.getString("Commands.Usage.2", "party", "itemshare", "<loot | mining | herbalism | woodcutting | misc> <true | false>"));
+                    return true;
+                }
+
+                try {
+                    handleToggleItemShareCategory(party, ItemShareType.valueOf(args[1].toUpperCase()), toggle);
+                }
+                catch (IllegalArgumentException ex) {
+                    sender.sendMessage(LocaleLoader.getString("Commands.Usage.2", "party", "itemshare", "<loot | mining | herbalism | woodcutting | misc> <true | false>"));
+                }
+
+                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 | misc> <true | false>"));
+                return true;
+        }
+    }
+
+    private void handleChangingShareMode(Party party, ShareMode mode) {
+        party.setItemShareMode(mode);
+
+        String changeModeMessage = LocaleLoader.getString("Commands.Party.SetSharing", LocaleLoader.getString("Party.ShareType.Item"), LocaleLoader.getString("Party.ShareMode." + StringUtils.getCapitalized(mode.toString())));
+
+        for (Player member : party.getOnlineMembers()) {
+            member.sendMessage(changeModeMessage);
+        }
+    }
+
+    private void handleToggleItemShareCategory(Party party, ItemShareType type, boolean toggle) {
+        party.setSharingDrops(type, toggle);
+
+        String toggleMessage = LocaleLoader.getString("Commands.Party.ToggleShareCategory", StringUtils.getCapitalized(type.toString()), toggle ? "enabled" : "disabled");
+
+        for (Player member : party.getOnlineMembers()) {
+            member.sendMessage(toggleMessage);
+        }
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/party/PartyJoinCommand.java

@@ -0,0 +1,80 @@
+package com.gmail.nossr50.commands.party;
+
+import com.gmail.nossr50.datatypes.party.Party;
+import com.gmail.nossr50.datatypes.player.McMMOPlayer;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.party.PartyManager;
+import com.gmail.nossr50.util.commands.CommandUtils;
+import com.gmail.nossr50.util.player.UserManager;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class PartyJoinCommand implements CommandExecutor {
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        switch (args.length) {
+            case 2:
+            case 3:
+                String targetName = CommandUtils.getMatchedPlayerName(args[1]);
+                McMMOPlayer mcMMOTarget = UserManager.getPlayer(targetName);
+
+                if (!CommandUtils.checkPlayerExistence(sender, targetName, mcMMOTarget)) {
+                    return true;
+                }
+
+                Player target = mcMMOTarget.getPlayer();
+
+                if (!mcMMOTarget.inParty()) {
+                    sender.sendMessage(LocaleLoader.getString("Party.PlayerNotInParty", targetName));
+                    return true;
+                }
+
+                Player player = (Player) sender;
+                McMMOPlayer mcMMOPlayer = UserManager.getPlayer(player);
+                Party targetParty = mcMMOTarget.getParty();
+
+                if (player.equals(target) || (mcMMOPlayer.inParty() && mcMMOPlayer.getParty().equals(targetParty))) {
+                    sender.sendMessage(LocaleLoader.getString("Party.Join.Self"));
+                    return true;
+                }
+
+                String password = getPassword(args);
+
+                // Make sure party passwords match
+                if (!PartyManager.checkPartyPassword(player, targetParty, password)) {
+                    return true;
+                }
+
+                String partyName = targetParty.getName();
+
+                // Changing parties
+                if (!PartyManager.changeOrJoinParty(mcMMOPlayer, partyName)) {
+                    return true;
+                }
+
+                if(PartyManager.isPartyFull(player, targetParty))
+                {
+                    player.sendMessage(LocaleLoader.getString("Commands.Party.PartyFull", targetParty.toString()));
+                    return true;
+                }
+
+                player.sendMessage(LocaleLoader.getString("Commands.Party.Join", partyName));
+                PartyManager.addToParty(mcMMOPlayer, targetParty);
+                return true;
+
+            default:
+                sender.sendMessage(LocaleLoader.getString("Commands.Usage.3", "party", "join", "<" + LocaleLoader.getString("Commands.Usage.Player") + ">", "[" + LocaleLoader.getString("Commands.Usage.Password") + "]"));
+                return true;
+        }
+    }
+
+    private String getPassword(String[] args) {
+        if (args.length == 3) {
+            return args[2];
+        }
+
+        return null;
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/party/PartyKickCommand.java

@@ -0,0 +1,51 @@
+package com.gmail.nossr50.commands.party;
+
+import com.gmail.nossr50.datatypes.party.Party;
+import com.gmail.nossr50.events.party.McMMOPartyChangeEvent.EventReason;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.mcMMO;
+import com.gmail.nossr50.party.PartyManager;
+import com.gmail.nossr50.util.commands.CommandUtils;
+import com.gmail.nossr50.util.player.UserManager;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class PartyKickCommand implements CommandExecutor {
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        switch (args.length) {
+            case 2:
+                Party playerParty = UserManager.getPlayer((Player) sender).getParty();
+                String targetName = CommandUtils.getMatchedPlayerName(args[1]);
+
+                if (!playerParty.hasMember(targetName)) {
+                    sender.sendMessage(LocaleLoader.getString("Party.NotInYourParty", targetName));
+                    return true;
+                }
+
+                OfflinePlayer target = mcMMO.p.getServer().getOfflinePlayer(targetName);
+
+                if (target.isOnline()) {
+                    Player onlineTarget = target.getPlayer();
+                    String partyName = playerParty.getName();
+
+                    if (!PartyManager.handlePartyChangeEvent(onlineTarget, partyName, null, EventReason.KICKED_FROM_PARTY)) {
+                        return true;
+                    }
+
+                    PartyManager.processPartyLeaving(UserManager.getPlayer(onlineTarget));
+                    onlineTarget.sendMessage(LocaleLoader.getString("Commands.Party.Kick", partyName));
+                }
+
+                PartyManager.removeFromParty(target, playerParty);
+                return true;
+
+            default:
+                sender.sendMessage(LocaleLoader.getString("Commands.Usage.2", "party", "kick", "<" + LocaleLoader.getString("Commands.Usage.Player") + ">"));
+                return true;
+        }
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/party/PartyLockCommand.java

@@ -0,0 +1,72 @@
+package com.gmail.nossr50.commands.party;
+
+import com.gmail.nossr50.datatypes.party.Party;
+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 org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class PartyLockCommand implements CommandExecutor {
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        switch (args.length) {
+            case 1:
+                if (args[0].equalsIgnoreCase("lock")) {
+                    togglePartyLock(sender, true);
+                }
+                else if (args[0].equalsIgnoreCase("unlock")) {
+                    togglePartyLock(sender, false);
+                }
+
+                return true;
+
+            case 2:
+                if (!args[0].equalsIgnoreCase("lock")) {
+                    sendUsageStrings(sender);
+                    return true;
+                }
+
+                if (CommandUtils.shouldEnableToggle(args[1])) {
+                    togglePartyLock(sender, true);
+                }
+                else if (CommandUtils.shouldDisableToggle(args[1])) {
+                    togglePartyLock(sender, false);
+                }
+                else {
+                    sendUsageStrings(sender);
+                }
+
+                return true;
+
+            default:
+                sendUsageStrings(sender);
+                return true;
+        }
+    }
+
+    private void sendUsageStrings(CommandSender sender) {
+        sender.sendMessage(LocaleLoader.getString("Commands.Usage.2", "party", "lock", "[on|off]"));
+        sender.sendMessage(LocaleLoader.getString("Commands.Usage.1", "party", "unlock"));
+    }
+
+    private void togglePartyLock(CommandSender sender, boolean lock) {
+        Party party = UserManager.getPlayer((Player) sender).getParty();
+
+        if (!Permissions.partySubcommand(sender, lock ? PartySubcommandType.LOCK : PartySubcommandType.UNLOCK)) {
+            sender.sendMessage(LocaleLoader.getString("mcMMO.NoPermission"));
+            return;
+        }
+
+        if (lock ? party.isLocked() : !party.isLocked()) {
+            sender.sendMessage(LocaleLoader.getString("Party." + (lock ? "IsLocked" : "IsntLocked")));
+            return;
+        }
+
+        party.setLocked(lock);
+        sender.sendMessage(LocaleLoader.getString("Party." + (lock ? "Locked" : "Unlocked")));
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/party/PartyQuitCommand.java

@@ -0,0 +1,36 @@
+package com.gmail.nossr50.commands.party;
+
+import com.gmail.nossr50.datatypes.party.Party;
+import com.gmail.nossr50.datatypes.player.McMMOPlayer;
+import com.gmail.nossr50.events.party.McMMOPartyChangeEvent.EventReason;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.party.PartyManager;
+import com.gmail.nossr50.util.player.UserManager;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class PartyQuitCommand implements CommandExecutor {
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        switch (args.length) {
+            case 1:
+                Player player = (Player) sender;
+                McMMOPlayer mcMMOPlayer = UserManager.getPlayer(player);
+                Party playerParty = mcMMOPlayer.getParty();
+
+                if (!PartyManager.handlePartyChangeEvent(player, playerParty.getName(), null, EventReason.LEFT_PARTY)) {
+                    return true;
+                }
+
+                PartyManager.removeFromParty(mcMMOPlayer);
+                sender.sendMessage(LocaleLoader.getString("Commands.Party.Leave"));
+                return true;
+
+            default:
+                sender.sendMessage(LocaleLoader.getString("Commands.Usage.1", "party", "quit"));
+                return true;
+        }
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/party/PartyRenameCommand.java

@@ -0,0 +1,60 @@
+package com.gmail.nossr50.commands.party;
+
+import com.gmail.nossr50.datatypes.party.Party;
+import com.gmail.nossr50.datatypes.player.McMMOPlayer;
+import com.gmail.nossr50.events.party.McMMOPartyChangeEvent.EventReason;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.party.PartyManager;
+import com.gmail.nossr50.util.player.UserManager;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class PartyRenameCommand implements CommandExecutor {
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        switch (args.length) {
+            case 2:
+                McMMOPlayer mcMMOPlayer = UserManager.getPlayer((Player) sender);
+                Party playerParty = mcMMOPlayer.getParty();
+
+                String oldPartyName = playerParty.getName();
+                String newPartyName = args[1];
+
+                // This is to prevent party leaders from spamming other players with the rename message
+                if (oldPartyName.equalsIgnoreCase(newPartyName)) {
+                    sender.sendMessage(LocaleLoader.getString("Party.Rename.Same"));
+                    return true;
+                }
+
+                Player player = mcMMOPlayer.getPlayer();
+
+                // Check to see if the party exists, and if it does cancel renaming the party
+                if (PartyManager.checkPartyExistence(player, newPartyName)) {
+                    return true;
+                }
+
+                String leaderName = playerParty.getLeader().getPlayerName();
+
+                for (Player member : playerParty.getOnlineMembers()) {
+                    if (!PartyManager.handlePartyChangeEvent(member, oldPartyName, newPartyName, EventReason.CHANGED_PARTIES)) {
+                        return true;
+                    }
+
+                    if (!member.getName().equalsIgnoreCase(leaderName)) {
+                        member.sendMessage(LocaleLoader.getString("Party.InformedOnNameChange", leaderName, newPartyName));
+                    }
+                }
+
+                playerParty.setName(newPartyName);
+
+                sender.sendMessage(LocaleLoader.getString("Commands.Party.Rename", newPartyName));
+                return true;
+
+            default:
+                sender.sendMessage(LocaleLoader.getString("Commands.Usage.2", "party", "rename", "<" + LocaleLoader.getString("Commands.Usage.PartyName") + ">"));
+                return true;
+        }
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/party/PartySubcommandType.java

@@ -0,0 +1,52 @@
+package com.gmail.nossr50.commands.party;
+
+public enum PartySubcommandType {
+    JOIN,
+    ACCEPT,
+    CREATE,
+    HELP,
+    INFO,
+    QUIT,
+    XPSHARE,
+    ITEMSHARE,
+    INVITE,
+    KICK,
+    DISBAND,
+    OWNER,
+    LOCK,
+    UNLOCK,
+    PASSWORD,
+    RENAME,
+    TELEPORT,
+    CHAT,
+    ALLIANCE;
+
+    public static PartySubcommandType getSubcommand(String commandName) {
+        for (PartySubcommandType command : values()) {
+            if (command.name().equalsIgnoreCase(commandName)) {
+                return command;
+            }
+        }
+
+        if (commandName.equalsIgnoreCase("?")) {
+            return HELP;
+        }
+        else if (commandName.equalsIgnoreCase("q") || commandName.equalsIgnoreCase("leave")) {
+            return QUIT;
+        }
+        else if (commandName.equalsIgnoreCase("leader")) {
+            return OWNER;
+        }
+        else if (commandName.equalsIgnoreCase("xpshare") || commandName.equalsIgnoreCase("shareexp") || commandName.equalsIgnoreCase("sharexp")) {
+            return XPSHARE;
+        }
+        else if (commandName.equalsIgnoreCase("shareitem") || commandName.equalsIgnoreCase("shareitems")) {
+            return ITEMSHARE;
+        }
+        else if (commandName.equalsIgnoreCase("ally")) {
+            return ALLIANCE;
+        }
+
+        return null;
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/party/PartyXpShareCommand.java

@@ -0,0 +1,55 @@
+package com.gmail.nossr50.commands.party;
+
+import com.gmail.nossr50.config.Config;
+import com.gmail.nossr50.datatypes.party.Party;
+import com.gmail.nossr50.datatypes.party.PartyFeature;
+import com.gmail.nossr50.datatypes.party.ShareMode;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.util.StringUtils;
+import com.gmail.nossr50.util.commands.CommandUtils;
+import com.gmail.nossr50.util.player.UserManager;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class PartyXpShareCommand implements CommandExecutor {
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        Party party = UserManager.getPlayer((Player) sender).getParty();
+
+        if (party.getLevel() < Config.getInstance().getPartyFeatureUnlockLevel(PartyFeature.XP_SHARE)) {
+            sender.sendMessage(LocaleLoader.getString("Party.Feature.Disabled.5"));
+            return true;
+        }
+
+        switch (args.length) {
+            case 2:
+                if (args[1].equalsIgnoreCase("none") || CommandUtils.shouldDisableToggle(args[1])) {
+                    handleChangingShareMode(party, ShareMode.NONE);
+                }
+                else if (args[1].equalsIgnoreCase("equal") || args[1].equalsIgnoreCase("even") || CommandUtils.shouldEnableToggle(args[1])) {
+                    handleChangingShareMode(party, ShareMode.EQUAL);
+                }
+                else {
+                    sender.sendMessage(LocaleLoader.getString("Commands.Usage.2", "party", "xpshare", "<NONE | EQUAL>"));
+                }
+
+                return true;
+
+            default:
+                sender.sendMessage(LocaleLoader.getString("Commands.Usage.2", "party", "xpshare", "<NONE | EQUAL>"));
+                return true;
+        }
+    }
+
+    private void handleChangingShareMode(Party party, ShareMode mode) {
+        party.setXpShareMode(mode);
+
+        String changeModeMessage = LocaleLoader.getString("Commands.Party.SetSharing", LocaleLoader.getString("Party.ShareType.Xp"), LocaleLoader.getString("Party.ShareMode." + StringUtils.getCapitalized(mode.toString())));
+
+        for (Player member : party.getOnlineMembers()) {
+            member.sendMessage(changeModeMessage);
+        }
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/party/alliance/PartyAllianceAcceptCommand.java

@@ -0,0 +1,38 @@
+package com.gmail.nossr50.commands.party.alliance;
+
+import com.gmail.nossr50.datatypes.player.McMMOPlayer;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.party.PartyManager;
+import com.gmail.nossr50.util.player.UserManager;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class PartyAllianceAcceptCommand implements CommandExecutor {
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        switch (args.length) {
+            case 2:
+                Player player = (Player) sender;
+                McMMOPlayer mcMMOPlayer = UserManager.getPlayer(player);
+
+                if (!mcMMOPlayer.hasPartyAllianceInvite()) {
+                    sender.sendMessage(LocaleLoader.getString("mcMMO.NoInvites"));
+                    return true;
+                }
+
+                if (mcMMOPlayer.getParty().getAlly() != null) {
+                    player.sendMessage(LocaleLoader.getString("Commands.Party.Alliance.AlreadyAllies"));
+                    return true;
+                }
+
+                PartyManager.acceptAllianceInvite(mcMMOPlayer);
+                return true;
+
+            default:
+                sender.sendMessage(LocaleLoader.getString("Commands.Usage.2", "party", "alliance", "accept"));
+                return true;
+        }
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/party/alliance/PartyAllianceCommand.java

@@ -0,0 +1,133 @@
+package com.gmail.nossr50.commands.party.alliance;
+
+import com.gmail.nossr50.config.Config;
+import com.gmail.nossr50.datatypes.party.Party;
+import com.gmail.nossr50.datatypes.party.PartyFeature;
+import com.gmail.nossr50.datatypes.player.McMMOPlayer;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.party.PartyManager;
+import com.gmail.nossr50.util.commands.CommandUtils;
+import com.gmail.nossr50.util.player.UserManager;
+import com.google.common.collect.ImmutableList;
+import org.bukkit.ChatColor;
+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 java.util.ArrayList;
+import java.util.List;
+
+public class PartyAllianceCommand implements TabExecutor {
+    private Player player;
+    private Party playerParty;
+    private Party targetParty;
+
+    public static final List<String> ALLIANCE_SUBCOMMANDS = ImmutableList.of("invite", "accept", "disband");
+
+    private CommandExecutor partyAllianceInviteCommand = new PartyAllianceInviteCommand();
+    private CommandExecutor partyAllianceAcceptCommand = new PartyAllianceAcceptCommand();
+    private CommandExecutor partyAllianceDisbandCommand = new PartyAllianceDisbandCommand();
+
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        if (CommandUtils.noConsoleUsage(sender)) {
+            return true;
+        }
+
+        player = (Player) sender;
+        McMMOPlayer mcMMOPlayer = UserManager.getPlayer(player);
+
+        playerParty = mcMMOPlayer.getParty();
+
+        switch (args.length) {
+            case 1:
+                if (playerParty.getLevel() < Config.getInstance().getPartyFeatureUnlockLevel(PartyFeature.ALLIANCE)) {
+                    sender.sendMessage(LocaleLoader.getString("Party.Feature.Disabled.3"));
+                    return true;
+                }
+
+                if (playerParty.getAlly() == null) {
+                    printUsage();
+                    return true;
+                }
+
+                targetParty = playerParty.getAlly();
+
+                displayPartyHeader();
+                displayMemberInfo(mcMMOPlayer);
+                return true;
+
+            case 2:
+            case 3:
+                if (playerParty.getLevel() < Config.getInstance().getPartyFeatureUnlockLevel(PartyFeature.ALLIANCE)) {
+                    sender.sendMessage(LocaleLoader.getString("Party.Feature.Disabled.3"));
+                    return true;
+                }
+
+                if (args[1].equalsIgnoreCase("invite")) {
+                    return partyAllianceInviteCommand.onCommand(sender, command, label, args);
+                }
+
+                if (args[1].equalsIgnoreCase("accept")) {
+                    return partyAllianceAcceptCommand.onCommand(sender, command, label, args);
+                }
+
+                if (args[1].equalsIgnoreCase("disband")) {
+                    return partyAllianceDisbandCommand.onCommand(sender, command, label, args);
+                }
+
+                if (playerParty.getAlly() == null) {
+                    printUsage();
+                    return true;
+                }
+
+                targetParty = playerParty.getAlly();
+
+                displayPartyHeader();
+                displayMemberInfo(mcMMOPlayer);
+                return true;
+
+            default:
+                return false;
+        }
+    }
+
+    private boolean printUsage() {
+        player.sendMessage(LocaleLoader.getString("Commands.Party.Alliance.Help.0"));
+        player.sendMessage(LocaleLoader.getString("Commands.Party.Alliance.Help.1"));
+        return true;
+    }
+
+    @Override
+    public List<String> onTabComplete(CommandSender commandSender, Command command, String label, String[] args) {
+        switch (args.length) {
+            case 1:
+                List<String> matches = StringUtil.copyPartialMatches(args[0], ALLIANCE_SUBCOMMANDS, new ArrayList<String>(ALLIANCE_SUBCOMMANDS.size()));
+
+                if (matches.size() == 0) {
+                    List<String> playerNames = CommandUtils.getOnlinePlayerNames(commandSender);
+                    return StringUtil.copyPartialMatches(args[0], playerNames, new ArrayList<String>(playerNames.size()));
+                }
+
+                return matches;
+            default:
+                return ImmutableList.of();
+        }
+    }
+
+    private void displayPartyHeader() {
+        player.sendMessage(LocaleLoader.getString("Commands.Party.Alliance.Header"));
+        player.sendMessage(LocaleLoader.getString("Commands.Party.Alliance.Ally", playerParty.getName(), targetParty.getName()));
+    }
+
+    private void displayMemberInfo(McMMOPlayer mcMMOPlayer) {
+        List<Player> nearMembers = PartyManager.getNearMembers(mcMMOPlayer);
+        player.sendMessage(LocaleLoader.getString("Commands.Party.Alliance.Members.Header"));
+        player.sendMessage(playerParty.createMembersList(player));
+        player.sendMessage(ChatColor.DARK_GRAY + "----------------------------");
+        player.sendMessage(targetParty.createMembersList(player));
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/party/alliance/PartyAllianceDisbandCommand.java

@@ -0,0 +1,35 @@
+package com.gmail.nossr50.commands.party.alliance;
+
+import com.gmail.nossr50.datatypes.party.Party;
+import com.gmail.nossr50.datatypes.player.McMMOPlayer;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.party.PartyManager;
+import com.gmail.nossr50.util.player.UserManager;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class PartyAllianceDisbandCommand implements CommandExecutor {
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        switch (args.length) {
+            case 2:
+                Player player = (Player) sender;
+                McMMOPlayer mcMMOPlayer = UserManager.getPlayer(player);
+                Party party = mcMMOPlayer.getParty();
+
+                if (party.getAlly() == null) {
+                    sender.sendMessage(LocaleLoader.getString("Commands.Party.Alliance.None"));
+                    return true;
+                }
+
+                PartyManager.disbandAlliance(player, party, party.getAlly());
+                return true;
+
+            default:
+                sender.sendMessage(LocaleLoader.getString("Commands.Usage.2", "party", "alliance", "disband"));
+                return true;
+        }
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/party/alliance/PartyAllianceInviteCommand.java

@@ -0,0 +1,70 @@
+package com.gmail.nossr50.commands.party.alliance;
+
+import com.gmail.nossr50.datatypes.party.Party;
+import com.gmail.nossr50.datatypes.player.McMMOPlayer;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.party.PartyManager;
+import com.gmail.nossr50.util.commands.CommandUtils;
+import com.gmail.nossr50.util.player.UserManager;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class PartyAllianceInviteCommand implements CommandExecutor {
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        switch (args.length) {
+            case 3:
+                String targetName = CommandUtils.getMatchedPlayerName(args[2]);
+                McMMOPlayer mcMMOTarget = UserManager.getOfflinePlayer(targetName);
+
+                if (!CommandUtils.checkPlayerExistence(sender, targetName, mcMMOTarget)) {
+                    return false;
+                }
+
+                Player target = mcMMOTarget.getPlayer();
+                Player player = (Player) sender;
+                McMMOPlayer mcMMOPlayer = UserManager.getPlayer(player);
+                String playerName = player.getName();
+
+                if (player.equals(target)) {
+                    sender.sendMessage(LocaleLoader.getString("Party.Invite.Self"));
+                    return true;
+                }
+
+                if (!mcMMOTarget.inParty()) {
+                    player.sendMessage(LocaleLoader.getString("Party.PlayerNotInParty", targetName));
+                    return true;
+                }
+
+                if (PartyManager.inSameParty(player, target)) {
+                    sender.sendMessage(LocaleLoader.getString("Party.Player.InSameParty", targetName));
+                    return true;
+                }
+
+                if (!mcMMOTarget.getParty().getLeader().getUniqueId().equals(target.getUniqueId())) {
+                    player.sendMessage(LocaleLoader.getString("Party.Target.NotOwner", targetName));
+                    return true;
+                }
+
+                Party playerParty = mcMMOPlayer.getParty();
+
+                if (playerParty.getAlly() != null) {
+                    player.sendMessage(LocaleLoader.getString("Commands.Party.Alliance.AlreadyAllies"));
+                    return true;
+                }
+
+                mcMMOTarget.setPartyAllianceInvite(playerParty);
+
+                sender.sendMessage(LocaleLoader.getString("Commands.Invite.Success"));
+                target.sendMessage(LocaleLoader.getString("Commands.Party.Alliance.Invite.0", playerParty.getName(), playerName));
+                target.sendMessage(LocaleLoader.getString("Commands.Party.Alliance.Invite.1"));
+                return true;
+
+            default:
+                sender.sendMessage(LocaleLoader.getString("Commands.Usage.3", "party", "alliance", "invite", "<" + LocaleLoader.getString("Commands.Usage.Player") + ">"));
+                return true;
+        }
+    }
+}

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

@@ -0,0 +1,31 @@
+package com.gmail.nossr50.commands.party.teleport;
+
+import com.gmail.nossr50.datatypes.party.PartyTeleportRecord;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.util.Permissions;
+import com.gmail.nossr50.util.player.UserManager;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+
+public class PtpAcceptAnyCommand implements CommandExecutor {
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        if (!Permissions.partyTeleportAcceptAll(sender)) {
+            sender.sendMessage(command.getPermissionMessage());
+            return true;
+        }
+
+        PartyTeleportRecord ptpRecord = UserManager.getPlayer(sender.getName()).getPartyTeleportRecord();
+
+        if (ptpRecord.isConfirmRequired()) {
+            sender.sendMessage(LocaleLoader.getString("Commands.ptp.AcceptAny.Disabled"));
+        }
+        else {
+            sender.sendMessage(LocaleLoader.getString("Commands.ptp.AcceptAny.Enabled"));
+        }
+
+        ptpRecord.toggleConfirmRequired();
+        return true;
+    }
+}

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

@@ -0,0 +1,63 @@
+package com.gmail.nossr50.commands.party.teleport;
+
+import com.gmail.nossr50.config.Config;
+import com.gmail.nossr50.datatypes.party.PartyTeleportRecord;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.util.Permissions;
+import com.gmail.nossr50.util.player.UserManager;
+import com.gmail.nossr50.util.skills.SkillUtils;
+import org.bukkit.World;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class PtpAcceptCommand implements CommandExecutor {
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        if (!Permissions.partyTeleportAccept(sender)) {
+            sender.sendMessage(command.getPermissionMessage());
+            return true;
+        }
+
+        Player player = (Player) sender;
+        PartyTeleportRecord ptpRecord = UserManager.getPlayer(player).getPartyTeleportRecord();
+
+        if (!ptpRecord.hasRequest()) {
+            player.sendMessage(LocaleLoader.getString("Commands.ptp.NoRequests"));
+            return true;
+        }
+
+        if (SkillUtils.cooldownExpired(ptpRecord.getTimeout(), Config.getInstance().getPTPCommandTimeout())) {
+            ptpRecord.removeRequest();
+            player.sendMessage(LocaleLoader.getString("Commands.ptp.RequestExpired"));
+            return true;
+        }
+
+        Player target = ptpRecord.getRequestor();
+        ptpRecord.removeRequest();
+
+        if (!PtpCommand.canTeleport(sender, player, target.getName())) {
+            return true;
+        }
+
+        if (Config.getInstance().getPTPCommandWorldPermissions()) {
+            World targetWorld = target.getWorld();
+            World playerWorld = player.getWorld();
+
+            if (!Permissions.partyTeleportAllWorlds(target)) {
+                if (!Permissions.partyTeleportWorld(target, targetWorld)) {
+                    target.sendMessage(LocaleLoader.getString("Commands.ptp.NoWorldPermissions", targetWorld.getName()));
+                    return true;
+                }
+                else if (targetWorld != playerWorld && !Permissions.partyTeleportWorld(target, playerWorld)) {
+                    target.sendMessage(LocaleLoader.getString("Commands.ptp.NoWorldPermissions", playerWorld.getName()));
+                    return true;
+                }
+            }
+        }
+
+        PtpCommand.handleTeleportWarmup(target, player);
+        return true;
+    }
+}

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

@@ -0,0 +1,223 @@
+package com.gmail.nossr50.commands.party.teleport;
+
+import com.gmail.nossr50.config.Config;
+import com.gmail.nossr50.config.WorldBlacklist;
+import com.gmail.nossr50.datatypes.party.Party;
+import com.gmail.nossr50.datatypes.party.PartyFeature;
+import com.gmail.nossr50.datatypes.party.PartyTeleportRecord;
+import com.gmail.nossr50.datatypes.player.McMMOPlayer;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.mcMMO;
+import com.gmail.nossr50.party.PartyManager;
+import com.gmail.nossr50.runnables.items.TeleportationWarmup;
+import com.gmail.nossr50.util.EventUtils;
+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.gmail.nossr50.worldguard.WorldGuardManager;
+import com.gmail.nossr50.worldguard.WorldGuardUtils;
+import com.google.common.collect.ImmutableList;
+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 java.util.ArrayList;
+import java.util.List;
+
+public class PtpCommand implements TabExecutor {
+    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();
+
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        if (CommandUtils.noConsoleUsage(sender)) {
+            return true;
+        }
+
+        Player player = (Player) sender;
+
+        /* WORLD GUARD MAIN FLAG CHECK */
+        if(WorldGuardUtils.isWorldGuardLoaded())
+        {
+            if(!WorldGuardManager.getInstance().hasMainFlag(player))
+                return true;
+        }
+
+        /* WORLD BLACKLIST CHECK */
+        if(WorldBlacklist.isWorldBlacklisted(player.getWorld()))
+            return true;
+
+        if (!UserManager.hasPlayerDataKey(player)) {
+            return true;
+        }
+
+        McMMOPlayer mcMMOPlayer = UserManager.getPlayer(player);
+
+        if (!mcMMOPlayer.inParty()) {
+            sender.sendMessage(LocaleLoader.getString("Commands.Party.None"));
+            return true;
+        }
+
+        Party party = mcMMOPlayer.getParty();
+
+        if (party.getLevel() < Config.getInstance().getPartyFeatureUnlockLevel(PartyFeature.TELEPORT)) {
+            sender.sendMessage(LocaleLoader.getString("Party.Feature.Disabled.2"));
+            return true;
+        }
+
+        switch (args.length) {
+            case 1:
+                if (args[0].equalsIgnoreCase("toggle")) {
+                    return ptpToggleCommand.onCommand(sender, command, label, args);
+                }
+
+                if (args[0].equalsIgnoreCase("acceptany") || args[0].equalsIgnoreCase("acceptall")) {
+                    return ptpAcceptAnyCommand.onCommand(sender, command, label, args);
+                }
+
+                long recentlyHurt = mcMMOPlayer.getRecentlyHurt();
+                int hurtCooldown = Config.getInstance().getPTPCommandRecentlyHurtCooldown();
+
+                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 ptpLastUse = mcMMOPlayer.getPartyTeleportRecord().getLastUse();
+
+                if (ptpCooldown > 0) {
+                    int timeRemaining = SkillUtils.calculateTimeLeft(ptpLastUse * Misc.TIME_CONVERSION_FACTOR, ptpCooldown, player);
+
+                    if (timeRemaining > 0) {
+                        player.sendMessage(LocaleLoader.getString("Item.Generic.Wait", timeRemaining));
+                        return true;
+                    }
+                }
+
+                sendTeleportRequest(sender, player, CommandUtils.getMatchedPlayerName(args[0]));
+                return true;
+
+            default:
+                return false;
+        }
+    }
+
+    @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) {
+                    Player player = (Player) sender;
+                    McMMOPlayer mcMMOPlayer = UserManager.getPlayer(player);
+
+                    if (!mcMMOPlayer.inParty()) {
+                        return ImmutableList.of();
+                    }
+
+                    List<String> playerNames = mcMMOPlayer.getParty().getOnlinePlayerNames(player);
+                    return StringUtil.copyPartialMatches(args[0], playerNames, new ArrayList<String>(playerNames.size()));
+                }
+
+                return matches;
+            default:
+                return ImmutableList.of();
+        }
+    }
+
+    private void sendTeleportRequest(CommandSender sender, Player player, String targetName) {
+        if (!canTeleport(sender, player, targetName)) {
+            return;
+        }
+
+        McMMOPlayer mcMMOTarget = UserManager.getPlayer(targetName);
+        Player target = mcMMOTarget.getPlayer();
+
+        PartyTeleportRecord ptpRecord = mcMMOTarget.getPartyTeleportRecord();
+
+        if (!ptpRecord.isConfirmRequired()) {
+            handleTeleportWarmup(player, target);
+            return;
+        }
+
+        ptpRecord.setRequestor(player);
+        ptpRecord.actualizeTimeout();
+
+        player.sendMessage(LocaleLoader.getString("Commands.Invite.Success"));
+
+        target.sendMessage(LocaleLoader.getString("Commands.ptp.Request1", player.getName()));
+        target.sendMessage(LocaleLoader.getString("Commands.ptp.Request2", Config.getInstance().getPTPCommandTimeout()));
+    }
+
+    protected static boolean canTeleport(CommandSender sender, Player player, String targetName) {
+        McMMOPlayer mcMMOTarget = UserManager.getPlayer(targetName);
+
+        if (!CommandUtils.checkPlayerExistence(sender, targetName, mcMMOTarget)) {
+            return false;
+        }
+
+        Player target = mcMMOTarget.getPlayer();
+
+        if (player.equals(target)) {
+            player.sendMessage(LocaleLoader.getString("Party.Teleport.Self"));
+            return false;
+        }
+
+        if (!PartyManager.inSameParty(player, target)) {
+            player.sendMessage(LocaleLoader.getString("Party.NotInYourParty", targetName));
+            return false;
+        }
+
+        if (!mcMMOTarget.getPartyTeleportRecord().isEnabled()) {
+            player.sendMessage(LocaleLoader.getString("Party.Teleport.Disabled", targetName));
+            return false;
+        }
+
+        if (!target.isValid()) {
+            player.sendMessage(LocaleLoader.getString("Party.Teleport.Dead"));
+            return false;
+        }
+
+        return true;
+    }
+
+    protected static void handleTeleportWarmup(Player teleportingPlayer, Player targetPlayer) {
+        McMMOPlayer mcMMOPlayer = UserManager.getPlayer(teleportingPlayer);
+        McMMOPlayer 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 {
+            EventUtils.handlePartyTeleportEvent(teleportingPlayer, targetPlayer);
+        }
+    }
+}

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

@@ -0,0 +1,31 @@
+package com.gmail.nossr50.commands.party.teleport;
+
+import com.gmail.nossr50.datatypes.party.PartyTeleportRecord;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.util.Permissions;
+import com.gmail.nossr50.util.player.UserManager;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+
+public class PtpToggleCommand implements CommandExecutor {
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        if (!Permissions.partyTeleportToggle(sender)) {
+            sender.sendMessage(command.getPermissionMessage());
+            return true;
+        }
+
+        PartyTeleportRecord ptpRecord = UserManager.getPlayer(sender.getName()).getPartyTeleportRecord();
+
+        if (ptpRecord.isEnabled()) {
+            sender.sendMessage(LocaleLoader.getString("Commands.ptp.Disabled"));
+        }
+        else {
+            sender.sendMessage(LocaleLoader.getString("Commands.ptp.Enabled"));
+        }
+
+        ptpRecord.toggleEnabled();
+        return true;
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/player/InspectCommand.java

@@ -0,0 +1,114 @@
+package com.gmail.nossr50.commands.player;
+
+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.PrimarySkillType;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.mcMMO;
+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;
+import com.google.common.collect.ImmutableList;
+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 java.util.ArrayList;
+import java.util.List;
+
+public class InspectCommand implements TabExecutor {
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        switch (args.length) {
+            case 1:
+                String playerName = CommandUtils.getMatchedPlayerName(args[0]);
+                McMMOPlayer mcMMOPlayer = UserManager.getOfflinePlayer(playerName);
+
+                // 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) {
+                    PlayerProfile profile = mcMMO.getDatabaseManager().loadPlayerProfile(playerName, false); // Temporary Profile
+
+                    if (!CommandUtils.isLoaded(sender, profile)) {
+                        return true;
+                    }
+
+                    if (CommandUtils.inspectOffline(sender, profile, Permissions.inspectOffline(sender))) {
+                        return true;
+                    }
+
+                    if (Config.getInstance().getScoreboardsEnabled() && sender instanceof Player && Config.getInstance().getInspectUseBoard()) {
+                        ScoreboardManager.enablePlayerInspectScoreboard((Player) sender, profile);
+
+                        if (!Config.getInstance().getInspectUseChat()) {
+                            return true;
+                        }
+                    }
+
+                    sender.sendMessage(LocaleLoader.getString("Inspect.OfflineStats", playerName));
+
+                    sender.sendMessage(LocaleLoader.getString("Stats.Header.Gathering"));
+                    for (PrimarySkillType skill : PrimarySkillType.GATHERING_SKILLS) {
+                        sender.sendMessage(CommandUtils.displaySkill(profile, skill));
+                    }
+
+                    sender.sendMessage(LocaleLoader.getString("Stats.Header.Combat"));
+                    for (PrimarySkillType skill : PrimarySkillType.COMBAT_SKILLS) {
+                        sender.sendMessage(CommandUtils.displaySkill(profile, skill));
+                    }
+
+                    sender.sendMessage(LocaleLoader.getString("Stats.Header.Misc"));
+                    for (PrimarySkillType skill : PrimarySkillType.MISC_SKILLS) {
+                        sender.sendMessage(CommandUtils.displaySkill(profile, skill));
+                    }
+
+                }
+                else {
+                    Player target = mcMMOPlayer.getPlayer();
+
+                    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 (Config.getInstance().getScoreboardsEnabled() && sender instanceof Player && Config.getInstance().getInspectUseBoard()) {
+                        ScoreboardManager.enablePlayerInspectScoreboard((Player) sender, mcMMOPlayer.getProfile());
+
+                        if (!Config.getInstance().getInspectUseChat()) {
+                            return true;
+                        }
+                    }
+
+                    sender.sendMessage(LocaleLoader.getString("Inspect.Stats", target.getName()));
+                    CommandUtils.printGatheringSkills(target, sender);
+                    CommandUtils.printCombatSkills(target, sender);
+                    CommandUtils.printMiscSkills(target, sender);
+                    sender.sendMessage(LocaleLoader.getString("Commands.PowerLevel", mcMMOPlayer.getPowerLevel()));
+                }
+
+                return true;
+
+            default:
+                return false;
+        }
+    }
+
+    @Override
+    public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) {
+        switch (args.length) {
+            case 1:
+                List<String> playerNames = CommandUtils.getOnlinePlayerNames(sender);
+                return StringUtil.copyPartialMatches(args[0], playerNames, new ArrayList<String>(playerNames.size()));
+            default:
+                return ImmutableList.of();
+        }
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/player/MccooldownCommand.java

@@ -0,0 +1,72 @@
+package com.gmail.nossr50.commands.player;
+
+import com.gmail.nossr50.config.Config;
+import com.gmail.nossr50.datatypes.player.McMMOPlayer;
+import com.gmail.nossr50.datatypes.skills.SuperAbilityType;
+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;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
+import org.bukkit.entity.Player;
+
+import java.util.List;
+
+public class MccooldownCommand implements TabExecutor {
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        if (CommandUtils.noConsoleUsage(sender)) {
+            return true;
+        }
+
+        if (!CommandUtils.hasPlayerDataKey(sender)) {
+            return true;
+        }
+
+        switch (args.length) {
+            case 0:
+                Player player = (Player) sender;
+
+                if (Config.getInstance().getScoreboardsEnabled() && Config.getInstance().getCooldownUseBoard()) {
+                    ScoreboardManager.enablePlayerCooldownScoreboard(player);
+
+                    if (!Config.getInstance().getCooldownUseChat()) {
+                        return true;
+                    }
+                }
+
+                McMMOPlayer mcMMOPlayer = UserManager.getPlayer(player);
+
+                player.sendMessage(LocaleLoader.getString("Commands.Cooldowns.Header"));
+                player.sendMessage(LocaleLoader.getString("mcMMO.NoSkillNote"));
+
+                for (SuperAbilityType ability : SuperAbilityType.values()) {
+                    if (!ability.getPermissions(player)) {
+                        continue;
+                    }
+
+                    int seconds = mcMMOPlayer.calculateTimeRemaining(ability);
+
+                    if (seconds <= 0) {
+                        player.sendMessage(LocaleLoader.getString("Commands.Cooldowns.Row.Y", ability.getName()));
+                    }
+                    else {
+                        player.sendMessage(LocaleLoader.getString("Commands.Cooldowns.Row.N", ability.getName(), seconds));
+                    }
+                }
+
+                return true;
+
+            default:
+                return false;
+        }
+    }
+
+    @Override
+    public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) {
+        return ImmutableList.of();
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/player/McrankCommand.java

@@ -0,0 +1,113 @@
+package com.gmail.nossr50.commands.player;
+
+import com.gmail.nossr50.config.Config;
+import com.gmail.nossr50.datatypes.player.McMMOPlayer;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.mcMMO;
+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.google.common.collect.ImmutableList;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
+import org.bukkit.entity.Player;
+import org.bukkit.metadata.FixedMetadataValue;
+import org.bukkit.util.StringUtil;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class McrankCommand 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.mcrank(sender)) {
+                    sender.sendMessage(command.getPermissionMessage());
+                    return true;
+                }
+
+                if (!CommandUtils.hasPlayerDataKey(sender)) {
+                    return true;
+                }
+
+                display(sender, sender.getName());
+
+                return true;
+
+            case 1:
+                if (!Permissions.mcrankOthers(sender)) {
+                    sender.sendMessage(command.getPermissionMessage());
+                    return true;
+                }
+
+                if (!CommandUtils.hasPlayerDataKey(sender)) {
+                    return true;
+                }
+
+                String playerName = CommandUtils.getMatchedPlayerName(args[0]);
+                McMMOPlayer mcMMOPlayer = UserManager.getOfflinePlayer(playerName);
+
+                if (mcMMOPlayer != null) {
+                    Player player = mcMMOPlayer.getPlayer();
+                    playerName = player.getName();
+
+                    if (CommandUtils.tooFar(sender, player, Permissions.mcrankFar(sender))) {
+                        return true;
+                    }
+                }
+                else if (CommandUtils.inspectOffline(sender, mcMMO.getDatabaseManager().loadPlayerProfile(playerName, false), Permissions.mcrankOffline(sender))) {
+                    return true;
+                }
+
+                display(sender, playerName);
+                return true;
+
+            default:
+                return false;
+        }
+    }
+
+    @Override
+    public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) {
+        switch (args.length) {
+            case 1:
+                List<String> playerNames = CommandUtils.getOnlinePlayerNames(sender);
+                return StringUtil.copyPartialMatches(args[0], playerNames, new ArrayList<String>(playerNames.size()));
+            default:
+                return ImmutableList.of();
+        }
+    }
+
+    private void display(CommandSender sender, String playerName) {
+        if (sender instanceof Player) {
+            McMMOPlayer mcMMOPlayer = UserManager.getPlayer(sender.getName());
+            long cooldownMillis = Math.max(Config.getInstance().getDatabasePlayerCooldown(), 1750);
+
+            if (mcMMOPlayer.getDatabaseATS() + cooldownMillis > System.currentTimeMillis()) {
+                sender.sendMessage(LocaleLoader.getString("Commands.Database.Cooldown"));
+                return;
+            }
+
+            if (((Player) sender).hasMetadata(mcMMO.databaseCommandKey)) {
+                sender.sendMessage(LocaleLoader.getString("Commands.Database.Processing"));
+                return;
+            } else {
+                ((Player) sender).setMetadata(mcMMO.databaseCommandKey, new FixedMetadataValue(mcMMO.p, null));
+            }
+
+            mcMMOPlayer.actualizeDatabaseATS();
+        }
+
+        boolean useBoard = Config.getInstance().getScoreboardsEnabled() && (sender instanceof Player) && (Config.getInstance().getRankUseBoard());
+        boolean useChat = !useBoard || Config.getInstance().getRankUseChat();
+
+        new McrankCommandAsyncTask(playerName, sender, useBoard, useChat).runTaskAsynchronously(mcMMO.p);
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/player/McstatsCommand.java

@@ -0,0 +1,66 @@
+package com.gmail.nossr50.commands.player;
+
+import com.gmail.nossr50.config.Config;
+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;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
+import org.bukkit.entity.Player;
+
+import java.util.List;
+
+public class McstatsCommand implements TabExecutor {
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        if (CommandUtils.noConsoleUsage(sender)) {
+            return true;
+        }
+
+        if (!CommandUtils.hasPlayerDataKey(sender)) {
+            return true;
+        }
+
+        switch (args.length) {
+            case 0:
+                Player player = (Player) sender;
+
+                if (Config.getInstance().getStatsUseBoard() && Config.getInstance().getScoreboardsEnabled()) {
+                    ScoreboardManager.enablePlayerStatsScoreboard(player);
+
+                    if (!Config.getInstance().getStatsUseChat()) {
+                        return true;
+                    }
+                }
+
+                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;
+
+            default:
+                return false;
+        }
+    }
+
+    @Override
+    public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) {
+        return ImmutableList.of();
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/player/MctopCommand.java

@@ -0,0 +1,135 @@
+package com.gmail.nossr50.commands.player;
+
+import com.gmail.nossr50.config.Config;
+import com.gmail.nossr50.datatypes.player.McMMOPlayer;
+import com.gmail.nossr50.datatypes.skills.PrimarySkillType;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.mcMMO;
+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.player.UserManager;
+import com.google.common.collect.ImmutableList;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
+import org.bukkit.entity.Player;
+import org.bukkit.metadata.FixedMetadataValue;
+import org.bukkit.util.StringUtil;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class MctopCommand implements TabExecutor {
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        PrimarySkillType skill = null;
+
+        switch (args.length) {
+            case 0:
+                display(1, skill, sender, command);
+                return true;
+
+            case 1:
+                if (StringUtils.isInt(args[0])) {
+                    display(Math.abs(Integer.parseInt(args[0])), skill, sender, command);
+                    return true;
+                }
+
+                skill = extractSkill(sender, args[0]);
+
+                if (skill == null) {
+                    return true;
+                }
+
+                display(1, skill, sender, command);
+                return true;
+
+            case 2:
+                if (CommandUtils.isInvalidInteger(sender, args[1])) {
+                    return true;
+                }
+
+                skill = extractSkill(sender, args[0]);
+
+                if (skill == null) {
+                    return true;
+                }
+
+                display(Math.abs(Integer.parseInt(args[1])), skill, sender, command);
+                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], PrimarySkillType.SKILL_NAMES, new ArrayList<String>(PrimarySkillType.SKILL_NAMES.size()));
+            default:
+                return ImmutableList.of();
+        }
+    }
+
+    private void display(int page, PrimarySkillType skill, CommandSender sender, Command command) {
+        if (skill != null && !Permissions.mctop(sender, skill)) {
+            sender.sendMessage(command.getPermissionMessage());
+            return;
+        }
+
+        if (sender instanceof Player) {
+            if (!CommandUtils.hasPlayerDataKey(sender)) {
+                return;
+            }
+
+            McMMOPlayer mcMMOPlayer = UserManager.getPlayer(sender.getName());
+            long cooldownMillis = Math.max(Config.getInstance().getDatabasePlayerCooldown(), 1750);
+
+            if (mcMMOPlayer.getDatabaseATS() + cooldownMillis > System.currentTimeMillis()) {
+                double seconds = ((mcMMOPlayer.getDatabaseATS() + cooldownMillis) - System.currentTimeMillis()) / 1000;
+                if (seconds < 1) {
+                    seconds = 1;
+                }
+
+                sender.sendMessage(LocaleLoader.formatString(LocaleLoader.getString("Commands.Database.Cooldown"), seconds));
+                return;
+            }
+
+            if (((Player) sender).hasMetadata(mcMMO.databaseCommandKey)) {
+                sender.sendMessage(LocaleLoader.getString("Commands.Database.Processing"));
+                return;
+            } else {
+                ((Player) sender).setMetadata(mcMMO.databaseCommandKey, new FixedMetadataValue(mcMMO.p, null));
+            }
+
+            mcMMOPlayer.actualizeDatabaseATS();
+        }
+
+        display(page, skill, sender);
+    }
+
+    private void display(int page, PrimarySkillType skill, CommandSender sender) {
+        boolean useBoard = (sender instanceof Player) && (Config.getInstance().getTopUseBoard());
+        boolean useChat = !useBoard || Config.getInstance().getTopUseChat();
+
+        new MctopCommandAsyncTask(page, skill, sender, useBoard, useChat).runTaskAsynchronously(mcMMO.p);
+    }
+
+    private PrimarySkillType extractSkill(CommandSender sender, String skillName) {
+        if (CommandUtils.isInvalidSkill(sender, skillName)) {
+            return null;
+        }
+
+        PrimarySkillType skill = PrimarySkillType.getSkill(skillName);
+
+        if (CommandUtils.isChildSkill(sender, skill)) {
+            return null;
+        }
+
+        return skill;
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/server/Mcmmoupgrade.java

@@ -0,0 +1,15 @@
+package com.gmail.nossr50.commands.server;
+
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+
+/**
+ * This command facilitates switching the skill system scale between classic and modern scale
+ */
+public class Mcmmoupgrade implements CommandExecutor {
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        return false;
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/skills/AcrobaticsCommand.java

@@ -0,0 +1,99 @@
+package com.gmail.nossr50.commands.skills;
+
+import com.gmail.nossr50.datatypes.skills.PrimarySkillType;
+import com.gmail.nossr50.datatypes.skills.SubSkillType;
+import com.gmail.nossr50.datatypes.skills.subskills.AbstractSubSkill;
+import com.gmail.nossr50.listeners.InteractionManager;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.util.TextComponentFactory;
+import com.gmail.nossr50.util.random.RandomChanceSkill;
+import com.gmail.nossr50.util.random.RandomChanceUtil;
+import com.gmail.nossr50.util.skills.SkillActivationType;
+import net.md_5.bungee.api.chat.TextComponent;
+import org.bukkit.entity.Player;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class AcrobaticsCommand extends SkillCommand {
+    private String dodgeChance;
+    private String dodgeChanceLucky;
+
+    private boolean canDodge;
+    private boolean canRoll;
+
+    public AcrobaticsCommand() {
+        super(PrimarySkillType.ACROBATICS);
+    }
+
+    @Override
+    protected void dataCalculations(Player player, float skillValue) {
+        // ACROBATICS_DODGE
+        if (canDodge) {
+            String[] dodgeStrings = getAbilityDisplayValues(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, player, SubSkillType.ACROBATICS_DODGE);
+            dodgeChance = dodgeStrings[0];
+            dodgeChanceLucky = dodgeStrings[1];
+        }
+    }
+
+    @Override
+    protected void permissionsCheck(Player player) {
+        canDodge = canUseSubskill(player, SubSkillType.ACROBATICS_DODGE);
+        canRoll = canUseSubskill(player, SubSkillType.ACROBATICS_ROLL);
+    }
+
+    @Override
+    protected List<String> statsDisplay(Player player, float skillValue, boolean hasEndurance, boolean isLucky) {
+        List<String> messages = new ArrayList<String>();
+
+        if (canDodge) {
+            messages.add(getStatMessage(SubSkillType.ACROBATICS_DODGE, dodgeChance)
+                    + (isLucky ? LocaleLoader.getString("Perks.Lucky.Bonus", dodgeChanceLucky) : ""));
+        }
+        
+        if (canRoll) {
+
+            AbstractSubSkill abstractSubSkill = InteractionManager.getAbstractByName("Roll");
+
+            if(abstractSubSkill != null)
+            {
+                double rollChance, graceChance;
+
+                //Chance to roll at half
+                RandomChanceSkill roll_rcs  = new RandomChanceSkill(player, SubSkillType.ACROBATICS_ROLL);
+
+                //Chance to graceful roll
+                RandomChanceSkill grace_rcs = new RandomChanceSkill(player, SubSkillType.ACROBATICS_ROLL);
+                grace_rcs.setSkillLevel(grace_rcs.getSkillLevel() * 2); //Double Odds
+
+                //Chance Stat Calculations
+                rollChance       = RandomChanceUtil.getRandomChanceExecutionChance(roll_rcs);
+                graceChance      = RandomChanceUtil.getRandomChanceExecutionChance(grace_rcs);
+                //damageThreshold  = AdvancedConfig.getInstance().getRollDamageThreshold();
+
+                String rollStrings[] = getAbilityDisplayValues(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, player, SubSkillType.ACROBATICS_ROLL);
+
+                //Format
+                double rollChanceLucky  = rollChance * 1.333D;
+                double graceChanceLucky = graceChance * 1.333D;
+
+                messages.add(getStatMessage(SubSkillType.ACROBATICS_ROLL, rollStrings[0])
+                        + (isLucky ? LocaleLoader.getString("Perks.Lucky.Bonus", rollStrings[1]) : ""));
+
+                /*messages.add(getStatMessage(true, false, SubSkillType.ACROBATICS_ROLL, String.valueOf(graceChance))
+                        + (isLucky ? LocaleLoader.getString("Perks.Lucky.Bonus", String.valueOf(graceChanceLucky)) : ""));*/
+            }
+        }
+
+        return messages;
+    }
+
+    @Override
+    protected List<TextComponent> getTextComponents(Player player) {
+        List<TextComponent> textComponents = new ArrayList<>();
+
+        TextComponentFactory.getSubSkillTextComponents(player, textComponents, PrimarySkillType.ACROBATICS);
+
+        return textComponents;
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/skills/AlchemyCommand.java

@@ -0,0 +1,96 @@
+package com.gmail.nossr50.commands.skills;
+
+import com.gmail.nossr50.datatypes.skills.PrimarySkillType;
+import com.gmail.nossr50.datatypes.skills.SubSkillType;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.skills.alchemy.AlchemyManager;
+import com.gmail.nossr50.util.Permissions;
+import com.gmail.nossr50.util.TextComponentFactory;
+import com.gmail.nossr50.util.player.UserManager;
+import com.gmail.nossr50.util.skills.RankUtils;
+import net.md_5.bungee.api.chat.TextComponent;
+import org.bukkit.entity.Player;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class AlchemyCommand extends SkillCommand {
+    private String brewSpeed;
+    private String brewSpeedLucky;
+
+    private int    tier;
+    private int    ingredientCount;
+    private String ingredientList;
+
+    private boolean canCatalysis;
+    private boolean canConcoctions;
+
+    public AlchemyCommand() {
+        super(PrimarySkillType.ALCHEMY);
+    }
+
+    protected String[] calculateAbilityDisplayValues(Player player) {
+        AlchemyManager alchemyManager = UserManager.getPlayer(player).getAlchemyManager();
+        String[] displayValues = new String[2];
+
+        boolean isLucky = Permissions.lucky(player, PrimarySkillType.ALCHEMY);
+
+        displayValues[0] = decimal.format(alchemyManager.calculateBrewSpeed(false)) + "x";
+        displayValues[1] = isLucky ? decimal.format(alchemyManager.calculateBrewSpeed(true)) + "x" : null;
+
+        return displayValues;
+    }
+
+    @Override
+    protected void dataCalculations(Player player, float skillValue) {
+        // ALCHEMY_CATALYSIS
+        if (canCatalysis) {
+            String[] catalysisStrings = calculateAbilityDisplayValues(player);
+            brewSpeed = catalysisStrings[0];
+            brewSpeedLucky = catalysisStrings[1];
+        }
+
+        // ALCHEMY_CONCOCTIONS
+        if (canConcoctions) {
+            AlchemyManager alchemyManager = UserManager.getPlayer(player).getAlchemyManager();
+            tier = alchemyManager.getTier();
+            ingredientCount = alchemyManager.getIngredients().size();
+            ingredientList = alchemyManager.getIngredientList();
+        }
+    }
+
+    @Override
+    protected void permissionsCheck(Player player) {
+        canCatalysis = canUseSubskill(player, SubSkillType.ALCHEMY_CATALYSIS);
+        canConcoctions = canUseSubskill(player, SubSkillType.ALCHEMY_CONCOCTIONS);
+    }
+
+    @Override
+    protected List<String> statsDisplay(Player player, float skillValue, boolean hasEndurance, boolean isLucky) {
+        List<String> messages = new ArrayList<String>();
+
+        if (canCatalysis) {
+            messages.add(getStatMessage(SubSkillType.ALCHEMY_CATALYSIS, brewSpeed)
+                    + (isLucky ? LocaleLoader.getString("Perks.Lucky.Bonus", brewSpeedLucky) : ""));
+        }
+
+        if (canConcoctions) {
+            messages.add(getStatMessage(false, true, SubSkillType.ALCHEMY_CONCOCTIONS, String.valueOf(tier), String.valueOf(RankUtils.getHighestRank(SubSkillType.ALCHEMY_CONCOCTIONS))));
+            messages.add(getStatMessage(true, true, SubSkillType.ALCHEMY_CONCOCTIONS, String.valueOf(ingredientCount), ingredientList));
+
+            //messages.add(LocaleLoader.getString("Alchemy.Concoctions.Rank", tier, RankUtils.getHighestRank(SubSkillType.ALCHEMY_CONCOCTIONS)));
+            //messages.add(LocaleLoader.getString("Alchemy.Concoctions.Ingredients", ingredientCount, ingredientList));
+        }
+
+        return messages;
+    }
+
+    @Override
+    protected List<TextComponent> getTextComponents(Player player) {
+        List<TextComponent> textComponents = new ArrayList<>();
+
+        TextComponentFactory.getSubSkillTextComponents(player, textComponents, PrimarySkillType.ALCHEMY);
+
+        return textComponents;
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/skills/AprilCommand.java

@@ -0,0 +1,203 @@
+package com.gmail.nossr50.commands.skills;
+
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.util.HolidayManager.FakeSkillType;
+import com.gmail.nossr50.util.Misc;
+import com.gmail.nossr50.util.StringUtils;
+import com.gmail.nossr50.util.commands.CommandUtils;
+import com.google.common.collect.ImmutableList;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
+import org.bukkit.entity.Player;
+
+import java.text.DecimalFormat;
+import java.util.ArrayList;
+import java.util.List;
+
+public class AprilCommand implements TabExecutor {
+    private String skillName;
+
+    protected DecimalFormat percent = new DecimalFormat("##0.00%");
+    protected DecimalFormat decimal = new DecimalFormat("##0.00");
+
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        if (CommandUtils.noConsoleUsage(sender)) {
+            return true;
+        }
+
+        skillName = StringUtils.getCapitalized(label);
+
+        switch (args.length) {
+            case 0:
+                Player player = (Player) sender;
+                FakeSkillType fakeSkillType = FakeSkillType.getByName(skillName);
+
+                float skillValue = Misc.getRandom().nextInt(99);
+
+                player.sendMessage(LocaleLoader.getString("Skills.Header", skillName));
+                player.sendMessage(LocaleLoader.getString("Commands.XPGain", getXPGainString(fakeSkillType)));
+                player.sendMessage(LocaleLoader.getString("Effects.Level", (int) skillValue, Misc.getRandom().nextInt(1000), 1000 + Misc.getRandom().nextInt(1000)));
+
+
+                List<String> effectMessages = effectsDisplay(fakeSkillType);
+
+                if (!effectMessages.isEmpty()) {
+                    player.sendMessage(LocaleLoader.getString("Skills.Header", LocaleLoader.getString("Effects.Effects")));
+
+                    for (String message : effectMessages) {
+                        player.sendMessage(message);
+                    }
+                }
+
+                List<String> statsMessages = statsDisplay(fakeSkillType);
+
+                if (!statsMessages.isEmpty()) {
+                    player.sendMessage(LocaleLoader.getString("Skills.Header", LocaleLoader.getString("Commands.Stats.Self")));
+
+                    for (String message : statsMessages) {
+                        player.sendMessage(message);
+                    }
+                }
+
+                player.sendMessage(LocaleLoader.formatString("[[DARK_AQUA]]Guide for {0} available - type /APRIL FOOLS ! :D", skillName));
+                return true;
+
+            default:
+                return true;
+        }
+    }
+
+    private String getXPGainString(FakeSkillType fakeSkillType) {
+        switch (fakeSkillType) {
+            case MACHO:
+                return "Get beaten up";
+            case JUMPING:
+                return "Kris Kross will make ya Jump Jump";
+            case THROWING:
+                return "Chuck your items on the floor";
+            case WRECKING:
+                return "I'M GONNA WRECK IT!";
+            case CRAFTING:
+                return "Craft apple pies";
+            case WALKING:
+                return "Walk around the park";
+            case SWIMMING:
+                return "Like a fish on a bicycle";
+            case FALLING:
+                return "Faceplant the floor, headbutt the ground";
+            case CLIMBING:
+                return "Climb the highest mountain";
+            case FLYING:
+                return "I believe I can fly";
+            case DIVING:
+                return "Scuba club 4000";
+            case PIGGY:
+                return "OINK! OINK!";
+            default:
+                return "Sit and wait?";
+        }
+    }
+
+    @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();
+        }
+    }
+
+    private List<String> effectsDisplay(FakeSkillType fakeSkillType) {
+        List<String> messages = new ArrayList<String>();
+
+        switch (fakeSkillType) {
+            case MACHO:
+                messages.add(LocaleLoader.getString("Effects.Template", "Punching bag", "Absorb damage, like a bag of sand"));
+                break;
+            case JUMPING:
+                messages.add(LocaleLoader.getString("Effects.Template", "Jump", "PRESS SPACE TO JUMP"));
+                messages.add(LocaleLoader.getString("Effects.Template", "Jump Twice", "PRESS SPACE TWICE TO JUMP TWICE"));
+                break;
+            case THROWING:
+                messages.add(LocaleLoader.getString("Effects.Template", "Drop Item", "Randomly drop items, at random"));
+                break;
+            case WRECKING:
+                messages.add(LocaleLoader.getString("Effects.Template", "Ralphinator", "Smash windows with your fists"));
+                break;
+            case CRAFTING:
+                messages.add(LocaleLoader.getString("Effects.Template", "Crafting", "Chance of successful craft"));
+                break;
+            case WALKING:
+                messages.add(LocaleLoader.getString("Effects.Template", "Walk", "Traveling gracefully by foot"));
+                break;
+            case SWIMMING:
+                messages.add(LocaleLoader.getString("Effects.Template", "Swim", "Just keep swimming, swimming, swimming"));
+                break;
+            case FALLING:
+                messages.add(LocaleLoader.getString("Effects.Template", "Skydiving", "Go jump of a cliff. No, seriously."));
+                break;
+            case CLIMBING:
+                messages.add(LocaleLoader.getString("Effects.Template", "Rock Climber", "Use string to climb mountains faster"));
+                break;
+            case FLYING:
+                messages.add(LocaleLoader.getString("Effects.Template", "Fly", "Throw yourself at the ground and miss"));
+                break;
+            case DIVING:
+                messages.add(LocaleLoader.getString("Effects.Template", "Hold Breath", "Press shift to hold your breath longer"));
+                break;
+            case PIGGY:
+                messages.add(LocaleLoader.getString("Effects.Template", "Carrot Turbo", "Supercharge your pigs with carrots"));
+                break;
+        }
+
+        return messages;
+    }
+
+    private List<String> statsDisplay(FakeSkillType fakeSkillType) {
+        List<String> messages = new ArrayList<String>();
+
+        switch (fakeSkillType) {
+            case MACHO:
+                messages.add(LocaleLoader.formatString("[[RED]]Damage Taken: [[YELLOW]]{0}%", decimal.format(Misc.getRandom().nextInt(77))));
+                break;
+            case JUMPING:
+                messages.add(LocaleLoader.formatString("[[RED]]Double Jump Chance: [[YELLOW]]{0}%", decimal.format(Misc.getRandom().nextInt(27))));
+                break;
+            case THROWING:
+                messages.add(LocaleLoader.formatString("[[RED]]Drop Item Chance: [[YELLOW]]{0}%", decimal.format(Misc.getRandom().nextInt(87))));
+                break;
+            case WRECKING:
+                messages.add(LocaleLoader.formatString("[[RED]]Wrecking Chance: [[YELLOW]]{0}%", decimal.format(Misc.getRandom().nextInt(14))));
+                break;
+            case CRAFTING:
+                messages.add(LocaleLoader.formatString("[[RED]]Crafting Success: [[YELLOW]]{0}%", decimal.format(Misc.getRandom().nextInt(27))));
+                break;
+            case WALKING:
+                messages.add(LocaleLoader.formatString("[[RED]]Walk Chance: [[YELLOW]]{0}%", decimal.format(Misc.getRandom().nextInt(27))));
+                break;
+            case SWIMMING:
+                messages.add(LocaleLoader.formatString("[[RED]]Swim Chance: [[YELLOW]]{0}%", decimal.format(Misc.getRandom().nextInt(27))));
+                break;
+            case FALLING:
+                messages.add(LocaleLoader.formatString("[[RED]]Skydiving Success: [[YELLOW]]{0}%", decimal.format(Misc.getRandom().nextInt(37))));
+                break;
+            case CLIMBING:
+                messages.add(LocaleLoader.formatString("[[RED]]Rock Climber Chance: [[YELLOW]]{0}%", decimal.format(Misc.getRandom().nextInt(27))));
+                break;
+            case FLYING:
+                messages.add(LocaleLoader.formatString("[[RED]]Fly Chance: [[YELLOW]]{0}%", decimal.format(Misc.getRandom().nextInt(27))));
+                break;
+            case DIVING:
+                messages.add(LocaleLoader.formatString("[[RED]]Hold Breath Chance: [[YELLOW]]{0}%", decimal.format(Misc.getRandom().nextInt(27))));
+                break;
+            case PIGGY:
+                messages.add(LocaleLoader.formatString("[[RED]]Carrot Turbo Boost: [[YELLOW]]{0}%", decimal.format(Misc.getRandom().nextInt(80)) + 10));
+                break;
+        }
+
+        return messages;
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/skills/ArcheryCommand.java

@@ -0,0 +1,88 @@
+package com.gmail.nossr50.commands.skills;
+
+import com.gmail.nossr50.datatypes.skills.PrimarySkillType;
+import com.gmail.nossr50.datatypes.skills.SubSkillType;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.skills.archery.Archery;
+import com.gmail.nossr50.util.TextComponentFactory;
+import com.gmail.nossr50.util.skills.SkillActivationType;
+import net.md_5.bungee.api.chat.TextComponent;
+import org.bukkit.entity.Player;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class ArcheryCommand extends SkillCommand {
+    private String skillShotBonus;
+    private String dazeChance;
+    private String dazeChanceLucky;
+    private String retrieveChance;
+    private String retrieveChanceLucky;
+
+    private boolean canSkillShot;
+    private boolean canDaze;
+    private boolean canRetrieve;
+
+    public ArcheryCommand() {
+        super(PrimarySkillType.ARCHERY);
+    }
+
+    @Override
+    protected void dataCalculations(Player player, float skillValue) {
+        // ARCHERY_ARROW_RETRIEVAL
+        if (canRetrieve) {
+            String[] retrieveStrings = getAbilityDisplayValues(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, player, SubSkillType.ARCHERY_ARROW_RETRIEVAL);
+            retrieveChance = retrieveStrings[0];
+            retrieveChanceLucky = retrieveStrings[1];
+        }
+        
+        // ARCHERY_DAZE
+        if (canDaze) {
+            String[] dazeStrings = getAbilityDisplayValues(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, player, SubSkillType.ARCHERY_DAZE);
+            dazeChance = dazeStrings[0];
+            dazeChanceLucky = dazeStrings[1];
+        }
+        
+        // SKILL SHOT
+        if (canSkillShot) {
+            skillShotBonus = percent.format(Archery.getDamageBonusPercent(player));
+        }
+    }
+
+    @Override
+    protected void permissionsCheck(Player player) {
+        canSkillShot = canUseSubskill(player, SubSkillType.ARCHERY_SKILL_SHOT);
+        canDaze = canUseSubskill(player, SubSkillType.ARCHERY_DAZE);
+        canRetrieve = canUseSubskill(player, SubSkillType.ARCHERY_ARROW_RETRIEVAL);
+    }
+
+    @Override
+    protected List<String> statsDisplay(Player player, float skillValue, boolean hasEndurance, boolean isLucky) {
+        List<String> messages = new ArrayList<String>();
+
+        if (canRetrieve) {
+            messages.add(getStatMessage(SubSkillType.ARCHERY_ARROW_RETRIEVAL, retrieveChance)
+                    + (isLucky ? LocaleLoader.getString("Perks.Lucky.Bonus", retrieveChanceLucky) : ""));
+        }
+        
+        if (canDaze) {
+            messages.add(getStatMessage(SubSkillType.ARCHERY_DAZE, dazeChance)
+                    + (isLucky ? LocaleLoader.getString("Perks.Lucky.Bonus", dazeChanceLucky) : ""));
+        }
+        
+        if (canSkillShot) {
+            messages.add(getStatMessage(SubSkillType.ARCHERY_SKILL_SHOT, skillShotBonus));
+        }
+
+        return messages;
+    }
+
+    @Override
+    protected List<TextComponent> getTextComponents(Player player) {
+        List<TextComponent> textComponents = new ArrayList<>();
+
+        TextComponentFactory.getSubSkillTextComponents(player, textComponents, PrimarySkillType.ARCHERY);
+
+        return textComponents;
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/skills/AxesCommand.java

@@ -0,0 +1,109 @@
+package com.gmail.nossr50.commands.skills;
+
+import com.gmail.nossr50.datatypes.skills.PrimarySkillType;
+import com.gmail.nossr50.datatypes.skills.SubSkillType;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.skills.axes.Axes;
+import com.gmail.nossr50.util.Permissions;
+import com.gmail.nossr50.util.TextComponentFactory;
+import com.gmail.nossr50.util.player.UserManager;
+import com.gmail.nossr50.util.skills.RankUtils;
+import com.gmail.nossr50.util.skills.SkillActivationType;
+import net.md_5.bungee.api.chat.TextComponent;
+import org.bukkit.entity.Player;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class AxesCommand extends SkillCommand {
+    private String critChance;
+    private String critChanceLucky;
+    private double axeMasteryDamage;
+    private double impactDamage;
+    private String skullSplitterLength;
+    private String skullSplitterLengthEndurance;
+
+    private boolean canSkullSplitter;
+    private boolean canCritical;
+    private boolean canAxeMastery;
+    private boolean canImpact;
+    private boolean canGreaterImpact;
+
+    public AxesCommand() {
+        super(PrimarySkillType.AXES);
+    }
+
+    @Override
+    protected void dataCalculations(Player player, float skillValue) {
+        // ARMOR IMPACT
+        if (canImpact) {
+            impactDamage = UserManager.getPlayer(player).getAxesManager().getImpactDurabilityDamage();
+        }
+
+        // AXE MASTERY
+        if (canAxeMastery) {
+            axeMasteryDamage = Axes.getAxeMasteryBonusDamage(player);
+        }
+        
+        // CRITICAL HIT
+        if (canCritical) {
+            String[] criticalHitStrings = getAbilityDisplayValues(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, player, SubSkillType.AXES_CRITICAL_STRIKES);
+            critChance = criticalHitStrings[0];
+            critChanceLucky = criticalHitStrings[1];
+        }
+        
+        // SKULL SPLITTER
+        if (canSkullSplitter) {
+            String[] skullSplitterStrings = calculateLengthDisplayValues(player, skillValue);
+            skullSplitterLength = skullSplitterStrings[0];
+            skullSplitterLengthEndurance = skullSplitterStrings[1];
+        }
+    }
+
+    @Override
+    protected void permissionsCheck(Player player) {
+        canSkullSplitter = Permissions.skullSplitter(player) && RankUtils.hasUnlockedSubskill(player, SubSkillType.AXES_SKULL_SPLITTER);
+        canCritical = canUseSubskill(player, SubSkillType.AXES_CRITICAL_STRIKES);
+        canAxeMastery = canUseSubskill(player, SubSkillType.AXES_AXE_MASTERY);
+        canImpact = canUseSubskill(player, SubSkillType.AXES_ARMOR_IMPACT);
+        canGreaterImpact = canUseSubskill(player, SubSkillType.AXES_GREATER_IMPACT);
+    }
+
+    @Override
+    protected List<String> statsDisplay(Player player, float skillValue, boolean hasEndurance, boolean isLucky) {
+        List<String> messages = new ArrayList<String>();
+
+        if (canImpact) {
+            messages.add(LocaleLoader.getString("Ability.Generic.Template", LocaleLoader.getString("Axes.Ability.Bonus.2"), LocaleLoader.getString("Axes.Ability.Bonus.3", impactDamage)));
+        }
+        
+        if (canAxeMastery) {
+            messages.add(LocaleLoader.getString("Ability.Generic.Template", LocaleLoader.getString("Axes.Ability.Bonus.0"), LocaleLoader.getString("Axes.Ability.Bonus.1", axeMasteryDamage)));
+        }
+
+        if (canCritical) {
+            messages.add(getStatMessage(SubSkillType.AXES_CRITICAL_STRIKES, critChance)
+                    + (isLucky ? LocaleLoader.getString("Perks.Lucky.Bonus", critChanceLucky) : ""));
+        }
+        
+        if (canGreaterImpact) {
+            messages.add(LocaleLoader.getString("Ability.Generic.Template", LocaleLoader.getString("Axes.Ability.Bonus.4"), LocaleLoader.getString("Axes.Ability.Bonus.5", Axes.greaterImpactBonusDamage)));
+        }
+
+        if (canSkullSplitter) {
+            messages.add(getStatMessage(SubSkillType.AXES_SKULL_SPLITTER, skullSplitterLength)
+                    + (hasEndurance ? LocaleLoader.getString("Perks.ActivationTime.Bonus", skullSplitterLengthEndurance) : ""));
+        }
+
+        return messages;
+    }
+
+    @Override
+    protected List<TextComponent> getTextComponents(Player player) {
+        List<TextComponent> textComponents = new ArrayList<>();
+
+        TextComponentFactory.getSubSkillTextComponents(player, textComponents, PrimarySkillType.AXES);
+
+        return textComponents;
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/skills/ExcavationCommand.java

@@ -0,0 +1,64 @@
+package com.gmail.nossr50.commands.skills;
+
+import com.gmail.nossr50.datatypes.skills.PrimarySkillType;
+import com.gmail.nossr50.datatypes.skills.SubSkillType;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.util.Permissions;
+import com.gmail.nossr50.util.TextComponentFactory;
+import com.gmail.nossr50.util.skills.RankUtils;
+import net.md_5.bungee.api.chat.TextComponent;
+import org.bukkit.entity.Player;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class ExcavationCommand extends SkillCommand {
+    private String gigaDrillBreakerLength;
+    private String gigaDrillBreakerLengthEndurance;
+
+    private boolean canGigaDrill;
+    private boolean canTreasureHunt;
+
+    public ExcavationCommand() {
+        super(PrimarySkillType.EXCAVATION);
+    }
+
+    @Override
+    protected void dataCalculations(Player player, float skillValue) {
+        // GIGA DRILL BREAKER
+        if (canGigaDrill) {
+            String gigaDrillStrings[] = calculateLengthDisplayValues(player, skillValue);
+            gigaDrillBreakerLength = gigaDrillStrings[0];
+            gigaDrillBreakerLengthEndurance = gigaDrillStrings[1];
+        }
+    }
+
+    @Override
+    protected void permissionsCheck(Player player) {
+        canGigaDrill = Permissions.gigaDrillBreaker(player) && RankUtils.hasUnlockedSubskill(player, SubSkillType.EXCAVATION_GIGA_DRILL_BREAKER);
+        canTreasureHunt = canUseSubskill(player, SubSkillType.EXCAVATION_ARCHAEOLOGY);
+    }
+
+    @Override
+    protected List<String> statsDisplay(Player player, float skillValue, boolean hasEndurance, boolean isLucky) {
+        List<String> messages = new ArrayList<String>();
+
+        if (canGigaDrill) {
+            messages.add(getStatMessage(SubSkillType.EXCAVATION_GIGA_DRILL_BREAKER, gigaDrillBreakerLength)
+                    + (hasEndurance ? LocaleLoader.getString("Perks.ActivationTime.Bonus", gigaDrillBreakerLengthEndurance) : ""));
+
+            //messages.add(LocaleLoader.getString("Excavation.Effect.Length", gigaDrillBreakerLength) + (hasEndurance ? LocaleLoader.getString("Perks.ActivationTime.Bonus", gigaDrillBreakerLengthEndurance) : ""));
+        }
+
+        return messages;
+    }
+
+    @Override
+    protected List<TextComponent> getTextComponents(Player player) {
+        List<TextComponent> textComponents = new ArrayList<>();
+
+        TextComponentFactory.getSubSkillTextComponents(player, textComponents, PrimarySkillType.EXCAVATION);
+
+        return textComponents;
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/skills/FishingCommand.java

@@ -0,0 +1,177 @@
+package com.gmail.nossr50.commands.skills;
+
+import com.gmail.nossr50.config.AdvancedConfig;
+import com.gmail.nossr50.config.treasure.TreasureConfig;
+import com.gmail.nossr50.datatypes.skills.PrimarySkillType;
+import com.gmail.nossr50.datatypes.skills.SubSkillType;
+import com.gmail.nossr50.datatypes.treasure.Rarity;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.skills.fishing.Fishing;
+import com.gmail.nossr50.skills.fishing.FishingManager;
+import com.gmail.nossr50.util.Permissions;
+import com.gmail.nossr50.util.TextComponentFactory;
+import com.gmail.nossr50.util.player.UserManager;
+import com.gmail.nossr50.util.random.RandomChanceUtil;
+import com.gmail.nossr50.util.skills.RankUtils;
+import net.md_5.bungee.api.chat.TextComponent;
+import org.bukkit.Location;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Player;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class FishingCommand extends SkillCommand {
+    private int lootTier;
+    private String shakeChance;
+    private String shakeChanceLucky;
+    private int fishermansDietRank;
+    private String biteChance;
+
+    private String trapTreasure;
+    private String commonTreasure;
+    private String uncommonTreasure;
+    private String rareTreasure;
+    private String epicTreasure;
+    private String legendaryTreasure;
+    private String recordTreasure;
+
+    private String magicChance;
+
+    private boolean canTreasureHunt;
+    private boolean canMagicHunt;
+    private boolean canShake;
+    private boolean canFishermansDiet;
+    private boolean canMasterAngler;
+    private boolean canIceFish;
+
+    public FishingCommand() {
+        super(PrimarySkillType.FISHING);
+    }
+
+    @Override
+    protected void dataCalculations(Player player, float skillValue) {
+        FishingManager fishingManager = UserManager.getPlayer(player).getFishingManager();
+
+        // TREASURE HUNTER
+        if (canTreasureHunt) {
+            lootTier = fishingManager.getLootTier();
+
+            // Item drop rates
+            commonTreasure = percent.format(TreasureConfig.getInstance().getItemDropRate(lootTier, Rarity.COMMON) / 100.0);
+            uncommonTreasure = percent.format(TreasureConfig.getInstance().getItemDropRate(lootTier, Rarity.UNCOMMON) / 100.0);
+            rareTreasure = percent.format(TreasureConfig.getInstance().getItemDropRate(lootTier, Rarity.RARE) / 100.0);
+            epicTreasure = percent.format(TreasureConfig.getInstance().getItemDropRate(lootTier, Rarity.EPIC) / 100.0);
+            legendaryTreasure = percent.format(TreasureConfig.getInstance().getItemDropRate(lootTier, Rarity.LEGENDARY) / 100.0);
+            recordTreasure = percent.format(TreasureConfig.getInstance().getItemDropRate(lootTier, Rarity.RECORD) / 100.0);
+
+            // Magic hunter drop rates
+            double totalEnchantChance = 0;
+
+            for (Rarity rarity : Rarity.values()) {
+                if (rarity != Rarity.RECORD) {
+                    totalEnchantChance += TreasureConfig.getInstance().getEnchantmentDropRate(lootTier, rarity);
+                }
+            }
+
+            if(totalEnchantChance >= 1)
+                magicChance = percent.format(totalEnchantChance / 100.0);
+            else
+                magicChance = percent.format(0);
+        }
+
+        // FISHING_SHAKE
+        if (canShake) {
+            String[] shakeStrings = RandomChanceUtil.calculateAbilityDisplayValuesStatic(player, PrimarySkillType.FISHING, fishingManager.getShakeChance());
+            shakeChance = shakeStrings[0];
+            shakeChanceLucky = shakeStrings[1];
+        }
+
+        // FISHERMAN'S DIET
+        if (canFishermansDiet) {
+            fishermansDietRank = calculateRank(skillValue, Fishing.fishermansDietMaxLevel, Fishing.fishermansDietRankLevel1);
+        }
+
+        // MASTER ANGLER
+        if (canMasterAngler) {
+            double rawBiteChance = 1.0 / (player.getWorld().hasStorm() ? 300 : 500);
+
+            Location location = fishingManager.getHookLocation();
+
+            if (location == null) {
+                location = player.getLocation();
+            }
+
+            if (Fishing.masterAnglerBiomes.contains(location.getBlock().getBiome())) {
+                rawBiteChance = rawBiteChance * AdvancedConfig.getInstance().getMasterAnglerBiomeModifier();
+            }
+
+            if (player.isInsideVehicle() && player.getVehicle().getType() == EntityType.BOAT) {
+                rawBiteChance = rawBiteChance * AdvancedConfig.getInstance().getMasterAnglerBoatModifier();
+            }
+
+            double luckyModifier = Permissions.lucky(player, PrimarySkillType.FISHING) ? 1.333D : 1.0D;
+
+            biteChance = percent.format((rawBiteChance * 100.0D) * luckyModifier);
+        }
+    }
+
+    @Override
+    protected void permissionsCheck(Player player) {
+        canTreasureHunt = canUseSubskill(player, SubSkillType.FISHING_TREASURE_HUNTER);
+        canMagicHunt = canUseSubskill(player, SubSkillType.FISHING_MAGIC_HUNTER) && canUseSubskill(player, SubSkillType.FISHING_TREASURE_HUNTER);
+        canShake = canUseSubskill(player, SubSkillType.FISHING_SHAKE);
+        canFishermansDiet = canUseSubskill(player, SubSkillType.FISHING_FISHERMANS_DIET);
+        canMasterAngler = canUseSubskill(player, SubSkillType.FISHING_MASTER_ANGLER);
+        canIceFish = canUseSubskill(player, SubSkillType.FISHING_ICE_FISHING);
+    }
+
+    @Override
+    protected List<String> statsDisplay(Player player, float skillValue, boolean hasEndurance, boolean isLucky) {
+        List<String> messages = new ArrayList<String>();
+        
+        if (canFishermansDiet) {
+            messages.add(getStatMessage(false, true, SubSkillType.FISHING_FISHERMANS_DIET, String.valueOf(fishermansDietRank)));
+        }
+        
+        if (canIceFish) {
+            messages.add(getStatMessage(SubSkillType.FISHING_ICE_FISHING, SubSkillType.FISHING_ICE_FISHING.getLocaleStatDescription()));
+        }
+        
+        if (canMagicHunt) {
+            messages.add(getStatMessage(SubSkillType.FISHING_MAGIC_HUNTER, magicChance));
+        }
+
+        if (canMasterAngler) {
+            //TODO: Update this with more details
+            messages.add(getStatMessage(false, true, SubSkillType.FISHING_MASTER_ANGLER, biteChance));
+        }
+        
+        if (canShake) {
+            messages.add(getStatMessage(SubSkillType.FISHING_SHAKE, shakeChance)
+            + (isLucky ? LocaleLoader.getString("Perks.Lucky.Bonus", shakeChanceLucky) : ""));
+        }
+        
+        if (canTreasureHunt) {
+            messages.add(getStatMessage(false, true, SubSkillType.FISHING_TREASURE_HUNTER, String.valueOf(lootTier), String.valueOf(RankUtils.getHighestRank(SubSkillType.FISHING_TREASURE_HUNTER))));
+            messages.add(getStatMessage(true, true, SubSkillType.FISHING_TREASURE_HUNTER,
+                    String.valueOf(commonTreasure),
+                    String.valueOf(uncommonTreasure),
+                    String.valueOf(rareTreasure),
+                    String.valueOf(epicTreasure),
+                    String.valueOf(legendaryTreasure),
+                    String.valueOf(recordTreasure)));
+        }
+
+        return messages;
+    }
+
+    @Override
+    protected List<TextComponent> getTextComponents(Player player) {
+        List<TextComponent> textComponents = new ArrayList<>();
+
+        TextComponentFactory.getSubSkillTextComponents(player, textComponents, PrimarySkillType.FISHING);
+
+        return textComponents;
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/skills/HerbalismCommand.java

@@ -0,0 +1,151 @@
+package com.gmail.nossr50.commands.skills;
+
+import com.gmail.nossr50.datatypes.skills.PrimarySkillType;
+import com.gmail.nossr50.datatypes.skills.SubSkillType;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.util.Permissions;
+import com.gmail.nossr50.util.TextComponentFactory;
+import com.gmail.nossr50.util.skills.RankUtils;
+import com.gmail.nossr50.util.skills.SkillActivationType;
+import net.md_5.bungee.api.chat.TextComponent;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class HerbalismCommand extends SkillCommand {
+    private String greenTerraLength;
+    private String greenTerraLengthEndurance;
+    private String greenThumbChance;
+    private String greenThumbChanceLucky;
+    private int greenThumbStage;
+    private int farmersDietRank;
+    private String doubleDropChance;
+    private String doubleDropChanceLucky;
+    private String hylianLuckChance;
+    private String hylianLuckChanceLucky;
+    private String shroomThumbChance;
+    private String shroomThumbChanceLucky;
+
+    private boolean hasHylianLuck;
+    private boolean canGreenTerra;
+    private boolean canGreenThumbPlants;
+    private boolean canGreenThumbBlocks;
+    private boolean canFarmersDiet;
+    private boolean canDoubleDrop;
+    private boolean canShroomThumb;
+
+    public HerbalismCommand() {
+        super(PrimarySkillType.HERBALISM);
+    }
+
+    @Override
+    protected void dataCalculations(Player player, float skillValue) {
+        
+        // DOUBLE DROPS
+        if (canDoubleDrop) {
+            String[] doubleDropStrings = getAbilityDisplayValues(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, player, SubSkillType.HERBALISM_DOUBLE_DROPS);;
+            doubleDropChance = doubleDropStrings[0];
+            doubleDropChanceLucky = doubleDropStrings[1];
+        }
+        
+        // FARMERS DIET
+        if (canFarmersDiet) {
+            farmersDietRank = RankUtils.getRank(player, SubSkillType.HERBALISM_FARMERS_DIET);
+        }
+        
+        // GREEN TERRA
+        if (canGreenTerra) {
+            String[] greenTerraStrings = calculateLengthDisplayValues(player, skillValue);
+            greenTerraLength = greenTerraStrings[0];
+            greenTerraLengthEndurance = greenTerraStrings[1];
+        }
+
+        // GREEN THUMB
+        if (canGreenThumbBlocks || canGreenThumbPlants) {
+            greenThumbStage = RankUtils.getRank(player, SubSkillType.HERBALISM_GREEN_THUMB);
+
+            String[] greenThumbStrings = getAbilityDisplayValues(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, player, SubSkillType.HERBALISM_GREEN_THUMB);
+            greenThumbChance = greenThumbStrings[0];
+            greenThumbChanceLucky = greenThumbStrings[1];
+        }
+
+        // HYLIAN LUCK
+        if (hasHylianLuck) {
+            String[] hylianLuckStrings = getAbilityDisplayValues(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, player, SubSkillType.HERBALISM_HYLIAN_LUCK);
+            hylianLuckChance = hylianLuckStrings[0];
+            hylianLuckChanceLucky = hylianLuckStrings[1];
+        }
+
+        // SHROOM THUMB
+        if (canShroomThumb) {
+            String[] shroomThumbStrings = getAbilityDisplayValues(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, player, SubSkillType.HERBALISM_SHROOM_THUMB);
+            shroomThumbChance = shroomThumbStrings[0];
+            shroomThumbChanceLucky = shroomThumbStrings[1];
+        }
+    }
+
+    @Override
+    protected void permissionsCheck(Player player) {
+        hasHylianLuck = canUseSubskill(player, SubSkillType.HERBALISM_HYLIAN_LUCK);
+        canGreenTerra = Permissions.greenTerra(player);
+        canGreenThumbPlants = RankUtils.hasUnlockedSubskill(player, SubSkillType.HERBALISM_GREEN_THUMB) && (Permissions.greenThumbPlant(player, Material.WHEAT) || Permissions.greenThumbPlant(player, Material.CARROT) || Permissions.greenThumbPlant(player, Material.POTATO) || Permissions.greenThumbPlant(player, Material.BEETROOT) || Permissions.greenThumbPlant(player, Material.NETHER_WART) || Permissions.greenThumbPlant(player, Material.COCOA));
+        canGreenThumbBlocks = RankUtils.hasUnlockedSubskill(player, SubSkillType.HERBALISM_GREEN_THUMB) && (Permissions.greenThumbBlock(player, Material.DIRT) || Permissions.greenThumbBlock(player, Material.COBBLESTONE) || Permissions.greenThumbBlock(player, Material.COBBLESTONE_WALL) || Permissions.greenThumbBlock(player, Material.STONE_BRICKS));
+        canFarmersDiet = canUseSubskill(player, SubSkillType.HERBALISM_FARMERS_DIET);
+        canDoubleDrop = canUseSubskill(player, SubSkillType.HERBALISM_DOUBLE_DROPS) && !skill.getDoubleDropsDisabled();
+        canShroomThumb = canUseSubskill(player, SubSkillType.HERBALISM_SHROOM_THUMB);
+    }
+
+    @Override
+    protected List<String> statsDisplay(Player player, float skillValue, boolean hasEndurance, boolean isLucky) {
+        List<String> messages = new ArrayList<String>();
+
+        if (canDoubleDrop) {
+            messages.add(getStatMessage(SubSkillType.HERBALISM_DOUBLE_DROPS, doubleDropChance)
+                    + (isLucky ? LocaleLoader.getString("Perks.Lucky.Bonus", doubleDropChanceLucky) : ""));
+        }
+        
+        if (canFarmersDiet) {
+            messages.add(getStatMessage(false, true, SubSkillType.HERBALISM_FARMERS_DIET, String.valueOf(farmersDietRank)));
+        }
+        
+        if (canGreenTerra) {
+            messages.add(getStatMessage(SubSkillType.HERBALISM_GREEN_TERRA, greenTerraLength)
+                    + (hasEndurance ? LocaleLoader.getString("Perks.ActivationTime.Bonus", greenTerraLengthEndurance) : ""));
+
+            //messages.add(LocaleLoader.getString("Herbalism.Ability.GTe.Length", greenTerraLength) + (hasEndurance ? LocaleLoader.getString("Perks.ActivationTime.Bonus", greenTerraLengthEndurance) : ""));
+        }
+
+        if (canGreenThumbBlocks || canGreenThumbPlants) {
+            messages.add(getStatMessage(SubSkillType.HERBALISM_GREEN_THUMB, greenThumbChance)
+                    + (isLucky ? LocaleLoader.getString("Perks.Lucky.Bonus", greenThumbChanceLucky) : ""));
+            //messages.add(LocaleLoader.getString("Herbalism.Ability.GTh.Chance", greenThumbChance) + (isLucky ? LocaleLoader.getString("Perks.Lucky.Bonus", greenThumbChanceLucky) : ""));
+        }
+
+        if (canGreenThumbPlants) {
+            messages.add(getStatMessage(true, true,SubSkillType.HERBALISM_GREEN_THUMB, String.valueOf(greenThumbStage)));
+        }
+
+        if (hasHylianLuck) {
+            messages.add(getStatMessage(SubSkillType.HERBALISM_HYLIAN_LUCK, hylianLuckChance)
+                    + (isLucky ? LocaleLoader.getString("Perks.Lucky.Bonus", hylianLuckChanceLucky) : ""));
+        }
+
+        if (canShroomThumb) {
+            messages.add(getStatMessage(SubSkillType.HERBALISM_SHROOM_THUMB, shroomThumbChance)
+                    + (isLucky ? LocaleLoader.getString("Perks.Lucky.Bonus", shroomThumbChanceLucky) : ""));
+        }
+
+        return messages;
+    }
+
+    @Override
+    protected List<TextComponent> getTextComponents(Player player) {
+        List<TextComponent> textComponents = new ArrayList<>();
+
+        TextComponentFactory.getSubSkillTextComponents(player, textComponents, PrimarySkillType.HERBALISM);
+
+        return textComponents;
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/skills/MiningCommand.java

@@ -0,0 +1,121 @@
+package com.gmail.nossr50.commands.skills;
+
+import com.gmail.nossr50.datatypes.skills.PrimarySkillType;
+import com.gmail.nossr50.datatypes.skills.SubSkillType;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.skills.mining.MiningManager;
+import com.gmail.nossr50.util.Permissions;
+import com.gmail.nossr50.util.TextComponentFactory;
+import com.gmail.nossr50.util.player.UserManager;
+import com.gmail.nossr50.util.skills.RankUtils;
+import com.gmail.nossr50.util.skills.SkillActivationType;
+import net.md_5.bungee.api.chat.TextComponent;
+import org.bukkit.entity.Player;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class MiningCommand extends SkillCommand {
+    private String doubleDropChance;
+    private String doubleDropChanceLucky;
+    private String superBreakerLength;
+    private String superBreakerLengthEndurance;
+
+    private int blastMiningRank;
+    private int bonusTNTDrops;
+    private double blastRadiusIncrease;
+    private String oreBonus;
+    private String debrisReduction;
+    private String blastDamageDecrease;
+
+    private boolean canSuperBreaker;
+    private boolean canDoubleDrop;
+    private boolean canBlast;
+    private boolean canBiggerBombs;
+    private boolean canDemoExpert;
+
+    public MiningCommand() {
+        super(PrimarySkillType.MINING);
+    }
+
+    @Override
+    protected void dataCalculations(Player player, float skillValue) {
+        // BLAST MINING
+        if (canBlast || canDemoExpert || canBiggerBombs) {
+            MiningManager miningManager = UserManager.getPlayer(player).getMiningManager();
+
+            blastMiningRank = miningManager.getBlastMiningTier();
+            bonusTNTDrops = miningManager.getDropMultiplier();
+            oreBonus = percent.format(miningManager.getOreBonus() / 30.0D); // Base received in TNT is 30%
+            debrisReduction = percent.format(miningManager.getDebrisReduction() / 30.0D); // Base received in TNT is 30%
+            blastDamageDecrease = percent.format(miningManager.getBlastDamageModifier() / 100.0D);
+            blastRadiusIncrease = miningManager.getBlastRadiusModifier();
+        }
+        
+        // DOUBLE DROPS
+        if (canDoubleDrop) {
+            String[] doubleDropStrings = getAbilityDisplayValues(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, player, SubSkillType.MINING_DOUBLE_DROPS);
+            doubleDropChance = doubleDropStrings[0];
+            doubleDropChanceLucky = doubleDropStrings[1];
+        }
+        
+        // SUPER BREAKER
+        if (canSuperBreaker) {
+            String[] superBreakerStrings = calculateLengthDisplayValues(player, skillValue);
+            superBreakerLength = superBreakerStrings[0];
+            superBreakerLengthEndurance = superBreakerStrings[1];
+        }
+    }
+
+    @Override
+    protected void permissionsCheck(Player player) {
+        canBiggerBombs = RankUtils.hasUnlockedSubskill(player, SubSkillType.MINING_BIGGER_BOMBS) && Permissions.biggerBombs(player);
+        canBlast = RankUtils.hasUnlockedSubskill(player, SubSkillType.MINING_BLAST_MINING) && Permissions.remoteDetonation(player);
+        canDemoExpert = RankUtils.hasUnlockedSubskill(player, SubSkillType.MINING_DEMOLITIONS_EXPERTISE) && Permissions.demolitionsExpertise(player);
+        canDoubleDrop = Permissions.isSubSkillEnabled(player, SubSkillType.MINING_DOUBLE_DROPS) && !skill.getDoubleDropsDisabled();
+        canSuperBreaker = RankUtils.hasUnlockedSubskill(player, SubSkillType.MINING_SUPER_BREAKER) && Permissions.superBreaker(player);
+    }
+
+    @Override
+    protected List<String> statsDisplay(Player player, float skillValue, boolean hasEndurance, boolean isLucky) {
+        List<String> messages = new ArrayList<String>();
+
+        if (canBiggerBombs) {
+            messages.add(getStatMessage(true, true, SubSkillType.MINING_BLAST_MINING, String.valueOf(blastRadiusIncrease)));
+            //messages.add(LocaleLoader.getString("Mining.Blast.Radius.Increase", blastRadiusIncrease));
+        }
+        
+        if (canBlast) {
+            messages.add(getStatMessage(false, true, SubSkillType.MINING_BLAST_MINING, String.valueOf(blastMiningRank), String.valueOf(RankUtils.getHighestRank(SubSkillType.MINING_BLAST_MINING)), LocaleLoader.getString("Mining.Blast.Effect", oreBonus, debrisReduction, bonusTNTDrops)));
+            //messages.add(LocaleLoader.getString("Mining.Blast.Rank", blastMiningRank, RankUtils.getHighestRank(SubSkillType.MINING_BLAST_MINING), LocaleLoader.getString("Mining.Blast.Effect", oreBonus, debrisReduction, bonusTNTDrops)));
+        }
+        
+         if (canDemoExpert) {
+            messages.add(getStatMessage(SubSkillType.MINING_DEMOLITIONS_EXPERTISE, blastDamageDecrease));
+            //messages.add(LocaleLoader.getString("Mining.Effect.Decrease", blastDamageDecrease));
+        }
+        
+        if (canDoubleDrop) {
+            messages.add(getStatMessage(SubSkillType.HERBALISM_DOUBLE_DROPS, doubleDropChance)
+                    + (isLucky ? LocaleLoader.getString("Perks.Lucky.Bonus", doubleDropChanceLucky) : ""));
+            //messages.add(LocaleLoader.getString("Mining.Effect.DropChance", doubleDropChance) + (isLucky ? LocaleLoader.getString("Perks.Lucky.Bonus", doubleDropChanceLucky) : ""));
+        }
+
+        if (canSuperBreaker) {
+            messages.add(getStatMessage(SubSkillType.MINING_SUPER_BREAKER, superBreakerLength)
+                    + (hasEndurance ? LocaleLoader.getString("Perks.ActivationTime.Bonus", superBreakerLengthEndurance) : ""));
+            //messages.add(LocaleLoader.getString("Mining.Ability.Length", superBreakerLength) + (hasEndurance ? LocaleLoader.getString("Perks.ActivationTime.Bonus", superBreakerLengthEndurance) : ""));
+        }
+
+        return messages;
+    }
+
+    @Override
+    protected List<TextComponent> getTextComponents(Player player) {
+        List<TextComponent> textComponents = new ArrayList<>();
+
+        TextComponentFactory.getSubSkillTextComponents(player, textComponents, PrimarySkillType.MINING);
+
+        return textComponents;
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/skills/MmoInfoCommand.java

@@ -0,0 +1,101 @@
+package com.gmail.nossr50.commands.skills;
+
+import com.gmail.nossr50.datatypes.skills.PrimarySkillType;
+import com.gmail.nossr50.datatypes.skills.SubSkillType;
+import com.gmail.nossr50.datatypes.skills.subskills.AbstractSubSkill;
+import com.gmail.nossr50.listeners.InteractionManager;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.util.Permissions;
+import com.gmail.nossr50.util.TextComponentFactory;
+import com.google.common.collect.ImmutableList;
+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 java.util.ArrayList;
+import java.util.List;
+
+/**
+ * This is the command that retrieves data about skills from in-game sources
+ */
+public class MmoInfoCommand implements TabExecutor {
+
+    @Override
+    public boolean onCommand(CommandSender commandSender, Command command, String s, String[] args) {
+        /*
+         * Only allow players to use this command
+         */
+        if(commandSender instanceof Player)
+        {
+            if(args.length < 1)
+                return false;
+
+            Player player = (Player) commandSender;
+            if(Permissions.mmoinfo(player))
+            {
+                if(args == null || args[0] == null)
+                    return false;
+
+                if(args[0].equalsIgnoreCase( "???"))
+                {
+                    player.sendMessage(LocaleLoader.getString("Commands.MmoInfo.Header"));
+                    player.sendMessage(LocaleLoader.getString("Commands.MmoInfo.SubSkillHeader", "???"));
+                    player.sendMessage(LocaleLoader.getString("Commands.MmoInfo.DetailsHeader"));
+                    player.sendMessage(LocaleLoader.getString("Commands.MmoInfo.Mystery"));
+                    return true;
+                } else if(InteractionManager.getAbstractByName(args[0]) != null || PrimarySkillType.SUBSKILL_NAMES.contains(args[0]))
+                {
+                    displayInfo(player, args[0]);
+                    return true;
+                }
+
+                //Not a real skill
+                player.sendMessage(LocaleLoader.getString("Commands.MmoInfo.NoMatch"));
+                return true;
+            }
+        }
+
+        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], PrimarySkillType.SUBSKILL_NAMES, new ArrayList<String>(PrimarySkillType.SUBSKILL_NAMES.size()));
+            default:
+                return ImmutableList.of();
+        }
+    }
+
+    private void displayInfo(Player player, String subSkillName)
+    {
+        //Check to see if the skill exists in the new system
+        AbstractSubSkill abstractSubSkill = InteractionManager.getAbstractByName(subSkillName);
+        if(abstractSubSkill != null)
+        {
+            /* New System Skills are programmable */
+            abstractSubSkill.printInfo(player);
+            //TextComponentFactory.sendPlayerUrlHeader(player);
+        } else {
+            /*
+             * Skill is only in the old system
+             */
+            player.sendMessage(LocaleLoader.getString("Commands.MmoInfo.Header"));
+            player.sendMessage(LocaleLoader.getString("Commands.MmoInfo.SubSkillHeader", subSkillName));
+            player.sendMessage(LocaleLoader.getString("Commands.MmoInfo.DetailsHeader"));
+            player.sendMessage(LocaleLoader.getString("Commands.MmoInfo.OldSkill"));
+        }
+
+        for(SubSkillType subSkillType : SubSkillType.values())
+        {
+            if(subSkillType.getNiceNameNoSpaces(subSkillType).equalsIgnoreCase(subSkillName))
+                subSkillName = subSkillType.getWikiName(subSkillType.toString());
+        }
+
+        //Send Player Wiki Link
+        TextComponentFactory.sendPlayerSubSkillWikiLink(player, subSkillName);
+    }
+}

mcMMO-core/src/main/java/com/gmail/nossr50/commands/skills/RepairCommand.java

@@ -0,0 +1,131 @@
+package com.gmail.nossr50.commands.skills;
+
+import com.gmail.nossr50.datatypes.skills.MaterialType;
+import com.gmail.nossr50.datatypes.skills.PrimarySkillType;
+import com.gmail.nossr50.datatypes.skills.SubSkillType;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.mcMMO;
+import com.gmail.nossr50.skills.repair.ArcaneForging;
+import com.gmail.nossr50.skills.repair.Repair;
+import com.gmail.nossr50.skills.repair.RepairManager;
+import com.gmail.nossr50.skills.repair.repairables.Repairable;
+import com.gmail.nossr50.util.Permissions;
+import com.gmail.nossr50.util.TextComponentFactory;
+import com.gmail.nossr50.util.player.UserManager;
+import com.gmail.nossr50.util.skills.RankUtils;
+import com.gmail.nossr50.util.skills.SkillActivationType;
+import net.md_5.bungee.api.chat.TextComponent;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class RepairCommand extends SkillCommand {
+    private String repairMasteryBonus;
+    private String superRepairChance;
+    private String superRepairChanceLucky;
+
+    private boolean canSuperRepair;
+    private boolean canMasterRepair;
+    private boolean canArcaneForge;
+    private boolean canRepairStone;
+    private boolean canRepairIron;
+    private boolean canRepairGold;
+    private boolean canRepairDiamond;
+    private boolean canRepairString;
+    private boolean canRepairLeather;
+    private boolean canRepairWood;
+    private boolean arcaneBypass;
+
+    private int diamondLevel;
+    private int goldLevel;
+    private int ironLevel;
+    private int stoneLevel;
+
+    public RepairCommand() {
+        super(PrimarySkillType.REPAIR);
+    }
+
+    @Override
+    protected void dataCalculations(Player player, float skillValue) {
+        // We're using pickaxes here, not the best but it works
+        Repairable diamondRepairable = mcMMO.getRepairableManager().getRepairable(Material.DIAMOND_PICKAXE);
+        Repairable goldRepairable = mcMMO.getRepairableManager().getRepairable(Material.GOLDEN_PICKAXE);
+        Repairable ironRepairable = mcMMO.getRepairableManager().getRepairable(Material.IRON_PICKAXE);
+        Repairable stoneRepairable = mcMMO.getRepairableManager().getRepairable(Material.STONE_PICKAXE);
+
+        // 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();
+        goldLevel = (goldRepairable == null) ? 0 : goldRepairable.getMinimumLevel();
+        ironLevel = (ironRepairable == null) ? 0 : ironRepairable.getMinimumLevel();
+        stoneLevel = (stoneRepairable == null) ? 0 : stoneRepairable.getMinimumLevel();
+
+        // REPAIR MASTERY
+        if (canMasterRepair) {
+            repairMasteryBonus = percent.format(Math.min(((Repair.repairMasteryMaxBonus / Repair.repairMasteryMaxBonusLevel) * skillValue), Repair.repairMasteryMaxBonus) / 100D);
+        }
+
+        // SUPER REPAIR
+        if (canSuperRepair) {
+            String[] superRepairStrings = getAbilityDisplayValues(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, player, SubSkillType.REPAIR_SUPER_REPAIR);
+            superRepairChance = superRepairStrings[0];
+            superRepairChanceLucky = superRepairStrings[1];
+        }
+    }
+
+    @Override
+    protected void permissionsCheck(Player player) {
+        canSuperRepair = canUseSubskill(player, SubSkillType.REPAIR_SUPER_REPAIR);
+        canMasterRepair = canUseSubskill(player, SubSkillType.REPAIR_REPAIR_MASTERY);
+        canArcaneForge = canUseSubskill(player, SubSkillType.REPAIR_ARCANE_FORGING);
+        canRepairDiamond = Permissions.repairMaterialType(player, MaterialType.DIAMOND);
+        canRepairGold = Permissions.repairMaterialType(player, MaterialType.GOLD);
+        canRepairIron = Permissions.repairMaterialType(player, MaterialType.IRON);
+        canRepairStone = Permissions.repairMaterialType(player, MaterialType.STONE);
+        canRepairString = Permissions.repairMaterialType(player, MaterialType.STRING);
+        canRepairLeather = Permissions.repairMaterialType(player, MaterialType.LEATHER);
+        canRepairWood = Permissions.repairMaterialType(player, MaterialType.WOOD);
+        arcaneBypass = Permissions.arcaneBypass(player);
+    }
+
+    @Override
+    protected List<String> statsDisplay(Player player, float skillValue, boolean hasEndurance, boolean isLucky) {
+        List<String> messages = new ArrayList<String>();
+
+        if (canArcaneForge) {
+            RepairManager repairManager = UserManager.getPlayer(player).getRepairManager();
+
+            messages.add(getStatMessage(false, true,
+                    SubSkillType.REPAIR_ARCANE_FORGING,
+                    String.valueOf(RankUtils.getRank(player, SubSkillType.REPAIR_ARCANE_FORGING)),
+                    RankUtils.getHighestRankStr(SubSkillType.REPAIR_ARCANE_FORGING)));
+
+            if (ArcaneForging.arcaneForgingEnchantLoss || ArcaneForging.arcaneForgingDowngrades) {
+                messages.add(getStatMessage(true, true, SubSkillType.REPAIR_ARCANE_FORGING,
+                        String.valueOf(arcaneBypass ? 100 : repairManager.getKeepEnchantChance()),
+                        String.valueOf(arcaneBypass ? 0 : repairManager.getDowngradeEnchantChance()))); //Jesus those parentheses
+            }
+        }
+        
+        if (canMasterRepair) {
+            messages.add(getStatMessage(false, true, SubSkillType.REPAIR_REPAIR_MASTERY, repairMasteryBonus));
+        }
+
+        if (canSuperRepair) {
+            messages.add(getStatMessage(SubSkillType.REPAIR_SUPER_REPAIR, superRepairChance)
+                    + (isLucky ? LocaleLoader.getString("Perks.Lucky.Bonus", superRepairChanceLucky) : ""));
+        }
+
+        return messages;
+    }
+
+    @Override
+    protected List<TextComponent> getTextComponents(Player player) {
+        List<TextComponent> textComponents = new ArrayList<>();
+
+        TextComponentFactory.getSubSkillTextComponents(player, textComponents, PrimarySkillType.REPAIR);
+
+        return textComponents;
+    }
+}