Fixes for importing profiles while the server is running

- Have the active database return unloaded profiles during import (this triggers the giant warning messages)
 - Reload the users AFTER the conversion is complete, not BEFORE

Changelog.txt

@@ -8,20 +8,26 @@ Key:
   - Removal
 
 Version 1.4.08-dev
+ + Added SecondaryAbilityType enum, and new SecondaryAbilityWeightedActivationCheckEvent, fired when a secondary ability checkes its activation chances
  + Added the possibility to gain experience when using Fishing "Shake"
  + Added config options to disable various sound effects
  + Smelting now works with custom ores - add smelting XP value to blocks.yml, or it will default to 1/10th of normal XP.
  + Added automatic cleanup of backups folder.
  + Added bypass permission for finding Fishing traps
+ = Fixed bug where LeafBlower permissions were ignored
  = Fixed bug with toggle commands not properly displaying the success message.
  = Fixed IllegalArgumentException caused by an empty Fishing treasure category
  = Fixed bug with Salvage not reading the config value for the anvil material.
  = Fixed exploit where you could receive smelting XP for improper items
  = Fixed bug where the Unbreaking enchantment was ignored when using "Super Breaker" or "Giga Drill Breaker"
  = Fixed bug which prevented players from gaining Acrobatics XP when the setting 'Prevent_XP_After_Teleport' was set to false
- = Fixed McMMOPlayerDisarmEvent reporting the skill level of the defending player, not the attacking player.
- = Fixed bug where arrow retrieval was not properly detecting entities that already existed in the tracker
+ = Fixed bug where cooldown donor perks were reducing more than expected
+ = Fixed bug where disabling hardcore mode for specific skills didn't work
+ = Fixed bug which caused the backup cleanup to delete old backups while it should have kept those
+ = Fixed bug where party chat broke if the display name contained special characters
  ! Updated localization files
+ ! Changed AxesCritical to CriticalHit in config file
+ ! Changed several secondary ability permissions(deprecated versions still exist)
 
 Version 1.4.07
  + Added XP boost to Acrobatics when wearing Boots of Feather Falling

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

@@ -1,5 +1,8 @@
 package com.gmail.nossr50.chat;
 
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
 import org.bukkit.ChatColor;
 import org.bukkit.entity.Player;
 import org.bukkit.plugin.Plugin;
@@ -27,7 +30,7 @@ public class PartyChatManager extends ChatManager {
     @Override
     protected void sendMessage() {
         if (Config.getInstance().getPartyChatColorLeaderName() && senderName.equalsIgnoreCase(party.getLeader())) {
-            message = message.replaceFirst(displayName, ChatColor.GOLD + displayName + ChatColor.RESET);
+            message = message.replaceFirst(Pattern.quote(displayName), ChatColor.GOLD + Matcher.quoteReplacement(displayName) + ChatColor.RESET);
         }
 
         for (Player member : party.getOnlineMembers()) {

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

@@ -3,13 +3,10 @@ package com.gmail.nossr50.commands.database;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandExecutor;
 import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-
 import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.database.DatabaseManager;
 import com.gmail.nossr50.database.DatabaseManagerFactory;
 import com.gmail.nossr50.datatypes.database.DatabaseType;
-import com.gmail.nossr50.datatypes.player.PlayerProfile;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.runnables.database.DatabaseConversionTask;
 import com.gmail.nossr50.util.player.UserManager;
@@ -52,17 +49,6 @@ public class ConvertDatabaseCommand implements CommandExecutor {
                 sender.sendMessage(LocaleLoader.getString("Commands.mcconvert.Database.Start", previousType.toString(), newType.toString()));
 
                 UserManager.saveAll();
-                UserManager.clearAll();
-
-                for (Player player : mcMMO.p.getServer().getOnlinePlayers()) {
-                    PlayerProfile profile = oldDatabase.loadPlayerProfile(player.getName(), false);
-
-                    if (profile.isLoaded()) {
-                        mcMMO.getDatabaseManager().saveUser(profile);
-                    }
-
-                    UserManager.addUser(player);
-                }
 
                 new DatabaseConversionTask(oldDatabase, sender, previousType.toString(), newType.toString()).runTaskAsynchronously(mcMMO.p);
                 return true;

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

@@ -52,7 +52,12 @@ public abstract class ExperienceCommand implements TabExecutor {
                     return true;
                 }
 
-                SkillType skill = SkillType.getSkill(args[1]);
+                SkillType skill;
+                if (args[1].equalsIgnoreCase("all")) {
+                    skill = null;
+                } else {
+                    skill = SkillType.getSkill(args[1]);
+                }
                 int value = Integer.parseInt(args[2]);
 
                 String playerName = Misc.getMatchedPlayerName(args[0]);
@@ -100,7 +105,7 @@ public abstract class ExperienceCommand implements TabExecutor {
     protected abstract void handlePlayerMessageSkill(Player player, int value, SkillType skill);
 
     private boolean validateArguments(CommandSender sender, String skillName, String value) {
-        if (CommandUtils.isInvalidInteger(sender, value) || CommandUtils.isInvalidSkill(sender, skillName)) {
+        if (CommandUtils.isInvalidInteger(sender, value) || (!skillName.equalsIgnoreCase("all") && CommandUtils.isInvalidSkill(sender, skillName))) {
             return false;
         }
 

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

@@ -22,6 +22,10 @@ import com.gmail.nossr50.util.commands.CommandUtils;
 import com.gmail.nossr50.util.player.UserManager;
 import com.google.common.collect.ImmutableList;
 
+/**
+ * This class mirrors the structure of ExperienceCommand, except the
+ * value/quantity argument is removed.
+ */
 public class SkillresetCommand implements TabExecutor {
     @Override
     public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
@@ -31,29 +35,35 @@ public class SkillresetCommand implements TabExecutor {
                     return true;
                 }
 
-                if (!Permissions.skillreset(sender)) {
+                if (!permissionsCheckSelf(sender)) {
                     sender.sendMessage(command.getPermissionMessage());
                     return true;
                 }
 
-                if (CommandUtils.isInvalidSkill(sender, args[0])) {
+                if (!validateArguments(sender, args[0])) {
                     return true;
                 }
 
-                editValues((Player) sender, UserManager.getPlayer(sender.getName()).getProfile(), SkillType.getSkill(args[0]), args.length, sender, command);
+                editValues((Player) sender, UserManager.getPlayer(sender.getName()).getProfile(), SkillType.getSkill(args[0]));
                 return true;
 
             case 2:
-                if (!Permissions.skillresetOthers(sender)) {
+                if (!permissionsCheckOthers(sender)) {
                     sender.sendMessage(command.getPermissionMessage());
                     return true;
                 }
 
-                if (CommandUtils.isInvalidSkill(sender, args[1])) {
+                if (!validateArguments(sender, args[1])) {
                     return true;
                 }
 
-                SkillType skill = SkillType.getSkill(args[1]);
+                SkillType skill;
+                if (args[1].equalsIgnoreCase("all")) {
+                    skill = null;
+                }
+                else {
+                    skill = SkillType.getSkill(args[1]);
+                }
 
                 String playerName = Misc.getMatchedPlayerName(args[0]);
                 McMMOPlayer mcMMOPlayer = UserManager.getPlayer(playerName, true);
@@ -66,13 +76,13 @@ public class SkillresetCommand implements TabExecutor {
                         return true;
                     }
 
-                    editValues(null, profile, skill, args.length, sender, command);
+                    editValues(null, profile, skill);
                 }
                 else {
-                    editValues(mcMMOPlayer.getPlayer(), mcMMOPlayer.getProfile(), skill, args.length, sender, command);
+                    editValues(mcMMOPlayer.getPlayer(), mcMMOPlayer.getProfile(), skill);
                 }
 
-                ExperienceCommand.handleSenderMessage(sender, playerName, skill);
+                handleSenderMessage(sender, playerName, skill);
                 return true;
 
             default:
@@ -93,31 +103,7 @@ public class SkillresetCommand implements TabExecutor {
         }
     }
 
-    private void editValues(Player player, PlayerProfile profile, SkillType skill, int argsLength, CommandSender sender, Command command) {
-        if (skill == null) {
-            for (SkillType skillType : SkillType.values()) {
-                handleCommand(player, profile, skillType, argsLength, sender, command);
-            }
-
-            if (player != null) {
-                player.sendMessage(LocaleLoader.getString("Commands.Reset.All"));
-            }
-        }
-        else {
-            handleCommand(player, profile, skill, argsLength, sender, command);
-
-            if (player != null) {
-                player.sendMessage(LocaleLoader.getString("Commands.Reset.Single", skill.getName()));
-            }
-        }
-    }
-
-    private void handleCommand(Player player, PlayerProfile profile, SkillType skill, int argsLength, CommandSender sender, Command command) {
-        if (argsLength == 1 && !Permissions.skillreset(sender, skill) || (argsLength == 2 && !Permissions.skillresetOthers(sender, skill))) {
-            sender.sendMessage(command.getPermissionMessage());
-            return;
-        }
-
+    protected void handleCommand(Player player, PlayerProfile profile, SkillType skill) {
         int levelsRemoved = profile.getSkillLevel(skill);
         float xpRemoved = profile.getSkillXpLevelRaw(skill);
 
@@ -130,4 +116,56 @@ public class SkillresetCommand implements TabExecutor {
 
         EventUtils.handleLevelChangeEvent(player, skill, levelsRemoved, xpRemoved, false);
     }
+
+    protected boolean permissionsCheckSelf(CommandSender sender) {
+        return Permissions.skillreset(sender);
+    }
+
+    protected boolean permissionsCheckOthers(CommandSender sender) {
+        return Permissions.skillresetOthers(sender);
+    }
+
+    protected void handlePlayerMessageAll(Player player) {
+        player.sendMessage(LocaleLoader.getString("Commands.Reset.All"));
+    }
+
+    protected void handlePlayerMessageSkill(Player player, SkillType skill) {
+        player.sendMessage(LocaleLoader.getString("Commands.Reset.Single", skill.getName()));
+    }
+
+    private boolean validateArguments(CommandSender sender, String skillName) {
+        if (CommandUtils.isInvalidSkill(sender, skillName) && !skillName.equalsIgnoreCase("all")) {
+            return false;
+        }
+
+        return true;
+    }
+
+    protected static void handleSenderMessage(CommandSender sender, String playerName, SkillType skill) {
+        if (skill == null) {
+            sender.sendMessage(LocaleLoader.getString("Commands.addlevels.AwardAll.2", playerName));
+        }
+        else {
+            sender.sendMessage(LocaleLoader.getString("Commands.addlevels.AwardSkill.2", skill.getName(), playerName));
+        }
+    }
+
+    protected void editValues(Player player, PlayerProfile profile, SkillType skill) {
+        if (skill == null) {
+            for (SkillType skillType : SkillType.values()) {
+                handleCommand(player, profile, skillType);
+            }
+
+            if (player != null) {
+                handlePlayerMessageAll(player);
+            }
+        }
+        else {
+            handleCommand(player, profile, skill);
+
+            if (player != null) {
+                handlePlayerMessageSkill(player, skill);
+            }
+        }
+    }
 }

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

@@ -41,7 +41,7 @@ public class MccooldownCommand implements TabExecutor {
                 player.sendMessage(LocaleLoader.getString("Commands.Cooldowns.Header"));
                 player.sendMessage(LocaleLoader.getString("mcMMO.NoSkillNote"));
 
-                for (AbilityType ability : AbilityType.NORMAL_ABILITIES) {
+                for (AbilityType ability : AbilityType.values()) {
                     if (!ability.getPermissions(player)) {
                         continue;
                     }

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

@@ -5,9 +5,9 @@ import java.util.List;
 
 import org.bukkit.entity.Player;
 
+import com.gmail.nossr50.datatypes.skills.SecondaryAbility;
 import com.gmail.nossr50.datatypes.skills.SkillType;
 import com.gmail.nossr50.locale.LocaleLoader;
-import com.gmail.nossr50.skills.acrobatics.Acrobatics;
 import com.gmail.nossr50.util.Permissions;
 
 public class AcrobaticsCommand extends SkillCommand {
@@ -30,21 +30,21 @@ public class AcrobaticsCommand extends SkillCommand {
     protected void dataCalculations(Player player, float skillValue, boolean isLucky) {
         // DODGE
         if (canDodge) {
-            String[] dodgeStrings = calculateAbilityDisplayValues(skillValue, Acrobatics.dodgeMaxBonusLevel, Acrobatics.dodgeMaxChance, isLucky);
+            String[] dodgeStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.DODGE, isLucky);
             dodgeChance = dodgeStrings[0];
             dodgeChanceLucky = dodgeStrings[1];
         }
 
         // ROLL
         if (canRoll) {
-            String[] rollStrings = calculateAbilityDisplayValues(skillValue, Acrobatics.rollMaxBonusLevel, Acrobatics.rollMaxChance, isLucky);
+            String[] rollStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.ROLL, isLucky);
             rollChance = rollStrings[0];
             rollChanceLucky = rollStrings[1];
         }
 
         // GRACEFUL ROLL
         if (canGracefulRoll) {
-            String[] gracefulRollStrings = calculateAbilityDisplayValues(skillValue, Acrobatics.gracefulRollMaxBonusLevel, Acrobatics.gracefulRollMaxChance, isLucky);
+            String[] gracefulRollStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.GRACEFUL_ROLL, isLucky);
             gracefulRollChance = gracefulRollStrings[0];
             gracefulRollChanceLucky = gracefulRollStrings[1];
         }
@@ -52,9 +52,9 @@ public class AcrobaticsCommand extends SkillCommand {
 
     @Override
     protected void permissionsCheck(Player player) {
-        canDodge = Permissions.dodge(player);
-        canRoll = Permissions.roll(player);
-        canGracefulRoll = Permissions.gracefulRoll(player);
+        canDodge = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.DODGE);
+        canRoll = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.ROLL);
+        canGracefulRoll = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.GRACEFUL_ROLL);
     }
 
     @Override

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

@@ -5,6 +5,7 @@ import java.util.List;
 
 import org.bukkit.entity.Player;
 
+import com.gmail.nossr50.datatypes.skills.SecondaryAbility;
 import com.gmail.nossr50.datatypes.skills.SkillType;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.skills.archery.Archery;
@@ -35,14 +36,14 @@ public class ArcheryCommand extends SkillCommand {
 
         // DAZE
         if (canDaze) {
-            String[] dazeStrings = calculateAbilityDisplayValues(skillValue, Archery.dazeMaxBonusLevel, Archery.dazeMaxBonus, isLucky);
+            String[] dazeStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.DAZE, isLucky);
             dazeChance = dazeStrings[0];
             dazeChanceLucky = dazeStrings[1];
         }
 
         // RETRIEVE
         if (canRetrieve) {
-            String[] retrieveStrings = calculateAbilityDisplayValues(skillValue, Archery.retrieveMaxBonusLevel, Archery.retrieveMaxChance, isLucky);
+            String[] retrieveStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.RETRIEVE, isLucky);
             retrieveChance = retrieveStrings[0];
             retrieveChanceLucky = retrieveStrings[1];
         }
@@ -50,9 +51,9 @@ public class ArcheryCommand extends SkillCommand {
 
     @Override
     protected void permissionsCheck(Player player) {
-        canSkillShot = Permissions.bonusDamage(player, skill);
-        canDaze = Permissions.daze(player);
-        canRetrieve = Permissions.arrowRetrieval(player);
+        canSkillShot = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.SKILL_SHOT);
+        canDaze = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.DAZE);
+        canRetrieve = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.RETRIEVE);
     }
 
     @Override

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

@@ -5,6 +5,7 @@ import java.util.List;
 
 import org.bukkit.entity.Player;
 
+import com.gmail.nossr50.datatypes.skills.SecondaryAbility;
 import com.gmail.nossr50.datatypes.skills.SkillType;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.skills.axes.Axes;
@@ -13,14 +14,14 @@ import com.gmail.nossr50.util.Permissions;
 public class AxesCommand extends SkillCommand {
     private String critChance;
     private String critChanceLucky;
-    private double bonusDamage;
+    private double axeMasteryDamage;
     private double impactDamage;
     private String skullSplitterLength;
     private String skullSplitterLengthEndurance;
 
     private boolean canSkullSplitter;
     private boolean canCritical;
-    private boolean canBonusDamage;
+    private boolean canAxeMastery;
     private boolean canImpact;
     private boolean canGreaterImpact;
 
@@ -30,7 +31,7 @@ public class AxesCommand extends SkillCommand {
 
     @Override
     protected void dataCalculations(Player player, float skillValue, boolean isLucky) {
-        // IMPACT
+        // ARMOR IMPACT
         if (canImpact) {
             impactDamage = 1 + (skillValue / Axes.impactIncreaseLevel);
         }
@@ -42,26 +43,26 @@ public class AxesCommand extends SkillCommand {
             skullSplitterLengthEndurance = skullSplitterStrings[1];
         }
 
-        // CRITICAL STRIKES
+        // CRITICAL HIT
         if (canCritical) {
-            String[] criticalStrikeStrings = calculateAbilityDisplayValues(skillValue, Axes.criticalHitMaxBonusLevel, Axes.criticalHitMaxChance, isLucky);
-            critChance = criticalStrikeStrings[0];
-            critChanceLucky = criticalStrikeStrings[1];
+            String[] criticalHitStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.CRITICAL_HIT, isLucky);
+            critChance = criticalHitStrings[0];
+            critChanceLucky = criticalHitStrings[1];
         }
 
         // AXE MASTERY
-        if (canBonusDamage) {
-            bonusDamage = Math.min(skillValue / (Axes.bonusDamageMaxBonusLevel / Axes.bonusDamageMaxBonus), Axes.bonusDamageMaxBonus);
+        if (canAxeMastery) {
+            axeMasteryDamage = Math.min(skillValue / (Axes.axeMasteryMaxBonusLevel / Axes.axeMasteryMaxBonus), Axes.axeMasteryMaxBonus);
         }
     }
 
     @Override
     protected void permissionsCheck(Player player) {
         canSkullSplitter = Permissions.skullSplitter(player);
-        canCritical = Permissions.criticalStrikes(player);
-        canBonusDamage = Permissions.bonusDamage(player, skill);
-        canImpact = Permissions.armorImpact(player);
-        canGreaterImpact = Permissions.greaterImpact(player);
+        canCritical = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.CRITICAL_HIT);
+        canAxeMastery = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.AXE_MASTERY);
+        canImpact = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.ARMOR_IMPACT);
+        canGreaterImpact = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.GREATER_IMPACT);
     }
 
     @Override
@@ -76,7 +77,7 @@ public class AxesCommand extends SkillCommand {
             messages.add(LocaleLoader.getString("Effects.Template", LocaleLoader.getString("Axes.Effect.2"), LocaleLoader.getString("Axes.Effect.3")));
         }
 
-        if (canBonusDamage) {
+        if (canAxeMastery) {
             messages.add(LocaleLoader.getString("Effects.Template", LocaleLoader.getString("Axes.Effect.4"), LocaleLoader.getString("Axes.Effect.5")));
         }
 
@@ -95,8 +96,8 @@ public class AxesCommand extends SkillCommand {
     protected List<String> statsDisplay(Player player, float skillValue, boolean hasEndurance, boolean isLucky) {
         List<String> messages = new ArrayList<String>();
 
-        if (canBonusDamage) {
-            messages.add(LocaleLoader.getString("Ability.Generic.Template", LocaleLoader.getString("Axes.Ability.Bonus.0"), LocaleLoader.getString("Axes.Ability.Bonus.1", bonusDamage)));
+        if (canAxeMastery) {
+            messages.add(LocaleLoader.getString("Ability.Generic.Template", LocaleLoader.getString("Axes.Ability.Bonus.0"), LocaleLoader.getString("Axes.Ability.Bonus.1", axeMasteryDamage)));
         }
 
         if (canImpact) {

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

@@ -5,6 +5,7 @@ import java.util.List;
 
 import org.bukkit.entity.Player;
 
+import com.gmail.nossr50.datatypes.skills.SecondaryAbility;
 import com.gmail.nossr50.datatypes.skills.SkillType;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.util.Permissions;
@@ -33,7 +34,7 @@ public class ExcavationCommand extends SkillCommand {
     @Override
     protected void permissionsCheck(Player player) {
         canGigaDrill = Permissions.gigaDrillBreaker(player);
-        canTreasureHunt = Permissions.excavationTreasureHunter(player);
+        canTreasureHunt = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.EXCAVATION_TREASURE_HUNTER);
     }
 
     @Override

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

@@ -10,6 +10,7 @@ import org.bukkit.entity.Player;
 
 import com.gmail.nossr50.config.AdvancedConfig;
 import com.gmail.nossr50.config.treasure.TreasureConfig;
+import com.gmail.nossr50.datatypes.skills.SecondaryAbility;
 import com.gmail.nossr50.datatypes.skills.SkillType;
 import com.gmail.nossr50.datatypes.treasure.Rarity;
 import com.gmail.nossr50.locale.LocaleLoader;
@@ -114,12 +115,12 @@ public class FishingCommand extends SkillCommand {
 
     @Override
     protected void permissionsCheck(Player player) {
-        canTreasureHunt = Permissions.fishingTreasureHunter(player);
-        canMagicHunt = Permissions.magicHunter(player);
-        canShake = Permissions.shake(player);
-        canFishermansDiet = Permissions.fishermansDiet(player);
-        canMasterAngler = Permissions.masterAngler(player);
-        canIceFish = Permissions.iceFishing(player);
+        canTreasureHunt = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.FISHING_TREASURE_HUNTER);
+        canMagicHunt = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.MAGIC_HUNTER);
+        canShake = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.SHAKE);
+        canFishermansDiet = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.FISHERMANS_DIET);
+        canMasterAngler = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.MASTER_ANGLER);
+        canIceFish = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.ICE_FISHING);
     }
 
     @Override

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

@@ -6,6 +6,7 @@ import java.util.List;
 import org.bukkit.Material;
 import org.bukkit.entity.Player;
 
+import com.gmail.nossr50.datatypes.skills.SecondaryAbility;
 import com.gmail.nossr50.datatypes.skills.SkillType;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.skills.herbalism.Herbalism;
@@ -55,28 +56,28 @@ public class HerbalismCommand extends SkillCommand {
         if (canGreenThumbBlocks || canGreenThumbPlants) {
             greenThumbStage = calculateRank(skillValue, Herbalism.greenThumbStageMaxLevel, Herbalism.greenThumbStageChangeLevel);
 
-            String[] greenThumbStrings = calculateAbilityDisplayValues(skillValue, Herbalism.greenThumbMaxLevel, Herbalism.greenThumbMaxChance, isLucky);
+            String[] greenThumbStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.GREEN_THUMB_PLANT, isLucky);
             greenThumbChance = greenThumbStrings[0];
             greenThumbChanceLucky = greenThumbStrings[1];
         }
 
         // DOUBLE DROPS
         if (canDoubleDrop) {
-            String[] doubleDropStrings = calculateAbilityDisplayValues(skillValue, Herbalism.doubleDropsMaxLevel, Herbalism.doubleDropsMaxChance, isLucky);
+            String[] doubleDropStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.HERBALISM_DOUBLE_DROPS, isLucky);
             doubleDropChance = doubleDropStrings[0];
             doubleDropChanceLucky = doubleDropStrings[1];
         }
 
         // HYLIAN LUCK
         if (hasHylianLuck) {
-            String[] hylianLuckStrings = calculateAbilityDisplayValues(skillValue, Herbalism.hylianLuckMaxLevel, Herbalism.hylianLuckMaxChance, isLucky);
+            String[] hylianLuckStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.HYLIAN_LUCK, isLucky);
             hylianLuckChance = hylianLuckStrings[0];
             hylianLuckChanceLucky = hylianLuckStrings[1];
         }
 
         // SHROOM THUMB
         if (canShroomThumb) {
-            String[] shroomThumbStrings = calculateAbilityDisplayValues(skillValue, Herbalism.shroomThumbMaxLevel, Herbalism.shroomThumbMaxChance, isLucky);
+            String[] shroomThumbStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.SHROOM_THUMB, isLucky);
             shroomThumbChance = shroomThumbStrings[0];
             shroomThumbChanceLucky = shroomThumbStrings[1];
         }
@@ -84,13 +85,13 @@ public class HerbalismCommand extends SkillCommand {
 
     @Override
     protected void permissionsCheck(Player player) {
-        hasHylianLuck = Permissions.hylianLuck(player);
+        hasHylianLuck = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.HYLIAN_LUCK);
         canGreenTerra = Permissions.greenTerra(player);
         canGreenThumbPlants = Permissions.greenThumbPlant(player, Material.CROPS) || Permissions.greenThumbPlant(player, Material.CARROT) || Permissions.greenThumbPlant(player, Material.POTATO) || Permissions.greenThumbPlant(player, Material.NETHER_WARTS) || Permissions.greenThumbPlant(player, Material.COCOA);
         canGreenThumbBlocks = Permissions.greenThumbBlock(player, Material.DIRT) || Permissions.greenThumbBlock(player, Material.COBBLESTONE) || Permissions.greenThumbBlock(player, Material.COBBLE_WALL) || Permissions.greenThumbBlock(player, Material.SMOOTH_BRICK);
-        canFarmersDiet = Permissions.farmersDiet(player);
-        canDoubleDrop = Permissions.doubleDrops(player, skill) && !skill.getDoubleDropsDisabled();
-        canShroomThumb = Permissions.shroomThumb(player);
+        canFarmersDiet = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.FARMERS_DIET);
+        canDoubleDrop = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.HERBALISM_DOUBLE_DROPS) && !skill.getDoubleDropsDisabled();
+        canShroomThumb = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.SHROOM_THUMB);
     }
 
     @Override

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

@@ -6,10 +6,10 @@ import java.util.List;
 import org.bukkit.entity.Player;
 
 import com.gmail.nossr50.config.AdvancedConfig;
+import com.gmail.nossr50.datatypes.skills.SecondaryAbility;
 import com.gmail.nossr50.datatypes.skills.SkillType;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.skills.mining.BlastMining.Tier;
-import com.gmail.nossr50.skills.mining.Mining;
 import com.gmail.nossr50.skills.mining.MiningManager;
 import com.gmail.nossr50.util.Permissions;
 import com.gmail.nossr50.util.player.UserManager;
@@ -48,7 +48,7 @@ public class MiningCommand extends SkillCommand {
 
         // DOUBLE DROPS
         if (canDoubleDrop) {
-            String[] doubleDropStrings = calculateAbilityDisplayValues(skillValue, Mining.doubleDropsMaxLevel, Mining.doubleDropsMaxChance, isLucky);
+            String[] doubleDropStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.MINING_DOUBLE_DROPS, isLucky);
             doubleDropChance = doubleDropStrings[0];
             doubleDropChanceLucky = doubleDropStrings[1];
         }
@@ -71,7 +71,7 @@ public class MiningCommand extends SkillCommand {
         canBiggerBombs = Permissions.biggerBombs(player);
         canBlast = Permissions.remoteDetonation(player);
         canDemoExpert = Permissions.demolitionsExpertise(player);
-        canDoubleDrop = Permissions.doubleDrops(player, skill) && !skill.getDoubleDropsDisabled();
+        canDoubleDrop = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.MINING_DOUBLE_DROPS) && !skill.getDoubleDropsDisabled();
         canSuperBreaker = Permissions.superBreaker(player);
     }
 

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

@@ -7,6 +7,7 @@ import org.bukkit.Material;
 import org.bukkit.entity.Player;
 
 import com.gmail.nossr50.mcMMO;
+import com.gmail.nossr50.datatypes.skills.SecondaryAbility;
 import com.gmail.nossr50.datatypes.skills.SkillType;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.skills.repair.ArcaneForging;
@@ -65,7 +66,7 @@ public class RepairCommand extends SkillCommand {
 
         // SUPER REPAIR
         if (canSuperRepair) {
-            String[] superRepairStrings = calculateAbilityDisplayValues(skillValue, Repair.superRepairMaxBonusLevel, Repair.superRepairMaxChance, isLucky);
+            String[] superRepairStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.SUPER_REPAIR, isLucky);
             superRepairChance = superRepairStrings[0];
             superRepairChanceLucky = superRepairStrings[1];
         }
@@ -73,10 +74,10 @@ public class RepairCommand extends SkillCommand {
 
     @Override
     protected void permissionsCheck(Player player) {
-        canSuperRepair = Permissions.superRepair(player);
-        canMasterRepair = Permissions.repairMastery(player);
-        canArcaneForge = Permissions.arcaneForging(player);
-        canSalvage = Permissions.salvage(player);
+        canSuperRepair = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.SUPER_REPAIR);
+        canMasterRepair = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.REPAIR_MASTERY);
+        canArcaneForge = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.ARCANE_FORGING);
+        canSalvage = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.SALVAGE);
         canRepairDiamond = Permissions.repairDiamond(player);
         canRepairGold = Permissions.repairGold(player);
         canRepairIron = Permissions.repairIron(player);

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

@@ -13,6 +13,7 @@ import org.bukkit.entity.Player;
 import com.gmail.nossr50.config.AdvancedConfig;
 import com.gmail.nossr50.config.Config;
 import com.gmail.nossr50.datatypes.player.McMMOPlayer;
+import com.gmail.nossr50.datatypes.skills.SecondaryAbility;
 import com.gmail.nossr50.datatypes.skills.SkillType;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.skills.child.FamilyTree;
@@ -136,8 +137,10 @@ public abstract class SkillCommand implements TabExecutor {
         return displayValues;
     }
 
-    protected String[] calculateAbilityDisplayValues(float skillValue, int maxBonusLevel, double maxChance, boolean isLucky) {
-        return calculateAbilityDisplayValues((maxChance / maxBonusLevel) * Math.min(skillValue, maxBonusLevel), isLucky);
+    protected String[] calculateAbilityDisplayValues(float skillValue, SecondaryAbility skillAbility, boolean isLucky) {
+        int maxBonusLevel = AdvancedConfig.getInstance().getMaxBonusLevel(skillAbility);
+
+        return calculateAbilityDisplayValues((AdvancedConfig.getInstance().getMaxChance(skillAbility) / maxBonusLevel) * Math.min(skillValue, maxBonusLevel), isLucky);
     }
 
     protected String[] calculateLengthDisplayValues(Player player, float skillValue) {

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

@@ -6,6 +6,7 @@ import java.util.List;
 import org.bukkit.entity.Player;
 
 import com.gmail.nossr50.config.AdvancedConfig;
+import com.gmail.nossr50.datatypes.skills.SecondaryAbility;
 import com.gmail.nossr50.datatypes.skills.SkillType;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.skills.smelting.Smelting;
@@ -38,7 +39,7 @@ public class SmeltingCommand extends SkillCommand {
 
         // SECOND SMELT
         if (canSecondSmelt) {
-            String[] secondSmeltStrings = calculateAbilityDisplayValues(skillValue, Smelting.secondSmeltMaxLevel, Smelting.secondSmeltMaxChance, isLucky);
+            String[] secondSmeltStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.SECOND_SMELT, isLucky);
             secondSmeltChance = secondSmeltStrings[0];
             secondSmeltChanceLucky = secondSmeltStrings[1];
         }
@@ -53,9 +54,9 @@ public class SmeltingCommand extends SkillCommand {
 
     @Override
     protected void permissionsCheck(Player player) {
-        canFuelEfficiency = Permissions.fuelEfficiency(player);
-        canSecondSmelt = Permissions.doubleDrops(player, skill);
-        canFluxMine = Permissions.fluxMining(player);
+        canFuelEfficiency = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.FUEL_EFFICIENCY);
+        canSecondSmelt = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.SECOND_SMELT);
+        canFluxMine = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.FLUX_MINING);
         canVanillaXPBoost = Permissions.vanillaXpBoost(player, skill);
     }
 

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

@@ -5,14 +5,16 @@ import java.util.List;
 
 import org.bukkit.entity.Player;
 
+import com.gmail.nossr50.config.AdvancedConfig;
+import com.gmail.nossr50.datatypes.skills.SecondaryAbility;
 import com.gmail.nossr50.datatypes.skills.SkillType;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.skills.swords.Swords;
 import com.gmail.nossr50.util.Permissions;
 
 public class SwordsCommand extends SkillCommand {
-    private String counterAttackChance;
-    private String counterAttackChanceLucky;
+    private String counterChance;
+    private String counterChanceLucky;
     private int bleedLength;
     private String bleedChance;
     private String bleedChanceLucky;
@@ -38,25 +40,25 @@ public class SwordsCommand extends SkillCommand {
 
         // BLEED
         if (canBleed) {
-            bleedLength = (skillValue >= Swords.bleedMaxBonusLevel) ? Swords.bleedMaxTicks : Swords.bleedBaseTicks;
+            bleedLength = (skillValue >= AdvancedConfig.getInstance().getMaxBonusLevel(SecondaryAbility.BLEED)) ? Swords.bleedMaxTicks : Swords.bleedBaseTicks;
 
-            String[] bleedStrings = calculateAbilityDisplayValues(skillValue, Swords.bleedMaxBonusLevel, Swords.bleedMaxChance, isLucky);
+            String[] bleedStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.BLEED, isLucky);
             bleedChance = bleedStrings[0];
             bleedChanceLucky = bleedStrings[1];
         }
 
-        // COUNTER ATTACK
+        // COUNTER
         if (canCounter) {
-            String[] counterAttackStrings = calculateAbilityDisplayValues(skillValue, Swords.counterAttackMaxBonusLevel, Swords.counterAttackMaxChance, isLucky);
-            counterAttackChance = counterAttackStrings[0];
-            counterAttackChanceLucky = counterAttackStrings[1];
+            String[] counterStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.COUNTER, isLucky);
+            counterChance = counterStrings[0];
+            counterChanceLucky = counterStrings[1];
         }
     }
 
     @Override
     protected void permissionsCheck(Player player) {
-        canBleed = Permissions.bleed(player);
-        canCounter = Permissions.counterAttack(player);
+        canBleed = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.BLEED);
+        canCounter = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.COUNTER);
         canSerratedStrike = Permissions.serratedStrikes(player);
     }
 
@@ -85,7 +87,7 @@ public class SwordsCommand extends SkillCommand {
         List<String> messages = new ArrayList<String>();
 
         if (canCounter) {
-            messages.add(LocaleLoader.getString("Swords.Combat.Counter.Chance", counterAttackChance) + (isLucky ? LocaleLoader.getString("Perks.Lucky.Bonus", counterAttackChanceLucky) : ""));
+            messages.add(LocaleLoader.getString("Swords.Combat.Counter.Chance", counterChance) + (isLucky ? LocaleLoader.getString("Perks.Lucky.Bonus", counterChanceLucky) : ""));
         }
 
         if (canBleed) {

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

@@ -7,6 +7,7 @@ import org.bukkit.entity.EntityType;
 import org.bukkit.entity.Player;
 
 import com.gmail.nossr50.config.Config;
+import com.gmail.nossr50.datatypes.skills.SecondaryAbility;
 import com.gmail.nossr50.datatypes.skills.SkillType;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.skills.taming.Taming;
@@ -33,7 +34,7 @@ public class TamingCommand extends SkillCommand {
     @Override
     protected void dataCalculations(Player player, float skillValue, boolean isLucky) {
         if (canGore) {
-            String[] goreStrings = calculateAbilityDisplayValues(skillValue, Taming.goreMaxBonusLevel, Taming.goreMaxChance, isLucky);
+            String[] goreStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.GORE, isLucky);
             goreChance = goreStrings[0];
             goreChanceLucky = goreStrings[1];
         }
@@ -41,15 +42,15 @@ public class TamingCommand extends SkillCommand {
 
     @Override
     protected void permissionsCheck(Player player) {
-        canBeastLore = Permissions.beastLore(player);
+        canBeastLore = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.BEAST_LORE);
         canCallWild = Permissions.callOfTheWild(player, EntityType.HORSE) || Permissions.callOfTheWild(player, EntityType.WOLF) || Permissions.callOfTheWild(player, EntityType.OCELOT);
-        canEnvironmentallyAware = Permissions.environmentallyAware(player);
-        canFastFood = Permissions.fastFoodService(player);
-        canGore = Permissions.gore(player);
-        canSharpenedClaws = Permissions.sharpenedClaws(player);
-        canShockProof = Permissions.shockProof(player);
-        canThickFur = Permissions.thickFur(player);
-        canHolyHound = Permissions.holyHound(player);
+        canEnvironmentallyAware = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.ENVIROMENTALLY_AWARE);
+        canFastFood = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.FAST_FOOD);
+        canGore = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.GORE);
+        canSharpenedClaws = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.SHARPENED_CLAWS);
+        canShockProof = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.SHOCK_PROOF);
+        canThickFur = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.THICK_FUR);
+        canHolyHound = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.HOLY_HOUND);
     }
 
     @Override

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

@@ -5,6 +5,7 @@ import java.util.List;
 
 import org.bukkit.entity.Player;
 
+import com.gmail.nossr50.datatypes.skills.SecondaryAbility;
 import com.gmail.nossr50.datatypes.skills.SkillType;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.skills.unarmed.Unarmed;
@@ -23,7 +24,7 @@ public class UnarmedCommand extends SkillCommand {
 
     private boolean canBerserk;
     private boolean canDisarm;
-    private boolean canBonusDamage;
+    private boolean canIronArm;
     private boolean canDeflect;
     private boolean canIronGrip;
 
@@ -42,26 +43,26 @@ public class UnarmedCommand extends SkillCommand {
 
         // DISARM
         if (canDisarm) {
-            String[] disarmStrings = calculateAbilityDisplayValues(skillValue, Unarmed.disarmMaxBonusLevel, Unarmed.disarmMaxChance, isLucky);
+            String[] disarmStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.DISARM, isLucky);
             disarmChance = disarmStrings[0];
             disarmChanceLucky = disarmStrings[1];
         }
 
         // DEFLECT
         if (canDeflect) {
-            String[] deflectStrings = calculateAbilityDisplayValues(skillValue, Unarmed.deflectMaxBonusLevel, Unarmed.deflectMaxChance, isLucky);
+            String[] deflectStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.DEFLECT, isLucky);
             deflectChance = deflectStrings[0];
             deflectChanceLucky = deflectStrings[1];
         }
 
         // IRON ARM
-        if (canBonusDamage) {
+        if (canIronArm) {
             ironArmBonus = Math.min(3 + ((int) skillValue / Unarmed.ironArmIncreaseLevel), Unarmed.ironArmMaxBonusDamage);
         }
 
         // IRON GRIP
         if (canIronGrip) {
-            String[] ironGripStrings = calculateAbilityDisplayValues(skillValue, Unarmed.ironGripMaxBonusLevel, Unarmed.ironGripMaxChance, isLucky);
+            String[] ironGripStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.IRON_GRIP, isLucky);
             ironGripChance = ironGripStrings[0];
             ironGripChanceLucky = ironGripStrings[1];
         }
@@ -70,10 +71,11 @@ public class UnarmedCommand extends SkillCommand {
     @Override
     protected void permissionsCheck(Player player) {
         canBerserk = Permissions.berserk(player);
-        canBonusDamage = Permissions.bonusDamage(player, skill);
-        canDeflect = Permissions.arrowDeflect(player);
-        canDisarm = Permissions.disarm(player);
-        canIronGrip = Permissions.ironGrip(player);
+        canIronArm = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.IRON_ARM);
+        canDeflect = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.DEFLECT);
+        canDisarm = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.DISARM);
+        canIronGrip = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.IRON_GRIP);
+        // TODO: Apparently we forgot about block cracker?
     }
 
     @Override
@@ -83,12 +85,13 @@ public class UnarmedCommand extends SkillCommand {
         if (canBerserk) {
             messages.add(LocaleLoader.getString("Effects.Template", LocaleLoader.getString("Unarmed.Effect.0"), LocaleLoader.getString("Unarmed.Effect.1")));
         }
+        // TODO: Apparently we forgot about block cracker?
 
         if (canDisarm) {
             messages.add(LocaleLoader.getString("Effects.Template", LocaleLoader.getString("Unarmed.Effect.2"), LocaleLoader.getString("Unarmed.Effect.3")));
         }
 
-        if (canBonusDamage) {
+        if (canIronArm) {
             messages.add(LocaleLoader.getString("Effects.Template", LocaleLoader.getString("Unarmed.Effect.4"), LocaleLoader.getString("Unarmed.Effect.5")));
         }
 
@@ -107,7 +110,7 @@ public class UnarmedCommand extends SkillCommand {
     protected List<String> statsDisplay(Player player, float skillValue, boolean hasEndurance, boolean isLucky) {
         List<String> messages = new ArrayList<String>();
 
-        if (canBonusDamage) {
+        if (canIronArm) {
             messages.add(LocaleLoader.getString("Ability.Generic.Template", LocaleLoader.getString("Unarmed.Ability.Bonus.0"), LocaleLoader.getString("Unarmed.Ability.Bonus.1", ironArmBonus)));
         }
 

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

@@ -6,9 +6,9 @@ import java.util.List;
 import org.bukkit.entity.Player;
 
 import com.gmail.nossr50.config.AdvancedConfig;
+import com.gmail.nossr50.datatypes.skills.SecondaryAbility;
 import com.gmail.nossr50.datatypes.skills.SkillType;
 import com.gmail.nossr50.locale.LocaleLoader;
-import com.gmail.nossr50.skills.woodcutting.Woodcutting;
 import com.gmail.nossr50.util.Permissions;
 
 public class WoodcuttingCommand extends SkillCommand {
@@ -36,7 +36,7 @@ public class WoodcuttingCommand extends SkillCommand {
 
         // DOUBLE DROPS
         if (canDoubleDrop) {
-            String[] doubleDropStrings = calculateAbilityDisplayValues(skillValue, Woodcutting.doubleDropsMaxLevel, Woodcutting.doubleDropsMaxChance, isLucky);
+            String[] doubleDropStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.WOODCUTTING_DOUBLE_DROPS, isLucky);
             doubleDropChance = doubleDropStrings[0];
             doubleDropChanceLucky = doubleDropStrings[1];
         }
@@ -45,8 +45,8 @@ public class WoodcuttingCommand extends SkillCommand {
     @Override
     protected void permissionsCheck(Player player) {
         canTreeFell = Permissions.treeFeller(player);
-        canDoubleDrop = Permissions.doubleDrops(player, skill) && !skill.getDoubleDropsDisabled();
-        canLeafBlow = Permissions.leafBlower(player);
+        canDoubleDrop = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.WOODCUTTING_DOUBLE_DROPS) && !skill.getDoubleDropsDisabled();
+        canLeafBlow = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.LEAF_BLOWER);
     }
 
     @Override

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

@@ -4,10 +4,13 @@ import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 
+import com.gmail.nossr50.datatypes.skills.SecondaryAbility;
+import com.gmail.nossr50.datatypes.skills.SkillType;
 import com.gmail.nossr50.skills.fishing.Fishing;
 import com.gmail.nossr50.skills.mining.BlastMining;
 import com.gmail.nossr50.skills.repair.ArcaneForging;
 import com.gmail.nossr50.skills.smelting.Smelting;
+import com.gmail.nossr50.util.StringUtils;
 
 public class AdvancedConfig extends AutoUpdateConfigLoader {
     private static AdvancedConfig instance;
@@ -40,11 +43,11 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
         }
 
         /* ACROBATICS */
-        if (getDodgeChanceMax() < 1) {
+        if (getMaxChance(SecondaryAbility.DODGE) < 1) {
             reason.add("Skills.Acrobatics.Dodge.ChanceMax should be at least 1!");
         }
 
-        if (getDodgeMaxBonusLevel() < 1) {
+        if (getMaxBonusLevel(SecondaryAbility.DODGE) < 1) {
             reason.add("Skills.Acrobatics.Dodge.MaxBonusLevel should be at least 1!");
         }
 
@@ -52,11 +55,11 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
             reason.add("Skills.Acrobatics.Dodge.DamageModifier should be greater than 1!");
         }
 
-        if (getRollChanceMax() < 1) {
+        if (getMaxChance(SecondaryAbility.ROLL) < 1) {
             reason.add("Skills.Acrobatics.Roll.ChanceMax should be at least 1!");
         }
 
-        if (getRollMaxBonusLevel() < 1) {
+        if (getMaxBonusLevel(SecondaryAbility.ROLL) < 1) {
             reason.add("Skills.Acrobatics.Roll.MaxBonusLevel should be at least 1!");
         }
 
@@ -64,11 +67,11 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
             reason.add("Skills.Acrobatics.Roll.DamageThreshold should be at least 0!");
         }
 
-        if (getGracefulRollChanceMax() < 1) {
+        if (getMaxChance(SecondaryAbility.GRACEFUL_ROLL) < 1) {
             reason.add("Skills.Acrobatics.GracefulRoll.ChanceMax should be at least 1!");
         }
 
-        if (getGracefulRollMaxBonusLevel() < 1) {
+        if (getMaxBonusLevel(SecondaryAbility.GRACEFUL_ROLL) < 1) {
             reason.add("Skills.Acrobatics.GracefulRoll.MaxBonusLevel should be at least 1!");
         }
 
@@ -89,11 +92,11 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
             reason.add("Skills.Archery.SkillShot.MaxBonus should be at least 0!");
         }
 
-        if (getDazeBonusMax() < 1) {
+        if (getMaxChance(SecondaryAbility.DAZE) < 1) {
             reason.add("Skills.Acrobatics.Daze.ChanceMax should be at least 1!");
         }
 
-        if (getDazeMaxBonusLevel() < 1) {
+        if (getMaxBonusLevel(SecondaryAbility.DAZE) < 1) {
             reason.add("Skills.Acrobatics.Daze.MaxBonusLevel should be at least 1!");
         }
 
@@ -101,11 +104,11 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
             reason.add("Skills.Acrobatics.Daze.BonusDamage should be at least 0!");
         }
 
-        if (getRetrieveChanceMax() < 1) {
+        if (getMaxChance(SecondaryAbility.RETRIEVE) < 1) {
             reason.add("Skills.Acrobatics.Retrieve.ChanceMax should be at least 1!");
         }
 
-        if (getRetrieveMaxBonusLevel() < 1) {
+        if (getMaxBonusLevel(SecondaryAbility.RETRIEVE) < 1) {
             reason.add("Skills.Acrobatics.Retrieve.MaxBonusLevel should be at least 1!");
         }
 
@@ -114,28 +117,28 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
         }
 
         /* AXES */
-        if (getBonusDamageAxesBonusMax() < 1) {
-            reason.add("Skills.Axes.DamageIncrease.MaxBonus should be at least 1!");
+        if (getAxeMasteryBonusMax() < 1) {
+            reason.add("Skills.Axes.AxeMastery.MaxBonus should be at least 1!");
         }
 
-        if (getBonusDamageAxesMaxBonusLevel() < 1) {
-            reason.add("Skills.Axes.DamageIncrease.MaxBonusLevel should be at least 1!");
+        if (getAxeMasteryMaxBonusLevel() < 1) {
+            reason.add("Skills.Axes.AxeMastery.MaxBonusLevel should be at least 1!");
         }
 
-        if (getAxesCriticalChance() < 1) {
-            reason.add("Skills.Axes.AxesCritical.ChanceMax should be at least 1!");
+        if (getMaxChance(SecondaryAbility.CRITICAL_HIT) < 1) {
+            reason.add("Skills.Axes.CriticalHit.ChanceMax should be at least 1!");
         }
 
-        if (getAxesCriticalMaxBonusLevel() < 1) {
-            reason.add("Skills.Axes.AxesCritical.MaxBonusLevel should be at least 1!");
+        if (getMaxBonusLevel(SecondaryAbility.CRITICAL_HIT) < 1) {
+            reason.add("Skills.Axes.CriticalHit.MaxBonusLevel should be at least 1!");
         }
 
-        if (getAxesCriticalPVPModifier() < 1) {
-            reason.add("Skills.Axes.AxesCritical.PVP_Modifier should be at least 1!");
+        if (getCriticalHitPVPModifier() < 1) {
+            reason.add("Skills.Axes.CriticalHit.PVP_Modifier should be at least 1!");
         }
 
-        if (getAxesCriticalPVEModifier() < 1) {
-            reason.add("Skills.Axes.AxesCritical.PVE_Modifier should be at least 1!");
+        if (getCriticalHitPVEModifier() < 1) {
+            reason.add("Skills.Axes.CriticalHit.PVE_Modifier should be at least 1!");
         }
 
         if (getGreaterImpactChance() < 1) {
@@ -228,44 +231,44 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
             reason.add("Skills.Herbalism.GreenThumb.StageChange should be at least 1!");
         }
 
-        if (getGreenThumbChanceMax() < 1) {
+        if (getMaxChance(SecondaryAbility.GREEN_THUMB_PLANT) < 1) {
             reason.add("Skills.Herbalism.GreenThumb.ChanceMax should be at least 1!");
         }
 
-        if (getGreenThumbMaxLevel() < 1) {
+        if (getMaxBonusLevel(SecondaryAbility.GREEN_THUMB_PLANT) < 1) {
             reason.add("Skills.Herbalism.GreenThumb.MaxBonusLevel should be at least 1!");
         }
 
-        if (getHerbalismDoubleDropsChanceMax() < 1) {
+        if (getMaxChance(SecondaryAbility.HERBALISM_DOUBLE_DROPS) < 1) {
             reason.add("Skills.Herbalism.DoubleDrops.ChanceMax should be at least 1!");
         }
 
-        if (getHerbalismDoubleDropsMaxLevel() < 1) {
+        if (getMaxBonusLevel(SecondaryAbility.HERBALISM_DOUBLE_DROPS) < 1) {
             reason.add("Skills.Herbalism.DoubleDrops.MaxBonusLevel should be at least 1!");
         }
 
-        if (getHylianLuckChanceMax() < 1) {
+        if (getMaxChance(SecondaryAbility.HYLIAN_LUCK) < 1) {
             reason.add("Skills.Herbalism.HylianLuck.ChanceMax should be at least 1!");
         }
 
-        if (getHylianLuckMaxLevel() < 1) {
+        if (getMaxBonusLevel(SecondaryAbility.HYLIAN_LUCK) < 1) {
             reason.add("Skills.Herbalism.HylianLuck.MaxBonusLevel should be at least 1!");
         }
 
-        if (getShroomThumbChanceMax() < 1) {
+        if (getMaxChance(SecondaryAbility.SHROOM_THUMB) < 1) {
             reason.add("Skills.Herbalism.ShroomThumb.ChanceMax should be at least 1!");
         }
 
-        if (getShroomThumbMaxLevel() < 1) {
+        if (getMaxBonusLevel(SecondaryAbility.SHROOM_THUMB) < 1) {
             reason.add("Skills.Herbalism.ShroomThumb.MaxBonusLevel should be at least 1!");
         }
 
         /* MINING */
-        if (getMiningDoubleDropChance() < 1) {
+        if (getMaxChance(SecondaryAbility.MINING_DOUBLE_DROPS) < 1) {
             reason.add("Skills.Mining.DoubleDrops.ChanceMax should be at least 1!");
         }
 
-        if (getMiningDoubleDropMaxLevel() < 1) {
+        if (getMaxBonusLevel(SecondaryAbility.MINING_DOUBLE_DROPS) < 1) {
             reason.add("Skills.Mining.DoubleDrops.MaxBonusLevel should be at least 1!");
         }
 
@@ -334,11 +337,11 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
             reason.add("Skills.Repair.RepairMastery.MaxBonusLevel should be at least 1!");
         }
 
-        if (getSuperRepairChanceMax() < 1) {
+        if (getMaxChance(SecondaryAbility.SUPER_REPAIR) < 1) {
             reason.add("Skills.Repair.SuperRepair.ChanceMax should be at least 1!");
         }
 
-        if (getSuperRepairMaxLevel() < 1) {
+        if (getMaxBonusLevel(SecondaryAbility.SUPER_REPAIR) < 1) {
             reason.add("Skills.Repair.SuperRepair.MaxBonusLevel should be at least 1!");
         }
 
@@ -387,11 +390,11 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
             reason.add("Skills.Smelting.FuelEfficiency.Multiplier should be at least 1!");
         }
 
-        if (getSecondSmeltMaxLevel() < 1) {
+        if (getMaxBonusLevel(SecondaryAbility.SECOND_SMELT) < 1) {
             reason.add("Skills.Smelting.SecondSmelt.MaxBonusLevel should be at least 1!");
         }
 
-        if (getSecondSmeltMaxChance() < 1) {
+        if (getMaxChance(SecondaryAbility.SECOND_SMELT) < 1) {
             reason.add("Skills.Smelting.SecondSmelt.ChanceMax should be at least 1!");
         }
 
@@ -428,11 +431,11 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
         }
 
         /* SWORDS */
-        if (getBleedChanceMax() < 1) {
+        if (getMaxChance(SecondaryAbility.BLEED) < 1) {
             reason.add("Skills.Swords.Bleed.ChanceMax should be at least 1!");
         }
 
-        if (getBleedMaxBonusLevel() < 1) {
+        if (getMaxBonusLevel(SecondaryAbility.BLEED) < 1) {
             reason.add("Skills.Swords.Bleed.MaxBonusLevel should be at least 1!");
         }
 
@@ -448,11 +451,11 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
             reason.add("Skills.Swords.Bleed.BaseTicks should be at least 1!");
         }
 
-        if (getCounterChanceMax() < 1) {
+        if (getMaxChance(SecondaryAbility.COUNTER) < 1) {
             reason.add("Skills.Swords.Counter.ChanceMax should be at least 1!");
         }
 
-        if (getCounterMaxBonusLevel() < 1) {
+        if (getMaxBonusLevel(SecondaryAbility.COUNTER) < 1) {
             reason.add("Skills.Swords.Counter.MaxBonusLevel should be at least 1!");
         }
 
@@ -470,11 +473,11 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
 
         /* TAMING */
 
-        if (getGoreChanceMax() < 1) {
+        if (getMaxChance(SecondaryAbility.GORE) < 1) {
             reason.add("Skills.Taming.Gore.ChanceMax should be at least 1!");
         }
 
-        if (getGoreMaxBonusLevel() < 1) {
+        if (getMaxBonusLevel(SecondaryAbility.GORE) < 1) {
             reason.add("Skills.Taming.Gore.MaxBonusLevel should be at least 1!");
         }
 
@@ -531,27 +534,27 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
         }
 
         /* UNARMED */
-        if (getDisarmChanceMax() < 1) {
+        if (getMaxChance(SecondaryAbility.DISARM) < 1) {
             reason.add("Skills.Unarmed.Disarm.ChanceMax should be at least 1!");
         }
 
-        if (getDisarmMaxBonusLevel() < 1) {
+        if (getMaxBonusLevel(SecondaryAbility.DISARM) < 1) {
             reason.add("Skills.Unarmed.Disarm.MaxBonusLevel should be at least 1!");
         }
 
-        if (getDeflectChanceMax() < 1) {
+        if (getMaxChance(SecondaryAbility.DEFLECT) < 1) {
             reason.add("Skills.Unarmed.Deflect.ChanceMax should be at least 1!");
         }
 
-        if (getDeflectMaxBonusLevel() < 1) {
+        if (getMaxBonusLevel(SecondaryAbility.DEFLECT) < 1) {
             reason.add("Skills.Unarmed.Deflect.MaxBonusLevel should be at least 1!");
         }
 
-        if (getIronGripChanceMax() < 1) {
+        if (getMaxChance(SecondaryAbility.IRON_GRIP) < 1) {
             reason.add("Skills.Unarmed.IronGrip.ChanceMax should be at least 1!");
         }
 
-        if (getIronGripMaxBonusLevel() < 1) {
+        if (getMaxBonusLevel(SecondaryAbility.IRON_GRIP) < 1) {
             reason.add("Skills.Unarmed.IronGrip.MaxBonusLevel should be at least 1!");
         }
 
@@ -576,11 +579,11 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
             reason.add("Skills.Woodcutting.LeafBlower.UnlockLevel should be at least 1!");
         }
 
-        if (getWoodcuttingDoubleDropChance() < 1) {
+        if (getMaxChance(SecondaryAbility.WOODCUTTING_DOUBLE_DROPS) < 1) {
             reason.add("Skills.Woodcutting.DoubleDrops.ChanceMax should be at least 1!");
         }
 
-        if (getWoodcuttingDoubleDropMaxLevel() < 1) {
+        if (getMaxBonusLevel(SecondaryAbility.WOODCUTTING_DOUBLE_DROPS) < 1) {
             reason.add("Skills.Woodcutting.DoubleDrops.MaxBonusLevel should be at least 1!");
         }
 
@@ -611,17 +614,14 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
     public int getAbilityLength() { return config.getInt("Skills.General.Ability.IncreaseLevel", 50); }
     public int getEnchantBuff() { return config.getInt("Skills.General.Ability.EnchantBuff", 5); }
 
+    public int getMaxBonusLevel(SecondaryAbility skillAbility) { return config.getInt("Skills." + StringUtils.getCapitalized(SkillType.bySecondaryAbility(skillAbility).toString()) + "." + StringUtils.getPrettySecondaryAbilityString(skillAbility).replace(" ", "") + ".MaxBonusLevel"); }
+    public double getMaxChance(SecondaryAbility skillAbility) { return config.getDouble("Skills." + StringUtils.getCapitalized(SkillType.bySecondaryAbility(skillAbility).toString()) + "." + StringUtils.getPrettySecondaryAbilityString(skillAbility).replace(" ", "") + ".ChanceMax", 100.0D); }
+
     /* ACROBATICS */
-    public double getDodgeChanceMax() { return config.getDouble("Skills.Acrobatics.Dodge.ChanceMax", 20.0D); }
-    public int getDodgeMaxBonusLevel() { return config.getInt("Skills.Acrobatics.Dodge.MaxBonusLevel", 800); }
     public double getDodgeDamageModifier() { return config.getDouble("Skills.Acrobatics.Dodge.DamageModifier", 2.0D); }
 
-    public double getRollChanceMax() { return config.getDouble("Skills.Acrobatics.Roll.ChanceMax", 100.0D); }
-    public int getRollMaxBonusLevel() { return config.getInt("Skills.Acrobatics.Roll.MaxBonusLevel", 1000); }
     public double getRollDamageThreshold() { return config.getDouble("Skills.Acrobatics.Roll.DamageThreshold", 7.0D); }
 
-    public double getGracefulRollChanceMax() { return config.getDouble("Skills.Acrobatics.GracefulRoll.ChanceMax", 100.0D); }
-    public int getGracefulRollMaxBonusLevel() { return config.getInt("Skills.Acrobatics.GracefulRoll.MaxBonusLevel", 500); }
     public double getGracefulRollDamageThreshold() { return config.getDouble("Skills.Acrobatics.GracefulRoll.DamageThreshold", 14.0D); }
 
     /* ARCHERY */
@@ -630,23 +630,16 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
     public double getSkillShotBonusMax() { return config.getDouble("Skills.Archery.SkillShot.MaxBonus", 2.0D); }
     public double getSkillShotDamageMax() { return config.getDouble("Skills.Archery.SkillShot.MaxDamage", 9.0D); }
 
-    public double getDazeBonusMax() { return config.getDouble("Skills.Archery.Daze.ChanceMax", 50.0D); }
-    public int getDazeMaxBonusLevel() { return config.getInt("Skills.Archery.Daze.MaxBonusLevel", 1000); }
     public double getDazeModifier() { return config.getDouble("Skills.Archery.Daze.BonusDamage", 4.0D); }
 
-    public double getRetrieveChanceMax() { return config.getDouble("Skills.Archery.Retrieve.ChanceMax", 100.0D); }
-    public int getRetrieveMaxBonusLevel() { return config.getInt("Skills.Archery.Retrieve.MaxBonusLevel", 1000); }
-
     public double getForceMultiplier() { return config.getDouble("Skills.Archery.ForceMultiplier", 2.0D); }
 
     /* AXES */
-    public double getBonusDamageAxesBonusMax() { return config.getDouble("Skills.Axes.DamageIncrease.MaxBonus", 4.0D); }
-    public int getBonusDamageAxesMaxBonusLevel() { return config.getInt("Skills.Axes.DamageIncrease.MaxBonusLevel", 200); }
+    public double getAxeMasteryBonusMax() { return config.getDouble("Skills.Axes.AxeMastery.MaxBonus", 4.0D); }
+    public int getAxeMasteryMaxBonusLevel() { return config.getInt("Skills.Axes.AxeMastery.MaxBonusLevel", 200); }
 
-    public double getAxesCriticalChance() { return config.getDouble("Skills.Axes.AxesCritical.ChanceMax", 37.50D); }
-    public int getAxesCriticalMaxBonusLevel() { return config.getInt("Skills.Axes.AxesCritical.MaxBonusLevel", 750); }
-    public double getAxesCriticalPVPModifier() { return config.getDouble("Skills.Axes.AxesCritical.PVP_Modifier", 1.5D); }
-    public double getAxesCriticalPVEModifier() { return config.getDouble("Skills.Axes.AxesCritical.PVE_Modifier", 2.0D); }
+    public double getCriticalHitPVPModifier() { return config.getDouble("Skills.Axes.CriticalHit.PVP_Modifier", 1.5D); }
+    public double getCriticalHitPVEModifier() { return config.getDouble("Skills.Axes.CriticalHit.PVE_Modifier", 2.0D); }
 
     public double getGreaterImpactChance() { return config.getDouble("Skills.Axes.GreaterImpact.Chance", 25.0D); }
     public double getGreaterImpactModifier() { return config.getDouble("Skills.Axes.GreaterImpact.KnockbackModifier", 1.5D); }
@@ -678,22 +671,8 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
     public int getFarmerDietRankChange() { return config.getInt("Skills.Herbalism.FarmersDiet.RankChange", 200); }
 
     public int getGreenThumbStageChange() { return config.getInt("Skills.Herbalism.GreenThumb.StageChange", 200); }
-    public double getGreenThumbChanceMax() { return config.getDouble("Skills.Herbalism.GreenThumb.ChanceMax", 100.0D); }
-    public int getGreenThumbMaxLevel() { return config.getInt("Skills.Herbalism.GreenThumb.MaxBonusLevel", 1500); }
-
-    public double getHerbalismDoubleDropsChanceMax() { return config.getDouble("Skills.Herbalism.DoubleDrops.ChanceMax", 100.0D); }
-    public int getHerbalismDoubleDropsMaxLevel() { return config.getInt("Skills.Herbalism.DoubleDrops.MaxBonusLevel", 1000); }
-
-    public double getHylianLuckChanceMax() { return config.getDouble("Skills.Herbalism.HylianLuck.ChanceMax", 10.0D); }
-    public int getHylianLuckMaxLevel() { return config.getInt("Skills.Herbalism.HylianLuck.MaxBonusLevel", 1000); }
-
-    public double getShroomThumbChanceMax() { return config.getDouble("Skills.Herbalism.ShroomThumb.ChanceMax", 50.0D); }
-    public int getShroomThumbMaxLevel() { return config.getInt("Skills.Herbalism.ShroomThumb.MaxBonusLevel", 1500); }
 
     /* MINING */
-    public double getMiningDoubleDropChance() { return config.getDouble("Skills.Mining.DoubleDrops.ChanceMax", 100.0D); }
-    public int getMiningDoubleDropMaxLevel() { return config.getInt("Skills.Mining.DoubleDrops.MaxBonusLevel", 1000); }
-
     public int getBlastMiningRankLevel(BlastMining.Tier tier) { return config.getInt("Skills.Mining.BlastMining.Rank_Levels.Rank_" + tier.toNumerical()); }
     public double getBlastDamageDecrease(BlastMining.Tier tier) { return config.getDouble("Skills.Mining.BlastMining.BlastDamageDecrease.Rank_" + tier.toNumerical()); }
     public double getOreBonus(BlastMining.Tier tier) { return config.getDouble("Skills.Mining.BlastMining.OreBonus.Rank_" + tier.toNumerical()); }
@@ -704,8 +683,6 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
     /* REPAIR */
     public double getRepairMasteryMaxBonus() { return config.getDouble("Skills.Repair.RepairMastery.MaxBonusPercentage", 200.0D); }
     public int getRepairMasteryMaxLevel() { return config.getInt("Skills.Repair.RepairMastery.MaxBonusLevel", 1000); }
-    public double getSuperRepairChanceMax() { return config.getDouble("Skills.Repair.SuperRepair.ChanceMax", 100.0D); }
-    public int getSuperRepairMaxLevel() { return config.getInt("Skills.Repair.SuperRepair.MaxBonusLevel", 1000); }
     public int getSalvageUnlockLevel() { return config.getInt("Skills.Repair.Salvage.UnlockLevel", 600); }
 
     /* Arcane Forging */
@@ -721,9 +698,6 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
     public int getBurnModifierMaxLevel() { return config.getInt("Skills.Smelting.FuelEfficiency.MaxBonusLevel", 1000); }
     public double getBurnTimeMultiplier() { return config.getDouble("Skills.Smelting.FuelEfficiency.Multiplier", 3.0D); }
 
-    public int getSecondSmeltMaxLevel() { return config.getInt("Skills.Smelting.SecondSmelt.MaxBonusLevel", 1000); }
-    public double getSecondSmeltMaxChance() { return config.getDouble("Skills.Smelting.SecondSmelt.ChanceMax", 100.0D); }
-
     public int getFluxMiningUnlockLevel() { return config.getInt("Skills.Smelting.FluxMining.UnlockLevel", 250); }
     public double getFluxMiningChance() { return config.getDouble("Skills.Smelting.FluxMining.Chance", 33.0D); }
 
@@ -732,22 +706,16 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
     public int getSmeltingVanillaXPBoostMultiplier(Smelting.Tier tier) { return config.getInt("Skills.Smelting.VanillaXPMultiplier.Rank_" + tier.toNumerical()); }
 
     /* SWORDS */
-    public double getBleedChanceMax() { return config.getDouble("Skills.Swords.Bleed.ChanceMax", 75.0D); }
-    public int getBleedMaxBonusLevel() { return config.getInt("Skills.Swords.Bleed.MaxBonusLevel", 750); }
     public int getBleedMaxTicks() { return config.getInt("Skills.Swords.Bleed.MaxTicks", 3); }
     public int getBleedBaseTicks() { return config.getInt("Skills.Swords.Bleed.BaseTicks", 2); }
 
     public boolean getCounterRequiresBlock() { return config.getBoolean("Skills.Swords.Counter.RequiresBlock"); }
-    public double getCounterChanceMax() { return config.getDouble("Skills.Swords.Counter.ChanceMax", 30.0D); }
-    public int getCounterMaxBonusLevel() { return config.getInt("Skills.Swords.Counter.MaxBonusLevel", 600); }
     public double getCounterModifier() { return config.getDouble("Skills.Swords.Counter.DamageModifier", 2.0D); }
 
     public double getSerratedStrikesModifier() { return config.getDouble("Skills.Swords.SerratedStrikes.DamageModifier", 4.0D); }
     public int getSerratedStrikesTicks() { return config.getInt("Skills.Swords.SerratedStrikes.BleedTicks", 5); }
 
     /* TAMING */
-    public double getGoreChanceMax() { return config.getDouble("Skills.Taming.Gore.ChanceMax", 100.0D); }
-    public int getGoreMaxBonusLevel() { return config.getInt("Skills.Taming.Gore.MaxBonusLevel", 1000); }
     public int getGoreBleedTicks() { return config.getInt("Skills.Taming.Gore.BleedTicks", 2); }
     public double getGoreModifier() { return config.getDouble("Skills.Taming.Gore.Modifier", 2.0D); }
 
@@ -770,25 +738,14 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
     public double getMaxHorseJumpStrength() { return config.getDouble("Skills.Taming.CallOfTheWild.MaxHorseJumpStrength", 2.0D); }
 
     /* UNARMED */
-    public double getDisarmChanceMax() { return config.getDouble("Skills.Unarmed.Disarm.ChanceMax", 33.0D); }
-    public int getDisarmMaxBonusLevel() { return config.getInt("Skills.Unarmed.Disarm.MaxBonusLevel", 1000); }
-
-    public double getDeflectChanceMax() { return config.getDouble("Skills.Unarmed.Deflect.ChanceMax", 50.0D); }
-    public int getDeflectMaxBonusLevel() { return config.getInt("Skills.Unarmed.Deflect.MaxBonusLevel", 1000); }
-
-    public double getIronGripChanceMax() { return config.getDouble("Skills.Unarmed.IronGrip.ChanceMax", 100.0D); }
-    public int getIronGripMaxBonusLevel() { return config.getInt("Skills.Unarmed.IronGrip.MaxBonusLevel", 1000); }
-
     public double getIronArmMinBonus() { return config.getDouble("Skills.Unarmed.IronArm.BonusMin", 3.0D); }
     public double getIronArmMaxBonus() { return config.getDouble("Skills.Unarmed.IronArm.BonusMax", 8.0D); }
     public int getIronArmIncreaseLevel() { return config.getInt("Skills.Unarmed.IronArm.IncreaseLevel", 50); }
+    public boolean getDisarmProtected() { return config.getBoolean("Skills.Unarmed.Disarm.AntiTheft", false); }
 
     /* WOODCUTTING */
     public int getLeafBlowUnlockLevel() { return config.getInt("Skills.Woodcutting.LeafBlower.UnlockLevel", 100); }
 
-    public double getWoodcuttingDoubleDropChance() { return config.getDouble("Skills.Woodcutting.DoubleDrops.ChanceMax", 100.0D); }
-    public int getWoodcuttingDoubleDropMaxLevel() { return config.getInt("Skills.Woodcutting.DoubleDrops.MaxBonusLevel", 1000); }
-
     /* KRAKEN STUFF */
     public boolean getKrakenEnabled() { return config.getBoolean("Kraken.Enabled", true); }
     public int getKrakenTriesBeforeRelease() { return config.getInt("Kraken.Tries_Before_Release", 50); }

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

@@ -205,6 +205,7 @@ public class Config extends AutoUpdateConfigLoader {
     public boolean getStatsTrackingEnabled() { return config.getBoolean("General.Stats_Tracking", true); }
     public boolean getUpdateCheckEnabled() { return config.getBoolean("General.Update_Check", true); }
     public boolean getPreferBeta() { return config.getBoolean("General.Prefer_Beta", false); }
+    public boolean getEventCallbackEnabled() { return config.getBoolean("General.Event_Callback", true); }
     public boolean getVerboseLoggingEnabled() { return config.getBoolean("General.Verbose_Logging", false); }
     public boolean getConfigOverwriteEnabled() { return config.getBoolean("General.Config_Update_Overwrite", true); }
 

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

@@ -83,7 +83,7 @@ public class CustomBlockConfig extends ConfigLoader {
                 continue;
             }
 
-            byte blockData = Byte.valueOf(blockInfo[1]);
+            byte blockData = (blockInfo.length == 2) ? Byte.valueOf(blockInfo[1]) : 0;
             MaterialData blockMaterialData = new MaterialData(blockMaterial, blockData);
             blockList.add(blockMaterialData);
 

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

@@ -21,7 +21,8 @@ public interface DatabaseManager {
     public void purgePowerlessUsers();
 
     /**
-     * Purge users who haven't logged on in over a certain time frame from the database.
+     * Purge users who haven't logged on in over a certain time frame from the
+     * database.
      */
     public void purgeOldUsers();
 
@@ -42,13 +43,13 @@ public interface DatabaseManager {
     public boolean saveUser(PlayerProfile profile);
 
     /**
-    * Retrieve leaderboard info.
-    *
-    * @param skillName The skill to retrieve info on
-    * @param pageNumber Which page in the leaderboards to retrieve
-    * @param statsPerPage The number of stats per page
-    * @return the requested leaderboard information
-    */
+     * Retrieve leaderboard info.
+     *
+     * @param skillName The skill to retrieve info on
+     * @param pageNumber Which page in the leaderboards to retrieve
+     * @param statsPerPage The number of stats per page
+     * @return the requested leaderboard information
+     */
     public List<PlayerStat> readLeaderboard(SkillType skill, int pageNumber, int statsPerPage);
 
     /**
@@ -74,9 +75,9 @@ public interface DatabaseManager {
      *
      * @param playerName The name of the player to load from the database
      * @param createNew Whether to create a new record if the player is not
-     *          found
+     *            found
      * @return The player's data, or an unloaded PlayerProfile if not found
-     *          and createNew is false
+     *         and createNew is false
      */
     public PlayerProfile loadPlayerProfile(String playerName, boolean createNew);
 
@@ -96,9 +97,17 @@ public interface DatabaseManager {
     public void convertUsers(DatabaseManager destination);
 
     /**
-     * Retrieve the type of database in use. Custom databases should return CUSTOM.
+     * Retrieve the type of database in use. Custom databases should return
+     * CUSTOM.
      *
      * @return The type of database
      */
     public DatabaseType getDatabaseType();
+
+    /**
+     * Used for database conversion. If this is set to true, profiles may not
+     * be loaded from the database. This method will be called before and
+     * after database imports.
+     */
+    public void setLoadingDisabled(boolean state);
 }

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

@@ -35,6 +35,7 @@ public final class FlatfileDatabaseManager implements DatabaseManager {
     private final long UPDATE_WAIT_TIME = 600000L; // 10 minutes
     private final File usersFile;
     private static final Object fileWritingLock = new Object();
+    private volatile boolean converting = false;
 
     protected FlatfileDatabaseManager() {
         usersFile = new File(mcMMO.getUsersFilePath());
@@ -42,6 +43,10 @@ public final class FlatfileDatabaseManager implements DatabaseManager {
         updateLeaderboards();
     }
 
+    public void setLoadingDisabled(boolean state) {
+        converting = state;
+    }
+
     public void purgePowerlessUsers() {
         int purgedUsers = 0;
 
@@ -369,6 +374,10 @@ public final class FlatfileDatabaseManager implements DatabaseManager {
     }
 
     public PlayerProfile loadPlayerProfile(String playerName, boolean create) {
+        if (converting) {
+            return new PlayerProfile(playerName, false);
+        }
+
         BufferedReader in = null;
         String usersFilePath = mcMMO.getUsersFilePath();
 

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

@@ -49,12 +49,19 @@ public final class SQLDatabaseManager implements DatabaseManager {
     // How many connection attempts have failed
     private int reconnectAttempt = 0;
 
+    // If we're importing users, do not allow creation of profiles
+    private volatile boolean converting = false;
+
     protected SQLDatabaseManager() {
         checkStructure();
 
         new SQLDatabaseKeepaliveTask(this).runTaskTimerAsynchronously(mcMMO.p, 10, 60L * 60 * Misc.TICK_CONVERSION_FACTOR);
     }
 
+    public void setLoadingDisabled(boolean state) {
+        converting = state;
+    }
+
     public void purgePowerlessUsers() {
         if (!checkConnected()) {
             return;
@@ -346,12 +353,16 @@ public final class SQLDatabaseManager implements DatabaseManager {
     }
 
     public PlayerProfile loadPlayerProfile(String playerName, boolean create) {
+        if (converting) {
+            return new PlayerProfile(playerName, false); // return unloaded profile during database conversion
+        }
+
         return loadPlayerProfile(playerName, create, true);
     }
 
     private PlayerProfile loadPlayerProfile(String playerName, boolean create, boolean retry) {
         if (!checkConnected()) {
-            return new PlayerProfile(playerName, false); // return fake profile if not connected
+            return new PlayerProfile(playerName, false); // return unloaded profile if not connected
         }
 
         PreparedStatement statement = null;

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

@@ -10,6 +10,7 @@ import org.bukkit.Server;
 import org.bukkit.Sound;
 import org.bukkit.entity.Player;
 import org.bukkit.inventory.ItemStack;
+import org.bukkit.metadata.FixedMetadataValue;
 import org.bukkit.scheduler.BukkitRunnable;
 
 import com.gmail.nossr50.mcMMO;
@@ -87,11 +88,13 @@ public class McMMOPlayer {
     private Location teleportCommence;
 
     private boolean isUsingUnarmed;
+    private final FixedMetadataValue playerMetadata;
 
     public McMMOPlayer(Player player) {
         String playerName = player.getName();
 
         this.player = player;
+        playerMetadata = new FixedMetadataValue(mcMMO.p, playerName);
         profile = mcMMO.getDatabaseManager().loadPlayerProfile(playerName, true);
         party = PartyManager.getPlayerParty(playerName);
         ptpRecord = new PartyTeleportRecord();
@@ -528,7 +531,7 @@ public class McMMOPlayer {
             return;
         }
 
-        if (!EventUtils.handleXpChangeEvent(player, skillType, xp, true)) {
+        if (!EventUtils.handleXpGainEvent(player, skillType, xp)) {
             return;
         }
 
@@ -757,10 +760,6 @@ public class McMMOPlayer {
         ToolType tool = skill.getTool();
         AbilityType ability = skill.getAbility();
 
-        if (!getToolPreparationMode(tool) || !ability.getPermissions(player)) {
-            return;
-        }
-
         setToolPreparationMode(tool, false);
 
         if (getAbilityMode(ability)) {
@@ -781,7 +780,7 @@ public class McMMOPlayer {
             return;
         }
 
-        if (!EventUtils.handlePlayerAbilityActivateEvent(player, ability)) {
+        if (EventUtils.callPlayerAbilityActivateEvent(player, skill).isCancelled()) {
             return;
         }
 
@@ -917,4 +916,8 @@ public class McMMOPlayer {
     public void resetCooldowns() {
         profile.resetCooldowns();
     }
+
+    public FixedMetadataValue getPlayerMetadata() {
+        return playerMetadata;
+    }
 }

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

@@ -14,6 +14,8 @@ import com.gmail.nossr50.datatypes.skills.SkillType;
 import com.gmail.nossr50.skills.child.FamilyTree;
 import com.gmail.nossr50.util.player.UserManager;
 
+import com.google.common.collect.ImmutableMap;
+
 public class PlayerProfile {
     private final String playerName;
     private boolean loaded;
@@ -32,7 +34,7 @@ public class PlayerProfile {
 
         mobHealthbarType = Config.getInstance().getMobHealthbarDefault();
 
-        for (AbilityType abilityType : AbilityType.NORMAL_ABILITIES) {
+        for (AbilityType abilityType : AbilityType.values()) {
             abilityDATS.put(abilityType, 0);
         }
 
@@ -63,7 +65,7 @@ public class PlayerProfile {
             return;
         }
 
-        changed = !mcMMO.getDatabaseManager().saveUser(this);
+        changed = !mcMMO.getDatabaseManager().saveUser(new PlayerProfile(playerName, ImmutableMap.copyOf(skills), ImmutableMap.copyOf(skillsXp), ImmutableMap.copyOf(abilityDATS), mobHealthbarType));
 
         if (changed) {
             mcMMO.p.getLogger().warning("PlayerProfile for " + playerName + " failed to save");

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

@@ -1,21 +1,15 @@
 package com.gmail.nossr50.datatypes.skills;
 
-import java.util.List;
-
 import org.bukkit.Material;
-import org.bukkit.block.Block;
 import org.bukkit.block.BlockState;
 import org.bukkit.entity.Player;
 
 import com.gmail.nossr50.config.Config;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.util.BlockUtils;
-import com.gmail.nossr50.util.EventUtils;
 import com.gmail.nossr50.util.Permissions;
 import com.gmail.nossr50.util.StringUtils;
 
-import com.google.common.collect.ImmutableList;
-
 public enum AbilityType {
     BERSERK(
             "Unarmed.Skills.Berserk.On",
@@ -75,16 +69,7 @@ public enum AbilityType {
             "Mining.Blast.Other.On",
             "Mining.Blast.Refresh",
             null),
-
-    /**
-     * No cooldown - always active
-     */
-    LEAF_BLOWER,
-
-    /**
-     * Not a first-class Ability - part of Berserk
-     */
-    BLOCK_CRACKER;
+    ;
 
     private String abilityOn;
     private String abilityOff;
@@ -92,20 +77,6 @@ public enum AbilityType {
     private String abilityRefresh;
     private String abilityPlayerOff;
 
-    /**
-     * Those abilities that have a cooldown saved to the database.
-     */
-    public static final List<AbilityType> NORMAL_ABILITIES = ImmutableList.of(BERSERK, BLAST_MINING, GIGA_DRILL_BREAKER, GREEN_TERRA, SERRATED_STRIKES, SKULL_SPLITTER, SUPER_BREAKER, TREE_FELLER);
-
-    /**
-     * Those abilities that do not have a cooldown saved to the database.
-     */
-    public static final List<AbilityType> NON_NORMAL_ABILITIES = ImmutableList.of(BLOCK_CRACKER, LEAF_BLOWER);
-
-    private AbilityType() {
-        this(null, null, null, null, null);
-    }
-
     private AbilityType(String abilityOn, String abilityOff, String abilityPlayer, String abilityRefresh, String abilityPlayerOff) {
         this.abilityOn = abilityOn;
         this.abilityOff = abilityOff;
@@ -181,18 +152,12 @@ public enum AbilityType {
             case BLAST_MINING:
                 return Permissions.remoteDetonation(player);
 
-            case BLOCK_CRACKER:
-                return Permissions.blockCracker(player);
-
             case GIGA_DRILL_BREAKER:
                 return Permissions.gigaDrillBreaker(player);
 
             case GREEN_TERRA:
                 return Permissions.greenTerra(player);
 
-            case LEAF_BLOWER:
-                return Permissions.leafBlower(player);
-
             case SERRATED_STRIKES:
                 return Permissions.serratedStrikes(player);
 
@@ -221,18 +186,12 @@ public enum AbilityType {
             case BERSERK:
                 return (BlockUtils.affectedByGigaDrillBreaker(blockState) || blockState.getType() == Material.SNOW);
 
-            case BLOCK_CRACKER:
-                return BlockUtils.affectedByBlockCracker(blockState);
-
             case GIGA_DRILL_BREAKER:
                 return BlockUtils.affectedByGigaDrillBreaker(blockState);
 
             case GREEN_TERRA:
                 return BlockUtils.canMakeMossy(blockState);
 
-            case LEAF_BLOWER:
-                return BlockUtils.isLeaves(blockState);
-
             case SUPER_BREAKER:
                 return BlockUtils.affectedBySuperBreaker(blockState);
 
@@ -243,23 +202,4 @@ public enum AbilityType {
                 return false;
         }
     }
-
-    /**
-     * Check to see if ability should be triggered.
-     *
-     * @param player The player using the ability
-     * @param block The block modified by the ability
-     * @return true if the ability should activate, false otherwise
-     */
-    public boolean triggerCheck(Player player, Block block) {
-        switch (this) {
-            case BERSERK:
-            case BLOCK_CRACKER:
-            case LEAF_BLOWER:
-                return blockCheck(block.getState()) && EventUtils.simulateBlockBreak(block, player, true);
-
-            default:
-                return false;
-        }
-    }
 }

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

@@ -0,0 +1,78 @@
+package com.gmail.nossr50.datatypes.skills;
+
+public enum SecondaryAbility {
+    /* ACROBATICS */
+    DODGE,
+    GRACEFUL_ROLL,
+    ROLL,
+
+    /* ARCHERY */
+    DAZE,
+    RETRIEVE,
+    SKILL_SHOT,
+
+    /* Axes */
+    ARMOR_IMPACT,
+    AXE_MASTERY,
+    CRITICAL_HIT,
+    GREATER_IMPACT,
+
+    /* Excavation */
+    EXCAVATION_TREASURE_HUNTER,
+
+    /* Fishing */
+    FISHERMANS_DIET,
+    FISHING_TREASURE_HUNTER,
+    ICE_FISHING,
+    MAGIC_HUNTER,
+    MASTER_ANGLER,
+    SHAKE,
+
+    /* Herbalism */
+    FARMERS_DIET,
+    GREEN_THUMB_PLANT,
+    GREEN_THUMB_BLOCK,
+    HERBALISM_DOUBLE_DROPS,
+    HYLIAN_LUCK,
+    SHROOM_THUMB,
+
+    /* Mining */
+    MINING_DOUBLE_DROPS,
+
+    /* Repair */
+    ARCANE_FORGING,
+    REPAIR_MASTERY,
+    SALVAGE,
+    SUPER_REPAIR,
+
+    /* Smelting */
+    FLUX_MINING,
+    FUEL_EFFICIENCY,
+    SECOND_SMELT,
+
+    /* Swords */
+    BLEED,
+    COUNTER,
+
+    /* Taming */
+    BEAST_LORE,
+    CALL_OF_THE_WILD,
+    ENVIROMENTALLY_AWARE,
+    FAST_FOOD,
+    GORE,
+    HOLY_HOUND,
+    SHARPENED_CLAWS,
+    SHOCK_PROOF,
+    THICK_FUR,
+
+    /* Unarmed */
+    BLOCK_CRACKER,
+    DEFLECT,
+    DISARM,
+    IRON_ARM,
+    IRON_GRIP,
+
+    /* Woodcutting */
+    LEAF_BLOWER,
+    WOODCUTTING_DOUBLE_DROPS;
+}

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

@@ -34,24 +34,25 @@ import com.gmail.nossr50.util.skills.ParticleEffectUtils;
 import com.google.common.collect.ImmutableList;
 
 public enum SkillType {
-    ACROBATICS(AcrobaticsManager.class, Color.WHITE),
-    ARCHERY(ArcheryManager.class, Color.MAROON),
-    AXES(AxesManager.class, Color.AQUA, AbilityType.SKULL_SPLITTER, ToolType.AXE),
-    EXCAVATION(ExcavationManager.class, Color.fromRGB(139, 69, 19), AbilityType.GIGA_DRILL_BREAKER, ToolType.SHOVEL),
-    FISHING(FishingManager.class, Color.NAVY),
-    HERBALISM(HerbalismManager.class, Color.GREEN, AbilityType.GREEN_TERRA, ToolType.HOE),
-    MINING(MiningManager.class, Color.GRAY, AbilityType.SUPER_BREAKER, ToolType.PICKAXE),
-    REPAIR(RepairManager.class, Color.SILVER),
-    SMELTING(SmeltingManager.class, Color.YELLOW),
-    SWORDS(SwordsManager.class, Color.fromRGB(178, 34, 34), AbilityType.SERRATED_STRIKES, ToolType.SWORD),
-    TAMING(TamingManager.class, Color.PURPLE),
-    UNARMED(UnarmedManager.class, Color.BLACK, AbilityType.BERSERK, ToolType.FISTS),
-    WOODCUTTING(WoodcuttingManager.class, Color.OLIVE, AbilityType.TREE_FELLER, ToolType.AXE);
+    ACROBATICS(AcrobaticsManager.class, Color.WHITE, ImmutableList.of(SecondaryAbility.DODGE, SecondaryAbility.GRACEFUL_ROLL, SecondaryAbility.ROLL)),
+    ARCHERY(ArcheryManager.class, Color.MAROON, ImmutableList.of(SecondaryAbility.DAZE, SecondaryAbility.RETRIEVE, SecondaryAbility.SKILL_SHOT)),
+    AXES(AxesManager.class, Color.AQUA, AbilityType.SKULL_SPLITTER, ToolType.AXE, ImmutableList.of(SecondaryAbility.ARMOR_IMPACT, SecondaryAbility.AXE_MASTERY, SecondaryAbility.CRITICAL_HIT, SecondaryAbility.GREATER_IMPACT)),
+    EXCAVATION(ExcavationManager.class, Color.fromRGB(139, 69, 19), AbilityType.GIGA_DRILL_BREAKER, ToolType.SHOVEL, ImmutableList.of(SecondaryAbility.EXCAVATION_TREASURE_HUNTER)),
+    FISHING(FishingManager.class, Color.NAVY, ImmutableList.of(SecondaryAbility.FISHERMANS_DIET, SecondaryAbility.FISHING_TREASURE_HUNTER, SecondaryAbility.ICE_FISHING, SecondaryAbility.MAGIC_HUNTER, SecondaryAbility.MASTER_ANGLER, SecondaryAbility.SHAKE)),
+    HERBALISM(HerbalismManager.class, Color.GREEN, AbilityType.GREEN_TERRA, ToolType.HOE, ImmutableList.of(SecondaryAbility.FARMERS_DIET, SecondaryAbility.GREEN_THUMB_PLANT, SecondaryAbility.GREEN_THUMB_BLOCK, SecondaryAbility.HERBALISM_DOUBLE_DROPS, SecondaryAbility.HYLIAN_LUCK, SecondaryAbility.SHROOM_THUMB)),
+    MINING(MiningManager.class, Color.GRAY, AbilityType.SUPER_BREAKER, ToolType.PICKAXE, ImmutableList.of(SecondaryAbility.MINING_DOUBLE_DROPS)),
+    REPAIR(RepairManager.class, Color.SILVER, ImmutableList.of(SecondaryAbility.ARCANE_FORGING, SecondaryAbility.REPAIR_MASTERY, SecondaryAbility.SALVAGE, SecondaryAbility.SUPER_REPAIR)),
+    SMELTING(SmeltingManager.class, Color.YELLOW, ImmutableList.of(SecondaryAbility.FLUX_MINING, SecondaryAbility.FUEL_EFFICIENCY, SecondaryAbility.SECOND_SMELT)),
+    SWORDS(SwordsManager.class, Color.fromRGB(178, 34, 34), AbilityType.SERRATED_STRIKES, ToolType.SWORD, ImmutableList.of(SecondaryAbility.BLEED, SecondaryAbility.COUNTER)),
+    TAMING(TamingManager.class, Color.PURPLE, ImmutableList.of(SecondaryAbility.BEAST_LORE, SecondaryAbility.CALL_OF_THE_WILD, SecondaryAbility.ENVIROMENTALLY_AWARE, SecondaryAbility.FAST_FOOD, SecondaryAbility.GORE, SecondaryAbility.HOLY_HOUND, SecondaryAbility.SHARPENED_CLAWS, SecondaryAbility.SHOCK_PROOF, SecondaryAbility.THICK_FUR)),
+    UNARMED(UnarmedManager.class, Color.BLACK, AbilityType.BERSERK, ToolType.FISTS, ImmutableList.of(SecondaryAbility.BLOCK_CRACKER, SecondaryAbility.DEFLECT, SecondaryAbility.DISARM, SecondaryAbility.IRON_ARM, SecondaryAbility.IRON_GRIP)),
+    WOODCUTTING(WoodcuttingManager.class, Color.OLIVE, AbilityType.TREE_FELLER, ToolType.AXE, ImmutableList.of(SecondaryAbility.LEAF_BLOWER, SecondaryAbility.WOODCUTTING_DOUBLE_DROPS));
 
     private Class<? extends SkillManager> managerClass;
     private Color runescapeColor;
     private AbilityType ability;
     private ToolType tool;
+    private List<SecondaryAbility> secondaryAbilities;
 
     public static final List<String> SKILL_NAMES;
 
@@ -85,18 +86,16 @@ public enum SkillType {
         NON_CHILD_SKILLS = ImmutableList.copyOf(nonChildSkills);
     }
 
-    private SkillType(Class<? extends SkillManager> managerClass, Color runescapeColor) {
-        this.managerClass = managerClass;
-        this.runescapeColor = runescapeColor;
-        ability = null;
-        tool = null;
+    private SkillType(Class<? extends SkillManager> managerClass, Color runescapeColor, List<SecondaryAbility> secondaryAbilities) {
+        this(managerClass, runescapeColor, null, null, secondaryAbilities);
     }
 
-    private SkillType(Class<? extends SkillManager> managerClass, Color runescapeColor, AbilityType ability, ToolType tool) {
+    private SkillType(Class<? extends SkillManager> managerClass, Color runescapeColor, AbilityType ability, ToolType tool, List<SecondaryAbility> secondaryAbilities) {
         this.managerClass = managerClass;
         this.runescapeColor = runescapeColor;
         this.ability = ability;
         this.tool = tool;
+        this.secondaryAbilities = secondaryAbilities;
     }
 
     public Class<? extends SkillManager> getManagerClass() {
@@ -148,6 +147,10 @@ public enum SkillType {
         return tool;
     }
 
+    public List<SecondaryAbility> getSkillAbilities() {
+        return secondaryAbilities;
+    }
+
     public double getXpModifier() {
         return ExperienceConfig.getInstance().getFormulaSkillModifier(this);
     }
@@ -185,6 +188,15 @@ public enum SkillType {
         }
     }
 
+    public static SkillType bySecondaryAbility(SecondaryAbility skillAbility) {
+        for (SkillType type : values()) {
+            if (type.getSkillAbilities().contains(skillAbility)) {
+                return type;
+            }
+        }
+        return null;
+    }
+
     public static SkillType byAbility(AbilityType ability) {
         for (SkillType type : values()) {
             if (type.getAbility() == ability) {

src/main/java/com/gmail/nossr50/events/abilities/McMMOPlayerAbilityEvent.java

@@ -1,62 +0,0 @@
-package com.gmail.nossr50.events.abilities;
-
-import org.bukkit.entity.Player;
-import org.bukkit.event.HandlerList;
-import org.bukkit.event.player.PlayerEvent;
-
-import com.gmail.nossr50.datatypes.skills.AbilityType;
-import com.gmail.nossr50.datatypes.skills.SkillType;
-
-public abstract class McMMOPlayerAbilityEvent extends PlayerEvent {
-    private SkillType skill;
-    private AbilityType ability;
-    private boolean useParticleEffects;
-
-    @Deprecated
-    protected McMMOPlayerAbilityEvent(Player player, SkillType skill) {
-        super(player);
-        ability = skill.getAbility();
-        useParticleEffects = true;
-    }
-
-    protected McMMOPlayerAbilityEvent(Player player, AbilityType ability) {
-        super(player);
-        this.ability = ability;
-        this.useParticleEffects = true;
-    }
-
-    protected McMMOPlayerAbilityEvent(Player player, AbilityType ability, boolean useParticleEffects) {
-        super(player);
-        this.ability = ability;
-        this.useParticleEffects = useParticleEffects;
-    }
-
-    @Deprecated
-    public SkillType getSkill() {
-        return skill;
-    }
-
-    public AbilityType getAbility() {
-        return ability;
-    }
-
-    public boolean useParticleEffects() {
-        return useParticleEffects;
-    }
-
-    public void shouldUseParticleEffects(boolean useParticleEffects) {
-        this.useParticleEffects = useParticleEffects;
-    }
-
-    /** Rest of file is required boilerplate for custom events **/
-    private static final HandlerList handlers = new HandlerList();
-
-    @Override
-    public HandlerList getHandlers() {
-        return handlers;
-    }
-
-    public static HandlerList getHandlerList() {
-        return handlers;
-    }
-}

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

@@ -1,9 +1,8 @@
-package com.gmail.nossr50.events.experience.levels;
+package com.gmail.nossr50.events.experience;
 
 import org.bukkit.entity.Player;
 
 import com.gmail.nossr50.datatypes.skills.SkillType;
-import com.gmail.nossr50.events.experience.McMMOPlayerExperienceEvent;
 
 /**
  * Called when a user levels change

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

@@ -1,4 +1,4 @@
-package com.gmail.nossr50.events.experience.levels;
+package com.gmail.nossr50.events.experience;
 
 import org.bukkit.entity.Player;
 

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

@@ -1,4 +1,4 @@
-package com.gmail.nossr50.events.experience.levels;
+package com.gmail.nossr50.events.experience;
 
 import org.bukkit.entity.Player;
 

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

@@ -1,4 +1,4 @@
-package com.gmail.nossr50.events.experience.xp;
+package com.gmail.nossr50.events.experience;
 
 import org.bukkit.entity.Player;
 
@@ -7,7 +7,7 @@ import com.gmail.nossr50.datatypes.skills.SkillType;
 /**
  * Called when a player gains XP in a skill
  */
-public class McMMOPlayerXpGainEvent extends McMMOPlayerXpChangeEvent {
+public class McMMOPlayerXpGainEvent extends McMMOPlayerExperienceEvent {
     private float xpGained;
 
     public McMMOPlayerXpGainEvent(Player player, SkillType skill, float xpGained) {
@@ -31,7 +31,7 @@ public class McMMOPlayerXpGainEvent extends McMMOPlayerXpChangeEvent {
     }
 
     /**
-     * @param xpGained float amount of experience gained in this event
+     * @param xpGained int amount of experience gained in this event
      */
     public void setRawXpGained(float xpGained) {
         this.xpGained = xpGained;

src/main/java/com/gmail/nossr50/events/experience/xp/McMMOPlayerXpChangeEvent.java

@@ -1,12 +0,0 @@
-package com.gmail.nossr50.events.experience.xp;
-
-import org.bukkit.entity.Player;
-
-import com.gmail.nossr50.datatypes.skills.SkillType;
-import com.gmail.nossr50.events.experience.McMMOPlayerExperienceEvent;
-
-public abstract class McMMOPlayerXpChangeEvent extends McMMOPlayerExperienceEvent {
-    public McMMOPlayerXpChangeEvent(Player player, SkillType skill) {
-        super(player, skill);
-    }
-}

src/main/java/com/gmail/nossr50/events/experience/xp/McMMOPlayerXpLossEvent.java

@@ -1,28 +0,0 @@
-package com.gmail.nossr50.events.experience.xp;
-
-import org.bukkit.entity.Player;
-
-import com.gmail.nossr50.datatypes.skills.SkillType;
-
-public class McMMOPlayerXpLossEvent extends McMMOPlayerXpChangeEvent {
-    private float xpLost;
-
-    public McMMOPlayerXpLossEvent(Player player, SkillType skill, float xpLost) {
-        super(player, skill);
-        this.xpLost = xpLost;
-    }
-
-    /**
-     * @return The amount of experience lost in this event
-     */
-    public float getRawXpLost() {
-        return xpLost;
-    }
-
-    /**
-     * @param xpLost amount of experience lost in this event
-     */
-    public void setRawXpLost(float xpLost) {
-        this.xpLost = xpLost;
-    }
-}

src/main/java/com/gmail/nossr50/events/skills/McMMOPlayerCombatEvent.java

@@ -1,40 +0,0 @@
-package com.gmail.nossr50.events.skills;
-
-import org.bukkit.entity.Entity;
-import org.bukkit.entity.Player;
-
-import com.gmail.nossr50.datatypes.skills.SkillType;
-import com.gmail.nossr50.events.fake.FakeEntityDamageByEntityEvent;
-import com.gmail.nossr50.util.player.UserManager;
-
-public abstract class McMMOPlayerCombatEvent extends FakeEntityDamageByEntityEvent {
-    private Player player;
-    private SkillType skill;
-    private int skillLevel;
-
-    protected McMMOPlayerCombatEvent(Player player, Entity damager, Entity damagee, DamageCause cause, double damage, SkillType skill) {
-        super(damager, damagee, cause, damage);
-        this.player = player;
-        this.skill = skill;
-        skillLevel = UserManager.getPlayer(player).getProfile().getSkillLevel(skill);
-    }
-
-    protected McMMOPlayerCombatEvent(Player player, Entity damagee, DamageCause cause, double damage, SkillType skill) {
-        super(player, damagee, cause, damage);
-        this.player = player;
-        this.skill = skill;
-        skillLevel = UserManager.getPlayer(player).getProfile().getSkillLevel(skill);
-    }
-
-    public Player getPlayer() {
-        return player;
-    }
-
-    public SkillType getSkill() {
-        return skill;
-    }
-
-    public int getSkillLevel() {
-        return skillLevel;
-    }
-}

src/main/java/com/gmail/nossr50/events/skills/McMMOPlayerTreasureEvent.java

@@ -1,44 +0,0 @@
-package com.gmail.nossr50.events.skills;
-
-import org.bukkit.entity.Player;
-import org.bukkit.event.Cancellable;
-import org.bukkit.inventory.ItemStack;
-
-import com.gmail.nossr50.datatypes.skills.SkillType;
-
-public abstract class McMMOPlayerTreasureEvent extends McMMOPlayerSkillEvent implements Cancellable {
-    private boolean cancelled;
-    private ItemStack treasure;
-    private int xpGained;
-
-    protected McMMOPlayerTreasureEvent(Player player, SkillType skill, ItemStack treasure, int xpGained) {
-        super(player, skill);
-        this.treasure = treasure;
-        this.xpGained = xpGained;
-        this.cancelled = false;
-    }
-
-    public ItemStack getTreasure() {
-        return treasure;
-    }
-
-    public void setTreasure(ItemStack item) {
-        this.treasure = item;
-    }
-
-    public int getXpGained() {
-        return xpGained;
-    }
-
-    public void setXpGained(int xpGained) {
-        this.xpGained = xpGained;
-    }
-
-    public boolean isCancelled() {
-        return cancelled;
-    }
-
-    public void setCancelled(boolean newValue) {
-        this.cancelled = newValue;
-    }
-}

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

@@ -1,25 +1,18 @@
-package com.gmail.nossr50.events.abilities;
+package com.gmail.nossr50.events.skills.abilities;
 
 import org.bukkit.entity.Player;
 import org.bukkit.event.Cancellable;
 
-import com.gmail.nossr50.datatypes.skills.AbilityType;
 import com.gmail.nossr50.datatypes.skills.SkillType;
 
 public class McMMOPlayerAbilityActivateEvent extends McMMOPlayerAbilityEvent implements Cancellable {
     private boolean cancelled;
 
-    @Deprecated
     public McMMOPlayerAbilityActivateEvent(Player player, SkillType skill) {
         super(player, skill);
         cancelled = false;
     }
 
-    public McMMOPlayerAbilityActivateEvent(Player player, AbilityType ability) {
-        super(player, ability);
-        cancelled = false;
-    }
-
     public boolean isCancelled() {
         return cancelled;
     }

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

@@ -1,17 +1,11 @@
-package com.gmail.nossr50.events.abilities;
+package com.gmail.nossr50.events.skills.abilities;
 
 import org.bukkit.entity.Player;
 
-import com.gmail.nossr50.datatypes.skills.AbilityType;
 import com.gmail.nossr50.datatypes.skills.SkillType;
 
 public class McMMOPlayerAbilityDeactivateEvent extends McMMOPlayerAbilityEvent {
-    @Deprecated
     public McMMOPlayerAbilityDeactivateEvent(Player player, SkillType skill) {
         super(player, skill);
     }
-
-    public McMMOPlayerAbilityDeactivateEvent(Player player, AbilityType ability) {
-        super(player, ability);
-    }
 }

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

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

src/main/java/com/gmail/nossr50/events/skills/acrobatics/McMMOPlayerAcrobaticsEvent.java

@@ -1,24 +0,0 @@
-package com.gmail.nossr50.events.skills.acrobatics;
-
-import org.bukkit.entity.Player;
-import org.bukkit.event.Cancellable;
-
-import com.gmail.nossr50.datatypes.skills.SkillType;
-import com.gmail.nossr50.events.skills.McMMOPlayerSkillEvent;
-
-public abstract class McMMOPlayerAcrobaticsEvent extends McMMOPlayerSkillEvent implements Cancellable {
-    private boolean cancelled;
-
-    protected McMMOPlayerAcrobaticsEvent(Player player) {
-        super(player, SkillType.ACROBATICS);
-        cancelled = false;
-    }
-
-    public boolean isCancelled() {
-        return cancelled;
-    }
-
-    public void setCancelled(boolean cancelled) {
-        this.cancelled = cancelled;
-    }
-}

src/main/java/com/gmail/nossr50/events/skills/acrobatics/McMMOPlayerDodgeEvent.java

@@ -1,30 +0,0 @@
-package com.gmail.nossr50.events.skills.acrobatics;
-
-import org.bukkit.entity.Player;
-
-public class McMMOPlayerDodgeEvent extends McMMOPlayerAcrobaticsEvent {
-    private double damageTaken;
-    private float xpGained;
-
-    public McMMOPlayerDodgeEvent(Player player, double damageTaken, float xpGained) {
-        super(player);
-        this.damageTaken = damageTaken;
-        this.xpGained = xpGained;
-    }
-
-    public double getDamageTaken() {
-        return damageTaken;
-    }
-
-    public void setDamageTaken(double damageTaken) {
-        this.damageTaken = damageTaken;
-    }
-
-    public float getXpGained() {
-        return xpGained;
-    }
-
-    public void setXpGained(float xpGained) {
-        this.xpGained = xpGained;
-    }
-}

src/main/java/com/gmail/nossr50/events/skills/acrobatics/McMMOPlayerRollEvent.java

@@ -1,36 +0,0 @@
-package com.gmail.nossr50.events.skills.acrobatics;
-
-import org.bukkit.entity.Player;
-
-public class McMMOPlayerRollEvent extends McMMOPlayerAcrobaticsEvent {
-    private double damageTaken;
-    private float xpGained;
-    private boolean graceful;
-
-    public McMMOPlayerRollEvent(Player player, double damageTaken, float xpGained, boolean graceful) {
-        super(player);
-        this.damageTaken = damageTaken;
-        this.xpGained = xpGained;
-        this.graceful = graceful;
-    }
-
-    public double getDamageTaken() {
-        return damageTaken;
-    }
-
-    public void setDamageTaken(double damageTaken) {
-        this.damageTaken = damageTaken;
-    }
-
-    public float getXpGained() {
-        return xpGained;
-    }
-
-    public void setXpGained(float xpGained) {
-        this.xpGained = xpGained;
-    }
-
-    public boolean isGraceful() {
-        return graceful;
-    }
-}

src/main/java/com/gmail/nossr50/events/skills/archery/McMMOPlayerArcheryCombatEvent.java

@@ -1,13 +0,0 @@
-package com.gmail.nossr50.events.skills.archery;
-
-import org.bukkit.entity.Entity;
-import org.bukkit.entity.Player;
-
-import com.gmail.nossr50.datatypes.skills.SkillType;
-import com.gmail.nossr50.events.skills.McMMOPlayerCombatEvent;
-
-public class McMMOPlayerArcheryCombatEvent extends McMMOPlayerCombatEvent {
-    public McMMOPlayerArcheryCombatEvent(Player player, Entity damager, Entity damagee, DamageCause cause, double damage) {
-        super(player, damager, damagee, cause, damage, SkillType.ARCHERY);
-    }
-}

src/main/java/com/gmail/nossr50/events/skills/archery/McMMOPlayerArcheryEvent.java

@@ -1,24 +0,0 @@
-package com.gmail.nossr50.events.skills.archery;
-
-import org.bukkit.entity.Player;
-import org.bukkit.event.Cancellable;
-
-import com.gmail.nossr50.datatypes.skills.SkillType;
-import com.gmail.nossr50.events.skills.McMMOPlayerSkillEvent;
-
-public abstract class McMMOPlayerArcheryEvent extends McMMOPlayerSkillEvent implements Cancellable {
-    private boolean cancelled;
-
-    protected McMMOPlayerArcheryEvent(Player player) {
-        super(player, SkillType.ARCHERY);
-        cancelled = false;
-    }
-
-    public boolean isCancelled() {
-        return cancelled;
-    }
-
-    public void setCancelled(boolean cancelled) {
-        this.cancelled = cancelled;
-    }
-}

src/main/java/com/gmail/nossr50/events/skills/archery/McMMOPlayerDazeEvent.java

@@ -1,12 +0,0 @@
-package com.gmail.nossr50.events.skills.archery;
-
-import org.bukkit.entity.Entity;
-import org.bukkit.entity.Player;
-
-import com.gmail.nossr50.skills.archery.Archery;
-
-public class McMMOPlayerDazeEvent extends McMMOPlayerArcheryCombatEvent {
-    public McMMOPlayerDazeEvent(Player player, Entity damager, Entity damagee) {
-        super(player, damager, damagee, DamageCause.PROJECTILE, Archery.dazeModifier);
-    }
-}

src/main/java/com/gmail/nossr50/events/skills/archery/McMMOPlayerSkillShotEvent.java

@@ -1,10 +0,0 @@
-package com.gmail.nossr50.events.skills.archery;
-
-import org.bukkit.entity.Entity;
-import org.bukkit.entity.Player;
-
-public class McMMOPlayerSkillShotEvent extends McMMOPlayerArcheryCombatEvent {
-    public McMMOPlayerSkillShotEvent(Player player, Entity damager, Entity damagee, double damage) {
-        super(player, damager, damagee, DamageCause.PROJECTILE, damage);
-    }
-}

src/main/java/com/gmail/nossr50/events/skills/axes/McMMOPlayerAxeCombatEvent.java

@@ -1,13 +0,0 @@
-package com.gmail.nossr50.events.skills.axes;
-
-import org.bukkit.entity.Entity;
-import org.bukkit.entity.Player;
-
-import com.gmail.nossr50.datatypes.skills.SkillType;
-import com.gmail.nossr50.events.skills.McMMOPlayerCombatEvent;
-
-public class McMMOPlayerAxeCombatEvent extends McMMOPlayerCombatEvent {
-    public McMMOPlayerAxeCombatEvent(Player player, Entity damagee, DamageCause cause, double damage) {
-        super(player, damagee, cause, damage, SkillType.AXES);
-    }
-}

src/main/java/com/gmail/nossr50/events/skills/axes/McMMOPlayerAxeEvent.java

@@ -1,24 +0,0 @@
-package com.gmail.nossr50.events.skills.axes;
-
-import org.bukkit.entity.Player;
-import org.bukkit.event.Cancellable;
-
-import com.gmail.nossr50.datatypes.skills.SkillType;
-import com.gmail.nossr50.events.skills.McMMOPlayerSkillEvent;
-
-public abstract class McMMOPlayerAxeEvent extends McMMOPlayerSkillEvent implements Cancellable {
-    private boolean cancelled;
-
-    protected McMMOPlayerAxeEvent(Player player) {
-        super(player, SkillType.AXES);
-        cancelled = false;
-    }
-
-    public boolean isCancelled() {
-        return cancelled;
-    }
-
-    public void setCancelled(boolean cancelled) {
-        this.cancelled = cancelled;
-    }
-}

src/main/java/com/gmail/nossr50/events/skills/axes/McMMOPlayerAxeMasteryEvent.java

@@ -1,12 +0,0 @@
-package com.gmail.nossr50.events.skills.axes;
-
-import org.bukkit.entity.Entity;
-import org.bukkit.entity.Player;
-
-public class McMMOPlayerAxeMasteryEvent extends McMMOPlayerAxeCombatEvent {
-    public McMMOPlayerAxeMasteryEvent(Player player, Entity damagee, double damage) {
-        super(player, damagee, DamageCause.ENTITY_ATTACK, damage);
-        // TODO Auto-generated constructor stub
-    }
-
-}

src/main/java/com/gmail/nossr50/events/skills/axes/McMMOPlayerCriticalHitEvent.java

@@ -1,10 +0,0 @@
-package com.gmail.nossr50.events.skills.axes;
-
-import org.bukkit.entity.Entity;
-import org.bukkit.entity.Player;
-
-public class McMMOPlayerCriticalHitEvent extends McMMOPlayerAxeCombatEvent {
-    public McMMOPlayerCriticalHitEvent(Player player, Entity damagee, double damage) {
-        super(player, damagee, DamageCause.ENTITY_ATTACK, damage);
-    }
-}

src/main/java/com/gmail/nossr50/events/skills/axes/McMMOPlayerGreaterImpactEvent.java

@@ -1,22 +0,0 @@
-package com.gmail.nossr50.events.skills.axes;
-
-import org.bukkit.entity.Entity;
-import org.bukkit.entity.Player;
-import org.bukkit.util.Vector;
-
-public class McMMOPlayerGreaterImpactEvent extends McMMOPlayerAxeCombatEvent {
-    private Vector knockbackVelocity;
-
-    public McMMOPlayerGreaterImpactEvent(Player player, Entity damagee, double damage, Vector knockbackVelocity) {
-        super(player, damagee, DamageCause.ENTITY_ATTACK, damage);
-        this.knockbackVelocity = knockbackVelocity;
-    }
-
-    public Vector getKnockbackVelocity() {
-        return knockbackVelocity;
-    }
-
-    public void setKnockbackVelocity(Vector knockbackVelocity) {
-        this.knockbackVelocity = knockbackVelocity;
-    }
-}

src/main/java/com/gmail/nossr50/events/skills/axes/McMMOPlayerImpactEvent.java

@@ -1,17 +0,0 @@
-package com.gmail.nossr50.events.skills.axes;
-
-import org.bukkit.entity.Player;
-import org.bukkit.inventory.ItemStack;
-
-public class McMMOPlayerImpactEvent extends McMMOPlayerAxeEvent {
-    private ItemStack armor;
-
-    public McMMOPlayerImpactEvent(Player player, ItemStack armor) {
-        super(player);
-        this.armor = armor;
-    }
-
-    public ItemStack getArmor() {
-        return armor;
-    }
-}

src/main/java/com/gmail/nossr50/events/skills/excavation/McMMOPlayerExcavationTreasureEvent.java

@@ -1,21 +0,0 @@
-package com.gmail.nossr50.events.skills.excavation;
-
-import org.bukkit.block.Block;
-import org.bukkit.entity.Player;
-import org.bukkit.inventory.ItemStack;
-
-import com.gmail.nossr50.datatypes.skills.SkillType;
-import com.gmail.nossr50.events.skills.McMMOPlayerTreasureEvent;
-
-public class McMMOPlayerExcavationTreasureEvent extends McMMOPlayerTreasureEvent {
-    private Block block;
-
-    public McMMOPlayerExcavationTreasureEvent(Player player, ItemStack treasure, int xpGained, Block block) {
-        super(player, SkillType.EXCAVATION, treasure, xpGained);
-        this.block = block;
-    }
-
-    public Block getBlock() {
-        return block;
-    }
-}

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

@@ -1,13 +0,0 @@
-package com.gmail.nossr50.events.skills.fishing;
-
-import org.bukkit.entity.Entity;
-import org.bukkit.entity.Player;
-
-import com.gmail.nossr50.datatypes.skills.SkillType;
-import com.gmail.nossr50.events.skills.McMMOPlayerCombatEvent;
-
-public abstract class McMMOPlayerFishingCombatEvent extends McMMOPlayerCombatEvent {
-    public McMMOPlayerFishingCombatEvent(Player player, Entity damager, Entity damagee, DamageCause cause, double damage) {
-        super(player, damager, damagee, cause, damage, SkillType.FISHING);
-    }
-}

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

@@ -3,11 +3,29 @@ package com.gmail.nossr50.events.skills.fishing;
 import org.bukkit.entity.Player;
 import org.bukkit.inventory.ItemStack;
 
-import com.gmail.nossr50.datatypes.skills.SkillType;
-import com.gmail.nossr50.events.skills.McMMOPlayerTreasureEvent;
+public class McMMOPlayerFishingTreasureEvent extends McMMOPlayerFishingEvent {
+    private ItemStack treasure;
+    private int xp;
 
-public class McMMOPlayerFishingTreasureEvent extends McMMOPlayerTreasureEvent {
-    public McMMOPlayerFishingTreasureEvent(Player player, ItemStack treasure, int xpGained) {
-        super(player, SkillType.FISHING, treasure, xpGained);
+    public McMMOPlayerFishingTreasureEvent(Player player, ItemStack treasure, int xp) {
+        super(player);
+        this.treasure = treasure;
+        this.xp = xp;
+    }
+
+    public ItemStack getTreasure() {
+        return treasure;
+    }
+
+    public void setTreasure(ItemStack item) {
+        this.treasure = item;
+    }
+
+    public int getXp() {
+        return xp;
+    }
+
+    public void setXp(int xp) {
+        this.xp = xp;
     }
 }

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

@@ -1,15 +1,13 @@
 package com.gmail.nossr50.events.skills.fishing;
 
-import org.bukkit.entity.Fish;
-import org.bukkit.entity.LivingEntity;
 import org.bukkit.entity.Player;
 import org.bukkit.inventory.ItemStack;
 
-public class McMMOPlayerShakeEvent extends McMMOPlayerFishingCombatEvent {
+public class McMMOPlayerShakeEvent extends McMMOPlayerFishingEvent {
     private ItemStack drop;
 
-    public McMMOPlayerShakeEvent(Player player, Fish hook, ItemStack drop, LivingEntity target, double damage) {
-        super(player, hook, target, DamageCause.PROJECTILE, damage);
+    public McMMOPlayerShakeEvent(Player player, ItemStack drop) {
+        super(player);
         this.drop = drop;
     }
 

src/main/java/com/gmail/nossr50/events/skills/herbalism/McMMOPlayerHerbalismEvent.java

@@ -1,12 +0,0 @@
-package com.gmail.nossr50.events.skills.herbalism;
-
-import org.bukkit.entity.Player;
-
-import com.gmail.nossr50.datatypes.skills.SkillType;
-import com.gmail.nossr50.events.skills.McMMOPlayerSkillEvent;
-
-public abstract class McMMOPlayerHerbalismEvent extends McMMOPlayerSkillEvent {
-    public McMMOPlayerHerbalismEvent(Player player) {
-        super(player, SkillType.HERBALISM);
-    }
-}

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

@@ -0,0 +1,25 @@
+package com.gmail.nossr50.events.skills.secondaryabilities;
+
+import org.bukkit.entity.Player;
+
+import com.gmail.nossr50.datatypes.skills.SecondaryAbility;
+import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.events.skills.McMMOPlayerSkillEvent;
+
+public abstract class SecondaryAbilityEvent extends McMMOPlayerSkillEvent {
+
+    private SecondaryAbility secondaryAbility;
+
+    public SecondaryAbilityEvent(Player player, SecondaryAbility secondaryAbility) {
+        super(player, SkillType.bySecondaryAbility(secondaryAbility));
+        this.secondaryAbility = secondaryAbility;
+    }
+
+    /**
+     * Gets the SecondaryAbility involved in the event
+     * @return the SecondaryAbility
+     */
+    public SecondaryAbility getSecondaryAbility() {
+        return secondaryAbility;
+    }
+}

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

@@ -0,0 +1,38 @@
+package com.gmail.nossr50.events.skills.secondaryabilities;
+
+import org.bukkit.entity.Player;
+import com.gmail.nossr50.datatypes.skills.SecondaryAbility;
+
+public class SecondaryAbilityWeightedActivationCheckEvent extends SecondaryAbilityEvent {
+
+    private double chance;
+
+    public SecondaryAbilityWeightedActivationCheckEvent(Player player, SecondaryAbility ability, double chance) {
+        super(player, ability);
+        this.chance = chance;
+    }
+
+    /**
+     * Gets the activation chance of the ability 0D being no chance,  1.0D being 100% chance
+     * @return The activation chance of the ability
+     */
+    public double getChance() {
+        return chance;
+    }
+
+    /**
+     * Sets the activation chance of the ability [0D-1.0D]
+     * @param The activation chance of the ability
+     */
+    public void setChance(double chance) {
+        this.chance = chance;
+    }
+
+    /**
+     * Sets the activation chance of the ability to 100% or 0%
+     * @param whether it should be successful or not
+     */
+    public void setSuccessful(boolean success) {
+        this.chance = success ? 1.0D : 0D;
+    }
+}

src/main/java/com/gmail/nossr50/events/skills/unarmed/McMMOPlayerDeflectEvent.java

@@ -1,9 +0,0 @@
-package com.gmail.nossr50.events.skills.unarmed;
-
-import org.bukkit.entity.Player;
-
-public class McMMOPlayerDeflectEvent extends McMMOPlayerUnarmedEvent {
-    public McMMOPlayerDeflectEvent(Player player) {
-        super(player);
-    }
-}

src/main/java/com/gmail/nossr50/events/skills/unarmed/McMMOPlayerDisarmEvent.java

@@ -1,27 +1,32 @@
 package com.gmail.nossr50.events.skills.unarmed;
 
 import org.bukkit.entity.Player;
-import org.bukkit.inventory.ItemStack;
+import org.bukkit.event.Cancellable;
 
-public class McMMOPlayerDisarmEvent extends McMMOPlayerUnarmedEvent {
+import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.events.skills.McMMOPlayerSkillEvent;
+
+public class McMMOPlayerDisarmEvent extends McMMOPlayerSkillEvent implements Cancellable {
+    private boolean cancelled;
     private Player defender;
-    private ItemStack droppedItem;
 
-    public McMMOPlayerDisarmEvent(Player attacker, Player defender) {
-        super(attacker);
+    public McMMOPlayerDisarmEvent(Player defender) {
+        super(defender, SkillType.UNARMED);
         this.defender = defender;
-        this.setDroppedItem(defender.getItemInHand());
     }
 
     public Player getDefender() {
         return defender;
     }
 
-    public ItemStack getDroppedItem() {
-        return droppedItem;
+    /** Following are required for Cancellable **/
+    @Override
+    public boolean isCancelled() {
+        return cancelled;
     }
 
-    public void setDroppedItem(ItemStack droppedItem) {
-        this.droppedItem = droppedItem;
+    @Override
+    public void setCancelled(boolean cancelled) {
+        this.cancelled = cancelled;
     }
 }

src/main/java/com/gmail/nossr50/events/skills/unarmed/McMMOPlayerUnarmedEvent.java

@@ -1,24 +0,0 @@
-package com.gmail.nossr50.events.skills.unarmed;
-
-import org.bukkit.entity.Player;
-import org.bukkit.event.Cancellable;
-
-import com.gmail.nossr50.datatypes.skills.SkillType;
-import com.gmail.nossr50.events.skills.McMMOPlayerSkillEvent;
-
-public abstract class McMMOPlayerUnarmedEvent extends McMMOPlayerSkillEvent implements Cancellable {
-    private boolean cancelled;
-
-    protected McMMOPlayerUnarmedEvent(Player player) {
-        super(player, SkillType.UNARMED);
-        cancelled = false;
-    }
-
-    public boolean isCancelled() {
-        return cancelled;
-    }
-
-    public void setCancelled(boolean cancelled) {
-        this.cancelled = cancelled;
-    }
-}

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

@@ -26,6 +26,7 @@ import com.gmail.nossr50.config.HiddenConfig;
 import com.gmail.nossr50.datatypes.player.McMMOPlayer;
 import com.gmail.nossr50.datatypes.skills.AbilityType;
 import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.datatypes.skills.ToolType;
 import com.gmail.nossr50.events.fake.FakeBlockBreakEvent;
 import com.gmail.nossr50.events.fake.FakeBlockDamageEvent;
 import com.gmail.nossr50.runnables.StickyPistonTrackerTask;
@@ -35,6 +36,7 @@ import com.gmail.nossr50.skills.mining.MiningManager;
 import com.gmail.nossr50.skills.smelting.SmeltingManager;
 import com.gmail.nossr50.skills.woodcutting.WoodcuttingManager;
 import com.gmail.nossr50.util.BlockUtils;
+import com.gmail.nossr50.util.EventUtils;
 import com.gmail.nossr50.util.ItemUtils;
 import com.gmail.nossr50.util.Misc;
 import com.gmail.nossr50.util.Permissions;
@@ -143,17 +145,21 @@ public class BlockListener implements Listener {
         ItemStack heldItem = player.getItemInHand();
 
         /* HERBALISM */
-        if (BlockUtils.affectedByGreenTerra(blockState) && Permissions.skillEnabled(player, SkillType.HERBALISM)) {
+        if (BlockUtils.affectedByGreenTerra(blockState)) {
             HerbalismManager herbalismManager = mcMMOPlayer.getHerbalismManager();
 
             /* Green Terra */
-            mcMMOPlayer.checkAbilityActivation(SkillType.HERBALISM);
+            if (herbalismManager.canActivateAbility()) {
+                mcMMOPlayer.checkAbilityActivation(SkillType.HERBALISM);
+            }
 
             /*
              * We don't check the block store here because herbalism has too many unusual edge cases.
              * Instead, we check it inside the drops handler.
              */
-            herbalismManager.blockBreak(blockState);
+            if (SkillType.HERBALISM.getPermissions(player)) {
+                herbalismManager.herbalismBlockCheck(blockState);
+            }
         }
 
         /* MINING */
@@ -177,7 +183,7 @@ public class BlockListener implements Listener {
         /* EXCAVATION */
         else if (BlockUtils.affectedByGigaDrillBreaker(blockState) && ItemUtils.isShovel(heldItem) && SkillType.EXCAVATION.getPermissions(player) && !mcMMO.getPlaceStore().isTrue(blockState)) {
             ExcavationManager excavationManager = mcMMOPlayer.getExcavationManager();
-            excavationManager.blockBreak(blockState);
+            excavationManager.excavationBlockCheck(blockState);
 
             if (mcMMOPlayer.getAbilityMode(AbilityType.GIGA_DRILL_BREAKER)) {
                 excavationManager.gigaDrillBreaker(blockState);
@@ -274,19 +280,19 @@ public class BlockListener implements Listener {
                 }
             }
 
-            if (ItemUtils.isHoe(heldItem) && (BlockUtils.affectedByGreenTerra(blockState) || BlockUtils.canMakeMossy(blockState))) {
+            if (mcMMOPlayer.getToolPreparationMode(ToolType.HOE) && ItemUtils.isHoe(heldItem) && (BlockUtils.affectedByGreenTerra(blockState) || BlockUtils.canMakeMossy(blockState)) && Permissions.greenTerra(player)) {
                 mcMMOPlayer.checkAbilityActivation(SkillType.HERBALISM);
             }
-            else if (ItemUtils.isAxe(heldItem) && BlockUtils.isLog(blockState)) {
+            else if (mcMMOPlayer.getToolPreparationMode(ToolType.AXE) && ItemUtils.isAxe(heldItem) && BlockUtils.isLog(blockState) && Permissions.treeFeller(player)) {
                 mcMMOPlayer.checkAbilityActivation(SkillType.WOODCUTTING);
             }
-            else if (ItemUtils.isPickaxe(heldItem) && BlockUtils.affectedBySuperBreaker(blockState)) {
+            else if (mcMMOPlayer.getToolPreparationMode(ToolType.PICKAXE) && ItemUtils.isPickaxe(heldItem) && BlockUtils.affectedBySuperBreaker(blockState) && Permissions.superBreaker(player)) {
                 mcMMOPlayer.checkAbilityActivation(SkillType.MINING);
             }
-            else if (ItemUtils.isShovel(heldItem) && BlockUtils.affectedByGigaDrillBreaker(blockState)) {
+            else if (mcMMOPlayer.getToolPreparationMode(ToolType.SHOVEL) && ItemUtils.isShovel(heldItem) && BlockUtils.affectedByGigaDrillBreaker(blockState) && Permissions.gigaDrillBreaker(player)) {
                 mcMMOPlayer.checkAbilityActivation(SkillType.EXCAVATION);
             }
-            else if (heldItem.getType() == Material.AIR && (BlockUtils.affectedByGigaDrillBreaker(blockState) || blockState.getType() == Material.SNOW || BlockUtils.affectedByBlockCracker(blockState))) {
+            else if (mcMMOPlayer.getToolPreparationMode(ToolType.FISTS) && heldItem.getType() == Material.AIR && (BlockUtils.affectedByGigaDrillBreaker(blockState) || blockState.getType() == Material.SNOW || BlockUtils.affectedByBlockCracker(blockState) && Permissions.berserk(player))) {
                 mcMMOPlayer.checkAbilityActivation(SkillType.UNARMED);
             }
         }
@@ -329,22 +335,22 @@ public class BlockListener implements Listener {
          * We don't need to check permissions here because they've already been checked for the ability to even activate.
          */
         if (mcMMOPlayer.getAbilityMode(AbilityType.GREEN_TERRA) && BlockUtils.canMakeMossy(blockState)) {
-            if (mcMMOPlayer.getHerbalismManager().greenTerra(blockState)) {
+            if (mcMMOPlayer.getHerbalismManager().processGreenTerra(blockState)) {
                 blockState.update(true);
             }
         }
         else if (mcMMOPlayer.getAbilityMode(AbilityType.BERSERK) && heldItem.getType() == Material.AIR) {
-            if (AbilityType.BERSERK.triggerCheck(player, block)) {
+            if (AbilityType.BERSERK.blockCheck(block.getState()) && EventUtils.simulateBlockBreak(block, player, true)) {
                 event.setInstaBreak(true);
                 player.playSound(block.getLocation(), Sound.ITEM_PICKUP, Misc.POP_VOLUME, Misc.getPopPitch());
             }
-            else if (mcMMOPlayer.getUnarmedManager().canUseBlockCracker() && AbilityType.BLOCK_CRACKER.triggerCheck(player, block)) {
+            else if (mcMMOPlayer.getUnarmedManager().canUseBlockCracker() && BlockUtils.affectedByBlockCracker(blockState) && EventUtils.simulateBlockBreak(block, player, true)) {
                 if (mcMMOPlayer.getUnarmedManager().blockCrackerCheck(blockState)) {
                     blockState.update();
                 }
             }
         }
-        else if (mcMMOPlayer.getWoodcuttingManager().canUseLeafBlower(heldItem) && AbilityType.LEAF_BLOWER.triggerCheck(player, block)) {
+        else if (mcMMOPlayer.getWoodcuttingManager().canUseLeafBlower(heldItem) && BlockUtils.isLeaves(blockState) && EventUtils.simulateBlockBreak(block, player, true)) {
             event.setInstaBreak(true);
             player.playSound(blockState.getLocation(), Sound.ITEM_PICKUP, Misc.POP_VOLUME, Misc.getPopPitch());
         }

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

@@ -36,10 +36,12 @@ import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.config.AdvancedConfig;
 import com.gmail.nossr50.config.Config;
 import com.gmail.nossr50.datatypes.player.McMMOPlayer;
+import com.gmail.nossr50.datatypes.skills.SecondaryAbility;
 import com.gmail.nossr50.events.fake.FakeEntityDamageByEntityEvent;
 import com.gmail.nossr50.events.fake.FakeEntityDamageEvent;
 import com.gmail.nossr50.party.PartyManager;
 import com.gmail.nossr50.runnables.skills.BleedTimerTask;
+import com.gmail.nossr50.skills.acrobatics.AcrobaticsManager;
 import com.gmail.nossr50.skills.archery.Archery;
 import com.gmail.nossr50.skills.fishing.Fishing;
 import com.gmail.nossr50.skills.herbalism.Herbalism;
@@ -74,7 +76,7 @@ public class EntityListener implements Listener {
         }
 
         projectile.setMetadata(mcMMO.bowForceKey, new FixedMetadataValue(plugin, Math.min(event.getForce() * AdvancedConfig.getInstance().getForceMultiplier(), 1.0)));
-        projectile.setMetadata(mcMMO.arrowDistanceKey, new FixedMetadataValue(plugin, projectile.getLocation()));
+        projectile.setMetadata(mcMMO.arrowDistanceKey, new FixedMetadataValue(plugin, Archery.locationToString(projectile.getLocation())));
     }
 
     @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
@@ -86,7 +88,7 @@ public class EntityListener implements Listener {
         }
 
         projectile.setMetadata(mcMMO.bowForceKey, new FixedMetadataValue(plugin, 1.0));
-        projectile.setMetadata(mcMMO.arrowDistanceKey, new FixedMetadataValue(plugin, projectile.getLocation()));
+        projectile.setMetadata(mcMMO.arrowDistanceKey, new FixedMetadataValue(plugin, Archery.locationToString(projectile.getLocation())));
     }
 
     /**
@@ -235,8 +237,16 @@ public class EntityListener implements Listener {
                         return;
                     }
 
-                    event.setDamage(mcMMOPlayer.getAcrobaticsManager().roll(event.getDamage()));
-                    event.setCancelled(event.getDamage() == 0);
+                    AcrobaticsManager acrobaticsManager = mcMMOPlayer.getAcrobaticsManager();
+
+                    if (acrobaticsManager.canRoll()) {
+                        event.setDamage(acrobaticsManager.rollCheck(event.getDamage()));
+
+                        if (event.getDamage() == 0) {
+                            event.setCancelled(true);
+                            return;
+                        }
+                    }
                     break;
 
                 case BLOCK_EXPLOSION:
@@ -506,7 +516,7 @@ public class EntityListener implements Listener {
             case GOLDEN_CARROT: /* RESTORES 3 HUNGER - RESTORES 5 1/2 HUNGER @ 1000 */
             case MUSHROOM_SOUP: /* RESTORES 4 HUNGER - RESTORES 6 1/2 HUNGER @ 1000 */
             case PUMPKIN_PIE:   /* RESTORES 4 HUNGER - RESTORES 6 1/2 HUNGER @ 1000 */
-                if (Permissions.farmersDiet(player)) {
+                if (Permissions.secondaryAbilityEnabled(player, SecondaryAbility.FARMERS_DIET)) {
                     event.setFoodLevel(UserManager.getPlayer(player).getHerbalismManager().farmersDiet(Herbalism.farmersDietRankLevel1, newFoodLevel));
                 }
                 return;
@@ -515,20 +525,20 @@ public class EntityListener implements Listener {
             case MELON:            /* RESTORES 1 HUNGER - RESTORES 2 1/2 HUNGER @ 1000 */
             case POISONOUS_POTATO: /* RESTORES 1 HUNGER - RESTORES 2 1/2 HUNGER @ 1000 */
             case POTATO_ITEM:      /* RESTORES 1/2 HUNGER - RESTORES 2 HUNGER @ 1000 */
-                if (Permissions.farmersDiet(player)) {
+                if (Permissions.secondaryAbilityEnabled(player, SecondaryAbility.FARMERS_DIET)) {
                     event.setFoodLevel(UserManager.getPlayer(player).getHerbalismManager().farmersDiet(Herbalism.farmersDietRankLevel2, newFoodLevel));
                 }
                 return;
 
             case COOKED_FISH: /* RESTORES 2 1/2 HUNGER - RESTORES 5 HUNGER @ 1000 */
-                if (Permissions.fishermansDiet(player)) {
-                    event.setFoodLevel(UserManager.getPlayer(player).getFishingManager().fishermansDiet(Fishing.fishermansDietRankLevel1, newFoodLevel));
+                if (Permissions.secondaryAbilityEnabled(player, SecondaryAbility.FISHERMANS_DIET)) {
+                    event.setFoodLevel(UserManager.getPlayer(player).getFishingManager().handleFishermanDiet(Fishing.fishermansDietRankLevel1, newFoodLevel));
                 }
                 return;
 
             case RAW_FISH:    /* RESTORES 1 HUNGER - RESTORES 2 1/2 HUNGER @ 1000 */
-                if (Permissions.fishermansDiet(player)) {
-                    event.setFoodLevel(UserManager.getPlayer(player).getFishingManager().fishermansDiet(Fishing.fishermansDietRankLevel2, newFoodLevel));
+                if (Permissions.secondaryAbilityEnabled(player, SecondaryAbility.FISHERMANS_DIET)) {
+                    event.setFoodLevel(UserManager.getPlayer(player).getFishingManager().handleFishermanDiet(Fishing.fishermansDietRankLevel2, newFoodLevel));
                 }
                 return;
 

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

@@ -14,9 +14,9 @@ import org.bukkit.event.inventory.InventoryClickEvent;
 import org.bukkit.event.inventory.InventoryCloseEvent;
 import org.bukkit.event.inventory.InventoryOpenEvent;
 import org.bukkit.inventory.ItemStack;
-import org.bukkit.metadata.FixedMetadataValue;
 
 import com.gmail.nossr50.mcMMO;
+import com.gmail.nossr50.datatypes.skills.SecondaryAbility;
 import com.gmail.nossr50.datatypes.skills.SkillType;
 import com.gmail.nossr50.runnables.PlayerUpdateInventoryTask;
 import com.gmail.nossr50.util.ItemUtils;
@@ -43,7 +43,7 @@ public class InventoryListener implements Listener {
         Block furnaceBlock = Misc.processInventoryOpenorCloseEvent(event);
 
         if (furnaceBlock != null && !furnaceBlock.hasMetadata(mcMMO.furnaceMetadataKey)) {
-            furnaceBlock.setMetadata(mcMMO.furnaceMetadataKey, new FixedMetadataValue(plugin, player.getName()));
+            furnaceBlock.setMetadata(mcMMO.furnaceMetadataKey, UserManager.getPlayer((Player) player).getPlayerMetadata());
         }
     }
 
@@ -73,7 +73,7 @@ public class InventoryListener implements Listener {
 
         Player player = Misc.getPlayerFromFurnace(furnaceBlock);
 
-        if (Misc.isNPCEntity(player) || !Permissions.fuelEfficiency(player)) {
+        if (Misc.isNPCEntity(player) || !Permissions.secondaryAbilityEnabled(player, SecondaryAbility.FUEL_EFFICIENCY)) {
             return;
         }
 

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

@@ -7,6 +7,7 @@ import org.bukkit.block.Block;
 import org.bukkit.block.BlockState;
 import org.bukkit.entity.Entity;
 import org.bukkit.entity.Item;
+import org.bukkit.entity.LivingEntity;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
@@ -35,6 +36,7 @@ import com.gmail.nossr50.datatypes.chat.ChatMode;
 import com.gmail.nossr50.datatypes.party.Party;
 import com.gmail.nossr50.datatypes.player.McMMOPlayer;
 import com.gmail.nossr50.datatypes.skills.AbilityType;
+import com.gmail.nossr50.datatypes.skills.SecondaryAbility;
 import com.gmail.nossr50.datatypes.skills.SkillType;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.party.ShareHandler;
@@ -211,15 +213,24 @@ public class PlayerListener implements Listener {
 
         switch (event.getState()) {
             case FISHING:
-                event.setCancelled(fishingManager.exploitPrevention());
+                if (!Permissions.krakenBypass(player)) {
+                    event.setCancelled(fishingManager.exploitPrevention());
+                }
                 return;
 
             case CAUGHT_FISH:
-                event.setExpToDrop(fishingManager.vanillaXpBoost(event.getExpToDrop()));
+                if (Permissions.vanillaXpBoost(player, SkillType.FISHING)) {
+                    event.setExpToDrop(fishingManager.handleVanillaXpBoost(event.getExpToDrop()));
+                }
                 return;
 
             case IN_GROUND:
-                event.setCancelled(fishingManager.iceFishing(event.getHook(), player.getTargetBlock(null, 100)));
+                Block block = player.getTargetBlock(null, 100);
+
+                if (fishingManager.canIceFish(block)) {
+                    event.setCancelled(true);
+                    fishingManager.iceFishing(event.getHook(), block);
+                }
                 return;
 
             default:
@@ -248,7 +259,9 @@ public class PlayerListener implements Listener {
 
         switch (event.getState()) {
             case FISHING:
-                fishingManager.masterAngler(event.getHook());
+                if (fishingManager.canMasterAngler()) {
+                    fishingManager.masterAngler(event.getHook());
+                }
                 return;
 
             case CAUGHT_FISH:
@@ -256,7 +269,9 @@ public class PlayerListener implements Listener {
                 return;
 
             case CAUGHT_ENTITY:
-                fishingManager.shake(event.getHook(), caught);
+                if (fishingManager.canShake(caught)) {
+                    fishingManager.shakeCheck((LivingEntity) caught);
+                }
                 return;
 
             default:
@@ -285,6 +300,14 @@ public class PlayerListener implements Listener {
         Item drop = event.getItem();
         ItemStack dropStack = drop.getItemStack();
 
+        if (drop.hasMetadata(mcMMO.disarmedItemKey)) {
+            if (!player.getName().equals(drop.getMetadata(mcMMO.disarmedItemKey).get(0).value())) {
+                event.setCancelled(true);
+            }
+
+            return;
+        }
+
         if (!drop.hasMetadata(mcMMO.droppedItemKey) && mcMMOPlayer.inParty() && ItemUtils.isSharable(dropStack)) {
             event.setCancelled(ShareHandler.handleItemShare(drop, mcMMOPlayer));
 
@@ -418,13 +441,14 @@ public class PlayerListener implements Listener {
                         }
                     }
                     /* SALVAGE CHECKS */
-                    else if (type == Repair.salvageAnvilMaterial && Permissions.salvage(player) && Repair.isSalvageable(heldItem)) {
+                    else if (type == Repair.salvageAnvilMaterial && Permissions.secondaryAbilityEnabled(player, SecondaryAbility.SALVAGE) && Repair.isSalvageable(heldItem)) {
                         RepairManager repairManager = mcMMOPlayer.getRepairManager();
                         event.setCancelled(true);
 
                         // Make sure the player knows what he's doing when trying to salvage an enchanted item
                         if (!(heldItem.getEnchantments().size() > 0) || repairManager.checkConfirmation(type, true)) {
                             repairManager.handleSalvage(block.getLocation(), heldItem);
+                            player.updateInventory();
                         }
                     }
                 }
@@ -455,7 +479,7 @@ public class PlayerListener implements Listener {
                         }
                     }
                     /* SALVAGE CHECKS */
-                    else if (type == Repair.salvageAnvilMaterial && Permissions.salvage(player) && Repair.isSalvageable(heldItem)) {
+                    else if (type == Repair.salvageAnvilMaterial && Permissions.secondaryAbilityEnabled(player, SecondaryAbility.SALVAGE) && Repair.isSalvageable(heldItem)) {
                         RepairManager repairManager = mcMMOPlayer.getRepairManager();
 
                         // Cancel salvaging an enchanted item
@@ -515,8 +539,12 @@ public class PlayerListener implements Listener {
                 /* GREEN THUMB CHECK */
                 HerbalismManager herbalismManager = mcMMOPlayer.getHerbalismManager();
 
-                if (herbalismManager.greenThumbBlocks(blockState) && EventUtils.simulateBlockBreak(block, player, false)) {
-                    blockState.update(true);
+                if (herbalismManager.canGreenThumbBlock(blockState)) {
+                    player.setItemInHand(new ItemStack(Material.SEEDS, heldItem.getAmount() - 1));
+
+                    if (herbalismManager.processGreenThumbBlocks(blockState) && EventUtils.simulateBlockBreak(block, player, false)) {
+                        blockState.update(true);
+                    }
                 }
 
                 /* SHROOM THUMB CHECK */

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

@@ -6,9 +6,9 @@ import org.bukkit.event.Listener;
 import org.bukkit.event.player.PlayerJoinEvent;
 import org.bukkit.event.player.PlayerQuitEvent;
 
-import com.gmail.nossr50.events.abilities.McMMOPlayerAbilityActivateEvent;
-import com.gmail.nossr50.events.experience.levels.McMMOPlayerLevelUpEvent;
-import com.gmail.nossr50.events.experience.xp.McMMOPlayerXpGainEvent;
+import com.gmail.nossr50.events.experience.McMMOPlayerLevelUpEvent;
+import com.gmail.nossr50.events.experience.McMMOPlayerXpGainEvent;
+import com.gmail.nossr50.events.skills.abilities.McMMOPlayerAbilityActivateEvent;
 import com.gmail.nossr50.util.scoreboards.ScoreboardManager;
 
 public class ScoreboardsListener implements Listener {

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

@@ -5,7 +5,7 @@ import org.bukkit.event.EventPriority;
 import org.bukkit.event.Listener;
 
 import com.gmail.nossr50.config.Config;
-import com.gmail.nossr50.events.experience.levels.McMMOPlayerLevelUpEvent;
+import com.gmail.nossr50.events.experience.McMMOPlayerLevelUpEvent;
 
 public class SelfListener implements Listener {
     @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)

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

@@ -105,6 +105,7 @@ public class mcMMO extends JavaPlugin {
     public final static String bowForceKey         = "mcMMO: Bow Force";
     public final static String arrowDistanceKey    = "mcMMO: Arrow Distance";
     public final static String customDamageKey     = "mcMMO: Custom Damage";
+    public final static String disarmedItemKey     = "mcMMO: Disarmed Item";
 
     public static FixedMetadataValue metadataValue;
 

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

@@ -15,7 +15,7 @@ public class SaveTimerTask extends BukkitRunnable {
         int count = 1;
 
         for (McMMOPlayer mcMMOPlayer : UserManager.getPlayers()) {
-            new PlayerProfileSaveTask(mcMMOPlayer.getProfile()).runTaskLater(mcMMO.p, count);
+            new PlayerProfileSaveTask(mcMMOPlayer.getProfile()).runTaskLaterAsynchronously(mcMMO.p, count);
             count++;
         }
 

src/main/java/com/gmail/nossr50/runnables/backups/CleanBackupsTask.java

@@ -6,13 +6,14 @@ import java.text.SimpleDateFormat;
 import java.util.ArrayList;
 import java.util.Calendar;
 import java.util.Date;
+import java.util.HashMap;
 import java.util.List;
 import java.util.concurrent.TimeUnit;
 
 import org.bukkit.scheduler.BukkitRunnable;
 
-import com.gmail.nossr50.config.Config;
 import com.gmail.nossr50.mcMMO;
+import com.gmail.nossr50.config.Config;
 
 public class CleanBackupsTask extends BukkitRunnable {
     private static final String BACKUP_DIRECTORY = mcMMO.getMainDirectory() + "backup" + File.separator;
@@ -21,7 +22,7 @@ public class CleanBackupsTask extends BukkitRunnable {
     @Override
     public void run() {
         List<Integer> savedDays = new ArrayList<Integer>();
-        List<Integer> savedWeeks = new ArrayList<Integer>();
+        HashMap<Integer, List<Integer>> savedYearsWeeks = new HashMap<Integer, List<Integer>>();
         List<File> toDelete = new ArrayList<File>();
         int amountTotal = 0;
         int amountDeleted = 0;
@@ -51,20 +52,29 @@ public class CleanBackupsTask extends BukkitRunnable {
             cal.setTime(date);
             int dayOfWeek = cal.get(Calendar.DAY_OF_WEEK);
             int weekOfYear = cal.get(Calendar.WEEK_OF_YEAR);
+            int year = cal.get(Calendar.YEAR);
 
             if (isPast24Hours(date) && Config.getInstance().getKeepLast24Hours()) {
                 // Keep all files from the last 24 hours
                 continue;
             }
-            else if (isLastWeek(date) && !savedDays.contains(dayOfWeek)  && Config.getInstance().getKeepDailyLastWeek()) {
+            else if (isLastWeek(date) && !savedDays.contains(dayOfWeek) && Config.getInstance().getKeepDailyLastWeek()) {
                 // Keep daily backups of the past week
                 savedDays.add(dayOfWeek);
                 continue;
             }
-            else if (!savedWeeks.contains(weekOfYear) && Config.getInstance().getKeepWeeklyPastMonth()) {
-                // Keep one backup of each week
-                savedWeeks.add(weekOfYear);
-                continue;
+            else {
+                List<Integer> savedWeeks = savedYearsWeeks.get(year);
+                if (savedWeeks == null) {
+                    savedWeeks = new ArrayList<Integer>();
+                    savedYearsWeeks.put(year, savedWeeks);
+                }
+
+                if (!savedWeeks.contains(weekOfYear) && Config.getInstance().getKeepWeeklyPastMonth()) {
+                    // Keep one backup of each week
+                    savedWeeks.add(weekOfYear);
+                    continue;
+                }
             }
 
             amountDeleted++;

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

@@ -1,11 +1,14 @@
 package com.gmail.nossr50.runnables.database;
 
 import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
 import org.bukkit.scheduler.BukkitRunnable;
 
 import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.database.DatabaseManager;
+import com.gmail.nossr50.datatypes.player.PlayerProfile;
 import com.gmail.nossr50.locale.LocaleLoader;
+import com.gmail.nossr50.util.player.UserManager;
 
 public class DatabaseConversionTask extends BukkitRunnable {
     private final DatabaseManager sourceDatabase;
@@ -20,12 +23,24 @@ public class DatabaseConversionTask extends BukkitRunnable {
 
     @Override
     public void run() {
-        sourceDatabase.convertUsers(mcMMO.getDatabaseManager());
+        try {
+            sourceDatabase.setLoadingDisabled(true);
+            sourceDatabase.convertUsers(mcMMO.getDatabaseManager());
+        }
+        finally {
+            sourceDatabase.setLoadingDisabled(false);
+        }
 
         mcMMO.p.getServer().getScheduler().runTask(mcMMO.p, new Runnable() {
             @Override
             public void run() {
                 sender.sendMessage(message);
+
+                // Reload all users from the new database
+                UserManager.clearAll();
+                for (Player player : mcMMO.p.getServer().getOnlinePlayers()) {
+                    UserManager.addUser(player);
+                }
             }
         });
    }

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

@@ -9,6 +9,7 @@ import com.gmail.nossr50.datatypes.player.McMMOPlayer;
 import com.gmail.nossr50.datatypes.skills.AbilityType;
 import com.gmail.nossr50.util.EventUtils;
 import com.gmail.nossr50.util.Misc;
+import com.gmail.nossr50.util.skills.ParticleEffectUtils;
 import com.gmail.nossr50.util.skills.PerksUtils;
 import com.gmail.nossr50.util.skills.SkillUtils;
 
@@ -45,11 +46,18 @@ public class AbilityDisableTask extends BukkitRunnable {
                 break;
         }
 
-        EventUtils.handleAbilityDeactivateEvent(player, ability);
+        EventUtils.callAbilityDeactivateEvent(player, ability);
 
         mcMMOPlayer.setAbilityMode(ability, false);
         mcMMOPlayer.setAbilityInformed(ability, false);
 
+        ParticleEffectUtils.playAbilityDisabledEffect(player);
+
+        if (mcMMOPlayer.useChatNotifications()) {
+            player.sendMessage(ability.getAbilityOff());
+        }
+
+        SkillUtils.sendSkillMessage(player, ability.getAbilityPlayerOff(player));
         new AbilityCooldownTask(mcMMOPlayer, ability).runTaskLaterAsynchronously(mcMMO.p, PerksUtils.handleCooldownPerks(player, ability.getCooldown()) * Misc.TICK_CONVERSION_FACTOR);
     }
 }

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

@@ -29,10 +29,6 @@ public abstract class SkillManager {
         return mcMMOPlayer.getSkillLevel(skill);
     }
 
-    public int getActivationChance() {
-        return activationChance;
-    }
-
     public void applyXpGain(float xp) {
         mcMMOPlayer.beginXpGain(skill, xp);
     }

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

@@ -5,17 +5,9 @@ import com.gmail.nossr50.config.Config;
 import com.gmail.nossr50.config.experience.ExperienceConfig;
 
 public final class Acrobatics {
-    public static int    dodgeMaxBonusLevel  = AdvancedConfig.getInstance().getDodgeMaxBonusLevel();
-    public static double dodgeDamageModifier = AdvancedConfig.getInstance().getDodgeDamageModifier();
-    public static double dodgeMaxChance      = AdvancedConfig.getInstance().getDodgeChanceMax();
-
-    public static int    rollMaxBonusLevel = AdvancedConfig.getInstance().getRollMaxBonusLevel();
-    public static double rollThreshold     = AdvancedConfig.getInstance().getRollDamageThreshold();
-    public static double rollMaxChance     = AdvancedConfig.getInstance().getRollChanceMax();
-
-    public static int    gracefulRollMaxBonusLevel = AdvancedConfig.getInstance().getGracefulRollMaxBonusLevel();
-    public static double gracefulRollThreshold     = AdvancedConfig.getInstance().getGracefulRollDamageThreshold();
-    public static double gracefulRollMaxChance     = AdvancedConfig.getInstance().getGracefulRollChanceMax();
+    public static double rollThreshold         = AdvancedConfig.getInstance().getRollDamageThreshold();
+    public static double gracefulRollThreshold = AdvancedConfig.getInstance().getGracefulRollDamageThreshold();
+    public static double dodgeDamageModifier   = AdvancedConfig.getInstance().getDodgeDamageModifier();
 
     public static int dodgeXpModifier = ExperienceConfig.getInstance().getDodgeXPModifier();
     public static int rollXpModifier  = ExperienceConfig.getInstance().getRollXPModifier();
@@ -27,11 +19,11 @@ public final class Acrobatics {
 
     private Acrobatics() {};
 
-    protected static double calculateModifiedDodgeDamage(double damage) {
-        return Math.max(damage / dodgeDamageModifier, 1.0);
+    protected static double calculateModifiedDodgeDamage(double damage, double damageModifier) {
+        return Math.max(damage / damageModifier, 1.0);
     }
 
-    protected static double calculateModifiedRollDamage(double damage, boolean isGraceful) {
-        return Math.max(damage - (isGraceful ? gracefulRollThreshold : rollThreshold), 0.0);
+    protected static double calculateModifiedRollDamage(double damage, double damageThreshold) {
+        return Math.max(damage - damageThreshold, 0.0);
     }
 }

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

@@ -8,12 +8,10 @@ import org.bukkit.entity.LightningStrike;
 import org.bukkit.entity.Player;
 import org.bukkit.inventory.ItemStack;
 
-import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.config.Config;
 import com.gmail.nossr50.datatypes.player.McMMOPlayer;
+import com.gmail.nossr50.datatypes.skills.SecondaryAbility;
 import com.gmail.nossr50.datatypes.skills.SkillType;
-import com.gmail.nossr50.events.skills.acrobatics.McMMOPlayerDodgeEvent;
-import com.gmail.nossr50.events.skills.acrobatics.McMMOPlayerRollEvent;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.skills.SkillManager;
 import com.gmail.nossr50.util.Misc;
@@ -30,11 +28,47 @@ public class AcrobaticsManager extends SkillManager {
     }
 
     public boolean canRoll() {
-        return !exploitPrevention() && Permissions.roll(getPlayer());
+        return !exploitPrevention() && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.ROLL);
     }
 
-    private boolean canDodge(Entity damager, double modifiedDamage) {
-        return (Permissions.dodge(getPlayer()) && !(damager instanceof LightningStrike && Acrobatics.dodgeLightningDisabled) && skill.shouldProcess(damager) && SkillUtils.activationSuccessful(getSkillLevel(), getActivationChance(), Acrobatics.dodgeMaxChance, Acrobatics.dodgeMaxBonusLevel) && !isFatal(modifiedDamage));
+    public boolean canDodge(Entity damager) {
+        if (Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.DODGE)) {
+            if (damager instanceof LightningStrike && Acrobatics.dodgeLightningDisabled) {
+                return false;
+            }
+
+            return skill.shouldProcess(damager);
+        }
+
+        return false;
+    }
+
+    /**
+     * Handle the damage reduction and XP gain from the Dodge ability
+     *
+     * @param damage The amount of damage initially dealt by the event
+     * @return the modified event damage if the ability was successful, the original event damage otherwise
+     */
+    public double dodgeCheck(double damage) {
+        double modifiedDamage = Acrobatics.calculateModifiedDodgeDamage(damage, Acrobatics.dodgeDamageModifier);
+        Player player = getPlayer();
+
+        if (!isFatal(modifiedDamage) && SkillUtils.activationSuccessful(SecondaryAbility.DODGE, player, getSkillLevel(), activationChance)) {
+            ParticleEffectUtils.playDodgeEffect(player);
+
+            if (mcMMOPlayer.useChatNotifications()) {
+                player.sendMessage(LocaleLoader.getString("Acrobatics.Combat.Proc"));
+            }
+
+            // Why do we check respawn cooldown here?
+            if (SkillUtils.cooldownExpired(mcMMOPlayer.getRespawnATS(), Misc.PLAYER_RESPAWN_COOLDOWN_SECONDS)) {
+                applyXpGain((float) (damage * Acrobatics.dodgeXpModifier));
+            }
+
+            return modifiedDamage;
+        }
+
+        return damage;
     }
 
     /**
@@ -43,28 +77,47 @@ public class AcrobaticsManager extends SkillManager {
      * @param damage The amount of damage initially dealt by the event
      * @return the modified event damage if the ability was successful, the original event damage otherwise
      */
-    public double roll(double damage) {
-        if (!canRoll()) {
-            return damage;
+    public double rollCheck(double damage) {
+        Player player = getPlayer();
+
+        if (player.isSneaking() && Permissions.secondaryAbilityEnabled(player, SecondaryAbility.GRACEFUL_ROLL)) {
+            return gracefulRollCheck(damage);
         }
 
-        Player player = getPlayer();
-        boolean isGraceful = player.isSneaking() && Permissions.gracefulRoll(player);
-        double modifiedDamage = Acrobatics.calculateModifiedRollDamage(damage, isGraceful);
+        double modifiedDamage = Acrobatics.calculateModifiedRollDamage(damage, Acrobatics.rollThreshold);
 
-        if (!isFatal(modifiedDamage) && isSuccessfulRoll(isGraceful)) {
-            McMMOPlayerRollEvent event = new McMMOPlayerRollEvent(player, modifiedDamage, calculateRollXP(damage, true), isGraceful);
-            mcMMO.p.getServer().getPluginManager().callEvent(event);
+        if (!isFatal(modifiedDamage) && SkillUtils.activationSuccessful(SecondaryAbility.ROLL, player, getSkillLevel(), activationChance)) {
+            player.sendMessage(LocaleLoader.getString("Acrobatics.Roll.Text"));
+            applyXpGain(calculateRollXP(damage, true));
 
-            if (event.isCancelled()) {
-                return damage;
-            }
-
-            return event.getDamageTaken();
+            return modifiedDamage;
+        }
+        else if (!isFatal(damage)) {
+            applyXpGain(calculateRollXP(damage, false));
+        }
+
+        lastFallLocation = player.getLocation();
+
+        return damage;
+    }
+
+    /**
+     * Handle the damage reduction and XP gain from the Graceful Roll ability
+     *
+     * @param damage The amount of damage initially dealt by the event
+     * @return the modified event damage if the ability was successful, the original event damage otherwise
+     */
+    private double gracefulRollCheck(double damage) {
+        double modifiedDamage = Acrobatics.calculateModifiedRollDamage(damage, Acrobatics.gracefulRollThreshold);
+
+        if (!isFatal(modifiedDamage) && SkillUtils.activationSuccessful(SecondaryAbility.GRACEFUL_ROLL, getPlayer(), getSkillLevel(), activationChance)) {
+            getPlayer().sendMessage(LocaleLoader.getString("Acrobatics.Ability.Proc"));
+            applyXpGain(calculateRollXP(damage, true));
+
+            return modifiedDamage;
         }
         else if (!isFatal(damage)) {
             applyXpGain(calculateRollXP(damage, false));
-            lastFallLocation = player.getLocation();
         }
 
         return damage;
@@ -97,47 +150,8 @@ public class AcrobaticsManager extends SkillManager {
         return fallTries > Config.getInstance().getAcrobaticsAFKMaxTries();
     }
 
-    /**
-     * Handle the damage reduction and XP gain from the Dodge ability
-     *
-     * @param damager The entity that dealt the damage
-     * @param damage The amount of damage initially dealt by the event
-     * @return the modified event damage if the ability was successful, the original event damage otherwise
-     */
-    public double dodge(Entity damager, double damage) {
-        double modifiedDamage = Acrobatics.calculateModifiedDodgeDamage(damage);
-
-        if (!canDodge(damager, modifiedDamage)) {
-            return damage;
-        }
-
-        Player player = getPlayer();
-
-        McMMOPlayerDodgeEvent event = new McMMOPlayerDodgeEvent(player, modifiedDamage, (float) (damage * Acrobatics.dodgeXpModifier));
-        mcMMO.p.getServer().getPluginManager().callEvent(event);
-
-        if (event.isCancelled()) {
-            return damage;
-        }
-
-        ParticleEffectUtils.playDodgeEffect(player);
-
-        if (mcMMOPlayer.useChatNotifications()) {
-            player.sendMessage(LocaleLoader.getString("Acrobatics.Combat.Proc"));
-        }
-
-        if (SkillUtils.cooldownExpired(mcMMOPlayer.getRespawnATS(), Misc.PLAYER_RESPAWN_COOLDOWN_SECONDS)) {
-            applyXpGain(event.getXpGained());
-        }
-
-        return event.getDamageTaken();
-    }
-
-    private boolean isSuccessfulRoll(boolean isGraceful) {
-        double maxChance = isGraceful ? Acrobatics.gracefulRollMaxChance : Acrobatics.rollMaxChance;
-        int maxLevel = isGraceful ? Acrobatics.gracefulRollMaxBonusLevel : Acrobatics.rollMaxBonusLevel;
-
-        return (maxChance / maxLevel) * Math.min(getSkillLevel(), maxLevel) > Misc.getRandom().nextInt(activationChance);
+    private boolean isFatal(double damage) {
+        return getPlayer().getHealth() - damage <= 0;
     }
 
     private float calculateRollXP(double damage, boolean isRoll) {
@@ -150,8 +164,4 @@ public class AcrobaticsManager extends SkillManager {
 
         return xp;
     }
-
-    private boolean isFatal(double damage) {
-        return getPlayer().getHealth() - damage < 1;
-    }
 }

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

@@ -1,39 +1,36 @@
 package com.gmail.nossr50.skills.archery;
 
-import java.util.HashMap;
-import java.util.Map;
-import java.util.UUID;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
 
+import org.bukkit.Location;
 import org.bukkit.Material;
 import org.bukkit.entity.LivingEntity;
 import org.bukkit.inventory.ItemStack;
 
+import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.config.AdvancedConfig;
 import com.gmail.nossr50.util.Misc;
 
 public class Archery {
-    private static Map<UUID, TrackedEntity> trackedEntities = new HashMap<UUID, TrackedEntity>();
-
-    public static int    retrieveMaxBonusLevel = AdvancedConfig.getInstance().getRetrieveMaxBonusLevel();
-    public static double retrieveMaxChance     = AdvancedConfig.getInstance().getRetrieveChanceMax();
+    private static List<TrackedEntity> trackedEntities = new ArrayList<TrackedEntity>();
 
     public static int    skillShotIncreaseLevel      = AdvancedConfig.getInstance().getSkillShotIncreaseLevel();
     public static double skillShotIncreasePercentage = AdvancedConfig.getInstance().getSkillShotIncreasePercentage();
     public static double skillShotMaxBonusPercentage = AdvancedConfig.getInstance().getSkillShotBonusMax();
     public static double skillShotMaxBonusDamage     = AdvancedConfig.getInstance().getSkillShotDamageMax();
 
-    public static int    dazeMaxBonusLevel = AdvancedConfig.getInstance().getDazeMaxBonusLevel();
     public static double dazeModifier      = AdvancedConfig.getInstance().getDazeModifier();
-    public static double dazeMaxBonus      = AdvancedConfig.getInstance().getDazeBonusMax();
 
     public static final double DISTANCE_XP_MULTIPLIER = 0.025;
 
     protected static void incrementTrackerValue(LivingEntity livingEntity) {
-        TrackedEntity trackedEntity = trackedEntities.get(livingEntity.getUniqueId());
-
-        if (trackedEntity != null) {
-            trackedEntity.incrementArrowCount();
-            return;
+        for (TrackedEntity trackedEntity : trackedEntities) {
+            if (trackedEntity.getLivingEntity().getEntityId() == livingEntity.getEntityId()) {
+                trackedEntity.incrementArrowCount();
+                return;
+            }
         }
 
         addToTracker(livingEntity); // If the entity isn't tracked yet
@@ -43,11 +40,11 @@ public class Archery {
         TrackedEntity trackedEntity = new TrackedEntity(livingEntity);
 
         trackedEntity.incrementArrowCount();
-        trackedEntities.put(livingEntity.getUniqueId(), trackedEntity);
+        trackedEntities.add(trackedEntity);
     }
 
-    protected static void removeFromTracker(UUID id) {
-        trackedEntities.remove(id);
+    protected static void removeFromTracker(TrackedEntity trackedEntity) {
+        trackedEntities.remove(trackedEntity);
     }
 
     /**
@@ -56,14 +53,24 @@ public class Archery {
      * @param livingEntity The entity hit by the arrows
      */
     public static void arrowRetrievalCheck(LivingEntity livingEntity) {
-        UUID id = livingEntity.getUniqueId();
-        TrackedEntity trackedEntity = trackedEntities.get(id);
+        for (Iterator<TrackedEntity> entityIterator = trackedEntities.iterator(); entityIterator.hasNext();) {
+            TrackedEntity trackedEntity = entityIterator.next();
 
-        if (trackedEntity == null) {
-            return;
+            if (trackedEntity.getID() == livingEntity.getUniqueId()) {
+                Misc.dropItems(livingEntity.getLocation(), new ItemStack(Material.ARROW), trackedEntity.getArrowCount());
+                entityIterator.remove();
+                return;
+            }
         }
+    }
 
-        Misc.dropItems(livingEntity.getLocation(), new ItemStack(Material.ARROW), trackedEntity.getArrowCount());
-        removeFromTracker(id);
+    public static Location stringToLocation(String location) {
+        String[] values = location.split(",");
+
+        return new Location(mcMMO.p.getServer().getWorld(values[0]), Double.parseDouble(values[1]), Double.parseDouble(values[2]), Double.parseDouble(values[3]), Float.parseFloat(values[4]), Float.parseFloat(values[5]));
+    }
+
+    public static String locationToString(Location location) {
+        return location.getWorld().getName() + "," + location.getX() + "," + location.getY() + "," + location.getZ() + "," + location.getYaw() + "," + location.getPitch();
     }
 }

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

@@ -5,19 +5,20 @@ import org.bukkit.entity.Arrow;
 import org.bukkit.entity.Entity;
 import org.bukkit.entity.LivingEntity;
 import org.bukkit.entity.Player;
+import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
 import org.bukkit.potion.PotionEffect;
 import org.bukkit.potion.PotionEffectType;
 
 import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.datatypes.player.McMMOPlayer;
+import com.gmail.nossr50.datatypes.skills.SecondaryAbility;
 import com.gmail.nossr50.datatypes.skills.SkillType;
-import com.gmail.nossr50.events.skills.archery.McMMOPlayerDazeEvent;
-import com.gmail.nossr50.events.skills.archery.McMMOPlayerSkillShotEvent;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.skills.SkillManager;
 import com.gmail.nossr50.util.Misc;
 import com.gmail.nossr50.util.Permissions;
 import com.gmail.nossr50.util.player.UserManager;
+import com.gmail.nossr50.util.skills.CombatUtils;
 import com.gmail.nossr50.util.skills.SkillUtils;
 
 public class ArcheryManager extends SkillManager {
@@ -25,14 +26,26 @@ public class ArcheryManager extends SkillManager {
         super(mcMMOPlayer, SkillType.ARCHERY);
     }
 
+    public boolean canDaze(LivingEntity target) {
+        return target instanceof Player && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.DAZE);
+    }
+
+    public boolean canSkillShot() {
+        return getSkillLevel() >= Archery.skillShotIncreaseLevel && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.SKILL_SHOT);
+    }
+
+    public boolean canRetrieveArrows() {
+        return Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.RETRIEVE);
+    }
+
     /**
      * Calculate bonus XP awarded for Archery when hitting a far-away target.
      *
      * @param target The {@link LivingEntity} damaged by the arrow
      * @param damager The {@link Entity} who shot the arrow
      */
-    public void awardDistanceXpBonus(LivingEntity target, Entity damager) {
-        Location firedLocation = (Location) damager.getMetadata(mcMMO.arrowDistanceKey).get(0).value();
+    public void distanceXpBonus(LivingEntity target, Entity damager) {
+        Location firedLocation = Archery.stringToLocation(damager.getMetadata(mcMMO.arrowDistanceKey).get(0).asString());
         Location targetLocation = target.getLocation();
 
         if (firedLocation.getWorld() != targetLocation.getWorld()) {
@@ -46,52 +59,39 @@ public class ArcheryManager extends SkillManager {
      * Track arrows fired for later retrieval.
      *
      * @param target The {@link LivingEntity} damaged by the arrow
-     * @param arrow The {@link Arrow} that damaged the target
      */
-    public void trackArrow(LivingEntity target, Arrow arrow) {
-        if (!canTrackArrows(target, arrow)) {
-            return;
+    public void retrieveArrows(LivingEntity target) {
+        if (SkillUtils.activationSuccessful(SecondaryAbility.RETRIEVE, getPlayer(), getSkillLevel(), activationChance)) {
+            Archery.incrementTrackerValue(target);
         }
-
-        Archery.incrementTrackerValue(target);
     }
 
     /**
      * Handle the effects of the Daze ability
      *
-     * @param target The {@link LivingEntity} being affected by the ability
+     * @param defender The {@link Player} being affected by the ability
      * @param arrow The {@link Arrow} that was fired
      */
-    public double daze(LivingEntity target, Arrow arrow) {
-        if (!canDaze(target)) {
+    public double daze(Player defender, Arrow arrow) {
+        if (!SkillUtils.activationSuccessful(SecondaryAbility.DAZE, getPlayer(), getSkillLevel(), activationChance)) {
             return 0;
         }
 
-        Player attacker = getPlayer();
-
-        McMMOPlayerDazeEvent event = new McMMOPlayerDazeEvent(attacker, arrow, target);
-        mcMMO.p.getServer().getPluginManager().callEvent(event);
-
-        if (event.isCancelled()) {
-            return 0;
-        }
-
-        Player defender = (Player) target;
         Location dazedLocation = defender.getLocation();
         dazedLocation.setPitch(90 - Misc.getRandom().nextInt(181));
 
         defender.teleport(dazedLocation);
-        defender.addPotionEffect(new PotionEffect(PotionEffectType.CONFUSION, Misc.TICK_CONVERSION_FACTOR * 10, 10));
+        defender.addPotionEffect(new PotionEffect(PotionEffectType.CONFUSION, 20 * 10, 10));
 
         if (UserManager.getPlayer(defender).useChatNotifications()) {
             defender.sendMessage(LocaleLoader.getString("Combat.TouchedFuzzy"));
         }
 
         if (mcMMOPlayer.useChatNotifications()) {
-            attacker.sendMessage(LocaleLoader.getString("Combat.TargetDazed"));
+            getPlayer().sendMessage(LocaleLoader.getString("Combat.TargetDazed"));
         }
 
-        return event.getDamage();
+        return CombatUtils.callFakeDamageEvent(arrow, defender, DamageCause.PROJECTILE, Archery.dazeModifier);
     }
 
     /**
@@ -102,36 +102,9 @@ public class ArcheryManager extends SkillManager {
      * @param arrow The {@link Arrow} that was fired
      */
     public double skillShot(LivingEntity target, double damage, Arrow arrow) {
-        if (!canUseSkillShot(target)) {
-            return 0;
-        }
-
-        McMMOPlayerSkillShotEvent event = new McMMOPlayerSkillShotEvent(getPlayer(), arrow, target, calculateSkillShotBonus(damage));
-        mcMMO.p.getServer().getPluginManager().callEvent(event);
-
-        if (event.isCancelled()) {
-            return 0;
-        }
-
-        return event.getDamage();
-    }
-
-    private double calculateSkillShotBonus(double damage) {
         double damageBonusPercent = Math.min(((getSkillLevel() / Archery.skillShotIncreaseLevel) * Archery.skillShotIncreasePercentage), Archery.skillShotMaxBonusPercentage);
         double archeryBonus = Math.min(damage * damageBonusPercent, Archery.skillShotMaxBonusDamage);
 
-        return archeryBonus;
-    }
-
-    private boolean canDaze(LivingEntity target) {
-        return target.isValid() && target instanceof Player && Permissions.daze(getPlayer()) && SkillUtils.activationSuccessful(getSkillLevel(), getActivationChance(), Archery.dazeMaxBonus, Archery.dazeMaxBonusLevel);
-    }
-
-    private boolean canUseSkillShot(LivingEntity target) {
-        return target.isValid() && getSkillLevel() >= Archery.skillShotIncreaseLevel && Permissions.bonusDamage(getPlayer(), skill);
-    }
-
-    private boolean canTrackArrows(LivingEntity target, Arrow arrow) {
-        return target.isValid() && Permissions.arrowRetrieval(getPlayer()) && !arrow.hasMetadata(mcMMO.infiniteArrowKey) && SkillUtils.activationSuccessful(getSkillLevel(), getActivationChance(), Archery.retrieveMaxChance, Archery.retrieveMaxBonusLevel);
+        return CombatUtils.callFakeDamageEvent(arrow, target, DamageCause.PROJECTILE, archeryBonus);
     }
 }

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

@@ -22,11 +22,15 @@ public class TrackedEntity extends BukkitRunnable {
     @Override
     public void run() {
         if (!livingEntity.isValid()) {
-            Archery.removeFromTracker(id);
+            Archery.removeFromTracker(this);
             this.cancel();
         }
     }
 
+    protected LivingEntity getLivingEntity() {
+        return livingEntity;
+    }
+
     protected UUID getID() {
         return id;
     }

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

@@ -7,13 +7,11 @@ import com.gmail.nossr50.config.AdvancedConfig;
 import com.gmail.nossr50.util.ItemUtils;
 
 public class Axes {
-    public static double bonusDamageMaxBonus      = AdvancedConfig.getInstance().getBonusDamageAxesBonusMax();
-    public static int    bonusDamageMaxBonusLevel = AdvancedConfig.getInstance().getBonusDamageAxesMaxBonusLevel();
+    public static double axeMasteryMaxBonus      = AdvancedConfig.getInstance().getAxeMasteryBonusMax();
+    public static int    axeMasteryMaxBonusLevel = AdvancedConfig.getInstance().getAxeMasteryMaxBonusLevel();
 
-    public static int    criticalHitMaxBonusLevel = AdvancedConfig.getInstance().getAxesCriticalMaxBonusLevel();
-    public static double criticalHitMaxChance     = AdvancedConfig.getInstance().getAxesCriticalChance();
-    public static double criticalHitPVPModifier   = AdvancedConfig.getInstance().getAxesCriticalPVPModifier();
-    public static double criticalHitPVEModifier   = AdvancedConfig.getInstance().getAxesCriticalPVEModifier();
+    public static double criticalHitPVPModifier   = AdvancedConfig.getInstance().getCriticalHitPVPModifier();
+    public static double criticalHitPVEModifier   = AdvancedConfig.getInstance().getCriticalHitPVEModifier();
 
     public static int    impactIncreaseLevel         = AdvancedConfig.getInstance().getArmorImpactIncreaseLevel();
     public static double impactChance                = AdvancedConfig.getInstance().getImpactChance();

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

@@ -6,11 +6,11 @@ import org.bukkit.inventory.ItemStack;
 
 import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.datatypes.player.McMMOPlayer;
+import com.gmail.nossr50.datatypes.skills.AbilityType;
+import com.gmail.nossr50.datatypes.skills.SecondaryAbility;
 import com.gmail.nossr50.datatypes.skills.SkillType;
-import com.gmail.nossr50.events.skills.axes.McMMOPlayerAxeMasteryEvent;
-import com.gmail.nossr50.events.skills.axes.McMMOPlayerCriticalHitEvent;
-import com.gmail.nossr50.events.skills.axes.McMMOPlayerGreaterImpactEvent;
-import com.gmail.nossr50.events.skills.axes.McMMOPlayerImpactEvent;
+import com.gmail.nossr50.datatypes.skills.ToolType;
+import com.gmail.nossr50.events.skills.secondaryabilities.SecondaryAbilityWeightedActivationCheckEvent;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.skills.SkillManager;
 import com.gmail.nossr50.util.ItemUtils;
@@ -26,24 +26,39 @@ public class AxesManager extends SkillManager {
         super(mcMMOPlayer, SkillType.AXES);
     }
 
+    public boolean canUseAxeMastery() {
+        return Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.AXE_MASTERY);
+    }
+
+    public boolean canCriticalHit(LivingEntity target) {
+        return target.isValid() && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.CRITICAL_HIT);
+    }
+
+    public boolean canImpact(LivingEntity target) {
+        return target.isValid() && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.ARMOR_IMPACT) && Axes.hasArmor(target);
+    }
+
+    public boolean canGreaterImpact(LivingEntity target) {
+        return target.isValid() && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.GREATER_IMPACT) && !Axes.hasArmor(target);
+    }
+
+    public boolean canUseSkullSplitter(LivingEntity target) {
+        return target.isValid() && mcMMOPlayer.getAbilityMode(AbilityType.SKULL_SPLITTER) && Permissions.skullSplitter(getPlayer());
+    }
+
+    public boolean canActivateAbility() {
+        return mcMMOPlayer.getToolPreparationMode(ToolType.AXE) && Permissions.skullSplitter(getPlayer());
+    }
+
     /**
      * Handle the effects of the Axe Mastery ability
      *
      * @param target The {@link LivingEntity} being affected by the ability
      */
     public double axeMastery(LivingEntity target) {
-        if (!canUseAxeMastery(target)) {
-            return 0;
-        }
+        double axeBonus = Math.min(getSkillLevel() / (Axes.axeMasteryMaxBonusLevel / Axes.axeMasteryMaxBonus), Axes.axeMasteryMaxBonus);
 
-        McMMOPlayerAxeMasteryEvent event = new McMMOPlayerAxeMasteryEvent(getPlayer(), target, calculateAxeMasteryBonus());
-        mcMMO.p.getServer().getPluginManager().callEvent(event);
-
-        if (event.isCancelled()) {
-            return 0;
-        }
-
-        return event.getDamage();
+        return CombatUtils.callFakeDamageEvent(getPlayer(), target, axeBonus);
     }
 
     /**
@@ -53,27 +68,24 @@ public class AxesManager extends SkillManager {
      * @param damage The amount of damage initially dealt by the event
      */
     public double criticalHit(LivingEntity target, double damage) {
-        if (!canCriticalHit(target)) {
+        if (!SkillUtils.activationSuccessful(SecondaryAbility.CRITICAL_HIT, getPlayer(), getSkillLevel(), activationChance)) {
             return 0;
         }
 
         Player player = getPlayer();
+
         player.sendMessage(LocaleLoader.getString("Axes.Combat.CriticalHit"));
 
-        boolean targetIsPlayer = target instanceof Player;
-
-        if (targetIsPlayer) {
+        if (target instanceof Player) {
             ((Player) target).sendMessage(LocaleLoader.getString("Axes.Combat.CritStruck"));
+
+            damage = (damage * Axes.criticalHitPVPModifier) - damage;
+        }
+        else {
+            damage = (damage * Axes.criticalHitPVEModifier) - damage;
         }
 
-        McMMOPlayerCriticalHitEvent event = new McMMOPlayerCriticalHitEvent(player, target, calculateCriticalHitBonus(damage, targetIsPlayer));
-        mcMMO.p.getServer().getPluginManager().callEvent(event);
-
-        if (event.isCancelled()) {
-            return 0;
-        }
-
-        return event.getDamage();
+        return CombatUtils.callFakeDamageEvent(player, target, damage);
     }
 
     /**
@@ -81,24 +93,16 @@ public class AxesManager extends SkillManager {
      *
      * @param target The {@link LivingEntity} being affected by Impact
      */
-    public void impact(LivingEntity target) {
-        if (!canImpact(target)) {
-            return;
-        }
-
-        Player player = getPlayer();
+    public void impactCheck(LivingEntity target) {
         int durabilityDamage = 1 + (getSkillLevel() / Axes.impactIncreaseLevel);
-        McMMOPlayerImpactEvent event;
 
         for (ItemStack armor : target.getEquipment().getArmorContents()) {
-            if (ItemUtils.isArmor(armor) && Axes.impactChance > Misc.getRandom().nextInt(getActivationChance())) {
-                SkillUtils.handleDurabilityChange(armor, durabilityDamage, Axes.impactMaxDurabilityModifier);
-
-                event = new McMMOPlayerImpactEvent(player, armor);
+            if (ItemUtils.isArmor(armor)) {
+                double chance = Axes.impactChance / activationChance;
+                SecondaryAbilityWeightedActivationCheckEvent event = new SecondaryAbilityWeightedActivationCheckEvent(getPlayer(), SecondaryAbility.ARMOR_IMPACT, chance);
                 mcMMO.p.getServer().getPluginManager().callEvent(event);
-
-                if (event.isCancelled()) {
-                    continue;
+                if ((event.getChance() * activationChance) > Misc.getRandom().nextInt(activationChance)) {
+                    SkillUtils.handleDurabilityChange(armor, durabilityDamage, Axes.impactMaxDurabilityModifier);
                 }
             }
         }
@@ -110,21 +114,17 @@ public class AxesManager extends SkillManager {
      * @param target The {@link LivingEntity} being affected by the ability
      */
     public double greaterImpact(LivingEntity target) {
-        if (!canUseGreaterImpact(target)) {
+        double chance = Axes.greaterImpactChance / activationChance;
+        SecondaryAbilityWeightedActivationCheckEvent event = new SecondaryAbilityWeightedActivationCheckEvent(getPlayer(), SecondaryAbility.GREATER_IMPACT, chance);
+        mcMMO.p.getServer().getPluginManager().callEvent(event);
+        if ((event.getChance() * activationChance) <= Misc.getRandom().nextInt(activationChance)) {
             return 0;
         }
 
         Player player = getPlayer();
 
-        McMMOPlayerGreaterImpactEvent event = new McMMOPlayerGreaterImpactEvent(player, target, Axes.greaterImpactBonusDamage, player.getLocation().getDirection().normalize().multiply(Axes.greaterImpactKnockbackMultiplier));
-        mcMMO.p.getServer().getPluginManager().callEvent(event);
-
-        if (event.isCancelled()) {
-            return 0;
-        }
-
         ParticleEffectUtils.playGreaterImpactEffect(target);
-        target.setVelocity(event.getKnockbackVelocity());
+        target.setVelocity(player.getLocation().getDirection().normalize().multiply(Axes.greaterImpactKnockbackMultiplier));
 
         if (mcMMOPlayer.useChatNotifications()) {
             player.sendMessage(LocaleLoader.getString("Axes.Combat.GI.Proc"));
@@ -138,7 +138,7 @@ public class AxesManager extends SkillManager {
             }
         }
 
-        return event.getDamage();
+        return CombatUtils.callFakeDamageEvent(player, target, Axes.greaterImpactBonusDamage);
     }
 
     /**
@@ -147,31 +147,7 @@ public class AxesManager extends SkillManager {
      * @param target The {@link LivingEntity} being affected by the ability
      * @param damage The amount of damage initially dealt by the event
      */
-    public void skullSplitter(LivingEntity target, double damage) {
+    public void skullSplitterCheck(LivingEntity target, double damage) {
         CombatUtils.applyAbilityAoE(getPlayer(), target, damage / Axes.skullSplitterModifier, skill);
     }
-
-    private double calculateAxeMasteryBonus() {
-        return Math.min(getSkillLevel() / (Axes.bonusDamageMaxBonusLevel / Axes.bonusDamageMaxBonus), Axes.bonusDamageMaxBonus);
-    }
-
-    private double calculateCriticalHitBonus(double damage, boolean isPlayer) {
-        return (damage * (isPlayer ? Axes.criticalHitPVPModifier : Axes.criticalHitPVEModifier)) - damage;
-    }
-
-    private boolean canUseAxeMastery(LivingEntity target) {
-        return target.isValid() && Permissions.bonusDamage(getPlayer(), skill);
-    }
-
-    private boolean canCriticalHit(LivingEntity target) {
-        return target.isValid() && Permissions.criticalStrikes(getPlayer()) && SkillUtils.activationSuccessful(getSkillLevel(), getActivationChance(), Axes.criticalHitMaxChance, Axes.criticalHitMaxBonusLevel);
-    }
-
-    private boolean canImpact(LivingEntity target) {
-        return target.isValid() && Axes.hasArmor(target) && Permissions.armorImpact(getPlayer());
-    }
-
-    private boolean canUseGreaterImpact(LivingEntity target) {
-        return target.isValid() && !Axes.hasArmor(target) && Permissions.greaterImpact(getPlayer()) && (Axes.greaterImpactChance > Misc.getRandom().nextInt(getActivationChance()));
-    }
 }

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

@@ -3,16 +3,13 @@ package com.gmail.nossr50.skills.excavation;
 import java.util.List;
 
 import org.bukkit.Location;
-import org.bukkit.block.Block;
 import org.bukkit.block.BlockState;
-import org.bukkit.entity.Player;
 
-import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.config.Config;
 import com.gmail.nossr50.datatypes.player.McMMOPlayer;
+import com.gmail.nossr50.datatypes.skills.SecondaryAbility;
 import com.gmail.nossr50.datatypes.skills.SkillType;
 import com.gmail.nossr50.datatypes.treasure.ExcavationTreasure;
-import com.gmail.nossr50.events.skills.excavation.McMMOPlayerExcavationTreasureEvent;
 import com.gmail.nossr50.skills.SkillManager;
 import com.gmail.nossr50.util.Misc;
 import com.gmail.nossr50.util.Permissions;
@@ -28,30 +25,20 @@ public class ExcavationManager extends SkillManager {
      *
      * @param blockState The {@link BlockState} to check ability activation for
      */
-    public void blockBreak(BlockState blockState) {
+    public void excavationBlockCheck(BlockState blockState) {
         int xp = Excavation.getBlockXP(blockState);
 
-        if (Permissions.excavationTreasureHunter(getPlayer())) {
+        if (Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.EXCAVATION_TREASURE_HUNTER)) {
             List<ExcavationTreasure> treasures = Excavation.getTreasures(blockState);
 
             if (!treasures.isEmpty()) {
                 int skillLevel = getSkillLevel();
                 Location location = blockState.getLocation();
 
-                Player player = getPlayer();
-                Block block = blockState.getBlock();
-
                 for (ExcavationTreasure treasure : treasures) {
-                    if (skillLevel >= treasure.getDropLevel() && SkillUtils.treasureDropSuccessful(treasure.getDropChance(), activationChance)) {
-                        McMMOPlayerExcavationTreasureEvent event = new McMMOPlayerExcavationTreasureEvent(player, treasure.getDrop(), treasure.getXp(), block);
-                        mcMMO.p.getServer().getPluginManager().callEvent(event);
-
-                        if (event.isCancelled()) {
-                            continue;
-                        }
-
-                        xp += event.getXpGained();
-                        Misc.dropItem(location, event.getTreasure());
+                    if (skillLevel >= treasure.getDropLevel() && SkillUtils.treasureDropSuccessful(getPlayer(), treasure.getDropChance(), activationChance)) {
+                        xp += treasure.getXp();
+                        Misc.dropItem(location, treasure.getDrop());
                     }
                 }
             }
@@ -66,8 +53,8 @@ public class ExcavationManager extends SkillManager {
      * @param blockState The {@link BlockState} to check ability activation for
      */
     public void gigaDrillBreaker(BlockState blockState) {
-        blockBreak(blockState);
-        blockBreak(blockState);
+        excavationBlockCheck(blockState);
+        excavationBlockCheck(blockState);
 
         SkillUtils.handleDurabilityChange(getPlayer().getItemInHand(), Config.getInstance().getAbilityToolDamage());
     }

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

@@ -41,6 +41,7 @@ import com.gmail.nossr50.config.Config;
 import com.gmail.nossr50.config.experience.ExperienceConfig;
 import com.gmail.nossr50.config.treasure.TreasureConfig;
 import com.gmail.nossr50.datatypes.player.McMMOPlayer;
+import com.gmail.nossr50.datatypes.skills.SecondaryAbility;
 import com.gmail.nossr50.datatypes.skills.SkillType;
 import com.gmail.nossr50.datatypes.treasure.EnchantmentTreasure;
 import com.gmail.nossr50.datatypes.treasure.FishingTreasure;
@@ -48,6 +49,7 @@ import com.gmail.nossr50.datatypes.treasure.Rarity;
 import com.gmail.nossr50.datatypes.treasure.ShakeTreasure;
 import com.gmail.nossr50.events.skills.fishing.McMMOPlayerFishingTreasureEvent;
 import com.gmail.nossr50.events.skills.fishing.McMMOPlayerShakeEvent;
+import com.gmail.nossr50.events.skills.secondaryabilities.SecondaryAbilityWeightedActivationCheckEvent;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.runnables.skills.KrakenAttackTask;
 import com.gmail.nossr50.skills.SkillManager;
@@ -73,6 +75,14 @@ public class FishingManager extends SkillManager {
         super(mcMMOPlayer, SkillType.FISHING);
     }
 
+    public boolean canShake(Entity target) {
+        return target instanceof LivingEntity && getSkillLevel() >= Tier.ONE.getLevel() && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.SHAKE);
+    }
+
+    public boolean canMasterAngler() {
+        return getSkillLevel() >= AdvancedConfig.getInstance().getMasterAnglerUnlockLevel() && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.MASTER_ANGLER);
+    }
+
     public boolean unleashTheKraken() {
         return unleashTheKraken(true);
     }
@@ -153,13 +163,11 @@ public class FishingManager extends SkillManager {
     }
 
     public boolean exploitPrevention() {
-        Player player = getPlayer();
-
-        if (Permissions.krakenBypass(player) || !AdvancedConfig.getInstance().getKrakenEnabled()) {
+        if (!AdvancedConfig.getInstance().getKrakenEnabled()) {
             return false;
         }
 
-        Block targetBlock = player.getTargetBlock(BlockUtils.getTransparentBlocks(), 100);
+        Block targetBlock = getPlayer().getTargetBlock(BlockUtils.getTransparentBlocks(), 100);
 
         if (!targetBlock.isLiquid()) {
             return false;
@@ -180,197 +188,30 @@ public class FishingManager extends SkillManager {
         return unleashTheKraken(false);
     }
 
-    /**
-     * Handle the Fisherman's Diet ability
-     *
-     * @param rankChange     The # of levels to change rank for the food
-     * @param eventFoodLevel The initial change in hunger from the event
-     *
-     * @return the modified change in hunger for the event
-     */
-    public int fishermansDiet(int rankChange, int eventFoodLevel) {
-        return SkillUtils.handleFoodSkills(getPlayer(), skill, eventFoodLevel, Fishing.fishermansDietRankLevel1, Fishing.fishermansDietMaxLevel, rankChange);
-    }
-
-    public boolean iceFishing(Fish hook, Block block) {
-        if (!canIceFish(block)) {
+    public boolean canIceFish(Block block) {
+        if (getSkillLevel() < AdvancedConfig.getInstance().getIceFishingUnlockLevel()) {
             return false;
         }
 
-        // Make a hole
-        block.setType(Material.STATIONARY_WATER);
-
-        for (BlockFace face : BlockFace.values()) {
-            Block relative = block.getRelative(face);
-
-            if (relative.getType() == Material.ICE) {
-                relative.setType(Material.STATIONARY_WATER);
-            }
+        if (block.getType() != Material.ICE) {
+            return false;
         }
 
-        // Recast in the new spot
-        return !EventUtils.callFakeFishEvent(getPlayer(), hook).isCancelled();
-    }
+        // Make sure this is a body of water, not just a block of ice.
+        Biome biome = block.getBiome();
+        boolean isFrozenBiome = (biome == Biome.FROZEN_OCEAN || biome == Biome.FROZEN_RIVER || biome == Biome.TAIGA || biome == Biome.TAIGA_HILLS || biome == Biome.ICE_PLAINS || biome == Biome.ICE_MOUNTAINS);
 
-    public void masterAngler(Fish hook) {
-        if (!canUseMasterAngler()) {
-            return;
+        if (!isFrozenBiome && (block.getRelative(BlockFace.DOWN, 3).getType() != Material.STATIONARY_WATER)) {
+            return false;
         }
 
         Player player = getPlayer();
-        Location location = hook.getLocation();
-        Biome biome = location.getBlock().getBiome();
-        double biteChance = hook.getBiteChance();
 
-        hookLocation = location;
-
-        if (biome == Biome.RIVER || biome == Biome.OCEAN) {
-            biteChance = biteChance * AdvancedConfig.getInstance().getMasterAnglerBiomeModifier();
+        if (!Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.ICE_FISHING)) {
+            return false;
         }
 
-        if (player.isInsideVehicle() && player.getVehicle().getType() == EntityType.BOAT) {
-            biteChance = biteChance * AdvancedConfig.getInstance().getMasterAnglerBoatModifier();
-        }
-
-        hook.setBiteChance(Math.min(biteChance, 1.0));
-    }
-
-    /**
-     * Process the results from a successful fishing trip
-     *
-     * @param fishingCatch The {@link Item} initially caught
-     */
-    public void handleFishing(Item fishingCatch) {
-        this.fishingCatch = fishingCatch;
-        int treasureXp = 0;
-        Player player = getPlayer();
-        FishingTreasure treasure = null;
-
-        if (Config.getInstance().getFishingDropsEnabled() && Permissions.fishingTreasureHunter(player)) {
-            treasure = getFishingTreasure();
-            this.fishingCatch = null;
-        }
-
-        if (treasure != null) {
-            player.sendMessage(LocaleLoader.getString("Fishing.Ability.TH.ItemFound"));
-
-            ItemStack treasureDrop = treasure.getDrop().clone(); // Not cloning is bad, m'kay?
-            Map<Enchantment, Integer> enchants = new HashMap<Enchantment, Integer>();
-
-            if (Permissions.magicHunter(player) && ItemUtils.isEnchantable(treasureDrop)) {
-                enchants = handleMagicHunter(treasureDrop);
-            }
-
-            McMMOPlayerFishingTreasureEvent event = EventUtils.callFishingTreasureEvent(player, treasureDrop, treasure.getXp(), enchants);
-
-            if (!event.isCancelled()) {
-                treasureDrop = event.getTreasure();
-                treasureXp = event.getXpGained();
-            }
-            else {
-                treasureDrop = null;
-                treasureXp = 0;
-            }
-
-            // Drop the original catch at the feet of the player and set the treasure as the real catch
-            if (treasureDrop != null) {
-                boolean enchanted = false;
-
-                if (!enchants.isEmpty()) {
-                    treasureDrop.addUnsafeEnchantments(enchants);
-                    enchanted = true;
-                }
-
-                if (enchanted) {
-                    player.sendMessage(LocaleLoader.getString("Fishing.Ability.TH.MagicFound"));
-                }
-
-                fishingCatch.setItemStack(treasureDrop);
-            }
-        }
-
-        applyXpGain(ExperienceConfig.getInstance().getFishingBaseXP() + treasureXp);
-    }
-
-    /**
-     * Handle the vanilla XP boost for Fishing
-     *
-     * @param experience The amount of experience initially awarded by the event
-     *
-     * @return the modified event experience
-     */
-    public int vanillaXpBoost(int experience) {
-        return experience * (Permissions.vanillaXpBoost(getPlayer(), skill) ? getVanillaXpMultiplier() : 1);
-    }
-
-    public Location getHookLocation() {
-        return hookLocation;
-    }
-
-    /**
-     * Handle the Shake ability
-     *
-     * @param entity The {@link Entity} affected by the ability
-     */
-    public void shake(Fish hook, Entity entity) {
-        if (!canShake(entity)) {
-            return;
-        }
-
-        fishingTries--; // Because autoclicking to shake is OK.
-
-        LivingEntity target = (LivingEntity) entity;
-        List<ShakeTreasure> possibleDrops = Fishing.findPossibleDrops(target);
-
-        if (possibleDrops == null || possibleDrops.isEmpty()) {
-            return;
-        }
-
-        ItemStack drop = Fishing.chooseDrop(possibleDrops);
-
-        // It's possible that chooseDrop returns null if the sum of probability in possibleDrops is inferior than 100
-        if (drop == null) {
-            return;
-        }
-
-        // Extra processing depending on the mob and drop type
-        switch (target.getType()) {
-            case SHEEP:
-                Sheep sheep = (Sheep) target;
-                drop = new Wool(sheep.getColor()).toItemStack(drop.getAmount());
-                sheep.setSheared(true);
-
-            case SKELETON:
-                if (((Skeleton) target).getSkeletonType() == SkeletonType.WITHER) {
-                    switch (drop.getType()) {
-                        case SKULL_ITEM:
-                            drop.setDurability((short) 1);
-                            break;
-
-                        case ARROW:
-                            drop.setType(Material.COAL);
-                            break;
-
-                        default:
-                            break;
-                    }
-                }
-                break;
-
-            default:
-                break;
-        }
-
-        McMMOPlayerShakeEvent event = new McMMOPlayerShakeEvent(getPlayer(), hook, drop, target, Math.max(target.getMaxHealth() / 4, 1)); // TODO: Config option for shake damage
-        mcMMO.p.getServer().getPluginManager().callEvent(event);
-
-        if (event.isCancelled()) {
-            return;
-        }
-
-        Misc.dropItem(target.getLocation(), event.getDrop());
-        CombatUtils.dealDamage(target, event.getDamage());
-        applyXpGain(ExperienceConfig.getInstance().getFishingShakeXP());
+        return EventUtils.simulateBlockBreak(block, player, false);
     }
 
     /**
@@ -407,6 +248,201 @@ public class FishingManager extends SkillManager {
         return 0.0;
     }
 
+    /**
+     * Handle the Fisherman's Diet ability
+     *
+     * @param rankChange     The # of levels to change rank for the food
+     * @param eventFoodLevel The initial change in hunger from the event
+     *
+     * @return the modified change in hunger for the event
+     */
+    public int handleFishermanDiet(int rankChange, int eventFoodLevel) {
+        return SkillUtils.handleFoodSkills(getPlayer(), skill, eventFoodLevel, Fishing.fishermansDietRankLevel1, Fishing.fishermansDietMaxLevel, rankChange);
+    }
+
+    public void iceFishing(Fish hook, Block block) {
+        // Make a hole
+        block.setType(Material.STATIONARY_WATER);
+
+        for (int x = -1; x <= 1; x++) {
+            for (int z = -1; z <= 1; z++) {
+                Block relative = block.getRelative(x, 0, z);
+
+                if (relative.getType() == Material.ICE) {
+                    relative.setType(Material.STATIONARY_WATER);
+                }
+            }
+        }
+
+        // Recast in the new spot
+        EventUtils.callFakeFishEvent(getPlayer(), hook);
+    }
+
+    public void masterAngler(Fish hook) {
+        Player player = getPlayer();
+        Location location = hook.getLocation();
+        Biome biome = location.getBlock().getBiome();
+        double biteChance = hook.getBiteChance();
+
+        hookLocation = location;
+
+        if (biome == Biome.RIVER || biome == Biome.OCEAN) {
+            biteChance = biteChance * AdvancedConfig.getInstance().getMasterAnglerBiomeModifier();
+        }
+
+        if (player.isInsideVehicle() && player.getVehicle().getType() == EntityType.BOAT) {
+            biteChance = biteChance * AdvancedConfig.getInstance().getMasterAnglerBoatModifier();
+        }
+
+        hook.setBiteChance(Math.min(biteChance, 1.0));
+    }
+
+    /**
+     * Process the results from a successful fishing trip
+     *
+     * @param fishingCatch The {@link Item} initially caught
+     */
+    public void handleFishing(Item fishingCatch) {
+        this.fishingCatch = fishingCatch;
+        int treasureXp = 0;
+        Player player = getPlayer();
+        FishingTreasure treasure = null;
+
+        if (Config.getInstance().getFishingDropsEnabled() && Permissions.secondaryAbilityEnabled(player, SecondaryAbility.FISHING_TREASURE_HUNTER)) {
+            treasure = getFishingTreasure();
+            this.fishingCatch = null;
+        }
+
+        if (treasure != null) {
+            player.sendMessage(LocaleLoader.getString("Fishing.Ability.TH.ItemFound"));
+
+            ItemStack treasureDrop = treasure.getDrop().clone(); // Not cloning is bad, m'kay?
+            Map<Enchantment, Integer> enchants = new HashMap<Enchantment, Integer>();
+
+            if (Permissions.secondaryAbilityEnabled(player, SecondaryAbility.MAGIC_HUNTER) && ItemUtils.isEnchantable(treasureDrop)) {
+                enchants = handleMagicHunter(treasureDrop);
+            }
+
+            McMMOPlayerFishingTreasureEvent event = EventUtils.callFishingTreasureEvent(player, treasureDrop, treasure.getXp(), enchants);
+
+            if (!event.isCancelled()) {
+                treasureDrop = event.getTreasure();
+                treasureXp = event.getXp();
+            }
+            else {
+                treasureDrop = null;
+                treasureXp = 0;
+            }
+
+            // Drop the original catch at the feet of the player and set the treasure as the real catch
+            if (treasureDrop != null) {
+                boolean enchanted = false;
+
+                if (!enchants.isEmpty()) {
+                    treasureDrop.addUnsafeEnchantments(enchants);
+                    enchanted = true;
+                }
+
+                if (enchanted) {
+                    player.sendMessage(LocaleLoader.getString("Fishing.Ability.TH.MagicFound"));
+                }
+
+                fishingCatch.setItemStack(treasureDrop);
+            }
+        }
+
+        applyXpGain(ExperienceConfig.getInstance().getFishingBaseXP() + treasureXp);
+    }
+
+    /**
+     * Handle the vanilla XP boost for Fishing
+     *
+     * @param experience The amount of experience initially awarded by the event
+     *
+     * @return the modified event damage
+     */
+    public int handleVanillaXpBoost(int experience) {
+        return experience * getVanillaXpMultiplier();
+    }
+
+    public Location getHookLocation() {
+        return hookLocation;
+    }
+
+    /**
+     * Handle the Shake ability
+     *
+     * @param target The {@link LivingEntity} affected by the ability
+     */
+    public void shakeCheck(LivingEntity target) {
+        fishingTries--; // Because autoclicking to shake is OK.
+
+        SecondaryAbilityWeightedActivationCheckEvent activationEvent = new SecondaryAbilityWeightedActivationCheckEvent(getPlayer(), SecondaryAbility.SHAKE, getShakeProbability() / activationChance);
+        mcMMO.p.getServer().getPluginManager().callEvent(activationEvent);
+        if ((activationEvent.getChance() * activationChance) > Misc.getRandom().nextInt(activationChance)) {
+            List<ShakeTreasure> possibleDrops = Fishing.findPossibleDrops(target);
+
+            if (possibleDrops == null || possibleDrops.isEmpty()) {
+                return;
+            }
+
+            ItemStack drop = Fishing.chooseDrop(possibleDrops);
+
+            // It's possible that chooseDrop returns null if the sum of probability in possibleDrops is inferior than 100
+            if (drop == null) {
+                return;
+            }
+
+            // Extra processing depending on the mob and drop type
+            switch (target.getType()) {
+                case SHEEP:
+                    Sheep sheep = (Sheep) target;
+
+                    if (drop.getType() == Material.WOOL) {
+                        if (sheep.isSheared()) {
+                            return;
+                        }
+
+                        drop = new Wool(sheep.getColor()).toItemStack(drop.getAmount());
+                        sheep.setSheared(true);
+                    }
+                    break;
+
+                case SKELETON:
+                    if (((Skeleton) target).getSkeletonType() == SkeletonType.WITHER) {
+                        switch (drop.getType()) {
+                            case SKULL_ITEM:
+                                drop.setDurability((short) 1);
+                                break;
+
+                            case ARROW:
+                                drop.setType(Material.COAL);
+                                break;
+
+                            default:
+                                break;
+                        }
+                    }
+                    break;
+
+                default:
+                    break;
+            }
+
+            McMMOPlayerShakeEvent shakeEvent = new McMMOPlayerShakeEvent(getPlayer(), drop);
+
+            drop = shakeEvent.getDrop();
+
+            if (shakeEvent.isCancelled() || drop == null) {
+                return;
+            }
+
+            Misc.dropItem(target.getLocation(), drop);
+            CombatUtils.dealDamage(target, Math.max(target.getMaxHealth() / 4, 1)); // Make it so you can shake a mob no more than 4 times.
+            applyXpGain(ExperienceConfig.getInstance().getFishingShakeXP());
+        }
+    }
+
     /**
      * Process the Treasure Hunter ability for Fishing
      *
@@ -584,34 +620,4 @@ public class FishingManager extends SkillManager {
 
         return 0;
     }
-
-    private boolean canShake(Entity target) {
-        return target.isValid() && target instanceof LivingEntity && getSkillLevel() >= Tier.ONE.getLevel() && Permissions.shake(getPlayer()) && getShakeProbability() > Misc.getRandom().nextInt(getActivationChance());
-    }
-
-    private boolean canUseMasterAngler() {
-        return getSkillLevel() >= AdvancedConfig.getInstance().getMasterAnglerUnlockLevel() && Permissions.masterAngler(getPlayer());
-    }
-
-    private boolean canIceFish(Block block) {
-        if (getSkillLevel() < AdvancedConfig.getInstance().getIceFishingUnlockLevel() || block.getType() != Material.ICE) {
-            return false;
-        }
-
-        // Make sure this is a body of water, not just a block of ice.
-        Biome biome = block.getBiome();
-        boolean isFrozenBiome = (biome == Biome.FROZEN_OCEAN || biome == Biome.FROZEN_RIVER || biome == Biome.TAIGA || biome == Biome.TAIGA_HILLS || biome == Biome.ICE_PLAINS || biome == Biome.ICE_MOUNTAINS);
-
-        if (!isFrozenBiome || (block.getRelative(BlockFace.DOWN, 3).getType() != Material.STATIONARY_WATER)) {
-            return false;
-        }
-
-        Player player = getPlayer();
-
-        if (!Permissions.iceFishing(player)) {
-            return false;
-        }
-
-        return EventUtils.simulateBlockBreak(block, player, false);
-    }
 }

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

@@ -17,18 +17,6 @@ public class Herbalism {
     public static int greenThumbStageChangeLevel = AdvancedConfig.getInstance().getGreenThumbStageChange();
     public static int greenThumbStageMaxLevel    = greenThumbStageChangeLevel * 4;
 
-    public static int    greenThumbMaxLevel  = AdvancedConfig.getInstance().getGreenThumbMaxLevel();
-    public static double greenThumbMaxChance = AdvancedConfig.getInstance().getGreenThumbChanceMax();
-
-    public static int    doubleDropsMaxLevel  = AdvancedConfig.getInstance().getHerbalismDoubleDropsMaxLevel();
-    public static double doubleDropsMaxChance = AdvancedConfig.getInstance().getHerbalismDoubleDropsChanceMax();
-
-    public static int    hylianLuckMaxLevel  = AdvancedConfig.getInstance().getHylianLuckMaxLevel();
-    public static double hylianLuckMaxChance = AdvancedConfig.getInstance().getHylianLuckChanceMax();
-
-    public static int    shroomThumbMaxLevel  = AdvancedConfig.getInstance().getShroomThumbMaxLevel();
-    public static double shroomThumbMaxChance = AdvancedConfig.getInstance().getShroomThumbChanceMax();
-
     /**
      * Convert blocks affected by the Green Thumb & Green Terra abilities.
      *

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

@@ -23,6 +23,7 @@ import com.gmail.nossr50.config.treasure.TreasureConfig;
 import com.gmail.nossr50.datatypes.mods.CustomBlock;
 import com.gmail.nossr50.datatypes.player.McMMOPlayer;
 import com.gmail.nossr50.datatypes.skills.AbilityType;
+import com.gmail.nossr50.datatypes.skills.SecondaryAbility;
 import com.gmail.nossr50.datatypes.skills.SkillType;
 import com.gmail.nossr50.datatypes.skills.ToolType;
 import com.gmail.nossr50.datatypes.treasure.HylianTreasure;
@@ -56,11 +57,11 @@ public class HerbalismManager extends SkillManager {
         Player player = getPlayer();
         Material itemType = player.getItemInHand().getType();
 
-        return (itemType == Material.RED_MUSHROOM || itemType == Material.BROWN_MUSHROOM) && BlockUtils.canMakeShroomy(blockState) && Permissions.shroomThumb(player);
+        return (itemType == Material.RED_MUSHROOM || itemType == Material.BROWN_MUSHROOM) && BlockUtils.canMakeShroomy(blockState) && Permissions.secondaryAbilityEnabled(player, SecondaryAbility.SHROOM_THUMB);
     }
 
     public boolean canUseHylianLuck() {
-        return Permissions.hylianLuck(getPlayer());
+        return Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.HYLIAN_LUCK);
     }
 
     public boolean canGreenTerraBlock(BlockState blockState) {
@@ -92,7 +93,7 @@ public class HerbalismManager extends SkillManager {
      * @param blockState The {@link BlockState} to check ability activation for
      * @return true if the ability was successful, false otherwise
      */
-    public boolean greenTerra(BlockState blockState) {
+    public boolean processGreenTerra(BlockState blockState) {
         Player player = getPlayer();
 
         if (!Permissions.greenThumbBlock(player, blockState.getType())) {
@@ -100,29 +101,34 @@ public class HerbalismManager extends SkillManager {
         }
 
         PlayerInventory playerInventory = player.getInventory();
+        ItemStack seed = new ItemStack(Material.SEEDS);
 
-        if (!playerInventory.contains(Material.SEEDS)) {
+        if (!playerInventory.containsAtLeast(seed, 1)) {
             player.sendMessage(LocaleLoader.getString("Herbalism.Ability.GTe.NeedMore"));
             return false;
         }
 
-        playerInventory.removeItem(new ItemStack(Material.SEEDS));
-        player.updateInventory();
+        playerInventory.removeItem(seed);
+        player.updateInventory(); // Needed until replacement available
 
         return Herbalism.convertGreenTerraBlocks(blockState);
     }
 
     /**
-     * Process double drops & XP gain for Herbalism.
+     * 
      *
      * @param blockState The {@link BlockState} to check ability activation for
      */
-    public void blockBreak(BlockState blockState) {
+    public void herbalismBlockCheck(BlockState blockState) {
         Player player = getPlayer();
         Material material = blockState.getType();
         boolean oneBlockPlant = !(material == Material.CACTUS || material == Material.SUGAR_CANE_BLOCK);
 
-        if (!canBlockCheck() || (oneBlockPlant && mcMMO.getPlaceStore().isTrue(blockState))) {
+        if (oneBlockPlant && mcMMO.getPlaceStore().isTrue(blockState)) {
+            return;
+        }
+
+        if (!canBlockCheck()) {
             return;
         }
 
@@ -135,7 +141,7 @@ public class HerbalismManager extends SkillManager {
             CustomBlock customBlock = ModUtils.getCustomBlock(blockState);
             xp = customBlock.getXpGain();
 
-            if (Permissions.doubleDrops(player, skill) && customBlock.isDoubleDropEnabled()) {
+            if (Permissions.secondaryAbilityEnabled(player, SecondaryAbility.HERBALISM_DOUBLE_DROPS) && customBlock.isDoubleDropEnabled()) {
                 drops = blockState.getBlock().getDrops();
             }
         }
@@ -146,7 +152,7 @@ public class HerbalismManager extends SkillManager {
 
             xp = ExperienceConfig.getInstance().getXp(skill, material);
 
-            if (Config.getInstance().getDoubleDropsEnabled(skill, material) && Permissions.doubleDrops(player, skill)) {
+            if (Config.getInstance().getDoubleDropsEnabled(skill, material) && Permissions.secondaryAbilityEnabled(player, SecondaryAbility.HERBALISM_DOUBLE_DROPS)) {
                 drops = blockState.getBlock().getDrops();
             }
 
@@ -163,7 +169,7 @@ public class HerbalismManager extends SkillManager {
         }
 
         for (int i = greenTerra ? 2 : 1; i != 0; i--) {
-            if (SkillUtils.activationSuccessful(getSkillLevel(), getActivationChance(), Herbalism.doubleDropsMaxChance, Herbalism.doubleDropsMaxLevel)) {
+            if (SkillUtils.activationSuccessful(SecondaryAbility.HERBALISM_DOUBLE_DROPS, getPlayer(), getSkillLevel(), activationChance)) {
                 for (ItemStack item : drops) {
                     Misc.dropItems(blockState.getLocation(), item, amount);
                 }
@@ -177,15 +183,8 @@ public class HerbalismManager extends SkillManager {
      * @param blockState The {@link BlockState} to check ability activation for
      * @return true if the ability was successful, false otherwise
      */
-    public boolean greenThumbBlocks(BlockState blockState) {
-        if (!canGreenThumbBlock(blockState)) {
-            return false;
-        }
-
-        ItemStack heldItem = getPlayer().getItemInHand();
-        heldItem.setAmount(heldItem.getAmount() - 1);
-
-        if (!SkillUtils.activationSuccessful(getSkillLevel(), getActivationChance(), Herbalism.greenThumbMaxChance, Herbalism.greenThumbMaxLevel)) {
+    public boolean processGreenThumbBlocks(BlockState blockState) {
+        if (!SkillUtils.activationSuccessful(SecondaryAbility.GREEN_THUMB_BLOCK, getPlayer(), getSkillLevel(), activationChance)) {
             getPlayer().sendMessage(LocaleLoader.getString("Herbalism.Ability.GTh.Fail"));
             return false;
         }
@@ -200,7 +199,7 @@ public class HerbalismManager extends SkillManager {
      * @return true if the ability was successful, false otherwise
      */
     public boolean processHylianLuck(BlockState blockState) {
-        if (!SkillUtils.activationSuccessful(getSkillLevel(), getActivationChance(), Herbalism.hylianLuckMaxChance, Herbalism.hylianLuckMaxLevel)) {
+        if (!SkillUtils.activationSuccessful(SecondaryAbility.HYLIAN_LUCK, getPlayer(), getSkillLevel(), activationChance)) {
             return false;
         }
 
@@ -268,7 +267,7 @@ public class HerbalismManager extends SkillManager {
         playerInventory.removeItem(new ItemStack(Material.RED_MUSHROOM));
         player.updateInventory();
 
-        if (!SkillUtils.activationSuccessful(getSkillLevel(), getActivationChance(), Herbalism.shroomThumbMaxChance, Herbalism.shroomThumbMaxLevel)) {
+        if (!SkillUtils.activationSuccessful(SecondaryAbility.SHROOM_THUMB, getPlayer(), getSkillLevel(), activationChance)) {
             player.sendMessage(LocaleLoader.getString("Herbalism.Ability.ShroomThumb.Fail"));
             return false;
         }
@@ -285,35 +284,43 @@ public class HerbalismManager extends SkillManager {
     private void processGreenThumbPlants(BlockState blockState, boolean greenTerra) {
         Player player = getPlayer();
         PlayerInventory playerInventory = player.getInventory();
-        Material seed = null;
+        ItemStack seed = null;
 
         switch (blockState.getType()) {
             case CARROT:
-                seed = Material.CARROT_ITEM;
+                seed = new ItemStack(Material.CARROT_ITEM);
                 break;
 
             case CROPS:
-                seed = Material.SEEDS;
+                seed = new ItemStack(Material.SEEDS);
                 break;
 
             case NETHER_WARTS:
-                seed = Material.NETHER_STALK;
+                seed = new ItemStack(Material.NETHER_STALK);
                 break;
 
             case POTATO:
-                seed = Material.POTATO_ITEM;
+                seed = new ItemStack(Material.POTATO_ITEM);
                 break;
 
             default:
                 break;
         }
 
-        if (!playerInventory.contains(seed) || (!greenTerra && !SkillUtils.activationSuccessful(getSkillLevel(), getActivationChance(), Herbalism.greenThumbMaxChance, Herbalism.greenThumbMaxLevel)) || !handleBlockState(blockState, greenTerra)) {
+        if (!playerInventory.containsAtLeast(seed, 1)) {
             return;
         }
 
-        playerInventory.removeItem(new ItemStack(seed));
-        player.updateInventory();
+        if (!greenTerra && !SkillUtils.activationSuccessful(SecondaryAbility.GREEN_THUMB_PLANT, getPlayer(), getSkillLevel(), activationChance)) {
+            return;
+        }
+
+        if (!handleBlockState(blockState, greenTerra)) {
+            return;
+        }
+
+        playerInventory.removeItem(seed);
+        player.updateInventory(); // Needed until replacement available
         new HerbalismBlockUpdaterTask(blockState).runTaskLater(mcMMO.p, 0);
     }
 

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

@@ -4,7 +4,6 @@ import org.bukkit.Material;
 import org.bukkit.block.BlockState;
 import org.bukkit.inventory.ItemStack;
 
-import com.gmail.nossr50.config.AdvancedConfig;
 import com.gmail.nossr50.config.Config;
 import com.gmail.nossr50.config.experience.ExperienceConfig;
 import com.gmail.nossr50.datatypes.skills.SkillType;
@@ -12,8 +11,6 @@ import com.gmail.nossr50.util.Misc;
 import com.gmail.nossr50.util.ModUtils;
 
 public class Mining {
-    public static int    doubleDropsMaxLevel  = AdvancedConfig.getInstance().getMiningDoubleDropMaxLevel();
-    public static double doubleDropsMaxChance = AdvancedConfig.getInstance().getMiningDoubleDropChance();
 
     /**
      * Calculate XP gain for Mining.

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

@@ -9,12 +9,11 @@ import org.bukkit.block.BlockState;
 import org.bukkit.enchantments.Enchantment;
 import org.bukkit.entity.Player;
 import org.bukkit.entity.TNTPrimed;
-import org.bukkit.metadata.FixedMetadataValue;
-
 import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.config.Config;
 import com.gmail.nossr50.datatypes.player.McMMOPlayer;
 import com.gmail.nossr50.datatypes.skills.AbilityType;
+import com.gmail.nossr50.datatypes.skills.SecondaryAbility;
 import com.gmail.nossr50.datatypes.skills.SkillType;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.runnables.skills.AbilityCooldownTask;
@@ -60,7 +59,7 @@ public class MiningManager extends SkillManager {
 
         applyXpGain(Mining.getBlockXp(blockState));
 
-        if (!Permissions.doubleDrops(player, skill)) {
+        if (!Permissions.secondaryAbilityEnabled(player, SecondaryAbility.MINING_DOUBLE_DROPS)) {
             return;
         }
 
@@ -77,7 +76,7 @@ public class MiningManager extends SkillManager {
         boolean silkTouch = player.getItemInHand().containsEnchantment(Enchantment.SILK_TOUCH);
 
         for (int i = mcMMOPlayer.getAbilityMode(skill.getAbility()) ? 2 : 1; i != 0; i--) {
-            if (SkillUtils.activationSuccessful(getSkillLevel(), getActivationChance(), Mining.doubleDropsMaxChance, Mining.doubleDropsMaxLevel)) {
+            if (SkillUtils.activationSuccessful(SecondaryAbility.MINING_DOUBLE_DROPS, getPlayer(), getSkillLevel(), activationChance)) {
                 if (silkTouch) {
                     Mining.handleSilkTouchDrops(blockState);
                 }
@@ -104,7 +103,7 @@ public class MiningManager extends SkillManager {
         SkillUtils.sendSkillMessage(player, AbilityType.BLAST_MINING.getAbilityPlayer(player));
         player.sendMessage(LocaleLoader.getString("Mining.Blast.Boom"));
 
-        tnt.setMetadata(mcMMO.tntMetadataKey, new FixedMetadataValue(mcMMO.p, player.getName()));
+        tnt.setMetadata(mcMMO.tntMetadataKey, mcMMOPlayer.getPlayerMetadata());
         tnt.setFuseTicks(0);
         targetBlock.setType(Material.AIR);
 

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

@@ -19,9 +19,6 @@ public class Repair {
     public static int    repairMasteryMaxBonusLevel = AdvancedConfig.getInstance().getRepairMasteryMaxLevel();
     public static double repairMasteryMaxBonus      = AdvancedConfig.getInstance().getRepairMasteryMaxBonus();
 
-    public static int    superRepairMaxBonusLevel = AdvancedConfig.getInstance().getSuperRepairMaxLevel();
-    public static double superRepairMaxChance     = AdvancedConfig.getInstance().getSuperRepairChanceMax();
-
     public static int salvageUnlockLevel = AdvancedConfig.getInstance().getSalvageUnlockLevel();
 
     public static Material salvageAnvilMaterial = Config.getInstance().getSalvageAnvilMaterial();

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

@@ -16,6 +16,7 @@ import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.config.Config;
 import com.gmail.nossr50.config.experience.ExperienceConfig;
 import com.gmail.nossr50.datatypes.player.McMMOPlayer;
+import com.gmail.nossr50.datatypes.skills.SecondaryAbility;
 import com.gmail.nossr50.datatypes.skills.SkillType;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.skills.SkillManager;
@@ -167,7 +168,7 @@ public class RepairManager extends SkillManager {
         }
 
         if (item.getDurability() == 0) {
-            player.setItemInHand(null);
+            player.setItemInHand(new ItemStack(Material.AIR));
             location.setY(location.getY() + 1);
 
             Misc.dropItems(location, new ItemStack(Repair.getRepairAndSalvageItem(item)), Repair.getRepairAndSalvageQuantities(item) * item.getAmount());
@@ -273,12 +274,12 @@ public class RepairManager extends SkillManager {
     private short repairCalculate(short durability, int repairAmount) {
         Player player = getPlayer();
 
-        if (Permissions.repairMastery(player)) {
+        if (Permissions.secondaryAbilityEnabled(player, SecondaryAbility.REPAIR_MASTERY)) {
             double bonus = repairAmount * Math.min((((Repair.repairMasteryMaxBonus / Repair.repairMasteryMaxBonusLevel) * getSkillLevel()) / 100.0D), Repair.repairMasteryMaxBonus / 100.0D);
             repairAmount += bonus;
         }
 
-        if (Permissions.superRepair(player) && checkPlayerProcRepair()) {
+        if (Permissions.secondaryAbilityEnabled(player, SecondaryAbility.SUPER_REPAIR) && checkPlayerProcRepair()) {
             repairAmount *= 2.0D;
         }
 
@@ -295,7 +296,7 @@ public class RepairManager extends SkillManager {
      * @return true if bonus granted, false otherwise
      */
     private boolean checkPlayerProcRepair() {
-        if (SkillUtils.activationSuccessful(getSkillLevel(), getActivationChance(), Repair.superRepairMaxChance, Repair.superRepairMaxBonusLevel)) {
+        if (SkillUtils.activationSuccessful(SecondaryAbility.SUPER_REPAIR, getPlayer(), getSkillLevel(), activationChance)) {
             getPlayer().sendMessage(LocaleLoader.getString("Repair.Skills.FeltEasy"));
             return true;
         }
@@ -322,7 +323,7 @@ public class RepairManager extends SkillManager {
             return;
         }
 
-        if (getArcaneForgingRank() == 0 || !Permissions.arcaneForging(player)) {
+        if (getArcaneForgingRank() == 0 || !Permissions.secondaryAbilityEnabled(player, SecondaryAbility.ARCANE_FORGING)) {
             for (Enchantment enchant : enchants.keySet()) {
                 item.removeEnchantment(enchant);
             }

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

@@ -43,9 +43,6 @@ public class Smelting {
     public static int    burnModifierMaxLevel = AdvancedConfig.getInstance().getBurnModifierMaxLevel();
     public static double burnTimeMultiplier   = AdvancedConfig.getInstance().getBurnTimeMultiplier();
 
-    public static int    secondSmeltMaxLevel  = AdvancedConfig.getInstance().getSecondSmeltMaxLevel();
-    public static double secondSmeltMaxChance = AdvancedConfig.getInstance().getSecondSmeltMaxChance();
-
     public static int    fluxMiningUnlockLevel = AdvancedConfig.getInstance().getFluxMiningUnlockLevel();
     public static double fluxMiningChance      = AdvancedConfig.getInstance().getFluxMiningChance();
 

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

@@ -8,10 +8,11 @@ import org.bukkit.inventory.ItemStack;
 
 import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.datatypes.player.McMMOPlayer;
+import com.gmail.nossr50.datatypes.skills.SecondaryAbility;
 import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.events.skills.secondaryabilities.SecondaryAbilityWeightedActivationCheckEvent;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.skills.SkillManager;
-import com.gmail.nossr50.skills.mining.Mining;
 import com.gmail.nossr50.skills.smelting.Smelting.Tier;
 import com.gmail.nossr50.util.BlockUtils;
 import com.gmail.nossr50.util.Misc;
@@ -24,11 +25,11 @@ public class SmeltingManager extends SkillManager {
     }
 
     public boolean canUseFluxMining(BlockState blockState) {
-        return getSkillLevel() >= Smelting.fluxMiningUnlockLevel && BlockUtils.affectedByFluxMining(blockState) && Permissions.fluxMining(getPlayer()) && !mcMMO.getPlaceStore().isTrue(blockState);
+        return getSkillLevel() >= Smelting.fluxMiningUnlockLevel && BlockUtils.affectedByFluxMining(blockState) && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.FLUX_MINING) && !mcMMO.getPlaceStore().isTrue(blockState);
     }
 
-    public boolean isDoubleDropSuccessful() {
-        return Permissions.doubleDrops(getPlayer(), skill) && SkillUtils.activationSuccessful(getSkillLevel(), getActivationChance(), Mining.doubleDropsMaxChance, Mining.doubleDropsMaxLevel);
+    public boolean isSecondSmeltSuccessful() {
+        return Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.SECOND_SMELT) && SkillUtils.activationSuccessful(SecondaryAbility.SECOND_SMELT, getPlayer(), getSkillLevel(), activationChance);
     }
 
     /**
@@ -40,7 +41,9 @@ public class SmeltingManager extends SkillManager {
     public boolean processFluxMining(BlockState blockState) {
         Player player = getPlayer();
 
-        if (Smelting.fluxMiningChance > Misc.getRandom().nextInt(getActivationChance())) {
+        SecondaryAbilityWeightedActivationCheckEvent event = new SecondaryAbilityWeightedActivationCheckEvent(getPlayer(), SecondaryAbility.FLUX_MINING, Smelting.fluxMiningChance / activationChance);
+        mcMMO.p.getServer().getPluginManager().callEvent(event);
+        if ((event.getChance() * activationChance) > Misc.getRandom().nextInt(activationChance)) {
             ItemStack item = null;
 
             switch (blockState.getType()) {
@@ -60,7 +63,7 @@ public class SmeltingManager extends SkillManager {
                 return false;
             }
 
-            Misc.dropItems(blockState.getLocation(), item, isDoubleDropSuccessful() ? 2 : 1);
+            Misc.dropItems(blockState.getLocation(), item, isSecondSmeltSuccessful() ? 2 : 1);
 
             blockState.setType(Material.AIR);
             player.sendMessage(LocaleLoader.getString("Smelting.FluxMining.Success"));
@@ -82,11 +85,9 @@ public class SmeltingManager extends SkillManager {
     }
 
     public ItemStack smeltProcessing(ItemStack smelting, ItemStack result) {
-        Player player = getPlayer();
-
         applyXpGain(Smelting.getResourceXp(smelting));
 
-        if (Permissions.doubleDrops(player, skill) && SkillUtils.activationSuccessful(getSkillLevel(), getActivationChance(), Smelting.secondSmeltMaxChance, Smelting.secondSmeltMaxLevel)) {
+        if (isSecondSmeltSuccessful()) {
             ItemStack newResult = result.clone();
 
             newResult.setAmount(result.getAmount() + 1);

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

@@ -3,15 +3,11 @@ package com.gmail.nossr50.skills.swords;
 import com.gmail.nossr50.config.AdvancedConfig;
 
 public class Swords {
-    public static int    bleedMaxBonusLevel = AdvancedConfig.getInstance().getBleedMaxBonusLevel();
     public static int    bleedMaxTicks      = AdvancedConfig.getInstance().getBleedMaxTicks();
     public static int    bleedBaseTicks     = AdvancedConfig.getInstance().getBleedBaseTicks();
-    public static double bleedMaxChance     = AdvancedConfig.getInstance().getBleedChanceMax();
 
     public static boolean counterAttackRequiresBlock = AdvancedConfig.getInstance().getCounterRequiresBlock();
-    public static int     counterAttackMaxBonusLevel = AdvancedConfig.getInstance().getCounterMaxBonusLevel();
     public static double  counterAttackModifier      = AdvancedConfig.getInstance().getCounterModifier();
-    public static double  counterAttackMaxChance     = AdvancedConfig.getInstance().getCounterChanceMax();
 
     public static double serratedStrikesModifier   = AdvancedConfig.getInstance().getSerratedStrikesModifier();
     public static int    serratedStrikesBleedTicks = AdvancedConfig.getInstance().getSerratedStrikesTicks();

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

@@ -4,8 +4,12 @@ import org.bukkit.entity.Entity;
 import org.bukkit.entity.LivingEntity;
 import org.bukkit.entity.Player;
 
+import com.gmail.nossr50.config.AdvancedConfig;
 import com.gmail.nossr50.datatypes.player.McMMOPlayer;
+import com.gmail.nossr50.datatypes.skills.AbilityType;
+import com.gmail.nossr50.datatypes.skills.SecondaryAbility;
 import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.datatypes.skills.ToolType;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.runnables.skills.BleedTimerTask;
 import com.gmail.nossr50.skills.SkillManager;
@@ -19,12 +23,20 @@ public class SwordsManager extends SkillManager {
         super(mcMMOPlayer, SkillType.SWORDS);
     }
 
+    public boolean canActivateAbility() {
+        return mcMMOPlayer.getToolPreparationMode(ToolType.SWORD) && Permissions.serratedStrikes(getPlayer());
+    }
+
     public boolean canUseBleed() {
-        return Permissions.bleed(getPlayer());
+        return Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.BLEED);
     }
 
     public boolean canUseCounterAttack(Entity target) {
-        return target instanceof LivingEntity && Permissions.counterAttack(getPlayer());
+        return target instanceof LivingEntity && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.COUNTER);
+    }
+
+    public boolean canUseSerratedStrike() {
+        return mcMMOPlayer.getAbilityMode(AbilityType.SERRATED_STRIKES) && Permissions.serratedStrikes(getPlayer());
     }
 
     /**
@@ -33,9 +45,9 @@ public class SwordsManager extends SkillManager {
      * @param target The defending entity
      */
     public void bleedCheck(LivingEntity target) {
-        if (SkillUtils.activationSuccessful(getSkillLevel(), getActivationChance(), Swords.bleedMaxChance, Swords.bleedMaxBonusLevel)) {
+        if (SkillUtils.activationSuccessful(SecondaryAbility.BLEED, getPlayer(), getSkillLevel(), activationChance)) {
 
-            if (getSkillLevel() >= Swords.bleedMaxBonusLevel) {
+            if (getSkillLevel() >= AdvancedConfig.getInstance().getMaxBonusLevel(SecondaryAbility.BLEED)) {
                 BleedTimerTask.add(target, Swords.bleedMaxTicks);
             }
             else {
@@ -67,7 +79,7 @@ public class SwordsManager extends SkillManager {
             return;
         }
 
-        if (SkillUtils.activationSuccessful(getSkillLevel(), getActivationChance(), Swords.counterAttackMaxChance, Swords.counterAttackMaxBonusLevel)) {
+        if (SkillUtils.activationSuccessful(SecondaryAbility.COUNTER, getPlayer(), getSkillLevel(), activationChance)) {
             CombatUtils.dealDamage(attacker, damage / Swords.counterAttackModifier);
 
             getPlayer().sendMessage(LocaleLoader.getString("Swords.Combat.Countered"));

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

@@ -19,9 +19,7 @@ public class Taming {
     public static double fastFoodServiceActivationChance = AdvancedConfig.getInstance().getFastFoodChance();
 
     public static int    goreBleedTicks    = AdvancedConfig.getInstance().getGoreBleedTicks();
-    public static int    goreMaxBonusLevel = AdvancedConfig.getInstance().getGoreMaxBonusLevel();
     public static double goreModifier      = AdvancedConfig.getInstance().getGoreModifier();
-    public static double goreMaxChance     = AdvancedConfig.getInstance().getGoreChanceMax();
 
     public static int    sharpenedClawsUnlockLevel = AdvancedConfig.getInstance().getSharpenedClawsUnlock();
     public static double sharpenedClawsBonusDamage = AdvancedConfig.getInstance().getSharpenedClawsBonus();

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

@@ -14,7 +14,9 @@ import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.config.AdvancedConfig;
 import com.gmail.nossr50.config.Config;
 import com.gmail.nossr50.datatypes.player.McMMOPlayer;
+import com.gmail.nossr50.datatypes.skills.SecondaryAbility;
 import com.gmail.nossr50.datatypes.skills.SkillType;
+import com.gmail.nossr50.events.skills.secondaryabilities.SecondaryAbilityWeightedActivationCheckEvent;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.runnables.skills.BleedTimerTask;
 import com.gmail.nossr50.skills.SkillManager;
@@ -30,35 +32,35 @@ public class TamingManager extends SkillManager {
     }
 
     public boolean canUseThickFur() {
-        return getSkillLevel() >= Taming.thickFurUnlockLevel && Permissions.thickFur(getPlayer());
+        return getSkillLevel() >= Taming.thickFurUnlockLevel && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.THICK_FUR);
     }
 
     public boolean canUseEnvironmentallyAware() {
-        return getSkillLevel() >= Taming.environmentallyAwareUnlockLevel && Permissions.environmentallyAware(getPlayer());
+        return getSkillLevel() >= Taming.environmentallyAwareUnlockLevel && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.ENVIROMENTALLY_AWARE);
     }
 
     public boolean canUseShockProof() {
-        return getSkillLevel() >= Taming.shockProofUnlockLevel && Permissions.shockProof(getPlayer());
+        return getSkillLevel() >= Taming.shockProofUnlockLevel && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.SHOCK_PROOF);
     }
 
     public boolean canUseHolyHound() {
-        return getSkillLevel() >= Taming.holyHoundUnlockLevel && Permissions.holyHound(getPlayer());
+        return getSkillLevel() >= Taming.holyHoundUnlockLevel && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.HOLY_HOUND);
     }
 
     public boolean canUseFastFoodService() {
-        return getSkillLevel() >= Taming.fastFoodServiceUnlockLevel && Permissions.fastFoodService(getPlayer());
+        return getSkillLevel() >= Taming.fastFoodServiceUnlockLevel && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.FAST_FOOD);
     }
 
     public boolean canUseSharpenedClaws() {
-        return getSkillLevel() >= Taming.sharpenedClawsUnlockLevel && Permissions.sharpenedClaws(getPlayer());
+        return getSkillLevel() >= Taming.sharpenedClawsUnlockLevel && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.SHARPENED_CLAWS);
     }
 
     public boolean canUseGore() {
-        return Permissions.gore(getPlayer());
+        return Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.GORE);
     }
 
     public boolean canUseBeastLore() {
-        return Permissions.beastLore(getPlayer());
+        return Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.BEAST_LORE);
     }
 
     /**
@@ -92,7 +94,10 @@ public class TamingManager extends SkillManager {
      * @param damage The damage being absorbed by the wolf
      */
     public void fastFoodService(Wolf wolf, double damage) {
-        if (Taming.fastFoodServiceActivationChance > Misc.getRandom().nextInt(getActivationChance())) {
+        double chance = Taming.fastFoodServiceActivationChance / activationChance;
+        SecondaryAbilityWeightedActivationCheckEvent event = new SecondaryAbilityWeightedActivationCheckEvent(getPlayer(), SecondaryAbility.FAST_FOOD, chance);
+        mcMMO.p.getServer().getPluginManager().callEvent(event);
+        if ((event.getChance() * activationChance) > Misc.getRandom().nextInt(activationChance)) {
 
             double health = wolf.getHealth();
             double maxHealth = wolf.getMaxHealth();
@@ -112,7 +117,7 @@ public class TamingManager extends SkillManager {
      * @param wolf The wolf using the ability
      */
     public double gore(LivingEntity target, double damage, Wolf wolf) {
-        if (!SkillUtils.activationSuccessful(getSkillLevel(), getActivationChance(), Taming.goreMaxChance, Taming.goreMaxBonusLevel)) {
+        if (!SkillUtils.activationSuccessful(SecondaryAbility.GORE, getPlayer(), getSkillLevel(), activationChance)) {
             return 0;
         }
 
@@ -255,7 +260,7 @@ public class TamingManager extends SkillManager {
             }
         }
 
-        heldItem.setAmount(heldItemAmount - summonAmount);
+        player.setItemInHand(new ItemStack(heldItem.getType(), heldItemAmount - summonAmount));
         player.sendMessage(LocaleLoader.getString("Taming.Summon.Complete"));
     }
 

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

@@ -14,15 +14,6 @@ public class Unarmed {
     public static double ironArmMaxBonusDamage = AdvancedConfig.getInstance().getIronArmMaxBonus();
     public static int    ironArmIncreaseLevel  = AdvancedConfig.getInstance().getIronArmIncreaseLevel();
 
-    public static int    disarmMaxBonusLevel = AdvancedConfig.getInstance().getDisarmMaxBonusLevel();
-    public static double disarmMaxChance     = AdvancedConfig.getInstance().getDisarmChanceMax();
-
-    public static int    deflectMaxBonusLevel = AdvancedConfig.getInstance().getDeflectMaxBonusLevel();
-    public static double deflectMaxChance     = AdvancedConfig.getInstance().getDeflectChanceMax();
-
-    public static int    ironGripMaxBonusLevel = AdvancedConfig.getInstance().getIronGripMaxBonusLevel();
-    public static double ironGripMaxChance     = AdvancedConfig.getInstance().getIronGripChanceMax();
-
     public static boolean blockCrackerSmoothBrick = Config.getInstance().getUnarmedBlockCrackerSmoothbrickToCracked();
 
     public static double berserkDamageModifier = 1.5;
@@ -80,8 +71,7 @@ public class Unarmed {
 
                 nextSlot++;
             }
-        }
-        else if (firstEmpty != -1) {
+        } else if (firstEmpty != -1) {
             drop.remove();
             dropStack.setAmount(dropAmount);
             inventory.setItem(firstEmpty, dropStack);