EpicKnarvik97/mcMMO
1
0
Fork 0
mirror of https://github.com/mcMMO-Dev/mcMMO.git synced 2025-07-01 21:24:43 +02:00
Code Issues Projects Releases Wiki Activity

Changed secondary abilities to use constants instead of enum

Browse Source
This commit is contained in:
ile123ile
2014-08-24 11:45:13 -07:00
parent 0700e4354c
commit edd764d5e6
41 changed files with 288 additions and 964 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
src/main/java/com/gmail/nossr50/commands/skills/AcrobaticsCommand.java
View File

@ -30,21 +30,21 @@ public class AcrobaticsCommand extends SkillCommand {
protected void dataCalculations(Player player, float skillValue, boolean isLucky) {
// DODGE
if (canDodge) {
String[] dodgeStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.DODGE, isLucky);
String[] dodgeStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.dodge, isLucky);
dodgeChance = dodgeStrings[0];
dodgeChanceLucky = dodgeStrings[1];
}
// ROLL
if (canRoll) {
String[] rollStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.ROLL, isLucky);
String[] rollStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.roll, isLucky);
rollChance = rollStrings[0];
rollChanceLucky = rollStrings[1];
}
// GRACEFUL ROLL
if (canGracefulRoll) {
String[] gracefulRollStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.GRACEFUL_ROLL, isLucky);
String[] gracefulRollStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.gracefullRoll, isLucky);
gracefulRollChance = gracefulRollStrings[0];
gracefulRollChanceLucky = gracefulRollStrings[1];
}
@ -52,9 +52,9 @@ public class AcrobaticsCommand extends SkillCommand {
@Override
protected void permissionsCheck(Player player) {
canDodge = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.DODGE);
canRoll = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.ROLL);
canGracefulRoll = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.GRACEFUL_ROLL);
canDodge = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.dodge);
canRoll = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.roll);
canGracefulRoll = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.gracefullRoll);
}
@Override

4
src/main/java/com/gmail/nossr50/commands/skills/AlchemyCommand.java
View File

@ -59,8 +59,8 @@ public class AlchemyCommand extends SkillCommand {
@Override
protected void permissionsCheck(Player player) {
canCatalysis = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.CATALYSIS);
canConcoctions = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.CONCOCTIONS);
canCatalysis = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.catalysis);
canConcoctions = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.concoctions);
}
@Override

10
src/main/java/com/gmail/nossr50/commands/skills/ArcheryCommand.java
View File

@ -36,14 +36,14 @@ public class ArcheryCommand extends SkillCommand {
// DAZE
if (canDaze) {
String[] dazeStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.DAZE, isLucky);
String[] dazeStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.daze, isLucky);
dazeChance = dazeStrings[0];
dazeChanceLucky = dazeStrings[1];
}
// RETRIEVE
if (canRetrieve) {
String[] retrieveStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.RETRIEVE, isLucky);
String[] retrieveStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.retrieve, isLucky);
retrieveChance = retrieveStrings[0];
retrieveChanceLucky = retrieveStrings[1];
}
@ -51,9 +51,9 @@ public class ArcheryCommand extends SkillCommand {
@Override
protected void permissionsCheck(Player player) {
canSkillShot = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.SKILL_SHOT);
canDaze = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.DAZE);
canRetrieve = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.RETRIEVE);
canSkillShot = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.skillShot);
canDaze = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.daze);
canRetrieve = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.retrieve);
}
@Override

10
src/main/java/com/gmail/nossr50/commands/skills/AxesCommand.java
View File

@ -45,7 +45,7 @@ public class AxesCommand extends SkillCommand {
// CRITICAL HIT
if (canCritical) {
String[] criticalHitStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.CRITICAL_HIT, isLucky);
String[] criticalHitStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.criticalHit, isLucky);
critChance = criticalHitStrings[0];
critChanceLucky = criticalHitStrings[1];
}
@ -59,10 +59,10 @@ public class AxesCommand extends SkillCommand {
@Override
protected void permissionsCheck(Player player) {
canSkullSplitter = Permissions.skullSplitter(player);
canCritical = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.CRITICAL_HIT);
canAxeMastery = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.AXE_MASTERY);
canImpact = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.ARMOR_IMPACT);
canGreaterImpact = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.GREATER_IMPACT);
canCritical = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.criticalHit);
canAxeMastery = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.axeMastery);
canImpact = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.armorImpact);
canGreaterImpact = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.greaterImpact);
}
@Override

2
src/main/java/com/gmail/nossr50/commands/skills/ExcavationCommand.java
View File

@ -34,7 +34,7 @@ public class ExcavationCommand extends SkillCommand {
@Override
protected void permissionsCheck(Player player) {
canGigaDrill = Permissions.gigaDrillBreaker(player);
canTreasureHunt = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.EXCAVATION_TREASURE_HUNTER);
canTreasureHunt = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.excavationTreasureHunter);
}
@Override

12
src/main/java/com/gmail/nossr50/commands/skills/FishingCommand.java
View File

@ -111,12 +111,12 @@ public class FishingCommand extends SkillCommand {
@Override
protected void permissionsCheck(Player player) {
canTreasureHunt = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.FISHING_TREASURE_HUNTER);
canMagicHunt = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.MAGIC_HUNTER);
canShake = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.SHAKE);
canFishermansDiet = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.FISHERMANS_DIET);
canMasterAngler = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.MASTER_ANGLER);
canIceFish = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.ICE_FISHING);
canTreasureHunt = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.fishingTreasureHunter);
canMagicHunt = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.magicHunter);
canShake = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.shake);
canFishermansDiet = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.fishermansDiet);
canMasterAngler = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.masterAngler);
canIceFish = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.iceFishing);
}
@Override

16
src/main/java/com/gmail/nossr50/commands/skills/HerbalismCommand.java
View File

@ -56,28 +56,28 @@ public class HerbalismCommand extends SkillCommand {
if (canGreenThumbBlocks || canGreenThumbPlants) {
greenThumbStage = calculateRank(skillValue, Herbalism.greenThumbStageMaxLevel, Herbalism.greenThumbStageChangeLevel);
String[] greenThumbStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.GREEN_THUMB_PLANT, isLucky);
String[] greenThumbStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.greenThumbPlant, isLucky);
greenThumbChance = greenThumbStrings[0];
greenThumbChanceLucky = greenThumbStrings[1];
}
// DOUBLE DROPS
if (canDoubleDrop) {
String[] doubleDropStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.HERBALISM_DOUBLE_DROPS, isLucky);
String[] doubleDropStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.herbalismDoubleDrops, isLucky);
doubleDropChance = doubleDropStrings[0];
doubleDropChanceLucky = doubleDropStrings[1];
}
// HYLIAN LUCK
if (hasHylianLuck) {
String[] hylianLuckStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.HYLIAN_LUCK, isLucky);
String[] hylianLuckStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.hylianLuck, isLucky);
hylianLuckChance = hylianLuckStrings[0];
hylianLuckChanceLucky = hylianLuckStrings[1];
}
// SHROOM THUMB
if (canShroomThumb) {
String[] shroomThumbStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.SHROOM_THUMB, isLucky);
String[] shroomThumbStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.shroomThumb, isLucky);
shroomThumbChance = shroomThumbStrings[0];
shroomThumbChanceLucky = shroomThumbStrings[1];
}
@ -85,13 +85,13 @@ public class HerbalismCommand extends SkillCommand {
@Override
protected void permissionsCheck(Player player) {
hasHylianLuck = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.HYLIAN_LUCK);
hasHylianLuck = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.hylianLuck);
canGreenTerra = Permissions.greenTerra(player);
canGreenThumbPlants = Permissions.greenThumbPlant(player, Material.CROPS) || Permissions.greenThumbPlant(player, Material.CARROT) || Permissions.greenThumbPlant(player, Material.POTATO) || Permissions.greenThumbPlant(player, Material.NETHER_WARTS) || Permissions.greenThumbPlant(player, Material.COCOA);
canGreenThumbBlocks = Permissions.greenThumbBlock(player, Material.DIRT) || Permissions.greenThumbBlock(player, Material.COBBLESTONE) || Permissions.greenThumbBlock(player, Material.COBBLE_WALL) || Permissions.greenThumbBlock(player, Material.SMOOTH_BRICK);
canFarmersDiet = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.FARMERS_DIET);
canDoubleDrop = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.HERBALISM_DOUBLE_DROPS) && !skill.getDoubleDropsDisabled();
canShroomThumb = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.SHROOM_THUMB);
canFarmersDiet = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.farmersDiet);
canDoubleDrop = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.herbalismDoubleDrops) && !skill.getDoubleDropsDisabled();
canShroomThumb = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.shroomThumb);
}
@Override

4
src/main/java/com/gmail/nossr50/commands/skills/MiningCommand.java
View File

@ -49,7 +49,7 @@ public class MiningCommand extends SkillCommand {
// DOUBLE DROPS
if (canDoubleDrop) {
String[] doubleDropStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.MINING_DOUBLE_DROPS, isLucky);
String[] doubleDropStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.miningDoubleDrops, isLucky);
doubleDropChance = doubleDropStrings[0];
doubleDropChanceLucky = doubleDropStrings[1];
}
@ -72,7 +72,7 @@ public class MiningCommand extends SkillCommand {
canBiggerBombs = Permissions.biggerBombs(player);
canBlast = Permissions.remoteDetonation(player);
canDemoExpert = Permissions.demolitionsExpertise(player);
canDoubleDrop = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.MINING_DOUBLE_DROPS) && !skill.getDoubleDropsDisabled();
canDoubleDrop = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.miningDoubleDrops) && !skill.getDoubleDropsDisabled();
canSuperBreaker = Permissions.superBreaker(player);
}

8
src/main/java/com/gmail/nossr50/commands/skills/RepairCommand.java
View File

@ -66,7 +66,7 @@ public class RepairCommand extends SkillCommand {
// SUPER REPAIR
if (canSuperRepair) {
String[] superRepairStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.SUPER_REPAIR, isLucky);
String[] superRepairStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.superRepair, isLucky);
superRepairChance = superRepairStrings[0];
superRepairChanceLucky = superRepairStrings[1];
}
@ -74,9 +74,9 @@ public class RepairCommand extends SkillCommand {
@Override
protected void permissionsCheck(Player player) {
canSuperRepair = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.SUPER_REPAIR);
canMasterRepair = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.REPAIR_MASTERY);
canArcaneForge = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.ARCANE_FORGING);
canSuperRepair = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.superRepair);
canMasterRepair = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.repairMastery);
canArcaneForge = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.arcaneForging);
canRepairDiamond = Permissions.repairMaterialType(player, MaterialType.DIAMOND);
canRepairGold = Permissions.repairMaterialType(player, MaterialType.GOLD);
canRepairIron = Permissions.repairMaterialType(player, MaterialType.IRON);

4
src/main/java/com/gmail/nossr50/commands/skills/SalvageCommand.java
View File

@ -29,8 +29,8 @@ public class SalvageCommand extends SkillCommand {
@Override
protected void permissionsCheck(Player player) {
canAdvancedSalvage = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.ADVANCED_SALVAGE);
canArcaneSalvage = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.ARCANE_SALVAGE);
canAdvancedSalvage = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.advancedSalvage);
canArcaneSalvage = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.arcaneSalvage);
}
@Override

8
src/main/java/com/gmail/nossr50/commands/skills/SmeltingCommand.java
View File

@ -39,7 +39,7 @@ public class SmeltingCommand extends SkillCommand {
// SECOND SMELT
if (canSecondSmelt) {
String[] secondSmeltStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.SECOND_SMELT, isLucky);
String[] secondSmeltStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.secondSmelt, isLucky);
secondSmeltChance = secondSmeltStrings[0];
secondSmeltChanceLucky = secondSmeltStrings[1];
}
@ -54,9 +54,9 @@ public class SmeltingCommand extends SkillCommand {
@Override
protected void permissionsCheck(Player player) {
canFuelEfficiency = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.FUEL_EFFICIENCY);
canSecondSmelt = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.SECOND_SMELT);
canFluxMine = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.FLUX_MINING);
canFuelEfficiency = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.fuelEfficiency);
canSecondSmelt = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.secondSmelt);
canFluxMine = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.fluxMining);
canVanillaXPBoost = Permissions.vanillaXpBoost(player, skill);
}

10
src/main/java/com/gmail/nossr50/commands/skills/SwordsCommand.java
View File

@ -40,16 +40,16 @@ public class SwordsCommand extends SkillCommand {
// BLEED
if (canBleed) {
bleedLength = (skillValue >= AdvancedConfig.getInstance().getMaxBonusLevel(SecondaryAbility.BLEED)) ? Swords.bleedMaxTicks : Swords.bleedBaseTicks;
bleedLength = (skillValue >= AdvancedConfig.getInstance().getMaxBonusLevel(SecondaryAbility.bleed)) ? Swords.bleedMaxTicks : Swords.bleedBaseTicks;
String[] bleedStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.BLEED, isLucky);
String[] bleedStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.bleed, isLucky);
bleedChance = bleedStrings[0];
bleedChanceLucky = bleedStrings[1];
}
// COUNTER
if (canCounter) {
String[] counterStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.COUNTER, isLucky);
String[] counterStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.counter, isLucky);
counterChance = counterStrings[0];
counterChanceLucky = counterStrings[1];
}
@ -57,8 +57,8 @@ public class SwordsCommand extends SkillCommand {
@Override
protected void permissionsCheck(Player player) {
canBleed = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.BLEED);
canCounter = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.COUNTER);
canBleed = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.bleed);
canCounter = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.counter);
canSerratedStrike = Permissions.serratedStrikes(player);
}

18
src/main/java/com/gmail/nossr50/commands/skills/TamingCommand.java
View File

@ -34,7 +34,7 @@ public class TamingCommand extends SkillCommand {
@Override
protected void dataCalculations(Player player, float skillValue, boolean isLucky) {
if (canGore) {
String[] goreStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.GORE, isLucky);
String[] goreStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.gore, isLucky);
goreChance = goreStrings[0];
goreChanceLucky = goreStrings[1];
}
@ -42,15 +42,15 @@ public class TamingCommand extends SkillCommand {
@Override
protected void permissionsCheck(Player player) {
canBeastLore = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.BEAST_LORE);
canBeastLore = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.beastLore);
canCallWild = Permissions.callOfTheWild(player, EntityType.HORSE) || Permissions.callOfTheWild(player, EntityType.WOLF) || Permissions.callOfTheWild(player, EntityType.OCELOT);
canEnvironmentallyAware = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.ENVIROMENTALLY_AWARE);
canFastFood = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.FAST_FOOD);
canGore = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.GORE);
canSharpenedClaws = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.SHARPENED_CLAWS);
canShockProof = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.SHOCK_PROOF);
canThickFur = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.THICK_FUR);
canHolyHound = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.HOLY_HOUND);
canEnvironmentallyAware = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.enviromentallyAware);
canFastFood = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.fastFood);
canGore = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.gore);
canSharpenedClaws = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.sharpenedClaws);
canShockProof = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.shockProof);
canThickFur = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.thickFur);
canHolyHound = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.holyHound);
}
@Override

14
src/main/java/com/gmail/nossr50/commands/skills/UnarmedCommand.java
View File

@ -43,14 +43,14 @@ public class UnarmedCommand extends SkillCommand {
// DISARM
if (canDisarm) {
String[] disarmStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.DISARM, isLucky);
String[] disarmStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.disarm, isLucky);
disarmChance = disarmStrings[0];
disarmChanceLucky = disarmStrings[1];
}
// DEFLECT
if (canDeflect) {
String[] deflectStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.DEFLECT, isLucky);
String[] deflectStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.deflect, isLucky);
deflectChance = deflectStrings[0];
deflectChanceLucky = deflectStrings[1];
}
@ -62,7 +62,7 @@ public class UnarmedCommand extends SkillCommand {
// IRON GRIP
if (canIronGrip) {
String[] ironGripStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.IRON_GRIP, isLucky);
String[] ironGripStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.ironGrip, isLucky);
ironGripChance = ironGripStrings[0];
ironGripChanceLucky = ironGripStrings[1];
}
@ -71,10 +71,10 @@ public class UnarmedCommand extends SkillCommand {
@Override
protected void permissionsCheck(Player player) {
canBerserk = Permissions.berserk(player);
canIronArm = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.IRON_ARM);
canDeflect = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.DEFLECT);
canDisarm = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.DISARM);
canIronGrip = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.IRON_GRIP);
canIronArm = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.ironArm);
canDeflect = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.deflect);
canDisarm = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.disarm);
canIronGrip = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.ironGrip);
// TODO: Apparently we forgot about block cracker?
}

6
src/main/java/com/gmail/nossr50/commands/skills/WoodcuttingCommand.java
View File

@ -36,7 +36,7 @@ public class WoodcuttingCommand extends SkillCommand {
// DOUBLE DROPS
if (canDoubleDrop) {
String[] doubleDropStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.WOODCUTTING_DOUBLE_DROPS, isLucky);
String[] doubleDropStrings = calculateAbilityDisplayValues(skillValue, SecondaryAbility.woodcuttingDoubleDrops, isLucky);
doubleDropChance = doubleDropStrings[0];
doubleDropChanceLucky = doubleDropStrings[1];
}
@ -45,8 +45,8 @@ public class WoodcuttingCommand extends SkillCommand {
@Override
protected void permissionsCheck(Player player) {
canTreeFell = Permissions.treeFeller(player);
canDoubleDrop = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.WOODCUTTING_DOUBLE_DROPS) && !skill.getDoubleDropsDisabled();
canLeafBlow = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.LEAF_BLOWER);
canDoubleDrop = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.woodcuttingDoubleDrops) && !skill.getDoubleDropsDisabled();
canLeafBlow = Permissions.secondaryAbilityEnabled(player, SecondaryAbility.leafBlower);
}
@Override

80
src/main/java/com/gmail/nossr50/config/AdvancedConfig.java
View File

@ -46,11 +46,11 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
}
/* ACROBATICS */
if (getMaxChance(SecondaryAbility.DODGE) < 1) {
if (getMaxChance(SecondaryAbility.dodge) < 1) {
reason.add("Skills.Acrobatics.Dodge.ChanceMax should be at least 1!");
}
if (getMaxBonusLevel(SecondaryAbility.DODGE) < 1) {
if (getMaxBonusLevel(SecondaryAbility.dodge) < 1) {
reason.add("Skills.Acrobatics.Dodge.MaxBonusLevel should be at least 1!");
}
@ -58,11 +58,11 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
reason.add("Skills.Acrobatics.Dodge.DamageModifier should be greater than 1!");
}
if (getMaxChance(SecondaryAbility.ROLL) < 1) {
if (getMaxChance(SecondaryAbility.roll) < 1) {
reason.add("Skills.Acrobatics.Roll.ChanceMax should be at least 1!");
}
if (getMaxBonusLevel(SecondaryAbility.ROLL) < 1) {
if (getMaxBonusLevel(SecondaryAbility.roll) < 1) {
reason.add("Skills.Acrobatics.Roll.MaxBonusLevel should be at least 1!");
}
@ -70,11 +70,11 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
reason.add("Skills.Acrobatics.Roll.DamageThreshold should be at least 0!");
}
if (getMaxChance(SecondaryAbility.GRACEFUL_ROLL) < 1) {
if (getMaxChance(SecondaryAbility.gracefullRoll) < 1) {
reason.add("Skills.Acrobatics.GracefulRoll.ChanceMax should be at least 1!");
}
if (getMaxBonusLevel(SecondaryAbility.GRACEFUL_ROLL) < 1) {
if (getMaxBonusLevel(SecondaryAbility.gracefullRoll) < 1) {
reason.add("Skills.Acrobatics.GracefulRoll.MaxBonusLevel should be at least 1!");
}
@ -127,11 +127,11 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
reason.add("Skills.Archery.SkillShot.MaxBonus should be at least 0!");
}
if (getMaxChance(SecondaryAbility.DAZE) < 1) {
if (getMaxChance(SecondaryAbility.daze) < 1) {
reason.add("Skills.Acrobatics.Daze.ChanceMax should be at least 1!");
}
if (getMaxBonusLevel(SecondaryAbility.DAZE) < 1) {
if (getMaxBonusLevel(SecondaryAbility.daze) < 1) {
reason.add("Skills.Acrobatics.Daze.MaxBonusLevel should be at least 1!");
}
@ -139,11 +139,11 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
reason.add("Skills.Acrobatics.Daze.BonusDamage should be at least 0!");
}
if (getMaxChance(SecondaryAbility.RETRIEVE) < 1) {
if (getMaxChance(SecondaryAbility.retrieve) < 1) {
reason.add("Skills.Acrobatics.Retrieve.ChanceMax should be at least 1!");
}
if (getMaxBonusLevel(SecondaryAbility.RETRIEVE) < 1) {
if (getMaxBonusLevel(SecondaryAbility.retrieve) < 1) {
reason.add("Skills.Acrobatics.Retrieve.MaxBonusLevel should be at least 1!");
}
@ -160,11 +160,11 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
reason.add("Skills.Axes.AxeMastery.MaxBonusLevel should be at least 1!");
}
if (getMaxChance(SecondaryAbility.CRITICAL_HIT) < 1) {
if (getMaxChance(SecondaryAbility.criticalHit) < 1) {
reason.add("Skills.Axes.CriticalHit.ChanceMax should be at least 1!");
}
if (getMaxBonusLevel(SecondaryAbility.CRITICAL_HIT) < 1) {
if (getMaxBonusLevel(SecondaryAbility.criticalHit) < 1) {
reason.add("Skills.Axes.CriticalHit.MaxBonusLevel should be at least 1!");
}
@ -266,44 +266,44 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
reason.add("Skills.Herbalism.GreenThumb.StageChange should be at least 1!");
}
if (getMaxChance(SecondaryAbility.GREEN_THUMB_PLANT) < 1) {
if (getMaxChance(SecondaryAbility.greenThumbPlant) < 1) {
reason.add("Skills.Herbalism.GreenThumb.ChanceMax should be at least 1!");
}
if (getMaxBonusLevel(SecondaryAbility.GREEN_THUMB_PLANT) < 1) {
if (getMaxBonusLevel(SecondaryAbility.greenThumbPlant) < 1) {
reason.add("Skills.Herbalism.GreenThumb.MaxBonusLevel should be at least 1!");
}
if (getMaxChance(SecondaryAbility.HERBALISM_DOUBLE_DROPS) < 1) {
if (getMaxChance(SecondaryAbility.herbalismDoubleDrops) < 1) {
reason.add("Skills.Herbalism.DoubleDrops.ChanceMax should be at least 1!");
}
if (getMaxBonusLevel(SecondaryAbility.HERBALISM_DOUBLE_DROPS) < 1) {
if (getMaxBonusLevel(SecondaryAbility.herbalismDoubleDrops) < 1) {
reason.add("Skills.Herbalism.DoubleDrops.MaxBonusLevel should be at least 1!");
}
if (getMaxChance(SecondaryAbility.HYLIAN_LUCK) < 1) {
if (getMaxChance(SecondaryAbility.hylianLuck) < 1) {
reason.add("Skills.Herbalism.HylianLuck.ChanceMax should be at least 1!");
}
if (getMaxBonusLevel(SecondaryAbility.HYLIAN_LUCK) < 1) {
if (getMaxBonusLevel(SecondaryAbility.hylianLuck) < 1) {
reason.add("Skills.Herbalism.HylianLuck.MaxBonusLevel should be at least 1!");
}
if (getMaxChance(SecondaryAbility.SHROOM_THUMB) < 1) {
if (getMaxChance(SecondaryAbility.shroomThumb) < 1) {
reason.add("Skills.Herbalism.ShroomThumb.ChanceMax should be at least 1!");
}
if (getMaxBonusLevel(SecondaryAbility.SHROOM_THUMB) < 1) {
if (getMaxBonusLevel(SecondaryAbility.shroomThumb) < 1) {
reason.add("Skills.Herbalism.ShroomThumb.MaxBonusLevel should be at least 1!");
}
/* MINING */
if (getMaxChance(SecondaryAbility.MINING_DOUBLE_DROPS) < 1) {
if (getMaxChance(SecondaryAbility.miningDoubleDrops) < 1) {
reason.add("Skills.Mining.DoubleDrops.ChanceMax should be at least 1!");
}
if (getMaxBonusLevel(SecondaryAbility.MINING_DOUBLE_DROPS) < 1) {
if (getMaxBonusLevel(SecondaryAbility.miningDoubleDrops) < 1) {
reason.add("Skills.Mining.DoubleDrops.MaxBonusLevel should be at least 1!");
}
@ -372,11 +372,11 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
reason.add("Skills.Repair.RepairMastery.MaxBonusLevel should be at least 1!");
}
if (getMaxChance(SecondaryAbility.SUPER_REPAIR) < 1) {
if (getMaxChance(SecondaryAbility.superRepair) < 1) {
reason.add("Skills.Repair.SuperRepair.ChanceMax should be at least 1!");
}
if (getMaxBonusLevel(SecondaryAbility.SUPER_REPAIR) < 1) {
if (getMaxBonusLevel(SecondaryAbility.superRepair) < 1) {
reason.add("Skills.Repair.SuperRepair.MaxBonusLevel should be at least 1!");
}
@ -466,11 +466,11 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
reason.add("Skills.Smelting.FuelEfficiency.Multiplier should be at least 1!");
}
if (getMaxBonusLevel(SecondaryAbility.SECOND_SMELT) < 1) {
if (getMaxBonusLevel(SecondaryAbility.secondSmelt) < 1) {
reason.add("Skills.Smelting.SecondSmelt.MaxBonusLevel should be at least 1!");
}
if (getMaxChance(SecondaryAbility.SECOND_SMELT) < 1) {
if (getMaxChance(SecondaryAbility.secondSmelt) < 1) {
reason.add("Skills.Smelting.SecondSmelt.ChanceMax should be at least 1!");
}
@ -507,11 +507,11 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
}
/* SWORDS */
if (getMaxChance(SecondaryAbility.BLEED) < 1) {
if (getMaxChance(SecondaryAbility.bleed) < 1) {
reason.add("Skills.Swords.Bleed.ChanceMax should be at least 1!");
}
if (getMaxBonusLevel(SecondaryAbility.BLEED) < 1) {
if (getMaxBonusLevel(SecondaryAbility.bleed) < 1) {
reason.add("Skills.Swords.Bleed.MaxBonusLevel should be at least 1!");
}
@ -527,11 +527,11 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
reason.add("Skills.Swords.Bleed.BaseTicks should be at least 1!");
}
if (getMaxChance(SecondaryAbility.COUNTER) < 1) {
if (getMaxChance(SecondaryAbility.counter) < 1) {
reason.add("Skills.Swords.Counter.ChanceMax should be at least 1!");
}
if (getMaxBonusLevel(SecondaryAbility.COUNTER) < 1) {
if (getMaxBonusLevel(SecondaryAbility.counter) < 1) {
reason.add("Skills.Swords.Counter.MaxBonusLevel should be at least 1!");
}
@ -549,11 +549,11 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
/* TAMING */
if (getMaxChance(SecondaryAbility.GORE) < 1) {
if (getMaxChance(SecondaryAbility.gore) < 1) {
reason.add("Skills.Taming.Gore.ChanceMax should be at least 1!");
}
if (getMaxBonusLevel(SecondaryAbility.GORE) < 1) {
if (getMaxBonusLevel(SecondaryAbility.gore) < 1) {
reason.add("Skills.Taming.Gore.MaxBonusLevel should be at least 1!");
}
@ -610,27 +610,27 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
}
/* UNARMED */
if (getMaxChance(SecondaryAbility.DISARM) < 1) {
if (getMaxChance(SecondaryAbility.disarm) < 1) {
reason.add("Skills.Unarmed.Disarm.ChanceMax should be at least 1!");
}
if (getMaxBonusLevel(SecondaryAbility.DISARM) < 1) {
if (getMaxBonusLevel(SecondaryAbility.disarm) < 1) {
reason.add("Skills.Unarmed.Disarm.MaxBonusLevel should be at least 1!");
}
if (getMaxChance(SecondaryAbility.DEFLECT) < 1) {
if (getMaxChance(SecondaryAbility.deflect) < 1) {
reason.add("Skills.Unarmed.Deflect.ChanceMax should be at least 1!");
}
if (getMaxBonusLevel(SecondaryAbility.DEFLECT) < 1) {
if (getMaxBonusLevel(SecondaryAbility.deflect) < 1) {
reason.add("Skills.Unarmed.Deflect.MaxBonusLevel should be at least 1!");
}
if (getMaxChance(SecondaryAbility.IRON_GRIP) < 1) {
if (getMaxChance(SecondaryAbility.ironGrip) < 1) {
reason.add("Skills.Unarmed.IronGrip.ChanceMax should be at least 1!");
}
if (getMaxBonusLevel(SecondaryAbility.IRON_GRIP) < 1) {
if (getMaxBonusLevel(SecondaryAbility.ironGrip) < 1) {
reason.add("Skills.Unarmed.IronGrip.MaxBonusLevel should be at least 1!");
}
@ -655,11 +655,11 @@ public class AdvancedConfig extends AutoUpdateConfigLoader {
reason.add("Skills.Woodcutting.LeafBlower.UnlockLevel should be at least 0!");
}
if (getMaxChance(SecondaryAbility.WOODCUTTING_DOUBLE_DROPS) < 1) {
if (getMaxChance(SecondaryAbility.woodcuttingDoubleDrops) < 1) {
reason.add("Skills.Woodcutting.DoubleDrops.ChanceMax should be at least 1!");
}
if (getMaxBonusLevel(SecondaryAbility.WOODCUTTING_DOUBLE_DROPS) < 1) {
if (getMaxBonusLevel(SecondaryAbility.woodcuttingDoubleDrops) < 1) {
reason.add("Skills.Woodcutting.DoubleDrops.MaxBonusLevel should be at least 1!");
}

125
src/main/java/com/gmail/nossr50/datatypes/skills/SecondaryAbility.java
View File

@ -1,85 +1,100 @@
package com.gmail.nossr50.datatypes.skills;
public enum SecondaryAbility {
/* ACROBATICS */
DODGE,
GRACEFUL_ROLL,
ROLL,
public class SecondaryAbility {
/* ACROBATICS */
public static final SecondaryAbility dodge = new SecondaryAbility("DODGE");
public static final SecondaryAbility gracefullRoll = new SecondaryAbility("GRACEFUL_ROLL");
public static final SecondaryAbility roll = new SecondaryAbility("ROLL");
/* ALCHEMY */
CATALYSIS,
CONCOCTIONS,
public static final SecondaryAbility catalysis = new SecondaryAbility("CATALYSIS");
public static final SecondaryAbility concoctions = new SecondaryAbility("CONCOCTIONS");
/* ARCHERY */
DAZE,
RETRIEVE,
SKILL_SHOT,
public static final SecondaryAbility daze = new SecondaryAbility("DAZE");
public static final SecondaryAbility retrieve = new SecondaryAbility("RETRIEVE");
public static final SecondaryAbility skillShot = new SecondaryAbility("SKILL_SHOT");
/* Axes */
ARMOR_IMPACT,
AXE_MASTERY,
CRITICAL_HIT,
GREATER_IMPACT,
public static final SecondaryAbility armorImpact = new SecondaryAbility("ARMOR_IMPACT");
public static final SecondaryAbility axeMastery = new SecondaryAbility("AXE_MASTERY");
public static final SecondaryAbility criticalHit = new SecondaryAbility("CRITICAL_HIT");
public static final SecondaryAbility greaterImpact = new SecondaryAbility("GREATER_IMPACT");
/* Excavation */
EXCAVATION_TREASURE_HUNTER,
public static final SecondaryAbility excavationTreasureHunter = new SecondaryAbility("TREASURE_HUNTER");
/* Fishing */
FISHERMANS_DIET,
FISHING_TREASURE_HUNTER,
ICE_FISHING,
MAGIC_HUNTER,
MASTER_ANGLER,
SHAKE,
public static final SecondaryAbility fishermansDiet = new SecondaryAbility("FISHERMANS_DIET");
public static final SecondaryAbility fishingTreasureHunter = new SecondaryAbility("TREASURE_HUNTER");
public static final SecondaryAbility iceFishing = new SecondaryAbility("ICE_FISHING");
public static final SecondaryAbility magicHunter = new SecondaryAbility("MAGIC_HUNTER");
public static final SecondaryAbility masterAngler = new SecondaryAbility("MASTER_ANGLER");
public static final SecondaryAbility shake = new SecondaryAbility("SHAKE");
/* Herbalism */
FARMERS_DIET,
GREEN_THUMB_PLANT,
GREEN_THUMB_BLOCK,
HERBALISM_DOUBLE_DROPS,
HYLIAN_LUCK,
SHROOM_THUMB,
public static final SecondaryAbility farmersDiet = new SecondaryAbility("FARMERS_DIET");
public static final SecondaryAbility greenThumbPlant = new SecondaryAbility("GREEN_THUMB");
public static final SecondaryAbility greenThumbBlock = new SecondaryAbility("GREEN_THUMB");
public static final SecondaryAbility herbalismDoubleDrops = new SecondaryAbility("DOUBLE_DROPS");
public static final SecondaryAbility hylianLuck = new SecondaryAbility("HYLIAN_LUCK");
public static final SecondaryAbility shroomThumb = new SecondaryAbility("SHROOM_THUMB");
/* Mining */
MINING_DOUBLE_DROPS,
/* Mining */
public static final SecondaryAbility miningDoubleDrops = new SecondaryAbility("DOUBLE_DROPS");
/* Repair */
ARCANE_FORGING,
REPAIR_MASTERY,
SUPER_REPAIR,
public static final SecondaryAbility arcaneForging = new SecondaryAbility("ARCANE_FORGING");
public static final SecondaryAbility repairMastery = new SecondaryAbility("REPAIR_MASTERY");
public static final SecondaryAbility superRepair = new SecondaryAbility("SUPER_REPAIR");
/* Salvage */
ADVANCED_SALVAGE,
ARCANE_SALVAGE,
public static final SecondaryAbility advancedSalvage = new SecondaryAbility("ADVANCED_SALVAGE");
public static final SecondaryAbility arcaneSalvage = new SecondaryAbility("ARCANE_SALVAGE");
/* Smelting */
FLUX_MINING,
FUEL_EFFICIENCY,
SECOND_SMELT,
public static final SecondaryAbility fluxMining = new SecondaryAbility("FLUX_MINING");
public static final SecondaryAbility fuelEfficiency = new SecondaryAbility("FUEL_EFFICIENCY");
public static final SecondaryAbility secondSmelt = new SecondaryAbility("SECOND_SMELT");
/* Swords */
BLEED,
COUNTER,
public static final SecondaryAbility bleed = new SecondaryAbility("BLEED");
public static final SecondaryAbility counter = new SecondaryAbility("COUNTER");
/* Taming */
BEAST_LORE,
CALL_OF_THE_WILD,
ENVIROMENTALLY_AWARE,
FAST_FOOD,
GORE,
HOLY_HOUND,
SHARPENED_CLAWS,
SHOCK_PROOF,
THICK_FUR,
public static final SecondaryAbility beastLore = new SecondaryAbility("BEAST_LORE");
public static final SecondaryAbility callOfTheWild = new SecondaryAbility("CALL_OF_THE_WILD");
public static final SecondaryAbility enviromentallyAware = new SecondaryAbility("ENVIROMENTALLY_AWARE");
public static final SecondaryAbility fastFood = new SecondaryAbility("FAST_FOOD");
public static final SecondaryAbility gore = new SecondaryAbility("GORE");
public static final SecondaryAbility holyHound = new SecondaryAbility("HOLY_HOUND");
public static final SecondaryAbility sharpenedClaws = new SecondaryAbility("SHARPENED_CLAWS");
public static final SecondaryAbility shockProof = new SecondaryAbility("SHOCK_PROOF");
public static final SecondaryAbility thickFur = new SecondaryAbility("THICK_FUR");
/* Unarmed */
BLOCK_CRACKER,
DEFLECT,
DISARM,
IRON_ARM,
IRON_GRIP,
public static final SecondaryAbility blockCracker = new SecondaryAbility("BLOCK_CRACKER");
public static final SecondaryAbility deflect = new SecondaryAbility("DEFLECT");
public static final SecondaryAbility disarm = new SecondaryAbility("DISARM");
public static final SecondaryAbility ironArm = new SecondaryAbility("IRON_ARM");
public static final SecondaryAbility ironGrip = new SecondaryAbility("IRON_GRIP");
/* Woodcutting */
LEAF_BLOWER,
WOODCUTTING_DOUBLE_DROPS;
public static final SecondaryAbility leafBlower = new SecondaryAbility("LEAF_BLOWER");
public static final SecondaryAbility woodcuttingDoubleDrops = new SecondaryAbility("DOUBLE_DROPS");
private String name;
private SecondaryAbility(String name) {
this.name = name;
}
public String getName() {
return name;
}
@Override
public String toString() {
return getName();
}
}

30
src/main/java/com/gmail/nossr50/datatypes/skills/SkillType.java
View File

@ -68,21 +68,21 @@ public class SkillType {
private static List<SkillType> miscSkills = new ArrayList<SkillType>();
public static final SkillType acrobatics = createSkill("ACROBATICS" , AcrobaticsManager.class , AcrobaticsCommand.class , false, Color.WHITE, SkillUseType.MISC, ImmutableList.of(SecondaryAbility.DODGE, SecondaryAbility.GRACEFUL_ROLL, SecondaryAbility.ROLL));
public static final SkillType alchemy = createSkill("ALCHEMY" , AlchemyManager.class , AlchemyCommand.class , false, Color.FUCHSIA, SkillUseType.MISC, ImmutableList.of(SecondaryAbility.CATALYSIS, SecondaryAbility.CONCOCTIONS));
public static final SkillType archery = createSkill("ARCHERY" , ArcheryManager.class , ArcheryCommand.class , false, Color.MAROON, SkillUseType.COMBAT, ImmutableList.of(SecondaryAbility.DAZE, SecondaryAbility.RETRIEVE, SecondaryAbility.SKILL_SHOT));
public static final SkillType axes = createSkill("AXES" , AxesManager.class , AxesCommand.class , false, Color.AQUA, SkillUseType.COMBAT, AbilityType.skullSplitter, ToolType.AXE, ImmutableList.of(SecondaryAbility.ARMOR_IMPACT, SecondaryAbility.AXE_MASTERY, SecondaryAbility.CRITICAL_HIT, SecondaryAbility.GREATER_IMPACT));
public static final SkillType excavation = createSkill("EXCAVATION" , ExcavationManager.class , ExcavationCommand.class , false, Color.fromRGB(139, 69, 19), SkillUseType.GATHERING, AbilityType.gigaDrillBreaker, ToolType.SHOVEL, ImmutableList.of(SecondaryAbility.EXCAVATION_TREASURE_HUNTER));
public static final SkillType fishing = createSkill("FISHING" , FishingManager.class , FishingCommand.class , false, Color.NAVY, SkillUseType.GATHERING, ImmutableList.of(SecondaryAbility.FISHERMANS_DIET, SecondaryAbility.FISHING_TREASURE_HUNTER, SecondaryAbility.ICE_FISHING, SecondaryAbility.MAGIC_HUNTER, SecondaryAbility.MASTER_ANGLER, SecondaryAbility.SHAKE));
public static final SkillType herbalism = createSkill("HERBALISM" , HerbalismManager.class , HerbalismCommand.class , false, Color.GREEN, SkillUseType.GATHERING, AbilityType.greenTerra, ToolType.HOE, ImmutableList.of(SecondaryAbility.FARMERS_DIET, SecondaryAbility.GREEN_THUMB_PLANT, SecondaryAbility.GREEN_THUMB_BLOCK, SecondaryAbility.HERBALISM_DOUBLE_DROPS, SecondaryAbility.HYLIAN_LUCK, SecondaryAbility.SHROOM_THUMB));
public static final SkillType mining = createSkill("MINING" , MiningManager.class , MiningCommand.class , false, Color.GRAY, SkillUseType.GATHERING, AbilityType.superBreaker, ToolType.PICKAXE, ImmutableList.of(SecondaryAbility.MINING_DOUBLE_DROPS));
public static final SkillType repair = createSkill("REPAIR" , RepairManager.class , RepairCommand.class , false, Color.SILVER, SkillUseType.MISC, ImmutableList.of(SecondaryAbility.ARCANE_FORGING, SecondaryAbility.REPAIR_MASTERY, SecondaryAbility.SUPER_REPAIR));
public static final SkillType salvage = createSkill("SALVAGE" , SalvageManager.class , SalvageCommand.class , true, Color.ORANGE, SkillUseType.MISC, ImmutableList.of(SecondaryAbility.ADVANCED_SALVAGE, SecondaryAbility.ARCANE_SALVAGE));
public static final SkillType smelting = createSkill("SMELTING" , SmeltingManager.class , SmeltingCommand.class , true, Color.YELLOW, SkillUseType.MISC, ImmutableList.of(SecondaryAbility.FLUX_MINING, SecondaryAbility.FUEL_EFFICIENCY, SecondaryAbility.SECOND_SMELT));
public static final SkillType swords = createSkill("SWORDS" , SwordsManager.class , SwordsCommand.class , false, Color.fromRGB(178, 34, 34), SkillUseType.COMBAT, AbilityType.serratedStrikes, ToolType.SWORD, ImmutableList.of(SecondaryAbility.BLEED, SecondaryAbility.COUNTER));
public static final SkillType taming = createSkill("TAMING" , TamingManager.class , TamingCommand.class , false, Color.PURPLE, SkillUseType.COMBAT, ImmutableList.of(SecondaryAbility.BEAST_LORE, SecondaryAbility.CALL_OF_THE_WILD, SecondaryAbility.ENVIROMENTALLY_AWARE, SecondaryAbility.FAST_FOOD, SecondaryAbility.GORE, SecondaryAbility.HOLY_HOUND, SecondaryAbility.SHARPENED_CLAWS, SecondaryAbility.SHOCK_PROOF, SecondaryAbility.THICK_FUR));
public static final SkillType unarmed = createSkill("UNARMED" , UnarmedManager.class , UnarmedCommand.class , false, Color.BLACK, SkillUseType.COMBAT, AbilityType.berserk, ToolType.FISTS, ImmutableList.of(SecondaryAbility.BLOCK_CRACKER, SecondaryAbility.DEFLECT, SecondaryAbility.DISARM, SecondaryAbility.IRON_ARM, SecondaryAbility.IRON_GRIP));
public static final SkillType woodcutting = createSkill("WOODCUTTING", WoodcuttingManager.class , WoodcuttingCommand.class , false, Color.OLIVE, SkillUseType.GATHERING, AbilityType.treeFeller, ToolType.AXE, ImmutableList.of(SecondaryAbility.LEAF_BLOWER, SecondaryAbility.WOODCUTTING_DOUBLE_DROPS));
public static final SkillType acrobatics = createSkill("ACROBATICS" , AcrobaticsManager.class , AcrobaticsCommand.class , false, Color.WHITE, SkillUseType.MISC, ImmutableList.of(SecondaryAbility.dodge, SecondaryAbility.gracefullRoll, SecondaryAbility.roll));
public static final SkillType alchemy = createSkill("ALCHEMY" , AlchemyManager.class , AlchemyCommand.class , false, Color.FUCHSIA, SkillUseType.MISC, ImmutableList.of(SecondaryAbility.catalysis, SecondaryAbility.concoctions));
public static final SkillType archery = createSkill("ARCHERY" , ArcheryManager.class , ArcheryCommand.class , false, Color.MAROON, SkillUseType.COMBAT, ImmutableList.of(SecondaryAbility.daze, SecondaryAbility.retrieve, SecondaryAbility.skillShot));
public static final SkillType axes = createSkill("AXES" , AxesManager.class , AxesCommand.class , false, Color.AQUA, SkillUseType.COMBAT, AbilityType.skullSplitter, ToolType.AXE, ImmutableList.of(SecondaryAbility.armorImpact, SecondaryAbility.axeMastery, SecondaryAbility.criticalHit, SecondaryAbility.greaterImpact));
public static final SkillType excavation = createSkill("EXCAVATION" , ExcavationManager.class , ExcavationCommand.class , false, Color.fromRGB(139, 69, 19), SkillUseType.GATHERING, AbilityType.gigaDrillBreaker, ToolType.SHOVEL, ImmutableList.of(SecondaryAbility.excavationTreasureHunter));
public static final SkillType fishing = createSkill("FISHING" , FishingManager.class , FishingCommand.class , false, Color.NAVY, SkillUseType.GATHERING, ImmutableList.of(SecondaryAbility.fishermansDiet, SecondaryAbility.fishingTreasureHunter, SecondaryAbility.iceFishing, SecondaryAbility.magicHunter, SecondaryAbility.masterAngler, SecondaryAbility.shake));
public static final SkillType herbalism = createSkill("HERBALISM" , HerbalismManager.class , HerbalismCommand.class , false, Color.GREEN, SkillUseType.GATHERING, AbilityType.greenTerra, ToolType.HOE, ImmutableList.of(SecondaryAbility.farmersDiet, SecondaryAbility.greenThumbPlant, SecondaryAbility.greenThumbBlock, SecondaryAbility.herbalismDoubleDrops, SecondaryAbility.hylianLuck, SecondaryAbility.shroomThumb));
public static final SkillType mining = createSkill("MINING" , MiningManager.class , MiningCommand.class , false, Color.GRAY, SkillUseType.GATHERING, AbilityType.superBreaker, ToolType.PICKAXE, ImmutableList.of(SecondaryAbility.miningDoubleDrops));
public static final SkillType repair = createSkill("REPAIR" , RepairManager.class , RepairCommand.class , false, Color.SILVER, SkillUseType.MISC, ImmutableList.of(SecondaryAbility.arcaneForging, SecondaryAbility.repairMastery, SecondaryAbility.superRepair));
public static final SkillType salvage = createSkill("SALVAGE" , SalvageManager.class , SalvageCommand.class , true, Color.ORANGE, SkillUseType.MISC, ImmutableList.of(SecondaryAbility.advancedSalvage, SecondaryAbility.arcaneSalvage));
public static final SkillType smelting = createSkill("SMELTING" , SmeltingManager.class , SmeltingCommand.class , true, Color.YELLOW, SkillUseType.MISC, ImmutableList.of(SecondaryAbility.fluxMining, SecondaryAbility.fuelEfficiency, SecondaryAbility.secondSmelt));
public static final SkillType swords = createSkill("SWORDS" , SwordsManager.class , SwordsCommand.class , false, Color.fromRGB(178, 34, 34), SkillUseType.COMBAT, AbilityType.serratedStrikes, ToolType.SWORD, ImmutableList.of(SecondaryAbility.bleed, SecondaryAbility.counter));
public static final SkillType taming = createSkill("TAMING" , TamingManager.class , TamingCommand.class , false, Color.PURPLE, SkillUseType.COMBAT, ImmutableList.of(SecondaryAbility.beastLore, SecondaryAbility.callOfTheWild, SecondaryAbility.enviromentallyAware, SecondaryAbility.fastFood, SecondaryAbility.gore, SecondaryAbility.holyHound, SecondaryAbility.sharpenedClaws, SecondaryAbility.shockProof, SecondaryAbility.thickFur));
public static final SkillType unarmed = createSkill("UNARMED" , UnarmedManager.class , UnarmedCommand.class , false, Color.BLACK, SkillUseType.COMBAT, AbilityType.berserk, ToolType.FISTS, ImmutableList.of(SecondaryAbility.blockCracker, SecondaryAbility.deflect, SecondaryAbility.disarm, SecondaryAbility.ironArm, SecondaryAbility.ironGrip));
public static final SkillType woodcutting = createSkill("WOODCUTTING", WoodcuttingManager.class , WoodcuttingCommand.class , false, Color.OLIVE, SkillUseType.GATHERING, AbilityType.treeFeller, ToolType.AXE, ImmutableList.of(SecondaryAbility.leafBlower, SecondaryAbility.woodcuttingDoubleDrops));
private String name;

8
src/main/java/com/gmail/nossr50/listeners/EntityListener.java
View File

@ -545,7 +545,7 @@ public class EntityListener implements Listener {
case GOLDEN_CARROT: /* RESTORES 3 HUNGER - RESTORES 5 1/2 HUNGER @ 1000 */
case MUSHROOM_SOUP: /* RESTORES 4 HUNGER - RESTORES 6 1/2 HUNGER @ 1000 */
case PUMPKIN_PIE: /* RESTORES 4 HUNGER - RESTORES 6 1/2 HUNGER @ 1000 */
if (Permissions.secondaryAbilityEnabled(player, SecondaryAbility.FARMERS_DIET)) {
if (Permissions.secondaryAbilityEnabled(player, SecondaryAbility.farmersDiet)) {
event.setFoodLevel(UserManager.getPlayer(player).getHerbalismManager().farmersDiet(Herbalism.farmersDietRankLevel1, newFoodLevel));
}
return;
@ -554,19 +554,19 @@ public class EntityListener implements Listener {
case MELON: /* RESTORES 1 HUNGER - RESTORES 2 1/2 HUNGER @ 1000 */
case POISONOUS_POTATO: /* RESTORES 1 HUNGER - RESTORES 2 1/2 HUNGER @ 1000 */
case POTATO_ITEM: /* RESTORES 1/2 HUNGER - RESTORES 2 HUNGER @ 1000 */
if (Permissions.secondaryAbilityEnabled(player, SecondaryAbility.FARMERS_DIET)) {
if (Permissions.secondaryAbilityEnabled(player, SecondaryAbility.farmersDiet)) {
event.setFoodLevel(UserManager.getPlayer(player).getHerbalismManager().farmersDiet(Herbalism.farmersDietRankLevel2, newFoodLevel));
}
return;
case COOKED_FISH: /* RESTORES 2 1/2 HUNGER - RESTORES 5 HUNGER @ 1000 */
if (Permissions.secondaryAbilityEnabled(player, SecondaryAbility.FISHERMANS_DIET)) {
if (Permissions.secondaryAbilityEnabled(player, SecondaryAbility.fishermansDiet)) {
event.setFoodLevel(UserManager.getPlayer(player).getFishingManager().handleFishermanDiet(Fishing.fishermansDietRankLevel1, newFoodLevel));
}
return;
case RAW_FISH: /* RESTORES 1 HUNGER - RESTORES 2 1/2 HUNGER @ 1000 */
if (Permissions.secondaryAbilityEnabled(player, SecondaryAbility.FISHERMANS_DIET)) {
if (Permissions.secondaryAbilityEnabled(player, SecondaryAbility.fishermansDiet)) {
event.setFoodLevel(UserManager.getPlayer(player).getFishingManager().handleFishermanDiet(Fishing.fishermansDietRankLevel2, newFoodLevel));
}
return;

6
src/main/java/com/gmail/nossr50/listeners/InventoryListener.java
View File

@ -95,7 +95,7 @@ public class InventoryListener implements Listener {
Player player = getPlayerFromFurnace(furnaceBlock);
if (!UserManager.hasPlayerDataKey(player) || !Permissions.secondaryAbilityEnabled(player, SecondaryAbility.FUEL_EFFICIENCY)) {
if (!UserManager.hasPlayerDataKey(player) || !Permissions.secondaryAbilityEnabled(player, SecondaryAbility.fuelEfficiency)) {
return;
}
@ -155,7 +155,7 @@ public class InventoryListener implements Listener {
HumanEntity whoClicked = event.getWhoClicked();
if (!UserManager.hasPlayerDataKey(event.getWhoClicked()) || !Permissions.secondaryAbilityEnabled(whoClicked, SecondaryAbility.CONCOCTIONS)) {
if (!UserManager.hasPlayerDataKey(event.getWhoClicked()) || !Permissions.secondaryAbilityEnabled(whoClicked, SecondaryAbility.concoctions)) {
return;
}
@ -254,7 +254,7 @@ public class InventoryListener implements Listener {
HumanEntity whoClicked = event.getWhoClicked();
if (!UserManager.hasPlayerDataKey(event.getWhoClicked()) || !Permissions.secondaryAbilityEnabled(whoClicked, SecondaryAbility.CONCOCTIONS)) {
if (!UserManager.hasPlayerDataKey(event.getWhoClicked()) || !Permissions.secondaryAbilityEnabled(whoClicked, SecondaryAbility.concoctions)) {
return;
}

2
src/main/java/com/gmail/nossr50/runnables/skills/AlchemyBrewTask.java
View File

@ -36,7 +36,7 @@ public class AlchemyBrewTask extends BukkitRunnable {
brewSpeed = DEFAULT_BREW_SPEED;
brewTimer = DEFAULT_BREW_TICKS;
if (player != null && !Misc.isNPCEntity(player) && Permissions.secondaryAbilityEnabled(player, SecondaryAbility.CATALYSIS)) {
if (player != null && !Misc.isNPCEntity(player) && Permissions.secondaryAbilityEnabled(player, SecondaryAbility.catalysis)) {
double catalysis = UserManager.getPlayer(player).getAlchemyManager().calculateBrewSpeed(Permissions.lucky(player, SkillType.alchemy));
McMMOPlayerCatalysisEvent event = new McMMOPlayerCatalysisEvent(player, catalysis);

12
src/main/java/com/gmail/nossr50/skills/acrobatics/AcrobaticsManager.java
View File

@ -29,11 +29,11 @@ public class AcrobaticsManager extends SkillManager {
}
public boolean canRoll() {
return !exploitPrevention() && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.ROLL);
return !exploitPrevention() && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.roll);
}
public boolean canDodge(Entity damager) {
if (Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.DODGE)) {
if (Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.dodge)) {
if (damager instanceof LightningStrike && Acrobatics.dodgeLightningDisabled) {
return false;
}
@ -54,7 +54,7 @@ public class AcrobaticsManager extends SkillManager {
double modifiedDamage = Acrobatics.calculateModifiedDodgeDamage(damage, Acrobatics.dodgeDamageModifier);
Player player = getPlayer();
if (!isFatal(modifiedDamage) && SkillUtils.activationSuccessful(SecondaryAbility.DODGE, player, getSkillLevel(), activationChance)) {
if (!isFatal(modifiedDamage) && SkillUtils.activationSuccessful(SecondaryAbility.dodge, player, getSkillLevel(), activationChance)) {
ParticleEffectUtils.playDodgeEffect(player);
if (mcMMOPlayer.useChatNotifications()) {
@ -81,13 +81,13 @@ public class AcrobaticsManager extends SkillManager {
public double rollCheck(double damage) {
Player player = getPlayer();
if (player.isSneaking() && Permissions.secondaryAbilityEnabled(player, SecondaryAbility.GRACEFUL_ROLL)) {
if (player.isSneaking() && Permissions.secondaryAbilityEnabled(player, SecondaryAbility.gracefullRoll)) {
return gracefulRollCheck(damage);
}
double modifiedDamage = Acrobatics.calculateModifiedRollDamage(damage, Acrobatics.rollThreshold);
if (!isFatal(modifiedDamage) && SkillUtils.activationSuccessful(SecondaryAbility.ROLL, player, getSkillLevel(), activationChance)) {
if (!isFatal(modifiedDamage) && SkillUtils.activationSuccessful(SecondaryAbility.roll, player, getSkillLevel(), activationChance)) {
player.sendMessage(LocaleLoader.getString("Acrobatics.Roll.Text"));
applyXpGain(calculateRollXP(damage, true), XPGainReason.PVE);
@ -111,7 +111,7 @@ public class AcrobaticsManager extends SkillManager {
private double gracefulRollCheck(double damage) {
double modifiedDamage = Acrobatics.calculateModifiedRollDamage(damage, Acrobatics.gracefulRollThreshold);
if (!isFatal(modifiedDamage) && SkillUtils.activationSuccessful(SecondaryAbility.GRACEFUL_ROLL, getPlayer(), getSkillLevel(), activationChance)) {
if (!isFatal(modifiedDamage) && SkillUtils.activationSuccessful(SecondaryAbility.gracefullRoll, getPlayer(), getSkillLevel(), activationChance)) {
getPlayer().sendMessage(LocaleLoader.getString("Acrobatics.Ability.Proc"));
applyXpGain(calculateRollXP(damage, true), XPGainReason.PVE);

2
src/main/java/com/gmail/nossr50/skills/alchemy/AlchemyPotionBrewer.java
View File

@ -88,7 +88,7 @@ public final class AlchemyPotionBrewer {
}
private static List<ItemStack> getValidIngredients(Player player) {
return PotionConfig.getInstance().getIngredients((player == null || !Permissions.secondaryAbilityEnabled(player, SecondaryAbility.CONCOCTIONS)) ? 1 : UserManager.getPlayer(player).getAlchemyManager().getTier());
return PotionConfig.getInstance().getIngredients((player == null || !Permissions.secondaryAbilityEnabled(player, SecondaryAbility.concoctions)) ? 1 : UserManager.getPlayer(player).getAlchemyManager().getTier());
}
public static void finishBrewing(BlockState brewingStand, Player player, boolean forced) {

12
src/main/java/com/gmail/nossr50/skills/archery/ArcheryManager.java
View File

@ -24,15 +24,15 @@ public class ArcheryManager extends SkillManager {
}
public boolean canDaze(LivingEntity target) {
return target instanceof Player && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.DAZE);
return target instanceof Player && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.daze);
}
public boolean canSkillShot() {
return getSkillLevel() >= Archery.skillShotIncreaseLevel && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.SKILL_SHOT);
return getSkillLevel() >= Archery.skillShotIncreaseLevel && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.skillShot);
}
public boolean canRetrieveArrows() {
return Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.RETRIEVE);
return Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.retrieve);
}
/**
@ -58,7 +58,7 @@ public class ArcheryManager extends SkillManager {
* @param target The {@link LivingEntity} damaged by the arrow
*/
public void retrieveArrows(LivingEntity target) {
if (SkillUtils.activationSuccessful(SecondaryAbility.RETRIEVE, getPlayer(), getSkillLevel(), activationChance)) {
if (SkillUtils.activationSuccessful(SecondaryAbility.retrieve, getPlayer(), getSkillLevel(), activationChance)) {
Archery.incrementTrackerValue(target);
}
}
@ -69,7 +69,7 @@ public class ArcheryManager extends SkillManager {
* @param defender The {@link Player} being affected by the ability
*/
public double daze(Player defender) {
if (!SkillUtils.activationSuccessful(SecondaryAbility.DAZE, getPlayer(), getSkillLevel(), activationChance)) {
if (!SkillUtils.activationSuccessful(SecondaryAbility.daze, getPlayer(), getSkillLevel(), activationChance)) {
return 0;
}
@ -96,7 +96,7 @@ public class ArcheryManager extends SkillManager {
* @param damage The amount of damage initially dealt by the event
*/
public double skillShot(double damage) {
if (!SkillUtils.activationSuccessful(SecondaryAbility.SKILL_SHOT, getPlayer())) {
if (!SkillUtils.activationSuccessful(SecondaryAbility.skillShot, getPlayer())) {
return damage;
}

16
src/main/java/com/gmail/nossr50/skills/axes/AxesManager.java
View File

@ -27,19 +27,19 @@ public class AxesManager extends SkillManager {
}
public boolean canUseAxeMastery() {
return Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.AXE_MASTERY);
return Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.axeMastery);
}
public boolean canCriticalHit(LivingEntity target) {
return target.isValid() && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.CRITICAL_HIT);
return target.isValid() && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.criticalHit);
}
public boolean canImpact(LivingEntity target) {
return target.isValid() && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.ARMOR_IMPACT) && Axes.hasArmor(target);
return target.isValid() && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.armorImpact) && Axes.hasArmor(target);
}
public boolean canGreaterImpact(LivingEntity target) {
return target.isValid() && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.GREATER_IMPACT) && !Axes.hasArmor(target);
return target.isValid() && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.greaterImpact) && !Axes.hasArmor(target);
}
public boolean canUseSkullSplitter(LivingEntity target) {
@ -54,7 +54,7 @@ public class AxesManager extends SkillManager {
* Handle the effects of the Axe Mastery ability
*/
public double axeMastery() {
if (!SkillUtils.activationSuccessful(SecondaryAbility.AXE_MASTERY, getPlayer())) {
if (!SkillUtils.activationSuccessful(SecondaryAbility.axeMastery, getPlayer())) {
return 0;
}
@ -68,7 +68,7 @@ public class AxesManager extends SkillManager {
* @param damage The amount of damage initially dealt by the event
*/
public double criticalHit(LivingEntity target, double damage) {
if (!SkillUtils.activationSuccessful(SecondaryAbility.CRITICAL_HIT, getPlayer(), getSkillLevel(), activationChance)) {
if (!SkillUtils.activationSuccessful(SecondaryAbility.criticalHit, getPlayer(), getSkillLevel(), activationChance)) {
return 0;
}
@ -98,7 +98,7 @@ public class AxesManager extends SkillManager {
for (ItemStack armor : target.getEquipment().getArmorContents()) {
if (ItemUtils.isArmor(armor)) {
if (SkillUtils.activationSuccessful(SecondaryAbility.ARMOR_IMPACT, getPlayer(), Axes.impactChance, activationChance)) {
if (SkillUtils.activationSuccessful(SecondaryAbility.armorImpact, getPlayer(), Axes.impactChance, activationChance)) {
SkillUtils.handleDurabilityChange(armor, durabilityDamage, Axes.impactMaxDurabilityModifier);
}
}
@ -111,7 +111,7 @@ public class AxesManager extends SkillManager {
* @param target The {@link LivingEntity} being affected by the ability
*/
public double greaterImpact(LivingEntity target) {
if (!SkillUtils.activationSuccessful(SecondaryAbility.GREATER_IMPACT, getPlayer(), Axes.greaterImpactChance, activationChance)) {
if (!SkillUtils.activationSuccessful(SecondaryAbility.greaterImpact, getPlayer(), Axes.greaterImpactChance, activationChance)) {
return 0;
}

2
src/main/java/com/gmail/nossr50/skills/excavation/ExcavationManager.java
View File

@ -29,7 +29,7 @@ public class ExcavationManager extends SkillManager {
public void excavationBlockCheck(BlockState blockState) {
int xp = Excavation.getBlockXP(blockState);
if (Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.EXCAVATION_TREASURE_HUNTER)) {
if (Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.excavationTreasureHunter)) {
List<ExcavationTreasure> treasures = Excavation.getTreasures(blockState);
if (!treasures.isEmpty()) {

12
src/main/java/com/gmail/nossr50/skills/fishing/FishingManager.java
View File

@ -76,11 +76,11 @@ public class FishingManager extends SkillManager {
}
public boolean canShake(Entity target) {
return target instanceof LivingEntity && getSkillLevel() >= Tier.ONE.getLevel() && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.SHAKE);
return target instanceof LivingEntity && getSkillLevel() >= Tier.ONE.getLevel() && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.shake);
}
public boolean canMasterAngler() {
return getSkillLevel() >= AdvancedConfig.getInstance().getMasterAnglerUnlockLevel() && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.MASTER_ANGLER);
return getSkillLevel() >= AdvancedConfig.getInstance().getMasterAnglerUnlockLevel() && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.masterAngler);
}
public boolean unleashTheKraken() {
@ -204,7 +204,7 @@ public class FishingManager extends SkillManager {
Player player = getPlayer();
if (!Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.ICE_FISHING)) {
if (!Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.iceFishing)) {
return false;
}
@ -305,7 +305,7 @@ public class FishingManager extends SkillManager {
Player player = getPlayer();
FishingTreasure treasure = null;
if (Config.getInstance().getFishingDropsEnabled() && Permissions.secondaryAbilityEnabled(player, SecondaryAbility.FISHING_TREASURE_HUNTER)) {
if (Config.getInstance().getFishingDropsEnabled() && Permissions.secondaryAbilityEnabled(player, SecondaryAbility.fishingTreasureHunter)) {
treasure = getFishingTreasure();
this.fishingCatch = null;
}
@ -314,7 +314,7 @@ public class FishingManager extends SkillManager {
ItemStack treasureDrop = treasure.getDrop().clone(); // Not cloning is bad, m'kay?
Map<Enchantment, Integer> enchants = new HashMap<Enchantment, Integer>();
if (Permissions.secondaryAbilityEnabled(player, SecondaryAbility.MAGIC_HUNTER) && ItemUtils.isEnchantable(treasureDrop)) {
if (Permissions.secondaryAbilityEnabled(player, SecondaryAbility.magicHunter) && ItemUtils.isEnchantable(treasureDrop)) {
enchants = handleMagicHunter(treasureDrop);
}
@ -376,7 +376,7 @@ public class FishingManager extends SkillManager {
public void shakeCheck(LivingEntity target) {
fishingTries--; // Because autoclicking to shake is OK.
SecondaryAbilityWeightedActivationCheckEvent activationEvent = new SecondaryAbilityWeightedActivationCheckEvent(getPlayer(), SecondaryAbility.SHAKE, getShakeProbability() / activationChance);
SecondaryAbilityWeightedActivationCheckEvent activationEvent = new SecondaryAbilityWeightedActivationCheckEvent(getPlayer(), SecondaryAbility.shake, getShakeProbability() / activationChance);
mcMMO.p.getServer().getPluginManager().callEvent(activationEvent);
if ((activationEvent.getChance() * activationChance) > Misc.getRandom().nextInt(activationChance)) {
List<ShakeTreasure> possibleDrops = Fishing.findPossibleDrops(target);

18
src/main/java/com/gmail/nossr50/skills/herbalism/HerbalismManager.java
View File

@ -57,11 +57,11 @@ public class HerbalismManager extends SkillManager {
Player player = getPlayer();
Material itemType = player.getItemInHand().getType();
return (itemType == Material.RED_MUSHROOM || itemType == Material.BROWN_MUSHROOM) && BlockUtils.canMakeShroomy(blockState) && Permissions.secondaryAbilityEnabled(player, SecondaryAbility.SHROOM_THUMB);
return (itemType == Material.RED_MUSHROOM || itemType == Material.BROWN_MUSHROOM) && BlockUtils.canMakeShroomy(blockState) && Permissions.secondaryAbilityEnabled(player, SecondaryAbility.shroomThumb);
}
public boolean canUseHylianLuck() {
return Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.HYLIAN_LUCK);
return Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.hylianLuck);
}
public boolean canGreenTerraBlock(BlockState blockState) {
@ -139,7 +139,7 @@ public class HerbalismManager extends SkillManager {
CustomBlock customBlock = mcMMO.getModManager().getBlock(blockState);
xp = customBlock.getXpGain();
if (Permissions.secondaryAbilityEnabled(player, SecondaryAbility.HERBALISM_DOUBLE_DROPS) && customBlock.isDoubleDropEnabled()) {
if (Permissions.secondaryAbilityEnabled(player, SecondaryAbility.herbalismDoubleDrops) && customBlock.isDoubleDropEnabled()) {
drops = blockState.getBlock().getDrops();
}
}
@ -155,7 +155,7 @@ public class HerbalismManager extends SkillManager {
xp = ExperienceConfig.getInstance().getXp(skill, material);
}
if (Config.getInstance().getDoubleDropsEnabled(skill, material) && Permissions.secondaryAbilityEnabled(player, SecondaryAbility.HERBALISM_DOUBLE_DROPS)) {
if (Config.getInstance().getDoubleDropsEnabled(skill, material) && Permissions.secondaryAbilityEnabled(player, SecondaryAbility.herbalismDoubleDrops)) {
drops = blockState.getBlock().getDrops();
}
@ -172,7 +172,7 @@ public class HerbalismManager extends SkillManager {
}
for (int i = greenTerra ? 2 : 1; i != 0; i--) {
if (SkillUtils.activationSuccessful(SecondaryAbility.HERBALISM_DOUBLE_DROPS, getPlayer(), getSkillLevel(), activationChance)) {
if (SkillUtils.activationSuccessful(SecondaryAbility.herbalismDoubleDrops, getPlayer(), getSkillLevel(), activationChance)) {
for (ItemStack item : drops) {
Misc.dropItems(blockState.getLocation(), item, amount);
}
@ -187,7 +187,7 @@ public class HerbalismManager extends SkillManager {
* @return true if the ability was successful, false otherwise
*/
public boolean processGreenThumbBlocks(BlockState blockState) {
if (!SkillUtils.activationSuccessful(SecondaryAbility.GREEN_THUMB_BLOCK, getPlayer(), getSkillLevel(), activationChance)) {
if (!SkillUtils.activationSuccessful(SecondaryAbility.greenThumbBlock, getPlayer(), getSkillLevel(), activationChance)) {
getPlayer().sendMessage(LocaleLoader.getString("Herbalism.Ability.GTh.Fail"));
return false;
}
@ -202,7 +202,7 @@ public class HerbalismManager extends SkillManager {
* @return true if the ability was successful, false otherwise
*/
public boolean processHylianLuck(BlockState blockState) {
if (!SkillUtils.activationSuccessful(SecondaryAbility.HYLIAN_LUCK, getPlayer(), getSkillLevel(), activationChance)) {
if (!SkillUtils.activationSuccessful(SecondaryAbility.hylianLuck, getPlayer(), getSkillLevel(), activationChance)) {
return false;
}
@ -270,7 +270,7 @@ public class HerbalismManager extends SkillManager {
playerInventory.removeItem(new ItemStack(Material.RED_MUSHROOM));
player.updateInventory();
if (!SkillUtils.activationSuccessful(SecondaryAbility.SHROOM_THUMB, getPlayer(), getSkillLevel(), activationChance)) {
if (!SkillUtils.activationSuccessful(SecondaryAbility.shroomThumb, getPlayer(), getSkillLevel(), activationChance)) {
player.sendMessage(LocaleLoader.getString("Herbalism.Ability.ShroomThumb.Fail"));
return false;
}
@ -314,7 +314,7 @@ public class HerbalismManager extends SkillManager {
return;
}
if (!greenTerra && !SkillUtils.activationSuccessful(SecondaryAbility.GREEN_THUMB_PLANT, getPlayer(), getSkillLevel(), activationChance)) {
if (!greenTerra && !SkillUtils.activationSuccessful(SecondaryAbility.greenThumbPlant, getPlayer(), getSkillLevel(), activationChance)) {
return;
}

4
src/main/java/com/gmail/nossr50/skills/mining/MiningManager.java
View File

@ -60,7 +60,7 @@ public class MiningManager extends SkillManager {
applyXpGain(Mining.getBlockXp(blockState), XPGainReason.PVE);
if (!Permissions.secondaryAbilityEnabled(player, SecondaryAbility.MINING_DOUBLE_DROPS)) {
if (!Permissions.secondaryAbilityEnabled(player, SecondaryAbility.miningDoubleDrops)) {
return;
}
@ -77,7 +77,7 @@ public class MiningManager extends SkillManager {
boolean silkTouch = player.getItemInHand().containsEnchantment(Enchantment.SILK_TOUCH);
for (int i = mcMMOPlayer.getAbilityMode(skill.getAbility()) ? 2 : 1; i != 0; i--) {
if (SkillUtils.activationSuccessful(SecondaryAbility.MINING_DOUBLE_DROPS, getPlayer(), getSkillLevel(), activationChance)) {
if (SkillUtils.activationSuccessful(SecondaryAbility.miningDoubleDrops, getPlayer(), getSkillLevel(), activationChance)) {
if (silkTouch) {
Mining.handleSilkTouchDrops(blockState);
}

8
src/main/java/com/gmail/nossr50/skills/repair/RepairManager.java
View File

@ -240,12 +240,12 @@ public class RepairManager extends SkillManager {
private short repairCalculate(short durability, int repairAmount) {
Player player = getPlayer();
if (Permissions.secondaryAbilityEnabled(player, SecondaryAbility.REPAIR_MASTERY)) {
if (Permissions.secondaryAbilityEnabled(player, SecondaryAbility.repairMastery)) {
double bonus = repairAmount * Math.min((((Repair.repairMasteryMaxBonus / Repair.repairMasteryMaxBonusLevel) * getSkillLevel()) / 100.0D), Repair.repairMasteryMaxBonus / 100.0D);
repairAmount += bonus;
}
if (Permissions.secondaryAbilityEnabled(player, SecondaryAbility.SUPER_REPAIR) && checkPlayerProcRepair()) {
if (Permissions.secondaryAbilityEnabled(player, SecondaryAbility.superRepair) && checkPlayerProcRepair()) {
repairAmount *= 2.0D;
}
@ -262,7 +262,7 @@ public class RepairManager extends SkillManager {
* @return true if bonus granted, false otherwise
*/
private boolean checkPlayerProcRepair() {
if (SkillUtils.activationSuccessful(SecondaryAbility.SUPER_REPAIR, getPlayer(), getSkillLevel(), activationChance)) {
if (SkillUtils.activationSuccessful(SecondaryAbility.superRepair, getPlayer(), getSkillLevel(), activationChance)) {
getPlayer().sendMessage(LocaleLoader.getString("Repair.Skills.FeltEasy"));
return true;
}
@ -289,7 +289,7 @@ public class RepairManager extends SkillManager {
return;
}
if (getArcaneForgingRank() == 0 || !Permissions.secondaryAbilityEnabled(player, SecondaryAbility.ARCANE_FORGING)) {
if (getArcaneForgingRank() == 0 || !Permissions.secondaryAbilityEnabled(player, SecondaryAbility.arcaneForging)) {
for (Enchantment enchant : enchants.keySet()) {
item.removeEnchantment(enchant);
}

6
src/main/java/com/gmail/nossr50/skills/smelting/SmeltingManager.java
View File

@ -26,11 +26,11 @@ public class SmeltingManager extends SkillManager {
}
public boolean canUseFluxMining(BlockState blockState) {
return getSkillLevel() >= Smelting.fluxMiningUnlockLevel && BlockUtils.affectedByFluxMining(blockState) && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.FLUX_MINING) && !mcMMO.getPlaceStore().isTrue(blockState);
return getSkillLevel() >= Smelting.fluxMiningUnlockLevel && BlockUtils.affectedByFluxMining(blockState) && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.fluxMining) && !mcMMO.getPlaceStore().isTrue(blockState);
}
public boolean isSecondSmeltSuccessful() {
return Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.SECOND_SMELT) && SkillUtils.activationSuccessful(SecondaryAbility.SECOND_SMELT, getPlayer(), getSkillLevel(), activationChance);
return Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.secondSmelt) && SkillUtils.activationSuccessful(SecondaryAbility.secondSmelt, getPlayer(), getSkillLevel(), activationChance);
}
/**
@ -42,7 +42,7 @@ public class SmeltingManager extends SkillManager {
public boolean processFluxMining(BlockState blockState) {
Player player = getPlayer();
SecondaryAbilityWeightedActivationCheckEvent event = new SecondaryAbilityWeightedActivationCheckEvent(getPlayer(), SecondaryAbility.FLUX_MINING, Smelting.fluxMiningChance / activationChance);
SecondaryAbilityWeightedActivationCheckEvent event = new SecondaryAbilityWeightedActivationCheckEvent(getPlayer(), SecondaryAbility.fluxMining, Smelting.fluxMiningChance / activationChance);
mcMMO.p.getServer().getPluginManager().callEvent(event);
if ((event.getChance() * activationChance) > Misc.getRandom().nextInt(activationChance)) {
ItemStack item = null;

10
src/main/java/com/gmail/nossr50/skills/swords/SwordsManager.java
View File

@ -31,11 +31,11 @@ public class SwordsManager extends SkillManager {
}
public boolean canUseBleed() {
return Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.BLEED);
return Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.bleed);
}
public boolean canUseCounterAttack(Entity target) {
return target instanceof LivingEntity && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.COUNTER);
return target instanceof LivingEntity && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.counter);
}
public boolean canUseSerratedStrike() {
@ -48,9 +48,9 @@ public class SwordsManager extends SkillManager {
* @param target The defending entity
*/
public void bleedCheck(LivingEntity target) {
if (SkillUtils.activationSuccessful(SecondaryAbility.BLEED, getPlayer(), getSkillLevel(), activationChance)) {
if (SkillUtils.activationSuccessful(SecondaryAbility.bleed, getPlayer(), getSkillLevel(), activationChance)) {
if (getSkillLevel() >= AdvancedConfig.getInstance().getMaxBonusLevel(SecondaryAbility.BLEED)) {
if (getSkillLevel() >= AdvancedConfig.getInstance().getMaxBonusLevel(SecondaryAbility.bleed)) {
BleedTimerTask.add(target, Swords.bleedMaxTicks);
}
else {
@ -82,7 +82,7 @@ public class SwordsManager extends SkillManager {
return;
}
if (SkillUtils.activationSuccessful(SecondaryAbility.COUNTER, getPlayer(), getSkillLevel(), activationChance)) {
if (SkillUtils.activationSuccessful(SecondaryAbility.counter, getPlayer(), getSkillLevel(), activationChance)) {
CombatUtils.dealDamage(attacker, damage / Swords.counterAttackModifier);
getPlayer().sendMessage(LocaleLoader.getString("Swords.Combat.Countered"));

20
src/main/java/com/gmail/nossr50/skills/taming/TamingManager.java
View File

@ -32,35 +32,35 @@ public class TamingManager extends SkillManager {
}
public boolean canUseThickFur() {
return getSkillLevel() >= Taming.thickFurUnlockLevel && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.THICK_FUR);
return getSkillLevel() >= Taming.thickFurUnlockLevel && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.thickFur);
}
public boolean canUseEnvironmentallyAware() {
return getSkillLevel() >= Taming.environmentallyAwareUnlockLevel && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.ENVIROMENTALLY_AWARE);
return getSkillLevel() >= Taming.environmentallyAwareUnlockLevel && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.enviromentallyAware);
}
public boolean canUseShockProof() {
return getSkillLevel() >= Taming.shockProofUnlockLevel && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.SHOCK_PROOF);
return getSkillLevel() >= Taming.shockProofUnlockLevel && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.shockProof);
}
public boolean canUseHolyHound() {
return getSkillLevel() >= Taming.holyHoundUnlockLevel && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.HOLY_HOUND);
return getSkillLevel() >= Taming.holyHoundUnlockLevel && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.holyHound);
}
public boolean canUseFastFoodService() {
return getSkillLevel() >= Taming.fastFoodServiceUnlockLevel && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.FAST_FOOD);
return getSkillLevel() >= Taming.fastFoodServiceUnlockLevel && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.fastFood);
}
public boolean canUseSharpenedClaws() {
return getSkillLevel() >= Taming.sharpenedClawsUnlockLevel && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.SHARPENED_CLAWS);
return getSkillLevel() >= Taming.sharpenedClawsUnlockLevel && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.sharpenedClaws);
}
public boolean canUseGore() {
return Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.GORE);
return Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.gore);
}
public boolean canUseBeastLore() {
return Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.BEAST_LORE);
return Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.beastLore);
}
/**
@ -94,7 +94,7 @@ public class TamingManager extends SkillManager {
* @param damage The damage being absorbed by the wolf
*/
public void fastFoodService(Wolf wolf, double damage) {
if (!SkillUtils.activationSuccessful(SecondaryAbility.FAST_FOOD, getPlayer(), Taming.fastFoodServiceActivationChance, activationChance)) {
if (!SkillUtils.activationSuccessful(SecondaryAbility.fastFood, getPlayer(), Taming.fastFoodServiceActivationChance, activationChance)) {
return;
}
@ -114,7 +114,7 @@ public class TamingManager extends SkillManager {
* @param damage The initial damage
*/
public double gore(LivingEntity target, double damage) {
if (!SkillUtils.activationSuccessful(SecondaryAbility.GORE, getPlayer(), getSkillLevel(), activationChance)) {
if (!SkillUtils.activationSuccessful(SecondaryAbility.gore, getPlayer(), getSkillLevel(), activationChance)) {
return 0;
}

18
src/main/java/com/gmail/nossr50/skills/unarmed/UnarmedManager.java
View File

@ -34,7 +34,7 @@ public class UnarmedManager extends SkillManager {
}
public boolean canUseIronArm() {
return Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.IRON_ARM);
return Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.ironArm);
}
public boolean canUseBerserk() {
@ -42,21 +42,21 @@ public class UnarmedManager extends SkillManager {
}
public boolean canDisarm(LivingEntity target) {
return target instanceof Player && ((Player) target).getItemInHand().getType() != Material.AIR && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.DISARM);
return target instanceof Player && ((Player) target).getItemInHand().getType() != Material.AIR && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.disarm);
}
public boolean canDeflect() {
Player player = getPlayer();
return player.getItemInHand().getType() == Material.AIR && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.DEFLECT);
return player.getItemInHand().getType() == Material.AIR && Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.deflect);
}
public boolean canUseBlockCracker() {
return Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.BLOCK_CRACKER);
return Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.blockCracker);
}
public boolean blockCrackerCheck(BlockState blockState) {
if (!SkillUtils.activationSuccessful(SecondaryAbility.BLOCK_CRACKER, getPlayer())) {
if (!SkillUtils.activationSuccessful(SecondaryAbility.blockCracker, getPlayer())) {
return false;
}
@ -89,7 +89,7 @@ public class UnarmedManager extends SkillManager {
* @param defender The defending player
*/
public void disarmCheck(Player defender) {
if (SkillUtils.activationSuccessful(SecondaryAbility.DISARM, getPlayer(), getSkillLevel(), activationChance) && !hasIronGrip(defender)) {
if (SkillUtils.activationSuccessful(SecondaryAbility.disarm, getPlayer(), getSkillLevel(), activationChance) && !hasIronGrip(defender)) {
if (EventUtils.callDisarmEvent(defender).isCancelled()) {
return;
}
@ -109,7 +109,7 @@ public class UnarmedManager extends SkillManager {
* Check for arrow deflection.
*/
public boolean deflectCheck() {
if (SkillUtils.activationSuccessful(SecondaryAbility.DEFLECT, getPlayer(), getSkillLevel(), activationChance)) {
if (SkillUtils.activationSuccessful(SecondaryAbility.deflect, getPlayer(), getSkillLevel(), activationChance)) {
getPlayer().sendMessage(LocaleLoader.getString("Combat.ArrowDeflect"));
return true;
}
@ -132,7 +132,7 @@ public class UnarmedManager extends SkillManager {
* Handle the effects of the Iron Arm ability
*/
public double ironArm() {
if (!SkillUtils.activationSuccessful(SecondaryAbility.IRON_ARM, getPlayer())) {
if (!SkillUtils.activationSuccessful(SecondaryAbility.ironArm, getPlayer())) {
return 0;
}
@ -146,7 +146,7 @@ public class UnarmedManager extends SkillManager {
* @return true if the defender was not disarmed, false otherwise
*/
private boolean hasIronGrip(Player defender) {
if (!Misc.isNPCEntity(defender) && Permissions.secondaryAbilityEnabled(defender, SecondaryAbility.IRON_GRIP) && SkillUtils.activationSuccessful(SecondaryAbility.IRON_GRIP, defender, skill)) {
if (!Misc.isNPCEntity(defender) && Permissions.secondaryAbilityEnabled(defender, SecondaryAbility.ironGrip) && SkillUtils.activationSuccessful(SecondaryAbility.ironGrip, defender, skill)) {
defender.sendMessage(LocaleLoader.getString("Unarmed.Ability.IronGrip.Defender"));
getPlayer().sendMessage(LocaleLoader.getString("Unarmed.Ability.IronGrip.Attacker"));

4
src/main/java/com/gmail/nossr50/skills/woodcutting/WoodcuttingManager.java
View File

@ -34,7 +34,7 @@ public class WoodcuttingManager extends SkillManager {
}
public boolean canUseLeafBlower(ItemStack heldItem) {
return Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.LEAF_BLOWER) && getSkillLevel() >= Woodcutting.leafBlowerUnlockLevel && ItemUtils.isAxe(heldItem);
return Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.leafBlower) && getSkillLevel() >= Woodcutting.leafBlowerUnlockLevel && ItemUtils.isAxe(heldItem);
}
public boolean canUseTreeFeller(ItemStack heldItem) {
@ -42,7 +42,7 @@ public class WoodcuttingManager extends SkillManager {
}
protected boolean canGetDoubleDrops() {
return Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.WOODCUTTING_DOUBLE_DROPS) && SkillUtils.activationSuccessful(SecondaryAbility.WOODCUTTING_DOUBLE_DROPS, getPlayer(), getSkillLevel(), activationChance);
return Permissions.secondaryAbilityEnabled(getPlayer(), SecondaryAbility.woodcuttingDoubleDrops) && SkillUtils.activationSuccessful(SecondaryAbility.woodcuttingDoubleDrops, getPlayer(), getSkillLevel(), activationChance);
}
/**

26
src/main/java/com/gmail/nossr50/util/StringUtils.java
View File

@ -36,20 +36,20 @@ public class StringUtils {
}
public static String getPrettySecondaryAbilityString(SecondaryAbility secondaryAbility) {
switch (secondaryAbility) {
case HERBALISM_DOUBLE_DROPS:
case MINING_DOUBLE_DROPS:
case WOODCUTTING_DOUBLE_DROPS:
return "Double Drops";
case FISHING_TREASURE_HUNTER:
case EXCAVATION_TREASURE_HUNTER:
return "Treasure Hunter";
case GREEN_THUMB_BLOCK:
case GREEN_THUMB_PLANT:
return "Green Thumb";
default:
// switch (secondaryAbility) {
// case herbalismDoubleDrops:
// case miningDoubleDrops:
// case woodcuttingDoubleDrops:
// return "Double Drops";
// case fishingTreasureHunter:
// case excavationTreasureHunter:
// return "Treasure Hunter";
// case greenThumbBlock:
// case greenThumbPlant:
// return "Green Thumb";
// default:
return createPrettyEnumString(secondaryAbility.toString());
}
// }
}
public static String getPrettyPartyFeatureString(PartyFeature partyFeature) {

2
src/main/java/com/gmail/nossr50/util/skills/SkillUtils.java
View File

@ -223,7 +223,7 @@ public class SkillUtils {
}
public static boolean treasureDropSuccessful(Player player, double dropChance, int activationChance) {
SecondaryAbilityWeightedActivationCheckEvent event = new SecondaryAbilityWeightedActivationCheckEvent(player, SecondaryAbility.EXCAVATION_TREASURE_HUNTER, dropChance / activationChance);
SecondaryAbilityWeightedActivationCheckEvent event = new SecondaryAbilityWeightedActivationCheckEvent(player, SecondaryAbility.excavationTreasureHunter, dropChance / activationChance);
mcMMO.p.getServer().getPluginManager().callEvent(event);
return (event.getChance() * activationChance) > (Misc.getRandom().nextDouble() * activationChance) && !event.isCancelled();
}