diff --git a/src/main/java/net/Indyuce/mmocore/MMOCore.java b/src/main/java/net/Indyuce/mmocore/MMOCore.java index 6dfbffc3..6bbae7d7 100644 --- a/src/main/java/net/Indyuce/mmocore/MMOCore.java +++ b/src/main/java/net/Indyuce/mmocore/MMOCore.java @@ -90,11 +90,6 @@ public class MMOCore extends LuminePlugin { public final MMOLoadManager loadManager = new MMOLoadManager(); - public boolean healthRegenFlat; - public boolean manaRegenFlat; - public boolean staminaRegenFlat; - public boolean stelliumRegenFlat; - public boolean shouldDebugSQL = false; public MMOCore() { @@ -146,13 +141,6 @@ public class MMOCore extends LuminePlugin { if (getConfig().isConfigurationSection("default-playerdata")) dataProvider.getDataManager().loadDefaultData(getConfig().getConfigurationSection("default-playerdata")); - if (getConfig().isConfigurationSection("stat-regen-flat")) { - healthRegenFlat = getConfig().getBoolean("stat-regen-flat.health", true); - manaRegenFlat = getConfig().getBoolean("stat-regen-flat.mana", true); - staminaRegenFlat = getConfig().getBoolean("stat-regen-flat.stamina", true); - stelliumRegenFlat = getConfig().getBoolean("stat-regen-flat.stellium", true); - } - if (Bukkit.getPluginManager().getPlugin("Vault") != null) economy = new VaultEconomy(); if (Bukkit.getPluginManager().getPlugin("PlaceholderAPI") != null) { @@ -190,32 +178,8 @@ public class MMOCore extends LuminePlugin { if (player.isOnline() && !player.getPlayer().isDead()) for (PlayerResource resource : PlayerResource.values()) { double regenAmount = player.getProfess().getHandler(resource).getRegen(player); - switch (resource) { - case HEALTH: - if (healthRegenFlat && regenAmount != 0) - resource.regen(player, regenAmount); - else if (!healthRegenFlat && regenAmount * player.getStats().getStat(StatType.HEALTH_REGENERATION) != 0) - resource.regen(player, player.getStats().getStat(StatType.MAX_HEALTH) * regenAmount); - break; - case MANA: - if (manaRegenFlat && regenAmount != 0) - resource.regen(player, regenAmount); - else if (!manaRegenFlat && regenAmount * player.getStats().getStat(StatType.MANA_REGENERATION) != 0) - resource.regen(player, player.getStats().getStat(StatType.MAX_MANA) * regenAmount); - break; - case STAMINA: - if (staminaRegenFlat && regenAmount != 0) - resource.regen(player, regenAmount); - else if (!staminaRegenFlat && regenAmount * player.getStats().getStat(StatType.STAMINA_REGENERATION) != 0) - resource.regen(player, player.getStats().getStat(StatType.MAX_STAMINA) * regenAmount); - break; - case STELLIUM: - if (stelliumRegenFlat && regenAmount != 0) - resource.regen(player, regenAmount); - else if (!stelliumRegenFlat && regenAmount * player.getStats().getStat(StatType.STELLIUM_REGENERATION) != 0) - resource.regen(player, player.getStats().getStat(StatType.MAX_STELLIUM) * regenAmount); - break; - } + if (regenAmount != 0) + resource.regen(player, regenAmount); } } }.runTaskTimer(MMOCore.plugin, 100, 20); diff --git a/src/main/java/net/Indyuce/mmocore/api/player/profess/PlayerClass.java b/src/main/java/net/Indyuce/mmocore/api/player/profess/PlayerClass.java index 25d6504b..b088dba3 100644 --- a/src/main/java/net/Indyuce/mmocore/api/player/profess/PlayerClass.java +++ b/src/main/java/net/Indyuce/mmocore/api/player/profess/PlayerClass.java @@ -10,7 +10,7 @@ import net.Indyuce.mmocore.MMOCore; import net.Indyuce.mmocore.api.player.profess.event.EventTrigger; import net.Indyuce.mmocore.api.player.profess.resource.ManaDisplayOptions; import net.Indyuce.mmocore.api.player.profess.resource.PlayerResource; -import net.Indyuce.mmocore.api.player.profess.resource.ResourceHandler; +import net.Indyuce.mmocore.api.player.profess.resource.ResourceRegeneration; import net.Indyuce.mmocore.api.player.stats.StatType; import net.Indyuce.mmocore.api.util.MMOCoreUtils; import net.Indyuce.mmocore.api.util.math.formula.LinearValue; @@ -47,7 +47,7 @@ public class PlayerClass extends PostLoadObject { private final Map skills = new LinkedHashMap<>(); private final List subclasses = new ArrayList<>(); - private final Map resourceHandlers = new HashMap<>(); + private final Map resourceHandlers = new HashMap<>(); private final Map eventTriggers = new HashMap<>(); private final CastingParticle castParticle; @@ -142,7 +142,7 @@ public class PlayerClass extends PostLoadObject { String format = key.toLowerCase().replace("_", "-").replace(" ", "-"); eventTriggers.put(format, new EventTrigger(format, config.getStringList("triggers." + key))); } catch (IllegalArgumentException exception) { - MMOCore.log(Level.WARNING, "[PlayerClasses:" + id + "] " + exception.getMessage()); + MMOCore.log(Level.WARNING, "Could not load trigger '" + key + "' from class '" + id + "':" + exception.getMessage()); } } @@ -153,15 +153,15 @@ public class PlayerClass extends PostLoadObject { for (PlayerResource resource : PlayerResource.values()) { if (config.isConfigurationSection("resource." + resource.name().toLowerCase())) try { - resourceHandlers.put(resource, new ResourceHandler(resource, + resourceHandlers.put(resource, new ResourceRegeneration(resource, config.getConfigurationSection("resource." + resource.name().toLowerCase()))); } catch (IllegalArgumentException exception) { - MMOCore.log(Level.WARNING, "[PlayerClasses:" + id + "] Could not load special resource regen for " - + resource.name() + ": " + exception.getMessage()); - resourceHandlers.put(resource, new ResourceHandler(resource)); + MMOCore.log(Level.WARNING, "Could not load special " + resource.name().toLowerCase() + " regen from class '" + + id + "': " + exception.getMessage()); + resourceHandlers.put(resource, new ResourceRegeneration(resource)); } else - resourceHandlers.put(resource, new ResourceHandler(resource)); + resourceHandlers.put(resource, new ResourceRegeneration(resource)); } } @@ -185,7 +185,7 @@ public class PlayerClass extends PostLoadObject { setOption(ClassOption.DEFAULT, false); for (PlayerResource resource : PlayerResource.values()) - resourceHandlers.put(resource, new ResourceHandler(resource)); + resourceHandlers.put(resource, new ResourceRegeneration(resource)); } @Override @@ -215,7 +215,7 @@ public class PlayerClass extends PostLoadObject { return manaDisplay; } - public ResourceHandler getHandler(PlayerResource resource) { + public ResourceRegeneration getHandler(PlayerResource resource) { return resourceHandlers.get(resource); } diff --git a/src/main/java/net/Indyuce/mmocore/api/player/profess/resource/PlayerResource.java b/src/main/java/net/Indyuce/mmocore/api/player/profess/resource/PlayerResource.java index 090e22d0..fcbec451 100644 --- a/src/main/java/net/Indyuce/mmocore/api/player/profess/resource/PlayerResource.java +++ b/src/main/java/net/Indyuce/mmocore/api/player/profess/resource/PlayerResource.java @@ -12,115 +12,118 @@ import java.util.function.Function; public enum PlayerResource { - HEALTH(StatType.HEALTH_REGENERATION, ClassOption.OFF_COMBAT_HEALTH_REGEN, - (data) -> data.getPlayer().getHealth(), - data -> data.getPlayer().getAttribute(Attribute.GENERIC_MAX_HEALTH).getValue(), - (data, amount) -> data.heal(amount, PlayerResourceUpdateEvent.UpdateReason.REGENERATION), - (data, amount) -> data.heal(amount, PlayerResourceUpdateEvent.UpdateReason.COMMAND), - (data, amount) -> data.heal(-amount, PlayerResourceUpdateEvent.UpdateReason.COMMAND), - (data, amount) -> data.getPlayer().setHealth(amount)), + HEALTH(data -> data.getPlayer().getHealth(), + data -> data.getPlayer().getAttribute(Attribute.GENERIC_MAX_HEALTH).getValue(), + (data, amount) -> data.heal(amount, PlayerResourceUpdateEvent.UpdateReason.REGENERATION), + (data, amount) -> data.heal(amount, PlayerResourceUpdateEvent.UpdateReason.COMMAND), + (data, amount) -> data.heal(-amount, PlayerResourceUpdateEvent.UpdateReason.COMMAND), + (data, amount) -> data.getPlayer().setHealth(amount)), - MANA(StatType.MANA_REGENERATION, ClassOption.OFF_COMBAT_MANA_REGEN, - PlayerData::getMana, - data -> data.getStats().getStat(StatType.MAX_MANA), - (data, amount) -> data.giveMana(amount, PlayerResourceUpdateEvent.UpdateReason.REGENERATION), - (data, amount) -> data.giveMana(amount, PlayerResourceUpdateEvent.UpdateReason.COMMAND), - (data, amount) -> data.giveMana(-amount, PlayerResourceUpdateEvent.UpdateReason.COMMAND), - (data, amount) -> data.setMana(amount)), + MANA(PlayerData::getMana, + data -> data.getStats().getStat(StatType.MAX_MANA), + (data, amount) -> data.giveMana(amount, PlayerResourceUpdateEvent.UpdateReason.REGENERATION), + (data, amount) -> data.giveMana(amount, PlayerResourceUpdateEvent.UpdateReason.COMMAND), + (data, amount) -> data.giveMana(-amount, PlayerResourceUpdateEvent.UpdateReason.COMMAND), + (data, amount) -> data.setMana(amount)), - STAMINA(StatType.STAMINA_REGENERATION, ClassOption.OFF_COMBAT_STAMINA_REGEN, - PlayerData::getStamina, - data -> data.getStats().getStat(StatType.MAX_STAMINA), - (data, amount) -> data.giveStamina(amount, PlayerResourceUpdateEvent.UpdateReason.REGENERATION), - (data, amount) -> data.giveStamina(amount, PlayerResourceUpdateEvent.UpdateReason.COMMAND), - (data, amount) -> data.giveStamina(-amount, PlayerResourceUpdateEvent.UpdateReason.COMMAND), - (data, amount) -> data.setStamina(amount)), + STAMINA(PlayerData::getStamina, + data -> data.getStats().getStat(StatType.MAX_STAMINA), + (data, amount) -> data.giveStamina(amount, PlayerResourceUpdateEvent.UpdateReason.REGENERATION), + (data, amount) -> data.giveStamina(amount, PlayerResourceUpdateEvent.UpdateReason.COMMAND), + (data, amount) -> data.giveStamina(-amount, PlayerResourceUpdateEvent.UpdateReason.COMMAND), + (data, amount) -> data.setStamina(amount)), - STELLIUM(StatType.STELLIUM_REGENERATION, ClassOption.OFF_COMBAT_STELLIUM_REGEN, - PlayerData::getStellium, - data -> data.getStats().getStat(StatType.MAX_STELLIUM), - (data, amount) -> data.giveStellium(amount, PlayerResourceUpdateEvent.UpdateReason.REGENERATION), - (data, amount) -> data.giveStellium(amount, PlayerResourceUpdateEvent.UpdateReason.COMMAND), - (data, amount) -> data.giveStellium(-amount, PlayerResourceUpdateEvent.UpdateReason.COMMAND), - (data, amount) -> data.setStellium(amount)); + STELLIUM(PlayerData::getStellium, + data -> data.getStats().getStat(StatType.MAX_STELLIUM), + (data, amount) -> data.giveStellium(amount, PlayerResourceUpdateEvent.UpdateReason.REGENERATION), + (data, amount) -> data.giveStellium(amount, PlayerResourceUpdateEvent.UpdateReason.COMMAND), + (data, amount) -> data.giveStellium(-amount, PlayerResourceUpdateEvent.UpdateReason.COMMAND), + (data, amount) -> data.setStellium(amount)); - private final StatType regenStat; - private final ClassOption offCombatRegen; - private final Function current, max; - private final BiConsumer regen; + private final StatType regenStat, maxRegenStat; + private final ClassOption offCombatRegen; + private final Function current, max; + private final BiConsumer regen; - // Used for MMOCore commands - private final BiConsumer set, give, take; + // Used for MMOCore commands + private final BiConsumer set, give, take; - PlayerResource(StatType regenStat, ClassOption offCombatRegen, - Function current, - Function max, - BiConsumer regen, - BiConsumer give, - BiConsumer take, - BiConsumer set) { - this.regenStat = regenStat; - this.offCombatRegen = offCombatRegen; - this.current = current; - this.max = max; - this.regen = regen; - this.give = give; - this.take = take; - this.set = set; - } + PlayerResource(Function current, + Function max, + BiConsumer regen, + BiConsumer give, + BiConsumer take, + BiConsumer set) { + this.regenStat = StatType.valueOf(name() + "_REGENERATION"); + this.maxRegenStat = StatType.valueOf("MAX_" + name() + "_REGENERATION"); + this.offCombatRegen = ClassOption.valueOf("OFF_COMBAT_" + name() + "_REGEN"); + this.current = current; + this.max = max; + this.regen = regen; + this.give = give; + this.take = take; + this.set = set; + } - /** - * @return Stat which corresponds to resource regeneration - */ - public StatType getRegenStat() { - return regenStat; - } + /** + * @return Stat which corresponds to flat resource regeneration + */ + public StatType getRegenStat() { + return regenStat; + } - /** - * @return Class option which determines whether or not resource should be - * regenerated off combat only - */ - public ClassOption getOffCombatRegen() { - return offCombatRegen; - } + /** + * @return Stat which corresponds to resource regeneration scaling with the player's max health + */ + public StatType getMaxRegenStat() { + return maxRegenStat; + } - /** - * @return Current resource of the given player - */ - public double getCurrent(PlayerData player) { - return current.apply(player); - } + /** + * @return Class option which determines whether or not resource should be + * regenerated off combat only + */ + public ClassOption getOffCombatRegen() { + return offCombatRegen; + } - /** - * @return Max amount of that resource of the given player - */ - public double getMax(PlayerData player) { - return max.apply(player); - } + /** + * @return Current resource of the given player + */ + public double getCurrent(PlayerData player) { + return current.apply(player); + } - /** - * Regens a player resource. Whatever resource, a bukkit event is triggered - * - * @param player Player to regen - * @param amount Amount to regen - */ - public void regen(PlayerData player, double amount) { - regen.accept(player, amount); - } + /** + * @return Max amount of that resource of the given player + */ + public double getMax(PlayerData player) { + return max.apply(player); + } - /** - * Used by MMOCore admin commands here: {@link net.Indyuce.mmocore.command.rpg.admin.ResourceCommandTreeNode} - */ - public BiConsumer getConsumer(ManaTrigger.Operation operation) { - switch (operation) { - case SET: - return set; - case TAKE: - return take; - case GIVE: - return give; - default: - throw new IllegalArgumentException("Operation cannot be null"); - } - } + /** + * Regens a player resource. Whatever resource, a bukkit event is triggered + * + * @param player Player to regen + * @param amount Amount to regen + */ + public void regen(PlayerData player, double amount) { + regen.accept(player, amount); + } + + /** + * Used by MMOCore admin commands here: {@link net.Indyuce.mmocore.command.rpg.admin.ResourceCommandTreeNode} + */ + public BiConsumer getConsumer(ManaTrigger.Operation operation) { + switch (operation) { + case SET: + return set; + case TAKE: + return take; + case GIVE: + return give; + default: + throw new IllegalArgumentException("Operation cannot be null"); + } + } } diff --git a/src/main/java/net/Indyuce/mmocore/api/player/profess/resource/ResourceHandler.java b/src/main/java/net/Indyuce/mmocore/api/player/profess/resource/ResourceHandler.java deleted file mode 100644 index 0dd2ccf0..00000000 --- a/src/main/java/net/Indyuce/mmocore/api/player/profess/resource/ResourceHandler.java +++ /dev/null @@ -1,100 +0,0 @@ -package net.Indyuce.mmocore.api.player.profess.resource; - -import java.util.function.BiFunction; - -import org.apache.commons.lang.Validate; -import org.bukkit.configuration.ConfigurationSection; - -import net.Indyuce.mmocore.api.player.PlayerData; -import net.Indyuce.mmocore.api.util.math.formula.LinearValue; - -public class ResourceHandler { - - /** - * Resource should only regenerate when the player is out of combat - */ - private final boolean offCombatOnly; - - /** - * Percentage of scaling which the player regenerates every second - */ - private final LinearValue scalar; - - /** - * Whether the resource regeneration scales on missing or max resource. if - * TYPE is null, then there is no special regeneration. - */ - private final HandlerType type; - private final PlayerResource resource; - - /** - * Used when there is no special resource regeneration - */ - public ResourceHandler(PlayerResource resource) { - this(resource, null, null, false); - } - - public ResourceHandler(PlayerResource resource, ConfigurationSection config) { - this.resource = resource; - offCombatOnly = config.getBoolean("off-combat"); - - Validate.isTrue(config.contains("type"), "Could not find resource regen scaling type"); - type = HandlerType.valueOf(config.getString("type").toUpperCase()); - - Validate.notNull(config.getConfigurationSection("value"), "Could not find resource regen value config section"); - scalar = new LinearValue(config.getConfigurationSection("value")); - } - - public ResourceHandler(PlayerResource resource, HandlerType type, LinearValue scalar, boolean offCombatOnly) { - this.resource = resource; - this.type = type; - this.scalar = scalar; - this.offCombatOnly = offCombatOnly; - } - - /** - * Apply regeneration formulas: first calculates base resource regen due to - * the player stats and then apply the special resource regeneration due to - * the player class - * - * @param player - * Player regenerating - * @return The amount of resource which should be regenerated EVERY SECOND - */ - public double getRegen(PlayerData player) { - double d = 0; - - // base resource regeneration = value of the corresponding regen stat - if (!player.isInCombat() || !player.getProfess().hasOption(resource.getOffCombatRegen())) - d += player.getStats().getStat(resource.getRegenStat()); - - // extra resource regeneration based on CLASS, scales on LEVEL - if (type != null && (!player.isInCombat() || !offCombatOnly)) - d = this.scalar.calculate(player.getLevel()) / 100 * type.getScaling(player, resource); - - return d; - } - - public enum HandlerType { - - /** - * Resource regeneration scales on max resource - */ - MAX((player, resource) -> resource.getMax(player)), - - /** - * Resource regeneration scales on missing resource - */ - MISSING((player, resource) -> resource.getMax(player) - resource.getCurrent(player)); - - private final BiFunction calculation; - - HandlerType(BiFunction calculation) { - this.calculation = calculation; - } - - public double getScaling(PlayerData player, PlayerResource resource) { - return calculation.apply(player, resource); - } - } -} diff --git a/src/main/java/net/Indyuce/mmocore/api/player/profess/resource/ResourceRegeneration.java b/src/main/java/net/Indyuce/mmocore/api/player/profess/resource/ResourceRegeneration.java new file mode 100644 index 00000000..071fe4b7 --- /dev/null +++ b/src/main/java/net/Indyuce/mmocore/api/player/profess/resource/ResourceRegeneration.java @@ -0,0 +1,103 @@ +package net.Indyuce.mmocore.api.player.profess.resource; + +import net.Indyuce.mmocore.api.player.PlayerData; +import net.Indyuce.mmocore.api.util.math.formula.LinearValue; +import org.apache.commons.lang.Validate; +import org.bukkit.configuration.ConfigurationSection; + +import java.util.function.BiFunction; + +public class ResourceRegeneration { + + /** + * Resource should only regenerate when the player is out of combat + */ + private final boolean offCombatOnly; + + /** + * Percentage of scaling which the player regenerates every second + */ + private final LinearValue scalar; + + /** + * Whether the resource regeneration scales on missing or max resource. if + * TYPE is null, then there is no special regeneration. + */ + private final HandlerType type; + private final PlayerResource resource; + + /** + * Used when there is no special resource regeneration + */ + public ResourceRegeneration(PlayerResource resource) { + this(resource, null, null, false); + } + + public ResourceRegeneration(PlayerResource resource, ConfigurationSection config) { + this.resource = resource; + offCombatOnly = config.getBoolean("off-combat"); + + Validate.isTrue(config.contains("type"), "Could not find resource regen scaling type"); + type = HandlerType.valueOf(config.getString("type").toUpperCase()); + + Validate.notNull(config.getConfigurationSection("value"), "Could not find resource regen value config section"); + scalar = new LinearValue(config.getConfigurationSection("value")); + } + + public ResourceRegeneration(PlayerResource resource, HandlerType type, LinearValue scalar, boolean offCombatOnly) { + this.resource = resource; + this.type = type; + this.scalar = scalar; + this.offCombatOnly = offCombatOnly; + } + + /** + * Apply regeneration formulas: first calculates base resource regen due to + * the player stats and then apply the special resource regeneration due to + * the player class + * + * @param player Player regenerating + * @return The amount of resource which should be regenerated EVERY SECOND + */ + public double getRegen(PlayerData player) { + double d = 0; + + if (!player.isInCombat() || !player.getProfess().hasOption(resource.getOffCombatRegen())) { + + // Flat resource regeneration + d += player.getStats().getStat(resource.getRegenStat()); + + // Component which scales with max resource + d += player.getStats().getStat(resource.getMaxRegenStat()) / 100 * resource.getMax(player); + } + + // Special resource regeneration + if (type != null && (!player.isInCombat() || !offCombatOnly)) + d += this.scalar.calculate(player.getLevel()) / 100 * type.getScaling(player, resource); + + return d; + } + + public enum HandlerType { + + /** + * Resource regeneration scales on max resource + */ + MAX((player, resource) -> resource.getMax(player)), + + /** + * Resource regeneration scales on missing resource + */ + MISSING((player, resource) -> resource.getMax(player) - resource.getCurrent(player)); + + private final BiFunction calculation; + + HandlerType(BiFunction calculation) { + this.calculation = calculation; + } + + public double getScaling(PlayerData player, PlayerResource resource) { + return calculation.apply(player, resource); + } + } +} diff --git a/src/main/java/net/Indyuce/mmocore/api/player/stats/StatType.java b/src/main/java/net/Indyuce/mmocore/api/player/stats/StatType.java index 1e82fe23..99c0c245 100644 --- a/src/main/java/net/Indyuce/mmocore/api/player/stats/StatType.java +++ b/src/main/java/net/Indyuce/mmocore/api/player/stats/StatType.java @@ -1,130 +1,160 @@ package net.Indyuce.mmocore.api.player.stats; +import io.lumine.mythic.lib.MythicLib; import net.Indyuce.mmocore.MMOCore; import net.Indyuce.mmocore.api.ConfigFile; -import net.Indyuce.mmocore.experience.Profession; import net.Indyuce.mmocore.api.util.math.formula.LinearValue; -import io.lumine.mythic.lib.MythicLib; +import net.Indyuce.mmocore.experience.Profession; import org.bukkit.configuration.file.FileConfiguration; import java.text.DecimalFormat; public enum StatType { - ATTACK_DAMAGE, - ATTACK_SPEED, - MAX_HEALTH, - HEALTH_REGENERATION, + // Vanilla stats + ATTACK_DAMAGE, + ATTACK_SPEED, + MAX_HEALTH, + HEALTH_REGENERATION, + MAX_HEALTH_REGENERATION, - MOVEMENT_SPEED, - SPEED_MALUS_REDUCTION, - KNOCKBACK_RESISTANCE, + // Misc + MOVEMENT_SPEED, + SPEED_MALUS_REDUCTION, + KNOCKBACK_RESISTANCE, - MAX_MANA, - MAX_STAMINA, - MAX_STELLIUM, - MANA_REGENERATION, - STAMINA_REGENERATION, - STELLIUM_REGENERATION, + // Mana + MAX_MANA, + MANA_REGENERATION, + MAX_MANA_REGENERATION, - ARMOR, - ARMOR_TOUGHNESS, + // Stamina + MAX_STAMINA, + STAMINA_REGENERATION, + MAX_STAMINA_REGENERATION, - CRITICAL_STRIKE_CHANCE, - CRITICAL_STRIKE_POWER, - SKILL_CRITICAL_STRIKE_CHANCE, - SKILL_CRITICAL_STRIKE_POWER, + // Stellium + MAX_STELLIUM, + STELLIUM_REGENERATION, + MAX_STELLIUM_REGENERATION, - BLOCK_POWER, - BLOCK_RATING, - BLOCK_COOLDOWN_REDUCTION, - DODGE_RATING, - DODGE_COOLDOWN_REDUCTION, - PARRY_RATING, - PARRY_COOLDOWN_REDUCTION, + // Vanilla armor stats + ARMOR, + ARMOR_TOUGHNESS, - ADDITIONAL_EXPERIENCE, - COOLDOWN_REDUCTION, + // Critical strikes + CRITICAL_STRIKE_CHANCE, + CRITICAL_STRIKE_POWER, + SKILL_CRITICAL_STRIKE_CHANCE, + SKILL_CRITICAL_STRIKE_POWER, - MAGIC_DAMAGE, - PHYSICAL_DAMAGE, - PROJECTILE_DAMAGE, - WEAPON_DAMAGE, - SKILL_DAMAGE, - UNDEAD_DAMAGE, + // Mitigation + DEFENSE, + BLOCK_POWER, + BLOCK_RATING, + BLOCK_COOLDOWN_REDUCTION, + DODGE_RATING, + DODGE_COOLDOWN_REDUCTION, + PARRY_RATING, + PARRY_COOLDOWN_REDUCTION, - PVP_DAMAGE, - PVE_DAMAGE, + // Utility + ADDITIONAL_EXPERIENCE, + COOLDOWN_REDUCTION, - DEFENSE, - DAMAGE_REDUCTION, - MAGIC_DAMAGE_REDUCTION, - PHYSICAL_DAMAGE_REDUCTION, - PROJECTILE_DAMAGE_REDUCTION, - WEAPON_DAMAGE_REDUCTION, - SKILL_DAMAGE_REDUCTION, + // Damage-type based stats + MAGIC_DAMAGE, + PHYSICAL_DAMAGE, + PROJECTILE_DAMAGE, + WEAPON_DAMAGE, + SKILL_DAMAGE, + UNDEAD_DAMAGE, - // reduces amount of tugs needed to fish - FISHING_STRENGTH("fishing"), + // Misc damage stats + PVP_DAMAGE, + PVE_DAMAGE, - // chance of instant success when fishing - CRITICAL_FISHING_CHANCE("fishing"), + // Damage reduction stats + DAMAGE_REDUCTION, + MAGIC_DAMAGE_REDUCTION, + PHYSICAL_DAMAGE_REDUCTION, + PROJECTILE_DAMAGE_REDUCTION, + WEAPON_DAMAGE_REDUCTION, + SKILL_DAMAGE_REDUCTION, - // chance of crit fishing failure - CRITICAL_FISHING_FAILURE_CHANCE("fishing"), + /** + * Reduces amount of tugs needed to fish + */ + FISHING_STRENGTH("fishing"), - // chance of dropping more minerals when mining. - FORTUNE, + /** + * Chance of instant success when fishing + */ + CRITICAL_FISHING_CHANCE("fishing"), - // get haste when mining blocks. - GATHERING_HASTE, + /** + * Chance of crit fishing failure + */ + CRITICAL_FISHING_FAILURE_CHANCE("fishing"), - // chance of getting more crops when farming - LUCK_OF_THE_FIELD; + /** + * Chance of dropping more minerals when mining. + */ + FORTUNE, - private String profession; + /** + * Get haste when mining blocks. + */ + GATHERING_HASTE, - private LinearValue defaultInfo; - private DecimalFormat format; + /** + * Chance of getting more crops when farming + */ + LUCK_OF_THE_FIELD; - StatType() { - // completely custom stat. - } + private String profession; - @SuppressWarnings("SameParameterValue") - StatType(String profession) { - this.profession = profession; - } + private LinearValue defaultInfo; + private DecimalFormat format; - public String getProfession() { - return profession; - } + StatType() { + // Completely custom stat + } - public Profession findProfession() { - return MMOCore.plugin.professionManager.get(profession); - } + @SuppressWarnings("SameParameterValue") + StatType(String profession) { + this.profession = profession; + } - public boolean hasProfession() { - return profession != null; - } + public String getProfession() { + return profession; + } - public LinearValue getDefault() { - return defaultInfo; - } + public Profession findProfession() { + return MMOCore.plugin.professionManager.get(profession); + } - public boolean matches(Profession profession) { - return this.profession != null && this.profession.equals(profession.getId()); - } + public boolean hasProfession() { + return profession != null; + } - public String format(double value) { - return format.format(value); - } + public LinearValue getDefault() { + return defaultInfo; + } - public static void load() { - FileConfiguration config = new ConfigFile("stats").getConfig(); - for (StatType stat : values()) { - stat.defaultInfo = config.contains("default." + stat.name()) ? new LinearValue(config.getConfigurationSection("default." + stat.name())) : new LinearValue(0, 0); - stat.format = MythicLib.plugin.getMMOConfig().newFormat(config.contains("decimal-format." + stat.name()) ? config.getString("decimal-format." + stat.name()) : "0.#"); - } - } + public boolean matches(Profession profession) { + return this.profession != null && this.profession.equals(profession.getId()); + } + + public String format(double value) { + return format.format(value); + } + + public static void load() { + FileConfiguration config = new ConfigFile("stats").getConfig(); + for (StatType stat : values()) { + stat.defaultInfo = config.contains("default." + stat.name()) ? new LinearValue(config.getConfigurationSection("default." + stat.name())) : new LinearValue(0, 0); + stat.format = MythicLib.plugin.getMMOConfig().newFormat(config.contains("decimal-format." + stat.name()) ? config.getString("decimal-format." + stat.name()) : "0.#"); + } + } }