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,18 +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 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) {
+    protected void handleCommand(Player player, PlayerProfile profile, SkillType skill) {
-        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;
-        }
-
         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);
+        canDodge = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.DODGE);
-        canRoll = Permissions.roll(player);
+        canRoll = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.ROLL);
-        canGracefulRoll = Permissions.gracefulRoll(player);
+        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);
+        canSkillShot = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.SKILL_SHOT);
-        canDaze = Permissions.daze(player);
+        canDaze = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.DAZE);
-        canRetrieve = Permissions.arrowRetrieval(player);
+        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);
+            String[] criticalHitStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.CRITICAL_HIT, isLucky);
-            critChance = criticalStrikeStrings[0];
+            critChance = criticalHitStrings[0];
-            critChanceLucky = criticalStrikeStrings[1];
+            critChanceLucky = criticalHitStrings[1];
         }
 
         // AXE MASTERY
-        if (canBonusDamage) {
+        if (canAxeMastery) {
-            bonusDamage = Math.min(skillValue / (Axes.bonusDamageMaxBonusLevel / Axes.bonusDamageMaxBonus), Axes.bonusDamageMaxBonus);
+            axeMasteryDamage = Math.min(skillValue / (Axes.axeMasteryMaxBonusLevel / Axes.axeMasteryMaxBonus), Axes.axeMasteryMaxBonus);
         }
     }
 
     @Override
     protected void permissionsCheck(Player player) {
         canSkullSplitter = Permissions.skullSplitter(player);
-        canCritical = Permissions.criticalStrikes(player);
+        canCritical = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.CRITICAL_HIT);
-        canBonusDamage = Permissions.bonusDamage(player, skill);
+        canAxeMastery = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.AXE_MASTERY);
-        canImpact = Permissions.armorImpact(player);
+        canImpact = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.ARMOR_IMPACT);
-        canGreaterImpact = Permissions.greaterImpact(player);
+        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) {
+        if (canAxeMastery) {
-            messages.add(LocaleLoader.getString("Ability.Generic.Template", LocaleLoader.getString("Axes.Ability.Bonus.0"), LocaleLoader.getString("Axes.Ability.Bonus.1", bonusDamage)));
+            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);
+        canTreasureHunt = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.FISHING_TREASURE_HUNTER);
-        canMagicHunt = Permissions.magicHunter(player);
+        canMagicHunt = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.MAGIC_HUNTER);
-        canShake = Permissions.shake(player);
+        canShake = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.SHAKE);
-        canFishermansDiet = Permissions.fishermansDiet(player);
+        canFishermansDiet = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.FISHERMANS_DIET);
-        canMasterAngler = Permissions.masterAngler(player);
+        canMasterAngler = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.MASTER_ANGLER);
-        canIceFish = Permissions.iceFishing(player);
+        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);
+        canFarmersDiet = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.FARMERS_DIET);
-        canDoubleDrop = Permissions.doubleDrops(player, skill) && !skill.getDoubleDropsDisabled();
+        canDoubleDrop = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.HERBALISM_DOUBLE_DROPS) && !skill.getDoubleDropsDisabled();
-        canShroomThumb = Permissions.shroomThumb(player);
+        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);
+        canSuperRepair = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.SUPER_REPAIR);
-        canMasterRepair = Permissions.repairMastery(player);
+        canMasterRepair = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.REPAIR_MASTERY);
-        canArcaneForge = Permissions.arcaneForging(player);
+        canArcaneForge = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.ARCANE_FORGING);
-        canSalvage = Permissions.salvage(player);
+        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) {
+    protected String[] calculateAbilityDisplayValues(float skillValue, SecondaryAbility skillAbility, boolean isLucky) {
-        return calculateAbilityDisplayValues((maxChance / maxBonusLevel) * Math.min(skillValue, maxBonusLevel), 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);
+        canFuelEfficiency = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.FUEL_EFFICIENCY);
-        canSecondSmelt = Permissions.doubleDrops(player, skill);
+        canSecondSmelt = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.SECOND_SMELT);
-        canFluxMine = Permissions.fluxMining(player);
+        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 counterChance;
-    private String counterAttackChanceLucky;
+    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);
+            String[] counterStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.COUNTER, isLucky);
-            counterAttackChance = counterAttackStrings[0];
+            counterChance = counterStrings[0];
-            counterAttackChanceLucky = counterAttackStrings[1];
+            counterChanceLucky = counterStrings[1];
         }
     }
 
     @Override
     protected void permissionsCheck(Player player) {
-        canBleed = Permissions.bleed(player);
+        canBleed = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.BLEED);
-        canCounter = Permissions.counterAttack(player);
+        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);
+        canEnvironmentallyAware = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.ENVIROMENTALLY_AWARE);
-        canFastFood = Permissions.fastFoodService(player);
+        canFastFood = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.FAST_FOOD);
-        canGore = Permissions.gore(player);
+        canGore = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.GORE);
-        canSharpenedClaws = Permissions.sharpenedClaws(player);
+        canSharpenedClaws = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.SHARPENED_CLAWS);
-        canShockProof = Permissions.shockProof(player);
+        canShockProof = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.SHOCK_PROOF);
-        canThickFur = Permissions.thickFur(player);
+        canThickFur = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.THICK_FUR);
-        canHolyHound = Permissions.holyHound(player);
+        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);
+        canIronArm = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.IRON_ARM);
-        canDeflect = Permissions.arrowDeflect(player);
+        canDeflect = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.DEFLECT);
-        canDisarm = Permissions.disarm(player);
+        canDisarm = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.DISARM);
-        canIronGrip = Permissions.ironGrip(player);
+        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();
+        canDoubleDrop = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.WOODCUTTING_DOUBLE_DROPS) && !skill.getDoubleDropsDisabled();
-        canLeafBlow = Permissions.leafBlower(player);
+        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) {
+        if (getAxeMasteryBonusMax() < 1) {
-            reason.add("Skills.Axes.DamageIncrease.MaxBonus should be at least 1!");
+            reason.add("Skills.Axes.AxeMastery.MaxBonus should be at least 1!");
         }
 
-        if (getBonusDamageAxesMaxBonusLevel() < 1) {
+        if (getAxeMasteryMaxBonusLevel() < 1) {
-            reason.add("Skills.Axes.DamageIncrease.MaxBonusLevel should be at least 1!");
+            reason.add("Skills.Axes.AxeMastery.MaxBonusLevel should be at least 1!");
         }
 
-        if (getAxesCriticalChance() < 1) {
+        if (getMaxChance(SecondaryAbility.CRITICAL_HIT) < 1) {
-            reason.add("Skills.Axes.AxesCritical.ChanceMax should be at least 1!");
+            reason.add("Skills.Axes.CriticalHit.ChanceMax should be at least 1!");
         }
 
-        if (getAxesCriticalMaxBonusLevel() < 1) {
+        if (getMaxBonusLevel(SecondaryAbility.CRITICAL_HIT) < 1) {
-            reason.add("Skills.Axes.AxesCritical.MaxBonusLevel should be at least 1!");
+            reason.add("Skills.Axes.CriticalHit.MaxBonusLevel should be at least 1!");
         }
 
-        if (getAxesCriticalPVPModifier() < 1) {
+        if (getCriticalHitPVPModifier() < 1) {
-            reason.add("Skills.Axes.AxesCritical.PVP_Modifier should be at least 1!");
+            reason.add("Skills.Axes.CriticalHit.PVP_Modifier should be at least 1!");
         }
 
-        if (getAxesCriticalPVEModifier() < 1) {
+        if (getCriticalHitPVEModifier() < 1) {
-            reason.add("Skills.Axes.AxesCritical.PVE_Modifier should be at least 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 double getAxeMasteryBonusMax() { return config.getDouble("Skills.Axes.AxeMastery.MaxBonus", 4.0D); }
-    public int getBonusDamageAxesMaxBonusLevel() { return config.getInt("Skills.Axes.DamageIncrease.MaxBonusLevel", 200); }
+    public int getAxeMasteryMaxBonusLevel() { return config.getInt("Skills.Axes.AxeMastery.MaxBonusLevel", 200); }
 
-    public double getAxesCriticalChance() { return config.getDouble("Skills.Axes.AxesCritical.ChanceMax", 37.50D); }
+    public double getCriticalHitPVPModifier() { return config.getDouble("Skills.Axes.CriticalHit.PVP_Modifier", 1.5D); }
-    public int getAxesCriticalMaxBonusLevel() { return config.getInt("Skills.Axes.AxesCritical.MaxBonusLevel", 750); }
+    public double getCriticalHitPVEModifier() { return config.getDouble("Skills.Axes.CriticalHit.PVE_Modifier", 2.0D); }
-    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 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/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();
 
@@ -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();
@@ -913,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),
+    ACROBATICS(AcrobaticsManager.class, Color.WHITE, ImmutableList.of(SecondaryAbility.DODGE, SecondaryAbility.GRACEFUL_ROLL, SecondaryAbility.ROLL)),
-    ARCHERY(ArcheryManager.class, Color.MAROON),
+    ARCHERY(ArcheryManager.class, Color.MAROON, ImmutableList.of(SecondaryAbility.DAZE, SecondaryAbility.RETRIEVE, SecondaryAbility.SKILL_SHOT)),
-    AXES(AxesManager.class, Color.AQUA, AbilityType.SKULL_SPLITTER, ToolType.AXE),
+    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),
+    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),
+    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),
+    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),
+    MINING(MiningManager.class, Color.GRAY, AbilityType.SUPER_BREAKER, ToolType.PICKAXE, ImmutableList.of(SecondaryAbility.MINING_DOUBLE_DROPS)),
-    REPAIR(RepairManager.class, Color.SILVER),
+    REPAIR(RepairManager.class, Color.SILVER, ImmutableList.of(SecondaryAbility.ARCANE_FORGING, SecondaryAbility.REPAIR_MASTERY, SecondaryAbility.SALVAGE, SecondaryAbility.SUPER_REPAIR)),
-    SMELTING(SmeltingManager.class, Color.YELLOW),
+    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),
+    SWORDS(SwordsManager.class, Color.fromRGB(178, 34, 34), AbilityType.SERRATED_STRIKES, ToolType.SWORD, ImmutableList.of(SecondaryAbility.BLEED, SecondaryAbility.COUNTER)),
-    TAMING(TamingManager.class, Color.PURPLE),
+    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),
+    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);
+    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) {
+    private SkillType(Class<? extends SkillManager> managerClass, Color runescapeColor, List<SecondaryAbility> secondaryAbilities) {
-        this.managerClass = managerClass;
+        this(managerClass, runescapeColor, null, null, secondaryAbilities);
-        this.runescapeColor = runescapeColor;
-        ability = null;
-        tool = null;
     }
 
-    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/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/listeners/BlockListener.java

@@ -36,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;
@@ -339,17 +340,17 @@ public class BlockListener implements Listener {
             }
         }
         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,6 +36,7 @@ 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;
@@ -515,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;
@@ -524,19 +525,19 @@ 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)) {
+                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)) {
+                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

@@ -36,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;
@@ -299,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));
 
@@ -432,7 +441,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();
                         event.setCancelled(true);
 
@@ -470,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

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,6 +52,7 @@ 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
@@ -61,11 +63,19 @@ public class CleanBackupsTask extends BukkitRunnable {
                 savedDays.add(dayOfWeek);
                 continue;
             }
-            else if (!savedWeeks.contains(weekOfYear) && Config.getInstance().getKeepWeeklyPastMonth()) {
+            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++;
             toDelete.add(file);

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() {
+        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/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 dodgeDamageModifier   = AdvancedConfig.getInstance().getDodgeDamageModifier();
 
     public static int dodgeXpModifier = ExperienceConfig.getInstance().getDodgeXPModifier();
     public static int rollXpModifier  = ExperienceConfig.getInstance().getRollXPModifier();

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

@@ -10,6 +10,7 @@ import org.bukkit.inventory.ItemStack;
 
 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.SkillManager;
@@ -27,11 +28,11 @@ public class AcrobaticsManager extends SkillManager {
     }
 
     public boolean canRoll() {
-        return !exploitPrevention() && Permissions.roll(getPlayer());
+        return !exploitPrevention() && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.ROLL);
     }
 
     public boolean canDodge(Entity damager) {
-        if (Permissions.dodge(getPlayer())) {
+        if (Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.DODGE)) {
             if (damager instanceof LightningStrike && Acrobatics.dodgeLightningDisabled) {
                 return false;
             }
@@ -52,7 +53,7 @@ public class AcrobaticsManager extends SkillManager {
         double modifiedDamage = Acrobatics.calculateModifiedDodgeDamage(damage, Acrobatics.dodgeDamageModifier);
         Player player = getPlayer();
 
-        if (!isFatal(modifiedDamage) && SkillUtils.activationSuccessful(getSkillLevel(), getActivationChance(), Acrobatics.dodgeMaxChance, Acrobatics.dodgeMaxBonusLevel)) {
+        if (!isFatal(modifiedDamage) && SkillUtils.activationSuccessful(SecondaryAbility.DODGE, player, getSkillLevel(), activationChance)) {
             ParticleEffectUtils.playDodgeEffect(player);
 
             if (mcMMOPlayer.useChatNotifications()) {
@@ -79,13 +80,13 @@ public class AcrobaticsManager extends SkillManager {
     public double rollCheck(double damage) {
         Player player = getPlayer();
 
-        if (player.isSneaking() && Permissions.gracefulRoll(player)) {
+        if (player.isSneaking() && Permissions.secondaryAbilityEnabled(player, SecondaryAbility.GRACEFUL_ROLL)) {
             return gracefulRollCheck(damage);
         }
 
         double modifiedDamage = Acrobatics.calculateModifiedRollDamage(damage, Acrobatics.rollThreshold);
 
-        if (!isFatal(modifiedDamage) && isSuccessfulRoll(Acrobatics.rollMaxChance, Acrobatics.rollMaxBonusLevel)) {
+        if (!isFatal(modifiedDamage) && SkillUtils.activationSuccessful(SecondaryAbility.ROLL, player, getSkillLevel(), activationChance)) {
             player.sendMessage(LocaleLoader.getString("Acrobatics.Roll.Text"));
             applyXpGain(calculateRollXP(damage, true));
 
@@ -109,7 +110,7 @@ public class AcrobaticsManager extends SkillManager {
     private double gracefulRollCheck(double damage) {
         double modifiedDamage = Acrobatics.calculateModifiedRollDamage(damage, Acrobatics.gracefulRollThreshold);
 
-        if (!isFatal(modifiedDamage) && isSuccessfulRoll(Acrobatics.gracefulRollMaxChance, Acrobatics.gracefulRollMaxBonusLevel)) {
+        if (!isFatal(modifiedDamage) && SkillUtils.activationSuccessful(SecondaryAbility.GRACEFUL_ROLL, getPlayer(), getSkillLevel(), activationChance)) {
             getPlayer().sendMessage(LocaleLoader.getString("Acrobatics.Ability.Proc"));
             applyXpGain(calculateRollXP(damage, true));
 
@@ -149,12 +150,8 @@ public class AcrobaticsManager extends SkillManager {
         return fallTries > Config.getInstance().getAcrobaticsAFKMaxTries();
     }
 
-    private boolean isSuccessfulRoll(double maxChance, int maxLevel) {
-        return (maxChance / maxLevel) * Math.min(getSkillLevel(), maxLevel) > Misc.getRandom().nextInt(activationChance);
-    }
-
     private boolean isFatal(double damage) {
-        return getPlayer().getHealth() - damage < 1;
+        return getPlayer().getHealth() - damage <= 0;
     }
 
     private float calculateRollXP(double damage, boolean isRoll) {

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

@@ -16,17 +16,12 @@ import com.gmail.nossr50.util.Misc;
 public class Archery {
     private static List<TrackedEntity> trackedEntities = new ArrayList<TrackedEntity>();
 
-    public static int    retrieveMaxBonusLevel = AdvancedConfig.getInstance().getRetrieveMaxBonusLevel();
-    public static double retrieveMaxChance     = AdvancedConfig.getInstance().getRetrieveChanceMax();
-
     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;
 

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

@@ -11,6 +11,7 @@ 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.locale.LocaleLoader;
 import com.gmail.nossr50.skills.SkillManager;
@@ -26,15 +27,15 @@ public class ArcheryManager extends SkillManager {
     }
 
     public boolean canDaze(LivingEntity target) {
-        return target instanceof Player && Permissions.daze(getPlayer());
+        return target instanceof Player && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.DAZE);
     }
 
     public boolean canSkillShot() {
-        return getSkillLevel() >= Archery.skillShotIncreaseLevel && Permissions.bonusDamage(getPlayer(), skill);
+        return getSkillLevel() >= Archery.skillShotIncreaseLevel && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.SKILL_SHOT);
     }
 
-    public boolean canTrackArrows() {
+    public boolean canRetrieveArrows() {
-        return Permissions.arrowRetrieval(getPlayer());
+        return Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.RETRIEVE);
     }
 
     /**
@@ -59,8 +60,8 @@ public class ArcheryManager extends SkillManager {
      *
      * @param target The {@link LivingEntity} damaged by the arrow
      */
-    public void trackArrows(LivingEntity target) {
+    public void retrieveArrows(LivingEntity target) {
-        if (SkillUtils.activationSuccessful(getSkillLevel(), getActivationChance(), Archery.retrieveMaxChance, Archery.retrieveMaxBonusLevel)) {
+        if (SkillUtils.activationSuccessful(SecondaryAbility.RETRIEVE, getPlayer(), getSkillLevel(), activationChance)) {
             Archery.incrementTrackerValue(target);
         }
     }
@@ -72,7 +73,7 @@ public class ArcheryManager extends SkillManager {
      * @param arrow The {@link Arrow} that was fired
      */
     public double daze(Player defender, Arrow arrow) {
-        if (!SkillUtils.activationSuccessful(getSkillLevel(), getActivationChance(), Archery.dazeMaxBonus, Archery.dazeMaxBonusLevel)) {
+        if (!SkillUtils.activationSuccessful(SecondaryAbility.DAZE, getPlayer(), getSkillLevel(), activationChance)) {
             return 0;
         }
 

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 double axeMasteryMaxBonus      = AdvancedConfig.getInstance().getAxeMasteryBonusMax();
-    public static int    bonusDamageMaxBonusLevel = AdvancedConfig.getInstance().getBonusDamageAxesMaxBonusLevel();
+    public static int    axeMasteryMaxBonusLevel = AdvancedConfig.getInstance().getAxeMasteryMaxBonusLevel();
 
-    public static int    criticalHitMaxBonusLevel = AdvancedConfig.getInstance().getAxesCriticalMaxBonusLevel();
+    public static double criticalHitPVPModifier   = AdvancedConfig.getInstance().getCriticalHitPVPModifier();
-    public static double criticalHitMaxChance     = AdvancedConfig.getInstance().getAxesCriticalChance();
+    public static double criticalHitPVEModifier   = AdvancedConfig.getInstance().getCriticalHitPVEModifier();
-    public static double criticalHitPVPModifier   = AdvancedConfig.getInstance().getAxesCriticalPVPModifier();
-    public static double criticalHitPVEModifier   = AdvancedConfig.getInstance().getAxesCriticalPVEModifier();
 
     public static int    impactIncreaseLevel         = AdvancedConfig.getInstance().getArmorImpactIncreaseLevel();
     public static double impactChance                = AdvancedConfig.getInstance().getImpactChance();

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

@@ -4,10 +4,13 @@ import org.bukkit.entity.LivingEntity;
 import org.bukkit.entity.Player;
 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.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;
@@ -24,19 +27,19 @@ public class AxesManager extends SkillManager {
     }
 
     public boolean canUseAxeMastery() {
-        return Permissions.bonusDamage(getPlayer(), skill);
+        return Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.AXE_MASTERY);
     }
 
     public boolean canCriticalHit(LivingEntity target) {
-        return target.isValid() && Permissions.criticalStrikes(getPlayer());
+        return target.isValid() && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.CRITICAL_HIT);
     }
 
     public boolean canImpact(LivingEntity target) {
-        return target.isValid() && Permissions.armorImpact(getPlayer()) && Axes.hasArmor(target);
+        return target.isValid() && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.ARMOR_IMPACT) && Axes.hasArmor(target);
     }
 
     public boolean canGreaterImpact(LivingEntity target) {
-        return target.isValid() && Permissions.greaterImpact(getPlayer()) && !Axes.hasArmor(target);
+        return target.isValid() && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.GREATER_IMPACT) && !Axes.hasArmor(target);
     }
 
     public boolean canUseSkullSplitter(LivingEntity target) {
@@ -53,7 +56,7 @@ public class AxesManager extends SkillManager {
      * @param target The {@link LivingEntity} being affected by the ability
      */
     public double axeMastery(LivingEntity target) {
-        double axeBonus = Math.min(getSkillLevel() / (Axes.bonusDamageMaxBonusLevel / Axes.bonusDamageMaxBonus), Axes.bonusDamageMaxBonus);
+        double axeBonus = Math.min(getSkillLevel() / (Axes.axeMasteryMaxBonusLevel / Axes.axeMasteryMaxBonus), Axes.axeMasteryMaxBonus);
 
         return CombatUtils.callFakeDamageEvent(getPlayer(), target, axeBonus);
     }
@@ -65,7 +68,7 @@ public class AxesManager extends SkillManager {
      * @param damage The amount of damage initially dealt by the event
      */
     public double criticalHit(LivingEntity target, double damage) {
-        if (!SkillUtils.activationSuccessful(getSkillLevel(), getActivationChance(), Axes.criticalHitMaxChance, Axes.criticalHitMaxBonusLevel)) {
+        if (!SkillUtils.activationSuccessful(SecondaryAbility.CRITICAL_HIT, getPlayer(), getSkillLevel(), activationChance)) {
             return 0;
         }
 
@@ -94,11 +97,16 @@ public class AxesManager extends SkillManager {
         int durabilityDamage = 1 + (getSkillLevel() / Axes.impactIncreaseLevel);
 
         for (ItemStack armor : target.getEquipment().getArmorContents()) {
-            if (ItemUtils.isArmor(armor) && Axes.impactChance > Misc.getRandom().nextInt(getActivationChance())) {
+            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.getChance() * activationChance) > Misc.getRandom().nextInt(activationChance)) {
                     SkillUtils.handleDurabilityChange(armor, durabilityDamage, Axes.impactMaxDurabilityModifier);
                 }
             }
         }
+    }
 
     /**
      * Handle the effects of the Greater Impact ability
@@ -106,7 +114,10 @@ public class AxesManager extends SkillManager {
      * @param target The {@link LivingEntity} being affected by the ability
      */
     public double greaterImpact(LivingEntity target) {
-        if (!(Axes.greaterImpactChance > Misc.getRandom().nextInt(getActivationChance()))) {
+        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;
         }
 

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

@@ -7,6 +7,7 @@ import org.bukkit.block.BlockState;
 
 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.skills.SkillManager;
@@ -27,7 +28,7 @@ public class ExcavationManager extends SkillManager {
     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()) {
@@ -35,7 +36,7 @@ public class ExcavationManager extends SkillManager {
                 Location location = blockState.getLocation();
 
                 for (ExcavationTreasure treasure : treasures) {
-                    if (skillLevel >= treasure.getDropLevel() && SkillUtils.treasureDropSuccessful(treasure.getDropChance(), activationChance)) {
+                    if (skillLevel >= treasure.getDropLevel() && SkillUtils.treasureDropSuccessful(getPlayer(), treasure.getDropChance(), activationChance)) {
                         xp += treasure.getXp();
                         Misc.dropItem(location, treasure.getDrop());
                     }

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;
@@ -74,11 +76,11 @@ public class FishingManager extends SkillManager {
     }
 
     public boolean canShake(Entity target) {
-        return target instanceof LivingEntity && getSkillLevel() >= Tier.ONE.getLevel() && Permissions.shake(getPlayer());
+        return target instanceof LivingEntity && getSkillLevel() >= Tier.ONE.getLevel() && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.SHAKE);
     }
 
     public boolean canMasterAngler() {
-        return getSkillLevel() >= AdvancedConfig.getInstance().getMasterAnglerUnlockLevel() && Permissions.masterAngler(getPlayer());
+        return getSkillLevel() >= AdvancedConfig.getInstance().getMasterAnglerUnlockLevel() && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.MASTER_ANGLER);
     }
 
     public boolean unleashTheKraken() {
@@ -205,7 +207,7 @@ public class FishingManager extends SkillManager {
 
         Player player = getPlayer();
 
-        if (!Permissions.iceFishing(player)) {
+        if (!Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.ICE_FISHING)) {
             return false;
         }
 
@@ -306,7 +308,7 @@ public class FishingManager extends SkillManager {
         Player player = getPlayer();
         FishingTreasure treasure = null;
 
-        if (Config.getInstance().getFishingDropsEnabled() && Permissions.fishingTreasureHunter(player)) {
+        if (Config.getInstance().getFishingDropsEnabled() && Permissions.secondaryAbilityEnabled(player, SecondaryAbility.FISHING_TREASURE_HUNTER)) {
             treasure = getFishingTreasure();
             this.fishingCatch = null;
         }
@@ -317,7 +319,7 @@ public class FishingManager extends SkillManager {
             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)) {
+            if (Permissions.secondaryAbilityEnabled(player, SecondaryAbility.MAGIC_HUNTER) && ItemUtils.isEnchantable(treasureDrop)) {
                 enchants = handleMagicHunter(treasureDrop);
             }
 
@@ -375,7 +377,9 @@ public class FishingManager extends SkillManager {
     public void shakeCheck(LivingEntity target) {
         fishingTries--; // Because autoclicking to shake is OK.
 
-        if (getShakeProbability() > Misc.getRandom().nextInt(getActivationChance())) {
+        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()) {
@@ -425,11 +429,11 @@ public class FishingManager extends SkillManager {
                     break;
             }
 
-            McMMOPlayerShakeEvent event = new McMMOPlayerShakeEvent(getPlayer(), drop);
+            McMMOPlayerShakeEvent shakeEvent = new McMMOPlayerShakeEvent(getPlayer(), drop);
 
-            drop = event.getDrop();
+            drop = shakeEvent.getDrop();
 
-            if (event.isCancelled() || drop == null) {
+            if (shakeEvent.isCancelled() || drop == null) {
                 return;
             }
 

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) {
@@ -140,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();
             }
         }
@@ -151,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();
             }
 
@@ -168,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);
                 }
@@ -183,7 +184,7 @@ public class HerbalismManager extends SkillManager {
      * @return true if the ability was successful, false otherwise
      */
     public boolean processGreenThumbBlocks(BlockState blockState) {
-        if (!SkillUtils.activationSuccessful(getSkillLevel(), getActivationChance(), Herbalism.greenThumbMaxChance, Herbalism.greenThumbMaxLevel)) {
+        if (!SkillUtils.activationSuccessful(SecondaryAbility.GREEN_THUMB_BLOCK, getPlayer(), getSkillLevel(), activationChance)) {
             getPlayer().sendMessage(LocaleLoader.getString("Herbalism.Ability.GTh.Fail"));
             return false;
         }
@@ -198,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;
         }
 
@@ -266,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;
         }
@@ -310,7 +311,7 @@ public class HerbalismManager extends SkillManager {
             return;
         }
 
-        if (!greenTerra && !SkillUtils.activationSuccessful(getSkillLevel(), getActivationChance(), Herbalism.greenThumbMaxChance, Herbalism.greenThumbMaxLevel)) {
+        if (!greenTerra && !SkillUtils.activationSuccessful(SecondaryAbility.GREEN_THUMB_PLANT, getPlayer(), getSkillLevel(), activationChance)) {
             return;
         }
 

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;
@@ -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() {
+    public boolean isSecondSmeltSuccessful() {
-        return Permissions.doubleDrops(getPlayer(), skill) && SkillUtils.activationSuccessful(getSkillLevel(), getActivationChance(), Mining.doubleDropsMaxChance, Mining.doubleDropsMaxLevel);
+        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,10 @@ 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;
@@ -26,11 +28,11 @@ public class SwordsManager extends SkillManager {
     }
 
     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() {
@@ -43,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 {
@@ -77,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;
         }
 

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;

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

@@ -2,14 +2,17 @@ package com.gmail.nossr50.skills.unarmed;
 
 import org.bukkit.Material;
 import org.bukkit.block.BlockState;
+import org.bukkit.entity.Item;
 import org.bukkit.entity.LivingEntity;
 import org.bukkit.entity.Player;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.material.MaterialData;
 import org.bukkit.material.SmoothBrick;
-
+import com.gmail.nossr50.mcMMO;
+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;
@@ -17,6 +20,7 @@ import com.gmail.nossr50.skills.SkillManager;
 import com.gmail.nossr50.util.EventUtils;
 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;
 
@@ -30,7 +34,7 @@ public class UnarmedManager extends SkillManager {
     }
 
     public boolean canUseIronArm() {
-        return Permissions.bonusDamage(getPlayer(), skill);
+        return Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.IRON_ARM);
     }
 
     public boolean canUseBerserk() {
@@ -38,17 +42,17 @@ public class UnarmedManager extends SkillManager {
     }
 
     public boolean canDisarm(LivingEntity target) {
-        return target instanceof Player && ((Player) target).getItemInHand().getType() != Material.AIR && Permissions.disarm(getPlayer());
+        return target instanceof Player && ((Player) target).getItemInHand().getType() != Material.AIR && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.DISARM);
     }
 
     public boolean canDeflect() {
         Player player = getPlayer();
 
-        return player.getItemInHand().getType() == Material.AIR && Permissions.arrowDeflect(player);
+        return player.getItemInHand().getType() == Material.AIR && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.DEFLECT);
     }
 
     public boolean canUseBlockCracker() {
-        return Permissions.blockCracker(getPlayer());
+        return Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.BLOCK_CRACKER);
     }
 
     public boolean blockCrackerCheck(BlockState blockState) {
@@ -81,12 +85,16 @@ public class UnarmedManager extends SkillManager {
      * @param defender The defending player
      */
     public void disarmCheck(Player defender) {
-        if (SkillUtils.activationSuccessful(getSkillLevel(), getActivationChance(), Unarmed.disarmMaxChance, Unarmed.disarmMaxBonusLevel) && !hasIronGrip(defender)) {
+        if (SkillUtils.activationSuccessful(SecondaryAbility.DISARM, getPlayer(), getSkillLevel(), activationChance) && !hasIronGrip(defender)) {
             if (EventUtils.callDisarmEvent(defender).isCancelled()) {
                 return;
             }
 
-            Misc.dropItem(defender.getLocation(), defender.getItemInHand());
+            Item item = Misc.dropItem(defender.getLocation(), defender.getItemInHand());
+
+            if (item != null && AdvancedConfig.getInstance().getDisarmProtected()) {
+                item.setMetadata(mcMMO.disarmedItemKey, UserManager.getPlayer(defender).getPlayerMetadata());
+            }
 
             defender.setItemInHand(new ItemStack(Material.AIR));
             defender.sendMessage(LocaleLoader.getString("Skills.Disarmed"));
@@ -97,7 +105,7 @@ public class UnarmedManager extends SkillManager {
      * Check for arrow deflection.
      */
     public boolean deflectCheck() {
-        if (SkillUtils.activationSuccessful(getSkillLevel(), getActivationChance(), Unarmed.deflectMaxChance, Unarmed.deflectMaxBonusLevel)) {
+        if (SkillUtils.activationSuccessful(SecondaryAbility.DEFLECT, getPlayer(), getSkillLevel(), activationChance)) {
             getPlayer().sendMessage(LocaleLoader.getString("Combat.ArrowDeflect"));
             return true;
         }
@@ -135,7 +143,7 @@ public class UnarmedManager extends SkillManager {
      * @return true if the defender was not disarmed, false otherwise
      */
     private boolean hasIronGrip(Player defender) {
-        if (!Misc.isNPCEntity(defender) && Permissions.ironGrip(defender) && SkillUtils.activationSuccessful(defender, skill, Unarmed.ironGripMaxChance, Unarmed.ironGripMaxBonusLevel)) {
+        if (!Misc.isNPCEntity(defender) && Permissions.secondaryAbilityEnabled(defender, SecondaryAbility.IRON_GRIP) && SkillUtils.activationSuccessful(SecondaryAbility.IRON_GRIP, defender, skill)) {
             defender.sendMessage(LocaleLoader.getString("Unarmed.Ability.IronGrip.Defender"));
             getPlayer().sendMessage(LocaleLoader.getString("Unarmed.Ability.IronGrip.Attacker"));
 

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

@@ -5,6 +5,7 @@ import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Set;
 
+import org.bukkit.Material;
 import org.bukkit.block.BlockFace;
 import org.bukkit.block.BlockState;
 import org.bukkit.inventory.ItemStack;
@@ -20,9 +21,6 @@ import com.gmail.nossr50.util.ModUtils;
 import com.gmail.nossr50.util.skills.SkillUtils;
 
 public final class Woodcutting {
-    public static int    doubleDropsMaxLevel  = AdvancedConfig.getInstance().getWoodcuttingDoubleDropMaxLevel();
-    public static double doubleDropsMaxChance = AdvancedConfig.getInstance().getWoodcuttingDoubleDropChance();
-
     public static int leafBlowerUnlockLevel = AdvancedConfig.getInstance().getLeafBlowUnlockLevel();
     public static int treeFellerThreshold = Config.getInstance().getTreeFellerThreshold();
 
@@ -165,7 +163,7 @@ public final class Woodcutting {
      * once the JIT has optimized the function (use the ability about 4 times
      * before taking measurements).
      */
-    protected static void processTree(BlockState blockState, LinkedHashSet<BlockState> treeFellerBlocks) {
+    protected static void processTree(BlockState blockState, Set<BlockState> treeFellerBlocks) {
         List<BlockState> futureCenterBlocks = new ArrayList<BlockState>();
 
         // Check the block up and take different behavior (smaller search) if it's a log
@@ -212,6 +210,7 @@ public final class Woodcutting {
      */
     protected static boolean handleDurabilityLoss(Set<BlockState> treeFellerBlocks, ItemStack inHand) {
         short durabilityLoss = 0;
+        Material type = inHand.getType();
 
         for (BlockState blockState : treeFellerBlocks) {
             if (BlockUtils.isLog(blockState)) {
@@ -220,7 +219,7 @@ public final class Woodcutting {
         }
 
         SkillUtils.handleDurabilityChange(inHand, durabilityLoss);
-        return (inHand.getDurability() < inHand.getType().getMaxDurability());
+        return (inHand.getDurability() < (mcMMO.getRepairableManager().isRepairable(type) ? mcMMO.getRepairableManager().getRepairable(type).getMaximumDurability() : type.getMaxDurability()));
     }
 
     /**
@@ -240,11 +239,11 @@ public final class Woodcutting {
             return false;
         }
 
+        // Without this check Tree Feller propagates through leaves until the threshold is hit
         if (treeFellerBlocks.size() > treeFellerThreshold) {
             treeFellerReachedThreshold = true;
         }
 
-        // Without this check Tree Feller propagates through leaves until the threshold is hit
         if (BlockUtils.isLog(blockState)) {
             treeFellerBlocks.add(blockState);
             futureCenterBlocks.add(blockState);

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

@@ -1,6 +1,6 @@
 package com.gmail.nossr50.skills.woodcutting;
 
-import java.util.LinkedHashSet;
+import java.util.HashSet;
 import java.util.Set;
 
 import org.bukkit.Material;
@@ -14,6 +14,7 @@ import org.bukkit.material.Tree;
 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.locale.LocaleLoader;
 import com.gmail.nossr50.skills.SkillManager;
@@ -32,7 +33,7 @@ public class WoodcuttingManager extends SkillManager {
     }
 
     public boolean canUseLeafBlower(ItemStack heldItem) {
-        return getSkillLevel() >= Woodcutting.leafBlowerUnlockLevel && ItemUtils.isAxe(heldItem);
+        return Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.LEAF_BLOWER) && getSkillLevel() >= Woodcutting.leafBlowerUnlockLevel && ItemUtils.isAxe(heldItem);
     }
 
     public boolean canUseTreeFeller(ItemStack heldItem) {
@@ -40,7 +41,7 @@ public class WoodcuttingManager extends SkillManager {
     }
 
     protected boolean canGetDoubleDrops() {
-        return Permissions.doubleDrops(getPlayer(), skill) && SkillUtils.activationSuccessful(getSkillLevel(), getActivationChance(), Woodcutting.doubleDropsMaxChance, Woodcutting.doubleDropsMaxLevel);
+        return Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.WOODCUTTING_DOUBLE_DROPS) && SkillUtils.activationSuccessful(SecondaryAbility.WOODCUTTING_DOUBLE_DROPS, getPlayer(), getSkillLevel(), activationChance);
     }
 
     /**
@@ -72,7 +73,7 @@ public class WoodcuttingManager extends SkillManager {
      */
     public void processTreeFeller(BlockState blockState) {
         Player player = getPlayer();
-        LinkedHashSet<BlockState> treeFellerBlocks = new LinkedHashSet<BlockState>();
+        Set<BlockState> treeFellerBlocks = new HashSet<BlockState>();
 
         Woodcutting.treeFellerReachedThreshold = false;
 
@@ -152,7 +153,7 @@ public class WoodcuttingManager extends SkillManager {
                         break;
 
                     case LEAVES:
-                        Misc.randomDropItems(blockState.getLocation(), block.getDrops(), 10.0);
+                        Misc.dropItems(blockState.getLocation(), block.getDrops());
                         break;
 
                     default:

src/main/java/com/gmail/nossr50/util/HardcoreManager.java

@@ -22,6 +22,10 @@ public final class HardcoreManager {
         int totalLevelsLost = 0;
 
         for (SkillType skillType : SkillType.NON_CHILD_SKILLS) {
+            if (!skillType.getHardcoreStatLossEnabled()) {
+                break;
+            }
+
             int playerSkillLevel = playerProfile.getSkillLevel(skillType);
             int playerSkillXpLevel = playerProfile.getSkillXpLevel(skillType);
 
@@ -54,6 +58,10 @@ public final class HardcoreManager {
         int totalLevelsStolen = 0;
 
         for (SkillType skillType : SkillType.NON_CHILD_SKILLS) {
+            if (!skillType.getHardcoreVampirismEnabled()) {
+                break;
+            }
+
             int killerSkillLevel = killerProfile.getSkillLevel(skillType);
             int victimSkillLevel = victimProfile.getSkillLevel(skillType);
 

src/main/java/com/gmail/nossr50/util/Misc.java

@@ -14,6 +14,7 @@ import org.bukkit.block.BlockState;
 import org.bukkit.block.Furnace;
 import org.bukkit.entity.Entity;
 import org.bukkit.entity.HumanEntity;
+import org.bukkit.entity.Item;
 import org.bukkit.entity.NPC;
 import org.bukkit.entity.Player;
 import org.bukkit.event.inventory.InventoryEvent;
@@ -172,10 +173,11 @@ public final class Misc {
      *
      * @param location The location to drop the item at
      * @param itemStack The item to drop
+     * @return Dropped Item entity or null if invalid or cancelled
      */
-    public static void dropItem(Location location, ItemStack itemStack) {
+    public static Item dropItem(Location location, ItemStack itemStack) {
         if (itemStack.getType() == Material.AIR) {
-            return;
+            return null;
         }
 
         // We can't get the item until we spawn it and we want to make it cancellable, so we have a custom event.
@@ -183,10 +185,10 @@ public final class Misc {
         mcMMO.p.getServer().getPluginManager().callEvent(event);
 
         if (event.isCancelled()) {
-            return;
+            return null;
         }
 
-        location.getWorld().dropItemNaturally(location, itemStack);
+        return location.getWorld().dropItemNaturally(location, itemStack);
     }
 
     public static void profileCleanup(String playerName) {
@@ -201,7 +203,7 @@ public final class Misc {
 
     public static void printProgress(int convertedUsers, int progressInterval, long startMillis) {
         if ((convertedUsers % progressInterval) == 0) {
-            mcMMO.p.getLogger().info(String.format("Conversion progress: %d users at %.2f users/second", convertedUsers, convertedUsers / ((System.currentTimeMillis() - startMillis) / TIME_CONVERSION_FACTOR)));
+            mcMMO.p.getLogger().info(String.format("Conversion progress: %d users at %.2f users/second", convertedUsers, convertedUsers / (double) ((System.currentTimeMillis() - startMillis) / TIME_CONVERSION_FACTOR)));
         }
     }
 

src/main/java/com/gmail/nossr50/util/Permissions.java

@@ -11,6 +11,7 @@ import org.bukkit.plugin.PluginManager;
 
 import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.commands.party.PartySubcommandType;
+import com.gmail.nossr50.datatypes.skills.SecondaryAbility;
 import com.gmail.nossr50.datatypes.skills.SkillType;
 
 public final class Permissions {
@@ -123,44 +124,19 @@ public final class Permissions {
      */
 
     public static boolean skillEnabled(Permissible permissible, SkillType skill) {return permissible.hasPermission("mcmmo.skills." + skill.toString().toLowerCase()); }
-    public static boolean doubleDrops(Permissible permissible, SkillType skill) { return permissible.hasPermission("mcmmo.ability." + skill.toString().toLowerCase() + ".doubledrops"); }
     public static boolean vanillaXpBoost(Permissible permissible, SkillType skill) { return permissible.hasPermission("mcmmo.ability." + skill.toString().toLowerCase() + ".vanillaxpboost"); }
-    public static boolean bonusDamage(Permissible permissible, SkillType skill) { return permissible.hasPermission("mcmmo.ability." + skill.toString().toLowerCase() + ".bonusdamage"); }
+    public static boolean secondaryAbilityEnabled(Permissible permissible, SecondaryAbility skillAbility) { return permissible.hasPermission("mcmmo.ability." + SkillType.bySecondaryAbility(skillAbility).toString().toLowerCase() + "." + StringUtils.getPrettySecondaryAbilityString(skillAbility).replace(" ", "").toLowerCase()); }
-
-    /* ACROBATICS */
-    public static boolean dodge(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.acrobatics.dodge"); }
-    public static boolean gracefulRoll(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.acrobatics.gracefulroll"); }
-    public static boolean roll(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.acrobatics.roll"); }
-
-    /* ARCHERY */
-    public static boolean arrowRetrieval(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.archery.trackarrows"); }
-    public static boolean daze(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.archery.daze"); }
 
     /* AXES */
-    public static boolean armorImpact(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.axes.impact"); }
-    public static boolean criticalStrikes(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.axes.criticalhit"); }
-    public static boolean greaterImpact(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.axes.greaterimpact"); }
     public static boolean skullSplitter(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.axes.skullsplitter"); }
 
     /* EXCAVATION */
     public static boolean gigaDrillBreaker(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.excavation.gigadrillbreaker"); }
-    public static boolean excavationTreasureHunter(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.excavation.treasures"); }
-
-    /* FISHING */
-    public static boolean fishermansDiet(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.fishing.fishermansdiet"); }
-    public static boolean fishingTreasureHunter(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.fishing.treasures"); }
-    public static boolean iceFishing(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.fishing.icefishing"); }
-    public static boolean magicHunter(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.fishing.magic"); }
-    public static boolean masterAngler(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.fishing.masterangler"); }
-    public static boolean shake(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.fishing.shakemob"); }
 
     /* HERBALISM */
-    public static boolean farmersDiet(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.herbalism.farmersdiet"); }
     public static boolean greenTerra(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.herbalism.greenterra"); }
     public static boolean greenThumbBlock(Permissible permissible, Material material) { return permissible.hasPermission("mcmmo.ability.herbalism.greenthumb.blocks." + material.toString().replace("_", "").toLowerCase()); }
     public static boolean greenThumbPlant(Permissible permissible, Material material) { return permissible.hasPermission("mcmmo.ability.herbalism.greenthumb.plants." + material.toString().replace("_", "").toLowerCase()); }
-    public static boolean hylianLuck(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.herbalism.hylianluck"); }
-    public static boolean shroomThumb(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.herbalism.shroomthumb"); }
 
     /* MINING */
     public static boolean biggerBombs(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.mining.blastmining.biggerbombs"); }
@@ -169,11 +145,6 @@ public final class Permissions {
     public static boolean superBreaker(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.mining.superbreaker"); }
 
     /* REPAIR */
-    public static boolean arcaneForging(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.repair.arcaneforging"); }
-    public static boolean repairMastery(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.repair.repairmastery"); }
-    public static boolean salvage(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.repair.salvage"); }
-    public static boolean superRepair(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.repair.repairbonus"); }
-
     public static boolean repairArmor(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.repair.armorrepair"); }
     public static boolean repairTools(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.repair.toolrepair"); }
     public static boolean repairOtherItems(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.repair.otherrepair"); }
@@ -187,36 +158,16 @@ public final class Permissions {
     public static boolean repairStone(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.repair.stonerepair"); }
     public static boolean repairWood(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.repair.woodrepair"); }
 
-    /* SMELTING */
-    public static boolean fluxMining(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.smelting.fluxmining"); }
-    public static boolean fuelEfficiency(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.smelting.fuelefficiency"); }
-
     /* SWORDS */
-    public static boolean bleed(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.swords.bleed"); }
-    public static boolean counterAttack(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.swords.counterattack"); }
     public static boolean serratedStrikes(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.swords.serratedstrikes"); }
 
     /* TAMING */
-    public static boolean beastLore(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.taming.beastlore"); }
     public static boolean callOfTheWild(Permissible permissible, EntityType type) { return permissible.hasPermission("mcmmo.ability.taming.callofthewild." + type.toString().toLowerCase()); }
     public static boolean renamePets(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.taming.callofthewild.renamepets"); }
-    public static boolean environmentallyAware(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.taming.environmentallyaware"); }
-    public static boolean fastFoodService(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.taming.fastfoodservice"); }
-    public static boolean gore(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.taming.gore"); }
-    public static boolean holyHound(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.taming.holyhound"); }
-    public static boolean thickFur(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.taming.thickfur"); }
-    public static boolean sharpenedClaws(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.taming.sharpenedclaws"); }
-    public static boolean shockProof(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.taming.shockproof"); }
-
     /* UNARMED */
-    public static boolean arrowDeflect(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.unarmed.deflect"); }
     public static boolean berserk(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.unarmed.berserk"); }
-    public static boolean blockCracker(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.unarmed.blockcracker"); }
-    public static boolean disarm(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.unarmed.disarm"); }
-    public static boolean ironGrip(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.unarmed.irongrip"); }
 
     /* WOODCUTTING */
-    public static boolean leafBlower(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.woodcutting.leafblower"); }
     public static boolean treeFeller(Permissible permissible) { return permissible.hasPermission("mcmmo.ability.woodcutting.treefeller"); }
 
     /*

src/main/java/com/gmail/nossr50/util/StringUtils.java

@@ -4,6 +4,7 @@ import org.bukkit.Material;
 import org.bukkit.entity.EntityType;
 
 import com.gmail.nossr50.datatypes.skills.AbilityType;
+import com.gmail.nossr50.datatypes.skills.SecondaryAbility;
 
 public class StringUtils {
     /**
@@ -28,6 +29,23 @@ public class StringUtils {
         return createPrettyEnumString(ability.toString());
     }
 
+    public static String getPrettySecondaryAbilityString(SecondaryAbility secondaryAbility) {
+        switch(secondaryAbility) {
+            case HERBALISM_DOUBLE_DROPS:
+            case MINING_DOUBLE_DROPS:
+            case WOODCUTTING_DOUBLE_DROPS:
+                return "Double Drops";
+            case FISHING_TREASURE_HUNTER:
+            case EXCAVATION_TREASURE_HUNTER:
+                return "Treasure Hunter";
+            case GREEN_THUMB_BLOCK:
+            case GREEN_THUMB_PLANT:
+                return "Green Thumb";
+            default:
+                return createPrettyEnumString(secondaryAbility.toString());
+        }
+    }
+
     private static String createPrettyEnumString(String baseString) {
         String[] substrings = baseString.split("_");
         String prettyString = "";

src/main/java/com/gmail/nossr50/util/commands/CommandUtils.java

@@ -134,7 +134,7 @@ public final class CommandUtils {
     }
 
     public static boolean isInvalidSkill(CommandSender sender, String skillName) {
-        if (skillName.equalsIgnoreCase("all") || SkillUtils.isSkill(skillName)) {
+        if (SkillUtils.isSkill(skillName)) {
             return false;
         }
 

src/main/java/com/gmail/nossr50/util/scoreboards/ScoreboardManager.java

@@ -106,7 +106,7 @@ public class ScoreboardManager {
             }
         }
 
-        for (AbilityType type : AbilityType.NORMAL_ABILITIES) {
+        for (AbilityType type : AbilityType.values()) {
             abilityLabelSkillBuilder.put(type, getOfflinePlayerDots((type == AbilityType.BLAST_MINING ? ChatColor.BLUE : ChatColor.AQUA) + type.getName()));
         }
 

src/main/java/com/gmail/nossr50/util/scoreboards/ScoreboardWrapper.java

@@ -456,7 +456,7 @@ public class ScoreboardWrapper {
         case COOLDOWNS_BOARD:
             boolean anyCooldownsActive = false;
 
-            for (AbilityType ability : AbilityType.NORMAL_ABILITIES) {
+            for (AbilityType ability : AbilityType.values()) {
                 int seconds = Math.max(mcMMOPlayer.calculateTimeRemaining(ability), 0);
 
                 if (seconds != 0) {

src/main/java/com/gmail/nossr50/util/skills/CombatUtils.java

@@ -176,8 +176,8 @@ public final class CombatUtils {
             finalDamage += archeryManager.daze((Player) target, arrow);
         }
 
-        if (!arrow.hasMetadata(mcMMO.infiniteArrowKey) && archeryManager.canTrackArrows()) {
+        if (!arrow.hasMetadata(mcMMO.infiniteArrowKey) && archeryManager.canRetrieveArrows()) {
-            archeryManager.trackArrows(target);
+            archeryManager.retrieveArrows(target);
         }
 
         archeryManager.distanceXpBonus(target, arrow);

src/main/java/com/gmail/nossr50/util/skills/PerksUtils.java

@@ -16,7 +16,7 @@ public final class PerksUtils {
             cooldown *= 0.5;
         }
         else if (Permissions.thirdedCooldowns(player)) {
-            cooldown *= (1.0 / 3.0);
+            cooldown *= (2.0 / 3.0);
         }
         else if (Permissions.quarteredCooldowns(player)) {
             cooldown *= 0.75;

src/main/java/com/gmail/nossr50/util/skills/SkillUtils.java

@@ -18,7 +18,9 @@ import com.gmail.nossr50.config.Config;
 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.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.util.ItemUtils;
 import com.gmail.nossr50.util.Misc;
@@ -187,16 +189,25 @@ public class SkillUtils {
         itemStack.setDurability((short) Math.min(itemStack.getDurability() + durabilityModifier, maxDurability));
     }
 
-    public static boolean activationSuccessful(Player player, SkillType skill, double maxChance, int maxLevel) {
+    public static boolean activationSuccessful(SecondaryAbility skillAbility, Player player, SkillType skill) {
-        return activationSuccessful(UserManager.getPlayer(player).getSkillLevel(skill), PerksUtils.handleLuckyPerks(player, skill), maxChance, maxLevel);
+        return activationSuccessful(skillAbility, player, UserManager.getPlayer(player).getSkillLevel(skill), PerksUtils.handleLuckyPerks(player, skill));
     }
 
-    public static boolean activationSuccessful(int skillLevel, int activationChance, double maxChance, int maxLevel) {
+    public static boolean activationSuccessful(SecondaryAbility skillAbility, Player player, int skillLevel, int activationChance) {
-        return (maxChance / maxLevel) * Math.min(skillLevel, maxLevel) > Misc.getRandom().nextInt(activationChance);
+        return activationSuccessful(skillAbility, player, skillLevel, activationChance, AdvancedConfig.getInstance().getMaxChance(skillAbility), AdvancedConfig.getInstance().getMaxBonusLevel(skillAbility));
     }
 
-    public static boolean treasureDropSuccessful(double dropChance, int activationChance) {
+    public static boolean activationSuccessful(SecondaryAbility skillAbility, Player player, int skillLevel, int activationChance, double maxChance, int maxLevel) {
-        return dropChance > Misc.getRandom().nextDouble() * activationChance;
+        double chance = (maxChance / maxLevel) * Math.min(skillLevel, maxLevel) / activationChance;
+        SecondaryAbilityWeightedActivationCheckEvent event = new SecondaryAbilityWeightedActivationCheckEvent(player, skillAbility, chance);
+        mcMMO.p.getServer().getPluginManager().callEvent(event);
+        return (event.getChance() * activationChance) > Misc.getRandom().nextInt(activationChance);
+    }
+
+    public static boolean treasureDropSuccessful(Player player, double dropChance, int activationChance) {;
+        SecondaryAbilityWeightedActivationCheckEvent event = new SecondaryAbilityWeightedActivationCheckEvent(player, SecondaryAbility.EXCAVATION_TREASURE_HUNTER, dropChance / activationChance);
+        mcMMO.p.getServer().getPluginManager().callEvent(event);
+        return (event.getChance() * activationChance) > (Misc.getRandom().nextDouble() * activationChance);
     }
 
     private static boolean isLocalizedSkill(String skillName) {

src/main/resources/advanced.yml

@@ -80,19 +80,17 @@ Skills:
     #  Settings for Axes
     ###
     Axes:
-        DamageIncrease:
+        AxeMastery:
             # MaxBonus: Maximum bonus damage when on <MaxBonusLevel> or higher
             # MaxBonusLevel: Level where <MaxBonus> is reached
             MaxBonus: 4.0
             MaxBonusLevel: 200
 
-        AxesCritical:
+        CriticalHit:
             # ChanceMax: Maximum chance of causing a critical hit when on <MaxBonusLevel> or higher
             # MaxBonusLevel: Level where <ChanceMax> of causing critical hits is reached
             ChanceMax: 37.50
             MaxBonusLevel: 750
-
-        AxesCritical:
             # Damage modifier of critical hits for PVP / PVE, when causing a critical hit the damage gets multiplied by the modifier
             PVP_Modifier: 1.5
             PVE_Modifier: 2.0
@@ -458,8 +456,10 @@ Skills:
         Disarm:
             # ChanceMax: Maximum chance of disarming other players
             # MaxBonusLevel: Level when the maximum chance to disarm is reached
+            # AntiTheft: Determines if only the disarmed player can retrieve disarmed items
             ChanceMax: 33.0
             MaxBonusLevel: 1000
+            AntiTheft: false
 
         Deflect:
             # ChanceMax: Maximum chance of deflecting arrows

src/main/resources/config.yml

@@ -375,12 +375,12 @@ Commands:
     partychat:
         Chat_Prefix_Format: '[[GREEN]]([[WHITE]]{0}[[GREEN]])'
 
-        # Allow mcMMO to use player display names in chat instead of their usernames
+        # Allow mcMMO to use player display names in party chat instead of their usernames
         Use_Display_Names: true
     adminchat:
         Chat_Prefix_Format: '[[AQUA]][[[WHITE]]{0}[[AQUA]]]'
 
-        # Allow mcMMO to use player display names in chat instead of their usernames
+        # Allow mcMMO to use player display names in admin chat instead of their usernames
         Use_Display_Names: true
 
 #

src/main/resources/locale/locale_en_US.properties

@@ -162,7 +162,7 @@ Herbalism.Effect.13=Spread mycelium to dirt & grass
 Herbalism.HylianLuck=[[GREEN]]The luck of Hyrule is with you today!
 Herbalism.Listener=Herbalism: 
 Herbalism.SkillName=HERBALISM
-Herbalism.Skills.GTe[[RED]]**Green Terra has worn off**
+Herbalism.Skills.GTe.Off=[[RED]]**Green Terra has worn off**
 Herbalism.Skills.GTe.On=[[GREEN]]**GREEN TERRA ACTIVATED**
 Herbalism.Skills.GTe.Refresh=[[GREEN]]Your [[YELLOW]]Green Terra [[GREEN]]ability is refreshed!
 Herbalism.Skills.GTe.Other.Off=[[RED]]Green Terra[[GREEN]] has worn off for [[YELLOW]]{0}
@@ -518,7 +518,7 @@ Commands.Reset=[[RED]]Reset a skill's level to 0
 Commands.Scoreboard.Clear=[[DARK_AQUA]]mcMMO scoreboard cleared.
 Commands.Scoreboard.NoBoard=[[RED]]The mcMMO scoreboard is not active.
 Commands.Scoreboard.Keep=[[DARK_AQUA]]The mcMMO scoreboard will stay up until you use [[GREEN]]/mcscoreboard clear[[DARK_AQUA]].
-Commands.Scoreboard.Timer=[[DARK_AQUA]]The mcMMO scoreboard will clear [[GOLD]]{1}[[DARK_AQUA]] seconds from now.
+Commands.Scoreboard.Timer=[[DARK_AQUA]]The mcMMO scoreboard will clear [[GOLD]]{0}[[DARK_AQUA]] seconds from now.
 Commands.Scoreboard.Help.0=[[GOLD]] == [[GREEN]]Help for [[RED]]/mcscoreboard[[GOLD]] == 
 Commands.Scoreboard.Help.1=[[DARK_AQUA]]/mcscoreboard[[AQUA]] clear [[WHITE]] - clear the McMMO scoreboard
 Commands.Scoreboard.Help.2=[[DARK_AQUA]]/mcscoreboard[[AQUA]] keep [[WHITE]] - keep the mcMMO scoreboard up

src/main/resources/locale/locale_ko.properties

@@ -464,7 +464,7 @@ Commands.Reset=[[RED]]\uc2a4\ud0ac \ub808\ubca8\uc744 0\uc73c\ub85c \ucd08\uae30
 Commands.Scoreboard.Clear=[[DARK_AQUA]]mcMMO \uc810\uc218\ud310 \uccad\uc18c\ub428.
 Commands.Scoreboard.NoBoard=[[RED]]mcMMO \uc810\uc218\ud310\uc740 \ud65c\uc131\ub418\uc788\uc9c0 \uc54a\uc74c.
 Commands.Scoreboard.Keep=[[DARK_AQUA]]mcMMO \uc810\uc218\ud310\uc740 \ub2f9\uc2e0\uc774 [[GREEN]]/mcscoreboard clear[[DARK_AQUA]]\ub97c \uc0ac\uc6a9\ud560 \ub54c\uae4c\uc9c0 \uc720\uc9c0\ub420 \uac83\uc784.
-Commands.Scoreboard.Timer=[[DARK_AQUA]]mcMMO \uc810\uc218\ud310\uc740 \uc9c0\uae08\uc73c\ub85c\ubd80\ud130 [[GOLD]]{1}[[DARK_AQUA]]\ucd08 \ub0b4\uc5d0 \uccad\uc18c\ub420 \uc608\uc815\uc784.
+Commands.Scoreboard.Timer=[[DARK_AQUA]]mcMMO \uc810\uc218\ud310\uc740 \uc9c0\uae08\uc73c\ub85c\ubd80\ud130 [[GOLD]]{0}[[DARK_AQUA]]\ucd08 \ub0b4\uc5d0 \uccad\uc18c\ub420 \uc608\uc815\uc784.
 Commands.Scoreboard.Help.0=[[GOLD]] == [[RED]]/mcscoreboard [[GREEN]]\ub3c4\uc6c0\ub9d0[[GOLD]] ==
 Commands.Scoreboard.Help.1=[[DARK_AQUA]]/mcscoreboard[[AQUA]] clear [[WHITE]] - McMMO \uc810\uc218\ud310\uc744 \uccad\uc18c\ud568
 Commands.Scoreboard.Help.2=[[DARK_AQUA]]/mcscoreboard[[AQUA]] keep [[WHITE]] - McMMO \uc810\uc218\ud310\uc744 \uc720\uc9c0\ud568

src/main/resources/locale/locale_pt_BR.properties

@@ -145,7 +145,7 @@ Commands.PowerLevel=[[DARK_RED]]N\u00cdVEL DE PODER: [[GREEN]]{0}
 Commands.Scoreboard.Clear=[[DARK_AQUA]]mcMMO scoreboard sumiu.
 Commands.Scoreboard.NoBoard=[[RED]]The mcMMO scoreboard nao esta ativo.
 Commands.Scoreboard.Keep=[[DARK_AQUA]]O mcMMO scoreboard vai estar visivel ate voce usar [[GREEN]]/mcscoreboard clear[[DARK_AQUA]].
-Commands.Scoreboard.Timer=[[DARK_AQUA]]O mcMMO scoreboard vai sumir em [[GOLD]]{1}[[DARK_AQUA]] segundos.
+Commands.Scoreboard.Timer=[[DARK_AQUA]]O mcMMO scoreboard vai sumir em [[GOLD]]{0}[[DARK_AQUA]] segundos.
 Commands.Scoreboard.Help.0=[[GOLD]] == [[GREEN]]Ajuda para [[RED]]/mcscoreboard[[GOLD]] ==
 Commands.Scoreboard.Help.1=[[DARK_AQUA]]/mcscoreboard[[AQUA]] clear [[WHITE]] - oculta o McMMO scoreboard
 Commands.Scoreboard.Help.2=[[DARK_AQUA]]/mcscoreboard[[AQUA]] keep [[WHITE]] - mantem o McMMO scoreboard visivel

src/main/resources/locale/locale_ru.properties

@@ -465,7 +465,7 @@ Commands.Reset=[[RED]]\u0421\u0431\u0440\u043e\u0441 \u0443\u0440\u043e\u0432\u0
 Commands.Scoreboard.Clear=[[DARK_AQUA]]\u0422\u0430\u0431\u043b\u0438\u0446\u0430 \u0440\u0435\u0437\u0443\u043b\u044c\u0442\u0430\u0442\u043e\u0432 mcMMO \u0443\u0431\u0440\u0430\u043d\u0430.
 Commands.Scoreboard.NoBoard=[[RED]]\u0422\u0430\u0431\u043b\u0438\u0446\u0430 \u0440\u0435\u0437\u0443\u043b\u044c\u0442\u0430\u0442\u043e\u0432 mcMMO \u043d\u0435 \u0430\u043a\u0442\u0438\u0432\u043d\u0430.
 Commands.Scoreboard.Keep=[[DARK_AQUA]]\u0422\u0430\u0431\u043b\u0438\u0446\u0430 \u0440\u0435\u0437\u0443\u043b\u044c\u0442\u0430\u0442\u043e\u0432 mcMMO \u0431\u0443\u0434\u0435\u0442 \u043e\u0442\u043e\u0431\u0440\u0430\u0436\u0430\u0442\u044c\u0441\u044f \u0434\u043e \u0442\u0435\u0445 \u043f\u043e\u0440 \u043f\u043e\u043a\u0430 \u0432\u044b \u043d\u0435 \u0438\u0441\u043f\u043e\u043b\u044c\u0437\u0443\u0435\u0442\u0435 [[GREEN]]/mcscoreboard clear[[DARK_AQUA]].
-Commands.Scoreboard.Timer=[[DARK_AQUA]]\u0422\u0430\u0431\u043b\u0438\u0446\u0430 \u0440\u0435\u0437\u0443\u043b\u044c\u0442\u0430\u0442\u043e\u0432 mcMMO \u0438\u0441\u0447\u0435\u0437\u043d\u0435\u0442 \u0447\u0435\u0440\u0435\u0437 [[GOLD]]{1}[[DARK_AQUA]] \u0441\u0435\u043a\u0443\u043d\u0434.
+Commands.Scoreboard.Timer=[[DARK_AQUA]]\u0422\u0430\u0431\u043b\u0438\u0446\u0430 \u0440\u0435\u0437\u0443\u043b\u044c\u0442\u0430\u0442\u043e\u0432 mcMMO \u0438\u0441\u0447\u0435\u0437\u043d\u0435\u0442 \u0447\u0435\u0440\u0435\u0437 [[GOLD]]{0}[[DARK_AQUA]] \u0441\u0435\u043a\u0443\u043d\u0434.
 Commands.Scoreboard.Help.0=[[GOLD]] == [[GREEN]]\u041f\u043e\u043c\u043e\u0449\u044c \u043f\u043e [[RED]]/mcscoreboard[[GOLD]] ==
 Commands.Scoreboard.Help.1=[[DARK_AQUA]]/mcscoreboard[[AQUA]] clear [[WHITE]] - \u0443\u0431\u0440\u0430\u0442\u044c \u0442\u0430\u0431\u043b\u0438\u0446\u0443 \u0440\u0435\u0437\u0443\u043b\u044c\u0442\u0430\u0442\u043e\u0432 McMMO
 Commands.Scoreboard.Help.2=[[DARK_AQUA]]/mcscoreboard[[AQUA]] keep [[WHITE]] - \u043f\u043e\u0441\u0442\u043e\u044f\u043d\u043d\u043e \u043e\u0442\u043e\u0431\u0440\u0430\u0436\u0430\u0442\u044c \u0442\u0430\u0431\u043b\u0438\u0446\u0443 \u0440\u0435\u0437\u0443\u043b\u044c\u0442\u0430\u0442\u043e\u0432 mcMMO

src/main/resources/locale/locale_zh_TW.properties

@@ -465,7 +465,7 @@ Commands.Reset=[[RED]]\u8a2d\u5b9a\u6280\u80fd\u7b49\u7d1a\u70ba0
 Commands.Scoreboard.Clear=[[DARK_AQUA]]\u5df2\u6e05\u9664 mcMMO \u5f97\u5206\u699c.
 Commands.Scoreboard.NoBoard=[[RED]]mcMMO \u5f97\u5206\u699c\u4e26\u672a\u555f\u7528.
 Commands.Scoreboard.Keep=[[DARK_AQUA]]mcMMO \u5f97\u5206\u699c\u6703\u6301\u7e8c\u986f\u793a\u76f4\u5230\u4f60\u8f38\u5165 [[GREEN]]/mcscoreboard clear[[DARK_AQUA]].
-Commands.Scoreboard.Timer=[[DARK_AQUA]]mcMMO \u5f97\u5206\u699c\u5c07\u5728 [[GOLD]]{1}[[DARK_AQUA]] \u79d2\u540e\u6e05\u9664.
+Commands.Scoreboard.Timer=[[DARK_AQUA]]mcMMO \u5f97\u5206\u699c\u5c07\u5728 [[GOLD]]{0}[[DARK_AQUA]] \u79d2\u540e\u6e05\u9664.
 Commands.Scoreboard.Help.0=[[GOLD]] == [[RED]]/mcscoreboard [[GREEN]]\u8aaa\u660e [[GOLD]]==
 Commands.Scoreboard.Help.1=[[DARK_AQUA]]/mcscoreboard[[AQUA]] clear [[WHITE]] - \u6e05\u9664 McMMO \u5f97\u5206\u699c
 Commands.Scoreboard.Help.2=[[DARK_AQUA]]/mcscoreboard[[AQUA]] keep [[WHITE]] - \u6301\u7e8c\u986f\u793a mcMMO \u5f97\u5206\u699c

src/main/resources/plugin.yml

@@ -107,6 +107,7 @@ commands:
         aliases: [mcmobhealth]
         description: Change the style of the mob healthbar
     mcscoreboard:
+        aliases: [mcsb]
         description: Manage your mcMMO Scoreboard
     kraken:
         aliases: [mckraken]
@@ -175,14 +176,14 @@ permissions:
     mcmmo.ability.archery.all:
         description: Allows access to all Archery abilities
         children:
-            mcmmo.ability.archery.bonusdamage: true
+            mcmmo.ability.archery.skillshot: true
             mcmmo.ability.archery.daze: true
-            mcmmo.ability.archery.trackarrows: true
+            mcmmo.ability.archery.retrieve: true
-    mcmmo.ability.archery.bonusdamage:
+    mcmmo.ability.archery.skillshot:
-        description: Allows bonus damage from Archery
+        description: Allows bonus damage from the Archery SkillShot ability
     mcmmo.ability.archery.daze:
         description: Allows access to the Daze ability
-    mcmmo.ability.archery.trackarrows:
+    mcmmo.ability.archery.retrieve:
         description: Allows tracking & retrieval of arrows
     mcmmo.ability.axes.*:
         default: false
@@ -192,48 +193,21 @@ permissions:
     mcmmo.ability.axes.all:
         description: Allows access to all Axes abilities
         children:
-            mcmmo.ability.axes.bonusdamage: true
+            mcmmo.ability.axes.axemastery: true
             mcmmo.ability.axes.criticalhit: true
             mcmmo.ability.axes.greaterimpact: true
-            mcmmo.ability.axes.impact: true
+            mcmmo.ability.axes.armorimpact: true
             mcmmo.ability.axes.skullsplitter: true
-    mcmmo.ability.axes.bonusdamage:
+    mcmmo.ability.axes.axemastery:
         description: Allows bonus damage from Axes
     mcmmo.ability.axes.criticalhit:
         description: Allows access to the Critical Hit ability
     mcmmo.ability.axes.greaterimpact:
         description: Allows access to the Greater Impact ability
-    mcmmo.ability.axes.impact:
+    mcmmo.ability.axes.armorimpact:
         description: Allows access to the Impact ability
     mcmmo.ability.axes.skullsplitter:
         description: Allows access to the Skull Splitter ability
-    mcmmo.ability.blastmining.*:
-        default: false
-        description: Allows access to all Blast Mining abilities
-        children:
-            mcmmo.ability.blastmining.all: true
-    mcmmo.ability.blastmining.all:
-        default: false
-        description: Allows access to all Blast Mining abilities
-        children:
-            mcmmo.ability.blastmining.biggerbombs: true
-            mcmmo.ability.blastmining.demolitionsexpertise: true
-            mcmmo.ability.blastmining.detonate: true
-    mcmmo.ability.blastmining.biggerbombs:
-        default: false
-        description: Allows access to the Bigger Bombs ability
-        children:
-            mcmmo.ability.mining.blastmining.biggerbombs: true
-    mcmmo.ability.blastmining.demolitionsexpertise:
-        default: false
-        description: Allows access to the Demolitions Expertise ability
-        children:
-            mcmmo.ability.mining.blastmining.demolitionsexpertise: true
-    mcmmo.ability.blastmining.detonate:
-        default: false
-        description: Allows for remote TNT detonation
-        children:
-            mcmmo.ability.mining.blastmining.detonate: true
     mcmmo.ability.excavation.*:
         default: false
         description: Allows access to all Excavation abilities
@@ -243,10 +217,10 @@ permissions:
         description: Allows access to all Excavation abilities
         children:
             mcmmo.ability.excavation.gigadrillbreaker: true
-            mcmmo.ability.excavation.treasures: true
+            mcmmo.ability.excavation.treasurehunter: true
     mcmmo.ability.excavation.gigadrillbreaker:
         description: Allows access to the Giga Drill Breaker ability
-    mcmmo.ability.excavation.treasures:
+    mcmmo.ability.excavation.treasurehunter:
         description: Allows treasure drops from Excavation
     mcmmo.ability.fishing.*:
         default: false
@@ -258,22 +232,22 @@ permissions:
         children:
             mcmmo.ability.fishing.fishermansdiet: true
             mcmmo.ability.fishing.icefishing: true
-            mcmmo.ability.fishing.magic: true
+            mcmmo.ability.fishing.magichunter: true
             mcmmo.ability.fishing.masterangler: true
-            mcmmo.ability.fishing.shakemob: true
+            mcmmo.ability.fishing.shake: true
-            mcmmo.ability.fishing.treasures: true
+            mcmmo.ability.fishing.treasurehunter: true
             mcmmo.ability.fishing.vanillaxpboost: true
     mcmmo.ability.fishing.fishermansdiet:
         description: Allows access to the Fishermans's Diet ability
     mcmmo.ability.fishing.icefishing:
         description: Allows access to the Ice Fishing ability
-    mcmmo.ability.fishing.magic:
+    mcmmo.ability.fishing.magichunter:
         description: Allows enchanted drops from Fishing
     mcmmo.ability.fishing.masterangler:
         description: Allows access to the Master Angler ability
-    mcmmo.ability.fishing.shakemob:
+    mcmmo.ability.fishing.shake:
         description: Allows access to the Shake Mob ability
-    mcmmo.ability.fishing.treasures:
+    mcmmo.ability.fishing.treasurehunter:
         description: Allows treasure drops from Fishing
     mcmmo.ability.fishing.vanillaxpboost:
         description: Allows vanilla XP boost from Fishing
@@ -350,36 +324,6 @@ permissions:
         description: Allows access to the Green Thumb ability for netherwart
     mcmmo.ability.herbalism.greenthumb.plants.potato:
         description: Allows access to the Green Thumb ability for potatoes
-    mcmmo.ability.herbalism.greenthumbblocks:
-        default: false
-        description: Allows access to all Green Thumb abilities for blocks
-        children:
-            mcmmo.ability.herbalism.greenthumb.blocks.all: true
-    mcmmo.ability.herbalism.greenthumbcarrots:
-        default: false
-        description: Allows access to the Green Thumb ability for carrots
-        children:
-            mcmmo.ability.herbalism.greenthumb.plants.carrot: true
-    mcmmo.ability.herbalism.greenthumbcocoa:
-        default: false
-        description: Allows access to the Green Thumb ability for cocoa
-        children:
-            mcmmo.ability.herbalism.greenthumb.plants.cocoa: true
-    mcmmo.ability.herbalism.greenthumbnetherwart:
-        default: false
-        description: Allows access to the Green Thumb ability for netherwart
-        children:
-            mcmmo.ability.herbalism.greenthumb.plants.netherwarts: true
-    mcmmo.ability.herbalism.greenthumbpotatoes:
-        default: false
-        description: Allows access to the Green Thumb ability for potatoes
-        children:
-            mcmmo.ability.herbalism.greenthumb.plants.potato: true
-    mcmmo.ability.herbalism.greenthumbwheat:
-        default: false
-        description: Allows access to the Green Thumb ability for wheat
-        children:
-            mcmmo.ability.herbalism.greenthumb.plants.crops: true
     mcmmo.ability.herbalism.hylianluck:
         description: Allows access to the Hylian Luck ability
     mcmmo.ability.herbalism.shroomthumb:
@@ -455,7 +399,7 @@ permissions:
         description: Allows ability to repair items of material type OTHER
     mcmmo.ability.repair.otherrepair:
         description: Allows ability to repair items of type OTHER
-    mcmmo.ability.repair.repairbonus:
+    mcmmo.ability.repair.superrepair:
         description: Allows access to Super Repair bonus
     mcmmo.ability.repair.repairmastery:
         description: Allows access to Repair Mastery
@@ -477,21 +421,16 @@ permissions:
     mcmmo.ability.smelting.all:
         description: Allows access to all Smelting abilities
         children:
-            mcmmo.ability.smelting.doubledrops: true
+            mcmmo.ability.smelting.secondsmelt: true
             mcmmo.ability.smelting.fluxmining: true
             mcmmo.ability.smelting.fuelefficiency: true
             mcmmo.ability.smelting.vanillaxpboost: true
-    mcmmo.ability.smelting.doubledrops:
-        description: Allows access to the Second Smelt ability
     mcmmo.ability.smelting.fluxmining:
         description: Allows access to the Flux Mining ability
     mcmmo.ability.smelting.fuelefficiency:
         description: Allows access to the Fuel Efficiency ability
     mcmmo.ability.smelting.secondsmelt:
-        default: false
         description: Allows access to the Second Smelt ability
-        children:
-            mcmmo.ability.smelting.doubledrops: true
     mcmmo.ability.smelting.vanillaxpboost:
         description: Allows vanilla XP boost from Smelting
     mcmmo.ability.swords.*:
@@ -503,11 +442,11 @@ permissions:
         description: Allows access to all Swords abilities
         children:
             mcmmo.ability.swords.bleed: true
-            mcmmo.ability.swords.counterattack: true
+            mcmmo.ability.swords.counter: true
             mcmmo.ability.swords.serratedstrikes: true
     mcmmo.ability.swords.bleed:
         description: Allows access to the Bleed ability
-    mcmmo.ability.swords.counterattack:
+    mcmmo.ability.swords.counter:
         description: Allows access to the Counter Attack ability
     mcmmo.ability.swords.serratedstrikes:
         description: Allows access to the Serrated Strikes ability
@@ -522,7 +461,7 @@ permissions:
             mcmmo.ability.taming.beastlore: true
             mcmmo.ability.taming.callofthewild.all: true
             mcmmo.ability.taming.environmentallyaware: true
-            mcmmo.ability.taming.fastfoodservice: true
+            mcmmo.ability.taming.fastfood: true
             mcmmo.ability.taming.gore: true
             mcmmo.ability.taming.holyhound: true
             mcmmo.ability.taming.sharpenedclaws: true
@@ -555,14 +494,9 @@ permissions:
         description: Allows players to rename pets with Call of the Wild
     mcmmo.ability.taming.callofthewild.wolf:
         description: Allows players to summon Wolves with Call of the Wild
-    mcmmo.ability.taming.callofthewild_renamepets:
-        default: false
-        description: Pets spawned with Call of the Wild will have custom names
-        children:
-            mcmmo.ability.taming.callofthewild.renamepets: true
     mcmmo.ability.taming.environmentallyaware:
         description: Allows access to the Environmentally Aware ability
-    mcmmo.ability.taming.fastfoodservice:
+    mcmmo.ability.taming.fastfood:
         description: Allows access to the Fast Food Service ability
     mcmmo.ability.taming.gore:
         description: Allows access to the Gore ability
@@ -584,7 +518,7 @@ permissions:
         children:
             mcmmo.ability.unarmed.berserk: true
             mcmmo.ability.unarmed.blockcracker: true
-            mcmmo.ability.unarmed.bonusdamage: true
+            mcmmo.ability.unarmed.ironarm: true
             mcmmo.ability.unarmed.deflect: true
             mcmmo.ability.unarmed.disarm: true
             mcmmo.ability.unarmed.irongrip: true
@@ -592,8 +526,8 @@ permissions:
         description: Allows access to the Berserker ability
     mcmmo.ability.unarmed.blockcracker:
         description: Allows access to the Block Cracker ability
-    mcmmo.ability.unarmed.bonusdamage:
+    mcmmo.ability.unarmed.ironarm:
-        description: Allows bonus damage from Unarmed
+        description: Allows bonus damage from the Iron Arm ability
     mcmmo.ability.unarmed.deflect:
         description: Allows access to the Deflect ability
     mcmmo.ability.unarmed.disarm:
@@ -1843,3 +1777,128 @@ permissions:
     mcmmo.tools.updatecheck:
         default: false
         description: Notifies admins if there is a new version of mcMMO available
+    mcmmo.ability.fishing.shakemob:
+        default: false
+        description: deprecated
+        children:
+            mcmmo.ability.fishing.shake: true
+    mcmmo.ability.axes.impact:
+        default: false
+        description: deprecated
+        children:
+            mcmmo.ability.axes.armorimpact: true
+    mcmmo.ability.taming.fastfoodservice:
+        default: false
+        description: deprecated
+        children:
+            mcmmo.ability.taming.fastfood: true
+    mcmmo.ability.archery.trackarrows:
+        default: false
+        description: deprecated
+        children:
+            mcmmo.ability.archery.retrieve: true
+    mcmmo.ability.repair.repairbonus:
+        default: false
+        description: deprecated
+        children:
+            mcmmo.ability.repair.superrepair: true
+    mcmmo.ability.swords.counterattack:
+        default: false
+        description: deprecated
+        children:
+            mcmmo.ability.swords.counter: true
+    mcmmo.ability.archery.bonusdamage:
+        default: false
+        description: deprecated
+        children:
+            mcmmo.ability.archery.skillshot: true
+    mcmmo.ability.excavation.treasures:
+        default: false
+        description: deprecated
+        children:
+            mcmmo.ability.excavation.treasurehunter: true
+    mcmmo.ability.fishing.treasures:
+        default: false
+        description: deprecated
+        children:
+            mcmmo.ability.fishing.treasurehunter: true
+    mcmmo.ability.fishing.magic:
+        default: false
+        description: deprecated
+        children:
+            mcmmo.ability.fishing.magichunter: true
+    mcmmo.ability.unarmed.bonusdamage:
+        default: false
+        description: deprecated
+        children:
+            mcmmo.ability.unarmed.ironarm: true
+    mcmmo.ability.axes.bonusdamage:
+        default: false
+        description: deprecated
+        children:
+            mcmmo.ability.axes.axemastery: true
+    mcmmo.ability.smelting.doubledrops:
+        default: false
+        description: deprecated
+        children:
+            mcmmo.ability.smelting.secondsmelt: true
+    mcmmo.ability.taming.callofthewild_renamepets:
+        default: false
+        description: deprecated
+        children:
+            mcmmo.ability.taming.callofthewild.renamepets: true
+    mcmmo.ability.blastmining.*:
+        default: false
+        description: deprecated
+        children:
+            mcmmo.ability.mining.blastmining.*: true
+    mcmmo.ability.blastmining.all:
+        default: false
+        description: deprecated
+        children:
+            mcmmo.ability.mining.blastmining.all: true
+    mcmmo.ability.blastmining.biggerbombs:
+        default: false
+        description: deprecated
+        children:
+            mcmmo.ability.mining.blastmining.biggerbombs: true
+    mcmmo.ability.blastmining.demolitionsexpertise:
+        default: false
+        description: deprecated
+        children:
+            mcmmo.ability.mining.blastmining.demolitionsexpertise: true
+    mcmmo.ability.blastmining.detonate:
+        default: false
+        description: deprecated
+        children:
+            mcmmo.ability.mining.blastmining.detonate: true
+    mcmmo.ability.herbalism.greenthumbblocks:
+        default: false
+        description: deprecated
+        children:
+            mcmmo.ability.herbalism.greenthumb.blocks.all: true
+    mcmmo.ability.herbalism.greenthumbcarrots:
+        default: false
+        description: deprecated
+        children:
+            mcmmo.ability.herbalism.greenthumb.plants.carrot: true
+    mcmmo.ability.herbalism.greenthumbcocoa:
+        default: false
+        description: deprecated
+        children:
+            mcmmo.ability.herbalism.greenthumb.plants.cocoa: true
+    mcmmo.ability.herbalism.greenthumbnetherwart:
+        default: false
+        description: deprecated
+        children:
+            mcmmo.ability.herbalism.greenthumb.plants.netherwarts: true
+    mcmmo.ability.herbalism.greenthumbpotatoes:
+        default: false
+        description: deprecated
+        children:
+            mcmmo.ability.herbalism.greenthumb.plants.potato: true
+    mcmmo.ability.herbalism.greenthumbwheat:
+        default: false
+        description: deprecated
+        children:
+            mcmmo.ability.herbalism.greenthumb.plants.crops: true