Reformat advanced.yml making the keys consistent

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

@@ -95,7 +95,7 @@ public class SmeltingCommand extends SkillCommand {
         }
 
         if (canVanillaXPBoost) {
-            int unlockLevel = AdvancedConfig.getInstance().getSmeltingVanillaXPBoostRankLevel(Tier.ONE);
+            int unlockLevel = AdvancedConfig.getInstance().getSmeltingRankLevel(Tier.ONE);
 
             if (skillValue < unlockLevel) {
                 player.sendMessage(LocaleLoader.getString("Ability.Generic.Template.Lock", LocaleLoader.getString("Smelting.Ability.Locked.0", unlockLevel)));

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

@@ -32,48 +32,48 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
 
         /* GENERAL */
         if (getAbilityLength() < 1) {
-            reason.add("Skills.General.Ability_IncreaseLevel should be at least 1!");
+            reason.add("Skills.General.Ability.IncreaseLevel should be at least 1!");
         }
 
         if (getEnchantBuff() < 1) {
-            reason.add("Skills.General.Ability_EnchantBuff should be at least 1!");
+            reason.add("Skills.General.Ability.EnchantBuff should be at least 1!");
         }
 
         /* ACROBATICS */
         if (getDodgeChanceMax() < 1) {
-            reason.add("Skills.Acrobatics.Dodge_ChanceMax should be at least 1!");
+            reason.add("Skills.Acrobatics.Dodge.ChanceMax should be at least 1!");
         }
 
         if (getDodgeMaxBonusLevel() < 1) {
-            reason.add("Skills.Acrobatics.Dodge_MaxBonusLevel should be at least 1!");
+            reason.add("Skills.Acrobatics.Dodge.MaxBonusLevel should be at least 1!");
         }
 
         if (getDodgeDamageModifier() <= 1) {
-            reason.add("Skills.Acrobatics.Dodge_DamageModifier should be greater than 1!");
+            reason.add("Skills.Acrobatics.Dodge.DamageModifier should be greater than 1!");
         }
 
         if (getRollChanceMax() < 1) {
-            reason.add("Skills.Acrobatics.Roll_ChanceMax should be at least 1!");
+            reason.add("Skills.Acrobatics.Roll.ChanceMax should be at least 1!");
         }
 
         if (getRollMaxBonusLevel() < 1) {
-            reason.add("Skills.Acrobatics.Roll_MaxBonusLevel should be at least 1!");
+            reason.add("Skills.Acrobatics.Roll.MaxBonusLevel should be at least 1!");
         }
 
         if (getRollDamageThreshold() < 0) {
-            reason.add("Skills.Acrobatics.Roll_DamageThreshold should be at least 0!");
+            reason.add("Skills.Acrobatics.Roll.DamageThreshold should be at least 0!");
         }
 
         if (getGracefulRollChanceMax() < 1) {
-            reason.add("Skills.Acrobatics.GracefulRoll_ChanceMax should be at least 1!");
+            reason.add("Skills.Acrobatics.GracefulRoll.ChanceMax should be at least 1!");
         }
 
         if (getGracefulRollMaxBonusLevel() < 1) {
-            reason.add("Skills.Acrobatics.GracefulRoll_MaxBonusLevel should be at least 1!");
+            reason.add("Skills.Acrobatics.GracefulRoll.MaxBonusLevel should be at least 1!");
         }
 
         if (getGracefulRollDamageThreshold() < 0) {
-            reason.add("Skills.Acrobatics.GracefulRoll_DamageThreshold should be at least 0!");
+            reason.add("Skills.Acrobatics.GracefulRoll.DamageThreshold should be at least 0!");
         }
 
         if (getDodgeXPModifier() < 0) {
@@ -90,92 +90,92 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
 
         /* ARCHERY */
         if (getSkillShotIncreaseLevel() < 1) {
-            reason.add("Skills.Archery.SkillShot_IncreaseLevel should be at least 1!");
+            reason.add("Skills.Archery.SkillShot.IncreaseLevel should be at least 1!");
         }
 
         if (getSkillShotIncreasePercentage() <= 0) {
-            reason.add("Skills.Archery.SkillShot_IncreasePercentage should be greater than 0!");
+            reason.add("Skills.Archery.SkillShot.IncreasePercentage should be greater than 0!");
         }
 
         if (getSkillShotBonusMax() < 0) {
-            reason.add("Skills.Archery.SkillShot_MaxBonus should be at least 0!");
+            reason.add("Skills.Archery.SkillShot.MaxBonus should be at least 0!");
         }
 
         if (getDazeBonusMax() < 1) {
-            reason.add("Skills.Acrobatics.Daze_MaxChance should be at least 1!");
+            reason.add("Skills.Acrobatics.Daze.MaxChance should be at least 1!");
         }
 
         if (getDazeMaxBonusLevel() < 1) {
-            reason.add("Skills.Acrobatics.Daze_MaxBonusLevel should be at least 1!");
+            reason.add("Skills.Acrobatics.Daze.MaxBonusLevel should be at least 1!");
         }
 
         if (getDazeModifier() < 0) {
-            reason.add("Skills.Acrobatics.Daze_BonusDamage should be at least 0!");
+            reason.add("Skills.Acrobatics.Daze.BonusDamage should be at least 0!");
         }
 
         if (getRetrieveChanceMax() < 1) {
-            reason.add("Skills.Acrobatics.Retrieve_MaxBonus should be at least 1!");
+            reason.add("Skills.Acrobatics.Retrieve.MaxBonus should be at least 1!");
         }
 
         if (getRetrieveMaxBonusLevel() < 1) {
-            reason.add("Skills.Acrobatics.Retrieve_MaxBonusLevel should be at least 1!");
+            reason.add("Skills.Acrobatics.Retrieve.MaxBonusLevel should be at least 1!");
         }
 
         if (getForceMultiplier() < 0) {
-            reason.add("Skills.Acrobatics.Force_Multiplier should be at least 0!");
+            reason.add("Skills.Acrobatics.ForceMultiplier should be at least 0!");
         }
 
         /* AXES */
         if (getBonusDamageAxesBonusMax() < 1) {
-            reason.add("Skills.Axes.DamageIncrease_MaxBonus should be at least 1!");
+            reason.add("Skills.Axes.DamageIncrease.MaxBonus should be at least 1!");
         }
 
         if (getBonusDamageAxesMaxBonusLevel() < 1) {
-            reason.add("Skills.Axes.DamageIncrease_MaxBonusLevel should be at least 1!");
+            reason.add("Skills.Axes.DamageIncrease.MaxBonusLevel should be at least 1!");
         }
 
         if (getAxesCriticalChance() < 1) {
-            reason.add("Skills.Axes.AxesCritical_MaxChance should be at least 1!");
+            reason.add("Skills.Axes.AxesCritical.MaxChance should be at least 1!");
         }
 
         if (getAxesCriticalMaxBonusLevel() < 1) {
-            reason.add("Skills.Axes.AxesCritical_MaxBonusLevel should be at least 1!");
+            reason.add("Skills.Axes.AxesCritical.MaxBonusLevel should be at least 1!");
         }
 
         if (getAxesCriticalPVPModifier() < 1) {
-            reason.add("Skills.Axes.AxesCritical_PVP_Modifier should be at least 1!");
+            reason.add("Skills.Axes.AxesCritical.PVP_Modifier should be at least 1!");
         }
 
         if (getAxesCriticalPVEModifier() < 1) {
-            reason.add("Skills.Axes.AxesCritical_PVE_Modifier should be at least 1!");
+            reason.add("Skills.Axes.AxesCritical.PVE_Modifier should be at least 1!");
         }
 
         if (getGreaterImpactChance() < 1) {
-            reason.add("Skills.Axes.GreaterImpact_Chance should be at least 1!");
+            reason.add("Skills.Axes.GreaterImpact.Chance should be at least 1!");
         }
 
         if (getGreaterImpactModifier() < 1) {
-            reason.add("Skills.Axes.GreaterImpact_KnockbackModifier should be at least 1!");
+            reason.add("Skills.Axes.GreaterImpact.KnockbackModifier should be at least 1!");
         }
 
         if (getGreaterImpactBonusDamage() < 1) {
-            reason.add("Skills.Axes.GreaterImpact_BonusDamage should be at least 1!");
+            reason.add("Skills.Axes.GreaterImpact.BonusDamage should be at least 1!");
         }
 
         if (getArmorImpactIncreaseLevel() < 1) {
-            reason.add("Skills.Axes.ArmorImpact_IncreaseLevel should be at least 1!");
+            reason.add("Skills.Axes.ArmorImpact.IncreaseLevel should be at least 1!");
         }
 
         if (getImpactChance() < 1) {
-            reason.add("Skills.Axes.ArmorImpact_Chance should be at least 1!");
+            reason.add("Skills.Axes.ArmorImpact.Chance should be at least 1!");
         }
 
         if (getArmorImpactMaxDurabilityDamage() < 1) {
-            reason.add("Skills.Axes.ArmorImpact_MaxPercentageDurabilityDamage should be at least 1!");
+            reason.add("Skills.Axes.ArmorImpact.MaxPercentageDurabilityDamage should be at least 1!");
         }
 
         if (getSkullSplitterModifier() < 1) {
-            reason.add("Skills.Axes.SkullSplitter_DamagerModifier should be at least 1!");
+            reason.add("Skills.Axes.SkullSplitter.DamagerModifier should be at least 1!");
         }
 
         /* FISHING */
@@ -183,7 +183,7 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
 
         for (Fishing.Tier tier : fishingTierList) {
             if (getFishingTierLevel(tier) < 0) {
-                reason.add("Skills.Fishing.Tier_Levels.Tier" + tier.toNumerical() + " should be at least 0!");
+                reason.add("Skills.Fishing.Rank_Levels.Rank_" + tier.toNumerical() + " should be at least 0!");
             }
 
             if (getShakeChance(tier) < 0) {
@@ -191,14 +191,14 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
             }
 
             if (getFishingVanillaXPModifier(tier) < 0) {
-                reason.add("Skills.Fishing.VanillaXPBoost.Rank_" + tier.toNumerical() + " should be at least 0!");
+                reason.add("Skills.Fishing.VanillaXPMultiplier.Rank_" + tier.toNumerical() + " should be at least 0!");
             }
 
             if (tier != Fishing.Tier.EIGHT) {
                 Fishing.Tier nextTier = fishingTierList.get(fishingTierList.indexOf(tier) - 1);
 
                 if (getFishingTierLevel(tier) >= getFishingTierLevel(nextTier)) {
-                    reason.add("Skills.Fishing.Tier_Levels.Tier" + tier.toNumerical() + " should be less than Skills.Fishing.Tier_Levels.Tier" + nextTier.toNumerical() + "!");
+                    reason.add("Skills.Fishing.Rank_Levels.Rank_" + tier.toNumerical() + " should be less than Skills.Fishing.Rank_Levels.Rank_" + nextTier.toNumerical() + "!");
                 }
 
                 if (getShakeChance(tier) > getShakeChance(nextTier)) {
@@ -206,170 +206,170 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
                 }
 
                 if (getFishingVanillaXPModifier(tier) > getFishingVanillaXPModifier(nextTier)) {
-                    reason.add("Skills.Fishing.VanillaXPBoost.Rank_" + tier.toNumerical() + " should be less than or equal to Skills.Fishing.VanillaXPBoost.Rank_" + nextTier.toNumerical() + "!");
+                    reason.add("Skills.Fishing.VanillaXPMultiplier.Rank_" + tier.toNumerical() + " should be less than or equal to Skills.Fishing.VanillaXPMultiplier.Rank_" + nextTier.toNumerical() + "!");
                 }
             }
         }
 
         if (getFishingMagicMultiplier() <= 0) {
-            reason.add("Skills.Fishing.MagicHunter_Multiplier should be greater than 0!");
+            reason.add("Skills.Fishing.MagicHunter.Multiplier should be greater than 0!");
         }
 
         if (getFishermanDietRankChange() < 1) {
-            reason.add("Skills.Fishing.Fisherman_Diet_RankChange should be at least 1!");
+            reason.add("Skills.Fishing.FishermansDiet.RankChange should be at least 1!");
         }
 
         if (getIceFishingUnlockLevel() < 1) {
-            reason.add("Skills.Fishing.Ice_Fishing_UnlockLevel should be at least 1!");
+            reason.add("Skills.Fishing.IceFishing.UnlockLevel should be at least 1!");
         }
 
         /* HERBALISM */
         if (getFarmerDietRankChange() < 1) {
-            reason.add("Skills.Herbalism.Farmer_Diet_RankChange should be at least 1!");
+            reason.add("Skills.Herbalism.FarmersDiet.RankChange should be at least 1!");
         }
 
         if (getGreenThumbStageChange() < 1) {
-            reason.add("Skills.Herbalism.GreenThumb_StageChange should be at least 1!");
+            reason.add("Skills.Herbalism.GreenThumb.StageChange should be at least 1!");
         }
 
         if (getGreenThumbChanceMax() < 1) {
-            reason.add("Skills.Herbalism.GreenThumb_ChanceMax should be at least 1!");
+            reason.add("Skills.Herbalism.GreenThumb.ChanceMax should be at least 1!");
         }
 
         if (getGreenThumbMaxLevel() < 1) {
-            reason.add("Skills.Herbalism.GreenThumb_MaxBonusLevel should be at least 1!");
+            reason.add("Skills.Herbalism.GreenThumb.MaxBonusLevel should be at least 1!");
         }
 
         if (getHerbalismDoubleDropsChanceMax() < 1) {
-            reason.add("Skills.Herbalism.DoubleDrops_ChanceMax should be at least 1!");
+            reason.add("Skills.Herbalism.DoubleDrops.ChanceMax should be at least 1!");
         }
 
         if (getHerbalismDoubleDropsMaxLevel() < 1) {
-            reason.add("Skills.Herbalism.DoubleDrops_MaxBonusLevel should be at least 1!");
+            reason.add("Skills.Herbalism.DoubleDrops.MaxBonusLevel should be at least 1!");
         }
 
         if (getHylianLuckChanceMax() < 1) {
-            reason.add("Skills.Herbalism.HylianLuck_ChanceMax should be at least 1!");
+            reason.add("Skills.Herbalism.HylianLuck.ChanceMax should be at least 1!");
         }
 
         if (getHylianLuckMaxLevel() < 1) {
-            reason.add("Skills.Herbalism.HylianLuck_MaxBonusLevel should be at least 1!");
+            reason.add("Skills.Herbalism.HylianLuck.MaxBonusLevel should be at least 1!");
         }
 
         if (getShroomThumbChanceMax() < 1) {
-            reason.add("Skills.Herbalism.ShroomThumb_ChanceMax should be at least 1!");
+            reason.add("Skills.Herbalism.ShroomThumb.ChanceMax should be at least 1!");
         }
 
         if (getShroomThumbMaxLevel() < 1) {
-            reason.add("Skills.Herbalism.ShroomThumb_MaxBonusLevel should be at least 1!");
+            reason.add("Skills.Herbalism.ShroomThumb.MaxBonusLevel should be at least 1!");
         }
 
         /* MINING */
         if (getMiningDoubleDropChance() < 1) {
-            reason.add("Skills.Mining.DoubleDrops_ChanceMax should be at least 1!");
+            reason.add("Skills.Mining.DoubleDrops.ChanceMax should be at least 1!");
         }
 
         if (getMiningDoubleDropMaxLevel() < 1) {
-            reason.add("Skills.Mining.DoubleDrops_MaxBonusLevel should be at least 1!");
+            reason.add("Skills.Mining.DoubleDrops.MaxBonusLevel should be at least 1!");
         }
 
         List<BlastMining.Tier> blastMiningTierList = Arrays.asList(BlastMining.Tier.values());
 
         for (BlastMining.Tier tier : blastMiningTierList) {
             if (getBlastMiningRankLevel(tier) < 0) {
-                reason.add("Skills.Mining.BlastMining_Rank" + tier.toNumerical() + " should be at least 0!");
+                reason.add("Skills.Mining.BlastMining.Rank_Levels.Rank_" + tier.toNumerical() + " should be at least 0!");
             }
 
             if (getBlastDamageDecrease(tier) < 0) {
-                reason.add("Skills.Mining.BlastDamageDecrease_Rank" + tier.toNumerical() + " should be at least 0!");
+                reason.add("Skills.Mining.BlastMining.BlastDamageDecrease.Rank_" + tier.toNumerical() + " should be at least 0!");
             }
 
             if (getOreBonus(tier) < 0) {
-                reason.add("Skills.Mining.OreBonus_Rank" + tier.toNumerical() + " should be at least 0!");
+                reason.add("Skills.Mining.BlastMining.OreBonus.Rank_" + tier.toNumerical() + " should be at least 0!");
             }
 
             if (getDebrisReduction(tier) < 0) {
-                reason.add("Skills.Mining.DebrisReduction_Rank" + tier.toNumerical() + " should be at least 0!");
+                reason.add("Skills.Mining.BlastMining.DebrisReduction.Rank_" + tier.toNumerical() + " should be at least 0!");
             }
 
             if (getDropMultiplier(tier) < 0) {
-                reason.add("Skills.Mining.DropMultiplier_Rank" + tier.toNumerical() + " should be at least 0!");
+                reason.add("Skills.Mining.BlastMining.DropMultiplier.Rank_" + tier.toNumerical() + " should be at least 0!");
             }
 
             if (getBlastRadiusModifier(tier) < 0) {
-                reason.add("Skills.Mining.BlastRadiusModifier_Rank" + tier.toNumerical() + " should be at least 0!");
+                reason.add("Skills.Mining.BlastMining.BlastRadiusModifier.Rank_" + tier.toNumerical() + " should be at least 0!");
             }
 
             if (tier != BlastMining.Tier.EIGHT) {
                 BlastMining.Tier nextTier = blastMiningTierList.get(blastMiningTierList.indexOf(tier) - 1);
 
                 if (getBlastMiningRankLevel(tier) >= getBlastMiningRankLevel(nextTier)) {
-                    reason.add("Skills.Mining.BlastMining_Rank" + tier.toNumerical() + " should be less than Skills.Mining.BlastMining_Rank" + nextTier.toNumerical() + "!");
+                    reason.add("Skills.Mining.BlastMining.Rank_Levels.Rank_" + tier.toNumerical() + " should be less than Skills.Mining.BlastMining.Rank_Levels.Rank_" + nextTier.toNumerical() + "!");
                 }
 
                 if (getBlastDamageDecrease(tier) > getBlastDamageDecrease(nextTier)) {
-                    reason.add("Skills.Mining.BlastDamageDecrease_Rank" + tier.toNumerical() + " should be less than or equal to Skills.Mining.BlastDamageDecrease_Rank" + nextTier.toNumerical() + "!");
+                    reason.add("Skills.Mining.BlastMining.BlastDamageDecrease.Rank_" + tier.toNumerical() + " should be less than or equal to Skills.Mining.BlastMining.BlastDamageDecrease.Rank_" + nextTier.toNumerical() + "!");
                 }
 
                 if (getOreBonus(tier) > getOreBonus(nextTier)) {
-                    reason.add("Skills.Mining.OreBonus_Rank" + tier.toNumerical() + " should be less than or equal to Skills.Mining.OreBonus_Rank" + nextTier.toNumerical() + "!");
+                    reason.add("Skills.Mining.BlastMining.OreBonus.Rank_" + tier.toNumerical() + " should be less than or equal to Skills.Mining.BlastMining.OreBonus.Rank_" + nextTier.toNumerical() + "!");
                 }
 
                 if (getDebrisReduction(tier) > getDebrisReduction(nextTier)) {
-                    reason.add("Skills.Mining.DebrisReduction_Rank" + tier.toNumerical() + " should be less than or equal to Skills.Mining.DebrisReduction_Rank" + nextTier.toNumerical() + "!");
+                    reason.add("Skills.Mining.BlastMining.DebrisReduction.Rank_" + tier.toNumerical() + " should be less than or equal to Skills.Mining.BlastMining.DebrisReduction.Rank_" + nextTier.toNumerical() + "!");
                 }
 
                 if (getDropMultiplier(tier) > getDropMultiplier(nextTier)) {
-                    reason.add("Skills.Mining.DropMultiplier_Rank" + tier.toNumerical() + " should be less than or equal to Skills.Mining.DropMultiplier_Rank" + nextTier.toNumerical() + "!");
+                    reason.add("Skills.Mining.BlastMining.DropMultiplier.Rank_" + tier.toNumerical() + " should be less than or equal to Skills.Mining.BlastMining.DropMultiplier.Rank_" + nextTier.toNumerical() + "!");
                 }
 
                 if (getBlastRadiusModifier(tier) > getBlastRadiusModifier(nextTier)) {
-                    reason.add("Skills.Mining.BlastRadiusModifier_Rank" + tier.toNumerical() + " should be less than or equal to Skills.Mining.BlastRadiusModifier_Rank" + nextTier.toNumerical() + "!");
+                    reason.add("Skills.Mining.BlastMining.BlastRadiusModifier.Rank_" + tier.toNumerical() + " should be less than or equal to Skills.Mining.BlastMining.BlastRadiusModifier.Rank_" + nextTier.toNumerical() + "!");
                 }
             }
         }
 
         /* REPAIR */
         if (getRepairMasteryMaxBonus() < 1) {
-            reason.add("Skills.Repair.RepairMastery_MaxBonusPercentage should be at least 1!");
+            reason.add("Skills.Repair.RepairMastery.MaxBonusPercentage should be at least 1!");
         }
 
         if (getRepairMasteryMaxLevel() < 1) {
-            reason.add("Skills.Repair.RepairMastery_MaxBonusLevel should be at least 1!");
+            reason.add("Skills.Repair.RepairMastery.MaxBonusLevel should be at least 1!");
         }
 
         if (getSuperRepairChanceMax() < 1) {
-            reason.add("Skills.Repair.SuperRepair_ChanceMax should be at least 1!");
+            reason.add("Skills.Repair.SuperRepair.ChanceMax should be at least 1!");
         }
 
         if (getSuperRepairMaxLevel() < 1) {
-            reason.add("Skills.Repair.SuperRepair_MaxBonusLevel should be at least 1!");
+            reason.add("Skills.Repair.SuperRepair.MaxBonusLevel should be at least 1!");
         }
 
         if (getSalvageUnlockLevel() < 1) {
-            reason.add("Skills.Repair.Salvage_UnlockLevel should be at least 1!");
+            reason.add("Skills.Repair.Salvage.UnlockLevel should be at least 1!");
         }
 
         List<ArcaneForging.Tier> arcaneForgingTierList = Arrays.asList(ArcaneForging.Tier.values());
 
         for (ArcaneForging.Tier tier : arcaneForgingTierList) {
             if (getArcaneForgingRankLevel(tier) < 0) {
-                reason.add("Skills.Repair.Arcane_Forging.Rank_Levels.Rank_" + tier.toNumerical() + " should be at least 0!");
+                reason.add("Skills.Repair.ArcaneForging.Rank_Levels.Rank_" + tier.toNumerical() + " should be at least 0!");
             }
 
             if (getArcaneForgingDowngradeChance(tier) < 0 || getArcaneForgingDowngradeChance(tier) > 100) {
-                reason.add("Skills.Repair.Arcane_Forging.Downgrades.Chance.Rank_" + tier.toNumerical() + " only accepts values from 0 to 100!");
+                reason.add("Skills.Repair.ArcaneForging.Downgrades.Chance.Rank_" + tier.toNumerical() + " only accepts values from 0 to 100!");
             }
 
             if (getArcaneForgingKeepEnchantsChance(tier) < 0 || getArcaneForgingKeepEnchantsChance(tier) > 100) {
-                reason.add("Skills.Repair.Arcane_Forging.Keep_Enchants.Chance.Rank_" + tier.toNumerical() + " only accepts values from 0 to 100!");
+                reason.add("Skills.Repair.ArcaneForging.Keep_Enchants.Chance.Rank_" + tier.toNumerical() + " only accepts values from 0 to 100!");
             }
 
             if (tier != ArcaneForging.Tier.EIGHT) {
                 ArcaneForging.Tier nextTier = arcaneForgingTierList.get(arcaneForgingTierList.indexOf(tier) - 1);
 
                 if (getArcaneForgingRankLevel(tier) >= getArcaneForgingRankLevel(nextTier)) {
-                    reason.add("Skills.Repair.Arcane_Forging.Rank_Levels.Rank_" + tier.toNumerical() + " should be less than Skills.Repair.Arcane_Forging.Rank_Levels.Rank_" + nextTier.toNumerical() + "!");
+                    reason.add("Skills.Repair.ArcaneForging.Rank_Levels.Rank_" + tier.toNumerical() + " should be less than Skills.Repair.ArcaneForging.Rank_Levels.Rank_" + nextTier.toNumerical() + "!");
                 }
 
                 if (getArcaneForgingDowngradeChance(nextTier) > getArcaneForgingDowngradeChance(tier)) {
@@ -377,212 +377,212 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
                 }
 
                 if (getArcaneForgingKeepEnchantsChance(tier) > getArcaneForgingKeepEnchantsChance(nextTier)) {
-                    reason.add("Skills.Repair.Arcane_Forging.Keep_Enchants.Chance.Rank_" + tier.toNumerical() + " should be less than or equal to Skills.Repair.Arcane_Forging.Keep_Enchants.Chance.Rank_" + nextTier.toNumerical() + "!");
+                    reason.add("Skills.Repair.ArcaneForging.Keep_Enchants.Chance.Rank_" + tier.toNumerical() + " should be less than or equal to Skills.Repair.ArcaneForging.Keep_Enchants.Chance.Rank_" + nextTier.toNumerical() + "!");
                 }
             }
         }
 
         /* SMELTING */
         if (getBurnModifierMaxLevel() < 1) {
-            reason.add("Skills.Smelting.FuelEfficiency_MaxBonusLevel should be at least 1!");
+            reason.add("Skills.Smelting.FuelEfficiency.MaxBonusLevel should be at least 1!");
         }
 
         if (getBurnTimeMultiplier() < 1) {
-            reason.add("Skills.Smelting.FuelEfficiency_Multiplier should be at least 1!");
+            reason.add("Skills.Smelting.FuelEfficiency.Multiplier should be at least 1!");
         }
 
         if (getSecondSmeltMaxLevel() < 1) {
-            reason.add("Skills.Smelting.SecondSmelt_MaxBonusLevel should be at least 1!");
+            reason.add("Skills.Smelting.SecondSmelt.MaxBonusLevel should be at least 1!");
         }
 
         if (getSecondSmeltMaxChance() < 1) {
-            reason.add("Skills.Smelting.SecondSmelt_MaxBonusChance should be at least 1!");
+            reason.add("Skills.Smelting.SecondSmelt.MaxBonusChance should be at least 1!");
         }
 
         if (getFluxMiningUnlockLevel() < 1) {
-            reason.add("Skills.Smelting.FluxMining_UnlockLevel should be at least 1!");
+            reason.add("Skills.Smelting.FluxMining.UnlockLevel should be at least 1!");
         }
 
         if (getFluxMiningChance() < 1) {
-            reason.add("Skills.Smelting.FluxMining_Chance should be at least 1!");
+            reason.add("Skills.Smelting.FluxMining.Chance should be at least 1!");
         }
 
         List<Smelting.Tier> smeltingTierList = Arrays.asList(Smelting.Tier.values());
 
         for (Smelting.Tier tier : smeltingTierList) {
-            if (getSmeltingVanillaXPBoostRankLevel(tier) < 0) {
-                reason.add("Skills.Smelting.VanillaXPBoost.Rank_Levels.Rank_" + tier.toNumerical() + " should be at least 0!");
+            if (getSmeltingRankLevel(tier) < 0) {
+                reason.add("Skills.Smelting.Rank_Levels.Rank_" + tier.toNumerical() + " should be at least 0!");
             }
 
             if (getSmeltingVanillaXPBoostMultiplier(tier) < 1) {
-                reason.add("Skills.Smelting.VanillaXPBoost.XP_Multiplier.Rank_" + tier.toNumerical() + " should be at least 1!");
+                reason.add("Skills.Smelting.VanillaXPMultiplier.Rank_" + tier.toNumerical() + " should be at least 1!");
             }
 
             if (tier != Smelting.Tier.EIGHT) {
                 Smelting.Tier nextTier = smeltingTierList.get(smeltingTierList.indexOf(tier) - 1);
 
-                if (getSmeltingVanillaXPBoostRankLevel(tier) >= getSmeltingVanillaXPBoostRankLevel(nextTier)) {
-                    reason.add("Skills.Smelting.VanillaXPBoost.Rank_Levels.Rank_" + tier.toNumerical() + " should be less than Skills.Smelting.VanillaXPBoost.Rank_Levels.Rank_" + nextTier.toNumerical() + "!");
+                if (getSmeltingRankLevel(tier) >= getSmeltingRankLevel(nextTier)) {
+                    reason.add("Skills.Smelting.Rank_Levels.Rank_" + tier.toNumerical() + " should be less than Skills.Smelting.Rank_Levels.Rank_" + nextTier.toNumerical() + "!");
                 }
 
-                if (getSmeltingVanillaXPBoostMultiplier(tier) > getSmeltingVanillaXPBoostRankLevel(nextTier)) {
-                    reason.add("Skills.Smelting.VanillaXPBoost.XP_Multiplier.Rank_" + tier.toNumerical() + " should be less than or equal to Skills.Smelting.VanillaXPBoost.XP_Multiplier.Rank_" + nextTier.toNumerical() + "!");
+                if (getSmeltingVanillaXPBoostMultiplier(tier) > getSmeltingRankLevel(nextTier)) {
+                    reason.add("Skills.Smelting.VanillaXPMultiplier.Rank_" + tier.toNumerical() + " should be less than or equal to Skills.Smelting.VanillaXPMultiplier.Rank_" + nextTier.toNumerical() + "!");
                 }
             }
         }
 
         /* SWORDS */
         if (getBleedChanceMax() < 1) {
-            reason.add("Skills.Swords.Bleed_ChanceMax should be at least 1!");
+            reason.add("Skills.Swords.Bleed.ChanceMax should be at least 1!");
         }
 
         if (getBleedMaxBonusLevel() < 1) {
-            reason.add("Skills.Swords.Bleed_MaxBonusLevel should be at least 1!");
+            reason.add("Skills.Swords.Bleed.MaxBonusLevel should be at least 1!");
         }
 
         if (getBleedMaxTicks() < 1) {
-            reason.add("Skills.Swords.Bleed_MaxTicks should be at least 1!");
+            reason.add("Skills.Swords.Bleed.MaxTicks should be at least 1!");
         }
 
         if (getBleedMaxTicks() < getBleedBaseTicks()) {
-            reason.add("Skills.Swords.Bleed_MaxTicks should be at least Skills.Swords.Bleed_BaseTicks!");
+            reason.add("Skills.Swords.Bleed.MaxTicks should be at least Skills.Swords.Bleed.BaseTicks!");
         }
 
         if (getBleedBaseTicks() < 1) {
-            reason.add("Skills.Swords.Bleed_BaseTicks should be at least 1!");
+            reason.add("Skills.Swords.Bleed.BaseTicks should be at least 1!");
         }
 
         if (getCounterChanceMax() < 1) {
-            reason.add("Skills.Swords.Counter_ChanceMax should be at least 1!");
+            reason.add("Skills.Swords.Counter.ChanceMax should be at least 1!");
         }
 
         if (getCounterMaxBonusLevel() < 1) {
-            reason.add("Skills.Swords.Counter_MaxBonusLevel should be at least 1!");
+            reason.add("Skills.Swords.Counter.MaxBonusLevel should be at least 1!");
         }
 
         if (getCounterModifier() < 1) {
-            reason.add("Skills.Swords.Counter_DamageModifier should be at least 1!");
+            reason.add("Skills.Swords.Counter.DamageModifier should be at least 1!");
         }
 
         if (getSerratedStrikesModifier() < 1) {
-            reason.add("Skills.Swords.SerratedStrikes_DamageModifier should be at least 1!");
+            reason.add("Skills.Swords.SerratedStrikes.DamageModifier should be at least 1!");
         }
 
         if (getSerratedStrikesTicks() < 1) {
-            reason.add("Skills.Swords.SerratedStrikes_BleedTicks should be at least 1!");
+            reason.add("Skills.Swords.SerratedStrikes.BleedTicks should be at least 1!");
         }
 
         /* TAMING */
 
         if (getGoreChanceMax() < 1) {
-            reason.add("Skills.Taming.Gore_ChanceMax should be at least 1!");
+            reason.add("Skills.Taming.Gore.ChanceMax should be at least 1!");
         }
 
         if (getGoreMaxBonusLevel() < 1) {
-            reason.add("Skills.Taming.Gore_MaxBonusLevel should be at least 1!");
+            reason.add("Skills.Taming.Gore.MaxBonusLevel should be at least 1!");
         }
 
         if (getGoreBleedTicks() < 1) {
-            reason.add("Skills.Taming.Gore_BleedTicks should be at least 1!");
+            reason.add("Skills.Taming.Gore.BleedTicks should be at least 1!");
         }
 
         if (getGoreModifier() < 1) {
-            reason.add("Skills.Taming.Gore_Modifier should be at least 1!");
+            reason.add("Skills.Taming.Gore.Modifier should be at least 1!");
         }
 
         if (getFastFoodUnlock() < 1) {
-            reason.add("Skills.Taming.FastFood_UnlockLevel should be at least 1!");
+            reason.add("Skills.Taming.FastFood.UnlockLevel should be at least 1!");
         }
 
         if (getFastFoodChance() < 1) {
-            reason.add("Skills.Taming.FastFood_Chance should be at least 1!");
+            reason.add("Skills.Taming.FastFood.Chance should be at least 1!");
         }
 
         if (getEnviromentallyAwareUnlock() < 1) {
-            reason.add("Skills.Taming.EnvironmentallyAware_UnlockLevel should be at least 1!");
+            reason.add("Skills.Taming.EnvironmentallyAware.UnlockLevel should be at least 1!");
         }
 
         if (getThickFurUnlock() < 1) {
-            reason.add("Skills.Taming.ThickFur_UnlockLevel should be at least 1!");
+            reason.add("Skills.Taming.ThickFur.UnlockLevel should be at least 1!");
         }
 
         if (getThickFurModifier() < 1) {
-            reason.add("Skills.Taming.ThickFur_Modifier should be at least 1!");
+            reason.add("Skills.Taming.ThickFur.Modifier should be at least 1!");
         }
 
         if (getHolyHoundUnlock() < 1) {
-            reason.add("Skills.Taming.HolyHound_UnlockLevel should be at least 1!");
+            reason.add("Skills.Taming.HolyHound.UnlockLevel should be at least 1!");
         }
 
         if (getShockProofUnlock() < 1) {
-            reason.add("Skills.Taming.ShockProof_UnlockLevel should be at least 1!");
+            reason.add("Skills.Taming.ShockProof.UnlockLevel should be at least 1!");
         }
 
         if (getShockProofModifier() < 1) {
-            reason.add("Skills.Taming.ShockProof_Modifier should be at least 1!");
+            reason.add("Skills.Taming.ShockProof.Modifier should be at least 1!");
         }
 
         if (getSharpenedClawsUnlock() < 1) {
-            reason.add("Skills.Taming.SharpenedClaws_UnlockLevel should be at least 1!");
+            reason.add("Skills.Taming.SharpenedClaws.UnlockLevel should be at least 1!");
         }
 
         if (getSharpenedClawsBonus() < 1) {
-            reason.add("Skills.Taming.SharpenedClaws_Bonus should be at least 1!");
+            reason.add("Skills.Taming.SharpenedClaws.Bonus should be at least 1!");
         }
 
 
         /* UNARMED */
         if (getDisarmChanceMax() < 1) {
-            reason.add("Skills.Unarmed.Disarm_ChanceMax should be at least 1!");
+            reason.add("Skills.Unarmed.Disarm.ChanceMax should be at least 1!");
         }
 
         if (getDisarmMaxBonusLevel() < 1) {
-            reason.add("Skills.Unarmed.Disarm_MaxBonusLevel should be at least 1!");
+            reason.add("Skills.Unarmed.Disarm.MaxBonusLevel should be at least 1!");
         }
 
         if (getDeflectChanceMax() < 1) {
-            reason.add("Skills.Unarmed.Deflect_ChanceMax should be at least 1!");
+            reason.add("Skills.Unarmed.Deflect.ChanceMax should be at least 1!");
         }
 
         if (getDeflectMaxBonusLevel() < 1) {
-            reason.add("Skills.Unarmed.Deflect_MaxBonusLevel should be at least 1!");
+            reason.add("Skills.Unarmed.Deflect.MaxBonusLevel should be at least 1!");
         }
 
         if (getIronGripChanceMax() < 1) {
-            reason.add("Skills.Unarmed.IronGrip_ChanceMax should be at least 1!");
+            reason.add("Skills.Unarmed.IronGrip.ChanceMax should be at least 1!");
         }
 
         if (getIronGripMaxBonusLevel() < 1) {
-            reason.add("Skills.Unarmed.IronGrip_MaxBonusLevel should be at least 1!");
+            reason.add("Skills.Unarmed.IronGrip.MaxBonusLevel should be at least 1!");
         }
 
         if (getIronArmMinBonus() < 0) {
-            reason.add("Skills.Unarmed.IronArm_BonusMin should be at least 0!");
+            reason.add("Skills.Unarmed.IronArm.BonusMin should be at least 0!");
         }
 
         if (getIronArmMaxBonus() < 0) {
-            reason.add("Skills.Unarmed.IronArm_BonusMax should be at least 0!");
+            reason.add("Skills.Unarmed.IronArm.BonusMax should be at least 0!");
         }
 
         if (getIronArmMaxBonus() < getIronArmMinBonus()) {
-            reason.add("Skills.Unarmed.IronArm_BonusMax should be greater than or equal to Skills.Unarmed.IronArm_BonusMin!");
+            reason.add("Skills.Unarmed.IronArm.BonusMax should be greater than or equal to Skills.Unarmed.IronArm.BonusMin!");
         }
 
         if (getIronArmIncreaseLevel() < 1) {
-            reason.add("Skills.Unarmed.IronArm_IncreaseLevel should be at least 1!");
+            reason.add("Skills.Unarmed.IronArm.IncreaseLevel should be at least 1!");
         }
 
         /* WOODCUTTING */
         if (getLeafBlowUnlockLevel() < 1) {
-            reason.add("Skills.Woodcutting.LeafBlower_UnlockLevel should be at least 1!");
+            reason.add("Skills.Woodcutting.LeafBlower.UnlockLevel should be at least 1!");
         }
 
         if (getWoodcuttingDoubleDropChance() < 1) {
-            reason.add("Skills.Woodcutting.DoubleDrops_ChanceMax should be at least 1!");
+            reason.add("Skills.Woodcutting.DoubleDrops.ChanceMax should be at least 1!");
         }
 
         if (getWoodcuttingDoubleDropMaxLevel() < 1) {
-            reason.add("Skills.Woodcutting.DoubleDrops_MaxBonusLevel should be at least 1!");
+            reason.add("Skills.Woodcutting.DoubleDrops.MaxBonusLevel should be at least 1!");
         }
 
         /* KRAKEN */
@@ -609,21 +609,21 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
     protected void loadKeys() {}
 
     /* GENERAL */
-    public int getAbilityLength() { return config.getInt("Skills.General.Ability_IncreaseLevel", 50); }
-    public int getEnchantBuff() { return config.getInt("Skills.General.Ability_EnchantBuff", 5); }
+    public int getAbilityLength() { return config.getInt("Skills.General.Ability.IncreaseLevel", 50); }
+    public int getEnchantBuff() { return config.getInt("Skills.General.Ability.EnchantBuff", 5); }
 
     /* ACROBATICS */
-    public double getDodgeChanceMax() { return config.getDouble("Skills.Acrobatics.Dodge_ChanceMax", 20.0D); }
-    public int getDodgeMaxBonusLevel() { return config.getInt("Skills.Acrobatics.Dodge_MaxBonusLevel", 800); }
-    public double getDodgeDamageModifier() { return config.getDouble("Skills.Acrobatics.Dodge_DamageModifier", 2.0D); }
+    public double getDodgeChanceMax() { return config.getDouble("Skills.Acrobatics.Dodge.ChanceMax", 20.0D); }
+    public int getDodgeMaxBonusLevel() { return config.getInt("Skills.Acrobatics.Dodge.MaxBonusLevel", 800); }
+    public double getDodgeDamageModifier() { return config.getDouble("Skills.Acrobatics.Dodge.DamageModifier", 2.0D); }
 
-    public double getRollChanceMax() { return config.getDouble("Skills.Acrobatics.Roll_ChanceMax", 100.0D); }
-    public int getRollMaxBonusLevel() { return config.getInt("Skills.Acrobatics.Roll_MaxBonusLevel", 1000); }
-    public double getRollDamageThreshold() { return config.getDouble("Skills.Acrobatics.Roll_DamageThreshold", 7.0D); }
+    public double getRollChanceMax() { return config.getDouble("Skills.Acrobatics.Roll.ChanceMax", 100.0D); }
+    public int getRollMaxBonusLevel() { return config.getInt("Skills.Acrobatics.Roll.MaxBonusLevel", 1000); }
+    public double getRollDamageThreshold() { return config.getDouble("Skills.Acrobatics.Roll.DamageThreshold", 7.0D); }
 
-    public double getGracefulRollChanceMax() { return config.getDouble("Skills.Acrobatics.GracefulRoll_ChanceMax", 100.0D); }
-    public int getGracefulRollMaxBonusLevel() { return config.getInt("Skills.Acrobatics.GracefulRoll_MaxBonusLevel", 500); }
-    public double getGracefulRollDamageThreshold() { return config.getDouble("Skills.Acrobatics.GracefulRoll_DamageThreshold", 14.0D); }
+    public double getGracefulRollChanceMax() { return config.getDouble("Skills.Acrobatics.GracefulRoll.ChanceMax", 100.0D); }
+    public int getGracefulRollMaxBonusLevel() { return config.getInt("Skills.Acrobatics.GracefulRoll.MaxBonusLevel", 500); }
+    public double getGracefulRollDamageThreshold() { return config.getDouble("Skills.Acrobatics.GracefulRoll.DamageThreshold", 14.0D); }
 
     public int getDodgeXPModifier() { return config.getInt("Skills.Acrobatics.Dodge_XP_Modifier", 120); }
     public int getRollXPModifier() { return config.getInt("Skills.Acrobatics.Roll_XP_Modifier", 80); }
@@ -632,38 +632,38 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
     public double getFeatherFallXPModifier() { return config.getDouble("Skills.Acrobatics.FeatherFall_Multiplier", 2.0); }
 
     /* ARCHERY */
-    public int getSkillShotIncreaseLevel() { return config.getInt("Skills.Archery.SkillShot_IncreaseLevel", 50); }
-    public double getSkillShotIncreasePercentage() { return config.getDouble("Skills.Archery.SkillShot_IncreasePercentage", 0.1D); }
-    public double getSkillShotBonusMax() { return config.getDouble("Skills.Archery.SkillShot_MaxBonus", 2.0D); }
-    public double getSkillShotDamageMax() { return config.getDouble("Skills.Archery.SkillShot_MaxDamage", 9.0D); }
+    public int getSkillShotIncreaseLevel() { return config.getInt("Skills.Archery.SkillShot.IncreaseLevel", 50); }
+    public double getSkillShotIncreasePercentage() { return config.getDouble("Skills.Archery.SkillShot.IncreasePercentage", 0.1D); }
+    public double getSkillShotBonusMax() { return config.getDouble("Skills.Archery.SkillShot.MaxBonus", 2.0D); }
+    public double getSkillShotDamageMax() { return config.getDouble("Skills.Archery.SkillShot.MaxDamage", 9.0D); }
 
-    public double getDazeBonusMax() { return config.getDouble("Skills.Archery.Daze_MaxChance", 50.0D); }
-    public int getDazeMaxBonusLevel() { return config.getInt("Skills.Archery.Daze_MaxBonusLevel", 1000); }
-    public double getDazeModifier() { return config.getDouble("Skills.Archery.Daze_BonusDamage", 4.0D); }
+    public double getDazeBonusMax() { return config.getDouble("Skills.Archery.Daze.MaxChance", 50.0D); }
+    public int getDazeMaxBonusLevel() { return config.getInt("Skills.Archery.Daze.MaxBonusLevel", 1000); }
+    public double getDazeModifier() { return config.getDouble("Skills.Archery.Daze.BonusDamage", 4.0D); }
 
-    public double getRetrieveChanceMax() { return config.getDouble("Skills.Archery.Retrieve_MaxBonus", 100.0D); }
-    public int getRetrieveMaxBonusLevel() { return config.getInt("Skills.Archery.Retrieve_MaxBonusLevel", 1000); }
+    public double getRetrieveChanceMax() { return config.getDouble("Skills.Archery.Retrieve.MaxBonus", 100.0D); }
+    public int getRetrieveMaxBonusLevel() { return config.getInt("Skills.Archery.Retrieve.MaxBonusLevel", 1000); }
 
-    public double getForceMultiplier() { return config.getDouble("Skills.Archery.Force_Multiplier", 2.0D); }
+    public double getForceMultiplier() { return config.getDouble("Skills.Archery.ForceMultiplier", 2.0D); }
 
     /* AXES */
-    public double getBonusDamageAxesBonusMax() { return config.getDouble("Skills.Axes.DamageIncrease_MaxBonus", 4.0D); }
-    public int getBonusDamageAxesMaxBonusLevel() { return config.getInt("Skills.Axes.DamageIncrease_MaxBonusLevel", 200); }
+    public double getBonusDamageAxesBonusMax() { return config.getDouble("Skills.Axes.DamageIncrease.MaxBonus", 4.0D); }
+    public int getBonusDamageAxesMaxBonusLevel() { return config.getInt("Skills.Axes.DamageIncrease.MaxBonusLevel", 200); }
 
-    public double getAxesCriticalChance() { return config.getDouble("Skills.Axes.AxesCritical_MaxChance", 37.50D); }
-    public int getAxesCriticalMaxBonusLevel() { return config.getInt("Skills.Axes.AxesCritical_MaxBonusLevel", 750); }
-    public double getAxesCriticalPVPModifier() { return config.getDouble("Skills.Axes.AxesCritical_PVP_Modifier", 1.5D); }
-    public double getAxesCriticalPVEModifier() { return config.getDouble("Skills.Axes.AxesCritical_PVE_Modifier", 2.0D); }
+    public double getAxesCriticalChance() { return config.getDouble("Skills.Axes.AxesCritical.MaxChance", 37.50D); }
+    public int getAxesCriticalMaxBonusLevel() { return config.getInt("Skills.Axes.AxesCritical.MaxBonusLevel", 750); }
+    public double getAxesCriticalPVPModifier() { return config.getDouble("Skills.Axes.AxesCritical.PVP_Modifier", 1.5D); }
+    public double getAxesCriticalPVEModifier() { return config.getDouble("Skills.Axes.AxesCritical.PVE_Modifier", 2.0D); }
 
-    public double getGreaterImpactChance() { return config.getDouble("Skills.Axes.GreaterImpact_Chance", 25.0D); }
-    public double getGreaterImpactModifier() { return config.getDouble("Skills.Axes.GreaterImpact_KnockbackModifier", 1.5D); }
-    public double getGreaterImpactBonusDamage() { return config.getDouble("Skills.Axes.GreaterImpact_BonusDamage", 2.0D); }
+    public double getGreaterImpactChance() { return config.getDouble("Skills.Axes.GreaterImpact.Chance", 25.0D); }
+    public double getGreaterImpactModifier() { return config.getDouble("Skills.Axes.GreaterImpact.KnockbackModifier", 1.5D); }
+    public double getGreaterImpactBonusDamage() { return config.getDouble("Skills.Axes.GreaterImpact.BonusDamage", 2.0D); }
 
-    public int getArmorImpactIncreaseLevel() { return config.getInt("Skills.Axes.ArmorImpact_IncreaseLevel", 50); }
-    public double getImpactChance() { return config.getDouble("Skills.Axes.ArmorImpact_Chance", 25.0D); }
-    public double getArmorImpactMaxDurabilityDamage() { return config.getDouble("Skills.Axes.ArmorImpact_MaxPercentageDurabilityDamage", 20.0D); }
+    public int getArmorImpactIncreaseLevel() { return config.getInt("Skills.Axes.ArmorImpact.IncreaseLevel", 50); }
+    public double getImpactChance() { return config.getDouble("Skills.Axes.ArmorImpact.Chance", 25.0D); }
+    public double getArmorImpactMaxDurabilityDamage() { return config.getDouble("Skills.Axes.ArmorImpact.MaxPercentageDurabilityDamage", 20.0D); }
 
-    public double getSkullSplitterModifier() { return config.getDouble("Skills.Axes.SkullSplitter_DamagerModifier", 2.0D); }
+    public double getSkullSplitterModifier() { return config.getDouble("Skills.Axes.SkullSplitter.DamagerModifier", 2.0D); }
 
     /* EXCAVATION */
     //Nothing to configure, everything is already configurable in config.yml
@@ -671,125 +671,126 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
     /* FISHING */
     public int getFishingTierLevel(Fishing.Tier tier) { return config.getInt("Skills.Fishing.Rank_Levels.Rank_" + tier.toNumerical()); }
     public double getShakeChance(Fishing.Tier tier) { return config.getDouble("Skills.Fishing.Shake_Chance.Rank_" + tier.toNumerical()); }
-    public int getFishingVanillaXPModifier(Fishing.Tier tier) { return config.getInt("Skills.Fishing.VanillaXPBoost.Rank_" + tier.toNumerical()); }
+    public int getFishingVanillaXPModifier(Fishing.Tier tier) { return config.getInt("Skills.Fishing.VanillaXPMultiplier.Rank_" + tier.toNumerical()); }
 
-    public double getFishingMagicMultiplier() { return config.getDouble("Skills.Fishing.MagicHunter_Multiplier", 5.0D); }
+    public double getFishingMagicMultiplier() { return config.getDouble("Skills.Fishing.MagicHunter.Multiplier", 2.5D); }
 
-    public int getFishermanDietRankChange() { return config.getInt("Skills.Fishing.Fisherman_Diet_RankChange", 200); }
+    public int getFishermanDietRankChange() { return config.getInt("Skills.Fishing.FishermansDiet.RankChange", 200); }
 
-    public int getIceFishingUnlockLevel() { return config.getInt("Skills.Fishing.Ice_Fishing_UnlockLevel", 50); }
+    public int getIceFishingUnlockLevel() { return config.getInt("Skills.Fishing.IceFishing.UnlockLevel", 50); }
 
     /* HERBALISM */
-    public int getFarmerDietRankChange() { return config.getInt("Skills.Herbalism.Farmer_Diet_RankChange", 200); }
+    public int getFarmerDietRankChange() { return config.getInt("Skills.Herbalism.FarmersDiet.RankChange", 200); }
 
-    public int getGreenThumbStageChange() { return config.getInt("Skills.Herbalism.GreenThumb_StageChange", 200); }
-    public double getGreenThumbChanceMax() { return config.getDouble("Skills.Herbalism.GreenThumb_ChanceMax", 100.0D); }
-    public int getGreenThumbMaxLevel() { return config.getInt("Skills.Herbalism.GreenThumb_MaxBonusLevel", 1500); }
+    public int getGreenThumbStageChange() { return config.getInt("Skills.Herbalism.GreenThumb.StageChange", 200); }
+    public double getGreenThumbChanceMax() { return config.getDouble("Skills.Herbalism.GreenThumb.ChanceMax", 100.0D); }
+    public int getGreenThumbMaxLevel() { return config.getInt("Skills.Herbalism.GreenThumb.MaxBonusLevel", 1500); }
 
-    public double getHerbalismDoubleDropsChanceMax() { return config.getDouble("Skills.Herbalism.DoubleDrops_ChanceMax", 100.0D); }
-    public int getHerbalismDoubleDropsMaxLevel() { return config.getInt("Skills.Herbalism.DoubleDrops_MaxBonusLevel", 1000); }
+    public double getHerbalismDoubleDropsChanceMax() { return config.getDouble("Skills.Herbalism.DoubleDrops.ChanceMax", 100.0D); }
+    public int getHerbalismDoubleDropsMaxLevel() { return config.getInt("Skills.Herbalism.DoubleDrops.MaxBonusLevel", 1000); }
 
-    public double getHylianLuckChanceMax() { return config.getDouble("Skills.Herbalism.HylianLuck_ChanceMax", 10.0D); }
-    public int getHylianLuckMaxLevel() { return config.getInt("Skills.Herbalism.HylianLuck_MaxBonusLevel", 1000); }
+    public double getHylianLuckChanceMax() { return config.getDouble("Skills.Herbalism.HylianLuck.ChanceMax", 10.0D); }
+    public int getHylianLuckMaxLevel() { return config.getInt("Skills.Herbalism.HylianLuck.MaxBonusLevel", 1000); }
 
-    public double getShroomThumbChanceMax() { return config.getDouble("Skills.Herbalism.ShroomThumb_ChanceMax", 50.0D); }
-    public int getShroomThumbMaxLevel() { return config.getInt("Skills.Herbalism.ShroomThumb_MaxBonusLevel", 1500); }
+    public double getShroomThumbChanceMax() { return config.getDouble("Skills.Herbalism.ShroomThumb.ChanceMax", 50.0D); }
+    public int getShroomThumbMaxLevel() { return config.getInt("Skills.Herbalism.ShroomThumb.MaxBonusLevel", 1500); }
 
     /* MINING */
-    public double getMiningDoubleDropChance() { return config.getDouble("Skills.Mining.DoubleDrops_ChanceMax", 100.0D); }
-    public int getMiningDoubleDropMaxLevel() { return config.getInt("Skills.Mining.DoubleDrops_MaxBonusLevel", 1000); }
+    public double getMiningDoubleDropChance() { return config.getDouble("Skills.Mining.DoubleDrops.ChanceMax", 100.0D); }
+    public int getMiningDoubleDropMaxLevel() { return config.getInt("Skills.Mining.DoubleDrops.MaxBonusLevel", 1000); }
 
-    public int getBlastMiningRankLevel(BlastMining.Tier tier) { return config.getInt("Skills.Mining.BlastMining_Rank" + tier.toNumerical()); }
-    public double getBlastDamageDecrease(BlastMining.Tier tier) { return config.getDouble("Skills.Mining.BlastDamageDecrease_Rank" + tier.toNumerical()); }
-    public double getOreBonus(BlastMining.Tier tier) { return config.getDouble("Skills.Mining.OreBonus_Rank" + tier.toNumerical()); }
-    public double getDebrisReduction(BlastMining.Tier tier) { return config.getDouble("Skills.Mining.DebrisReduction_Rank" + tier.toNumerical()); }
-    public int getDropMultiplier(BlastMining.Tier tier) { return config.getInt("Skills.Mining.DropMultiplier_Rank" + tier.toNumerical()); }
-    public double getBlastRadiusModifier(BlastMining.Tier tier) { return config.getDouble("Skills.Mining.BlastRadiusModifier_Rank" + tier.toNumerical()); }
+    public int getBlastMiningRankLevel(BlastMining.Tier tier) { return config.getInt("Skills.Mining.BlastMining.Rank_Levels.Rank_" + tier.toNumerical()); }
+    public double getBlastDamageDecrease(BlastMining.Tier tier) { return config.getDouble("Skills.Mining.BlastMining.BlastDamageDecrease.Rank_" + tier.toNumerical()); }
+    public double getOreBonus(BlastMining.Tier tier) { return config.getDouble("Skills.Mining.BlastMining.OreBonus.Rank_" + tier.toNumerical()); }
+    public double getDebrisReduction(BlastMining.Tier tier) { return config.getDouble("Skills.Mining.BlastMining.DebrisReduction.Rank_" + tier.toNumerical()); }
+    public int getDropMultiplier(BlastMining.Tier tier) { return config.getInt("Skills.Mining.BlastMining.DropMultiplier.Rank_" + tier.toNumerical()); }
+    public double getBlastRadiusModifier(BlastMining.Tier tier) { return config.getDouble("Skills.Mining.BlastMining.BlastRadiusModifier.Rank_" + tier.toNumerical()); }
 
     /* REPAIR */
-    public double getRepairMasteryMaxBonus() { return config.getDouble("Skills.Repair.RepairMastery_MaxBonusPercentage", 200.0D); }
-    public int getRepairMasteryMaxLevel() { return config.getInt("Skills.Repair.RepairMastery_MaxBonusLevel", 1000); }
-    public double getSuperRepairChanceMax() { return config.getDouble("Skills.Repair.SuperRepair_ChanceMax", 100.0D); }
-    public int getSuperRepairMaxLevel() { return config.getInt("Skills.Repair.SuperRepair_MaxBonusLevel", 1000); }
-    public int getSalvageUnlockLevel() { return config.getInt("Skills.Repair.Salvage_UnlockLevel", 600); }
+    public double getRepairMasteryMaxBonus() { return config.getDouble("Skills.Repair.RepairMastery.MaxBonusPercentage", 200.0D); }
+    public int getRepairMasteryMaxLevel() { return config.getInt("Skills.Repair.RepairMastery.MaxBonusLevel", 1000); }
+    public double getSuperRepairChanceMax() { return config.getDouble("Skills.Repair.SuperRepair.ChanceMax", 100.0D); }
+    public int getSuperRepairMaxLevel() { return config.getInt("Skills.Repair.SuperRepair.MaxBonusLevel", 1000); }
+    public int getSalvageUnlockLevel() { return config.getInt("Skills.Repair.Salvage.UnlockLevel", 600); }
 
     /* Arcane Forging */
-    public int getArcaneForgingRankLevel(ArcaneForging.Tier tier) { return config.getInt("Skills.Repair.Arcane_Forging.Rank_Levels.Rank_" + tier.toNumerical()); }
+    public int getArcaneForgingRankLevel(ArcaneForging.Tier tier) { return config.getInt("Skills.Repair.ArcaneForging.Rank_Levels.Rank_" + tier.toNumerical()); }
 
-    public boolean getArcaneForgingEnchantLossEnabled() { return config.getBoolean("Skills.Repair.Arcane_Forging.May_Lose_Enchants", true); }
-    public double getArcaneForgingKeepEnchantsChance(ArcaneForging.Tier tier) { return config.getDouble("Skills.Repair.Arcane_Forging.Keep_Enchants_Chance.Rank_" + tier.toNumerical()); }
+    public boolean getArcaneForgingEnchantLossEnabled() { return config.getBoolean("Skills.Repair.ArcaneForging.May_Lose_Enchants", true); }
+    public double getArcaneForgingKeepEnchantsChance(ArcaneForging.Tier tier) { return config.getDouble("Skills.Repair.ArcaneForging.Keep_Enchants_Chance.Rank_" + tier.toNumerical()); }
 
-    public boolean getArcaneForgingDowngradeEnabled() { return config.getBoolean("Skills.Repair.Arcane_Forging.Downgrades_Enabled", true); }
-    public double getArcaneForgingDowngradeChance(ArcaneForging.Tier tier) { return config.getDouble("Skills.Repair.Arcane_Forging.Downgrades_Chance.Rank_" + tier.toNumerical()); }
+    public boolean getArcaneForgingDowngradeEnabled() { return config.getBoolean("Skills.Repair.ArcaneForging.Downgrades_Enabled", true); }
+    public double getArcaneForgingDowngradeChance(ArcaneForging.Tier tier) { return config.getDouble("Skills.Repair.ArcaneForging.Downgrades_Chance.Rank_" + tier.toNumerical()); }
 
     /* SMELTING */
-    public int getBurnModifierMaxLevel() { return config.getInt("Skills.Smelting.FuelEfficiency_MaxBonusLevel", 1000); }
-    public double getBurnTimeMultiplier() { return config.getDouble("Skills.Smelting.FuelEfficiency_Multiplier", 3.0D); }
+    public int getBurnModifierMaxLevel() { return config.getInt("Skills.Smelting.FuelEfficiency.MaxBonusLevel", 1000); }
+    public double getBurnTimeMultiplier() { return config.getDouble("Skills.Smelting.FuelEfficiency.Multiplier", 3.0D); }
 
-    public int getSecondSmeltMaxLevel() { return config.getInt("Skills.Smelting.SecondSmelt_MaxBonusLevel", 1000); }
-    public double getSecondSmeltMaxChance() { return config.getDouble("Skills.Smelting.SecondSmelt_MaxBonusChance", 100.0D); }
+    public int getSecondSmeltMaxLevel() { return config.getInt("Skills.Smelting.SecondSmelt.MaxBonusLevel", 1000); }
+    public double getSecondSmeltMaxChance() { return config.getDouble("Skills.Smelting.SecondSmelt.MaxBonusChance", 100.0D); }
 
-    public int getFluxMiningUnlockLevel() { return config.getInt("Skills.Smelting.FluxMining_UnlockLevel", 250); }
-    public double getFluxMiningChance() { return config.getDouble("Skills.Smelting.FluxMining_Chance", 33.0D); }
+    public int getFluxMiningUnlockLevel() { return config.getInt("Skills.Smelting.FluxMining.UnlockLevel", 250); }
+    public double getFluxMiningChance() { return config.getDouble("Skills.Smelting.FluxMining.Chance", 33.0D); }
 
-    public int getSmeltingVanillaXPBoostRankLevel(Smelting.Tier tier) { return config.getInt("Skills.Smelting.VanillaXPBoost.Rank_Levels.Rank_" + tier.toNumerical()); }
-    public int getSmeltingVanillaXPBoostMultiplier(Smelting.Tier tier) { return config.getInt("Skills.Smelting.VanillaXPBoost.XP_Multiplier.Rank_" + tier.toNumerical()); }
+    public int getSmeltingRankLevel(Smelting.Tier tier) { return config.getInt("Skills.Smelting.Rank_Levels.Rank_" + tier.toNumerical()); }
+
+    public int getSmeltingVanillaXPBoostMultiplier(Smelting.Tier tier) { return config.getInt("Skills.Smelting.VanillaXPMultiplier.Rank_" + tier.toNumerical()); }
 
     /* SWORDS */
-    public double getBleedChanceMax() { return config.getDouble("Skills.Swords.Bleed_ChanceMax", 75.0D); }
-    public int getBleedMaxBonusLevel() { return config.getInt("Skills.Swords.Bleed_MaxBonusLevel", 750); }
-    public int getBleedMaxTicks() { return config.getInt("Skills.Swords.Bleed_MaxTicks", 3); }
-    public int getBleedBaseTicks() { return config.getInt("Skills.Swords.Bleed_BaseTicks", 2); }
+    public double getBleedChanceMax() { return config.getDouble("Skills.Swords.Bleed.ChanceMax", 75.0D); }
+    public int getBleedMaxBonusLevel() { return config.getInt("Skills.Swords.Bleed.MaxBonusLevel", 750); }
+    public int getBleedMaxTicks() { return config.getInt("Skills.Swords.Bleed.MaxTicks", 3); }
+    public int getBleedBaseTicks() { return config.getInt("Skills.Swords.Bleed.BaseTicks", 2); }
 
-    public boolean getCounterRequiresBlock() { return config.getBoolean("Skills.Swords.Counter_RequiresBlock"); }
-    public double getCounterChanceMax() { return config.getDouble("Skills.Swords.Counter_ChanceMax", 30.0D); }
-    public int getCounterMaxBonusLevel() { return config.getInt("Skills.Swords.Counter_MaxBonusLevel", 600); }
-    public double getCounterModifier() { return config.getDouble("Skills.Swords.Counter_DamageModifier", 2.0D); }
+    public boolean getCounterRequiresBlock() { return config.getBoolean("Skills.Swords.Counter.RequiresBlock"); }
+    public double getCounterChanceMax() { return config.getDouble("Skills.Swords.Counter.ChanceMax", 30.0D); }
+    public int getCounterMaxBonusLevel() { return config.getInt("Skills.Swords.Counter.MaxBonusLevel", 600); }
+    public double getCounterModifier() { return config.getDouble("Skills.Swords.Counter.DamageModifier", 2.0D); }
 
-    public double getSerratedStrikesModifier() { return config.getDouble("Skills.Swords.SerratedStrikes_DamageModifier", 4.0D); }
-    public int getSerratedStrikesTicks() { return config.getInt("Skills.Swords.SerratedStrikes_BleedTicks", 5); }
+    public double getSerratedStrikesModifier() { return config.getDouble("Skills.Swords.SerratedStrikes.DamageModifier", 4.0D); }
+    public int getSerratedStrikesTicks() { return config.getInt("Skills.Swords.SerratedStrikes.BleedTicks", 5); }
 
     /* TAMING */
-    public double getGoreChanceMax() { return config.getDouble("Skills.Taming.Gore_ChanceMax", 100.0D); }
-    public int getGoreMaxBonusLevel() { return config.getInt("Skills.Taming.Gore_MaxBonusLevel", 1000); }
-    public int getGoreBleedTicks() { return config.getInt("Skills.Taming.Gore_BleedTicks", 2); }
-    public double getGoreModifier() { return config.getDouble("Skills.Taming.Gore_Modifier", 2.0D); }
+    public double getGoreChanceMax() { return config.getDouble("Skills.Taming.Gore.ChanceMax", 100.0D); }
+    public int getGoreMaxBonusLevel() { return config.getInt("Skills.Taming.Gore.MaxBonusLevel", 1000); }
+    public int getGoreBleedTicks() { return config.getInt("Skills.Taming.Gore.BleedTicks", 2); }
+    public double getGoreModifier() { return config.getDouble("Skills.Taming.Gore.Modifier", 2.0D); }
 
-    public int getFastFoodUnlock() { return config.getInt("Skills.Taming.FastFood_UnlockLevel", 50); }
-    public double getFastFoodChance() { return config.getDouble("Skills.Taming.FastFood_Chance", 50.0D); }
+    public int getFastFoodUnlock() { return config.getInt("Skills.Taming.FastFood.UnlockLevel", 50); }
+    public double getFastFoodChance() { return config.getDouble("Skills.Taming.FastFood.Chance", 50.0D); }
 
-    public int getEnviromentallyAwareUnlock() { return config.getInt("Skills.Taming.EnvironmentallyAware_UnlockLevel", 100); }
+    public int getEnviromentallyAwareUnlock() { return config.getInt("Skills.Taming.EnvironmentallyAware.UnlockLevel", 100); }
 
-    public int getThickFurUnlock() { return config.getInt("Skills.Taming.ThickFur_UnlockLevel", 250); }
-    public double getThickFurModifier() { return config.getDouble("Skills.Taming.ThickFur_Modifier", 2.0D); }
+    public int getThickFurUnlock() { return config.getInt("Skills.Taming.ThickFur.UnlockLevel", 250); }
+    public double getThickFurModifier() { return config.getDouble("Skills.Taming.ThickFur.Modifier", 2.0D); }
 
-    public int getHolyHoundUnlock() {return config.getInt("Skills.Taming.HolyHound_UnlockLevel", 375); }
+    public int getHolyHoundUnlock() {return config.getInt("Skills.Taming.HolyHound.UnlockLevel", 375); }
 
-    public int getShockProofUnlock() { return config.getInt("Skills.Taming.ShockProof_UnlockLevel", 500); }
-    public double getShockProofModifier() { return config.getDouble("Skills.Taming.ShockProof_Modifier", 6.0D); }
+    public int getShockProofUnlock() { return config.getInt("Skills.Taming.ShockProof.UnlockLevel", 500); }
+    public double getShockProofModifier() { return config.getDouble("Skills.Taming.ShockProof.Modifier", 6.0D); }
 
-    public int getSharpenedClawsUnlock() { return config.getInt("Skills.Taming.SharpenedClaws_UnlockLevel", 750); }
-    public double getSharpenedClawsBonus() { return config.getDouble("Skills.Taming.SharpenedClaws_Bonus", 2.0D); }
+    public int getSharpenedClawsUnlock() { return config.getInt("Skills.Taming.SharpenedClaws.UnlockLevel", 750); }
+    public double getSharpenedClawsBonus() { return config.getDouble("Skills.Taming.SharpenedClaws.Bonus", 2.0D); }
 
     /* UNARMED */
-    public double getDisarmChanceMax() { return config.getDouble("Skills.Unarmed.Disarm_ChanceMax", 33.0D); }
-    public int getDisarmMaxBonusLevel() { return config.getInt("Skills.Unarmed.Disarm_MaxBonusLevel", 1000); }
+    public double getDisarmChanceMax() { return config.getDouble("Skills.Unarmed.Disarm.ChanceMax", 33.0D); }
+    public int getDisarmMaxBonusLevel() { return config.getInt("Skills.Unarmed.Disarm.MaxBonusLevel", 1000); }
 
-    public double getDeflectChanceMax() { return config.getDouble("Skills.Unarmed.Deflect_ChanceMax", 50.0D); }
-    public int getDeflectMaxBonusLevel() { return config.getInt("Skills.Unarmed.Deflect_MaxBonusLevel", 1000); }
+    public double getDeflectChanceMax() { return config.getDouble("Skills.Unarmed.Deflect.ChanceMax", 50.0D); }
+    public int getDeflectMaxBonusLevel() { return config.getInt("Skills.Unarmed.Deflect.MaxBonusLevel", 1000); }
 
-    public double getIronGripChanceMax() { return config.getDouble("Skills.Unarmed.IronGrip_ChanceMax", 100.0D); }
-    public int getIronGripMaxBonusLevel() { return config.getInt("Skills.Unarmed.IronGrip_MaxBonusLevel", 1000); }
+    public double getIronGripChanceMax() { return config.getDouble("Skills.Unarmed.IronGrip.ChanceMax", 100.0D); }
+    public int getIronGripMaxBonusLevel() { return config.getInt("Skills.Unarmed.IronGrip.MaxBonusLevel", 1000); }
 
-    public double getIronArmMinBonus() { return config.getDouble("Skills.Unarmed.IronArm_BonusMin", 3.0D); }
-    public double getIronArmMaxBonus() { return config.getDouble("Skills.Unarmed.IronArm_BonusMax", 8.0D); }
-    public int getIronArmIncreaseLevel() { return config.getInt("Skills.Unarmed.IronArm_IncreaseLevel", 50); }
+    public double getIronArmMinBonus() { return config.getDouble("Skills.Unarmed.IronArm.BonusMin", 3.0D); }
+    public double getIronArmMaxBonus() { return config.getDouble("Skills.Unarmed.IronArm.BonusMax", 8.0D); }
+    public int getIronArmIncreaseLevel() { return config.getInt("Skills.Unarmed.IronArm.IncreaseLevel", 50); }
 
     /* WOODCUTTING */
-    public int getLeafBlowUnlockLevel() { return config.getInt("Skills.Woodcutting.LeafBlower_UnlockLevel", 100); }
+    public int getLeafBlowUnlockLevel() { return config.getInt("Skills.Woodcutting.LeafBlower.UnlockLevel", 100); }
 
-    public double getWoodcuttingDoubleDropChance() { return config.getDouble("Skills.Woodcutting.DoubleDrops_ChanceMax", 100.0D); }
-    public int getWoodcuttingDoubleDropMaxLevel() { return config.getInt("Skills.Woodcutting.DoubleDrops_MaxBonusLevel", 1000); }
+    public double getWoodcuttingDoubleDropChance() { return config.getDouble("Skills.Woodcutting.DoubleDrops.ChanceMax", 100.0D); }
+    public int getWoodcuttingDoubleDropMaxLevel() { return config.getInt("Skills.Woodcutting.DoubleDrops.MaxBonusLevel", 1000); }
 
     /* KRAKEN STUFF */
     public boolean getKrakenEnabled() { return config.getBoolean("Kraken.Enabled", true); }

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

@@ -29,7 +29,7 @@ public class Smelting {
         }
 
         protected int getLevel() {
-            return AdvancedConfig.getInstance().getSmeltingVanillaXPBoostRankLevel(this);
+            return AdvancedConfig.getInstance().getSmeltingRankLevel(this);
         }
 
         protected int getVanillaXPBoostModifier() {

src/main/resources/advanced.yml

@@ -15,35 +15,38 @@
 ###
 Skills:
     General:
-        # This setting will determine when the length of every ability gets longer with 1 second
-        Ability_IncreaseLevel: 50
-        # This setting determines how many enchant levels to use when buffing Super Breaker & Giga Drill Breaker
-        Ability_EnchantBuff: 5
+        Ability:
+            # IncreaseLevel: This setting will determine when the length of every ability gets longer with 1 second
+            # EnchantBuff: This setting determines how many enchant levels to use when buffing Super Breaker & Giga Drill Breaker
+            IncreaseLevel: 50
+            EnchantBuff: 5
     #
     #  Settings for Acrobatics
     ###
     Acrobatics:
-        # Dodge_ChanceMax: Maximum chance of dodging when on Dodge_MaxBonusLevel or higher
-        # Dodge_MaxBonusLevel: On this level or higher, the dodge chance will not go higher than Dodge_ChanceMax
-        # Dodge_DamageModifer: Dodge damage will be divided by this modifier
-        Dodge_ChanceMax: 20.0
-        Dodge_MaxBonusLevel: 800
-        Dodge_DamageModifier: 2.0
-
-        # Roll_ChanceMax: Maximum chance of rolling when on Roll_MaxBonusLevel or higher
-        # Roll_MaxBonusLevel: On this level or higher, the roll chance will not go higher than Roll_ChanceMax
-        # Roll_DamageThreshold: The max damage a player can negate with a roll
-        Roll_ChanceMax: 100.0
-        Roll_MaxBonusLevel: 1000
-        Roll_DamageThreshold: 7.0
-
-        # GracefulRoll_ChanceMax: Maximum chance of graceful rolling when on GracefulRoll_MaxBonusLevel or higher
-        # GracefulRoll_MaxBonusLevel: On this level or higher, the graceful roll chance will not go higher than GracefulRoll_ChanceMax
-        # GracefulRoll_DamageThreshold: The max damage a player can negate with a graceful roll
-        # GracefulRoll_SuccessModifier: Graceful rolls will be this many times more likely to succeed than regular rolls
-        GracefulRoll_ChanceMax: 100.0
-        GracefulRoll_MaxBonusLevel: 500
-        GracefulRoll_DamageThreshold: 14.0
+        Dodge:
+            # ChanceMax: Maximum chance of dodging when on Dodge_MaxBonusLevel or higher
+            # MaxBonusLevel: On this level or higher, the dodge chance will not go higher than Dodge_ChanceMax
+            # DamageModifer: Dodge damage will be divided by this modifier
+            ChanceMax: 20.0
+            MaxBonusLevel: 800
+            DamageModifier: 2.0
+
+        Roll:
+            # ChanceMax: Maximum chance of rolling when on Roll_MaxBonusLevel or higher
+            # MaxBonusLevel: On this level or higher, the roll chance will not go higher than Roll_ChanceMax
+            # DamageThreshold: The max damage a player can negate with a roll
+            ChanceMax: 100.0
+            MaxBonusLevel: 1000
+            DamageThreshold: 7.0
+
+        GracefulRoll:
+            # ChanceMax: Maximum chance of graceful rolling when on GracefulRoll_MaxBonusLevel or higher
+            # MaxBonusLevel: On this level or higher, the graceful roll chance will not go higher than GracefulRoll_ChanceMax
+            # DamageThreshold: The max damage a player can negate with a graceful roll
+            ChanceMax: 100.0
+            MaxBonusLevel: 500
+            DamageThreshold: 14.0
 
         # Amount of experience for performing a dodge, roll or fall
         Dodge_XP_Modifier: 120
@@ -56,221 +59,248 @@ Skills:
     #  Settings for Archery
     ###
     Archery:
-        # SkillShot_IncreaseLevel: Every "SkillShot_IncreaseLevel" the skillshot bonus will go up by "SkillShot_IncreasePercentage"
-        # SkillShot_IncreasePercentage: This is a percentage value, 0.1 = 10%
-        # SkillShot_MaxBonus: When the SkillShot_MaxBonus has been reached, the bonus percentage will not go up anymore. 2.0 = 200%
-        SkillShot_IncreaseLevel: 50
-        SkillShot_IncreasePercentage: 0.1
-        SkillShot_MaxBonus: 2.0
-        SkillShot_MaxDamage: 9.0
-
-        # Daze_MaxChance: Maximum chance of causing daze to opponents
-        # Daze_MaxBonusLevel: Maximum bonus level of Daze, when a player reaches this level his chance of causing a daze will be "Daze_MaxChance"
-        # Daze_Modifier: Extra damage for arrows that cause a daze (2 damage = 1 heart)
-        Daze_MaxChance: 50.0
-        Daze_MaxBonusLevel: 1000
-        Daze_Modifier: 4.0
-
-        # Retrieve_MaxChance: Maximum chance or retrieving arrows
-        # Retrieve_MaxBonusLevel: Maximum bonus level for Arrow retrieval, at this level the chance of retrieving arrows from mobs is Retrieve_MaxBonus
-        Retrieve_MaxChance: 100.0
-        Retrieve_MaxBonusLevel: 1000
-
-        #Force_Multiplier: Multiply the force of the bow by this for an XP boost.
-        Force_Multiplier: 2.0
+        SkillShot:
+            # IncreaseLevel: Every <IncreaseLevel> the skillshot bonus will go up by <IncreasePercentage>
+            # IncreasePercentage: This is a percentage value, 0.1 = 10%
+            # MaxBonus: When the <MaxBonus> has been reached, the bonus percentage will not go up anymore. 2.0 = 200%
+            IncreaseLevel: 50
+            IncreasePercentage: 0.1
+            MaxBonus: 2.0
+            MaxDamage: 9.0
+
+        Daze:
+            # MaxChance: Maximum chance of causing daze to opponents
+            # MaxBonusLevel: Maximum bonus level of Daze, when a player reaches this level his chance of causing a daze will be <Daze_MaxChance>
+            # Modifier: Extra damage for arrows that cause a daze (2 damage = 1 heart)
+            MaxChance: 50.0
+            MaxBonusLevel: 1000
+            Modifier: 4.0
+
+        Retrieve:
+            # MaxChance: Maximum chance or retrieving arrows
+            # MaxBonusLevel: Maximum bonus level for Arrow retrieval, at this level the chance of retrieving arrows from mobs is <MaxBonus>
+            MaxChance: 100.0
+            MaxBonusLevel: 1000
+
+        # ForceMultiplier: Multiply the force of the bow by this for an XP boost.
+        ForceMultiplier: 2.0
     #
     #  Settings for Axes
     ###
     Axes:
-        # DamageIncrease_MaxBonus: Maximum bonus damage
-        # DamageIncrease_MaxBonusLevel: Level where the maximum bonus is reached
-        DamageIncrease_MaxBonus: 4.0
-        DamageIncrease_MaxBonusLevel: 200
-
-        # AxesCritical_MaxChance: Maximum chance of causing a critical hit
-        # AxesCritical_MaxBonusLevel: Level where the maximum chance of causing critical hits is reached
-        AxesCritical_MaxChance: 37.50
-        AxesCritical_MaxBonusLevel: 750
-
-        # Damage modifier of critical hits for PVP / PVE, when causing a critical hit the damage gets multiplied by the modifier
-        AxesCritical_PVP_Modifier: 1.5
-        AxesCritical_PVE_Modifier: 2.0
-
-        # GreaterImpact_Chance: Chance of hitting with GreaterImpact, knocksbacks mobs
-        # GreaterImpact_KnockbackModifier: Velocity modifier of GreaterImpact hits, this determines how great the knockback is
-        # GreaterImpact_BonusDamage: Extra damage for GreaterImpact hits
-        GreaterImpact_Chance: 25.0
-        GreaterImpact_KnockbackModifier: 1.5
-        GreaterImpact_BonusDamage: 2.0
-
-        # ArmorImpact_IncreaseLevel: Every "IncreaseLevel" the durability damage goes up with 1
-        # ArmorImpact_Chance: Chance of hitting with ArmorImpact
-        # ArmorImpact_MaxPercentageDurabilityDamage: Durability damage cap for ArmorImpact, 20% means that you can never destroy a piece of armor in less than 5 hits
-        ArmorImpact_IncreaseLevel: 50
-        ArmorImpact_Chance: 25.0
-        ArmorImpact_MaxPercentageDurabilityDamage: 20.0
-
-        # SkullSplitter_DamageModifier: Damage will get divided by this modifier
-        SkullSplitter_DamageModifier: 2.0
+        DamageIncrease:
+            # MaxBonus: Maximum bonus damage
+            # MaxBonusLevel: Level where the maximum bonus is reached
+            MaxBonus: 4.0
+            MaxBonusLevel: 200
+
+        AxesCritical:
+            # MaxChance: Maximum chance of causing a critical hit
+            # MaxBonusLevel: Level where the maximum chance of causing critical hits is reached
+            MaxChance: 37.50
+            MaxBonusLevel: 750
+
+        AxesCritical:
+            # Damage modifier of critical hits for PVP / PVE, when causing a critical hit the damage gets multiplied by the modifier
+            PVP_Modifier: 1.5
+            PVE_Modifier: 2.0
+
+        GreaterImpact:
+            # Chance: Chance of hitting with GreaterImpact, knocksbacks mobs
+            # KnockbackModifier: Velocity modifier of GreaterImpact hits, this determines how great the knockback is
+            # BonusDamage: Extra damage for GreaterImpact hits
+            Chance: 25.0
+            KnockbackModifier: 1.5
+            BonusDamage: 2.0
+
+        ArmorImpact:
+            # IncreaseLevel: Every "IncreaseLevel" the durability damage goes up with 1
+            # Chance: Chance of hitting with ArmorImpact
+            # MaxPercentageDurabilityDamage: Durability damage cap for ArmorImpact, 20% means that you can never destroy a piece of armor in less than 5 hits
+            IncreaseLevel: 50
+            Chance: 25.0
+            MaxPercentageDurabilityDamage: 20.0
+
+        SkullSplitter:
+            # DamageModifier: Damage will get divided by this modifier
+            DamageModifier: 2.0
     #
     #  Settings for Fishing
     ###
     Fishing:
         # Rank_Levels: Fishing level where rank gets unlocked
         Rank_Levels:
-            Rank_1: 125
-            Rank_2: 250
-            Rank_3: 375
-            Rank_4: 500
-            Rank_5: 625
-            Rank_6: 750
-            Rank_7: 875
-            Rank_8: 1000
+            Rank_1: 0
+            Rank_2: 125
+            Rank_3: 250
+            Rank_4: 375
+            Rank_5: 500
+            Rank_6: 625
+            Rank_7: 700
+            Rank_8: 875
 
         Shake_Chance:
-            Rank_1: 25.0
-            Rank_2: 25.0
-            Rank_3: 35.0
+            Rank_1: 15.0
+            Rank_2: 15.0
+            Rank_3: 25.0
             Rank_4: 35.0
             Rank_5: 45.0
             Rank_6: 55.0
             Rank_7: 65.0
             Rank_8: 75.0
 
-        # VanillaXPBoost: Vanilla XP gained from fishing is multiplied by these values.
-        VanillaXPBoost:
-            XP_Multiplier:
-                Rank_1: 1
-                Rank_2: 1
-                Rank_3: 2
-                Rank_4: 2
-                Rank_5: 3
-                Rank_6: 4
-                Rank_7: 5
-                Rank_8: 6
-
-        # MagicHunter_Multiplier: Determines the chance of fishing enchanted items. The chance is calculated by getting the fishing TreasureHunt tier and multiplying it with MagicHunter_Multiplier
-        MagicHunter_Multiplier: 5.0
-
-        # This determines when Fisherman's Diet adds extra hunger recovery to food
-        Fisherman_Diet_RankChange: 200
-
-        # Ice_Fishing_UnlockLevel: Fishing level when the Ice Fishing ability unlocks
-        Ice_Fishing_UnlockLevel: 50
+        # VanillaXPMultiplier: Vanilla XP gained from fishing is multiplied by these values.
+        VanillaXPMultiplier:
+            Rank_1: 1
+            Rank_2: 2
+            Rank_3: 3
+            Rank_4: 3
+            Rank_5: 4
+            Rank_6: 4
+            Rank_7: 5
+            Rank_8: 5
+
+        MagicHunter:
+            # Multiplier: Determines the chance of fishing enchanted items. The chance is calculated by getting the fishing TreasureHunt tier and multiplying it with <Multiplier>
+            Multiplier: 2.5
+
+        FishermansDiet:
+            # This determines when Fisherman's Diet adds extra hunger recovery to food
+            RankChange: 200
+
+        IceFishing:
+            # UnlockLevel: Fishing level when the Ice Fishing ability unlocks
+            UnlockLevel: 50
     #
     #  Settings for Herbalism
     ###
     Herbalism:
-        # This determines when Farmersdiet and Fishermans diet add extra hunger recovery to food
-        Farmer_Diet_RankChange: 200
-
-        # GreenThumb_StageChange: Level value when the GreenThumb stage level goes up
-        # GreenThumb_ChanceMax: Maximum chance of GreenThumb
-        # GreenThumb_MaxBonusLevel: On this level, GreenThumb chance will be GreenThumb_ChanceMax
-        GreenThumb_StageChange: 200
-        GreenThumb_ChanceMax: 100.0
-        GreenThumb_MaxBonusLevel: 1500
-
-        # DoubleDrops_ChanceMax: Maximum chance of receiving double drops
-        # DoubleDrops_MaxBonusLevel: Level when the maximum chance of receiving double drops is reached
-        DoubleDrops_ChanceMax: 100.0
-        DoubleDrops_MaxBonusLevel: 1000
-
-        # HylianLuck_ChanceMax: Maximum chance of Hylian Luck
-        # HylianLuck_MaxBonusLevel: On this level, Hylian Luck chance will be HylianLuck_ChanceMax
-        HylianLuck_ChanceMax: 10.0
-        HylianLuck_MaxBonusLevel: 1000
-
-        # ShroomThumb_ChanceMax: Maximum chance of ShroomThumb
-        # ShroomThumb_MaxBonusLevel: On this level, ShroomThumb chance will be ShroomThumb_ChanceMax
-        ShroomThumb_ChanceMax: 50.0
-        ShroomThumb_MaxBonusLevel: 1500
+        FarmersDiet:
+            # This determines when Farmers Diet adds extra hunger recovery to food
+            RankChange: 200
+
+        GreenThumb:
+            # StageChange: Level value when the GreenThumb stage level goes up
+            # ChanceMax: Maximum chance of GreenThumb
+            # MaxBonusLevel: On this level, GreenThumb chance will be ChanceMax
+            StageChange: 200
+            ChanceMax: 100.0
+            MaxBonusLevel: 1500
+
+        DoubleDrops:
+            # ChanceMax: Maximum chance of receiving double drops
+            # MaxBonusLevel: Level when the maximum chance of receiving double drops is reached
+            ChanceMax: 100.0
+            MaxBonusLevel: 1000
+
+        HylianLuck:
+            # ChanceMax: Maximum chance of Hylian Luck
+            # MaxBonusLevel: On this level, Hylian Luck chance will be ChanceMax
+            ChanceMax: 10.0
+            MaxBonusLevel: 1000
+
+        # ChanceMax: Maximum chance of ShroomThumb
+        # MaxBonusLevel: On this level, ShroomThumb chance will be ChanceMax
+        ShroomThumb:
+            ChanceMax: 50.0
+            MaxBonusLevel: 1500
     #
     #  Settings for Mining
     ###
     Mining:
-        # DoubleDrops_ChanceMax: Maximum chance of receiving double drops
-        # DoubleDrops_MaxBonusLevel: Level when the maximum chance of receiving double drops is reached
-        DoubleDrops_ChanceMax: 100.0
-        DoubleDrops_MaxBonusLevel: 1000
+        DoubleDrops:
+            # ChanceMax: Maximum chance of receiving double drops
+            # MaxBonusLevel: Level when the maximum chance of receiving double drops is reached
+            ChanceMax: 100.0
+            MaxBonusLevel: 1000
 
         # BlastMining_Rank: BlastMining rank unlocks
-        BlastMining_Rank1: 125
-        BlastMining_Rank2: 250
-        BlastMining_Rank3: 375
-        BlastMining_Rank4: 500
-        BlastMining_Rank5: 625
-        BlastMining_Rank6: 750
-        BlastMining_Rank7: 875
-        BlastMining_Rank8: 1000
-
-        # BlastDamageDecrease_Rank: % of damage reduced from TNT explosions
-        BlastDamageDecrease_Rank1: 0.0
-        BlastDamageDecrease_Rank2: 0.0
-        BlastDamageDecrease_Rank3: 0.0
-        BlastDamageDecrease_Rank4: 25.0
-        BlastDamageDecrease_Rank5: 25.0
-        BlastDamageDecrease_Rank6: 50.0
-        BlastDamageDecrease_Rank7: 50.0
-        BlastDamageDecrease_Rank8: 100.0
-
-        # OreBonus_Rank: % of extra ores received when Blast Mining
-        OreBonus_Rank1: 35.0
-        OreBonus_Rank2: 40.0
-        OreBonus_Rank3: 45.0
-        OreBonus_Rank4: 50.0
-        OreBonus_Rank5: 55.0
-        OreBonus_Rank6: 60.0
-        OreBonus_Rank7: 65.0
-        OreBonus_Rank8: 70.0
-
-        # DebrisReduction_Rank: % of fewer non-ores received when Blast Mining
-        DebrisReduction_Rank1: 10.0
-        DebrisReduction_Rank2: 20.0
-        DebrisReduction_Rank3: 30.0
-        DebrisReduction_Rank4: 30.0
-        DebrisReduction_Rank5: 30.0
-        DebrisReduction_Rank6: 30.0
-        DebrisReduction_Rank7: 30.0
-        DebrisReduction_Rank8: 30.0
-
-        # DropMultiplier_Rank: # of times each ore will drop
-        DropMultiplier_Rank1: 1
-        DropMultiplier_Rank2: 1
-        DropMultiplier_Rank3: 1
-        DropMultiplier_Rank4: 1
-        DropMultiplier_Rank5: 2
-        DropMultiplier_Rank6: 2
-        DropMultiplier_Rank7: 3
-        DropMultiplier_Rank8: 3
-
-        # BlastRadiusModifier_Rank: Increases the blast radius by this amount
-        BlastRadiusModifier_Rank1: 1.0
-        BlastRadiusModifier_Rank2: 1.0
-        BlastRadiusModifier_Rank3: 2.0
-        BlastRadiusModifier_Rank4: 2.0
-        BlastRadiusModifier_Rank5: 3.0
-        BlastRadiusModifier_Rank6: 3.0
-        BlastRadiusModifier_Rank7: 4.0
-        BlastRadiusModifier_Rank8: 4.0
+        BlastMining:
+            Rank_Levels:
+                Rank_1: 125
+                Rank_2: 250
+                Rank_3: 375
+                Rank_4: 500
+                Rank_5: 625
+                Rank_6: 750
+                Rank_7: 875
+                Rank_8: 1000
+
+            # BlastDamageDecrease Ranks: % of damage reduced from TNT explosions
+            BlastDamageDecrease:
+                Rank_1: 0.0
+                Rank_2: 0.0
+                Rank_3: 0.0
+                Rank_4: 25.0
+                Rank_5: 25.0
+                Rank_6: 50.0
+                Rank_7: 50.0
+                Rank_8: 100.0
+
+            # OreBonus Ranks: % of extra ores received when Blast Mining
+            OreBonus:
+                Rank_1: 35.0
+                Rank_2: 40.0
+                Rank_3: 45.0
+                Rank_4: 50.0
+                Rank_5: 55.0
+                Rank_6: 60.0
+                Rank_7: 65.0
+                Rank_8: 70.0
+
+            # DebrisReduction_Rank: % of fewer non-ores received when Blast Mining
+            DebrisReduction:
+                Rank_1: 10.0
+                Rank_2: 20.0
+                Rank_3: 30.0
+                Rank_4: 30.0
+                Rank_5: 30.0
+                Rank_6: 30.0
+                Rank_7: 30.0
+                Rank_8: 30.0
+
+            # DropMultiplier Ranks: # of times each ore will drop
+            DropMultiplier:
+                Rank_1: 1
+                Rank_2: 1
+                Rank_3: 1
+                Rank_4: 1
+                Rank_5: 2
+                Rank_6: 2
+                Rank_7: 3
+                Rank_8: 3
+
+            # BlastRadiusModifier Ranks: Increases the blast radius by this amount
+            BlastRadiusModifier:
+                Rank_1: 1.0
+                Rank_2: 1.0
+                Rank_3: 2.0
+                Rank_4: 2.0
+                Rank_5: 3.0
+                Rank_6: 3.0
+                Rank_7: 4.0
+                Rank_8: 4.0
     #
     #  Settings for Repair
     ###
     Repair:
-        # RepairMastery_ChanceMax: Maximum bonus percentage for Repair Mastery
-        # RepairMastery_MaxBonusLevel: On this level, the maximum bonus is reached
-        RepairMastery_MaxBonusPercentage: 200.0
-        RepairMastery_MaxBonusLevel: 1000
-
-        # SuperRepair_ChanceMax: Maximum chance of Super Repair
-        # SuperRepair_MaxBonusLevel: On this level, Super Repair chance will be SuperRepair_ChanceMax
-        SuperRepair_ChanceMax: 100.0
-        SuperRepair_MaxBonusLevel: 1000
-
-        # Salvage_UnlockLevel: Level when Salvage become available
-        Salvage_UnlockLevel: 600
-
-        Arcane_Forging:
+        RepairMastery:
+            # ChanceMax: Maximum bonus percentage for Repair Mastery
+            # MaxBonusLevel: On this level, the maximum bonus is reached
+            MaxBonusPercentage: 200.0
+            MaxBonusLevel: 1000
+
+        SuperRepair:
+            # ChanceMax: Maximum chance of Super Repair
+            # MaxBonusLevel: On this level, Super Repair chance will be SuperRepair_ChanceMax
+            ChanceMax: 100.0
+            MaxBonusLevel: 1000
+
+        Salvage:
+            # UnlockLevel: Level when Salvage become available
+            UnlockLevel: 600
+
+        ArcaneForging:
             May_Lose_Enchants: true
             Rank_Levels:
                 Rank_1: 125
@@ -304,144 +334,165 @@ Skills:
     #  Settings for Smelting
     ###
     Smelting:
-        # FuelEfficiency_Multiplier: The furnace burn time will be multiplied by this value.
-        # FuelEfficiency_MaxBonusLevel: On this level, the efficiency multiplier will stop increasing
-        FuelEfficiency_Multiplier: 3.0
-        FuelEfficiency_MaxBonusLevel: 1000
-
-        # SecondSmelt_MaxBonusChance: Maximum chance of triggering Second Smelt
-        # SecondSmelt_MaxBonusLevel: On this level, the chance to cause Second Smelt will be SecondSmelt_MaxBonusChance
-        SecondSmelt_MaxBonusChance: 100.0
-        SecondSmelt_MaxBonusLevel: 1000
-
-        # FluxMining_UnlockLevel: Level when Flux Mining becomes available
-        # FluxMining_Chance: Chance for Flux Mining to activate
-        FluxMining_UnlockLevel: 250
-        FluxMining_Chance: 33.0
-
-        # These are the levels at which each progressive level of Vanilla XP Boost unlocks.
-        VanillaXPBoost:
-            Rank_Levels:
-                Rank_1: 125
-                Rank_2: 250
-                Rank_3: 375
-                Rank_4: 500
-                Rank_5: 625
-                Rank_6: 750
-                Rank_7: 875
-                Rank_8: 1000
-            XP_Multiplier:
-                Rank_1: 1
-                Rank_2: 2
-                Rank_3: 3
-                Rank_4: 3
-                Rank_5: 4
-                Rank_6: 4
-                Rank_7: 5
-                Rank_8: 5
+        FuelEfficiency:
+            # Multiplier: The furnace burn time will be multiplied by this value.
+            # MaxBonusLevel: On this level, the efficiency multiplier will stop increasing
+            Multiplier: 3.0
+            MaxBonusLevel: 1000
+
+        SecondSmelt:
+            # MaxBonusChance: Maximum chance of triggering Second Smelt
+            # MaxBonusLevel: On this level, the chance to cause Second Smelt will be SecondSmelt_MaxBonusChance
+            MaxBonusChance: 100.0
+            MaxBonusLevel: 1000
+
+        FluxMining:
+            # UnlockLevel: Level when Flux Mining becomes available
+            # Chance: Chance for Flux Mining to activate
+            UnlockLevel: 250
+            Chance: 33.0
+
+        # Rank_Levels: Smelting level where rank gets unlocked
+        Rank_Levels:
+            Rank_1: 125
+            Rank_2: 250
+            Rank_3: 375
+            Rank_4: 500
+            Rank_5: 625
+            Rank_6: 750
+            Rank_7: 875
+            Rank_8: 1000
+
+        # VanillaXPMultiplier: Vanilla XP gained from smelting ores is multiplied by these values.
+        VanillaXPMultiplier:
+            Rank_1: 1
+            Rank_2: 2
+            Rank_3: 3
+            Rank_4: 3
+            Rank_5: 4
+            Rank_6: 4
+            Rank_7: 5
+            Rank_8: 5
 
     #
     #  Settings for Swords
     ###
     Swords:
-        # Bleed_ChanceMax: Maximum chance of triggering bleeding
-        # Bleed_MaxBonusLevel: On this level, the chance to cause Bleeding will be Bleed_ChanceMax
-        Bleed_ChanceMax: 75.0
-        Bleed_MaxBonusLevel: 750
-        # These settings determine how long the Bleeding effect lasts
-        Bleed_MaxTicks: 3
-        Bleed_BaseTicks: 2
-
-        # Counter_RequiresBlock: Determines if blocking is required to trigger counter attack
-        Counter_RequiresBlock: true
-
-        # Counter_ChanceMax: Maximum chance of triggering a counter attack
-        # Counter_MaxBonusLevel: On this level, the chance to Counter will be Counter_ChanceMax
-        Counter_ChanceMax: 30.0
-        Counter_MaxBonusLevel: 600
-
-        # Counter_DamageModifier: Damaged caused by the damager will get divided by this modifier and dealt back to the damager
-        Counter_DamageModifier: 2.0
-
-        # SerratedStrikes_DamageModifier: Damage will get divided by this modifier
-        # SerratedStrikes_BleedTicks: This determines how long the bleeding effect of SerratedStrikes lasts
-        SerratedStrikes_DamageModifier: 4.0
-        SerratedStrikes_BleedTicks: 5
+        Bleed:
+            # ChanceMax: Maximum chance of triggering bleeding
+            # MaxBonusLevel: On this level, the chance to cause Bleeding will be Bleed_ChanceMax
+            ChanceMax: 75.0
+            MaxBonusLevel: 750
+
+            # These settings determine how long the Bleeding effect lasts
+            MaxTicks: 3
+            BaseTicks: 2
+
+        Counter:
+            # RequiresBlock: Determines if blocking is required to trigger counter attack
+            RequiresBlock: true
+
+            # ChanceMax: Maximum chance of triggering a counter attack
+            # MaxBonusLevel: On this level, the chance to Counter will be Counter_ChanceMax
+            ChanceMax: 30.0
+            MaxBonusLevel: 600
+
+            # DamageModifier: Damaged caused by the damager will get divided by this modifier and dealt back to the damager
+            DamageModifier: 2.0
+
+        SerratedStrikes:
+            # DamageModifier: Damage will get divided by this modifier
+            # BleedTicks: This determines how long the bleeding effect of SerratedStrikes lasts
+            DamageModifier: 4.0
+            BleedTicks: 5
     #
     #  Settings for Taming
     ###
     Taming:
-        # Gore_ChanceMax: Maximum chance of triggering gore
-        # Gore_MaxBonusLevel: On this level, the chance to cause Gore will be Gore_ChanceMax
-        Gore_ChanceMax: 100.0
-        Gore_MaxBonusLevel: 1000
-
-        # Gore_BleedTicks: Determines the length of the bleeding effect
-        # Gore_Modifier: Damage will get multiplied by this modifier
-        Gore_BleedTicks: 2
-        Gore_Modifier: 2.0
-
-        # FastFood_UnlockLevel: Level when FastFood unlocks
-        # FastFood_Chance: The chance for wolves to heal hp when inflicting damage
-        FastFood_UnlockLevel: 50
-        FastFood_Chance: 50.0
-
-        # EnvironmentallyAware_UnlockLevel: Level when EnvironmentallyAware unlocks
-        EnvironmentallyAware_UnlockLevel: 100
-
-        # ThickFur_UnlockLevel: Level when ThickFur unlocks
-        # ThickFur_Modifier: Damage will get divided by this modifier
-        ThickFur_UnlockLevel: 250
-        ThickFur_Modifier: 2.0
-
-        # HolyHound_UnlockLevel: Level when HolyHound unlocks
-        HolyHound_UnlockLevel: 375
-
-        # ShockProof_UnlockLevel: Level when ShockProof unlocks
-        # ShockProof_Modifier: Damage will get divided by this modifier
-        ShockProof_UnlockLevel: 500
-        ShockProof_Modifier: 6.0
-
-        # SharpenedClaws_UnlockLevel: Level when SharpenedClaws unlocks
-        # SharpenedClaws_Bonus: This bonus will get added to the damage caused
-        SharpenedClaws_UnlockLevel: 750
-        SharpenedClaws_Bonus: 2.0
+        Gore:
+            # ChanceMax: Maximum chance of triggering gore
+            # MaxBonusLevel: On this level, the chance to cause Gore will be Gore_ChanceMax
+            ChanceMax: 100.0
+            MaxBonusLevel: 1000
+
+            # BleedTicks: Determines the length of the bleeding effect
+            # Modifier: Damage will get multiplied by this modifier
+            BleedTicks: 2
+            Modifier: 2.0
+
+        FastFood:
+            # UnlockLevel: Level when FastFood unlocks
+            # Chance: The chance for wolves to heal hp when inflicting damage
+            UnlockLevel: 50
+            Chance: 50.0
+
+        EnvironmentallyAware:
+            # UnlockLevel: Level when EnvironmentallyAware unlocks
+            UnlockLevel: 100
+
+        ThickFur:
+            # UnlockLevel: Level when ThickFur unlocks
+            # Modifier: Damage will get divided by this modifier
+            UnlockLevel: 250
+            Modifier: 2.0
+
+        HolyHound:
+            # UnlockLevel: Level when HolyHound unlocks
+            UnlockLevel: 375
+
+        ShockProof:
+            # UnlockLevel: Level when ShockProof unlocks
+            # Modifier: Damage will get divided by this modifier
+            UnlockLevel: 500
+            Modifier: 6.0
+
+        SharpenedClaws:
+            # UnlockLevel: Level when SharpenedClaws unlocks
+            # Bonus: This bonus will get added to the damage caused
+            UnlockLevel: 750
+            Bonus: 2.0
     #
     #  Settings for Unarmed
     ###
     Unarmed:
-        # Disarm_ChanceMax: Maximum chance of disarming other players
-        # Disarm_MaxBonusLevel: Level when the maximum chance to disarm is reached
-        Disarm_ChanceMax: 33.0
-        Disarm_MaxBonusLevel: 1000
-
-        # Deflect_ChanceMax: Maximum chance of deflecting arrows
-        # Deflect_MaxBonusLevel: Level when the maximum chance to deflect is reached
-        Deflect_ChanceMax: 50.0
-        Deflect_MaxBonusLevel: 1000
-
-        # IronGrip_ChanceMax: Maximum chance of preventing being disarmed
-        # IronGrip_MaxBonusLevel: Level when the maximum chance to prevent being disarmed is reached
-        IronGrip_ChanceMax: 100.0
-        IronGrip_MaxBonusLevel: 1000
-
-        # IronArm_BonusMin: Minimum bonus damage for unarmed
-        # IronArm_BonusMax: Maximum bonus damage for unarmed
-        # IronArm_IncreaseLevel: Bonus damage increases every increase level
-        IronArm_BonusMin: 3.0
-        IronArm_BonusMax: 8.0
-        IronArm_IncreaseLevel: 50
+        Disarm:
+            # ChanceMax: Maximum chance of disarming other players
+            # MaxBonusLevel: Level when the maximum chance to disarm is reached
+            ChanceMax: 33.0
+            MaxBonusLevel: 1000
+
+        Deflect:
+            # ChanceMax: Maximum chance of deflecting arrows
+            # MaxBonusLevel: Level when the maximum chance to deflect is reached
+            ChanceMax: 50.0
+            MaxBonusLevel: 1000
+
+        IronGrip:
+            # ChanceMax: Maximum chance of preventing being disarmed
+            # MaxBonusLevel: Level when the maximum chance to prevent being disarmed is reached
+            ChanceMax: 100.0
+            MaxBonusLevel: 1000
+
+        IronArm:
+            # BonusMin: Minimum bonus damage for unarmed
+            # BonusMax: Maximum bonus damage for unarmed
+            # IncreaseLevel: Bonus damage increases every increase level
+            BonusMin: 3.0
+            BonusMax: 8.0
+            IncreaseLevel: 50
     #
     #  Settings for Woodcutting
     ###
     Woodcutting:
-        # LeafBlower_UnlockLevel: At this level, the passive ability LeafBlower unlocks
-        LeafBlower_UnlockLevel: 100
-
-        # DoubleDrops_ChanceMax: Maximum chance of receiving double drops
-        # DoubleDrops_MaxBonusLevel: Level when the maximum chance of receiving double drops is reached
-        DoubleDrops_ChanceMax: 100.0
-        DoubleDrops_MaxBonusLevel: 1000
+        LeafBlower:
+            # UnlockLevel: At this level, the passive ability LeafBlower unlocks
+            UnlockLevel: 100
+
+        DoubleDrops:
+            # ChanceMax: Maximum chance of receiving double drops
+            # MaxBonusLevel: Level when the maximum chance of receiving double drops is reached
+            ChanceMax: 100.0
+            MaxBonusLevel: 1000
 #
 #  Customize the kraken!
 ###