Rewrote the RNG system to be more unified

.gitignore

@@ -4,6 +4,9 @@
 /.settings
 /dependency-reduced-pom.xml
 
+#vs code
+/.vscode
+
 # netbeans
 /nbproject
 

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

@@ -1,14 +1,14 @@
 package com.gmail.nossr50.commands.skills;
 
-import com.gmail.nossr50.config.AdvancedConfig;
-import com.gmail.nossr50.config.Config;
 import com.gmail.nossr50.datatypes.skills.PrimarySkillType;
 import com.gmail.nossr50.datatypes.skills.SubSkillType;
 import com.gmail.nossr50.datatypes.skills.subskills.AbstractSubSkill;
 import com.gmail.nossr50.listeners.InteractionManager;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.util.TextComponentFactory;
-import com.gmail.nossr50.util.skills.SkillUtils;
+import com.gmail.nossr50.util.random.RandomChanceSkill;
+import com.gmail.nossr50.util.random.RandomChanceUtil;
+import com.gmail.nossr50.util.skills.SkillActivationType;
 import net.md_5.bungee.api.chat.TextComponent;
 import org.bukkit.entity.Player;
 
@@ -27,10 +27,10 @@ public class AcrobaticsCommand extends SkillCommand {
     }
 
     @Override
-    protected void dataCalculations(Player player, float skillValue, boolean isLucky) {
+    protected void dataCalculations(Player player, float skillValue) {
         // ACROBATICS_DODGE
         if (canDodge) {
-            String[] dodgeStrings = SkillUtils.calculateAbilityDisplayValues(skillValue, SubSkillType.ACROBATICS_DODGE, isLucky);
+            String[] dodgeStrings = getAbilityDisplayValues(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, player, SubSkillType.ACROBATICS_DODGE);
             dodgeChance = dodgeStrings[0];
             dodgeChanceLucky = dodgeStrings[1];
         }
@@ -57,22 +57,29 @@ public class AcrobaticsCommand extends SkillCommand {
 
             if(abstractSubSkill != null)
             {
-                double maxBonusLevel = AdvancedConfig.getInstance().getMaxBonusLevel(abstractSubSkill);
+                double rollChance, graceChance;
-                double maxChance = AdvancedConfig.getInstance().getMaxChance(abstractSubSkill);
-                double rollChance   = SkillUtils.getChanceOfSuccess(skillValue, maxBonusLevel, maxChance);
-                double graceChance  = SkillUtils.getChanceOfSuccess(skillValue, maxBonusLevel, maxChance / 2);
 
-                rollChance = Math.min(100.0D, rollChance);
+                //Chance to roll at half
-                graceChance = Math.min(100.0D, graceChance);
+                RandomChanceSkill roll_rcs  = new RandomChanceSkill(player, SubSkillType.ACROBATICS_ROLL);
 
-                String rollChanceLucky = isLucky ? percent.format(Math.min(100.0D, (rollChance * 1.3333D) / 100.0D)) : null;
+                //Chance to graceful roll
-                String graceChanceLucky = isLucky ? percent.format(Math.min(100.0D, (graceChance * 1.3333D) / 100.0D)) : null;
+                RandomChanceSkill grace_rcs = new RandomChanceSkill(player, SubSkillType.ACROBATICS_ROLL);
+                grace_rcs.setSkillLevel(grace_rcs.getSkillLevel() * 2); //Double Odds
 
-                messages.add(getStatMessage(SubSkillType.ACROBATICS_ROLL, percent.format(rollChance)
+                //Chance Stat Calculations
-                        + (isLucky ? LocaleLoader.getString("Perks.Lucky.Bonus", rollChanceLucky) : "")));
+                rollChance       = RandomChanceUtil.getRandomChanceExecutionChance(roll_rcs);
+                graceChance      = RandomChanceUtil.getRandomChanceExecutionChance(grace_rcs);
+                //damageThreshold  = AdvancedConfig.getInstance().getRollDamageThreshold();
 
-                messages.add(getStatMessage(true, false, SubSkillType.ACROBATICS_ROLL, percent.format(graceChance)
+                //Format
-                        + (isLucky ? LocaleLoader.getString("Perks.Lucky.Bonus", graceChanceLucky) : "")));
+                double rollChanceLucky  = rollChance * 1.333D;
+                double graceChanceLucky = graceChance * 1.333D;
+
+                messages.add(getStatMessage(SubSkillType.ACROBATICS_ROLL, String.valueOf(rollChance))
+                        + (isLucky ? LocaleLoader.getString("Perks.Lucky.Bonus", String.valueOf(rollChanceLucky)) : ""));
+
+                messages.add(getStatMessage(true, false, SubSkillType.ACROBATICS_ROLL, String.valueOf(graceChance))
+                        + (isLucky ? LocaleLoader.getString("Perks.Lucky.Bonus", String.valueOf(graceChanceLucky)) : ""));
             }
         }
 

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

@@ -4,6 +4,7 @@ import com.gmail.nossr50.datatypes.skills.PrimarySkillType;
 import com.gmail.nossr50.datatypes.skills.SubSkillType;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.skills.alchemy.AlchemyManager;
+import com.gmail.nossr50.util.Permissions;
 import com.gmail.nossr50.util.TextComponentFactory;
 import com.gmail.nossr50.util.player.UserManager;
 import com.gmail.nossr50.util.skills.RankUtils;
@@ -28,10 +29,12 @@ public class AlchemyCommand extends SkillCommand {
         super(PrimarySkillType.ALCHEMY);
     }
 
-    protected String[] calculateAbilityDisplayValues(Player player, boolean isLucky) {
+    protected String[] calculateAbilityDisplayValues(Player player) {
         AlchemyManager alchemyManager = UserManager.getPlayer(player).getAlchemyManager();
         String[] displayValues = new String[2];
 
+        boolean isLucky = Permissions.lucky(player, PrimarySkillType.ALCHEMY);
+
         displayValues[0] = decimal.format(alchemyManager.calculateBrewSpeed(false)) + "x";
         displayValues[1] = isLucky ? decimal.format(alchemyManager.calculateBrewSpeed(true)) + "x" : null;
 
@@ -39,10 +42,10 @@ public class AlchemyCommand extends SkillCommand {
     }
 
     @Override
-    protected void dataCalculations(Player player, float skillValue, boolean isLucky) {
+    protected void dataCalculations(Player player, float skillValue) {
         // ALCHEMY_CATALYSIS
         if (canCatalysis) {
-            String[] catalysisStrings = calculateAbilityDisplayValues(player, isLucky);
+            String[] catalysisStrings = calculateAbilityDisplayValues(player);
             brewSpeed = catalysisStrings[0];
             brewSpeedLucky = catalysisStrings[1];
         }

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

@@ -5,6 +5,7 @@ import com.gmail.nossr50.datatypes.skills.SubSkillType;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.skills.archery.Archery;
 import com.gmail.nossr50.util.TextComponentFactory;
+import com.gmail.nossr50.util.skills.SkillActivationType;
 import net.md_5.bungee.api.chat.TextComponent;
 import org.bukkit.entity.Player;
 
@@ -27,17 +28,17 @@ public class ArcheryCommand extends SkillCommand {
     }
 
     @Override
-    protected void dataCalculations(Player player, float skillValue, boolean isLucky) {
+    protected void dataCalculations(Player player, float skillValue) {
         // ARCHERY_ARROW_RETRIEVAL
         if (canRetrieve) {
-            String[] retrieveStrings = calculateAbilityDisplayValues(skillValue, SubSkillType.ARCHERY_ARROW_RETRIEVAL, isLucky);
+            String[] retrieveStrings = getAbilityDisplayValues(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, player, SubSkillType.ARCHERY_ARROW_RETRIEVAL);
             retrieveChance = retrieveStrings[0];
             retrieveChanceLucky = retrieveStrings[1];
         }
         
         // ARCHERY_DAZE
         if (canDaze) {
-            String[] dazeStrings = calculateAbilityDisplayValues(skillValue, SubSkillType.ARCHERY_DAZE, isLucky);
+            String[] dazeStrings = getAbilityDisplayValues(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, player, SubSkillType.ARCHERY_DAZE);
             dazeChance = dazeStrings[0];
             dazeChanceLucky = dazeStrings[1];
         }

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

@@ -6,7 +6,9 @@ import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.skills.axes.Axes;
 import com.gmail.nossr50.util.Permissions;
 import com.gmail.nossr50.util.TextComponentFactory;
+import com.gmail.nossr50.util.player.UserManager;
 import com.gmail.nossr50.util.skills.RankUtils;
+import com.gmail.nossr50.util.skills.SkillActivationType;
 import net.md_5.bungee.api.chat.TextComponent;
 import org.bukkit.entity.Player;
 
@@ -32,10 +34,10 @@ public class AxesCommand extends SkillCommand {
     }
 
     @Override
-    protected void dataCalculations(Player player, float skillValue, boolean isLucky) {
+    protected void dataCalculations(Player player, float skillValue) {
         // ARMOR IMPACT
         if (canImpact) {
-            impactDamage = 1 + (skillValue / Axes.impactIncreaseLevel);
+            impactDamage = UserManager.getPlayer(player).getAxesManager().getImpactDurabilityDamage();
         }
 
         // AXE MASTERY
@@ -45,7 +47,7 @@ public class AxesCommand extends SkillCommand {
         
         // CRITICAL HIT
         if (canCritical) {
-            String[] criticalHitStrings = calculateAbilityDisplayValues(skillValue, SubSkillType.AXES_CRITICAL_STRIKES, isLucky);
+            String[] criticalHitStrings = getAbilityDisplayValues(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, player, SubSkillType.AXES_CRITICAL_STRIKES);
             critChance = criticalHitStrings[0];
             critChanceLucky = criticalHitStrings[1];
         }

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

@@ -24,7 +24,7 @@ public class ExcavationCommand extends SkillCommand {
     }
 
     @Override
-    protected void dataCalculations(Player player, float skillValue, boolean isLucky) {
+    protected void dataCalculations(Player player, float skillValue) {
         // GIGA DRILL BREAKER
         if (canGigaDrill) {
             String gigaDrillStrings[] = calculateLengthDisplayValues(player, skillValue);

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

@@ -10,7 +10,9 @@ import com.gmail.nossr50.skills.fishing.Fishing;
 import com.gmail.nossr50.skills.fishing.FishingManager;
 import com.gmail.nossr50.util.TextComponentFactory;
 import com.gmail.nossr50.util.player.UserManager;
+import com.gmail.nossr50.util.random.RandomChanceUtil;
 import com.gmail.nossr50.util.skills.RankUtils;
+import com.gmail.nossr50.util.skills.SkillActivationType;
 import net.md_5.bungee.api.chat.TextComponent;
 import org.bukkit.Location;
 import org.bukkit.entity.EntityType;
@@ -48,7 +50,7 @@ public class FishingCommand extends SkillCommand {
     }
 
     @Override
-    protected void dataCalculations(Player player, float skillValue, boolean isLucky) {
+    protected void dataCalculations(Player player, float skillValue) {
         FishingManager fishingManager = UserManager.getPlayer(player).getFishingManager();
 
         // TREASURE HUNTER
@@ -78,7 +80,7 @@ public class FishingCommand extends SkillCommand {
 
         // FISHING_SHAKE
         if (canShake) {
-            String[] shakeStrings = calculateAbilityDisplayValues(UserManager.getPlayer(player).getFishingManager().getShakeProbability(), isLucky);
+            String[] shakeStrings = getAbilityDisplayValues(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, player, SubSkillType.FISHING_SHAKE);
             shakeChance = shakeStrings[0];
             shakeChanceLucky = shakeStrings[1];
         }
@@ -105,7 +107,7 @@ public class FishingCommand extends SkillCommand {
                 rawBiteChance = rawBiteChance * AdvancedConfig.getInstance().getMasterAnglerBoatModifier();
             }
 
-            biteChance = calculateAbilityDisplayValues(rawBiteChance * 100.0, isLucky)[0];
+            biteChance = RandomChanceUtil.calculateAbilityDisplayValuesStatic(player,PrimarySkillType.FISHING,rawBiteChance)[0];
         }
     }
 

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

@@ -6,6 +6,7 @@ import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.util.Permissions;
 import com.gmail.nossr50.util.TextComponentFactory;
 import com.gmail.nossr50.util.skills.RankUtils;
+import com.gmail.nossr50.util.skills.SkillActivationType;
 import net.md_5.bungee.api.chat.TextComponent;
 import org.bukkit.Material;
 import org.bukkit.entity.Player;
@@ -40,11 +41,11 @@ public class HerbalismCommand extends SkillCommand {
     }
 
     @Override
-    protected void dataCalculations(Player player, float skillValue, boolean isLucky) {
+    protected void dataCalculations(Player player, float skillValue) {
         
         // DOUBLE DROPS
         if (canDoubleDrop) {
-            String[] doubleDropStrings = calculateAbilityDisplayValues(skillValue, SubSkillType.HERBALISM_DOUBLE_DROPS, isLucky);
+            String[] doubleDropStrings = getAbilityDisplayValues(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, player, SubSkillType.HERBALISM_DOUBLE_DROPS);;
             doubleDropChance = doubleDropStrings[0];
             doubleDropChanceLucky = doubleDropStrings[1];
         }
@@ -65,21 +66,21 @@ public class HerbalismCommand extends SkillCommand {
         if (canGreenThumbBlocks || canGreenThumbPlants) {
             greenThumbStage = RankUtils.getRank(player, SubSkillType.HERBALISM_GREEN_THUMB);
 
-            String[] greenThumbStrings = calculateAbilityDisplayValues(skillValue, SubSkillType.HERBALISM_GREEN_THUMB, isLucky);
+            String[] greenThumbStrings = getAbilityDisplayValues(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, player, SubSkillType.HERBALISM_GREEN_THUMB);
             greenThumbChance = greenThumbStrings[0];
             greenThumbChanceLucky = greenThumbStrings[1];
         }
 
         // HYLIAN LUCK
         if (hasHylianLuck) {
-            String[] hylianLuckStrings = calculateAbilityDisplayValues(skillValue, SubSkillType.HERBALISM_HYLIAN_LUCK, isLucky);
+            String[] hylianLuckStrings = getAbilityDisplayValues(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, player, SubSkillType.HERBALISM_HYLIAN_LUCK);
             hylianLuckChance = hylianLuckStrings[0];
             hylianLuckChanceLucky = hylianLuckStrings[1];
         }
 
         // SHROOM THUMB
         if (canShroomThumb) {
-            String[] shroomThumbStrings = calculateAbilityDisplayValues(skillValue, SubSkillType.HERBALISM_SHROOM_THUMB, isLucky);
+            String[] shroomThumbStrings = getAbilityDisplayValues(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, player, SubSkillType.HERBALISM_SHROOM_THUMB);
             shroomThumbChance = shroomThumbStrings[0];
             shroomThumbChanceLucky = shroomThumbStrings[1];
         }

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

@@ -8,6 +8,7 @@ import com.gmail.nossr50.util.Permissions;
 import com.gmail.nossr50.util.TextComponentFactory;
 import com.gmail.nossr50.util.player.UserManager;
 import com.gmail.nossr50.util.skills.RankUtils;
+import com.gmail.nossr50.util.skills.SkillActivationType;
 import net.md_5.bungee.api.chat.TextComponent;
 import org.bukkit.entity.Player;
 
@@ -38,7 +39,7 @@ public class MiningCommand extends SkillCommand {
     }
 
     @Override
-    protected void dataCalculations(Player player, float skillValue, boolean isLucky) {
+    protected void dataCalculations(Player player, float skillValue) {
         // BLAST MINING
         if (canBlast || canDemoExpert || canBiggerBombs) {
             MiningManager miningManager = UserManager.getPlayer(player).getMiningManager();
@@ -53,7 +54,7 @@ public class MiningCommand extends SkillCommand {
         
         // DOUBLE DROPS
         if (canDoubleDrop) {
-            String[] doubleDropStrings = calculateAbilityDisplayValues(skillValue, SubSkillType.MINING_DOUBLE_DROPS, isLucky);
+            String[] doubleDropStrings = getAbilityDisplayValues(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, player, SubSkillType.MINING_DOUBLE_DROPS);
             doubleDropChance = doubleDropStrings[0];
             doubleDropChanceLucky = doubleDropStrings[1];
         }

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

@@ -13,6 +13,7 @@ import com.gmail.nossr50.util.Permissions;
 import com.gmail.nossr50.util.TextComponentFactory;
 import com.gmail.nossr50.util.player.UserManager;
 import com.gmail.nossr50.util.skills.RankUtils;
+import com.gmail.nossr50.util.skills.SkillActivationType;
 import net.md_5.bungee.api.chat.TextComponent;
 import org.bukkit.Material;
 import org.bukkit.entity.Player;
@@ -47,7 +48,7 @@ public class RepairCommand extends SkillCommand {
     }
 
     @Override
-    protected void dataCalculations(Player player, float skillValue, boolean isLucky) {
+    protected void dataCalculations(Player player, float skillValue) {
         // We're using pickaxes here, not the best but it works
         Repairable diamondRepairable = mcMMO.getRepairableManager().getRepairable(Material.DIAMOND_PICKAXE);
         Repairable goldRepairable = mcMMO.getRepairableManager().getRepairable(Material.GOLDEN_PICKAXE);
@@ -67,7 +68,7 @@ public class RepairCommand extends SkillCommand {
 
         // SUPER REPAIR
         if (canSuperRepair) {
-            String[] superRepairStrings = calculateAbilityDisplayValues(skillValue, SubSkillType.REPAIR_SUPER_REPAIR, isLucky);
+            String[] superRepairStrings = getAbilityDisplayValues(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, player, SubSkillType.REPAIR_SUPER_REPAIR);
             superRepairChance = superRepairStrings[0];
             superRepairChanceLucky = superRepairStrings[1];
         }

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

@@ -23,7 +23,7 @@ public class SalvageCommand extends SkillCommand {
     }
 
     @Override
-    protected void dataCalculations(Player player, float skillValue, boolean isLucky) {
+    protected void dataCalculations(Player player, float skillValue) {
         // TODO Auto-generated method stub
 
     }

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

@@ -12,9 +12,11 @@ import com.gmail.nossr50.util.StringUtils;
 import com.gmail.nossr50.util.TextComponentFactory;
 import com.gmail.nossr50.util.commands.CommandUtils;
 import com.gmail.nossr50.util.player.UserManager;
+import com.gmail.nossr50.util.random.RandomChanceUtil;
 import com.gmail.nossr50.util.scoreboards.ScoreboardManager;
 import com.gmail.nossr50.util.skills.PerksUtils;
 import com.gmail.nossr50.util.skills.RankUtils;
+import com.gmail.nossr50.util.skills.SkillActivationType;
 import com.google.common.collect.ImmutableList;
 import net.md_5.bungee.api.ChatColor;
 import net.md_5.bungee.api.chat.TextComponent;
@@ -70,7 +72,7 @@ public abstract class SkillCommand implements TabExecutor {
                 }
 
                 permissionsCheck(player);
-                dataCalculations(player, skillValue, isLucky);
+                dataCalculations(player, skillValue);
 
                 sendSkillCommandHeader(player, mcMMOPlayer, (int) skillValue);
 
@@ -217,19 +219,8 @@ public abstract class SkillCommand implements TabExecutor {
         return Math.min((int) skillValue, maxLevel) / rankChangeLevel;
     }
 
-    protected String[] calculateAbilityDisplayValues(double chance, boolean isLucky) {
+    protected String[] getAbilityDisplayValues(SkillActivationType skillActivationType, Player player, SubSkillType subSkill) {
-        String[] displayValues = new String[2];
+        return RandomChanceUtil.calculateAbilityDisplayValues(skillActivationType, player, subSkill);
-
-        displayValues[0] = percent.format(Math.min(chance, 100.0D) / 100.0D);
-        displayValues[1] = isLucky ? percent.format(Math.min(chance * 1.3333D, 100.0D) / 100.0D) : null;
-
-        return displayValues;
-    }
-
-    protected String[] calculateAbilityDisplayValues(float skillValue, SubSkillType subSkill, boolean isLucky) {
-        int maxBonusLevel = AdvancedConfig.getInstance().getMaxBonusLevel(subSkill);
-
-        return calculateAbilityDisplayValues((AdvancedConfig.getInstance().getMaxChance(subSkill) / maxBonusLevel) * Math.min(skillValue, maxBonusLevel), isLucky);
     }
 
     protected String[] calculateLengthDisplayValues(Player player, float skillValue) {
@@ -285,7 +276,7 @@ public abstract class SkillCommand implements TabExecutor {
         return newArray;
     }
 
-    protected abstract void dataCalculations(Player player, float skillValue, boolean isLucky);
+    protected abstract void dataCalculations(Player player, float skillValue);
 
     protected abstract void permissionsCheck(Player player);
 

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

@@ -8,6 +8,7 @@ import com.gmail.nossr50.util.Permissions;
 import com.gmail.nossr50.util.TextComponentFactory;
 import com.gmail.nossr50.util.player.UserManager;
 import com.gmail.nossr50.util.skills.RankUtils;
+import com.gmail.nossr50.util.skills.SkillActivationType;
 import net.md_5.bungee.api.chat.TextComponent;
 import org.bukkit.entity.Player;
 
@@ -16,10 +17,10 @@ import java.util.List;
 
 public class SmeltingCommand extends SkillCommand {
     private String burnTimeModifier;
-    private String secondSmeltChance;
+    private String str_secondSmeltChance;
-    private String secondSmeltChanceLucky;
+    private String str_secondSmeltChanceLucky;
-    private String fluxMiningChance;
+    private String str_fluxMiningChance;
-    private String fluxMiningChanceLucky;
+    private String str_fluxMiningChanceLucky;
 
     private boolean canFuelEfficiency;
     private boolean canSecondSmelt;
@@ -31,7 +32,7 @@ public class SmeltingCommand extends SkillCommand {
     }
 
     @Override
-    protected void dataCalculations(Player player, float skillValue, boolean isLucky) {
+    protected void dataCalculations(Player player, float skillValue) {
         // FUEL EFFICIENCY
         if (canFuelEfficiency) {
             burnTimeModifier = decimal.format(1 + ((skillValue / Smelting.burnModifierMaxLevel) * Smelting.burnTimeMultiplier));
@@ -39,16 +40,16 @@ public class SmeltingCommand extends SkillCommand {
 
         // FLUX MINING
         if (canFluxMine) {
-            String[] fluxMiningStrings = calculateAbilityDisplayValues(Smelting.fluxMiningChance, isLucky);
+            String[] fluxMiningStrings = getAbilityDisplayValues(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, player, SubSkillType.SMELTING_FLUX_MINING);
-            fluxMiningChance = fluxMiningStrings[0];
+            str_fluxMiningChance = fluxMiningStrings[0];
-            fluxMiningChanceLucky = fluxMiningStrings[1];
+            str_fluxMiningChanceLucky = fluxMiningStrings[1];
         }
         
         // SECOND SMELT
         if (canSecondSmelt) {
-            String[] secondSmeltStrings = calculateAbilityDisplayValues(skillValue, SubSkillType.SMELTING_SECOND_SMELT, isLucky);
+            String[] secondSmeltStrings = getAbilityDisplayValues(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, player, SubSkillType.SMELTING_SECOND_SMELT);
-            secondSmeltChance = secondSmeltStrings[0];
+            str_secondSmeltChance = secondSmeltStrings[0];
-            secondSmeltChanceLucky = secondSmeltStrings[1];
+            str_secondSmeltChanceLucky = secondSmeltStrings[1];
         }
     }
 
@@ -65,7 +66,7 @@ public class SmeltingCommand extends SkillCommand {
         List<String> messages = new ArrayList<String>();
 
         if (canFluxMine) {
-            messages.add(LocaleLoader.getString("Smelting.Ability.FluxMining", fluxMiningChance) + (isLucky ? LocaleLoader.getString("Perks.Lucky.Bonus", fluxMiningChanceLucky) : ""));
+            messages.add(LocaleLoader.getString("Smelting.Ability.FluxMining", str_fluxMiningChance) + (isLucky ? LocaleLoader.getString("Perks.Lucky.Bonus", str_fluxMiningChanceLucky) : ""));
         }
         
         if (canFuelEfficiency) {
@@ -73,7 +74,7 @@ public class SmeltingCommand extends SkillCommand {
         }
 
         if (canSecondSmelt) {
-            messages.add(LocaleLoader.getString("Smelting.Ability.SecondSmelt", secondSmeltChance) + (isLucky ? LocaleLoader.getString("Perks.Lucky.Bonus", secondSmeltChanceLucky) : ""));
+            messages.add(LocaleLoader.getString("Smelting.Ability.SecondSmelt", str_secondSmeltChance) + (isLucky ? LocaleLoader.getString("Perks.Lucky.Bonus", str_secondSmeltChanceLucky) : ""));
         }
 
         if (canVanillaXPBoost) {

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

@@ -8,6 +8,7 @@ import com.gmail.nossr50.util.Permissions;
 import com.gmail.nossr50.util.TextComponentFactory;
 import com.gmail.nossr50.util.player.UserManager;
 import com.gmail.nossr50.util.skills.RankUtils;
+import com.gmail.nossr50.util.skills.SkillActivationType;
 import net.md_5.bungee.api.chat.TextComponent;
 import org.bukkit.entity.Player;
 
@@ -32,10 +33,10 @@ public class SwordsCommand extends SkillCommand {
     }
 
     @Override
-    protected void dataCalculations(Player player, float skillValue, boolean isLucky) {
+    protected void dataCalculations(Player player, float skillValue) {
         // SWORDS_COUNTER_ATTACK
         if (canCounter) {
-            String[] counterStrings = calculateAbilityDisplayValues(skillValue, SubSkillType.SWORDS_COUNTER_ATTACK, isLucky);
+            String[] counterStrings = getAbilityDisplayValues(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, player, SubSkillType.SWORDS_COUNTER_ATTACK);
             counterChance = counterStrings[0];
             counterChanceLucky = counterStrings[1];
         }
@@ -44,7 +45,7 @@ public class SwordsCommand extends SkillCommand {
         if (canBleed) {
             bleedLength = UserManager.getPlayer(player).getSwordsManager().getRuptureBleedTicks();
 
-            String[] bleedStrings = calculateAbilityDisplayValues(skillValue, SubSkillType.SWORDS_RUPTURE, isLucky);
+            String[] bleedStrings = getAbilityDisplayValues(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, player, SubSkillType.SWORDS_RUPTURE);
             bleedChance = bleedStrings[0];
             bleedChanceLucky = bleedStrings[1];
         }

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

@@ -6,6 +6,7 @@ import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.skills.taming.Taming;
 import com.gmail.nossr50.util.Permissions;
 import com.gmail.nossr50.util.TextComponentFactory;
+import com.gmail.nossr50.util.skills.SkillActivationType;
 import net.md_5.bungee.api.chat.TextComponent;
 import org.bukkit.entity.EntityType;
 import org.bukkit.entity.Player;
@@ -32,9 +33,9 @@ public class TamingCommand extends SkillCommand {
     }
 
     @Override
-    protected void dataCalculations(Player player, float skillValue, boolean isLucky) {
+    protected void dataCalculations(Player player, float skillValue) {
         if (canGore) {
-            String[] goreStrings = calculateAbilityDisplayValues(skillValue, SubSkillType.TAMING_GORE, isLucky);
+            String[] goreStrings = getAbilityDisplayValues(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, player, SubSkillType.TAMING_GORE);
             goreChance = goreStrings[0];
             goreChanceLucky = goreStrings[1];
         }

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

@@ -6,7 +6,9 @@ import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.skills.unarmed.Unarmed;
 import com.gmail.nossr50.util.Permissions;
 import com.gmail.nossr50.util.TextComponentFactory;
+import com.gmail.nossr50.util.player.UserManager;
 import com.gmail.nossr50.util.skills.RankUtils;
+import com.gmail.nossr50.util.skills.SkillActivationType;
 import net.md_5.bungee.api.chat.TextComponent;
 import org.bukkit.entity.Player;
 
@@ -35,10 +37,10 @@ public class UnarmedCommand extends SkillCommand {
     }
 
     @Override
-    protected void dataCalculations(Player player, float skillValue, boolean isLucky) {
+    protected void dataCalculations(Player player, float skillValue) {
         // UNARMED_ARROW_DEFLECT
         if (canDeflect) {
-            String[] deflectStrings = calculateAbilityDisplayValues(skillValue, SubSkillType.UNARMED_ARROW_DEFLECT, isLucky);
+            String[] deflectStrings = getAbilityDisplayValues(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, player, SubSkillType.UNARMED_ARROW_DEFLECT);;
             deflectChance = deflectStrings[0];
             deflectChanceLucky = deflectStrings[1];
         }
@@ -52,19 +54,19 @@ public class UnarmedCommand extends SkillCommand {
 
         // UNARMED_DISARM
         if (canDisarm) {
-            String[] disarmStrings = calculateAbilityDisplayValues(skillValue, SubSkillType.UNARMED_DISARM, isLucky);
+            String[] disarmStrings = getAbilityDisplayValues(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, player, SubSkillType.UNARMED_DISARM);;
             disarmChance = disarmStrings[0];
             disarmChanceLucky = disarmStrings[1];
         }
 
         // IRON ARM
         if (canIronArm) {
-            ironArmBonus = Math.min(Unarmed.ironArmMinBonusDamage + ((int) skillValue / Unarmed.ironArmIncreaseLevel), Unarmed.ironArmMaxBonusDamage);
+            ironArmBonus = UserManager.getPlayer(player).getUnarmedManager().getIronArmDamage();
         }
 
         // IRON GRIP
         if (canIronGrip) {
-            String[] ironGripStrings = calculateAbilityDisplayValues(skillValue, SubSkillType.UNARMED_IRON_GRIP, isLucky);
+            String[] ironGripStrings = getAbilityDisplayValues(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, player, SubSkillType.UNARMED_IRON_GRIP);
             ironGripChance = ironGripStrings[0];
             ironGripChanceLucky = ironGripStrings[1];
         }

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

@@ -6,6 +6,7 @@ import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.util.Permissions;
 import com.gmail.nossr50.util.TextComponentFactory;
 import com.gmail.nossr50.util.skills.RankUtils;
+import com.gmail.nossr50.util.skills.SkillActivationType;
 import net.md_5.bungee.api.chat.TextComponent;
 import org.bukkit.entity.Player;
 
@@ -30,10 +31,10 @@ public class WoodcuttingCommand extends SkillCommand {
     }
 
     @Override
-    protected void dataCalculations(Player player, float skillValue, boolean isLucky) {
+    protected void dataCalculations(Player player, float skillValue) {
         // DOUBLE DROPS
         if (canDoubleDrop) {
-            setDoubleDropClassicChanceStrings(skillValue, isLucky);
+            setDoubleDropClassicChanceStrings(player);
         }
         
         // TREE FELLER
@@ -44,8 +45,8 @@ public class WoodcuttingCommand extends SkillCommand {
         }
     }
 
-    private void setDoubleDropClassicChanceStrings(float skillValue, boolean isLucky) {
+    private void setDoubleDropClassicChanceStrings(Player player) {
-        String[] doubleDropStrings = calculateAbilityDisplayValues(skillValue, SubSkillType.WOODCUTTING_HARVEST_LUMBER, isLucky);
+        String[] doubleDropStrings = getAbilityDisplayValues(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, player, SubSkillType.WOODCUTTING_HARVEST_LUMBER);;
         doubleDropChance = doubleDropStrings[0];
         doubleDropChanceLucky = doubleDropStrings[1];
     }

src/main/java/com/gmail/nossr50/datatypes/skills/subskills/acrobatics/Roll.java

@@ -2,20 +2,22 @@ package com.gmail.nossr50.datatypes.skills.subskills.acrobatics;
 
 import com.gmail.nossr50.config.AdvancedConfig;
 import com.gmail.nossr50.config.Config;
+import com.gmail.nossr50.config.experience.ExperienceConfig;
 import com.gmail.nossr50.datatypes.interactions.NotificationType;
 import com.gmail.nossr50.datatypes.player.McMMOPlayer;
 import com.gmail.nossr50.datatypes.player.PlayerProfile;
 import com.gmail.nossr50.datatypes.skills.SubSkillType;
 import com.gmail.nossr50.datatypes.skills.XPGainReason;
-import com.gmail.nossr50.datatypes.skills.subskills.interfaces.RandomChance;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.mcMMO;
-import com.gmail.nossr50.skills.acrobatics.Acrobatics;
 import com.gmail.nossr50.util.EventUtils;
 import com.gmail.nossr50.util.Misc;
 import com.gmail.nossr50.util.Permissions;
 import com.gmail.nossr50.util.player.NotificationManager;
 import com.gmail.nossr50.util.player.UserManager;
+import com.gmail.nossr50.util.random.RandomChanceExecution;
+import com.gmail.nossr50.util.random.RandomChanceSkill;
+import com.gmail.nossr50.util.random.RandomChanceUtil;
 import com.gmail.nossr50.util.skills.PerksUtils;
 import com.gmail.nossr50.util.skills.SkillActivationType;
 import com.gmail.nossr50.util.skills.SkillUtils;
@@ -32,7 +34,7 @@ import org.bukkit.event.EventPriority;
 import org.bukkit.event.entity.EntityDamageEvent;
 import org.bukkit.inventory.ItemStack;
 
-public class Roll extends AcrobaticsSubSkill implements RandomChance {
+public class Roll extends AcrobaticsSubSkill {
     private int fallTries = 0;
     protected Location lastFallLocation;
 
@@ -127,17 +129,14 @@ public class Roll extends AcrobaticsSubSkill implements RandomChance {
         float skillValue = playerProfile.getSkillLevel(getPrimarySkill());
         boolean isLucky = Permissions.lucky(player, getPrimarySkill());
 
-        String[] rollStrings = SkillUtils.calculateAbilityDisplayValues(skillValue, SubSkillType.ACROBATICS_ROLL, isLucky);
+        String[] rollStrings = RandomChanceUtil.calculateAbilityDisplayValues(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, player, SubSkillType.ACROBATICS_ROLL);
         rollChance = rollStrings[0];
         rollChanceLucky = rollStrings[1];
 
         /*
          * Graceful is double the odds of a normal roll
          */
-        String[] gracefulRollStrings = SkillUtils.calculateAbilityDisplayValuesCustom(skillValue,
+        String[] gracefulRollStrings = RandomChanceUtil.calculateAbilityDisplayValuesCustom(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, player, SubSkillType.ACROBATICS_ROLL, 2.0D);
-                isLucky,
-                AdvancedConfig.getInstance().getMaxBonusLevel(this) / 2,
-                AdvancedConfig.getInstance().getMaxChance(this));
         gracefulRollChance = gracefulRollStrings[0];
         gracefulRollChanceLucky = gracefulRollStrings[1];
 
@@ -168,28 +167,6 @@ public class Roll extends AcrobaticsSubSkill implements RandomChance {
 
     }
 
-    /**
-     * Gets the maximum chance for this interaction to succeed
-     *
-     * @return maximum chance for this outcome to succeed
-     */
-    @Override
-    public double getRandomChanceMaxChance() {
-        return AdvancedConfig.getInstance().getMaxChance(this);
-    }
-
-    /**
-     * The maximum bonus level for this skill
-     * This is when the skills level no longer increases the odds of success
-     * For example, setting this to 25 will mean the RandomChance success chance no longer grows after 25
-     *
-     * @return the maximum bonus from skill level for this skill
-     */
-    @Override
-    public int getRandomChanceMaxBonus() {
-        return AdvancedConfig.getInstance().getMaxBonusLevel(this);
-    }
-
     @Override
     public boolean isSuperAbility() {
         return false;
@@ -223,9 +200,10 @@ public class Roll extends AcrobaticsSubSkill implements RandomChance {
             return gracefulRollCheck(player, mcMMOPlayer, damage, skillLevel);
         }
 
-        double modifiedDamage = calculateModifiedRollDamage(damage, Acrobatics.rollThreshold);
+        double modifiedDamage = calculateModifiedRollDamage(damage, AdvancedConfig.getInstance().getRollDamageThreshold());
 
-        if (!isFatal(player, modifiedDamage) && SkillUtils.isActivationSuccessful(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, SubSkillType.ACROBATICS_ROLL, player, skillLevel, getActivationChance(mcMMOPlayer))) {
+        if (!isFatal(player, modifiedDamage)
+                && RandomChanceUtil.isActivationSuccessful(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, SubSkillType.ACROBATICS_ROLL, player)) {
             NotificationManager.sendPlayerInformation(player, NotificationType.SUBSKILL_MESSAGE, "Acrobatics.Roll.Text");
             SoundManager.sendCategorizedSound(player, player.getLocation(), SoundType.ROLL_ACTIVATED, SoundCategory.PLAYERS);
             //player.sendMessage(LocaleLoader.getString("Acrobatics.Roll.Text"));
@@ -258,13 +236,13 @@ public class Roll extends AcrobaticsSubSkill implements RandomChance {
      * @return the modified event damage if the ability was successful, the original event damage otherwise
      */
     private double gracefulRollCheck(Player player, McMMOPlayer mcMMOPlayer, double damage, int skillLevel) {
-        double modifiedDamage = calculateModifiedRollDamage(damage, Acrobatics.gracefulRollThreshold);
+        double modifiedDamage = calculateModifiedRollDamage(damage, AdvancedConfig.getInstance().getRollDamageThreshold() * 2);
+
+        RandomChanceSkill rcs = new RandomChanceSkill(player, subSkillType);
+        rcs.setSkillLevel(rcs.getSkillLevel() * 2); //Double the effective odds
 
         if (!isFatal(player, modifiedDamage)
-                && SkillUtils.isActivationSuccessfulCustom(player,
+                && RandomChanceUtil.checkRandomChanceExecutionSuccess(rcs))
-                this,
-                AdvancedConfig.getInstance().getMaxChance(SubSkillType.ACROBATICS_ROLL),
-                AdvancedConfig.getInstance().getMaxBonusLevel(SubSkillType.ACROBATICS_ROLL) / 2)) //This effectively makes it so you reach the max chance for success at half the requirements of roll's max chance (which would make graceful roll twice as likely per skill level)
         {
             NotificationManager.sendPlayerInformation(player, NotificationType.SUBSKILL_MESSAGE, "Acrobatics.Ability.Proc");
             SoundManager.sendCategorizedSound(player, player.getLocation(), SoundType.ROLL_ACTIVATED, SoundCategory.PLAYERS,0.5F);
@@ -307,10 +285,10 @@ public class Roll extends AcrobaticsSubSkill implements RandomChance {
 
     private float calculateRollXP(Player player, double damage, boolean isRoll) {
         ItemStack boots = player.getInventory().getBoots();
-        float xp = (float) (damage * (isRoll ? Acrobatics.rollXpModifier : Acrobatics.fallXpModifier));
+        float xp = (float) (damage * (isRoll ? ExperienceConfig.getInstance().getRollXPModifier() : ExperienceConfig.getInstance().getFallXPModifier()));
 
         if (boots != null && boots.containsEnchantment(Enchantment.PROTECTION_FALL)) {
-            xp *= Acrobatics.featherFallXPModifier;
+            xp *= ExperienceConfig.getInstance().getFeatherFallXPModifier();
         }
 
         return xp;
@@ -357,6 +335,7 @@ public class Roll extends AcrobaticsSubSkill implements RandomChance {
 
     /**
      * Returns a collection of strings about how a skill works
+     * Used in the MMO Info command
      *
      * @return
      */
@@ -376,20 +355,31 @@ public class Roll extends AcrobaticsSubSkill implements RandomChance {
             MaxBonusLevel: 100
             DamageThreshold: 7.0
          */
-        double rollChanceHalfMax, graceChanceHalfMax, maxBonusLevel, curve, damageThreshold, chancePerLevel;
+        double rollChanceHalfMax, graceChanceHalfMax, damageThreshold, chancePerLevel;
 
-        curve = AdvancedConfig.getInstance().getMaxChance(this);
+        //Chance to roll at half max skill
-        maxBonusLevel = (double) AdvancedConfig.getInstance().getMaxBonusLevel(this);
+        RandomChanceSkill rollHalfMaxSkill = new RandomChanceSkill(null, subSkillType);
+        int halfMaxSkillValue = mcMMO.isRetroModeEnabled() ? 500 : 50;
+        rollHalfMaxSkill.setSkillLevel(halfMaxSkillValue);
 
-        //Chance
+        //Chance to graceful roll at full skill
-        rollChanceHalfMax   = 100 * SkillUtils.getChanceOfSuccess(maxBonusLevel / 2, maxBonusLevel, curve);
+        RandomChanceSkill rollGraceHalfMaxSkill = new RandomChanceSkill(null, subSkillType);
-        graceChanceHalfMax  = 100 * SkillUtils.getChanceOfSuccess(maxBonusLevel / 2, maxBonusLevel, curve / 2);
+        rollGraceHalfMaxSkill.setSkillLevel(halfMaxSkillValue * 2); //Double the effective odds
-        damageThreshold     = AdvancedConfig.getInstance().getRollDamageThreshold();
 
-        chancePerLevel = (1/curve) * maxBonusLevel;
+        //Chance to roll per level
+        RandomChanceSkill rollOneSkillLevel = new RandomChanceSkill(null, subSkillType);
+        rollGraceHalfMaxSkill.setSkillLevel(1); //Level 1 skill
 
+        //Chance Stat Calculations
+        rollChanceHalfMax       = RandomChanceUtil.getRandomChanceExecutionChance(rollHalfMaxSkill);
+        graceChanceHalfMax      = RandomChanceUtil.getRandomChanceExecutionChance(rollGraceHalfMaxSkill);
+        damageThreshold         = AdvancedConfig.getInstance().getRollDamageThreshold();
 
-        return LocaleLoader.getString("Acrobatics.SubSkill.Roll.Mechanics", rollChanceHalfMax, graceChanceHalfMax, maxBonusLevel, chancePerLevel, damageThreshold, damageThreshold * 2);
+        chancePerLevel          = RandomChanceUtil.getRandomChanceExecutionChance(rollOneSkillLevel);
+
+        double maxLevel         = AdvancedConfig.getInstance().getMaxBonusLevel(SubSkillType.ACROBATICS_ROLL);
+
+        return LocaleLoader.getString("Acrobatics.SubSkill.Roll.Mechanics", rollChanceHalfMax, graceChanceHalfMax, maxLevel, chancePerLevel, damageThreshold, damageThreshold * 2);
     }
 
     /**
@@ -401,15 +391,18 @@ public class Roll extends AcrobaticsSubSkill implements RandomChance {
     @Override
     public Double[] getStats(Player player)
     {
-        double curve, maxBonusLevel, playerChanceRoll, playerChanceGrace;
+        double playerChanceRoll, playerChanceGrace;
 
-        curve = AdvancedConfig.getInstance().getMaxChance(this);
+        RandomChanceSkill roll          = new RandomChanceSkill(player, getSubSkillType());
-        maxBonusLevel = (double) AdvancedConfig.getInstance().getMaxBonusLevel(this);
+        RandomChanceSkill graceful      = new RandomChanceSkill(player, getSubSkillType());
 
-        playerChanceRoll        = 100 * SkillUtils.getChanceOfSuccess(UserManager.getPlayer(player).getSkillLevel(getPrimarySkill()), maxBonusLevel, curve);
+        graceful.setSkillLevel(graceful.getSkillLevel() * 2); //Double odds
-        playerChanceGrace       = 100 * SkillUtils.getChanceOfSuccess(UserManager.getPlayer(player).getSkillLevel(getPrimarySkill()), maxBonusLevel, curve / 2);
 
-        Double[] stats = { playerChanceRoll, playerChanceGrace};
+        //Calculate
+        playerChanceRoll        = RandomChanceUtil.getRandomChanceExecutionChance(roll);
+        playerChanceGrace       = RandomChanceUtil.getRandomChanceExecutionChance(graceful);
+
+        Double[] stats = { playerChanceRoll, playerChanceGrace }; //DEBUG
         return stats;
     }
 }

src/main/java/com/gmail/nossr50/datatypes/skills/subskills/interfaces/RandomChance.java

@@ -1,17 +0,0 @@
-package com.gmail.nossr50.datatypes.skills.subskills.interfaces;
-
-public interface RandomChance {
-    /**
-     * Gets the maximum chance for this interaction to succeed
-     * @return maximum chance for this outcome to succeed
-     */
-    double getRandomChanceMaxChance();
-
-    /**
-     * The maximum bonus level for this skill
-     * This is when the skills level no longer increases the odds of success
-     * For example, setting this to 25 will mean the RandomChance success chance no longer grows after 25
-     * @return the maximum bonus from skill level for this skill
-     */
-    int getRandomChanceMaxBonus();
-}

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

@@ -15,6 +15,7 @@ public class SubSkillEvent extends McMMOPlayerSkillEvent implements Cancellable
      * Only skills using the old system will fire this event
      * @param player target player
      * @param subSkillType target subskill
+     * @Deprecated Skills will be using a new system stemming from the AbstractSubSkill class so make sure you check for both events, this event will be removed eventually.
      */
     @Deprecated
     public SubSkillEvent(Player player, SubSkillType subSkillType) {

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

@@ -4,22 +4,22 @@ import com.gmail.nossr50.datatypes.skills.SubSkillType;
 import com.gmail.nossr50.datatypes.skills.subskills.AbstractSubSkill;
 import org.bukkit.entity.Player;
 
-public class SubSkillWeightedActivationCheckEvent extends SubSkillEvent {
+public class SubSkillRandomCheckEvent extends SubSkillEvent {
     private double chance;
 
-    public SubSkillWeightedActivationCheckEvent(Player player, SubSkillType ability, double chance) {
+    public SubSkillRandomCheckEvent(Player player, SubSkillType ability, double chance) {
         super(player, ability);
         this.chance = chance;
     }
 
-    public SubSkillWeightedActivationCheckEvent(Player player, AbstractSubSkill abstractSubSkill, double chance)
+    public SubSkillRandomCheckEvent(Player player, AbstractSubSkill abstractSubSkill, double chance)
     {
         super(player, abstractSubSkill);
         this.chance = chance;
     }
 
     /**
-     * Gets the activation chance of the ability 0D being no chance,  1.0D being 100% chance
+     * Gets the activation chance of the ability 0D being no chance,  100.0D being 100% chance
      *
      * @return The activation chance of the ability
      */
@@ -28,7 +28,7 @@ public class SubSkillWeightedActivationCheckEvent extends SubSkillEvent {
     }
 
     /**
-     * Sets the activation chance of the ability [0D-1.0D]
+     * Sets the activation chance of the ability [0D-100.0D]
      *
      * @param chance The activation chance of the ability
      */
@@ -42,6 +42,6 @@ public class SubSkillWeightedActivationCheckEvent extends SubSkillEvent {
      * @param success whether it should be successful or not
      */
     public void setSuccessful(boolean success) {
-        this.chance = success ? 1.0D : 0D;
+        this.chance = success ? 100.0D : 0D;
     }
 }

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

@@ -62,7 +62,6 @@ public class BleedTimerTask extends BukkitRunnable {
                 MobHealthbarUtils.handleMobHealthbars(target, damage, mcMMO.p); //Update health bars
             }
 
-
             CombatUtils.dealNoInvulnerabilityTickDamage(target, damage, attackerMap.get(target));
             //Play Bleed Sound
             SoundManager.worldSendSound(target.getWorld(), target.getLocation(), SoundType.BLEED);

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

@@ -5,16 +5,8 @@ import com.gmail.nossr50.config.Config;
 import com.gmail.nossr50.config.experience.ExperienceConfig;
 
 public final class Acrobatics {
-    public static double rollThreshold         = AdvancedConfig.getInstance().getRollDamageThreshold();
-    public static double gracefulRollThreshold = AdvancedConfig.getInstance().getGracefulRollDamageThreshold();
     public static double dodgeDamageModifier   = AdvancedConfig.getInstance().getDodgeDamageModifier();
-
     public static int dodgeXpModifier = ExperienceConfig.getInstance().getDodgeXPModifier();
-    public static int rollXpModifier  = ExperienceConfig.getInstance().getRollXPModifier();
-    public static int fallXpModifier  = ExperienceConfig.getInstance().getFallXPModifier();
-
-    public static double featherFallXPModifier = ExperienceConfig.getInstance().getFeatherFallXPModifier();
-
     public static boolean dodgeLightningDisabled = Config.getInstance().getDodgeLightningDisabled();
 
     private Acrobatics() {}

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

@@ -9,6 +9,7 @@ import com.gmail.nossr50.skills.SkillManager;
 import com.gmail.nossr50.util.Misc;
 import com.gmail.nossr50.util.Permissions;
 import com.gmail.nossr50.util.player.NotificationManager;
+import com.gmail.nossr50.util.random.RandomChanceUtil;
 import com.gmail.nossr50.util.skills.ParticleEffectUtils;
 import com.gmail.nossr50.util.skills.SkillActivationType;
 import com.gmail.nossr50.util.skills.SkillUtils;
@@ -44,14 +45,14 @@ public class AcrobaticsManager extends SkillManager {
         double modifiedDamage = Acrobatics.calculateModifiedDodgeDamage(damage, Acrobatics.dodgeDamageModifier);
         Player player = getPlayer();
 
-        if (!isFatal(modifiedDamage) && SkillUtils.isActivationSuccessful(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, SubSkillType.ACROBATICS_DODGE, player, getSkillLevel(), activationChance)) {
+        if (!isFatal(modifiedDamage) && RandomChanceUtil.isActivationSuccessful(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, SubSkillType.ACROBATICS_DODGE, player)) {
             ParticleEffectUtils.playDodgeEffect(player);
 
             if (mcMMOPlayer.useChatNotifications()) {
                 NotificationManager.sendPlayerInformation(player, NotificationType.SUBSKILL_MESSAGE, "Acrobatics.Combat.Proc");
             }
 
-            // Why do we check respawn cooldown here?
+            //Check respawn to prevent abuse
             if (SkillUtils.cooldownExpired(mcMMOPlayer.getRespawnATS(), Misc.PLAYER_RESPAWN_COOLDOWN_SECONDS)) {
                 applyXpGain((float) (damage * Acrobatics.dodgeXpModifier), XPGainReason.PVP);
             }

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

@@ -10,8 +10,8 @@ import com.gmail.nossr50.util.Misc;
 import com.gmail.nossr50.util.Permissions;
 import com.gmail.nossr50.util.player.NotificationManager;
 import com.gmail.nossr50.util.player.UserManager;
+import com.gmail.nossr50.util.random.RandomChanceUtil;
 import com.gmail.nossr50.util.skills.SkillActivationType;
-import com.gmail.nossr50.util.skills.SkillUtils;
 import org.bukkit.Location;
 import org.bukkit.entity.Entity;
 import org.bukkit.entity.LivingEntity;
@@ -59,7 +59,7 @@ public class ArcheryManager extends SkillManager {
      * @param target The {@link LivingEntity} damaged by the arrow
      */
     public void retrieveArrows(LivingEntity target) {
-        if (SkillUtils.isActivationSuccessful(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, SubSkillType.ARCHERY_ARROW_RETRIEVAL, getPlayer(), getSkillLevel(), activationChance)) {
+        if (RandomChanceUtil.isActivationSuccessful(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, SubSkillType.ARCHERY_ARROW_RETRIEVAL, getPlayer())) {
             Archery.incrementTrackerValue(target);
         }
     }
@@ -70,7 +70,7 @@ public class ArcheryManager extends SkillManager {
      * @param defender The {@link Player} being affected by the ability
      */
     public double daze(Player defender) {
-        if (!SkillUtils.isActivationSuccessful(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, SubSkillType.ARCHERY_DAZE, getPlayer(), getSkillLevel(), activationChance)) {
+        if (!RandomChanceUtil.isActivationSuccessful(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, SubSkillType.ARCHERY_DAZE, getPlayer())) {
             return 0;
         }
 
@@ -97,7 +97,7 @@ public class ArcheryManager extends SkillManager {
      * @param oldDamage The raw damage value of this arrow before we modify it
      */
     public double skillShot(double oldDamage) {
-        if (!SkillUtils.isActivationSuccessful(SkillActivationType.ALWAYS_FIRES, SubSkillType.ARCHERY_SKILL_SHOT, getPlayer(), 0, 0)) {
+        if (!RandomChanceUtil.isActivationSuccessful(SkillActivationType.ALWAYS_FIRES, SubSkillType.ARCHERY_SKILL_SHOT, getPlayer())) {
             return oldDamage;
         }
 

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

@@ -11,6 +11,7 @@ import com.gmail.nossr50.util.ItemUtils;
 import com.gmail.nossr50.util.Permissions;
 import com.gmail.nossr50.util.player.NotificationManager;
 import com.gmail.nossr50.util.player.UserManager;
+import com.gmail.nossr50.util.random.RandomChanceUtil;
 import com.gmail.nossr50.util.skills.CombatUtils;
 import com.gmail.nossr50.util.skills.ParticleEffectUtils;
 import com.gmail.nossr50.util.skills.SkillActivationType;
@@ -55,7 +56,7 @@ public class AxesManager extends SkillManager {
      * Handle the effects of the Axe Mastery ability
      */
     public double axeMastery() {
-        if (!SkillUtils.isActivationSuccessful(SkillActivationType.ALWAYS_FIRES, SubSkillType.AXES_AXE_MASTERY, getPlayer(), 0, 0)) {
+        if (!RandomChanceUtil.isActivationSuccessful(SkillActivationType.ALWAYS_FIRES, SubSkillType.AXES_AXE_MASTERY, getPlayer())) {
             return 0;
         }
 
@@ -69,7 +70,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.isActivationSuccessful(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, SubSkillType.AXES_CRITICAL_STRIKES, getPlayer(), getSkillLevel(), activationChance)) {
+        if (!RandomChanceUtil.isActivationSuccessful(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, SubSkillType.AXES_CRITICAL_STRIKES, getPlayer())) {
             return 0;
         }
 
@@ -101,17 +102,21 @@ public class AxesManager extends SkillManager {
      * @param target The {@link LivingEntity} being affected by Impact
      */
     public void impactCheck(LivingEntity target) {
-        int durabilityDamage = 1 + (getSkillLevel() / Axes.impactIncreaseLevel);
+        int durabilityDamage = getImpactDurabilityDamage();
 
         for (ItemStack armor : target.getEquipment().getArmorContents()) {
             if (armor != null && ItemUtils.isArmor(armor)) {
-                if (SkillUtils.isActivationSuccessful(SkillActivationType.RANDOM_STATIC_CHANCE, SubSkillType.AXES_ARMOR_IMPACT, getPlayer(), getSkillLevel(), activationChance)) {
+                if (RandomChanceUtil.isActivationSuccessful(SkillActivationType.RANDOM_STATIC_CHANCE, SubSkillType.AXES_ARMOR_IMPACT, getPlayer())) {
                     SkillUtils.handleDurabilityChange(armor, durabilityDamage, Axes.impactMaxDurabilityModifier);
                 }
             }
         }
     }
 
+    public int getImpactDurabilityDamage() {
+        return 1 + (getSkillLevel() / Axes.impactIncreaseLevel);
+    }
+
     /**
      * Handle the effects of the Greater Impact ability
      *
@@ -119,7 +124,7 @@ public class AxesManager extends SkillManager {
      */
     public double greaterImpact(LivingEntity target) {
         //static chance (3rd param)
-        if (!SkillUtils.isActivationSuccessful(SkillActivationType.RANDOM_STATIC_CHANCE, SubSkillType.AXES_GREATER_IMPACT, getPlayer(), getSkillLevel(), activationChance)) {
+        if (!RandomChanceUtil.isActivationSuccessful(SkillActivationType.RANDOM_STATIC_CHANCE, SubSkillType.AXES_GREATER_IMPACT, getPlayer())) {
             return 0;
         }
 

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

@@ -9,6 +9,9 @@ import com.gmail.nossr50.datatypes.treasure.ExcavationTreasure;
 import com.gmail.nossr50.skills.SkillManager;
 import com.gmail.nossr50.util.Misc;
 import com.gmail.nossr50.util.Permissions;
+import com.gmail.nossr50.util.random.RandomChanceSkillStatic;
+import com.gmail.nossr50.util.random.RandomChanceStatic;
+import com.gmail.nossr50.util.random.RandomChanceUtil;
 import com.gmail.nossr50.util.skills.SkillUtils;
 import org.bukkit.Location;
 import org.bukkit.block.BlockState;
@@ -36,7 +39,8 @@ public class ExcavationManager extends SkillManager {
                 Location location = Misc.getBlockCenter(blockState);
 
                 for (ExcavationTreasure treasure : treasures) {
-                    if (skillLevel >= treasure.getDropLevel() && SkillUtils.treasureDropSuccessful(getPlayer(), treasure.getDropChance(), activationChance)) {
+                    if (skillLevel >= treasure.getDropLevel()
+                            && RandomChanceUtil.checkRandomChanceExecutionSuccess(treasure.getDropChance())) {
                         xp += treasure.getXp();
                         Misc.dropItem(location, treasure.getDrop());
                     }

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

@@ -15,7 +15,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.SubSkillWeightedActivationCheckEvent;
+import com.gmail.nossr50.events.skills.secondaryabilities.SubSkillRandomCheckEvent;
 import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.runnables.skills.KrakenAttackTask;
 import com.gmail.nossr50.skills.SkillManager;
@@ -352,7 +352,7 @@ public class FishingManager extends SkillManager {
     public void shakeCheck(LivingEntity target) {
         fishingTries--; // Because autoclicking to shake is OK.
 
-        SubSkillWeightedActivationCheckEvent activationEvent = new SubSkillWeightedActivationCheckEvent(getPlayer(), SubSkillType.FISHING_SHAKE, getShakeProbability() / activationChance);
+        SubSkillRandomCheckEvent activationEvent = new SubSkillRandomCheckEvent(getPlayer(), SubSkillType.FISHING_SHAKE, getShakeProbability() / activationChance);
         mcMMO.p.getServer().getPluginManager().callEvent(activationEvent);
         if ((activationEvent.getChance() * activationChance) > Misc.getRandom().nextInt(activationChance)) {
             List<ShakeTreasure> possibleDrops = Fishing.findPossibleDrops(target);

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

@@ -13,6 +13,8 @@ import com.gmail.nossr50.runnables.skills.HerbalismBlockUpdaterTask;
 import com.gmail.nossr50.skills.SkillManager;
 import com.gmail.nossr50.util.*;
 import com.gmail.nossr50.util.player.NotificationManager;
+import com.gmail.nossr50.util.random.RandomChanceSkillStatic;
+import com.gmail.nossr50.util.random.RandomChanceUtil;
 import com.gmail.nossr50.util.skills.RankUtils;
 import com.gmail.nossr50.util.skills.SkillActivationType;
 import com.gmail.nossr50.util.skills.SkillUtils;
@@ -159,7 +161,7 @@ public class HerbalismManager extends SkillManager {
         }
 
         for (int i = greenTerra ? 2 : 1; i != 0; i--) {
-            if (SkillUtils.isActivationSuccessful(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, SubSkillType.HERBALISM_DOUBLE_DROPS, player, getSkillLevel(), activationChance)) {
+            if (RandomChanceUtil.isActivationSuccessful(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, SubSkillType.HERBALISM_DOUBLE_DROPS, player)) {
                 for (ItemStack item : drops) {
                     Misc.dropItems(Misc.getBlockCenter(blockState), item, amount);
                 }
@@ -174,7 +176,7 @@ public class HerbalismManager extends SkillManager {
      * @return true if the ability was successful, false otherwise
      */
     public boolean processGreenThumbBlocks(BlockState blockState) {
-        if (!SkillUtils.isActivationSuccessful(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, SubSkillType.HERBALISM_GREEN_THUMB, getPlayer(), getSkillLevel(), activationChance)) {
+        if (!RandomChanceUtil.isActivationSuccessful(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, SubSkillType.HERBALISM_GREEN_THUMB, getPlayer())) {
             NotificationManager.sendPlayerInformation(getPlayer(), NotificationType.SUBSKILL_MESSAGE_FAILURE, "Herbalism.Ability.GTh.Fail");
             return false;
         }
@@ -189,7 +191,7 @@ public class HerbalismManager extends SkillManager {
      * @return true if the ability was successful, false otherwise
      */
     public boolean processHylianLuck(BlockState blockState) {
-        if (!SkillUtils.isActivationSuccessful(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, SubSkillType.HERBALISM_HYLIAN_LUCK, getPlayer(), getSkillLevel(), activationChance)) {
+        if (!RandomChanceUtil.isActivationSuccessful(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, SubSkillType.HERBALISM_HYLIAN_LUCK, getPlayer())) {
             return false;
         }
 
@@ -207,7 +209,8 @@ public class HerbalismManager extends SkillManager {
         Location location = Misc.getBlockCenter(blockState);
 
         for (HylianTreasure treasure : treasures) {
-            if (skillLevel >= treasure.getDropLevel() && SkillUtils.treasureDropSuccessful(getPlayer(), treasure.getDropChance(), activationChance)) {
+            if (skillLevel >= treasure.getDropLevel()
+                    && RandomChanceUtil.checkRandomChanceExecutionSuccess(new RandomChanceSkillStatic(treasure.getDropChance(), getPlayer(), SubSkillType.HERBALISM_HYLIAN_LUCK))) {
                 if (!EventUtils.simulateBlockBreak(blockState.getBlock(), player, false)) {
                     return false;
                 }
@@ -244,7 +247,7 @@ public class HerbalismManager extends SkillManager {
         playerInventory.removeItem(new ItemStack(Material.RED_MUSHROOM));
         player.updateInventory();
 
-        if (!SkillUtils.isActivationSuccessful(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, SubSkillType.HERBALISM_SHROOM_THUMB, player, getSkillLevel(), activationChance)) {
+        if (!RandomChanceUtil.isActivationSuccessful(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, SubSkillType.HERBALISM_SHROOM_THUMB, player)) {
             NotificationManager.sendPlayerInformation(player, NotificationType.SUBSKILL_MESSAGE_FAILURE, "Herbalism.Ability.ShroomThumb.Fail");
             return false;
         }
@@ -301,7 +304,7 @@ public class HerbalismManager extends SkillManager {
             return;
         }
 
-        if (!greenTerra && !SkillUtils.isActivationSuccessful(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, SubSkillType.HERBALISM_GREEN_THUMB, player, getSkillLevel(), activationChance)) {
+        if (!greenTerra && !RandomChanceUtil.isActivationSuccessful(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, SubSkillType.HERBALISM_GREEN_THUMB, player)) {
             return;
         }
 

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

@@ -16,6 +16,7 @@ import com.gmail.nossr50.util.EventUtils;
 import com.gmail.nossr50.util.Misc;
 import com.gmail.nossr50.util.Permissions;
 import com.gmail.nossr50.util.player.NotificationManager;
+import com.gmail.nossr50.util.random.RandomChanceUtil;
 import com.gmail.nossr50.util.skills.RankUtils;
 import com.gmail.nossr50.util.skills.SkillActivationType;
 import com.gmail.nossr50.util.skills.SkillUtils;
@@ -82,7 +83,7 @@ public class MiningManager extends SkillManager {
 
         //TODO: Make this readable
         for (int i = mcMMOPlayer.getAbilityMode(skill.getAbility()) ? 2 : 1; i != 0; i--) {
-            if (SkillUtils.isActivationSuccessful(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, SubSkillType.MINING_DOUBLE_DROPS, player, getSkillLevel(), activationChance)) {
+            if (RandomChanceUtil.isActivationSuccessful(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, SubSkillType.MINING_DOUBLE_DROPS, player)) {
                 if (silkTouch) {
                     Mining.handleSilkTouchDrops(blockState);
                 }

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

@@ -17,6 +17,7 @@ import com.gmail.nossr50.util.Misc;
 import com.gmail.nossr50.util.Permissions;
 import com.gmail.nossr50.util.StringUtils;
 import com.gmail.nossr50.util.player.NotificationManager;
+import com.gmail.nossr50.util.random.RandomChanceUtil;
 import com.gmail.nossr50.util.skills.RankUtils;
 import com.gmail.nossr50.util.skills.SkillActivationType;
 import com.gmail.nossr50.util.skills.SkillUtils;
@@ -282,7 +283,7 @@ public class RepairManager extends SkillManager {
      * @return true if bonus granted, false otherwise
      */
     private boolean checkPlayerProcRepair() {
-        if (SkillUtils.isActivationSuccessful(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, SubSkillType.REPAIR_SUPER_REPAIR, getPlayer(), getSkillLevel(), activationChance)) {
+        if (RandomChanceUtil.isActivationSuccessful(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, SubSkillType.REPAIR_SUPER_REPAIR, getPlayer())) {
             NotificationManager.sendPlayerInformation(getPlayer(), NotificationType.SUBSKILL_MESSAGE, "Repair.Skills.FeltEasy");
             return true;
         }

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

@@ -5,7 +5,7 @@ import com.gmail.nossr50.datatypes.player.McMMOPlayer;
 import com.gmail.nossr50.datatypes.skills.PrimarySkillType;
 import com.gmail.nossr50.datatypes.skills.SubSkillType;
 import com.gmail.nossr50.datatypes.skills.XPGainReason;
-import com.gmail.nossr50.events.skills.secondaryabilities.SubSkillWeightedActivationCheckEvent;
+import com.gmail.nossr50.events.skills.secondaryabilities.SubSkillRandomCheckEvent;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.skills.SkillManager;
@@ -14,6 +14,7 @@ import com.gmail.nossr50.util.BlockUtils;
 import com.gmail.nossr50.util.EventUtils;
 import com.gmail.nossr50.util.Misc;
 import com.gmail.nossr50.util.Permissions;
+import com.gmail.nossr50.util.random.RandomChanceUtil;
 import com.gmail.nossr50.util.skills.ParticleEffectUtils;
 import com.gmail.nossr50.util.skills.RankUtils;
 import com.gmail.nossr50.util.skills.SkillActivationType;
@@ -42,7 +43,7 @@ public class SmeltingManager extends SkillManager {
     }
 
     public boolean isSecondSmeltSuccessful() {
-        return Permissions.isSubSkillEnabled(getPlayer(), SubSkillType.SMELTING_SECOND_SMELT) && SkillUtils.isActivationSuccessful(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, SubSkillType.SMELTING_SECOND_SMELT, getPlayer(), getSkillLevel(), activationChance);
+        return Permissions.isSubSkillEnabled(getPlayer(), SubSkillType.SMELTING_SECOND_SMELT) && RandomChanceUtil.isActivationSuccessful(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, SubSkillType.SMELTING_SECOND_SMELT, getPlayer());
     }
 
     /**
@@ -54,7 +55,7 @@ public class SmeltingManager extends SkillManager {
     public boolean processFluxMining(BlockState blockState) {
         Player player = getPlayer();
 
-        SubSkillWeightedActivationCheckEvent event = new SubSkillWeightedActivationCheckEvent(getPlayer(), SubSkillType.SMELTING_FLUX_MINING, Smelting.fluxMiningChance / activationChance);
+        SubSkillRandomCheckEvent event = new SubSkillRandomCheckEvent(getPlayer(), SubSkillType.SMELTING_FLUX_MINING, Smelting.fluxMiningChance / activationChance);
         mcMMO.p.getServer().getPluginManager().callEvent(event);
         if ((event.getChance() * activationChance) > Misc.getRandom().nextInt(activationChance)) {
             ItemStack item = null;

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

@@ -11,10 +11,10 @@ import com.gmail.nossr50.skills.SkillManager;
 import com.gmail.nossr50.util.Permissions;
 import com.gmail.nossr50.util.player.NotificationManager;
 import com.gmail.nossr50.util.player.UserManager;
+import com.gmail.nossr50.util.random.RandomChanceUtil;
 import com.gmail.nossr50.util.skills.CombatUtils;
 import com.gmail.nossr50.util.skills.RankUtils;
 import com.gmail.nossr50.util.skills.SkillActivationType;
-import com.gmail.nossr50.util.skills.SkillUtils;
 import org.bukkit.entity.Entity;
 import org.bukkit.entity.LivingEntity;
 import org.bukkit.entity.Player;
@@ -49,7 +49,7 @@ public class SwordsManager extends SkillManager {
      * @param target The defending entity
      */
     public void ruptureCheck(LivingEntity target) {
-        if (SkillUtils.isActivationSuccessful(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, SubSkillType.SWORDS_RUPTURE, getPlayer(), getSkillLevel(), activationChance)) {
+        if (RandomChanceUtil.isActivationSuccessful(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, SubSkillType.SWORDS_RUPTURE, getPlayer())) {
 
             if (target instanceof Player) {
                 Player defender = (Player) target;
@@ -85,7 +85,7 @@ public class SwordsManager extends SkillManager {
      * @param damage The amount of damage initially dealt by the event
      */
     public void counterAttackChecks(LivingEntity attacker, double damage) {
-        if (SkillUtils.isActivationSuccessful(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, SubSkillType.SWORDS_COUNTER_ATTACK, getPlayer(), getSkillLevel(), activationChance)) {
+        if (RandomChanceUtil.isActivationSuccessful(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, SubSkillType.SWORDS_COUNTER_ATTACK, getPlayer())) {
             CombatUtils.dealDamage(attacker, damage / Swords.counterAttackModifier, getPlayer());
 
             NotificationManager.sendPlayerInformation(getPlayer(), NotificationType.SUBSKILL_MESSAGE, "Swords.Combat.Countered");

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

@@ -9,7 +9,7 @@ import com.gmail.nossr50.datatypes.skills.PrimarySkillType;
 import com.gmail.nossr50.datatypes.skills.SubSkillType;
 import com.gmail.nossr50.datatypes.skills.XPGainReason;
 import com.gmail.nossr50.events.fake.FakeEntityTameEvent;
-import com.gmail.nossr50.events.skills.secondaryabilities.SubSkillWeightedActivationCheckEvent;
+import com.gmail.nossr50.events.skills.secondaryabilities.SubSkillRandomCheckEvent;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.mcMMO;
 import com.gmail.nossr50.runnables.skills.BleedTimerTask;
@@ -19,9 +19,9 @@ import com.gmail.nossr50.util.Permissions;
 import com.gmail.nossr50.util.StringUtils;
 import com.gmail.nossr50.util.player.NotificationManager;
 import com.gmail.nossr50.util.player.UserManager;
+import com.gmail.nossr50.util.random.RandomChanceUtil;
 import com.gmail.nossr50.util.skills.ParticleEffectUtils;
 import com.gmail.nossr50.util.skills.SkillActivationType;
-import com.gmail.nossr50.util.skills.SkillUtils;
 import org.bukkit.Location;
 import org.bukkit.Sound;
 import org.bukkit.entity.*;
@@ -87,7 +87,7 @@ public class TamingManager extends SkillManager {
      */
     public void fastFoodService(Wolf wolf, double damage) {
         //static chance (3rd param)
-        if (!SkillUtils.isActivationSuccessful(SkillActivationType.RANDOM_STATIC_CHANCE, SubSkillType.TAMING_FAST_FOOD_SERVICE, getPlayer(), getSkillLevel(), activationChance)) {
+        if (!RandomChanceUtil.isActivationSuccessful(SkillActivationType.RANDOM_STATIC_CHANCE, SubSkillType.TAMING_FAST_FOOD_SERVICE, getPlayer())) {
             return;
         }
 
@@ -107,7 +107,7 @@ public class TamingManager extends SkillManager {
      * @param damage The initial damage
      */
     public double gore(LivingEntity target, double damage) {
-        if (!SkillUtils.isActivationSuccessful(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, SubSkillType.TAMING_GORE, getPlayer(), getSkillLevel(), activationChance)) {
+        if (!RandomChanceUtil.isActivationSuccessful(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, SubSkillType.TAMING_GORE, getPlayer())) {
             return 0;
         }
 
@@ -192,7 +192,7 @@ public class TamingManager extends SkillManager {
 
     public void pummel(LivingEntity target, Wolf wolf) {
         double chance = 10 / activationChance;
-        SubSkillWeightedActivationCheckEvent event = new SubSkillWeightedActivationCheckEvent(getPlayer(), SubSkillType.TAMING_PUMMEL, chance);
+        SubSkillRandomCheckEvent event = new SubSkillRandomCheckEvent(getPlayer(), SubSkillType.TAMING_PUMMEL, chance);
         mcMMO.p.getServer().getPluginManager().callEvent(event);
         if ((event.getChance() * activationChance) <= Misc.getRandom().nextInt(activationChance)) {
             return;

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

@@ -15,8 +15,8 @@ import com.gmail.nossr50.util.Misc;
 import com.gmail.nossr50.util.Permissions;
 import com.gmail.nossr50.util.player.NotificationManager;
 import com.gmail.nossr50.util.player.UserManager;
+import com.gmail.nossr50.util.random.RandomChanceUtil;
 import com.gmail.nossr50.util.skills.SkillActivationType;
-import com.gmail.nossr50.util.skills.SkillUtils;
 import org.bukkit.Material;
 import org.bukkit.block.BlockState;
 import org.bukkit.block.data.BlockData;
@@ -57,7 +57,7 @@ public class UnarmedManager extends SkillManager {
     }
 
     public boolean blockCrackerCheck(BlockState blockState) {
-        if (!SkillUtils.isActivationSuccessful(SkillActivationType.ALWAYS_FIRES, SubSkillType.UNARMED_BLOCK_CRACKER, getPlayer(), 0, 0)) {
+        if (!RandomChanceUtil.isActivationSuccessful(SkillActivationType.ALWAYS_FIRES, SubSkillType.UNARMED_BLOCK_CRACKER, getPlayer())) {
             return false;
         }
 
@@ -83,7 +83,7 @@ public class UnarmedManager extends SkillManager {
      * @param defender The defending player
      */
     public void disarmCheck(Player defender) {
-        if (SkillUtils.isActivationSuccessful(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, SubSkillType.UNARMED_DISARM, getPlayer(), getSkillLevel(), activationChance) && !hasIronGrip(defender)) {
+        if (RandomChanceUtil.isActivationSuccessful(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, SubSkillType.UNARMED_DISARM, getPlayer()) && !hasIronGrip(defender)) {
             if (EventUtils.callDisarmEvent(defender).isCancelled()) {
                 return;
             }
@@ -103,7 +103,7 @@ public class UnarmedManager extends SkillManager {
      * Check for arrow deflection.
      */
     public boolean deflectCheck() {
-        if (SkillUtils.isActivationSuccessful(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, SubSkillType.UNARMED_ARROW_DEFLECT, getPlayer(), getSkillLevel(), activationChance)) {
+        if (RandomChanceUtil.isActivationSuccessful(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, SubSkillType.UNARMED_ARROW_DEFLECT, getPlayer())) {
             NotificationManager.sendPlayerInformation(getPlayer(), NotificationType.SUBSKILL_MESSAGE, "Combat.ArrowDeflect");
             return true;
         }
@@ -126,11 +126,15 @@ public class UnarmedManager extends SkillManager {
      * Handle the effects of the Iron Arm ability
      */
     public double ironArm() {
-        if (!SkillUtils.isActivationSuccessful(SkillActivationType.ALWAYS_FIRES, SubSkillType.UNARMED_IRON_ARM_STYLE, getPlayer(), 0, 0)) {
+        if (!RandomChanceUtil.isActivationSuccessful(SkillActivationType.ALWAYS_FIRES, SubSkillType.UNARMED_IRON_ARM_STYLE, getPlayer())) {
             return 0;
         }
 
         //linear check no cap
+        return getIronArmDamage();
+    }
+
+    public double getIronArmDamage() {
         return Math.min(Unarmed.ironArmMinBonusDamage + (getSkillLevel() / Unarmed.ironArmIncreaseLevel), Unarmed.ironArmMaxBonusDamage);
     }
 
@@ -141,7 +145,8 @@ 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.isSubSkillEnabled(defender, SubSkillType.UNARMED_IRON_GRIP) && SkillUtils.isActivationSuccessful(SkillActivationType.RANDOM_LINEAR_100_SCALE_NO_CAP, SubSkillType.UNARMED_IRON_GRIP, getPlayer(), getSkillLevel(), activationChance)) {
+        if (!Misc.isNPCEntity(defender) && Permissions.isSubSkillEnabled(defender, SubSkillType.UNARMED_IRON_GRIP)
+                && RandomChanceUtil.isActivationSuccessful(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, SubSkillType.UNARMED_IRON_GRIP, getPlayer())) {
             NotificationManager.sendPlayerInformation(defender, NotificationType.SUBSKILL_MESSAGE, "Unarmed.Ability.IronGrip.Defender");
             NotificationManager.sendPlayerInformation(getPlayer(), NotificationType.SUBSKILL_MESSAGE, "Unarmed.Ability.IronGrip.Attacker");
 

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

@@ -12,10 +12,10 @@ import com.gmail.nossr50.skills.SkillManager;
 import com.gmail.nossr50.skills.woodcutting.Woodcutting.ExperienceGainMethod;
 import com.gmail.nossr50.util.*;
 import com.gmail.nossr50.util.player.NotificationManager;
+import com.gmail.nossr50.util.random.RandomChanceUtil;
 import com.gmail.nossr50.util.skills.CombatUtils;
 import com.gmail.nossr50.util.skills.RankUtils;
 import com.gmail.nossr50.util.skills.SkillActivationType;
-import com.gmail.nossr50.util.skills.SkillUtils;
 import org.bukkit.Material;
 import org.bukkit.block.Block;
 import org.bukkit.block.BlockState;
@@ -44,7 +44,7 @@ public class WoodcuttingManager extends SkillManager {
     protected boolean canGetDoubleDrops() {
         return Permissions.isSubSkillEnabled(getPlayer(), SubSkillType.WOODCUTTING_HARVEST_LUMBER)
                 && RankUtils.hasReachedRank(1, getPlayer(), SubSkillType.WOODCUTTING_HARVEST_LUMBER)
-                && SkillUtils.isActivationSuccessful(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, SubSkillType.WOODCUTTING_HARVEST_LUMBER, getPlayer(), getSkillLevel(), activationChance);
+                && RandomChanceUtil.isActivationSuccessful(SkillActivationType.RANDOM_LINEAR_100_SCALE_WITH_CAP, SubSkillType.WOODCUTTING_HARVEST_LUMBER, getPlayer());
     }
 
     /**

src/main/java/com/gmail/nossr50/util/random/InvalidActivationException.java

@@ -0,0 +1,5 @@
+package com.gmail.nossr50.util.random;
+
+public class InvalidActivationException extends Exception {
+    //Weee
+}

src/main/java/com/gmail/nossr50/util/random/InvalidStaticChance.java

@@ -0,0 +1,5 @@
+package com.gmail.nossr50.util.random;
+
+public class InvalidStaticChance extends Exception {
+    //Weeee
+}

src/main/java/com/gmail/nossr50/util/random/RandomChanceExecution.java

@@ -0,0 +1,16 @@
+package com.gmail.nossr50.util.random;
+
+public interface RandomChanceExecution {
+    /**
+     * Gets the XPos used in the formula for success
+     * @return value of x for our success probability graph
+     */
+    double getXPos();
+
+    /**
+     * The maximum odds for this RandomChanceExecution
+     * For example, if this value is 10, then 10% odds would be the maximum and would be achieved only when xPos equaled the LinearCurvePeak
+     * @return maximum probability odds from 0.00 (no chance of ever happened) to 100.0 (probability can be guaranteed)
+     */
+    double getProbabilityCap();
+}

src/main/java/com/gmail/nossr50/util/random/RandomChanceSkill.java

@@ -0,0 +1,100 @@
+package com.gmail.nossr50.util.random;
+
+import com.gmail.nossr50.config.AdvancedConfig;
+import com.gmail.nossr50.datatypes.skills.PrimarySkillType;
+import com.gmail.nossr50.datatypes.skills.SubSkillType;
+import com.gmail.nossr50.util.player.UserManager;
+import org.bukkit.entity.Player;
+
+public class RandomChanceSkill implements RandomChanceExecution {
+
+    protected final PrimarySkillType primarySkillType;
+    protected final SubSkillType subSkillType;
+    protected final double probabilityCap;
+    private int skillLevel;
+
+    public RandomChanceSkill(Player player, SubSkillType subSkillType)
+    {
+        this.primarySkillType = subSkillType.getParentSkill();
+        this.subSkillType = subSkillType;
+        this.probabilityCap = RandomChanceUtil.LINEAR_CURVE_VAR;
+
+        if(player != null)
+            this.skillLevel = UserManager.getPlayer(player).getSkillLevel(primarySkillType);
+        else
+            this.skillLevel = 0;
+    }
+
+    public RandomChanceSkill(Player player, SubSkillType subSkillType, boolean hasCap)
+    {
+        if(hasCap)
+            this.probabilityCap = AdvancedConfig.getInstance().getMaximumProbability(subSkillType);
+        else
+            this.probabilityCap = RandomChanceUtil.LINEAR_CURVE_VAR;
+
+        this.primarySkillType = subSkillType.getParentSkill();
+        this.subSkillType = subSkillType;
+
+        if(player != null)
+            this.skillLevel = UserManager.getPlayer(player).getSkillLevel(primarySkillType);
+        else
+            this.skillLevel = 0;
+    }
+
+    /**
+     * The subskill corresponding to this RandomChanceSkill
+     * @return this subskill
+     */
+    public SubSkillType getSubSkill() {
+        return subSkillType;
+    }
+
+    /**
+     * Gets the skill level of the player who owns this RandomChanceSkill
+     * @return the current skill level relating to this RandomChanceSkill
+     */
+    public int getSkillLevel()
+    {
+        return skillLevel;
+    }
+
+    /**
+     * Modify the skill level used for this skill's RNG calculations
+     * @param newSkillLevel new skill level
+     */
+    public void setSkillLevel(int newSkillLevel) {
+        skillLevel = newSkillLevel;
+    }
+
+    /**
+     * The maximum bonus level for this skill
+     * This is when the skills level no longer increases the odds of success
+     * For example, a value of 25 will mean the success chance no longer grows after skill level 25
+     *
+     * @return the maximum bonus from skill level for this skill
+     */
+    public double getMaximumBonusLevelCap() {
+        return AdvancedConfig.getInstance().getMaxBonusLevel(subSkillType);
+    }
+
+    /**
+     * Gets the XPos used in the formula for success
+     *
+     * @return value of x for our success probability graph
+     */
+    @Override
+    public double getXPos() {
+        return getSkillLevel();
+    }
+
+    /**
+     * The maximum odds for this RandomChanceExecution
+     * For example, if this value is 10, then 10% odds would be the maximum and would be achieved only when xPos equaled the LinearCurvePeak
+     *
+     * @return maximum probability odds from 0.00 (no chance of ever happened) to 100.0 (probability can be guaranteed)
+     */
+    @Override
+    public double getProbabilityCap() {
+        return probabilityCap;
+    }
+}

src/main/java/com/gmail/nossr50/util/random/RandomChanceSkillStatic.java

@@ -0,0 +1,36 @@
+package com.gmail.nossr50.util.random;
+
+import com.gmail.nossr50.datatypes.skills.SubSkillType;
+import org.bukkit.entity.Player;
+
+public class RandomChanceSkillStatic extends RandomChanceSkill {
+    private final double xPos;
+
+    public RandomChanceSkillStatic(double xPos, Player player, SubSkillType subSkillType)
+    {
+        super(player, subSkillType);
+
+        this.xPos = xPos;
+    }
+
+    /**
+     * Gets the XPos used in the formula for success
+     *
+     * @return value of x for our success probability graph
+     */
+    @Override
+    public double getXPos() {
+        return xPos;
+    }
+
+    /**
+     * The maximum odds for this RandomChanceExecution
+     * For example, if this value is 10, then 10% odds would be the maximum and would be achieved only when xPos equaled the LinearCurvePeak
+     *
+     * @return maximum probability odds from 0.00 (no chance of ever happened) to 100.0 (probability can be guaranteed)
+     */
+    @Override
+    public double getProbabilityCap() {
+        return probabilityCap;
+    }
+}

src/main/java/com/gmail/nossr50/util/random/RandomChanceStatic.java

@@ -0,0 +1,33 @@
+package com.gmail.nossr50.util.random;
+
+public class RandomChanceStatic implements RandomChanceExecution {
+    private final double xPos;
+    private final double probabilityCap;
+
+    public RandomChanceStatic(double xPos)
+    {
+        this.xPos = xPos;
+        this.probabilityCap = xPos;
+    }
+
+    /**
+     * Gets the XPos used in the formula for success
+     *
+     * @return value of x for our success probability graph
+     */
+    @Override
+    public double getXPos() {
+        return xPos;
+    }
+
+    /**
+     * The maximum odds for this RandomChanceExecution
+     * For example, if this value is 10, then 10% odds would be the maximum and would be achieved only when xPos equaled the LinearCurvePeak
+     *
+     * @return maximum probability odds from 0.00 (no chance of ever happened) to 100.0 (probability can be guaranteed)
+     */
+    @Override
+    public double getProbabilityCap() {
+        return probabilityCap;
+    }
+}

src/main/java/com/gmail/nossr50/util/random/RandomChanceUtil.java

@@ -0,0 +1,286 @@
+package com.gmail.nossr50.util.random;
+
+import com.gmail.nossr50.config.AdvancedConfig;
+import com.gmail.nossr50.datatypes.skills.PrimarySkillType;
+import com.gmail.nossr50.datatypes.skills.SubSkillType;
+import com.gmail.nossr50.datatypes.skills.subskills.AbstractSubSkill;
+import com.gmail.nossr50.events.skills.secondaryabilities.SubSkillEvent;
+import com.gmail.nossr50.events.skills.secondaryabilities.SubSkillRandomCheckEvent;
+import com.gmail.nossr50.mcMMO;
+import com.gmail.nossr50.util.EventUtils;
+import com.gmail.nossr50.util.Misc;
+import com.gmail.nossr50.util.Permissions;
+import com.gmail.nossr50.util.skills.SkillActivationType;
+import org.bukkit.entity.Player;
+
+import java.text.DecimalFormat;
+import java.util.Random;
+
+public class RandomChanceUtil
+{
+    public static final DecimalFormat percent = new DecimalFormat("##0.00%");
+    //public static final DecimalFormat decimal = new DecimalFormat("##0.00");
+    public static final double LINEAR_CURVE_VAR = 100.0D;
+
+    /**
+     * This method is the final step in determining if a Sub-Skill / Secondary Skill in mcMMO successfully activates either from chance or otherwise
+     * Random skills check for success based on numbers and then fire a cancellable event, if that event is not cancelled they succeed
+     * non-RNG skills just fire the cancellable event and succeed if they go uncancelled
+     *
+     * @param skillActivationType this value represents what kind of activation procedures this sub-skill uses
+     * @param subSkillType The identifier for this specific sub-skill
+     * @param player The owner of this sub-skill
+     * @return returns true if all conditions are met and they event is not cancelled
+     */
+    public static boolean isActivationSuccessful(SkillActivationType skillActivationType, SubSkillType subSkillType, Player player)
+    {
+        switch(skillActivationType)
+        {
+            case RANDOM_LINEAR_100_SCALE_WITH_CAP:
+                return checkRandomChanceExecutionSuccess(player, subSkillType, true);
+            case RANDOM_STATIC_CHANCE:
+                return checkRandomStaticChanceExecutionSuccess(player, subSkillType);
+            case ALWAYS_FIRES:
+                SubSkillEvent event = EventUtils.callSubSkillEvent(player, subSkillType);
+                return !event.isCancelled();
+            default:
+                return false;
+        }
+    }
+
+    public static double getActivationChance(SkillActivationType skillActivationType, SubSkillType subSkillType, Player player)
+    {
+        switch(skillActivationType)
+        {
+            case RANDOM_LINEAR_100_SCALE_WITH_CAP:
+                return getRandomChanceExecutionSuccess(player, subSkillType, true);
+            case RANDOM_STATIC_CHANCE:
+                return getRandomStaticChanceExecutionSuccess(player, subSkillType);
+            default:
+                return 0.1337;
+        }
+    }
+
+    /**
+     * Checks whether or not the random chance succeeds
+     * @return true if the random chance succeeds
+     */
+    public static boolean checkRandomChanceExecutionSuccess(double chance)
+    {
+        //Check the odds
+        chance *= 100;
+
+        /*
+         * Stuff like treasures can specify a drop chance from 0.05 to 100
+         * Because of that we need to use a large int bound and multiply the chance by 100
+         */
+        return rollDice(chance, 10000);
+    }
+
+    public static boolean rollDice(double chanceOfSuccess, int bound) {
+        Random random = new Random();
+
+        if (chanceOfSuccess > random.nextInt(bound))
+            return true;
+        else
+            return false;
+    }
+
+    /**
+     * Used for stuff like Excavation, Fishing, etc...
+     * @param randomChance
+     * @return
+     */
+    public static boolean checkRandomChanceExecutionSuccess(RandomChanceSkillStatic randomChance)
+    {
+        double chanceOfSuccess = calculateChanceOfSuccess(randomChance);
+
+        //Check the odds
+        return rollDice(chanceOfSuccess, 100);
+    }
+
+    public static boolean checkRandomChanceExecutionSuccess(RandomChanceSkill randomChance)
+    {
+        double chanceOfSuccess = calculateChanceOfSuccess(randomChance);
+
+        Random random = new Random();
+
+        //Check the odds
+        return rollDice(chanceOfSuccess, 100);
+    }
+
+
+    /*public static double getRandomChanceExecutionChance(RandomChanceSkill randomChance)
+    {
+        double chanceOfSuccess = calculateChanceOfSuccess(randomChance);
+        return chanceOfSuccess;
+    }*/
+
+    /**
+     * Gets the Static Chance for something to activate
+     * @param randomChance
+     * @return
+     */
+    public static double getRandomChanceExecutionChance(RandomChanceExecution randomChance) {
+        double chanceOfSuccess = getChanceOfSuccess(randomChance.getXPos(), randomChance.getProbabilityCap(), LINEAR_CURVE_VAR);
+        return chanceOfSuccess;
+    }
+
+    /*private static double calculateChanceOfSuccess(RandomChanceStatic randomChance) {
+        double chanceOfSuccess = getChanceOfSuccess(randomChance.getXPos(), randomChance.getProbabilityCap());
+        return chanceOfSuccess;
+    }*/
+
+    private static double calculateChanceOfSuccess(RandomChanceSkill randomChance) {
+        double skillLevel = randomChance.getSkillLevel();
+        double maximumProbability = randomChance.getProbabilityCap();
+        double maximumBonusLevel = randomChance.getMaximumBonusLevelCap();
+
+        double chanceOfSuccess;
+
+        if (skillLevel >= maximumBonusLevel) {
+            //Chance of success is equal to the maximum probability if the maximum bonus level has been reached
+            chanceOfSuccess = maximumProbability;
+        } else {
+            //Get chance of success
+            chanceOfSuccess = getChanceOfSuccess(randomChance.getXPos(), maximumProbability, maximumBonusLevel);
+        }
+        return chanceOfSuccess;
+    }
+
+    /**
+     * The formula for RNG success is determined like this
+     * maximum probability * ( x / maxlevel )
+     *
+     * @return the chance of success from 0-100 (100 = guaranteed)
+     */
+    private static int getChanceOfSuccess(double x, double y, double z)
+    {
+        //return (int) (x / (y / LINEAR_CURVE_VAR));
+        return (int) (y * (x/z));
+        // max probability * (weight/maxlevel) = chance of success
+    }
+
+    private static int getChanceOfSuccess(double x, double y)
+    {
+        return (int) (x / (y / LINEAR_CURVE_VAR));
+        // max probability * (weight/maxlevel) = chance of success
+    }
+
+    public static double getRandomChanceExecutionSuccess(Player player, SubSkillType subSkillType, boolean hasCap)
+    {
+        RandomChanceSkill rcs = new RandomChanceSkill(player, subSkillType, hasCap);
+        return getRandomChanceExecutionChance(rcs);
+    }
+
+    public static double getRandomStaticChanceExecutionSuccess(Player player, SubSkillType subSkillType)
+    {
+        try {
+            return getRandomChanceExecutionChance(new RandomChanceSkillStatic(getStaticRandomChance(subSkillType), player, subSkillType));
+        } catch (InvalidStaticChance invalidStaticChance) {
+            //Catch invalid static skills
+            invalidStaticChance.printStackTrace();
+        }
+
+        return 0.1337; //Puts on shades
+    }
+
+    public static boolean checkRandomChanceExecutionSuccess(Player player, SubSkillType subSkillType, boolean hasCap)
+    {
+        return checkRandomChanceExecutionSuccess(new RandomChanceSkill(player, subSkillType, hasCap));
+    }
+
+    public static boolean checkRandomChanceExecutionSuccess(Player player, SubSkillType subSkillType)
+    {
+        return checkRandomChanceExecutionSuccess(new RandomChanceSkill(player, subSkillType));
+    }
+
+    public static boolean checkRandomStaticChanceExecutionSuccess(Player player, SubSkillType subSkillType)
+    {
+        try {
+            return checkRandomChanceExecutionSuccess(new RandomChanceSkillStatic(getStaticRandomChance(subSkillType), player, subSkillType));
+        } catch (InvalidStaticChance invalidStaticChance) {
+            //Catch invalid static skills
+            invalidStaticChance.printStackTrace();
+        }
+
+        return false;
+    }
+
+    /**
+     * Grabs static activation rolls for Secondary Abilities
+     * @param subSkillType The secondary ability to grab properties of
+     * @throws InvalidStaticChance if the skill has no defined static chance this exception will be thrown and you should know you're a naughty boy
+     * @return The static activation roll involved in the RNG calculation
+     */
+    public static double getStaticRandomChance(SubSkillType subSkillType) throws InvalidStaticChance
+    {
+        switch(subSkillType)
+        {
+            case AXES_ARMOR_IMPACT:
+                return AdvancedConfig.getInstance().getImpactChance();
+            case AXES_GREATER_IMPACT:
+                return AdvancedConfig.getInstance().getGreaterImpactChance();
+            case TAMING_FAST_FOOD_SERVICE:
+                return AdvancedConfig.getInstance().getFastFoodChance();
+            default:
+                throw new InvalidStaticChance();
+        }
+    }
+
+    public static boolean sendSkillEvent(Player player, SubSkillType subSkillType, double activationChance)
+    {
+        SubSkillRandomCheckEvent event = new SubSkillRandomCheckEvent(player, subSkillType, activationChance);
+        return !event.isCancelled();
+    }
+
+    /*public static boolean treasureDropSuccessful(Player player, double dropChance, int activationChance) {
+        SubSkillRandomCheckEvent event = new SubSkillRandomCheckEvent(player, SubSkillType.EXCAVATION_ARCHAEOLOGY, dropChance / activationChance);
+        mcMMO.p.getServer().getPluginManager().callEvent(event);
+        return (event.getChance() * activationChance) > (Misc.getRandom().nextDouble() * activationChance) && !event.isCancelled();
+    }*/
+
+    public static boolean isActivationSuccessful(SkillActivationType skillActivationType, AbstractSubSkill abstractSubSkill, Player player)
+    {
+        return isActivationSuccessful(skillActivationType, abstractSubSkill.getSubSkillType(), player);
+    }
+
+    public static String[] calculateAbilityDisplayValues(SkillActivationType skillActivationType, Player player, SubSkillType subSkillType) {
+        double successChance = getActivationChance(skillActivationType, subSkillType, player);
+        String[] displayValues = new String[2];
+
+        boolean isLucky = Permissions.lucky(player, subSkillType.getParentSkill());
+
+        displayValues[0] = percent.format(Math.min(successChance, 100.0D) / 100.0D);
+        displayValues[1] = isLucky ? percent.format(Math.min(successChance * 1.3333D, 100.0D) / 100.0D) : null;
+
+        return displayValues;
+    }
+
+    public static String[] calculateAbilityDisplayValuesStatic(Player player, PrimarySkillType primarySkillType, double chance) {
+        RandomChanceStatic rcs = new RandomChanceStatic(chance);
+        double successChance = getRandomChanceExecutionChance(rcs);
+
+        String[] displayValues = new String[2];
+
+        boolean isLucky = Permissions.lucky(player, primarySkillType);
+
+        displayValues[0] = percent.format(Math.min(successChance, 100.0D) / 100.0D);
+        displayValues[1] = isLucky ? percent.format(Math.min(successChance * 1.3333D, 100.0D) / 100.0D) : null;
+
+        return displayValues;
+    }
+
+    public static String[] calculateAbilityDisplayValuesCustom(SkillActivationType skillActivationType, Player player, SubSkillType subSkillType, double multiplier) {
+        double successChance = getActivationChance(skillActivationType, subSkillType, player);
+        successChance *= multiplier; //Currently only used for graceful roll
+        String[] displayValues = new String[2];
+
+        boolean isLucky = Permissions.lucky(player, subSkillType.getParentSkill());
+
+        displayValues[0] = percent.format(Math.min(successChance, 100.0D) / 100.0D);
+        displayValues[1] = isLucky ? percent.format(Math.min(successChance * 1.3333D, 100.0D) / 100.0D) : null;
+
+        return displayValues;
+    }
+}

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

@@ -4,7 +4,7 @@ package com.gmail.nossr50.util.skills;
  * Defines the type of random calculations to use with a given skill
  */
 public enum SkillActivationType {
-    RANDOM_LINEAR_100_SCALE_NO_CAP, //A skill level of 100 would guarantee the proc with this
+    //RANDOM_LINEAR_100_SCALE_NO_CAP, //A skill level of 100 would guarantee the proc with this
     RANDOM_LINEAR_100_SCALE_WITH_CAP, //This one is based on a scale of 1-100 but with a specified cap for max bonus
     RANDOM_STATIC_CHANCE, //The skill always has a SPECIFIC chance to succeed
     ALWAYS_FIRES //This skill isn't chance based and always fires

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

@@ -9,13 +9,8 @@ import com.gmail.nossr50.datatypes.skills.PrimarySkillType;
 import com.gmail.nossr50.datatypes.skills.SubSkillType;
 import com.gmail.nossr50.datatypes.skills.SuperAbilityType;
 import com.gmail.nossr50.datatypes.skills.XPGainReason;
-import com.gmail.nossr50.datatypes.skills.subskills.AbstractSubSkill;
-import com.gmail.nossr50.datatypes.skills.subskills.interfaces.RandomChance;
-import com.gmail.nossr50.events.skills.secondaryabilities.SubSkillEvent;
-import com.gmail.nossr50.events.skills.secondaryabilities.SubSkillWeightedActivationCheckEvent;
 import com.gmail.nossr50.locale.LocaleLoader;
 import com.gmail.nossr50.mcMMO;
-import com.gmail.nossr50.util.EventUtils;
 import com.gmail.nossr50.util.ItemUtils;
 import com.gmail.nossr50.util.Misc;
 import com.gmail.nossr50.util.StringUtils;
@@ -33,15 +28,11 @@ import org.bukkit.inventory.meta.ItemMeta;
 import org.bukkit.potion.PotionEffect;
 import org.bukkit.potion.PotionEffectType;
 
-import java.text.DecimalFormat;
 import java.util.ArrayList;
 import java.util.List;
 
 public class SkillUtils {
 
-    public static final DecimalFormat percent = new DecimalFormat("##0.00%");
-    public static final DecimalFormat decimal = new DecimalFormat("##0.00");
-
     public static void applyXpGain(McMMOPlayer mcMMOPlayer, PrimarySkillType skill, float xp, XPGainReason xpGainReason) {
         mcMMOPlayer.beginXpGain(skill, xp, xpGainReason);
     }
@@ -50,25 +41,6 @@ public class SkillUtils {
      * Skill Stat Calculations
      */
 
-    public static String[] calculateAbilityDisplayValues(double chance, boolean isLucky) {
-        String[] displayValues = new String[2];
-
-        displayValues[0] = percent.format(Math.min(chance, 100.0D) / 100.0D);
-        displayValues[1] = isLucky ? percent.format(Math.min(chance * 1.3333D, 100.0D) / 100.0D) : null;
-
-        return displayValues;
-    }
-
-    public static String[] calculateAbilityDisplayValues(float skillValue, SubSkillType subSkillType, boolean isLucky) {
-        int maxBonusLevel = AdvancedConfig.getInstance().getMaxBonusLevel(subSkillType);
-
-        return calculateAbilityDisplayValues((AdvancedConfig.getInstance().getMaxChance(subSkillType) / maxBonusLevel) * Math.min(skillValue, maxBonusLevel), isLucky);
-    }
-
-    public static String[] calculateAbilityDisplayValuesCustom(float skillValue, boolean isLucky, int maxBonusLevel, double maxChance) {
-        return calculateAbilityDisplayValues((maxChance / maxBonusLevel) * Math.min(skillValue, maxBonusLevel), isLucky);
-    }
-
     public static String[] calculateLengthDisplayValues(Player player, float skillValue, PrimarySkillType skill) {
         int maxLength = skill.getAbility().getMaxLength();
         int abilityLengthVar = AdvancedConfig.getInstance().getAbilityLength();
@@ -270,213 +242,6 @@ public class SkillUtils {
         itemStack.setDurability((short) Math.min(itemStack.getDurability() + durabilityModifier, maxDurability));
     }
 
-    /**
-     * Checks whether or not the given skill succeeds
-     * @param subSkillType The ability corresponding to this check
-     * @param player The player whose skill levels we are checking against
-     * @param skillLevel The skill level of the corresponding skill
-     * @param activationChance used to determine activation chance
-     * @param maxChance maximum chance
-     * @param maxLevel maximum skill level bonus
-     * @return true if random chance succeeds and the event isn't cancelled
-     */
-    private static boolean performRandomSkillCheck(SubSkillType subSkillType, Player player, int skillLevel, int activationChance, double maxChance, int maxLevel) {
-        if(Config.getInstance().getIsRetroMode())
-            maxLevel = maxLevel * 10;
-
-        double chance = (maxChance / maxLevel) * Math.min(skillLevel, maxLevel) / activationChance;
-        return performRandomSkillCheckStatic(subSkillType, player, activationChance, chance);
-    }
-
-    /* NEW VERSION */
-    private static boolean performRandomSkillCheck(AbstractSubSkill abstractSubSkill, Player player, int skillLevel, int activationChance, double maxChance, int maxLevel) {
-        if(Config.getInstance().getIsRetroMode())
-            maxLevel = maxLevel * 10;
-
-        double chance = (maxChance / maxLevel) * Math.min(skillLevel, maxLevel) / activationChance;
-        return performRandomSkillCheckStatic(abstractSubSkill, player, activationChance, chance);
-    }
-
-    /**
-     * This method is the final step in determining if a Sub-Skill / Secondary Skill in mcMMO successfully activates either from chance or otherwise
-     *
-     * There are 4 types of Sub-Skill / Secondary Skill activations in mcMMO
-     * 1) Random Chance with a linear increase to 100% (At 100 Skill Level)
-     * 2) Random Chance with a linear increase to 100% at 100 Skill Level but caps out earlier in the curve (At x/100 Skill Level)
-     * 3) Random Chance with a pre-determined activation roll and threshold roll
-     * 4) Skills that are not chance based
-     *
-     * Random skills check for success based on numbers and then fire a cancellable event, if that event is not cancelled they succeed
-     * All other skills just fire the cancellable event and succeed if it is not cancelled
-     *
-     * @param skillActivationType this value represents what kind of activation procedures this sub-skill uses
-     * @param subSkillType The identifier for this specific sub-skill
-     * @param player The owner of this sub-skill
-     * @param activationChance This is the value that we roll against, 100 is normal, and 75 is for lucky perk
-     * @return returns true if all conditions are met and they event is not cancelled
-     */
-    public static boolean isActivationSuccessful(SkillActivationType skillActivationType, SubSkillType subSkillType, Player player,
-                                                 int skillLevel, int activationChance)
-    {
-        //Maximum chance to succeed
-        double maxChance = AdvancedConfig.getInstance().getMaxChance(subSkillType);
-        //Maximum roll we can make
-        int maxBonusLevel = AdvancedConfig.getInstance().getMaxBonusLevel(subSkillType);
-
-        switch(skillActivationType)
-        {
-            //100 Skill = Guaranteed
-            case RANDOM_LINEAR_100_SCALE_NO_CAP:
-                return performRandomSkillCheck(subSkillType, player, skillLevel, PerksUtils.handleLuckyPerks(player, subSkillType.getParentSkill()), 100.0D, 100);
-            case RANDOM_LINEAR_100_SCALE_WITH_CAP:
-                return performRandomSkillCheck(subSkillType, player, skillLevel, PerksUtils.handleLuckyPerks(player, subSkillType.getParentSkill()), maxChance, maxBonusLevel);
-            case RANDOM_STATIC_CHANCE:
-                //Grab the static activation chance of this skill
-                double staticRoll = getSecondaryAbilityStaticChance(subSkillType) / activationChance;
-                return performRandomSkillCheckStatic(subSkillType, player, activationChance, staticRoll);
-            case ALWAYS_FIRES:
-                SubSkillEvent event = EventUtils.callSubSkillEvent(player, subSkillType);
-                return !event.isCancelled();
-                default:
-                    return false;
-        }
-    }
-
-    /**
-     * This method is for running a random success check with custom maxChance and maxBonusLevel values
-     * Mostly used for RNG effects that can't be directly associated with a specific AbstractSubSkill
-     * @param player target player
-     * @param abstractSubSkill this abstract subskill
-     * @param maxChance custom max chance
-     * @param maxBonusLevel custom max bonus level
-     * @return true if activation was successful
-     */
-    public static boolean isActivationSuccessfulCustom(Player player, AbstractSubSkill abstractSubSkill, double maxChance, int maxBonusLevel)
-    {
-        int skillLevel = UserManager.getPlayer(player).getSkillLevel(abstractSubSkill.getPrimarySkill());
-
-        return performRandomSkillCheck(abstractSubSkill, player, skillLevel, PerksUtils.handleLuckyPerks(player, abstractSubSkill.getPrimarySkill()), maxChance, maxBonusLevel);
-    }
-
-    public static double getChanceOfSuccess(int skillLevel, double maxLevelBonus, double curve)
-    {
-        return getChanceOfSuccess((double) skillLevel, maxLevelBonus, curve);
-    }
-
-    public static double getChanceOfSuccess(double skillLevel, double maxLevelBonus, double curve)
-    {
-        if(skillLevel > maxLevelBonus)
-            return maxLevelBonus / curve;
-
-       return skillLevel / curve;
-    }
-
-    /* NEW VERSION */
-    public static boolean isActivationSuccessful(SkillActivationType skillActivationType, AbstractSubSkill abstractSubSkill, Player player, double maxChance, int maxBonusLevel)
-    {
-        int skillLevel = UserManager.getPlayer(player).getSkillLevel(abstractSubSkill.getPrimarySkill());
-        PrimarySkillType skill = abstractSubSkill.getPrimarySkill();
-
-        switch(skillActivationType)
-        {
-            //100 Skill = Guaranteed
-            case RANDOM_LINEAR_100_SCALE_NO_CAP:
-                return performRandomSkillCheck(abstractSubSkill, player, skillLevel, PerksUtils.handleLuckyPerks(player, skill), 100.0D, 100);
-            case RANDOM_LINEAR_100_SCALE_WITH_CAP:
-                return performRandomSkillCheck(abstractSubSkill, player, skillLevel, PerksUtils.handleLuckyPerks(player, skill), maxChance, maxBonusLevel);
-            case RANDOM_STATIC_CHANCE:
-                //TODO: Add this in for the new system
-                //Grab the static activation chance of this skill
-                //double staticRoll = getSecondaryAbilityStaticChance(subSkillType) / activationChance;
-                //return performRandomSkillCheckStatic(subSkillType, player, activationChance, staticRoll);
-                return false;
-            case ALWAYS_FIRES:
-                SubSkillEvent event = EventUtils.callSubSkillEvent(player, abstractSubSkill);
-                return !event.isCancelled();
-            default:
-                return false;
-        }
-    }
-
-    public static boolean isActivationSuccessful(SkillActivationType skillActivationType, AbstractSubSkill abstractSubSkill, Player player)
-    {
-        //Maximum chance to succeed
-        RandomChance randomChance = (RandomChance) abstractSubSkill;
-        double maxChance = randomChance.getRandomChanceMaxChance();
-
-        //Maximum roll we can make
-        int maxBonusLevel = randomChance.getRandomChanceMaxBonus();
-        int skillLevel = UserManager.getPlayer(player).getSkillLevel(abstractSubSkill.getPrimarySkill());
-        PrimarySkillType skill = abstractSubSkill.getPrimarySkill();
-
-        switch(skillActivationType)
-        {
-            //100 Skill = Guaranteed
-            case RANDOM_LINEAR_100_SCALE_NO_CAP:
-                return performRandomSkillCheck(abstractSubSkill, player, skillLevel, PerksUtils.handleLuckyPerks(player, skill), 100.0D, 100);
-            case RANDOM_LINEAR_100_SCALE_WITH_CAP:
-                return performRandomSkillCheck(abstractSubSkill, player, skillLevel, PerksUtils.handleLuckyPerks(player, skill), maxChance, maxBonusLevel);
-            case RANDOM_STATIC_CHANCE:
-                //TODO: Add this in for the new system
-                //Grab the static activation chance of this skill
-                //double staticRoll = getSecondaryAbilityStaticChance(subSkillType) / activationChance;
-                //return performRandomSkillCheckStatic(subSkillType, player, activationChance, staticRoll);
-                return false;
-            case ALWAYS_FIRES:
-                SubSkillEvent event = EventUtils.callSubSkillEvent(player, abstractSubSkill);
-                return !event.isCancelled();
-            default:
-                return false;
-        }
-    }
-
-    /**
-     * Grabs static activation rolls for Secondary Abilities
-     * @param subSkillType The secondary ability to grab properties of
-     * @return The static activation roll involved in the RNG calculation
-     */
-    public static double getSecondaryAbilityStaticChance(SubSkillType subSkillType)
-    {
-        switch(subSkillType)
-        {
-            case AXES_ARMOR_IMPACT:
-                return AdvancedConfig.getInstance().getImpactChance();
-            case AXES_GREATER_IMPACT:
-                return AdvancedConfig.getInstance().getGreaterImpactChance();
-            case TAMING_FAST_FOOD_SERVICE:
-                return AdvancedConfig.getInstance().getFastFoodChance();
-                default:
-                    return 100.0D;
-        }
-    }
-
-    /**
-     * Used to determine whether or not a sub-skill activates from random chance (using static values)
-     * @param subSkillType The identifier for this specific sub-skill
-     * @param player The owner of this sub-skill
-     * @param activationChance This is the value that we roll against, 100 is normal, and 75 is for lucky perk
-     * @param chance This is the static modifier for our random calculations
-     * @return true if random chance was successful and the event wasn't cancelled
-     */
-    private static boolean performRandomSkillCheckStatic(SubSkillType subSkillType, Player player, int activationChance, double chance) {
-        SubSkillWeightedActivationCheckEvent event = new SubSkillWeightedActivationCheckEvent(player, subSkillType, chance);
-        mcMMO.p.getServer().getPluginManager().callEvent(event);
-        return (event.getChance() * activationChance) > Misc.getRandom().nextInt(activationChance) && !event.isCancelled();
-    }
-
-    /* NEW VERSION */
-    private static boolean performRandomSkillCheckStatic(AbstractSubSkill abstractSubSkill, Player player, int activationChance, double chance) {
-        SubSkillWeightedActivationCheckEvent event = new SubSkillWeightedActivationCheckEvent(player, abstractSubSkill, chance);
-        mcMMO.p.getServer().getPluginManager().callEvent(event);
-        return (event.getChance() * activationChance) > Misc.getRandom().nextInt(activationChance) && !event.isCancelled();
-    }
-
-    public static boolean treasureDropSuccessful(Player player, double dropChance, int activationChance) {
-        SubSkillWeightedActivationCheckEvent event = new SubSkillWeightedActivationCheckEvent(player, SubSkillType.EXCAVATION_ARCHAEOLOGY, dropChance / activationChance);
-        mcMMO.p.getServer().getPluginManager().callEvent(event);
-        return (event.getChance() * activationChance) > (Misc.getRandom().nextDouble() * activationChance) && !event.isCancelled();
-    }
-
     private static boolean isLocalizedSkill(String skillName) {
         for (PrimarySkillType skill : PrimarySkillType.values()) {
             if (skillName.equalsIgnoreCase(LocaleLoader.getString(StringUtils.getCapitalized(skill.toString()) + ".SkillName"))) {

src/main/resources/advanced.yml

@@ -103,18 +103,10 @@ Skills:
         Roll:
             # ChanceMax: Maximum chance of rolling when on <MaxBonusLevel> or higher
             # MaxBonusLevel: On this level or higher, the roll chance will not go higher than <ChanceMax>
-            # DamageThreshold: The max damage a player can negate with a roll
+            # DamageThreshold: The max damage a player can negate with a roll, graceful roll doubles this number
             ChanceMax: 100.0
             MaxBonusLevel: 100
             DamageThreshold: 7.0
-
-        GracefulRoll:
-            # ChanceMax: Maximum chance of graceful rolling when on <MaxBonusLevel> or higher
-            # MaxBonusLevel: On this level or higher, the graceful roll chance will not go higher than <ChanceMax>
-            # DamageThreshold: The max damage a player can negate with a graceful roll
-            ChanceMax: 100.0
-            MaxBonusLevel: 50
-            DamageThreshold: 14.0
     #
     #  Settings for Alchemy
     ###

src/main/resources/locale/.vscode/settings.json

@@ -1,7 +0,0 @@
-{
-    "workbench.colorCustomizations": {
-        "activityBar.background": "#3E176B",
-        "titleBar.activeBackground": "#562195",
-        "titleBar.activeForeground": "#FBF9FE"
-    }
-}