Major refactoring. This WILL break any mcMMO-related plugin that

does not properly hook into the API classes. 

This consolidates the skill-related classes into their own individual
packages, and moves several misc skill classes into the main Skill
package as well. This also moves all Party & Spout related files into
their own respective packages as well.

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

@@ -0,0 +1,211 @@
+package com.gmail.nossr50.skills;
+
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Player;
+
+import com.gmail.nossr50.config.Config;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.util.BlockChecks;
+import com.gmail.nossr50.util.Permissions;
+
+public enum AbilityType {
+    BERSERK(
+            Config.getInstance().getAbilityCooldownBerserk(),
+            Config.getInstance().getAbilityMaxTicksBerserk(),
+            "Unarmed.Skills.Berserk.On",
+            "Unarmed.Skills.Berserk.Off",
+            "Unarmed.Skills.Berserk.Other.On",
+            "Unarmed.Skills.Berserk.Refresh",
+            "Unarmed.Skills.Berserk.Other.Off"),
+
+    SUPER_BREAKER(
+            Config.getInstance().getAbilityCooldownSuperBreaker(),
+            Config.getInstance().getAbilityMaxTicksSuperBreaker(),
+            "Mining.Skills.SuperBreaker.On",
+            "Mining.Skills.SuperBreaker.Off",
+            "Mining.Skills.SuperBreaker.Other.On",
+            "Mining.Skills.SuperBreaker.Refresh",
+            "Mining.Skills.SuperBreaker.Other.Off"),
+
+    GIGA_DRILL_BREAKER(
+            Config.getInstance().getAbilityCooldownGigaDrillBreaker(),
+            Config.getInstance().getAbilityMaxTicksGigaDrillBreaker(),
+            "Excavation.Skills.GigaDrillBreaker.On",
+            "Excavation.Skills.GigaDrillBreaker.Off",
+            "Excavation.Skills.GigaDrillBreaker.Other.On",
+            "Excavation.Skills.GigaDrillBreaker.Refresh",
+            "Excavation.Skills.GigaDrillBreaker.Other.Off"),
+
+    GREEN_TERRA(
+            Config.getInstance().getAbilityCooldownGreenTerra(),
+            Config.getInstance().getAbilityMaxTicksGreenTerra(),
+            "Herbalism.Skills.GTe.On",
+            "Herbalism.Skills.GTe.Off",
+            "Herbalism.Skills.GTe.Other.On",
+            "Herbalism.Skills.GTe.Refresh",
+            "Herbalism.Skills.GTe.Other.Off"),
+
+    SKULL_SPLIITER(
+            Config.getInstance().getAbilityCooldownSkullSplitter(),
+            Config.getInstance().getAbilityMaxTicksSkullSplitter(),
+            "Axes.Skills.SS.On",
+            "Axes.Skills.SS.Off",
+            "Axes.Skills.SS.Other.On",
+            "Axes.Skills.SS.Refresh",
+            "Axes.Skills.SS.Other.Off"),
+
+    TREE_FELLER(
+            Config.getInstance().getAbilityCooldownTreeFeller(),
+            Config.getInstance().getAbilityMaxTicksTreeFeller(),
+            "Woodcutting.Skills.TreeFeller.On",
+            "Woodcutting.Skills.TreeFeller.Off",
+            "Woodcutting.Skills.TreeFeller.Other.On",
+            "Woodcutting.Skills.TreeFeller.Refresh",
+            "Woodcutting.Skills.TreeFeller.Other.Off"),
+
+    SERRATED_STRIKES(
+            Config.getInstance().getAbilityCooldownSerratedStrikes(),
+            Config.getInstance().getAbilityMaxTicksSerratedStrikes(),
+            "Swords.Skills.SS.On",
+            "Swords.Skills.SS.Off",
+            "Swords.Skills.SS.Other.On",
+            "Swords.Skills.SS.Refresh",
+            "Swords.Skills.SS.Other.Off"),
+
+    BLAST_MINING(
+            Config.getInstance().getAbilityCooldownBlastMining(),
+            Config.getInstance().getAbilityMaxTicksBlastMining(),
+            null,
+            null,
+            "Mining.Blast.Other.On",
+            "Mining.Blast.Refresh",
+            null),
+
+    LEAF_BLOWER(
+            0,
+            0,
+            null,
+            null,
+            null,
+            null,
+            null);
+
+    private int cooldown;
+    private int maxTicks;
+    private String abilityOn;
+    private String abilityOff;
+    private String abilityPlayer;
+    private String abilityRefresh;
+    private String abilityPlayerOff;
+
+    private AbilityType(int cooldown, int maxTicks, String abilityOn, String abilityOff, String abilityPlayer, String abilityRefresh, String abilityPlayerOff) {
+        this.cooldown = cooldown;
+        this.maxTicks = maxTicks;
+        this.abilityOn = abilityOn;
+        this.abilityOff = abilityOff;
+        this.abilityPlayer = abilityPlayer;
+        this.abilityRefresh = abilityRefresh;
+        this.abilityPlayerOff = abilityPlayerOff;
+    }
+
+    public int getCooldown() {
+        return this.cooldown;
+    }
+
+    public String getAbilityOn() {
+        return LocaleLoader.getString(this.abilityOn);
+    }
+
+    public String getAbilityOff() {
+        return LocaleLoader.getString(this.abilityOff);
+    }
+
+    public String getAbilityPlayer(Player player) {
+        return LocaleLoader.getString(this.abilityPlayer, new Object[] {player.getName()});
+    }
+
+    public String getAbilityPlayerOff(Player player) {
+        return LocaleLoader.getString(this.abilityPlayerOff, new Object[] {player.getName()});
+    }
+
+    public String getAbilityRefresh() {
+        return LocaleLoader.getString(this.abilityRefresh);
+    }
+
+    public int getMaxTicks() {
+        return this.maxTicks;
+    }
+
+    /**
+     * Get the permissions for this ability.
+     *
+     * @param player Player to check permissions for
+     * @return true if the player has permissions, false otherwise
+     */
+    public boolean getPermissions(Player player) {
+
+        switch (this) {
+        case BERSERK:
+            return Permissions.berserk(player);
+
+        case BLAST_MINING:
+            return Permissions.blastMining(player);
+
+        case GIGA_DRILL_BREAKER:
+            return Permissions.gigaDrillBreaker(player);
+
+        case GREEN_TERRA:
+            return Permissions.greenTerra(player);
+
+        case LEAF_BLOWER:
+            return Permissions.leafBlower(player);
+
+        case SERRATED_STRIKES:
+            return Permissions.serratedStrikes(player);
+
+        case SKULL_SPLIITER:
+            return Permissions.skullSplitter(player);
+
+        case SUPER_BREAKER:
+            return Permissions.superBreaker(player);
+
+        case TREE_FELLER:
+            return Permissions.treeFeller(player);
+
+        default:
+            return false;
+        }
+    }
+
+    /**
+     * Check if a block is affected by this ability.
+     *
+     * @param Block the block to check
+     * @return true if the block is affected by this ability, false otherwise
+     */
+    public boolean blockCheck(Block block) {
+        switch (this) {
+        case BERSERK:
+            return (BlockChecks.canBeGigaDrillBroken(block) || block.getType() == Material.SNOW);
+
+        case GIGA_DRILL_BREAKER:
+            return BlockChecks.canBeGigaDrillBroken(block);
+
+        case GREEN_TERRA:
+            return BlockChecks.makeMossy(block);
+
+        case LEAF_BLOWER:
+            return block.getType() == Material.LEAVES;
+
+        case SUPER_BREAKER:
+            return BlockChecks.canBeSuperBroken(block);
+
+        case TREE_FELLER:
+            return block.getType() == Material.LOG;
+
+        default:
+            return false;
+        }
+    }
+}

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

@@ -0,0 +1,544 @@
+package com.gmail.nossr50.skills;
+
+import org.bukkit.Material;
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.entity.Animals;
+import org.bukkit.entity.Arrow;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.IronGolem;
+import org.bukkit.entity.LightningStrike;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Skeleton;
+import org.bukkit.entity.Tameable;
+import org.bukkit.entity.Wolf;
+import org.bukkit.event.entity.EntityDamageByEntityEvent;
+import org.bukkit.event.entity.EntityDamageEvent;
+import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+import org.bukkit.event.player.PlayerAnimationEvent;
+import org.bukkit.inventory.ItemStack;
+
+import com.gmail.nossr50.mcMMO;
+import com.gmail.nossr50.config.Config;
+import com.gmail.nossr50.datatypes.PlayerProfile;
+import com.gmail.nossr50.events.fake.FakeEntityDamageByEntityEvent;
+import com.gmail.nossr50.events.fake.FakeEntityDamageEvent;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.party.PartyManager;
+import com.gmail.nossr50.runnables.BleedTimer;
+import com.gmail.nossr50.runnables.GainXp;
+import com.gmail.nossr50.skills.acrobatics.AcrobaticsManager;
+import com.gmail.nossr50.skills.archery.ArcheryManager;
+import com.gmail.nossr50.skills.axes.AxeManager;
+import com.gmail.nossr50.skills.swords.Swords;
+import com.gmail.nossr50.skills.swords.SwordsManager;
+import com.gmail.nossr50.skills.taming.TamingManager;
+import com.gmail.nossr50.skills.unarmed.UnarmedManager;
+import com.gmail.nossr50.util.ItemChecks;
+import com.gmail.nossr50.util.Misc;
+import com.gmail.nossr50.util.Permissions;
+import com.gmail.nossr50.util.Users;
+
+public class Combat {
+    private static Config configInstance = Config.getInstance();
+
+    /**
+     * Apply combat modifiers and process and XP gain.
+     *
+     * @param event The event to run the combat checks on.
+     */
+    public static void combatChecks(EntityDamageByEntityEvent event) {
+        if (event.getDamage() == 0 || event.getEntity().isDead()) {
+            return;
+        }
+
+        Entity damager = event.getDamager();
+        LivingEntity target = (LivingEntity) event.getEntity();
+
+        boolean targetIsPlayer = (target.getType() == EntityType.PLAYER);
+        boolean targetIsTamedPet = (target instanceof Tameable) ? ((Tameable) target).isTamed() : false;
+
+        switch (damager.getType()) {
+        case PLAYER:
+            Player attacker = (Player) event.getDamager();
+            ItemStack itemInHand = attacker.getItemInHand();
+
+            if (ItemChecks.isSword(itemInHand)) {
+                if (targetIsPlayer || targetIsTamedPet) {
+                    if (!configInstance.getSwordsPVP()) {
+                        return;
+                    }
+                }
+                else if (!configInstance.getSwordsPVE()) {
+                    return;
+                }
+
+                Skills.abilityCheck(attacker, SkillType.SWORDS);
+
+                SwordsManager swordsManager = new SwordsManager(attacker);
+                swordsManager.bleedCheck(target);
+                swordsManager.serratedStrikes(target, event.getDamage());
+
+                startGainXp(attacker, swordsManager.getProfile(), target, SkillType.SWORDS);
+            }
+            else if (ItemChecks.isAxe(itemInHand) && Permissions.axes(attacker)) {
+                if (targetIsPlayer || targetIsTamedPet) {
+                    if (!configInstance.getAxesPVP()) {
+                        return;
+                    }
+                }
+                else if (!configInstance.getAxesPVE()) {
+                    return;
+                }
+
+                Skills.abilityCheck(attacker, SkillType.AXES);
+
+                AxeManager axeManager = new AxeManager(attacker);
+                axeManager.bonusDamage(event);
+                axeManager.criticalHitCheck(event);
+                axeManager.impact(event);
+                axeManager.skullSplitter(event);
+
+                startGainXp(attacker, axeManager.getProfile(), target, SkillType.AXES);
+            }
+            else if (itemInHand.getType() == Material.AIR && Permissions.unarmed(attacker)) {
+                if (targetIsPlayer || targetIsTamedPet) {
+                    if (!configInstance.getUnarmedPVP()) {
+                        return;
+                    }
+                }
+                else if (!configInstance.getUnarmedPVE()) {
+                    return;
+                }
+
+                Skills.abilityCheck(attacker, SkillType.UNARMED);
+
+                UnarmedManager unarmedManager = new UnarmedManager(attacker);
+
+                unarmedManager.bonusDamage(event);
+
+                if (unarmedManager.getProfile().getAbilityMode(AbilityType.BERSERK) && Permissions.berserk(attacker)) {
+                    event.setDamage((int) (event.getDamage() * 1.5));
+                }
+
+                if (targetIsPlayer) {
+                    unarmedManager.disarmCheck((Player) target);
+                }
+
+                startGainXp(attacker, unarmedManager.getProfile(), target, SkillType.UNARMED);
+            }
+            else if (itemInHand.getType() == Material.BONE && target instanceof Tameable) {
+                TamingManager tamingManager = new TamingManager(attacker);
+                tamingManager.beastLore(target);
+                event.setCancelled(true);
+            }
+
+            break;
+
+        case WOLF:
+            Wolf wolf = (Wolf) damager;
+
+            if (wolf.isTamed() && wolf.getOwner() instanceof Player) {
+                Player master = (Player) wolf.getOwner();
+
+                if (targetIsPlayer || targetIsTamedPet) {
+                    if (!configInstance.getTamingPVP()) {
+                        return;
+                    }
+                }
+                else if (!configInstance.getTamingPVE()) {
+                    return;
+                }
+
+                TamingManager tamingManager = new TamingManager(master);
+
+                tamingManager.fastFoodService(wolf, event.getDamage());
+                tamingManager.sharpenedClaws(event);
+                tamingManager.gore(event);
+
+                startGainXp(master, Users.getProfile(master), target, SkillType.TAMING);
+            }
+
+            break;
+
+        case ARROW:
+            LivingEntity shooter = ((Arrow) damager).getShooter();
+
+            if (shooter == null || shooter.getType() != EntityType.PLAYER) {
+                break;
+            }
+
+            if (targetIsPlayer || targetIsTamedPet) {
+                if (!configInstance.getArcheryPVP()) {
+                    return;
+                }
+            }
+            else if (!configInstance.getArcheryPVE()) {
+                return;
+            }
+
+            archeryCheck((Player) shooter, target, event);
+            break;
+
+        default:
+            break;
+        }
+
+        if (targetIsPlayer) {
+            Player player = (Player) target;
+
+            AcrobaticsManager acroManager = new AcrobaticsManager(player);
+            SwordsManager swordsManager = new SwordsManager(player);
+
+            if (damager.getType() == EntityType.PLAYER) {
+                if (configInstance.getSwordsPVP()) {
+                    swordsManager.counterAttackChecks((LivingEntity) damager, event.getDamage());
+                }
+
+                if (configInstance.getAcrobaticsPVP()) {
+                    acroManager.dodgeCheck(event);
+                }
+            }
+            else {
+                if (configInstance.getSwordsPVE() && damager instanceof LivingEntity) {
+                    swordsManager.counterAttackChecks((LivingEntity) damager, event.getDamage());
+                }
+
+                if (configInstance.getAcrobaticsPVE()) {
+                    if (damager instanceof LightningStrike && configInstance.getDodgeLightningDisabled()) {
+                        return;
+                    }
+
+                    acroManager.dodgeCheck(event);
+                }
+            }
+        }
+    }
+
+    /**
+     * Process archery abilities.
+     *
+     * @param shooter The player shooting
+     * @param target The defending entity
+     * @param event The event to run the archery checks on.
+     */
+    public static void archeryCheck(Player shooter, LivingEntity target, EntityDamageByEntityEvent event) {
+        if (target instanceof Player) {
+            Player defender = (Player) target;
+
+            if (defender.getItemInHand().getType().equals(Material.AIR)) {
+                if (configInstance.getUnarmedPVP()) {
+                    UnarmedManager unarmedManager = new UnarmedManager(defender);
+                    unarmedManager.deflectCheck(event);
+                }
+            }
+        }
+
+        ArcheryManager archeryManager = new ArcheryManager(shooter);
+
+        archeryManager.skillShot(event);
+
+        if (target instanceof Player) {
+            archeryManager.dazeCheck((Player) target, event);
+        }
+
+        if (!(shooter.getItemInHand().containsEnchantment(Enchantment.ARROW_INFINITE))) {
+            archeryManager.trackArrows(target);
+        }
+
+        if (target != shooter) {
+            PlayerProfile profile = Users.getProfile(shooter);
+            startGainXp(shooter, profile, target, SkillType.ARCHERY);
+        }
+    }
+
+    /**
+     * Attempt to damage target for value dmg with reason CUSTOM
+     *
+     * @param target LivingEntity which to attempt to damage
+     * @param dmg Amount of damage to attempt to do
+     */
+    public static void dealDamage(LivingEntity target, int dmg) {
+        dealDamage(target, dmg, EntityDamageEvent.DamageCause.CUSTOM);
+    }
+
+    /**
+     * Attempt to damage target for value dmg with reason cause
+     *
+     * @param target LivingEntity which to attempt to damage
+     * @param dmg Amount of damage to attempt to do
+     * @param cause DamageCause to pass to damage event
+     */
+    private static void dealDamage(LivingEntity target, int dmg, DamageCause cause) {
+        if (configInstance.getEventCallbackEnabled()) {
+            EntityDamageEvent ede = new FakeEntityDamageEvent(target, cause, dmg);
+            mcMMO.p.getServer().getPluginManager().callEvent(ede);
+
+            if (ede.isCancelled()) {
+                return;
+            }
+
+            target.damage(ede.getDamage());
+        }
+        else {
+            target.damage(dmg);
+        }
+    }
+
+    /**
+     * Attempt to damage target for value dmg with reason ENTITY_ATTACK with damager attacker
+     *
+     * @param target LivingEntity which to attempt to damage
+     * @param dmg Amount of damage to attempt to do
+     * @param attacker Player to pass to event as damager
+     */
+    private static void dealDamage(LivingEntity target, int dmg, Player attacker) {
+        if (configInstance.getEventCallbackEnabled()) {
+            EntityDamageEvent ede = new FakeEntityDamageByEntityEvent(attacker, target, EntityDamageEvent.DamageCause.ENTITY_ATTACK, dmg);
+            mcMMO.p.getServer().getPluginManager().callEvent(ede);
+
+            if (ede.isCancelled()) {
+                return;
+            }
+
+            target.damage(ede.getDamage());
+        }
+        else {
+            target.damage(dmg);
+        }
+    }
+
+    /**
+     * Apply Area-of-Effect ability actions.
+     *
+     * @param attacker The attacking player
+     * @param target The defending entity
+     * @param damage The initial damage amount
+     * @param type The type of skill being used
+     */
+    public static void applyAbilityAoE(Player attacker, LivingEntity target, int damage, SkillType type) {
+        int numberOfTargets = Misc.getTier(attacker.getItemInHand()); //The higher the weapon tier, the more targets you hit
+        int damageAmount = damage;
+
+        if (damageAmount < 1) {
+            damageAmount = 1;
+        }
+
+        for (Entity entity : target.getNearbyEntities(2.5, 2.5, 2.5)) {
+            if (entity instanceof Player) {
+                if (Misc.isNPC((Player) entity)) {
+                    continue;
+                }
+            }
+
+            if (!(entity instanceof LivingEntity)) {
+                continue;
+            }
+
+            if (numberOfTargets <= 0) {
+                break;
+            }
+
+            if (!shouldBeAffected(attacker, entity)) {
+                continue;
+            }
+
+            PlayerAnimationEvent armswing = new PlayerAnimationEvent(attacker);
+            mcMMO.p.getServer().getPluginManager().callEvent(armswing);
+
+            switch (type) {
+            case SWORDS:
+                if (entity instanceof Player) {
+                    ((Player) entity).sendMessage(LocaleLoader.getString("Swords.Combat.SS.Struck"));
+                }
+
+                BleedTimer.add((LivingEntity) entity, Swords.serratedStrikesBleedTicks);
+
+                break;
+
+            case AXES:
+                if (entity instanceof Player) {
+                    ((Player) entity).sendMessage(LocaleLoader.getString("Axes.Combat.Cleave.Struck"));
+                }
+
+                break;
+
+            default:
+                break;
+            }
+
+            dealDamage((LivingEntity) entity, damageAmount, attacker);
+            numberOfTargets--;
+        }
+    }
+
+    /**
+     * Start the task that gives combat XP.
+     *
+     * @param attacker The attacking player
+     * @param profile The player's PlayerProfile
+     * @param target The defending entity
+     * @param skillType The skill being used
+     */
+    public static void startGainXp(Player attacker, PlayerProfile profile, LivingEntity target, SkillType skillType) {
+        double baseXP = 0;
+
+        if (target instanceof Player) {
+            if (!configInstance.getExperienceGainsPlayerVersusPlayerEnabled()) {
+                return;
+            }
+
+            Player defender = (Player) target;
+
+            if (System.currentTimeMillis() >= Users.getProfile(defender).getRespawnATS() + 5) {
+                baseXP = 20 * configInstance.getPlayerVersusPlayerXP();
+            }
+        }
+        else if (!mcMMO.placeStore.isSpawnedMob(target)) {
+            if (target instanceof Animals && !mcMMO.placeStore.isSpawnedPet(target)) {
+                baseXP = configInstance.getAnimalsXP();
+            }
+            else {
+                EntityType type = target.getType();
+
+                switch (type) {
+                case BAT:
+                    baseXP = configInstance.getAnimalsXP();
+                    break;
+
+                case BLAZE:
+                    baseXP = configInstance.getBlazeXP();
+                    break;
+
+                case CAVE_SPIDER:
+                    baseXP = configInstance.getCaveSpiderXP();
+                    break;
+
+                case CREEPER:
+                    baseXP = configInstance.getCreeperXP();
+                    break;
+
+                case ENDER_DRAGON:
+                    baseXP = configInstance.getEnderDragonXP();
+                    break;
+
+                case ENDERMAN:
+                    baseXP = configInstance.getEndermanXP();
+                    break;
+
+                case GHAST:
+                    baseXP = configInstance.getGhastXP();
+                    break;
+
+                case GIANT:
+                    baseXP = configInstance.getGiantXP();
+                    break;
+
+                case MAGMA_CUBE:
+                    baseXP = configInstance.getMagmaCubeXP();
+                    break;
+
+                case IRON_GOLEM:
+                    if (!((IronGolem) target).isPlayerCreated()) {
+                        baseXP = configInstance.getIronGolemXP();
+                    }
+
+                    break;
+
+                case PIG_ZOMBIE:
+                    baseXP = configInstance.getPigZombieXP();
+                    break;
+
+                case SILVERFISH:
+                    baseXP = configInstance.getSilverfishXP();
+                    break;
+
+                case SKELETON:
+                    switch(((Skeleton) target).getSkeletonType()) {
+                    case WITHER:
+                        baseXP = configInstance.getWitherSkeletonXP();
+                        break;
+                    default:
+                        baseXP = configInstance.getSkeletonXP();
+                        break;
+                    }
+                case SLIME:
+                    baseXP = configInstance.getSlimeXP();
+                    break;
+
+                case SPIDER:
+                    baseXP = configInstance.getSpiderXP();
+                    break;
+
+                case WITCH:
+                    baseXP = configInstance.getWitchXP();
+                    break;
+
+                case WITHER:
+                    baseXP = configInstance.getWitherXP();
+                    break;
+
+                case ZOMBIE:
+                    baseXP = configInstance.getZombieXP();
+                    break;
+
+                default:
+                    break;
+                }
+            }
+
+            baseXP *= 10;
+        }
+
+        if (baseXP != 0) {
+            mcMMO.p.getServer().getScheduler().scheduleSyncDelayedTask(mcMMO.p, new GainXp(attacker, profile, skillType, baseXP, target), 0);
+        }
+    }
+
+    /**
+     * Check to see if the given LivingEntity should be affected by a combat ability.
+     *
+     * @param player The attacking Player
+     * @param livingEntity The defending LivingEntity
+     * @return true if the Entity should be damaged, false otherwise.
+     */
+    public static boolean shouldBeAffected(Player player, Entity entity) {
+        if (entity instanceof Player) {
+            Player defender = (Player) entity;
+
+            if (!defender.getWorld().getPVP()) {
+                return false;
+            }
+
+            if (defender == player) {
+                return false;
+            }
+
+            if (PartyManager.getInstance().inSameParty(player, defender)) {
+                return false;
+            }
+
+            if (Users.getProfile(defender).getGodMode()) {
+                return false;
+            }
+
+            //It may seem a bit redundant but we need a check here to prevent bleed from being applied in applyAbilityAoE()
+            EntityDamageEvent ede = new FakeEntityDamageByEntityEvent(player, entity, EntityDamageEvent.DamageCause.ENTITY_ATTACK, 1);
+            mcMMO.p.getServer().getPluginManager().callEvent(ede);
+
+            if (ede.isCancelled()) {
+                return false;
+            }
+        }
+        else if (entity instanceof Tameable) {
+            Tameable pet = (Tameable) entity;
+
+            if (Misc.isFriendlyPet(player, pet)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+}

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

@@ -0,0 +1,174 @@
+package com.gmail.nossr50.skills;
+
+import java.text.DecimalFormat;
+
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import com.gmail.nossr50.commands.CommandHelper;
+import com.gmail.nossr50.datatypes.PlayerProfile;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.util.Misc;
+import com.gmail.nossr50.util.Page;
+import com.gmail.nossr50.util.Permissions;
+import com.gmail.nossr50.util.Users;
+
+public abstract class SkillCommand implements CommandExecutor {
+    private SkillType skill;
+    private String skillString;
+    private String permission;
+
+    protected Player player;
+    protected PlayerProfile profile;
+    protected float skillValue;
+    protected boolean isLucky;
+    protected boolean hasEndurance;
+
+    protected DecimalFormat percent = new DecimalFormat("##0.00%");
+
+    public SkillCommand(SkillType skill) {
+        this.skill = skill;
+        this.skillString = Misc.getCapitalized(skill.toString());
+        this.permission = "mcmmo.skills." + skillString.toLowerCase();
+    }
+
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        if (CommandHelper.noConsoleUsage(sender)) {
+            return true;
+        }
+
+        if (CommandHelper.noCommandPermissions(sender, permission)) {
+            return true;
+        }
+
+        player = (Player) sender;
+        profile = Users.getProfile(player);
+
+        if (profile == null) {
+            sender.sendMessage(LocaleLoader.getString("Commands.DoesNotExist"));
+            return true;
+        }
+
+        skillValue = profile.getSkillLevel(skill);
+        isLucky = Permissions.lucky(player, skill);
+        hasEndurance = (Permissions.activationTwelve(player) || Permissions.activationEight(player) || Permissions.activationFour(player));
+
+        dataCalculations();
+        permissionsCheck();
+
+        player.sendMessage(LocaleLoader.getString("Skills.Header", new Object[] { LocaleLoader.getString(skillString + ".SkillName") }));
+        player.sendMessage(LocaleLoader.getString("Commands.XPGain", new Object[] { LocaleLoader.getString("Commands.XPGain." + skillString) }));
+        player.sendMessage(LocaleLoader.getString("Effects.Level", new Object[] { profile.getSkillLevel(skill), profile.getSkillXpLevel(skill), profile.getXpToLevel(skill) }));
+
+        if (effectsHeaderPermissions()) {
+            player.sendMessage(LocaleLoader.getString("Skills.Header", new Object[] { LocaleLoader.getString("Effects.Effects") }));
+        }
+
+        effectsDisplay();
+
+        if (statsHeaderPermissions()) {
+            player.sendMessage(LocaleLoader.getString("Skills.Header", new Object[] { LocaleLoader.getString("Commands.Stats.Self") }));
+        }
+
+        statsDisplay();
+
+        Page.grabGuidePageForSkill(skill, player, args);
+
+        return true;
+    }
+
+    protected String calculateRank(int maxLevel, int rankChangeLevel) {
+        if (skillValue >= maxLevel) {
+            return String.valueOf(maxLevel / rankChangeLevel);
+        }
+
+        return String.valueOf((int) (skillValue / rankChangeLevel));
+    }
+
+    protected String[] calculateAbilityDisplayValues(double chance) {
+        if (isLucky) {
+            double luckyChance = chance * 1.3333D;
+
+            if (luckyChance >= 100D) {
+                return new String[] { percent.format(chance / 100.0D), percent.format(1.0D) };
+            }
+
+            return new String[] { percent.format(chance / 100.0D), percent.format(luckyChance / 100.0D) };
+        }
+
+        return new String[] { percent.format(chance / 100.0D), null };
+    }
+
+    protected String[] calculateAbilityDisplayValues(int maxBonusLevel, double maxChance) {
+        double abilityChance;
+
+        if (skillValue >= maxBonusLevel) {
+            abilityChance = maxChance;
+        }
+        else {
+            abilityChance = (maxChance / maxBonusLevel) * skillValue;
+        }
+
+        if (isLucky) {
+            double luckyChance = abilityChance * 1.3333D;
+
+            if (luckyChance >= 100D) {
+                return new String[] { percent.format(abilityChance / 100.0D), percent.format(1.0D) };
+            }
+
+            return new String[] { percent.format(abilityChance / 100.0D), percent.format(luckyChance / 100.0D) };
+        }
+
+        return new String[] { percent.format(abilityChance / 100.0D), null };
+    }
+
+    protected String[] calculateLengthDisplayValues() {
+        int maxLength = skill.getAbility().getMaxTicks();
+        int length = 2 + (int) (skillValue / Misc.abilityLengthIncreaseLevel);
+        int enduranceLength = 0;
+
+        if (Permissions.activationTwelve(player)) {
+            enduranceLength = length + 12;
+        }
+        else if (Permissions.activationEight(player)) {
+            enduranceLength = length + 8;
+        }
+        else if (Permissions.activationFour(player)) {
+            enduranceLength = length + 4;
+        }
+
+        if (maxLength != 0) {
+            if (length > maxLength) {
+                length = maxLength;
+            }
+
+            if (enduranceLength > maxLength) {
+                enduranceLength = maxLength;
+            }
+        }
+
+        return new String[] { String.valueOf(length), String.valueOf(enduranceLength) };
+    }
+
+    protected void luckyEffectsDisplay() {
+        if (isLucky) {
+            String perkPrefix = LocaleLoader.getString("MOTD.PerksPrefix");
+            player.sendMessage(perkPrefix + LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Perks.lucky.name"), LocaleLoader.getString("Perks.lucky.desc", new Object[] { Skills.localizeSkillName(skill) }) }));
+        }
+    }
+
+    protected abstract void dataCalculations();
+
+    protected abstract void permissionsCheck();
+
+    protected abstract boolean effectsHeaderPermissions();
+
+    protected abstract void effectsDisplay();
+
+    protected abstract boolean statsHeaderPermissions();
+
+    protected abstract void statsDisplay();
+}

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

@@ -3,7 +3,6 @@ package com.gmail.nossr50.skills;
 import org.bukkit.entity.Player;
 
 import com.gmail.nossr50.datatypes.PlayerProfile;
-import com.gmail.nossr50.datatypes.SkillType;
 import com.gmail.nossr50.util.Misc;
 import com.gmail.nossr50.util.Permissions;
 import com.gmail.nossr50.util.Users;

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

@@ -0,0 +1,145 @@
+package com.gmail.nossr50.skills;
+
+import org.bukkit.entity.Player;
+
+import com.gmail.nossr50.config.Config;
+import com.gmail.nossr50.util.Permissions;
+import com.gmail.nossr50.util.Users;
+
+public enum SkillType {
+    ACROBATICS(Config.getInstance().getLevelCapAcrobatics(), Config.getInstance().getFormulaMultiplierAcrobatics()),
+    ALL, //This one is just for convenience
+    ARCHERY(Config.getInstance().getLevelCapArchery(), Config.getInstance().getFormulaMultiplierArchery()),
+    AXES(AbilityType.SKULL_SPLIITER, Config.getInstance().getLevelCapAxes(), ToolType.AXE, Config.getInstance().getFormulaMultiplierAxes()),
+    EXCAVATION(AbilityType.GIGA_DRILL_BREAKER, Config.getInstance().getLevelCapExcavation(), ToolType.SHOVEL, Config.getInstance().getFormulaMultiplierExcavation()),
+    FISHING(Config.getInstance().getLevelCapFishing(), Config.getInstance().getFormulaMultiplierFishing()),
+    HERBALISM(AbilityType.GREEN_TERRA, Config.getInstance().getLevelCapHerbalism(), ToolType.HOE, Config.getInstance().getFormulaMultiplierHerbalism()),
+    MINING(AbilityType.SUPER_BREAKER, Config.getInstance().getLevelCapMining(), ToolType.PICKAXE, Config.getInstance().getFormulaMultiplierMining()),
+    REPAIR(Config.getInstance().getLevelCapRepair(), Config.getInstance().getFormulaMultiplierRepair()),
+    SWORDS(AbilityType.SERRATED_STRIKES, Config.getInstance().getLevelCapSwords(), ToolType.SWORD, Config.getInstance().getFormulaMultiplierSwords()),
+    TAMING(Config.getInstance().getLevelCapTaming(), Config.getInstance().getFormulaMultiplierTaming()),
+    UNARMED(AbilityType.BERSERK, Config.getInstance().getLevelCapUnarmed(), ToolType.FISTS, Config.getInstance().getFormulaMultiplierUnarmed()),
+    WOODCUTTING(AbilityType.TREE_FELLER, Config.getInstance().getLevelCapWoodcutting(), ToolType.AXE, Config.getInstance().getFormulaMultiplierWoodcutting());
+
+    private AbilityType ability;
+    private int maxLevel;
+    private ToolType tool;
+    private double xpModifier;
+
+    private SkillType() {
+        this.ability = null;
+        this.maxLevel = 0;
+        this.tool = null;
+        this.xpModifier = 0;
+    }
+
+    private SkillType(AbilityType ability, int maxLevel, ToolType tool, double xpModifier) {
+        this.ability = ability;
+        this.maxLevel = maxLevel;
+        this.tool = tool;
+        this.xpModifier = xpModifier;
+    }
+
+    private SkillType(int maxLevel, double xpModifier) {
+        this(null, maxLevel, null, xpModifier);
+    }
+
+    public AbilityType getAbility() {
+        return ability;
+    }
+
+    /**
+     * Get the max level of this skill.
+     *
+     * @return the max level of this skill
+     */
+    public int getMaxLevel() {
+        if (maxLevel > 0) {
+            return maxLevel;
+        }
+
+        return Integer.MAX_VALUE;
+    }
+
+    public ToolType getTool() {
+        return tool;
+    }
+
+    /**
+     * Get the base permissions associated with this skill.
+     *
+     * @param player The player to check the permissions for
+     * @return true if the player has permissions, false otherwise
+     */
+    public boolean getPermissions(Player player) {
+        switch (this) {
+        case ACROBATICS:
+            return Permissions.acrobatics(player);
+
+        case ARCHERY:
+            return Permissions.archery(player);
+
+        case AXES:
+            return Permissions.axes(player);
+
+        case EXCAVATION:
+            return Permissions.excavation(player);
+
+        case FISHING:
+            return Permissions.fishing(player);
+
+        case HERBALISM:
+            return Permissions.herbalism(player);
+
+        case MINING:
+            return Permissions.mining(player);
+
+        case REPAIR:
+            return Permissions.repair(player);
+
+        case SWORDS:
+            return Permissions.swords(player);
+
+        case TAMING:
+            return Permissions.taming(player);
+
+        case UNARMED:
+            return Permissions.unarmed(player);
+
+        case WOODCUTTING:
+            return Permissions.woodcutting(player);
+
+        default:
+            return false;
+        }
+    }
+
+    public double getXpModifier() {
+        return xpModifier;
+    }
+
+    public static SkillType getSkill(String skillName) {
+        if (skillName.equalsIgnoreCase("powerlevel") || skillName.equalsIgnoreCase("all")) {
+            return SkillType.ALL;
+        }
+
+        for (SkillType type : SkillType.values()) {
+            if (type.name().equalsIgnoreCase(skillName)) {
+                return type;
+            }
+        }
+
+        System.out.println("[DEBUG] Invalid mcMMO skill (" + skillName + ")");
+        return null;
+    }
+
+    /**
+     * Get the skill level for this skill.
+     *
+     * @param player The player to check
+     * @return
+     */
+    public int getSkillLevel(Player player) {
+        return Users.getProfile(player).getSkillLevel(this);
+    }
+}

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

@@ -0,0 +1,518 @@
+package com.gmail.nossr50.skills;
+
+import org.bukkit.block.Block;
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.getspout.spoutapi.SpoutManager;
+import org.getspout.spoutapi.player.SpoutPlayer;
+
+import com.gmail.nossr50.mcMMO;
+import com.gmail.nossr50.config.AdvancedConfig;
+import com.gmail.nossr50.config.Config;
+import com.gmail.nossr50.datatypes.PlayerProfile;
+import com.gmail.nossr50.events.experience.McMMOPlayerLevelUpEvent;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.spout.SpoutConfig;
+import com.gmail.nossr50.spout.SpoutStuff;
+import com.gmail.nossr50.util.Misc;
+import com.gmail.nossr50.util.ModChecks;
+import com.gmail.nossr50.util.Permissions;
+import com.gmail.nossr50.util.Users;
+
+public class Skills {
+    static AdvancedConfig advancedConfig = AdvancedConfig.getInstance();
+    public static int abilityLengthIncreaseLevel = advancedConfig.getAbilityLength();
+
+    /**
+     * Checks to see if the cooldown for an item or ability is expired.
+     *
+     * @param oldTime The time the ability or item was last used
+     * @param cooldown The amount of time that must pass between uses
+     * @param player The player whose cooldown is being checked
+     * @return true if the cooldown is over, false otherwise
+     */
+    public static boolean cooldownOver(long oldTime, int cooldown, Player player) {
+        long currentTime = System.currentTimeMillis();
+        int adjustedCooldown = cooldown;
+
+        //Reduced Cooldown Donor Perks
+        if (Permissions.cooldownsHalved(player)) {
+            adjustedCooldown = (int) (adjustedCooldown * 0.5);
+        }
+        else if (Permissions.cooldownsThirded(player)) {
+            adjustedCooldown = (int) (adjustedCooldown * 0.66);
+        }
+        else if (Permissions.cooldownsQuartered(player)) {
+            adjustedCooldown = (int) (adjustedCooldown * 0.75);
+        }
+
+        if (currentTime - oldTime >= (adjustedCooldown * Misc.TIME_CONVERSION_FACTOR)) {
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Calculate the time remaining until the cooldown expires.
+     *
+     * @param deactivatedTimeStamp Time of deactivation
+     * @param cooldown The length of the cooldown
+     * @return the number of seconds remaining before the cooldown expires
+     */
+    public static int calculateTimeLeft(long deactivatedTimeStamp, int cooldown, Player player) {
+        int adjustedCooldown = cooldown;
+
+        //Reduced Cooldown Donor Perks
+        if (Permissions.cooldownsHalved(player)) {
+            adjustedCooldown = (int) (adjustedCooldown * 0.5);
+        }
+        else if (Permissions.cooldownsThirded(player)) {
+            adjustedCooldown = (int) (adjustedCooldown * 0.66);
+        }
+        else if (Permissions.cooldownsQuartered(player)) {
+            adjustedCooldown = (int) (adjustedCooldown * 0.75);
+        }
+
+        return (int) (((deactivatedTimeStamp + (adjustedCooldown * Misc.TIME_CONVERSION_FACTOR)) - System.currentTimeMillis()) / Misc.TIME_CONVERSION_FACTOR);
+    }
+
+    /**
+     * Sends a message to the player when the cooldown expires.
+     *
+     * @param player The player to send a message to
+     * @param profile The profile of the player
+     * @param ability The ability to watch cooldowns for
+     */
+    public static void watchCooldown(Player player, PlayerProfile profile, AbilityType ability) {
+        if (player == null || profile == null || ability == null)
+            return;
+
+        if (!profile.getAbilityInformed(ability) && cooldownOver(profile.getSkillDATS(ability) * Misc.TIME_CONVERSION_FACTOR, ability.getCooldown(), player)) {
+            profile.setAbilityInformed(ability, true);
+            player.sendMessage(ability.getAbilityRefresh());
+        }
+    }
+
+    /**
+     * Process activating abilities & readying the tool.
+     *
+     * @param player The player using the ability
+     * @param skill The skill the ability is tied to
+     */
+    public static void activationCheck(Player player, SkillType skill) {
+        if (Config.getInstance().getAbilitiesOnlyActivateWhenSneaking() && !player.isSneaking()) {
+            return;
+        }
+
+        PlayerProfile profile = Users.getProfile(player);
+        AbilityType ability = skill.getAbility();
+        ToolType tool = skill.getTool();
+        ItemStack inHand = player.getItemInHand();
+
+        if (ModChecks.isCustomTool(inHand) && !ModChecks.getToolFromItemStack(inHand).isAbilityEnabled()) {
+            return;
+        }
+
+        /* Check if any abilities are active */
+        if (profile == null) {
+            return;
+        }
+
+        if (!profile.getAbilityUse()) {
+            return;
+        }
+
+        for (AbilityType x : AbilityType.values()) {
+            if (profile.getAbilityMode(x)) {
+                return;
+            }
+        }
+
+        /* Woodcutting & Axes need to be treated differently.
+         * Basically the tool always needs to ready and we check to see if the cooldown is over when the user takes action
+         */
+        if (ability.getPermissions(player) && tool.inHand(inHand) && !profile.getToolPreparationMode(tool)) {
+            if (skill != SkillType.WOODCUTTING && skill != SkillType.AXES) {
+                if (!profile.getAbilityMode(ability) && !cooldownOver(profile.getSkillDATS(ability) * Misc.TIME_CONVERSION_FACTOR, ability.getCooldown(), player)) {
+                    player.sendMessage(LocaleLoader.getString("Skills.TooTired", new Object[] { calculateTimeLeft(profile.getSkillDATS(ability) * Misc.TIME_CONVERSION_FACTOR, ability.getCooldown(), player) }));
+                    return;
+                }
+            }
+
+            if (Config.getInstance().getAbilityMessagesEnabled()) {
+                player.sendMessage(tool.getRaiseTool());
+            }
+
+            profile.setToolPreparationATS(tool, System.currentTimeMillis());
+            profile.setToolPreparationMode(tool, true);
+        }
+    }
+
+    /**
+     * Monitors various things relating to skill abilities.
+     *
+     * @param player The player using the skill
+     * @param profile The profile of the player
+     * @param curTime The current system time
+     * @param skill The skill being monitored
+     */
+    public static void monitorSkill(Player player, PlayerProfile profile, long curTime, SkillType skill) {
+        final int FOUR_SECONDS = 4000;
+
+        ToolType tool = skill.getTool();
+        AbilityType ability = skill.getAbility();
+
+        if (profile == null) {
+            return;
+        }
+
+        if (profile.getToolPreparationMode(tool) && curTime - (profile.getToolPreparationATS(tool) * Misc.TIME_CONVERSION_FACTOR) >= FOUR_SECONDS) {
+            profile.setToolPreparationMode(tool, false);
+
+            if (Config.getInstance().getAbilityMessagesEnabled()) {
+                player.sendMessage(tool.getLowerTool());
+            }
+        }
+
+        if (ability.getPermissions(player)) {
+            if (profile.getAbilityMode(ability) && (profile.getSkillDATS(ability) * Misc.TIME_CONVERSION_FACTOR) <= curTime) {
+                profile.setAbilityMode(ability, false);
+                profile.setAbilityInformed(ability, false);
+                player.sendMessage(ability.getAbilityOff());
+
+                Misc.sendSkillMessage(player, ability.getAbilityPlayerOff(player));
+            }
+        }
+    }
+
+    /**
+     * Check the XP of a skill.
+     *
+     * @param skillType The skill to check
+     * @param player The player whose skill to check
+     * @param profile The profile of the player whose skill to check
+     */
+    public static void xpCheckSkill(SkillType skillType, Player player, PlayerProfile profile) {
+        int skillups = 0;
+
+        if (profile.getSkillXpLevel(skillType) >= profile.getXpToLevel(skillType)) {
+
+            while (profile.getSkillXpLevel(skillType) >= profile.getXpToLevel(skillType)) {
+                if ((skillType.getMaxLevel() >= profile.getSkillLevel(skillType) + 1) && (Misc.getPowerLevelCap() >= Users.getPlayer(player).getPowerLevel() + 1)) {
+                    profile.removeXP(skillType, profile.getXpToLevel(skillType));
+                    skillups++;
+                    profile.skillUp(skillType, 1);
+
+                    McMMOPlayerLevelUpEvent eventToFire = new McMMOPlayerLevelUpEvent(player, skillType);
+                    mcMMO.p.getServer().getPluginManager().callEvent(eventToFire);
+                }
+                else {
+                    profile.addLevels(skillType, 0);
+                }
+            }
+
+            String capitalized = Misc.getCapitalized(skillType.toString());
+
+            /* Spout Stuff */
+            if (mcMMO.spoutEnabled) {
+                SpoutPlayer spoutPlayer = SpoutManager.getPlayer(player);
+
+                if (spoutPlayer != null && spoutPlayer.isSpoutCraftEnabled()) {
+                    SpoutStuff.levelUpNotification(skillType, spoutPlayer);
+
+                    /* Update custom titles */
+                    if (SpoutConfig.getInstance().getShowPowerLevel()) {
+                        spoutPlayer.setTitle(LocaleLoader.getString("Spout.Title", new Object[] {spoutPlayer.getName(), Users.getPlayer(player).getPowerLevel()} ));
+                    }
+                }
+                else {
+                    player.sendMessage(LocaleLoader.getString(capitalized + ".Skillup", new Object[] {String.valueOf(skillups), profile.getSkillLevel(skillType)}));
+                }
+            }
+            else {
+                player.sendMessage(LocaleLoader.getString(capitalized + ".Skillup", new Object[] {String.valueOf(skillups), profile.getSkillLevel(skillType)}));
+            }
+        }
+
+        if (mcMMO.spoutEnabled) {
+            SpoutPlayer spoutPlayer = (SpoutPlayer) player;
+
+            if (spoutPlayer != null && spoutPlayer.isSpoutCraftEnabled()) {
+                if (SpoutConfig.getInstance().getXPBarEnabled()) {
+                    profile.getSpoutHud().updateXpBar();
+                }
+            }
+        }
+    }
+
+    /**
+     * Check XP of all skills.
+     *
+     * @param player The player to check XP for.
+     * @param profile The profile of the player whose skill to check
+     */
+    public static void xpCheckAll(Player player, PlayerProfile profile) {
+        for (SkillType skillType : SkillType.values()) {
+            //Don't want to do anything with this one
+            if (skillType == SkillType.ALL) {
+                continue;
+            }
+
+            xpCheckSkill(skillType, player, profile);
+        }
+    }
+
+    /**
+     * Get the skill represented by the given string
+     *
+     * @param skillName The name of the skill
+     * @return the SkillType if it exists, null otherwise
+     */
+    public static SkillType getSkillType(String skillName) {
+        for (SkillType x : SkillType.values()) {
+            if (x.toString().equals(skillName.toUpperCase())) {
+                return x;
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Checks if the given string represents a valid skill
+     *
+     * @param skillname The name of the skill to check
+     * @return true if this is a valid skill, false otherwise
+     */
+    public static boolean isSkill(String skillName) {
+        if (getSkillType(skillName) != null) {
+            return true;
+        }
+
+        return false;
+    }
+
+    public static boolean isLocalizedSkill(String skillName) {
+        for (SkillType skill : SkillType.values()) {
+            if (skillName.equalsIgnoreCase(LocaleLoader.getString(Misc.getCapitalized(skill.toString() + ".SkillName")))) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public static String translateLocalizedSkill(String skillName) {
+        for (SkillType skill : SkillType.values()) {
+            if (skillName.equalsIgnoreCase(LocaleLoader.getString(Misc.getCapitalized(skill.toString() + ".SkillName")))) {
+                return skill.toString();
+            }
+        }
+
+        return null;
+    }
+
+    public static String localizeSkillName(SkillType skill) {
+        return Misc.getCapitalized(LocaleLoader.getString(Misc.getCapitalized(skill.toString()) + ".SkillName"));
+    }
+
+    /**
+     * Check if the player has any combat skill permissions.
+     *
+     * @param player The player to check permissions for
+     * @return true if the player has combat skills, false otherwise
+     */
+    public static boolean hasCombatSkills(Player player) {
+        if (Permissions.axes(player)
+                || Permissions.archery(player)
+                || Permissions.swords(player)
+                || Permissions.taming(player)
+                || Permissions.unarmed(player)) {
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Check if the player has any gathering skill permissions.
+     *
+     * @param player The player to check permissions for
+     * @return true if the player has gathering skills, false otherwise
+     */
+    public static boolean hasGatheringSkills(Player player) {
+        if (Permissions.excavation(player)
+                || Permissions.fishing(player)
+                || Permissions.herbalism(player)
+                || Permissions.mining(player)
+                || Permissions.woodcutting(player)) {
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Check if the player has any misc skill permissions.
+     *
+     * @param player The player to check permissions for
+     * @return true if the player has misc skills, false otherwise
+     */
+    public static boolean hasMiscSkills(Player player) {
+        if (Permissions.acrobatics(player) || Permissions.repair(player)) {
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Handle tool durability loss from abilities.
+     *
+     * @param inHand The item to damage
+     * @param durabilityLoss The durability to remove from the item
+     */
+    public static void abilityDurabilityLoss(ItemStack inHand, int durabilityLoss) {
+        if (Config.getInstance().getAbilitiesDamageTools()) {
+            if (inHand.containsEnchantment(Enchantment.DURABILITY)) {
+                int level = inHand.getEnchantmentLevel(Enchantment.DURABILITY);
+                if (Misc.getRandom().nextInt(level + 1) > 0) {
+                    return;
+                }
+            }
+            inHand.setDurability((short) (inHand.getDurability() + durabilityLoss));
+        }
+    }
+
+    /**
+     * Check to see if an ability can be activated.
+     *
+     * @param player The player activating the ability
+     * @param type The skill the ability is based on
+     */
+    public static void abilityCheck(Player player, SkillType type) {
+        PlayerProfile profile = Users.getProfile(player);
+        if (profile == null) {
+            return;
+        }
+        ToolType tool = type.getTool();
+
+        if (!profile.getToolPreparationMode(tool)) {
+            return;
+        }
+
+        profile.setToolPreparationMode(tool, false);
+
+        AbilityType ability = type.getAbility();
+
+        /* Axes and Woodcutting are odd because they share the same tool.
+         * We show them the too tired message when they take action.
+         */
+        if (type == SkillType.WOODCUTTING || type == SkillType.AXES) {
+            if (!profile.getAbilityMode(ability) && !cooldownOver(profile.getSkillDATS(ability) * Misc.TIME_CONVERSION_FACTOR, ability.getCooldown(), player)) {
+                player.sendMessage(LocaleLoader.getString("Skills.TooTired", new Object[] { calculateTimeLeft(profile.getSkillDATS(ability) * Misc.TIME_CONVERSION_FACTOR, ability.getCooldown(), player) }));
+                return;
+            }
+        }
+
+        int ticks = 2 + (profile.getSkillLevel(type) / abilityLengthIncreaseLevel);
+
+        if (Permissions.activationTwelve(player)) {
+            ticks = ticks + 12;
+        }
+        else if (Permissions.activationEight(player)) {
+            ticks = ticks + 8;
+        }
+        else if (Permissions.activationFour(player)) {
+            ticks = ticks + 4;
+        }
+
+        int maxTicks = ability.getMaxTicks();
+
+        if (maxTicks != 0 && ticks > maxTicks) {
+            ticks = maxTicks;
+        }
+
+        if (!profile.getAbilityMode(ability) && cooldownOver(profile.getSkillDATS(ability), ability.getCooldown(), player)) {
+            player.sendMessage(ability.getAbilityOn());
+
+            Misc.sendSkillMessage(player, ability.getAbilityPlayer(player));
+
+            profile.setSkillDATS(ability, System.currentTimeMillis() + (ticks * Misc.TIME_CONVERSION_FACTOR));
+            profile.setAbilityMode(ability, true);
+        }
+    }
+
+    /**
+     * Check to see if ability should be triggered.
+     *
+     * @param player The player using the ability
+     * @param block The block modified by the ability
+     * @param ability The ability to check
+     * @return true if the ability should activate, false otherwise
+     */
+    public static boolean triggerCheck(Player player, Block block, AbilityType ability) {
+        boolean activate = true;
+
+        if (!ability.getPermissions(player)) {
+            activate = false;
+            return activate;
+        }
+
+        switch (ability) {
+        case BERSERK:
+        case GIGA_DRILL_BREAKER:
+        case SUPER_BREAKER:
+        case LEAF_BLOWER:
+            if (!ability.blockCheck(block)) {
+                activate = false;
+                break;
+            }
+
+            if (!Misc.blockBreakSimulate(block, player, true)) {
+                activate = false;
+                break;
+            }
+            break;
+
+        case GREEN_TERRA:
+            if (!ability.blockCheck(block)) {
+                activate = false;
+                break;
+            }
+            break;
+
+        default:
+            activate = false;
+            break;
+        }
+
+        return activate;
+    }
+
+    /**
+     * Handle the processing of XP gain from individual skills.
+     *
+     * @param player The player that gained XP
+     * @param profile The profile of the player gaining XP
+     * @param type The type of skill to gain XP from
+     * @param xp the amount of XP to gain
+     */
+    public static void xpProcessing(Player player, PlayerProfile profile, SkillType type, int xp) {
+        if (player == null)
+            return;
+
+        if (type.getPermissions(player)) {
+            if (Users.getPlayer(player) == null)
+                return;
+
+            if ((type.getMaxLevel() < profile.getSkillLevel(type) + 1) || (Misc.getPowerLevelCap() < Users.getPlayer(player).getPowerLevel() + 1))
+                return;
+
+            Users.getPlayer(player).addXP(type, xp);
+            xpCheckSkill(type, player, profile);
+        }
+    }
+}

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

@@ -0,0 +1,63 @@
+package com.gmail.nossr50.skills;
+
+import org.bukkit.Material;
+import org.bukkit.inventory.ItemStack;
+
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.util.ItemChecks;
+
+public enum ToolType {
+    AXE(LocaleLoader.getString("Axes.Ability.Lower"), LocaleLoader.getString("Axes.Ability.Ready")),
+    FISTS(LocaleLoader.getString("Unarmed.Ability.Lower"), LocaleLoader.getString("Unarmed.Ability.Ready")),
+    HOE(LocaleLoader.getString("Herbalism.Ability.Lower"), LocaleLoader.getString("Herbalism.Ability.Ready")),
+    PICKAXE(LocaleLoader.getString("Mining.Ability.Lower"), LocaleLoader.getString("Mining.Ability.Ready")),
+    SHOVEL(LocaleLoader.getString("Excavation.Ability.Lower"), LocaleLoader.getString("Excavation.Ability.Ready")),
+    SWORD(LocaleLoader.getString("Swords.Ability.Lower"), LocaleLoader.getString("Swords.Ability.Ready"));
+
+    private String lowerTool;
+    private String raiseTool;
+
+    private ToolType(String lowerTool, String raiseTool) {
+        this.lowerTool = lowerTool;
+        this.raiseTool = raiseTool;
+    }
+
+    public String getLowerTool() {
+        return lowerTool;
+    }
+
+    public String getRaiseTool() {
+        return raiseTool;
+    }
+
+    /**
+     * Check to see if the item is of the appropriate type.
+     *
+     * @param is The item to check
+     * @return true if the item is the right type, false otherwise
+     */
+    public boolean inHand(ItemStack is) {
+        switch (this) {
+        case AXE:
+            return ItemChecks.isAxe(is);
+
+        case FISTS:
+            return is.getType().equals(Material.AIR);
+
+        case HOE:
+            return ItemChecks.isHoe(is);
+
+        case PICKAXE:
+            return ItemChecks.isPickaxe(is);
+
+        case SHOVEL:
+            return ItemChecks.isShovel(is);
+
+        case SWORD:
+            return ItemChecks.isSword(is);
+
+        default:
+            return false;
+        }
+    }
+}

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

@@ -0,0 +1,105 @@
+package com.gmail.nossr50.skills.acrobatics;
+
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.skills.SkillCommand;
+import com.gmail.nossr50.skills.SkillType;
+import com.gmail.nossr50.util.Permissions;
+
+public class AcrobaticsCommand extends SkillCommand {
+    private String dodgeChance;
+    private String dodgeChanceLucky;
+    private String rollChance;
+    private String rollChanceLucky;
+    private String gracefulRollChance;
+    private String gracefulRollChanceLucky;
+
+    private boolean canDodge;
+    private boolean canRoll;
+    private boolean canGracefulRoll;
+
+    public AcrobaticsCommand() {
+        super(SkillType.ACROBATICS);
+    }
+
+    @Override
+    protected void dataCalculations() {
+        //DODGE
+        String[] dodgeStrings = calculateAbilityDisplayValues(Acrobatics.dodgeMaxBonusLevel, Acrobatics.dodgeMaxChance);
+        dodgeChance = dodgeStrings[0];
+        dodgeChanceLucky = dodgeStrings[1];
+
+        //ROLL
+        String[] rollStrings = calculateAbilityDisplayValues(Acrobatics.rollMaxBonusLevel, Acrobatics.rollMaxChance);
+        rollChance = rollStrings[0];
+        rollChanceLucky = rollStrings[1];
+
+        //GRACEFUL ROLL
+        String[] gracefulRollStrings = calculateAbilityDisplayValues(Acrobatics.gracefulRollMaxBonusLevel, Acrobatics.gracefulRollMaxChance);
+        rollChance = gracefulRollStrings[0];
+        rollChanceLucky = gracefulRollStrings[1];
+    }
+
+    @Override
+    protected void permissionsCheck() {
+        canDodge = Permissions.dodge(player);
+        canRoll = Permissions.roll(player);
+        canGracefulRoll = Permissions.gracefulRoll(player);
+    }
+
+    @Override
+    protected boolean effectsHeaderPermissions() {
+        return canDodge || canGracefulRoll || canRoll;
+    }
+
+    @Override
+    protected void effectsDisplay() {
+        luckyEffectsDisplay();
+
+        if (canRoll) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Acrobatics.Effect.0"), LocaleLoader.getString("Acrobatics.Effect.1") }));
+        }
+
+        if (canGracefulRoll) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Acrobatics.Effect.2"), LocaleLoader.getString("Acrobatics.Effect.3") }));
+        }
+
+        if (canDodge) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Acrobatics.Effect.4"), LocaleLoader.getString("Acrobatics.Effect.5") }));
+        }
+    }
+
+    @Override
+    protected boolean statsHeaderPermissions() {
+        return canDodge || canGracefulRoll || canRoll;
+    }
+
+    @Override
+    protected void statsDisplay() {
+        if (canRoll) {
+            if (isLucky) {
+                player.sendMessage(LocaleLoader.getString("Acrobatics.Roll.Chance", new Object[] { rollChance }) + LocaleLoader.getString("Perks.lucky.bonus", new Object[] { rollChanceLucky }));
+            }
+            else {
+                player.sendMessage(LocaleLoader.getString("Acrobatics.Roll.Chance", new Object[] { rollChance }));
+            }
+        }
+
+        if (canGracefulRoll) {
+            if (isLucky) {
+                player.sendMessage(LocaleLoader.getString("Acrobatics.Roll.GraceChance", new Object[] { gracefulRollChance }) + LocaleLoader.getString("Perks.lucky.bonus", new Object[] { gracefulRollChanceLucky }));
+            }
+            else {
+                player.sendMessage(LocaleLoader.getString("Acrobatics.Roll.GraceChance", new Object[] { gracefulRollChance }));
+            }
+        }
+
+        if (canDodge) {
+            if (isLucky) {
+                player.sendMessage(LocaleLoader.getString("Acrobatics.DodgeChance", new Object[] { dodgeChance }) + LocaleLoader.getString("Perks.lucky.bonus", new Object[] { dodgeChanceLucky }));
+            }
+            else {
+                player.sendMessage(LocaleLoader.getString("Acrobatics.DodgeChance", new Object[] { dodgeChance }));
+            }
+        }
+    }
+}

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

@@ -4,8 +4,8 @@ import org.bukkit.entity.Player;
 import org.bukkit.event.entity.EntityDamageEvent;
 
 import com.gmail.nossr50.config.Config;
-import com.gmail.nossr50.datatypes.SkillType;
 import com.gmail.nossr50.skills.SkillManager;
+import com.gmail.nossr50.skills.SkillType;
 import com.gmail.nossr50.util.Misc;
 import com.gmail.nossr50.util.Permissions;
 

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

@@ -3,10 +3,10 @@ package com.gmail.nossr50.skills.acrobatics;
 import org.bukkit.event.entity.EntityDamageEvent;
 
 import com.gmail.nossr50.datatypes.PlayerProfile;
-import com.gmail.nossr50.datatypes.SkillType;
 import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.skills.SkillType;
+import com.gmail.nossr50.skills.Skills;
 import com.gmail.nossr50.util.Misc;
-import com.gmail.nossr50.util.Skills;
 
 public class DodgeEventHandler extends AcrobaticsEventHandler {
     protected DodgeEventHandler(AcrobaticsManager manager, EntityDamageEvent event) {

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

@@ -2,11 +2,11 @@ package com.gmail.nossr50.skills.acrobatics;
 
 import org.bukkit.event.entity.EntityDamageEvent;
 
-import com.gmail.nossr50.datatypes.SkillType;
 import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.skills.SkillType;
+import com.gmail.nossr50.skills.Skills;
 import com.gmail.nossr50.util.Misc;
 import com.gmail.nossr50.util.Permissions;
-import com.gmail.nossr50.util.Skills;
 
 public class RollEventHandler extends AcrobaticsEventHandler {
     protected boolean isGraceful;

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

@@ -0,0 +1,104 @@
+package com.gmail.nossr50.skills.archery;
+
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.skills.SkillCommand;
+import com.gmail.nossr50.skills.SkillType;
+import com.gmail.nossr50.util.Permissions;
+
+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(SkillType.ARCHERY);
+    }
+
+    @Override
+    protected void dataCalculations() {
+        //SKILL SHOT
+        double bonus = (skillValue / Archery.skillShotIncreaseLevel) * Archery.skillShotIncreasePercentage;
+
+        if (bonus > Archery.skillShotMaxBonusPercentage) {
+            skillShotBonus = percent.format(Archery.skillShotMaxBonusPercentage);
+        }
+        else {
+            skillShotBonus = percent.format(bonus);
+        }
+
+        //DAZE
+        String[] dazeStrings = calculateAbilityDisplayValues(Archery.dazeMaxBonusLevel, Archery.dazeMaxBonus);
+        dazeChance = dazeStrings[0];
+        dazeChanceLucky = dazeStrings[1];
+
+        //RETRIEVE
+        String[] retrieveStrings = calculateAbilityDisplayValues(Archery.retrieveMaxBonusLevel, Archery.retrieveMaxChance);
+        retrieveChance = retrieveStrings[0];
+        retrieveChanceLucky = retrieveStrings[1];
+    }
+
+    @Override
+    protected void permissionsCheck() {
+        canSkillShot = Permissions.archeryBonus(player);
+        canDaze = Permissions.daze(player);
+        canRetrieve = Permissions.trackArrows(player);
+    }
+
+    @Override
+    protected boolean effectsHeaderPermissions() {
+        return canSkillShot || canDaze || canRetrieve;
+    }
+
+    @Override
+    protected void effectsDisplay() {
+        luckyEffectsDisplay();
+
+        if (canSkillShot) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Archery.Effect.0"), LocaleLoader.getString("Archery.Effect.1") }));
+        }
+
+        if (canDaze) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Archery.Effect.2"), LocaleLoader.getString("Archery.Effect.3", new Object[] {Archery.dazeModifier}) }));
+        }
+
+        if (canRetrieve) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Archery.Effect.4"), LocaleLoader.getString("Archery.Effect.5") }));
+        }
+    }
+
+    @Override
+    protected boolean statsHeaderPermissions() {
+        return canSkillShot || canDaze || canRetrieve;
+    }
+
+    @Override
+    protected void statsDisplay() {
+        if (canSkillShot) {
+            player.sendMessage(LocaleLoader.getString("Archery.Combat.SkillshotBonus", new Object[] { skillShotBonus }));
+        }
+
+        if (canDaze) {
+            if (isLucky) {
+                player.sendMessage(LocaleLoader.getString("Archery.Combat.DazeChance", new Object[] { dazeChance }) + LocaleLoader.getString("Perks.lucky.bonus", new Object[] { dazeChanceLucky }));
+            }
+            else {
+                player.sendMessage(LocaleLoader.getString("Archery.Combat.DazeChance", new Object[] { dazeChance }));
+            }
+        }
+
+        if (canRetrieve) {
+            if (isLucky) {
+                player.sendMessage(LocaleLoader.getString("Archery.Combat.RetrieveChance", new Object[] { retrieveChance }) + LocaleLoader.getString("Perks.lucky.bonus", new Object[] { retrieveChanceLucky }));
+            }
+            else {
+                player.sendMessage(LocaleLoader.getString("Archery.Combat.RetrieveChance", new Object[] { retrieveChance }));
+            }
+        }
+    }
+}

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

@@ -4,8 +4,8 @@ import org.bukkit.entity.LivingEntity;
 import org.bukkit.entity.Player;
 import org.bukkit.event.entity.EntityDamageEvent;
 
-import com.gmail.nossr50.datatypes.SkillType;
 import com.gmail.nossr50.skills.SkillManager;
+import com.gmail.nossr50.skills.SkillType;
 import com.gmail.nossr50.util.Misc;
 import com.gmail.nossr50.util.Permissions;
 

src/main/java/com/gmail/nossr50/skills/axes/AxeManager.java

@@ -4,9 +4,9 @@ import org.bukkit.entity.Player;
 import org.bukkit.entity.Tameable;
 import org.bukkit.event.entity.EntityDamageByEntityEvent;
 
-import com.gmail.nossr50.datatypes.AbilityType;
-import com.gmail.nossr50.datatypes.SkillType;
+import com.gmail.nossr50.skills.AbilityType;
 import com.gmail.nossr50.skills.SkillManager;
+import com.gmail.nossr50.skills.SkillType;
 import com.gmail.nossr50.util.Misc;
 import com.gmail.nossr50.util.Permissions;
 

src/main/java/com/gmail/nossr50/skills/axes/AxesCommand.java

@@ -0,0 +1,128 @@
+package com.gmail.nossr50.skills.axes;
+
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.skills.SkillCommand;
+import com.gmail.nossr50.skills.SkillType;
+import com.gmail.nossr50.util.Permissions;
+
+public class AxesCommand extends SkillCommand {
+    private String critChance;
+    private String critChanceLucky;
+    private String bonusDamage;
+    private String impactDamage;
+    private String greaterImpactDamage;
+    private String skullSplitterLength;
+    private String skullSplitterLengthEndurance;
+
+    private boolean canSkullSplitter;
+    private boolean canCritical;
+    private boolean canBonusDamage;
+    private boolean canImpact;
+    private boolean canGreaterImpact;
+
+    public AxesCommand() {
+        super(SkillType.AXES);
+    }
+
+    @Override
+    protected void dataCalculations() {
+        //IMPACT
+        impactDamage = String.valueOf(1 + (skillValue / Axes.impactIncreaseLevel));
+        greaterImpactDamage = String.valueOf(Axes.greaterImpactBonusDamage);
+
+        //SKULL SPLITTER
+        String[] skullSplitterStrings = calculateLengthDisplayValues();
+        skullSplitterLength = skullSplitterStrings[0];
+        skullSplitterLengthEndurance = skullSplitterStrings[1];
+
+        //CRITICAL STRIKES
+        String[] criticalStrikeStrings = calculateAbilityDisplayValues(Axes.criticalHitMaxBonusLevel, Axes.criticalHitMaxChance);
+        critChance = criticalStrikeStrings[0];
+        critChanceLucky = criticalStrikeStrings[1];
+
+        //AXE MASTERY
+        if (skillValue >= Axes.bonusDamageMaxBonusLevel) {
+            bonusDamage = String.valueOf(Axes.bonusDamageMaxBonus);
+        }
+        else {
+            bonusDamage = String.valueOf(skillValue / Axes.bonusDamageMaxBonusLevel / Axes.bonusDamageMaxBonus);
+        }
+    }
+
+    @Override
+    protected void permissionsCheck() {
+        canSkullSplitter = Permissions.skullSplitter(player);
+        canCritical = Permissions.criticalHit(player);
+        canBonusDamage = Permissions.axeBonus(player);
+        canImpact = Permissions.impact(player);
+        canGreaterImpact = Permissions.greaterImpact(player);
+    }
+
+    @Override
+    protected boolean effectsHeaderPermissions() {
+        return canSkullSplitter || canCritical || canBonusDamage || canImpact || canGreaterImpact;
+    }
+
+    @Override
+    protected void effectsDisplay() {
+        luckyEffectsDisplay();
+
+        if (canSkullSplitter) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Axes.Effect.0"), LocaleLoader.getString("Axes.Effect.1") }));
+        }
+
+        if (canCritical) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Axes.Effect.2"), LocaleLoader.getString("Axes.Effect.3") }));
+        }
+
+        if (canBonusDamage) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Axes.Effect.4"), LocaleLoader.getString("Axes.Effect.5") }));
+        }
+
+        if (canImpact) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Axes.Effect.6"), LocaleLoader.getString("Axes.Effect.7") }));
+        }
+
+        if (canGreaterImpact) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Axes.Effect.8"), LocaleLoader.getString("Axes.Effect.9") }));
+        }
+    }
+
+    @Override
+    protected boolean statsHeaderPermissions() {
+        return canSkullSplitter || canCritical || canBonusDamage || canImpact || canGreaterImpact;
+    }
+
+    @Override
+    protected void statsDisplay() {
+        if (canBonusDamage) {
+            player.sendMessage(LocaleLoader.getString("Ability.Generic.Template", new Object[] { LocaleLoader.getString("Axes.Ability.Bonus.0"), LocaleLoader.getString("Axes.Ability.Bonus.1", new Object[] {bonusDamage}) }));
+        }
+
+        if (canImpact) {
+            player.sendMessage(LocaleLoader.getString("Ability.Generic.Template", new Object[] { LocaleLoader.getString("Axes.Ability.Bonus.2"), LocaleLoader.getString("Axes.Ability.Bonus.3", new Object[] {impactDamage}) }));
+        }
+
+        if (canGreaterImpact) {
+            player.sendMessage(LocaleLoader.getString("Ability.Generic.Template", new Object[] { LocaleLoader.getString("Axes.Ability.Bonus.4"), LocaleLoader.getString("Axes.Ability.Bonus.5", new Object[] {greaterImpactDamage}) }));
+        }
+
+        if (canCritical) {
+            if (isLucky) {
+                player.sendMessage(LocaleLoader.getString("Axes.Combat.CritChance", new Object[] { critChance }) + LocaleLoader.getString("Perks.lucky.bonus", new Object[] { critChanceLucky }));
+            }
+            else {
+                player.sendMessage(LocaleLoader.getString("Axes.Combat.CritChance", new Object[] { critChance }));
+            }
+        }
+
+        if (canSkullSplitter) {
+            if (hasEndurance) {
+                player.sendMessage(LocaleLoader.getString("Axes.Combat.SS.Length", new Object[] { skullSplitterLength }) + LocaleLoader.getString("Perks.activationtime.bonus", new Object[] { skullSplitterLengthEndurance }));
+            }
+            else {
+                player.sendMessage(LocaleLoader.getString("Axes.Combat.SS.Length", new Object[] { skullSplitterLength }));
+            }
+        }
+    }
+}

src/main/java/com/gmail/nossr50/skills/axes/SkullSplitterEventHandler.java

@@ -4,8 +4,8 @@ import org.bukkit.entity.LivingEntity;
 import org.bukkit.entity.Player;
 import org.bukkit.event.entity.EntityDamageByEntityEvent;
 
-import com.gmail.nossr50.datatypes.SkillType;
-import com.gmail.nossr50.util.Combat;
+import com.gmail.nossr50.skills.Combat;
+import com.gmail.nossr50.skills.SkillType;
 
 public class SkullSplitterEventHandler {
     private Player player;

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

@@ -1,4 +1,4 @@
-package com.gmail.nossr50.skills.gathering;
+package com.gmail.nossr50.skills.excavation;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -16,14 +16,14 @@ import com.gmail.nossr50.config.Config;
 import com.gmail.nossr50.config.TreasuresConfig;
 import com.gmail.nossr50.config.mods.CustomBlocksConfig;
 import com.gmail.nossr50.datatypes.PlayerProfile;
-import com.gmail.nossr50.datatypes.SkillType;
 import com.gmail.nossr50.datatypes.treasure.ExcavationTreasure;
 import com.gmail.nossr50.events.fake.FakePlayerAnimationEvent;
+import com.gmail.nossr50.skills.SkillType;
+import com.gmail.nossr50.skills.Skills;
 import com.gmail.nossr50.spout.SpoutSounds;
 import com.gmail.nossr50.util.Misc;
 import com.gmail.nossr50.util.ModChecks;
 import com.gmail.nossr50.util.Permissions;
-import com.gmail.nossr50.util.Skills;
 import com.gmail.nossr50.util.Users;
 
 public class Excavation {

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

@@ -0,0 +1,67 @@
+package com.gmail.nossr50.skills.excavation;
+
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.skills.SkillCommand;
+import com.gmail.nossr50.skills.SkillType;
+import com.gmail.nossr50.util.Permissions;
+
+public class ExcavationCommand extends SkillCommand {
+    private String gigaDrillBreakerLength;
+    private String gigaDrillBreakerLengthEndurance;
+
+    private boolean canGigaDrill;
+    private boolean canTreasureHunt;
+
+    public ExcavationCommand() {
+        super(SkillType.EXCAVATION);
+    }
+
+    @Override
+    protected void dataCalculations() {
+        //GIGA DRILL BREAKER
+        String gigaDrillStrings[] = calculateLengthDisplayValues();
+        gigaDrillBreakerLength = gigaDrillStrings[0];
+        gigaDrillBreakerLengthEndurance = gigaDrillStrings[1];
+    }
+
+    @Override
+    protected void permissionsCheck() {
+        canGigaDrill = Permissions.gigaDrillBreaker(player);
+        canTreasureHunt = Permissions.excavationTreasures(player);
+    }
+
+    @Override
+    protected boolean effectsHeaderPermissions() {
+        return canGigaDrill || canTreasureHunt;
+    }
+
+    @Override
+    protected void effectsDisplay() {
+        luckyEffectsDisplay();
+
+        if (canGigaDrill) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Excavation.Effect.0"), LocaleLoader.getString("Excavation.Effect.1") }));
+        }
+
+        if (canTreasureHunt) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Excavation.Effect.2"), LocaleLoader.getString("Excavation.Effect.3") }));
+        }
+    }
+
+    @Override
+    protected boolean statsHeaderPermissions() {
+        return canGigaDrill;
+    }
+
+    @Override
+    protected void statsDisplay() {
+        if (canGigaDrill) {
+            if (hasEndurance) {
+                player.sendMessage(LocaleLoader.getString("Excavation.Effect.Length", new Object[] { gigaDrillBreakerLength }) + LocaleLoader.getString("Perks.activationtime.bonus", new Object[] { gigaDrillBreakerLengthEndurance }));
+            }
+            else {
+                player.sendMessage(LocaleLoader.getString("Excavation.Effect.Length", new Object[] { gigaDrillBreakerLength }));
+            }
+        }
+    }
+}

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

@@ -1,4 +1,4 @@
-package com.gmail.nossr50.skills.gathering;
+package com.gmail.nossr50.skills.fishing;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -25,14 +25,14 @@ import com.gmail.nossr50.config.AdvancedConfig;
 import com.gmail.nossr50.config.Config;
 import com.gmail.nossr50.config.TreasuresConfig;
 import com.gmail.nossr50.datatypes.PlayerProfile;
-import com.gmail.nossr50.datatypes.SkillType;
 import com.gmail.nossr50.datatypes.treasure.FishingTreasure;
 import com.gmail.nossr50.locale.LocaleLoader;
-import com.gmail.nossr50.util.Combat;
+import com.gmail.nossr50.skills.Combat;
+import com.gmail.nossr50.skills.SkillType;
+import com.gmail.nossr50.skills.Skills;
 import com.gmail.nossr50.util.ItemChecks;
 import com.gmail.nossr50.util.Misc;
 import com.gmail.nossr50.util.Permissions;
-import com.gmail.nossr50.util.Skills;
 import com.gmail.nossr50.util.Users;
 
 public class Fishing {

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

@@ -0,0 +1,127 @@
+package com.gmail.nossr50.skills.fishing;
+
+import com.gmail.nossr50.config.AdvancedConfig;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.skills.SkillCommand;
+import com.gmail.nossr50.skills.SkillType;
+import com.gmail.nossr50.util.Permissions;
+
+public class FishingCommand extends SkillCommand {
+
+    AdvancedConfig advancedConfig = AdvancedConfig.getInstance();
+
+    private int lootTier;
+    private String magicChance;
+    private String magicChanceLucky;
+    private String chanceRaining = "";
+    private String shakeChance;
+    private String shakeChanceLucky;
+    private String fishermansDietRank;
+
+    private boolean canTreasureHunt;
+    private boolean canMagicHunt;
+    private boolean canShake;
+    private boolean canFishermansDiet;
+
+    public FishingCommand() {
+        super(SkillType.FISHING);
+    }
+
+    @Override
+    protected void dataCalculations() {
+        lootTier = Fishing.getFishingLootTier(profile);
+
+        //TREASURE HUNTER
+        double enchantChance = lootTier * Fishing.magicHunterMultiplier;
+
+        if (player.getWorld().hasStorm()) {
+            chanceRaining = LocaleLoader.getString("Fishing.Chance.Raining");
+            enchantChance = enchantChance * 1.1D;
+        }
+
+        String[] treasureHunterStrings = calculateAbilityDisplayValues(enchantChance);
+        magicChance = treasureHunterStrings[0];
+        magicChanceLucky = treasureHunterStrings[1];
+
+        //SHAKE
+        String[] shakeStrings = calculateAbilityDisplayValues(Fishing.getShakeChance(lootTier));
+        shakeChance = shakeStrings[0];
+        shakeChanceLucky = shakeStrings[1];
+
+        //FISHERMAN'S DIET
+        fishermansDietRank = calculateRank(Fishing.fishermanDietMaxLevel, Fishing.fishermanDietRankChangeLevel);
+    }
+
+    @Override
+    protected void permissionsCheck() {
+        canTreasureHunt = Permissions.fishingTreasures(player);
+        canMagicHunt = Permissions.fishingMagic(player);
+        canShake = Permissions.shakeMob(player);
+        canFishermansDiet = Permissions.fishermansDiet(player);
+    }
+
+    @Override
+    protected boolean effectsHeaderPermissions() {
+        return canTreasureHunt || canMagicHunt || canShake;
+    }
+
+    @Override
+    protected void effectsDisplay() {
+        luckyEffectsDisplay();
+
+        if (canTreasureHunt) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Fishing.Effect.0"), LocaleLoader.getString("Fishing.Effect.1") }));
+        }
+
+        if (canMagicHunt) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Fishing.Effect.2"), LocaleLoader.getString("Fishing.Effect.3") }));
+        }
+
+        if (canShake) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Fishing.Effect.4"), LocaleLoader.getString("Fishing.Effect.5") }));
+        }
+
+        if (canFishermansDiet) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Fishing.Effect.6"), LocaleLoader.getString("Fishing.Effect.7") }));
+        }
+    }
+
+    @Override
+    protected boolean statsHeaderPermissions() {
+        return canTreasureHunt || canMagicHunt || canShake;
+    }
+
+    @Override
+    protected void statsDisplay() {
+        if (canTreasureHunt) {
+            player.sendMessage(LocaleLoader.getString("Fishing.Ability.Rank", new Object[] { lootTier }));
+        }
+
+        if (canMagicHunt) {
+            if (isLucky) {
+                player.sendMessage(LocaleLoader.getString("Fishing.Enchant.Chance", new Object[] { magicChance}) + chanceRaining +  LocaleLoader.getString("Perks.lucky.bonus", new Object[] { magicChanceLucky }));
+            }
+            else {
+                player.sendMessage(LocaleLoader.getString("Fishing.Enchant.Chance", new Object[] { magicChance}) + chanceRaining);
+            }
+        }
+
+        if (canShake) {
+            if (skillValue < Fishing.shakeUnlockLevel) {
+                player.sendMessage(LocaleLoader.getString("Ability.Generic.Template.Lock", new Object[] { LocaleLoader.getString("Fishing.Ability.Locked.0", new Object[] { Fishing.shakeUnlockLevel }) }));
+            }
+            else {
+                if (isLucky) {
+                    player.sendMessage(LocaleLoader.getString("Fishing.Ability.Shake", new Object[] { shakeChance }) + LocaleLoader.getString("Perks.lucky.bonus", new Object[] { shakeChanceLucky }));
+                }
+                else {
+                    player.sendMessage(LocaleLoader.getString("Fishing.Ability.Shake", new Object[] { shakeChance }));
+                }
+            }
+        }
+
+        if (canFishermansDiet) {
+            player.sendMessage(LocaleLoader.getString("Fishing.Ability.FD", new Object[] { fishermansDietRank }));
+        }
+    }
+}

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

@@ -1,4 +1,4 @@
-package com.gmail.nossr50.skills.gathering;
+package com.gmail.nossr50.skills.herbalism;
 
 import org.bukkit.CropState;
 import org.bukkit.DyeColor;
@@ -15,16 +15,16 @@ import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.config.AdvancedConfig;
 import com.gmail.nossr50.config.Config;
 import com.gmail.nossr50.config.mods.CustomBlocksConfig;
-import com.gmail.nossr50.datatypes.AbilityType;
 import com.gmail.nossr50.datatypes.PlayerProfile;
-import com.gmail.nossr50.datatypes.SkillType;
 import com.gmail.nossr50.datatypes.mods.CustomBlock;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.runnables.GreenThumbTimer;
+import com.gmail.nossr50.skills.AbilityType;
+import com.gmail.nossr50.skills.SkillType;
+import com.gmail.nossr50.skills.Skills;
 import com.gmail.nossr50.util.Misc;
 import com.gmail.nossr50.util.ModChecks;
 import com.gmail.nossr50.util.Permissions;
-import com.gmail.nossr50.util.Skills;
 import com.gmail.nossr50.util.Users;
 
 public class Herbalism {

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

@@ -0,0 +1,155 @@
+package com.gmail.nossr50.skills.herbalism;
+
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.skills.SkillCommand;
+import com.gmail.nossr50.skills.SkillType;
+import com.gmail.nossr50.util.Permissions;
+
+public class HerbalismCommand extends SkillCommand {
+    private String greenTerraLength;
+    private String greenTerraLengthEndurance;
+    private String greenThumbChance;
+    private String greenThumbChanceLucky;
+    private String greenThumbStage;
+    private String farmersDietRank;
+    private String doubleDropChance;
+    private String doubleDropChanceLucky;
+    private String hylianLuckChance;
+    private String hylianLuckChanceLucky;
+
+    private boolean hasHylianLuck;
+    private boolean canGreenTerra;
+    private boolean canGreenThumbWheat;
+    private boolean canGreenThumbBlocks;
+    private boolean canFarmersDiet;
+    private boolean canDoubleDrop;
+    private boolean doubleDropsDisabled;
+
+    public HerbalismCommand() {
+        super(SkillType.HERBALISM);
+    }
+
+    @Override
+    protected void dataCalculations() {
+        //GREEN TERRA
+        String[] greenTerraStrings = calculateLengthDisplayValues();
+        greenTerraLength = greenTerraStrings[0];
+        greenTerraLengthEndurance = greenTerraStrings[1];
+
+        //FARMERS DIET
+        farmersDietRank = calculateRank(Herbalism.farmersDietMaxLevel, Herbalism.farmersDietRankChangeLevel);
+
+        //GREEN THUMB
+        greenThumbStage = calculateRank(Herbalism.greenThumbStageMaxLevel, Herbalism.greenThumbStageMaxLevel);
+
+        String[] greenThumbStrings = calculateAbilityDisplayValues(Herbalism.greenThumbMaxLevel, Herbalism.greenThumbMaxChance);
+        greenThumbChance = greenThumbStrings[0];
+        greenThumbChanceLucky = greenThumbStrings[1];
+
+        //DOUBLE DROPS
+        String[] doubleDropStrings = calculateAbilityDisplayValues(Herbalism.doubleDropsMaxLevel, Herbalism.doubleDropsMaxChance);
+        doubleDropChance = doubleDropStrings[0];
+        doubleDropChanceLucky = doubleDropStrings[1];
+
+        //HYLIAN LUCK
+        String[] hylianLuckStrings = calculateAbilityDisplayValues(Herbalism.hylianLuckMaxLevel, Herbalism.hylianLuckMaxChance);
+        hylianLuckChance = hylianLuckStrings[0];
+        hylianLuckChanceLucky = hylianLuckStrings[1];
+    }
+
+    @Override
+    protected void permissionsCheck() {
+        hasHylianLuck = Permissions.hylianLuck(player);
+        canGreenTerra = Permissions.greenTerra(player);
+        canGreenThumbWheat = Permissions.greenThumbWheat(player);
+        canGreenThumbBlocks = Permissions.greenThumbBlocks(player);
+        canFarmersDiet = Permissions.farmersDiet(player);
+        canDoubleDrop = Permissions.herbalismDoubleDrops(player);
+        doubleDropsDisabled = Herbalism.doubleDropsDisabled;
+    }
+
+    @Override
+    protected boolean effectsHeaderPermissions() {
+        return canGreenTerra || (canDoubleDrop && !doubleDropsDisabled) || canFarmersDiet || canGreenThumbBlocks || canGreenThumbWheat;
+    }
+
+    @Override
+    protected void effectsDisplay() {
+        luckyEffectsDisplay();
+
+        if (canGreenTerra) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Herbalism.Effect.0"), LocaleLoader.getString("Herbalism.Effect.1") }));
+        }
+
+        if (canGreenThumbWheat) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Herbalism.Effect.2"), LocaleLoader.getString("Herbalism.Effect.3") }));
+        }
+
+        if (canGreenThumbBlocks) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Herbalism.Effect.4"), LocaleLoader.getString("Herbalism.Effect.5") }));
+        }
+
+        if (canFarmersDiet) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Herbalism.Effect.6"), LocaleLoader.getString("Herbalism.Effect.7") }));
+        }
+
+        if (hasHylianLuck) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Herbalism.Effect.10"), LocaleLoader.getString("Herbalism.Effect.11") }));
+        }
+
+        if (canDoubleDrop && !doubleDropsDisabled) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Herbalism.Effect.8"), LocaleLoader.getString("Herbalism.Effect.9") }));
+        }
+    }
+
+    @Override
+    protected boolean statsHeaderPermissions() {
+        return canGreenTerra || (canDoubleDrop && !doubleDropsDisabled) || canFarmersDiet || canGreenThumbBlocks || canGreenThumbWheat;
+    }
+
+    @Override
+    protected void statsDisplay() {
+        if (canGreenTerra) {
+            if (hasEndurance) {
+                player.sendMessage(LocaleLoader.getString("Herbalism.Ability.GTe.Length", new Object[] { greenTerraLength }) + LocaleLoader.getString("Perks.activationtime.bonus", new Object[] { greenTerraLengthEndurance }));
+            }
+            else {
+                player.sendMessage(LocaleLoader.getString("Herbalism.Ability.GTe.Length", new Object[] { greenTerraLength }));
+            }
+        }
+
+        if (canGreenThumbBlocks || canGreenThumbWheat) {
+            if (isLucky) {
+                player.sendMessage(LocaleLoader.getString("Herbalism.Ability.GTh.Chance", new Object[] { greenThumbChance }) + LocaleLoader.getString("Perks.lucky.bonus", new Object[] { greenThumbChanceLucky }));
+            }
+            else {
+                player.sendMessage(LocaleLoader.getString("Herbalism.Ability.GTh.Chance", new Object[] { greenThumbChance }));
+            }
+        }
+
+        if (canGreenThumbWheat) {
+            player.sendMessage(LocaleLoader.getString("Herbalism.Ability.GTh.Stage", new Object[] { greenThumbStage }));
+        }
+
+        if (canFarmersDiet) {
+            player.sendMessage(LocaleLoader.getString("Herbalism.Ability.FD", new Object[] { farmersDietRank } ));
+        }
+
+        if (hasHylianLuck) {
+            if (isLucky) {
+                player.sendMessage(LocaleLoader.getString("Herbalism.Ability.HylianLuck", new Object[] { hylianLuckChance }) + LocaleLoader.getString("Perks.lucky.bonus", new Object[] { hylianLuckChanceLucky }));
+            }
+            else {
+                player.sendMessage(LocaleLoader.getString("Herbalism.Ability.HylianLuck", new Object[] { hylianLuckChance }));
+            }
+        }
+        if (canDoubleDrop && !doubleDropsDisabled) {
+            if (isLucky) {
+                player.sendMessage(LocaleLoader.getString("Herbalism.Ability.DoubleDropChance", new Object[] { doubleDropChance }) + LocaleLoader.getString("Perks.lucky.bonus", new Object[] { doubleDropChanceLucky }));
+            }
+            else {
+                player.sendMessage(LocaleLoader.getString("Herbalism.Ability.DoubleDropChance", new Object[] { doubleDropChance }));
+            }
+        }
+    }
+}

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

@@ -12,11 +12,11 @@ import org.bukkit.material.MaterialData;
 import com.gmail.nossr50.config.AdvancedConfig;
 import com.gmail.nossr50.config.Config;
 import com.gmail.nossr50.datatypes.PlayerProfile;
-import com.gmail.nossr50.datatypes.SkillType;
 import com.gmail.nossr50.datatypes.mods.CustomBlock;
+import com.gmail.nossr50.skills.SkillType;
+import com.gmail.nossr50.skills.Skills;
 import com.gmail.nossr50.util.Misc;
 import com.gmail.nossr50.util.ModChecks;
-import com.gmail.nossr50.util.Skills;
 
 public class Mining {
     private static AdvancedConfig advancedConfig = AdvancedConfig.getInstance();

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

@@ -0,0 +1,181 @@
+package com.gmail.nossr50.skills.mining;
+
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.skills.SkillCommand;
+import com.gmail.nossr50.skills.SkillType;
+import com.gmail.nossr50.util.Misc;
+import com.gmail.nossr50.util.Permissions;
+
+public class MiningCommand extends SkillCommand {
+    private String doubleDropChance;
+    private String doubleDropChanceLucky;
+    private String superBreakerLength;
+    private String superBreakerLengthEndurance;
+    private String blastMiningRank;
+    private String blastRadiusIncrease;
+    private String blastDamageDecrease;
+
+    private boolean canSuperBreaker;
+    private boolean canDoubleDrop;
+    private boolean canBlast;
+    private boolean canBiggerBombs;
+    private boolean canDemoExpert;
+    private boolean doubleDropsDisabled;
+
+    public MiningCommand() {
+        super(SkillType.MINING);
+    }
+
+    @Override
+    protected void dataCalculations() {
+        //SUPER BREAKER
+        String[] superBreakerStrings = calculateLengthDisplayValues();
+        superBreakerLength = superBreakerStrings[0];
+        superBreakerLengthEndurance = superBreakerStrings[1];
+
+        //DOUBLE DROPS
+        String[] doubleDropStrings = calculateAbilityDisplayValues(Mining.doubleDropsMaxLevel, Mining.doubleDropsMaxChance);
+        doubleDropChance = doubleDropStrings[0];
+        doubleDropChanceLucky = doubleDropStrings[1];
+
+        //BLAST MINING
+        if (skillValue >= BlastMining.rank8) {
+            blastMiningRank = "8";
+            blastDamageDecrease = "100.00%";
+            blastRadiusIncrease = "4";
+        }
+        else if (skillValue >= BlastMining.rank7) {
+            blastMiningRank = "7";
+            blastDamageDecrease = "50.00%";
+            blastRadiusIncrease = "3";
+        }
+        else if (skillValue >= BlastMining.rank6) {
+            blastMiningRank = "6";
+            blastDamageDecrease = "50.00%";
+            blastRadiusIncrease = "3";
+        }
+        else if (skillValue >= BlastMining.rank5) {
+            blastMiningRank = "5";
+            blastDamageDecrease = "25.00%";
+            blastRadiusIncrease = "2";
+        }
+        else if (skillValue >= BlastMining.rank4) {
+            blastMiningRank = "4";
+            blastDamageDecrease = "25.00%";
+            blastRadiusIncrease = "2";
+        }
+        else if (skillValue >= BlastMining.rank3) {
+            blastMiningRank = "3";
+            blastDamageDecrease = "0.00%";
+            blastRadiusIncrease = "1";
+        }
+        else if (skillValue >= BlastMining.rank2) {
+            blastMiningRank = "2";
+            blastDamageDecrease = "0.00%";
+            blastRadiusIncrease = "1";
+        }
+        else if (skillValue >= BlastMining.rank1) {
+            blastMiningRank = "1";
+            blastDamageDecrease = "0.00%";
+            blastRadiusIncrease = "0";
+        }
+        else {
+            blastMiningRank = "0";
+            blastDamageDecrease = "0.00%";
+            blastRadiusIncrease = "0";
+        }
+    }
+
+    @Override
+    protected void permissionsCheck() {
+        canBiggerBombs = Permissions.biggerBombs(player);
+        canBlast = Permissions.blastMining(player);
+        canDemoExpert = Permissions.demolitionsExpertise(player);
+        canDoubleDrop = Permissions.miningDoubleDrops(player);
+        canSuperBreaker = Permissions.superBreaker(player);
+        doubleDropsDisabled = Mining.doubleDropsDisabled;
+    }
+
+    @Override
+    protected boolean effectsHeaderPermissions() {
+        return canBiggerBombs || canBlast || canDemoExpert || (canDoubleDrop && !doubleDropsDisabled) || canSuperBreaker;
+    }
+
+    @Override
+    protected void effectsDisplay() {
+        luckyEffectsDisplay();
+
+        if (canSuperBreaker) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Mining.Effect.0"), LocaleLoader.getString("Mining.Effect.1") }));
+        }
+
+        if (canDoubleDrop && !doubleDropsDisabled) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Mining.Effect.2"), LocaleLoader.getString("Mining.Effect.3") }));
+        }
+
+        if (canBlast) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Mining.Effect.4"), LocaleLoader.getString("Mining.Effect.5") }));
+        }
+
+        if (canBiggerBombs) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Mining.Effect.6"), LocaleLoader.getString("Mining.Effect.7") }));
+        }
+
+        if (canDemoExpert) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Mining.Effect.8"), LocaleLoader.getString("Mining.Effect.9") }));
+        }
+    }
+
+    @Override
+    protected boolean statsHeaderPermissions() {
+        return canBiggerBombs || canBlast || canDemoExpert || (canDoubleDrop && !doubleDropsDisabled) || canSuperBreaker;
+    }
+
+    @Override
+    protected void statsDisplay() {
+        if (canDoubleDrop && !doubleDropsDisabled) {
+            if (isLucky) {
+                player.sendMessage(LocaleLoader.getString("Mining.Effect.DropChance", new Object[] { doubleDropChance }) + LocaleLoader.getString("Perks.lucky.bonus", new Object[] { doubleDropChanceLucky }));
+            }
+            else {
+                player.sendMessage(LocaleLoader.getString("Mining.Effect.DropChance", new Object[] { doubleDropChance }));
+            }
+        }
+
+        if (canSuperBreaker) {
+            if (hasEndurance) {
+                player.sendMessage(LocaleLoader.getString("Mining.Ability.Length", new Object[] { superBreakerLength }) + LocaleLoader.getString("Perks.activationtime.bonus", new Object[] { superBreakerLengthEndurance }));
+            }
+            else {
+                player.sendMessage(LocaleLoader.getString("Mining.Ability.Length", new Object[] { superBreakerLength }));
+            }
+        }
+
+        if (canBlast) {
+            if (skillValue < BlastMining.rank1) {
+                player.sendMessage(LocaleLoader.getString("Ability.Generic.Template.Lock", new Object[] { LocaleLoader.getString("Mining.Ability.Locked.0", new Object[] { BlastMining.rank1 })  }));
+            }
+            else {
+                player.sendMessage(LocaleLoader.getString("Mining.Blast.Rank", new Object[] { blastMiningRank, LocaleLoader.getString("Mining.Blast.Effect." + (Misc.getInt(blastMiningRank) - 1)) }));
+            }
+        }
+
+        if (canBiggerBombs) {
+            if (skillValue < BlastMining.rank2) {
+                player.sendMessage(LocaleLoader.getString("Ability.Generic.Template.Lock", new Object[] { LocaleLoader.getString("Mining.Ability.Locked.1", new Object[] { BlastMining.rank2 }) }));
+            }
+            else {
+                player.sendMessage(LocaleLoader.getString("Mining.Blast.Radius.Increase", new Object[] { blastRadiusIncrease }));
+            }
+        }
+
+        if (canDemoExpert) {
+            if (skillValue < BlastMining.rank4) {
+                player.sendMessage(LocaleLoader.getString("Ability.Generic.Template.Lock", new Object[] { LocaleLoader.getString("Mining.Ability.Locked.2", new Object[] { BlastMining.rank4 }) }));
+            }
+            else {
+                player.sendMessage(LocaleLoader.getString("Mining.Effect.Decrease", new Object[] { blastDamageDecrease }));
+            }
+        }
+    }
+}

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

@@ -9,8 +9,8 @@ import org.bukkit.event.entity.ExplosionPrimeEvent;
 import org.bukkit.event.player.PlayerInteractEvent;
 
 import com.gmail.nossr50.mcMMO;
-import com.gmail.nossr50.datatypes.SkillType;
 import com.gmail.nossr50.skills.SkillManager;
+import com.gmail.nossr50.skills.SkillType;
 import com.gmail.nossr50.util.Misc;
 import com.gmail.nossr50.util.Permissions;
 

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

@@ -9,11 +9,11 @@ import org.bukkit.entity.TNTPrimed;
 import org.bukkit.event.player.PlayerInteractEvent;
 
 import com.gmail.nossr50.mcMMO;
-import com.gmail.nossr50.datatypes.AbilityType;
 import com.gmail.nossr50.datatypes.PlayerProfile;
 import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.skills.AbilityType;
+import com.gmail.nossr50.skills.Skills;
 import com.gmail.nossr50.util.Misc;
-import com.gmail.nossr50.util.Skills;
 
 public class RemoteDetonationEventHandler {
     private Player player;

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

@@ -8,10 +8,10 @@ import org.getspout.spoutapi.sound.SoundEffect;
 
 import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.events.fake.FakePlayerAnimationEvent;
+import com.gmail.nossr50.skills.Skills;
 import com.gmail.nossr50.spout.SpoutSounds;
 import com.gmail.nossr50.util.Misc;
 import com.gmail.nossr50.util.ModChecks;
-import com.gmail.nossr50.util.Skills;
 
 public class SuperBreakerEventHandler {
     private MiningManager manager;

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

@@ -13,12 +13,12 @@ import org.getspout.spoutapi.player.SpoutPlayer;
 import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.config.AdvancedConfig;
 import com.gmail.nossr50.datatypes.PlayerProfile;
-import com.gmail.nossr50.datatypes.SkillType;
 import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.skills.SkillType;
+import com.gmail.nossr50.skills.Skills;
 import com.gmail.nossr50.spout.SpoutSounds;
 import com.gmail.nossr50.util.Misc;
 import com.gmail.nossr50.util.Permissions;
-import com.gmail.nossr50.util.Skills;
 import com.gmail.nossr50.util.Users;
 
 public class Repair {

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

@@ -0,0 +1,164 @@
+package com.gmail.nossr50.skills.repair;
+
+import org.bukkit.Material;
+
+import com.gmail.nossr50.mcMMO;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.skills.SkillCommand;
+import com.gmail.nossr50.skills.SkillType;
+import com.gmail.nossr50.util.Permissions;
+
+public class RepairCommand extends SkillCommand {
+    private int arcaneForgingRank;
+    private String repairMasteryBonus;
+    private String superRepairChance;
+    private String superRepairChanceLucky;
+
+    private boolean canSuperRepair;
+    private boolean canMasterRepair;
+    private boolean canArcaneForge;
+    private boolean canSalvage;
+    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(SkillType.REPAIR);
+    }
+
+    @Override
+    protected void dataCalculations() {
+        // We're using pickaxes here, not the best but it works
+        Repairable diamondRepairable = mcMMO.repairManager.getRepairable(Material.DIAMOND_PICKAXE.getId());
+        Repairable goldRepairable = mcMMO.repairManager.getRepairable(Material.GOLD_PICKAXE.getId());
+        Repairable ironRepairable = mcMMO.repairManager.getRepairable(Material.IRON_PICKAXE.getId());
+        Repairable stoneRepairable = mcMMO.repairManager.getRepairable(Material.STONE_PICKAXE.getId());
+
+        //TODO: This isn't really accurate - if they don't have pickaxes loaded it doesn't always mean the repair level is 0
+        diamondLevel = (diamondRepairable == null) ? 0 : diamondRepairable.getMinimumLevel();
+        goldLevel = (goldRepairable == null) ? 0 : goldRepairable.getMinimumLevel();
+        ironLevel = (ironRepairable == null) ? 0 : ironRepairable.getMinimumLevel();
+        stoneLevel = (stoneRepairable == null) ? 0 : stoneRepairable.getMinimumLevel();
+
+        //REPAIR MASTERY
+        if (skillValue >= Repair.REPAIR_MASTERY_MAX_BONUS_LEVEL) {
+            repairMasteryBonus = percent.format(Repair.REPAIR_MASTERY_CHANCE_MAX / 100D);
+        }
+        else {
+            repairMasteryBonus = percent.format((( Repair.REPAIR_MASTERY_CHANCE_MAX / Repair.REPAIR_MASTERY_MAX_BONUS_LEVEL) * skillValue) / 100D);
+        }
+
+        //SUPER REPAIR
+        String[] superRepairStrings = calculateAbilityDisplayValues(Repair.SUPER_REPAIR_MAX_BONUS_LEVEL, Repair.SUPER_REPAIR_CHANCE_MAX);
+        superRepairChance = superRepairStrings[0];
+        superRepairChanceLucky = superRepairStrings[1];
+
+        //ARCANE FORGING
+        arcaneForgingRank = Repair.getArcaneForgingRank(profile);
+    }
+
+    @Override
+    protected void permissionsCheck() {
+        canSuperRepair = Permissions.repairBonus(player);
+        canMasterRepair = Permissions.repairMastery(player);
+        canArcaneForge = Permissions.arcaneForging(player);
+        canSalvage = Permissions.salvage(player);
+        canRepairDiamond = Permissions.diamondRepair(player);
+        canRepairGold = Permissions.goldRepair(player);
+        canRepairIron = Permissions.ironRepair(player);
+        canRepairStone = Permissions.stoneRepair(player);
+        canRepairString = Permissions.stringRepair(player);
+        canRepairLeather = Permissions.leatherRepair(player);
+        canRepairWood = Permissions.woodRepair(player);
+        arcaneBypass = Permissions.arcaneBypass(player);
+    }
+
+    @Override
+    protected boolean effectsHeaderPermissions() {
+        return canArcaneForge || canSalvage || canRepairDiamond || canRepairGold || canRepairIron || canMasterRepair || canRepairStone || canSuperRepair || canRepairString || canRepairWood || canRepairLeather;
+    }
+
+    @Override
+    protected void effectsDisplay() {
+        luckyEffectsDisplay();
+
+        player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Repair.Effect.0"), LocaleLoader.getString("Repair.Effect.1") }));
+
+        if (canMasterRepair) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Repair.Effect.2"), LocaleLoader.getString("Repair.Effect.3") }));
+        }
+
+        if (canSuperRepair) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Repair.Effect.4"), LocaleLoader.getString("Repair.Effect.5") }));
+        }
+
+        /* Repair Level Requirements */
+
+        if (canRepairStone && stoneLevel > 0) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Repair.Effect.14", new Object[] { stoneLevel }), LocaleLoader.getString("Repair.Effect.15") }));
+        }
+
+        if (canRepairIron && ironLevel > 0) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Repair.Effect.12", new Object[] { ironLevel }), LocaleLoader.getString("Repair.Effect.13") }));
+        }
+
+        if (canRepairGold && goldLevel > 0) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Repair.Effect.10", new Object[] { goldLevel }), LocaleLoader.getString("Repair.Effect.11") }));
+        }
+
+        if (canRepairDiamond && diamondLevel > 0) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Repair.Effect.6", new Object[] { diamondLevel }), LocaleLoader.getString("Repair.Effect.7") }));
+        }
+
+        if (canSalvage && Salvage.salvageUnlockLevel > 0) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Repair.Effect.16", new Object[] { Salvage.salvageUnlockLevel }), LocaleLoader.getString("Repair.Effect.17") }));
+        }
+
+        if (canArcaneForge) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Repair.Effect.8"), LocaleLoader.getString("Repair.Effect.9") }));
+        }
+    }
+
+    @Override
+    protected boolean statsHeaderPermissions() {
+        return canArcaneForge || canMasterRepair || canSuperRepair;
+    }
+
+    @Override
+    protected void statsDisplay() {
+        if (canMasterRepair) {
+            player.sendMessage(LocaleLoader.getString("Repair.Skills.Mastery", new Object[] { repairMasteryBonus }));
+        }
+
+        if (canSuperRepair) {
+            if (isLucky) {
+                player.sendMessage(LocaleLoader.getString("Repair.Skills.Super.Chance", new Object[] { superRepairChance }) + LocaleLoader.getString("Perks.lucky.bonus", new Object[] { superRepairChanceLucky }));
+            }
+            else {
+                player.sendMessage(LocaleLoader.getString("Repair.Skills.Super.Chance", new Object[] { superRepairChance }));
+            }
+        }
+
+        if (canArcaneForge) {
+            player.sendMessage(LocaleLoader.getString("Repair.Arcane.Rank", new Object[] { arcaneForgingRank }));
+
+            if (Repair.arcaneForgingEnchantLoss) {
+                player.sendMessage(LocaleLoader.getString("Repair.Arcane.Chance.Success", new Object[] { (arcaneBypass ? 100 : Repair.getEnchantChance(arcaneForgingRank)) }));
+            }
+
+            if (Repair.arcaneForgingDowngrades) {
+                player.sendMessage(LocaleLoader.getString("Repair.Arcane.Chance.Downgrade", new Object[] { (arcaneBypass ? 0 : Repair.getDowngradeChance(arcaneForgingRank)) }));
+            }
+        }
+    }
+}

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

@@ -11,8 +11,8 @@ import org.getspout.spoutapi.player.SpoutPlayer;
 import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.config.Config;
 import com.gmail.nossr50.datatypes.PlayerProfile;
-import com.gmail.nossr50.datatypes.SkillType;
 import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.skills.SkillType;
 import com.gmail.nossr50.util.ItemChecks;
 import com.gmail.nossr50.util.Misc;
 import com.gmail.nossr50.util.Permissions;

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

@@ -10,9 +10,9 @@ import org.bukkit.inventory.ItemStack;
 import org.bukkit.inventory.PlayerInventory;
 
 import com.gmail.nossr50.datatypes.PlayerProfile;
-import com.gmail.nossr50.datatypes.SkillType;
 import com.gmail.nossr50.events.skills.McMMOPlayerRepairCheckEvent;
 import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.skills.SkillType;
 import com.gmail.nossr50.util.Misc;
 import com.gmail.nossr50.util.Permissions;
 import com.gmail.nossr50.util.Users;

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

@@ -0,0 +1,108 @@
+package com.gmail.nossr50.skills.repair.config;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+
+import org.bukkit.configuration.ConfigurationSection;
+
+import com.gmail.nossr50.config.ConfigLoader;
+import com.gmail.nossr50.skills.repair.RepairItemType;
+import com.gmail.nossr50.skills.repair.RepairMaterialType;
+import com.gmail.nossr50.skills.repair.Repairable;
+import com.gmail.nossr50.skills.repair.RepairableFactory;
+
+public class RepairConfig extends ConfigLoader {
+    private List<Repairable> repairables;
+
+    public RepairConfig(String fileName) {
+        super(fileName);
+        loadKeys();
+    }
+
+    @Override
+    protected void loadKeys() {
+        repairables = new ArrayList<Repairable>();
+
+        ConfigurationSection section = config.getConfigurationSection("Repairables");
+        Set<String> keys = section.getKeys(false);
+
+        for (String key : keys) {
+            // Validate all the things!
+            List<String> reason = new ArrayList<String>();
+
+            if (!config.contains("Repairables." + key + ".ItemId")) {
+                reason.add(key + " is missing ItemId");
+            }
+
+            if (!config.contains("Repairables." + key + ".RepairMaterialId")) {
+                reason.add(key + " is missing RepairMaterialId");
+            }
+
+            if (!config.contains("Repairables." + key + ".MaximumDurability")) {
+                reason.add(key + " is missing MaximumDurability");
+            }
+
+            int itemId = config.getInt("Repairables." + key + ".ItemId", 0);
+            int repairMaterialId = config.getInt("Repairables." + key + ".RepairMaterialId", 0);
+            int maximumDurability = config.getInt("Repairables." + key + ".MaximumDurability", 0);
+
+            int repairMetadata = config.getInt("Repairables." + key + ".RepairMaterialMetadata", -1);
+            int minimumLevel = config.getInt("Repairables." + key + ".MinimumLevel", 0);
+            int minimumQuantity = config.getInt("Repairables." + key + ".MinimumQuantity", 2);
+            double xpMultiplier = config.getDouble("Repairables." + key + ".XpMultiplier", 1);
+
+            RepairItemType repairItemType = RepairItemType.OTHER;
+            RepairMaterialType repairMaterialType = RepairMaterialType.OTHER;
+
+            String repairItemTypeString = config.getString("Repairables." + key + ".ItemType", "OTHER");
+            String repairMaterialTypeString = config.getString("Repairables." + key + ".MaterialType", "OTHER");
+
+            if (minimumLevel < 0) {
+                reason.add(key + " has an invalid MinimumLevel of " + minimumLevel);
+            }
+
+            if (minimumQuantity < 0) {
+                reason.add(key + " has an invalid MinimumQuantity of " + minimumQuantity);
+            }
+
+            try {
+                repairItemType = RepairItemType.valueOf(repairItemTypeString);
+            }
+            catch (IllegalArgumentException ex) {
+                reason.add(key + " has an invalid ItemType of " + repairItemTypeString);
+            }
+
+            try {
+                repairMaterialType = RepairMaterialType.valueOf(repairMaterialTypeString);
+            }
+            catch (IllegalArgumentException ex) {
+                reason.add(key + " has an invalid MaterialType of " + repairMaterialTypeString);
+            }
+
+            if (noErrorsInRepairable(reason)) {
+                Repairable repairable = RepairableFactory.getRepairable(itemId, repairMaterialId, (byte) repairMetadata, minimumLevel, minimumQuantity, (short) maximumDurability, repairItemType, repairMaterialType, xpMultiplier);
+                repairables.add(repairable);
+            }
+        }
+    }
+
+    protected List<Repairable> getLoadedRepairables() {
+        if (repairables == null) {
+            return new ArrayList<Repairable>();
+        }
+
+        return repairables;
+    }
+
+    private boolean noErrorsInRepairable(List<String> issues) {
+        if (issues.isEmpty()) {
+            return true;
+        }
+
+        for (String issue : issues) {
+            plugin.getLogger().warning(issue);
+        }
+        return false;
+    }
+}

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

@@ -0,0 +1,52 @@
+package com.gmail.nossr50.skills.repair.config;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Pattern;
+
+import com.gmail.nossr50.mcMMO;
+import com.gmail.nossr50.skills.repair.Repairable;
+
+public class RepairConfigManager {
+    private List<Repairable> repairables;
+
+    public RepairConfigManager(mcMMO plugin) {
+        repairables = new ArrayList<Repairable>();
+
+        Pattern pattern = Pattern.compile("repair\\.(?:.+)\\.yml");
+        File dataFolder = plugin.getDataFolder();
+        File vanilla = new File(dataFolder, "repair.vanilla.yml");
+
+        if (!vanilla.exists()) {
+            plugin.saveResource("repair.vanilla.yml", false);
+        }
+
+        for (String fileName : dataFolder.list()) {
+            if (!pattern.matcher(fileName).matches()) {
+                continue;
+            }
+
+            File file = new File(dataFolder, fileName);
+
+            if (file.isDirectory()) {
+                continue;
+            }
+
+            RepairConfig rConfig = new RepairConfig(fileName);
+            List<Repairable> rConfigRepairables = rConfig.getLoadedRepairables();
+
+            if (rConfigRepairables != null) {
+                repairables.addAll(rConfigRepairables);
+            }
+        }
+    }
+
+    public List<Repairable> getLoadedRepairables() {
+        if (repairables == null) {
+            return new ArrayList<Repairable>();
+        }
+
+        return repairables;
+    }
+}

src/main/java/com/gmail/nossr50/skills/swords/CounterAttackEventHandler.java

@@ -4,7 +4,7 @@ import org.bukkit.entity.LivingEntity;
 import org.bukkit.entity.Player;
 
 import com.gmail.nossr50.locale.LocaleLoader;
-import com.gmail.nossr50.util.Combat;
+import com.gmail.nossr50.skills.Combat;
 import com.gmail.nossr50.util.ItemChecks;
 import com.gmail.nossr50.util.Misc;
 

src/main/java/com/gmail/nossr50/skills/swords/SerratedStrikesEventHandler.java

@@ -3,9 +3,9 @@ package com.gmail.nossr50.skills.swords;
 import org.bukkit.entity.LivingEntity;
 import org.bukkit.entity.Player;
 
-import com.gmail.nossr50.datatypes.SkillType;
 import com.gmail.nossr50.runnables.BleedTimer;
-import com.gmail.nossr50.util.Combat;
+import com.gmail.nossr50.skills.Combat;
+import com.gmail.nossr50.skills.SkillType;
 
 public class SerratedStrikesEventHandler {
     private Player player;

src/main/java/com/gmail/nossr50/skills/swords/SwordsCommand.java

@@ -0,0 +1,117 @@
+package com.gmail.nossr50.skills.swords;
+
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.skills.SkillCommand;
+import com.gmail.nossr50.skills.SkillType;
+import com.gmail.nossr50.util.Permissions;
+
+public class SwordsCommand extends SkillCommand {
+    private String counterAttackChance;
+    private String counterAttackChanceLucky;
+    private String bleedLength;
+    private String bleedChance;
+    private String bleedChanceLucky;
+    private String serratedStrikesLength;
+    private String serratedStrikesLengthEndurance;
+
+    private boolean canCounter;
+    private boolean canSerratedStrike;
+    private boolean canBleed;
+
+    public SwordsCommand() {
+        super(SkillType.SWORDS);
+    }
+
+    @Override
+    protected void dataCalculations() {
+        //SERRATED STRIKES
+        String[] serratedStrikesStrings = calculateLengthDisplayValues();
+        serratedStrikesLength = serratedStrikesStrings[0];
+        serratedStrikesLengthEndurance = serratedStrikesStrings[1];
+
+        //BLEED
+        if (skillValue >= Swords.bleedMaxBonusLevel) {
+            bleedLength = String.valueOf(Swords.bleedMaxTicks);
+        }
+        else {
+            bleedLength = String.valueOf(Swords.bleedBaseTicks);
+        }
+
+        String[] bleedStrings = calculateAbilityDisplayValues(Swords.bleedMaxBonusLevel, Swords.bleedMaxChance);
+        bleedChance = bleedStrings[0];
+        bleedChanceLucky = bleedStrings[1];
+
+        //COUNTER ATTACK
+        String[] counterAttackStrings = calculateAbilityDisplayValues(Swords.counterAttackMaxBonusLevel, Swords.counterAttackMaxChance);
+        counterAttackChance = counterAttackStrings[0];
+        counterAttackChanceLucky = counterAttackStrings[1];
+    }
+
+    @Override
+    protected void permissionsCheck() {
+        canBleed = Permissions.swordsBleed(player);
+        canCounter = Permissions.counterAttack(player);
+        canSerratedStrike = Permissions.serratedStrikes(player);
+    }
+
+    @Override
+    protected boolean effectsHeaderPermissions() {
+        return canBleed || canCounter || canSerratedStrike;
+    }
+
+    @Override
+    protected void effectsDisplay() {
+        luckyEffectsDisplay();
+
+        if (canCounter) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Swords.Effect.0"), LocaleLoader.getString("Swords.Effect.1", new Object[] {percent.format(100.D / Swords.counterAttackModifier)} ) }));
+        }
+
+        if (canSerratedStrike) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Swords.Effect.2"), LocaleLoader.getString("Swords.Effect.3", new Object[] {percent.format(100.0D / Swords.serratedStrikesModifier)}) }));
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Swords.Effect.4"), LocaleLoader.getString("Swords.Effect.5", new Object[] {Swords.serratedStrikesBleedTicks}) }));
+        }
+
+        if (canBleed) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Swords.Effect.6"), LocaleLoader.getString("Swords.Effect.7") }));
+        }
+    }
+
+    @Override
+    protected boolean statsHeaderPermissions() {
+        return canBleed || canCounter || canSerratedStrike;
+    }
+
+    @Override
+    protected void statsDisplay() {
+        if (canCounter) {
+            if (isLucky) {
+                player.sendMessage(LocaleLoader.getString("Swords.Combat.Counter.Chance", new Object[] { counterAttackChance }) + LocaleLoader.getString("Perks.lucky.bonus", new Object[] { counterAttackChanceLucky }));
+            }
+            else {
+                player.sendMessage(LocaleLoader.getString("Swords.Combat.Counter.Chance", new Object[] { counterAttackChance }));
+            }
+        }
+
+        if (canBleed) {
+            player.sendMessage(LocaleLoader.getString("Swords.Combat.Bleed.Length", new Object[] { bleedLength }));
+            player.sendMessage(LocaleLoader.getString("Swords.Combat.Bleed.Note"));
+
+            if (isLucky) {
+                player.sendMessage(LocaleLoader.getString("Swords.Combat.Bleed.Chance", new Object[] { bleedChance }) + LocaleLoader.getString("Perks.lucky.bonus", new Object[] { bleedChanceLucky }));
+            }
+            else {
+                player.sendMessage(LocaleLoader.getString("Swords.Combat.Bleed.Chance", new Object[] { bleedChance }));
+            }
+        }
+
+        if (canSerratedStrike) {
+            if (hasEndurance) {
+                player.sendMessage(LocaleLoader.getString("Swords.SS.Length", new Object[] { serratedStrikesLength }) + LocaleLoader.getString("Perks.activationtime.bonus", new Object[] { serratedStrikesLengthEndurance }));
+            }
+            else {
+                player.sendMessage(LocaleLoader.getString("Swords.SS.Length", new Object[] { serratedStrikesLength }));
+            }
+        }
+    }
+}

src/main/java/com/gmail/nossr50/skills/swords/SwordsManager.java

@@ -3,10 +3,10 @@ package com.gmail.nossr50.skills.swords;
 import org.bukkit.entity.LivingEntity;
 import org.bukkit.entity.Player;
 
-import com.gmail.nossr50.datatypes.AbilityType;
-import com.gmail.nossr50.datatypes.SkillType;
+import com.gmail.nossr50.skills.AbilityType;
+import com.gmail.nossr50.skills.Combat;
 import com.gmail.nossr50.skills.SkillManager;
-import com.gmail.nossr50.util.Combat;
+import com.gmail.nossr50.skills.SkillType;
 import com.gmail.nossr50.util.Misc;
 import com.gmail.nossr50.util.Permissions;
 

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

@@ -0,0 +1,150 @@
+package com.gmail.nossr50.skills.taming;
+
+import com.gmail.nossr50.config.Config;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.skills.SkillCommand;
+import com.gmail.nossr50.skills.SkillType;
+import com.gmail.nossr50.util.Permissions;
+
+public class TamingCommand extends SkillCommand {
+    private String goreChance;
+    private String goreChanceLucky;
+
+    private boolean canBeastLore;
+    private boolean canGore;
+    private boolean canSharpenedClaws;
+    private boolean canEnvironmentallyAware;
+    private boolean canThickFur;
+    private boolean canShockProof;
+    private boolean canCallWild;
+    private boolean canFastFood;
+
+    public TamingCommand() {
+        super(SkillType.TAMING);
+    }
+
+    @Override
+    protected void dataCalculations() {
+        String[] goreStrings = calculateAbilityDisplayValues(Taming.goreMaxBonusLevel, Taming.goreMaxChance);
+        goreChance = goreStrings[0];
+        goreChanceLucky = goreStrings[1];
+    }
+
+    @Override
+    protected void permissionsCheck() {
+        canBeastLore = Permissions.beastLore(player);
+        canCallWild = Permissions.callOfTheWild(player);
+        canEnvironmentallyAware = Permissions.environmentallyAware(player);
+        canFastFood = Permissions.fastFoodService(player);
+        canGore = Permissions.gore(player);
+        canSharpenedClaws = Permissions.sharpenedClaws(player);
+        canShockProof = Permissions.shockProof(player);
+        canThickFur = Permissions.thickFur(player);
+    }
+
+    @Override
+    protected boolean effectsHeaderPermissions() {
+        return canBeastLore || canCallWild || canEnvironmentallyAware || canFastFood || canGore || canSharpenedClaws || canShockProof || canThickFur;
+    }
+
+    @Override
+    protected void effectsDisplay() {
+        luckyEffectsDisplay();
+
+        if (canBeastLore) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Taming.Effect.0"), LocaleLoader.getString("Taming.Effect.1") }));
+        }
+
+        if (canGore) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Taming.Effect.2"), LocaleLoader.getString("Taming.Effect.3") }));
+        }
+
+        if (canSharpenedClaws) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Taming.Effect.4"), LocaleLoader.getString("Taming.Effect.5") }));
+        }
+
+        if (canEnvironmentallyAware) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Taming.Effect.6"), LocaleLoader.getString("Taming.Effect.7") }));
+        }
+
+        if (canThickFur) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Taming.Effect.8"), LocaleLoader.getString("Taming.Effect.9") }));
+        }
+
+        if (canShockProof) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Taming.Effect.10"), LocaleLoader.getString("Taming.Effect.11") }));
+        }
+
+        if (canFastFood) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Taming.Effect.16"), LocaleLoader.getString("Taming.Effect.17") }));
+        }
+
+        if (canCallWild) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Taming.Effect.12"), LocaleLoader.getString("Taming.Effect.13") }));
+            player.sendMessage(LocaleLoader.getString("Taming.Effect.14", new Object[] { Config.getInstance().getTamingCOTWOcelotCost() }));
+            player.sendMessage(LocaleLoader.getString("Taming.Effect.15", new Object[] { Config.getInstance().getTamingCOTWWolfCost() }));
+        }
+    }
+
+    @Override
+    protected boolean statsHeaderPermissions() {
+        return canEnvironmentallyAware || canFastFood || canGore || canSharpenedClaws || canShockProof || canThickFur;
+    }
+
+    @Override
+    protected void statsDisplay() {
+        if (canFastFood) {
+            if (skillValue < Taming.fastFoodServiceUnlockLevel) {
+                player.sendMessage(LocaleLoader.getString("Ability.Generic.Template.Lock", new Object[] { LocaleLoader.getString("Taming.Ability.Locked.4", new Object[] { Taming.fastFoodServiceUnlockLevel } ) }));
+            }
+            else {
+                player.sendMessage(LocaleLoader.getString("Ability.Generic.Template", new Object[] { LocaleLoader.getString("Taming.Ability.Bonus.8"), LocaleLoader.getString("Taming.Ability.Bonus.9", new Object[] { percent.format(Taming.fastFoodServiceActivationChance) } ) }));
+            }
+        }
+
+        if (canEnvironmentallyAware) {
+            if (skillValue < Taming.environmentallyAwareUnlockLevel) {
+                player.sendMessage(LocaleLoader.getString("Ability.Generic.Template.Lock", new Object[] { LocaleLoader.getString("Taming.Ability.Locked.0", new Object[] { Taming.environmentallyAwareUnlockLevel } ) }));
+            }
+            else {
+                player.sendMessage(LocaleLoader.getString("Ability.Generic.Template", new Object[] { LocaleLoader.getString("Taming.Ability.Bonus.0"), LocaleLoader.getString("Taming.Ability.Bonus.1") }));
+            }
+        }
+
+        if (canThickFur) {
+            if (skillValue < Taming.thickFurUnlockLevel) {
+                player.sendMessage(LocaleLoader.getString("Ability.Generic.Template.Lock", new Object[] { LocaleLoader.getString("Taming.Ability.Locked.1", new Object[] { Taming.thickFurUnlockLevel } ) }));
+            }
+            else {
+                player.sendMessage(LocaleLoader.getString("Ability.Generic.Template", new Object[] { LocaleLoader.getString("Taming.Ability.Bonus.2"), LocaleLoader.getString("Taming.Ability.Bonus.3", new Object[] { Taming.thickFurModifier }) }));
+            }
+        }
+
+        if (canShockProof) {
+            if (skillValue < Taming.shockProofUnlockLevel) {
+                player.sendMessage(LocaleLoader.getString("Ability.Generic.Template.Lock", new Object[] { LocaleLoader.getString("Taming.Ability.Locked.2", new Object[] { Taming.shockProofUnlockLevel } ) }));
+            }
+            else {
+                player.sendMessage(LocaleLoader.getString("Ability.Generic.Template", new Object[] { LocaleLoader.getString("Taming.Ability.Bonus.4"), LocaleLoader.getString("Taming.Ability.Bonus.5", new Object[] { Taming.shockProofModifier }) }));
+            }
+        }
+
+        if (canSharpenedClaws) {
+            if (skillValue < Taming.sharpenedClawsUnlockLevel) {
+                player.sendMessage(LocaleLoader.getString("Ability.Generic.Template.Lock", new Object[] { LocaleLoader.getString("Taming.Ability.Locked.3", new Object[] { Taming.sharpenedClawsUnlockLevel } ) }));
+            }
+            else {
+                player.sendMessage(LocaleLoader.getString("Ability.Generic.Template", new Object[] { LocaleLoader.getString("Taming.Ability.Bonus.6"), LocaleLoader.getString("Taming.Ability.Bonus.7", new Object[] { Taming.sharpenedClawsBonusDamage }) }));
+            }
+        }
+
+        if (canGore) {
+            if (isLucky) {
+                player.sendMessage(LocaleLoader.getString("Taming.Combat.Chance.Gore", new Object[] { goreChance }) + LocaleLoader.getString("Perks.lucky.bonus", new Object[] { goreChanceLucky }));
+            }
+            else {
+                player.sendMessage(LocaleLoader.getString("Taming.Combat.Chance.Gore", new Object[] { goreChance }));
+            }
+        }
+    }
+}

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

@@ -9,8 +9,8 @@ import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
 import org.bukkit.inventory.ItemStack;
 
 import com.gmail.nossr50.config.Config;
-import com.gmail.nossr50.datatypes.SkillType;
 import com.gmail.nossr50.skills.SkillManager;
+import com.gmail.nossr50.skills.SkillType;
 import com.gmail.nossr50.util.Misc;
 import com.gmail.nossr50.util.Permissions;
 

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

@@ -2,8 +2,8 @@ package com.gmail.nossr50.skills.unarmed;
 
 import org.bukkit.entity.Player;
 
-import com.gmail.nossr50.datatypes.SkillType;
 import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.skills.SkillType;
 import com.gmail.nossr50.util.Misc;
 import com.gmail.nossr50.util.Users;
 

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

@@ -0,0 +1,146 @@
+package com.gmail.nossr50.skills.unarmed;
+
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.skills.SkillCommand;
+import com.gmail.nossr50.skills.SkillType;
+import com.gmail.nossr50.util.Permissions;
+
+public class UnarmedCommand extends SkillCommand {
+    private String berserkLength;
+    private String berserkLengthEndurance;
+    private String deflectChance;
+    private String deflectChanceLucky;
+    private String disarmChance;
+    private String disarmChanceLucky;
+    private String ironGripChance;
+    private String ironGripChanceLucky;
+    private String ironArmBonus;
+
+    private boolean canBerserk;
+    private boolean canDisarm;
+    private boolean canBonusDamage;
+    private boolean canDeflect;
+    private boolean canIronGrip;
+
+    public UnarmedCommand() {
+        super(SkillType.UNARMED);
+    }
+
+    @Override
+    protected void dataCalculations() {
+        //BERSERK
+        String[] berserkStrings = calculateLengthDisplayValues();
+        berserkLength = berserkStrings[0];
+        berserkLengthEndurance = berserkStrings[1];
+
+        //DISARM
+        String[] disarmStrings = calculateAbilityDisplayValues(Unarmed.disarmMaxBonusLevel, Unarmed.disarmMaxChance);
+        disarmChance = disarmStrings[0];
+        disarmChanceLucky = disarmStrings[1];
+
+        //DEFLECT
+        String[] deflectStrings = calculateAbilityDisplayValues(Unarmed.deflectMaxBonusLevel, Unarmed.deflectMaxChance);
+        deflectChance = deflectStrings[0];
+        deflectChanceLucky = deflectStrings[1];
+
+        //IRON ARM
+        if (skillValue >= ((Unarmed.ironArmMaxBonusDamage - 3) * Unarmed.ironArmIncreaseLevel)) {
+            ironArmBonus = String.valueOf(Unarmed.ironArmMaxBonusDamage);
+        }
+        else {
+            ironArmBonus = String.valueOf(3 + (skillValue / Unarmed.ironArmIncreaseLevel));
+        }
+
+        //IRON GRIP
+        String[] ironGripStrings = calculateAbilityDisplayValues(Unarmed.ironGripMaxBonusLevel, Unarmed.ironGripMaxChance);
+        ironGripChance = ironGripStrings[0];
+        ironGripChanceLucky = ironGripStrings[1];
+    }
+
+    @Override
+    protected void permissionsCheck() {
+        canBerserk = Permissions.berserk(player);
+        canBonusDamage = Permissions.unarmedBonus(player);
+        canDeflect = Permissions.deflect(player);
+        canDisarm = Permissions.disarm(player);
+        canIronGrip = Permissions.ironGrip(player);
+    }
+
+    @Override
+    protected boolean effectsHeaderPermissions() {
+        return canBerserk || canBonusDamage || canDeflect || canDisarm || canIronGrip;
+    }
+
+    @Override
+    protected void effectsDisplay() {
+        luckyEffectsDisplay();
+
+        if (canBerserk) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Unarmed.Effect.0"), LocaleLoader.getString("Unarmed.Effect.1") }));
+        }
+
+        if (canDisarm) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Unarmed.Effect.2"), LocaleLoader.getString("Unarmed.Effect.3") }));
+        }
+
+        if (canBonusDamage) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Unarmed.Effect.4"), LocaleLoader.getString("Unarmed.Effect.5") }));
+        }
+
+        if (canDeflect) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Unarmed.Effect.6"), LocaleLoader.getString("Unarmed.Effect.7") }));
+        }
+
+        if (canIronGrip) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Unarmed.Effect.8"), LocaleLoader.getString("Unarmed.Effect.9") }));
+        }
+    }
+
+    @Override
+    protected boolean statsHeaderPermissions() {
+        return canBerserk || canBonusDamage || canDeflect || canDisarm || canIronGrip;
+    }
+
+    @Override
+    protected void statsDisplay() {
+        if (canBonusDamage) {
+            player.sendMessage(LocaleLoader.getString("Ability.Generic.Template", new Object[] { LocaleLoader.getString("Unarmed.Ability.Bonus.0"), LocaleLoader.getString("Unarmed.Ability.Bonus.1", new Object[] {ironArmBonus}) }));
+        }
+
+        if (canDeflect) {
+            if (isLucky) {
+                player.sendMessage(LocaleLoader.getString("Unarmed.Ability.Chance.ArrowDeflect", new Object[] { deflectChance }) + LocaleLoader.getString("Perks.lucky.bonus", new Object[] { deflectChanceLucky }));
+            }
+            else {
+                player.sendMessage(LocaleLoader.getString("Unarmed.Ability.Chance.ArrowDeflect", new Object[] { deflectChance }));
+            }
+        }
+
+        if (canDisarm) {
+            if (isLucky) {
+                player.sendMessage(LocaleLoader.getString("Unarmed.Ability.Chance.Disarm", new Object[] { disarmChance }) + LocaleLoader.getString("Perks.lucky.bonus", new Object[] { disarmChanceLucky }));
+            }
+            else {
+                player.sendMessage(LocaleLoader.getString("Unarmed.Ability.Chance.Disarm", new Object[] { disarmChance }));
+            }
+        }
+
+        if (canIronGrip) {
+            if (isLucky) {
+                player.sendMessage(LocaleLoader.getString("Unarmed.Ability.Chance.IronGrip", new Object[] { ironGripChance }) + LocaleLoader.getString("Perks.lucky.bonus", new Object[] { ironGripChanceLucky }));
+            }
+            else {
+                player.sendMessage(LocaleLoader.getString("Unarmed.Ability.Chance.IronGrip", new Object[] { ironGripChance }));
+            }
+        }
+
+        if (canBerserk) {
+            if (hasEndurance) {
+                player.sendMessage(LocaleLoader.getString("Unarmed.Ability.Berserk.Length", new Object[] { berserkLength }) + LocaleLoader.getString("Perks.activationtime.bonus", new Object[] { berserkLengthEndurance }));
+            }
+            else {
+                player.sendMessage(LocaleLoader.getString("Unarmed.Ability.Berserk.Length", new Object[] { berserkLength }));
+            }
+        }
+    }
+}

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

@@ -3,8 +3,8 @@ package com.gmail.nossr50.skills.unarmed;
 import org.bukkit.entity.Player;
 import org.bukkit.event.entity.EntityDamageEvent;
 
-import com.gmail.nossr50.datatypes.SkillType;
 import com.gmail.nossr50.skills.SkillManager;
+import com.gmail.nossr50.skills.SkillType;
 import com.gmail.nossr50.util.Misc;
 import com.gmail.nossr50.util.Permissions;
 

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

@@ -1,4 +1,4 @@
-package com.gmail.nossr50.skills.gathering;
+package com.gmail.nossr50.skills.woodcutting;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -19,20 +19,20 @@ import org.getspout.spoutapi.sound.SoundEffect;
 import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.config.AdvancedConfig;
 import com.gmail.nossr50.config.Config;
-import com.gmail.nossr50.datatypes.SkillType;
 import com.gmail.nossr50.datatypes.mods.CustomBlock;
 import com.gmail.nossr50.events.fake.FakePlayerAnimationEvent;
 import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.skills.Combat;
+import com.gmail.nossr50.skills.SkillType;
+import com.gmail.nossr50.skills.Skills;
 import com.gmail.nossr50.spout.SpoutSounds;
 import com.gmail.nossr50.util.BlockChecks;
-import com.gmail.nossr50.util.Combat;
 import com.gmail.nossr50.util.Misc;
 import com.gmail.nossr50.util.ModChecks;
 import com.gmail.nossr50.util.Permissions;
-import com.gmail.nossr50.util.Skills;
 import com.gmail.nossr50.util.Users;
 
-public class WoodCutting {
+public class Woodcutting {
     private static final AdvancedConfig ADVANCED_CONFIG = AdvancedConfig.getInstance();
     private static boolean treeFellerReachedThreshold = false;
 
@@ -95,7 +95,7 @@ public class WoodCutting {
             }
 
             if (block.getType() == Material.LOG) {
-                WoodCutting.woodCuttingProcCheck(player, block);
+                Woodcutting.woodCuttingProcCheck(player, block);
 
                 TreeSpecies species = ((Tree) block.getState().getData()).getSpecies();
 
@@ -131,7 +131,7 @@ public class WoodCutting {
                 if (ModChecks.isCustomLogBlock(block)) {
                     CustomBlock customBlock = ModChecks.getCustomBlock(block);
 
-                    WoodCutting.woodCuttingProcCheck(player, block);
+                    Woodcutting.woodCuttingProcCheck(player, block);
 
                     xp = customBlock.getXpGain();
                     int minimumDropAmount = customBlock.getMinimumDropAmount();
@@ -378,7 +378,7 @@ public class WoodCutting {
             }
         }
 
-        WoodCutting.woodCuttingProcCheck(player, block);
+        Woodcutting.woodCuttingProcCheck(player, block);
         Skills.xpProcessing(player,  Users.getProfile(player), SkillType.WOODCUTTING, xp);
     }
 

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

@@ -0,0 +1,102 @@
+package com.gmail.nossr50.skills.woodcutting;
+
+import com.gmail.nossr50.config.AdvancedConfig;
+import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.skills.SkillCommand;
+import com.gmail.nossr50.skills.SkillType;
+import com.gmail.nossr50.util.Permissions;
+
+public class WoodcuttingCommand extends SkillCommand {
+    AdvancedConfig advancedConfig = AdvancedConfig.getInstance();
+    private String treeFellerLength;
+    private String treeFellerLengthEndurance;
+    private String doubleDropChance;
+    private String doubleDropChanceLucky;
+
+    private boolean canTreeFell;
+    private boolean canLeafBlow;
+    private boolean canDoubleDrop;
+    private boolean doubleDropsDisabled;
+
+    public WoodcuttingCommand() {
+        super(SkillType.WOODCUTTING);
+    }
+
+    @Override
+    protected void dataCalculations() {
+        //TREE FELLER
+        String[] treeFellerStrings = calculateLengthDisplayValues();
+        treeFellerLength = treeFellerStrings[0];
+        treeFellerLengthEndurance = treeFellerStrings[1];
+
+        //DOUBLE DROPS
+        String[] doubleDropStrings = calculateAbilityDisplayValues(Woodcutting.doubleDropsMaxLevel, Woodcutting.doubleDropsMaxChance);
+        doubleDropChance = doubleDropStrings[0];
+        doubleDropChanceLucky = doubleDropStrings[1];
+    }
+
+    @Override
+    protected void permissionsCheck() {
+        canTreeFell = Permissions.treeFeller(player);
+        canDoubleDrop = Permissions.woodcuttingDoubleDrops(player);
+        canLeafBlow = Permissions.leafBlower(player);
+        doubleDropsDisabled = Woodcutting.doubleDropsDisabled;
+    }
+
+    @Override
+    protected boolean effectsHeaderPermissions() {
+        return (canDoubleDrop && !doubleDropsDisabled) || canLeafBlow || canTreeFell;
+    }
+
+    @Override
+    protected void effectsDisplay() {
+        luckyEffectsDisplay();
+
+        if (canTreeFell) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Woodcutting.Effect.0"), LocaleLoader.getString("Woodcutting.Effect.1") }));
+        }
+
+        if (canLeafBlow) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Woodcutting.Effect.2"), LocaleLoader.getString("Woodcutting.Effect.3") }));
+        }
+
+        if (canDoubleDrop && !doubleDropsDisabled) {
+            player.sendMessage(LocaleLoader.getString("Effects.Template", new Object[] { LocaleLoader.getString("Woodcutting.Effect.4"), LocaleLoader.getString("Woodcutting.Effect.5") }));
+        }
+    }
+
+    @Override
+    protected boolean statsHeaderPermissions() {
+        return (canDoubleDrop && !doubleDropsDisabled) || canLeafBlow || canTreeFell;
+    }
+
+    @Override
+    protected void statsDisplay() {
+        if (canLeafBlow) {
+            if (skillValue < Woodcutting.leafBlowerUnlockLevel) {
+                player.sendMessage(LocaleLoader.getString("Ability.Generic.Template.Lock", new Object[] { LocaleLoader.getString("Woodcutting.Ability.Locked.0", new Object[] { Woodcutting.leafBlowerUnlockLevel }) }));
+            }
+            else {
+                player.sendMessage(LocaleLoader.getString("Ability.Generic.Template", new Object[] { LocaleLoader.getString("Woodcutting.Ability.0"), LocaleLoader.getString("Woodcutting.Ability.1") }));
+            }
+        }
+
+        if (canDoubleDrop && !doubleDropsDisabled) {
+            if (isLucky) {
+                player.sendMessage(LocaleLoader.getString("Woodcutting.Ability.Chance.DDrop", new Object[] { doubleDropChance }) + LocaleLoader.getString("Perks.lucky.bonus", new Object[] { doubleDropChanceLucky }));
+            }
+            else {
+                player.sendMessage(LocaleLoader.getString("Woodcutting.Ability.Chance.DDrop", new Object[] { doubleDropChance }));
+            }
+        }
+
+        if (canTreeFell) {
+            if (hasEndurance) {
+                player.sendMessage(LocaleLoader.getString("Woodcutting.Ability.Length", new Object[] { treeFellerLength }) + LocaleLoader.getString("Perks.activationtime.bonus", new Object[] { treeFellerLengthEndurance }));
+            }
+            else {
+                player.sendMessage(LocaleLoader.getString("Woodcutting.Ability.Length", new Object[] { treeFellerLength }));
+            }
+        }
+    }
+}