lineage2/l2j_mobius
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Simple arrays for balancer configurations.

Browse Source
This commit is contained in:
MobiusDevelopment
2020-06-21 00:54:31 +00:00
parent 169df4d6fc
commit 4379cad634
105 changed files with 2055 additions and 2070 deletions
Download Patch File Download Diff File Expand all files Collapse all files

217
L2J_Mobius_2.5_Underground/java/org/l2jmobius/Config.java
View File

@ -43,7 +43,6 @@ import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.regex.Pattern;
@ -1124,42 +1123,42 @@ public class Config
public static String TITLE_FOR_PVP_AMOUNT4;
public static String TITLE_FOR_PVP_AMOUNT5;
public static boolean CHAT_ADMIN;
public static Map<ClassId, Float> PVE_MAGICAL_SKILL_DAMAGE_MULTIPLIERS = new ConcurrentHashMap<>();
public static Map<ClassId, Float> PVP_MAGICAL_SKILL_DAMAGE_MULTIPLIERS = new ConcurrentHashMap<>();
public static Map<ClassId, Float> PVE_MAGICAL_SKILL_DEFENCE_MULTIPLIERS = new ConcurrentHashMap<>();
public static Map<ClassId, Float> PVP_MAGICAL_SKILL_DEFENCE_MULTIPLIERS = new ConcurrentHashMap<>();
public static Map<ClassId, Float> PVE_MAGICAL_SKILL_CRITICAL_CHANCE_MULTIPLIERS = new ConcurrentHashMap<>();
public static Map<ClassId, Float> PVP_MAGICAL_SKILL_CRITICAL_CHANCE_MULTIPLIERS = new ConcurrentHashMap<>();
public static Map<ClassId, Float> PVE_MAGICAL_SKILL_CRITICAL_DAMAGE_MULTIPLIERS = new ConcurrentHashMap<>();
public static Map<ClassId, Float> PVP_MAGICAL_SKILL_CRITICAL_DAMAGE_MULTIPLIERS = new ConcurrentHashMap<>();
public static Map<ClassId, Float> PVE_PHYSICAL_SKILL_DAMAGE_MULTIPLIERS = new ConcurrentHashMap<>();
public static Map<ClassId, Float> PVP_PHYSICAL_SKILL_DAMAGE_MULTIPLIERS = new ConcurrentHashMap<>();
public static Map<ClassId, Float> PVE_PHYSICAL_SKILL_DEFENCE_MULTIPLIERS = new ConcurrentHashMap<>();
public static Map<ClassId, Float> PVP_PHYSICAL_SKILL_DEFENCE_MULTIPLIERS = new ConcurrentHashMap<>();
public static Map<ClassId, Float> PVE_PHYSICAL_SKILL_CRITICAL_CHANCE_MULTIPLIERS = new ConcurrentHashMap<>();
public static Map<ClassId, Float> PVP_PHYSICAL_SKILL_CRITICAL_CHANCE_MULTIPLIERS = new ConcurrentHashMap<>();
public static Map<ClassId, Float> PVE_PHYSICAL_SKILL_CRITICAL_DAMAGE_MULTIPLIERS = new ConcurrentHashMap<>();
public static Map<ClassId, Float> PVP_PHYSICAL_SKILL_CRITICAL_DAMAGE_MULTIPLIERS = new ConcurrentHashMap<>();
public static Map<ClassId, Float> PVE_PHYSICAL_ATTACK_DAMAGE_MULTIPLIERS = new ConcurrentHashMap<>();
public static Map<ClassId, Float> PVP_PHYSICAL_ATTACK_DAMAGE_MULTIPLIERS = new ConcurrentHashMap<>();
public static Map<ClassId, Float> PVE_PHYSICAL_ATTACK_DEFENCE_MULTIPLIERS = new ConcurrentHashMap<>();
public static Map<ClassId, Float> PVP_PHYSICAL_ATTACK_DEFENCE_MULTIPLIERS = new ConcurrentHashMap<>();
public static Map<ClassId, Float> PVE_PHYSICAL_ATTACK_CRITICAL_CHANCE_MULTIPLIERS = new ConcurrentHashMap<>();
public static Map<ClassId, Float> PVP_PHYSICAL_ATTACK_CRITICAL_CHANCE_MULTIPLIERS = new ConcurrentHashMap<>();
public static Map<ClassId, Float> PVE_PHYSICAL_ATTACK_CRITICAL_DAMAGE_MULTIPLIERS = new ConcurrentHashMap<>();
public static Map<ClassId, Float> PVP_PHYSICAL_ATTACK_CRITICAL_DAMAGE_MULTIPLIERS = new ConcurrentHashMap<>();
public static Map<ClassId, Float> PVE_BLOW_SKILL_DAMAGE_MULTIPLIERS = new ConcurrentHashMap<>();
public static Map<ClassId, Float> PVP_BLOW_SKILL_DAMAGE_MULTIPLIERS = new ConcurrentHashMap<>();
public static Map<ClassId, Float> PVE_BLOW_SKILL_DEFENCE_MULTIPLIERS = new ConcurrentHashMap<>();
public static Map<ClassId, Float> PVP_BLOW_SKILL_DEFENCE_MULTIPLIERS = new ConcurrentHashMap<>();
public static Map<ClassId, Float> PVE_ENERGY_SKILL_DAMAGE_MULTIPLIERS = new ConcurrentHashMap<>();
public static Map<ClassId, Float> PVP_ENERGY_SKILL_DAMAGE_MULTIPLIERS = new ConcurrentHashMap<>();
public static Map<ClassId, Float> PVE_ENERGY_SKILL_DEFENCE_MULTIPLIERS = new ConcurrentHashMap<>();
public static Map<ClassId, Float> PVP_ENERGY_SKILL_DEFENCE_MULTIPLIERS = new ConcurrentHashMap<>();
public static Map<ClassId, Float> PLAYER_HEALING_SKILL_MULTIPLIERS = new ConcurrentHashMap<>();
public static Map<ClassId, Float> SKILL_MASTERY_CHANCE_MULTIPLIERS = new ConcurrentHashMap<>();
public static Map<ClassId, Float> EXP_AMOUNT_MULTIPLIERS = new ConcurrentHashMap<>();
public static Map<ClassId, Float> SP_AMOUNT_MULTIPLIERS = new ConcurrentHashMap<>();
public static float[] PVE_MAGICAL_SKILL_DAMAGE_MULTIPLIERS = new float[190];
public static float[] PVP_MAGICAL_SKILL_DAMAGE_MULTIPLIERS = new float[190];
public static float[] PVE_MAGICAL_SKILL_DEFENCE_MULTIPLIERS = new float[190];
public static float[] PVP_MAGICAL_SKILL_DEFENCE_MULTIPLIERS = new float[190];
public static float[] PVE_MAGICAL_SKILL_CRITICAL_CHANCE_MULTIPLIERS = new float[190];
public static float[] PVP_MAGICAL_SKILL_CRITICAL_CHANCE_MULTIPLIERS = new float[190];
public static float[] PVE_MAGICAL_SKILL_CRITICAL_DAMAGE_MULTIPLIERS = new float[190];
public static float[] PVP_MAGICAL_SKILL_CRITICAL_DAMAGE_MULTIPLIERS = new float[190];
public static float[] PVE_PHYSICAL_SKILL_DAMAGE_MULTIPLIERS = new float[190];
public static float[] PVP_PHYSICAL_SKILL_DAMAGE_MULTIPLIERS = new float[190];
public static float[] PVE_PHYSICAL_SKILL_DEFENCE_MULTIPLIERS = new float[190];
public static float[] PVP_PHYSICAL_SKILL_DEFENCE_MULTIPLIERS = new float[190];
public static float[] PVE_PHYSICAL_SKILL_CRITICAL_CHANCE_MULTIPLIERS = new float[190];
public static float[] PVP_PHYSICAL_SKILL_CRITICAL_CHANCE_MULTIPLIERS = new float[190];
public static float[] PVE_PHYSICAL_SKILL_CRITICAL_DAMAGE_MULTIPLIERS = new float[190];
public static float[] PVP_PHYSICAL_SKILL_CRITICAL_DAMAGE_MULTIPLIERS = new float[190];
public static float[] PVE_PHYSICAL_ATTACK_DAMAGE_MULTIPLIERS = new float[190];
public static float[] PVP_PHYSICAL_ATTACK_DAMAGE_MULTIPLIERS = new float[190];
public static float[] PVE_PHYSICAL_ATTACK_DEFENCE_MULTIPLIERS = new float[190];
public static float[] PVP_PHYSICAL_ATTACK_DEFENCE_MULTIPLIERS = new float[190];
public static float[] PVE_PHYSICAL_ATTACK_CRITICAL_CHANCE_MULTIPLIERS = new float[190];
public static float[] PVP_PHYSICAL_ATTACK_CRITICAL_CHANCE_MULTIPLIERS = new float[190];
public static float[] PVE_PHYSICAL_ATTACK_CRITICAL_DAMAGE_MULTIPLIERS = new float[190];
public static float[] PVP_PHYSICAL_ATTACK_CRITICAL_DAMAGE_MULTIPLIERS = new float[190];
public static float[] PVE_BLOW_SKILL_DAMAGE_MULTIPLIERS = new float[190];
public static float[] PVP_BLOW_SKILL_DAMAGE_MULTIPLIERS = new float[190];
public static float[] PVE_BLOW_SKILL_DEFENCE_MULTIPLIERS = new float[190];
public static float[] PVP_BLOW_SKILL_DEFENCE_MULTIPLIERS = new float[190];
public static float[] PVE_ENERGY_SKILL_DAMAGE_MULTIPLIERS = new float[190];
public static float[] PVP_ENERGY_SKILL_DAMAGE_MULTIPLIERS = new float[190];
public static float[] PVE_ENERGY_SKILL_DEFENCE_MULTIPLIERS = new float[190];
public static float[] PVP_ENERGY_SKILL_DEFENCE_MULTIPLIERS = new float[190];
public static float[] PLAYER_HEALING_SKILL_MULTIPLIERS = new float[190];
public static float[] SKILL_MASTERY_CHANCE_MULTIPLIERS = new float[190];
public static float[] EXP_AMOUNT_MULTIPLIERS = new float[190];
public static float[] SP_AMOUNT_MULTIPLIERS = new float[190];
public static boolean MULTILANG_ENABLE;
public static List<String> MULTILANG_ALLOWED = new ArrayList<>();
public static String MULTILANG_DEFAULT;
@ -2592,8 +2591,8 @@ public class Config
// Load ClassBalance config file (if exists)
final PropertiesParser ClassBalance = new PropertiesParser(CUSTOM_CLASS_BALANCE_CONFIG_FILE);
Arrays.fill(PVE_MAGICAL_SKILL_DAMAGE_MULTIPLIERS, 1f);
final String[] pveMagicalSkillDamageMultipliers = ClassBalance.getString("PveMagicalSkillDamageMultipliers", "").trim().split(";");
PVE_MAGICAL_SKILL_DAMAGE_MULTIPLIERS.clear();
if (pveMagicalSkillDamageMultipliers.length > 0)
{
for (String info : pveMagicalSkillDamageMultipliers)
@ -2602,12 +2601,12 @@ public class Config
if (classInfo.length == 2)
{
final String id = classInfo[0].trim();
PVE_MAGICAL_SKILL_DAMAGE_MULTIPLIERS.put(Util.isDigit(id) ? ClassId.getClassId(Integer.parseInt(id)) : Enum.valueOf(ClassId.class, id), Float.parseFloat(classInfo[1].trim()));
PVE_MAGICAL_SKILL_DAMAGE_MULTIPLIERS[Util.isDigit(id) ? Integer.parseInt(id) : Enum.valueOf(ClassId.class, id).getId()] = Float.parseFloat(classInfo[1].trim());
}
}
}
Arrays.fill(PVP_MAGICAL_SKILL_DAMAGE_MULTIPLIERS, 1f);
final String[] pvpMagicalSkillDamageMultipliers = ClassBalance.getString("PvpMagicalSkillDamageMultipliers", "").trim().split(";");
PVP_MAGICAL_SKILL_DAMAGE_MULTIPLIERS.clear();
if (pvpMagicalSkillDamageMultipliers.length > 0)
{
for (String info : pvpMagicalSkillDamageMultipliers)
@ -2616,12 +2615,12 @@ public class Config
if (classInfo.length == 2)
{
final String id = classInfo[0].trim();
PVP_MAGICAL_SKILL_DAMAGE_MULTIPLIERS.put(Util.isDigit(id) ? ClassId.getClassId(Integer.parseInt(id)) : Enum.valueOf(ClassId.class, id), Float.parseFloat(classInfo[1].trim()));
PVP_MAGICAL_SKILL_DAMAGE_MULTIPLIERS[Util.isDigit(id) ? Integer.parseInt(id) : Enum.valueOf(ClassId.class, id).getId()] = Float.parseFloat(classInfo[1].trim());
}
}
}
Arrays.fill(PVE_MAGICAL_SKILL_DEFENCE_MULTIPLIERS, 1f);
final String[] pveMagicalSkillDefenceMultipliers = ClassBalance.getString("PveMagicalSkillDefenceMultipliers", "").trim().split(";");
PVE_MAGICAL_SKILL_DEFENCE_MULTIPLIERS.clear();
if (pveMagicalSkillDefenceMultipliers.length > 0)
{
for (String info : pveMagicalSkillDefenceMultipliers)
@ -2630,12 +2629,12 @@ public class Config
if (classInfo.length == 2)
{
final String id = classInfo[0].trim();
PVE_MAGICAL_SKILL_DEFENCE_MULTIPLIERS.put(Util.isDigit(id) ? ClassId.getClassId(Integer.parseInt(id)) : Enum.valueOf(ClassId.class, id), Float.parseFloat(classInfo[1].trim()));
PVE_MAGICAL_SKILL_DEFENCE_MULTIPLIERS[Util.isDigit(id) ? Integer.parseInt(id) : Enum.valueOf(ClassId.class, id).getId()] = Float.parseFloat(classInfo[1].trim());
}
}
}
Arrays.fill(PVP_MAGICAL_SKILL_DEFENCE_MULTIPLIERS, 1f);
final String[] pvpMagicalSkillDefenceMultipliers = ClassBalance.getString("PvpMagicalSkillDefenceMultipliers", "").trim().split(";");
PVP_MAGICAL_SKILL_DEFENCE_MULTIPLIERS.clear();
if (pvpMagicalSkillDefenceMultipliers.length > 0)
{
for (String info : pvpMagicalSkillDefenceMultipliers)
@ -2644,12 +2643,12 @@ public class Config
if (classInfo.length == 2)
{
final String id = classInfo[0].trim();
PVP_MAGICAL_SKILL_DEFENCE_MULTIPLIERS.put(Util.isDigit(id) ? ClassId.getClassId(Integer.parseInt(id)) : Enum.valueOf(ClassId.class, id), Float.parseFloat(classInfo[1].trim()));
PVP_MAGICAL_SKILL_DEFENCE_MULTIPLIERS[Util.isDigit(id) ? Integer.parseInt(id) : Enum.valueOf(ClassId.class, id).getId()] = Float.parseFloat(classInfo[1].trim());
}
}
}
Arrays.fill(PVE_MAGICAL_SKILL_CRITICAL_CHANCE_MULTIPLIERS, 1f);
final String[] pveMagicalSkillCriticalChanceMultipliers = ClassBalance.getString("PveMagicalSkillCriticalChanceMultipliers", "").trim().split(";");
PVE_MAGICAL_SKILL_CRITICAL_CHANCE_MULTIPLIERS.clear();
if (pveMagicalSkillCriticalChanceMultipliers.length > 0)
{
for (String info : pveMagicalSkillCriticalChanceMultipliers)
@ -2658,12 +2657,12 @@ public class Config
if (classInfo.length == 2)
{
final String id = classInfo[0].trim();
PVE_MAGICAL_SKILL_CRITICAL_CHANCE_MULTIPLIERS.put(Util.isDigit(id) ? ClassId.getClassId(Integer.parseInt(id)) : Enum.valueOf(ClassId.class, id), Float.parseFloat(classInfo[1].trim()));
PVE_MAGICAL_SKILL_CRITICAL_CHANCE_MULTIPLIERS[Util.isDigit(id) ? Integer.parseInt(id) : Enum.valueOf(ClassId.class, id).getId()] = Float.parseFloat(classInfo[1].trim());
}
}
}
Arrays.fill(PVP_MAGICAL_SKILL_CRITICAL_CHANCE_MULTIPLIERS, 1f);
final String[] pvpMagicalSkillCriticalChanceMultipliers = ClassBalance.getString("PvpMagicalSkillCriticalChanceMultipliers", "").trim().split(";");
PVP_MAGICAL_SKILL_CRITICAL_CHANCE_MULTIPLIERS.clear();
if (pvpMagicalSkillCriticalChanceMultipliers.length > 0)
{
for (String info : pvpMagicalSkillCriticalChanceMultipliers)
@ -2672,12 +2671,12 @@ public class Config
if (classInfo.length == 2)
{
final String id = classInfo[0].trim();
PVP_MAGICAL_SKILL_CRITICAL_CHANCE_MULTIPLIERS.put(Util.isDigit(id) ? ClassId.getClassId(Integer.parseInt(id)) : Enum.valueOf(ClassId.class, id), Float.parseFloat(classInfo[1].trim()));
PVP_MAGICAL_SKILL_CRITICAL_CHANCE_MULTIPLIERS[Util.isDigit(id) ? Integer.parseInt(id) : Enum.valueOf(ClassId.class, id).getId()] = Float.parseFloat(classInfo[1].trim());
}
}
}
Arrays.fill(PVE_MAGICAL_SKILL_CRITICAL_DAMAGE_MULTIPLIERS, 1f);
final String[] pveMagicalSkillCriticalDamageMultipliers = ClassBalance.getString("PveMagicalSkillCriticalDamageMultipliers", "").trim().split(";");
PVE_MAGICAL_SKILL_CRITICAL_DAMAGE_MULTIPLIERS.clear();
if (pveMagicalSkillCriticalDamageMultipliers.length > 0)
{
for (String info : pveMagicalSkillCriticalDamageMultipliers)
@ -2686,12 +2685,12 @@ public class Config
if (classInfo.length == 2)
{
final String id = classInfo[0].trim();
PVE_MAGICAL_SKILL_CRITICAL_DAMAGE_MULTIPLIERS.put(Util.isDigit(id) ? ClassId.getClassId(Integer.parseInt(id)) : Enum.valueOf(ClassId.class, id), Float.parseFloat(classInfo[1].trim()));
PVE_MAGICAL_SKILL_CRITICAL_DAMAGE_MULTIPLIERS[Util.isDigit(id) ? Integer.parseInt(id) : Enum.valueOf(ClassId.class, id).getId()] = Float.parseFloat(classInfo[1].trim());
}
}
}
Arrays.fill(PVP_MAGICAL_SKILL_CRITICAL_DAMAGE_MULTIPLIERS, 1f);
final String[] pvpMagicalSkillCriticalDamageMultipliers = ClassBalance.getString("PvpMagicalSkillCriticalDamageMultipliers", "").trim().split(";");
PVP_MAGICAL_SKILL_CRITICAL_DAMAGE_MULTIPLIERS.clear();
if (pvpMagicalSkillCriticalDamageMultipliers.length > 0)
{
for (String info : pvpMagicalSkillCriticalDamageMultipliers)
@ -2700,12 +2699,12 @@ public class Config
if (classInfo.length == 2)
{
final String id = classInfo[0].trim();
PVP_MAGICAL_SKILL_CRITICAL_DAMAGE_MULTIPLIERS.put(Util.isDigit(id) ? ClassId.getClassId(Integer.parseInt(id)) : Enum.valueOf(ClassId.class, id), Float.parseFloat(classInfo[1].trim()));
PVP_MAGICAL_SKILL_CRITICAL_DAMAGE_MULTIPLIERS[Util.isDigit(id) ? Integer.parseInt(id) : Enum.valueOf(ClassId.class, id).getId()] = Float.parseFloat(classInfo[1].trim());
}
}
}
Arrays.fill(PVE_PHYSICAL_SKILL_DAMAGE_MULTIPLIERS, 1f);
final String[] pvePhysicalSkillDamageMultipliers = ClassBalance.getString("PvePhysicalSkillDamageMultipliers", "").trim().split(";");
PVE_PHYSICAL_SKILL_DAMAGE_MULTIPLIERS.clear();
if (pvePhysicalSkillDamageMultipliers.length > 0)
{
for (String info : pvePhysicalSkillDamageMultipliers)
@ -2714,12 +2713,12 @@ public class Config
if (classInfo.length == 2)
{
final String id = classInfo[0].trim();
PVE_PHYSICAL_SKILL_DAMAGE_MULTIPLIERS.put(Util.isDigit(id) ? ClassId.getClassId(Integer.parseInt(id)) : Enum.valueOf(ClassId.class, id), Float.parseFloat(classInfo[1].trim()));
PVE_PHYSICAL_SKILL_DAMAGE_MULTIPLIERS[Util.isDigit(id) ? Integer.parseInt(id) : Enum.valueOf(ClassId.class, id).getId()] = Float.parseFloat(classInfo[1].trim());
}
}
}
Arrays.fill(PVP_PHYSICAL_SKILL_DAMAGE_MULTIPLIERS, 1f);
final String[] pvpPhysicalSkillDamageMultipliers = ClassBalance.getString("PvpPhysicalSkillDamageMultipliers", "").trim().split(";");
PVP_PHYSICAL_SKILL_DAMAGE_MULTIPLIERS.clear();
if (pvpPhysicalSkillDamageMultipliers.length > 0)
{
for (String info : pvpPhysicalSkillDamageMultipliers)
@ -2728,12 +2727,12 @@ public class Config
if (classInfo.length == 2)
{
final String id = classInfo[0].trim();
PVP_PHYSICAL_SKILL_DAMAGE_MULTIPLIERS.put(Util.isDigit(id) ? ClassId.getClassId(Integer.parseInt(id)) : Enum.valueOf(ClassId.class, id), Float.parseFloat(classInfo[1].trim()));
PVP_PHYSICAL_SKILL_DAMAGE_MULTIPLIERS[Util.isDigit(id) ? Integer.parseInt(id) : Enum.valueOf(ClassId.class, id).getId()] = Float.parseFloat(classInfo[1].trim());
}
}
}
Arrays.fill(PVE_PHYSICAL_SKILL_DEFENCE_MULTIPLIERS, 1f);
final String[] pvePhysicalSkillDefenceMultipliers = ClassBalance.getString("PvePhysicalSkillDefenceMultipliers", "").trim().split(";");
PVE_PHYSICAL_SKILL_DEFENCE_MULTIPLIERS.clear();
if (pvePhysicalSkillDefenceMultipliers.length > 0)
{
for (String info : pvePhysicalSkillDefenceMultipliers)
@ -2742,12 +2741,12 @@ public class Config
if (classInfo.length == 2)
{
final String id = classInfo[0].trim();
PVE_PHYSICAL_SKILL_DEFENCE_MULTIPLIERS.put(Util.isDigit(id) ? ClassId.getClassId(Integer.parseInt(id)) : Enum.valueOf(ClassId.class, id), Float.parseFloat(classInfo[1].trim()));
PVE_PHYSICAL_SKILL_DEFENCE_MULTIPLIERS[Util.isDigit(id) ? Integer.parseInt(id) : Enum.valueOf(ClassId.class, id).getId()] = Float.parseFloat(classInfo[1].trim());
}
}
}
Arrays.fill(PVP_PHYSICAL_SKILL_DEFENCE_MULTIPLIERS, 1f);
final String[] pvpPhysicalSkillDefenceMultipliers = ClassBalance.getString("PvpPhysicalSkillDefenceMultipliers", "").trim().split(";");
PVP_PHYSICAL_SKILL_DEFENCE_MULTIPLIERS.clear();
if (pvpPhysicalSkillDefenceMultipliers.length > 0)
{
for (String info : pvpPhysicalSkillDefenceMultipliers)
@ -2756,12 +2755,12 @@ public class Config
if (classInfo.length == 2)
{
final String id = classInfo[0].trim();
PVP_PHYSICAL_SKILL_DEFENCE_MULTIPLIERS.put(Util.isDigit(id) ? ClassId.getClassId(Integer.parseInt(id)) : Enum.valueOf(ClassId.class, id), Float.parseFloat(classInfo[1].trim()));
PVP_PHYSICAL_SKILL_DEFENCE_MULTIPLIERS[Util.isDigit(id) ? Integer.parseInt(id) : Enum.valueOf(ClassId.class, id).getId()] = Float.parseFloat(classInfo[1].trim());
}
}
}
Arrays.fill(PVE_PHYSICAL_SKILL_CRITICAL_CHANCE_MULTIPLIERS, 1f);
final String[] pvePhysicalSkillCriticalChanceMultipliers = ClassBalance.getString("PvePhysicalSkillCriticalChanceMultipliers", "").trim().split(";");
PVE_PHYSICAL_SKILL_CRITICAL_CHANCE_MULTIPLIERS.clear();
if (pvePhysicalSkillCriticalChanceMultipliers.length > 0)
{
for (String info : pvePhysicalSkillCriticalChanceMultipliers)
@ -2770,12 +2769,12 @@ public class Config
if (classInfo.length == 2)
{
final String id = classInfo[0].trim();
PVE_PHYSICAL_SKILL_CRITICAL_CHANCE_MULTIPLIERS.put(Util.isDigit(id) ? ClassId.getClassId(Integer.parseInt(id)) : Enum.valueOf(ClassId.class, id), Float.parseFloat(classInfo[1].trim()));
PVE_PHYSICAL_SKILL_CRITICAL_CHANCE_MULTIPLIERS[Util.isDigit(id) ? Integer.parseInt(id) : Enum.valueOf(ClassId.class, id).getId()] = Float.parseFloat(classInfo[1].trim());
}
}
}
Arrays.fill(PVP_PHYSICAL_SKILL_CRITICAL_CHANCE_MULTIPLIERS, 1f);
final String[] pvpPhysicalSkillCriticalChanceMultipliers = ClassBalance.getString("PvpPhysicalSkillCriticalChanceMultipliers", "").trim().split(";");
PVP_PHYSICAL_SKILL_CRITICAL_CHANCE_MULTIPLIERS.clear();
if (pvpPhysicalSkillCriticalChanceMultipliers.length > 0)
{
for (String info : pvpPhysicalSkillCriticalChanceMultipliers)
@ -2784,12 +2783,12 @@ public class Config
if (classInfo.length == 2)
{
final String id = classInfo[0].trim();
PVP_PHYSICAL_SKILL_CRITICAL_CHANCE_MULTIPLIERS.put(Util.isDigit(id) ? ClassId.getClassId(Integer.parseInt(id)) : Enum.valueOf(ClassId.class, id), Float.parseFloat(classInfo[1].trim()));
PVP_PHYSICAL_SKILL_CRITICAL_CHANCE_MULTIPLIERS[Util.isDigit(id) ? Integer.parseInt(id) : Enum.valueOf(ClassId.class, id).getId()] = Float.parseFloat(classInfo[1].trim());
}
}
}
Arrays.fill(PVE_PHYSICAL_SKILL_CRITICAL_DAMAGE_MULTIPLIERS, 1f);
final String[] pvePhysicalSkillCriticalDamageMultipliers = ClassBalance.getString("PvePhysicalSkillCriticalDamageMultipliers", "").trim().split(";");
PVE_PHYSICAL_SKILL_CRITICAL_DAMAGE_MULTIPLIERS.clear();
if (pvePhysicalSkillCriticalDamageMultipliers.length > 0)
{
for (String info : pvePhysicalSkillCriticalDamageMultipliers)
@ -2798,12 +2797,12 @@ public class Config
if (classInfo.length == 2)
{
final String id = classInfo[0].trim();
PVE_PHYSICAL_SKILL_CRITICAL_DAMAGE_MULTIPLIERS.put(Util.isDigit(id) ? ClassId.getClassId(Integer.parseInt(id)) : Enum.valueOf(ClassId.class, id), Float.parseFloat(classInfo[1].trim()));
PVE_PHYSICAL_SKILL_CRITICAL_DAMAGE_MULTIPLIERS[Util.isDigit(id) ? Integer.parseInt(id) : Enum.valueOf(ClassId.class, id).getId()] = Float.parseFloat(classInfo[1].trim());
}
}
}
Arrays.fill(PVP_PHYSICAL_SKILL_CRITICAL_DAMAGE_MULTIPLIERS, 1f);
final String[] pvpPhysicalSkillCriticalDamageMultipliers = ClassBalance.getString("PvpPhysicalSkillCriticalDamageMultipliers", "").trim().split(";");
PVP_PHYSICAL_SKILL_CRITICAL_DAMAGE_MULTIPLIERS.clear();
if (pvpPhysicalSkillCriticalDamageMultipliers.length > 0)
{
for (String info : pvpPhysicalSkillCriticalDamageMultipliers)
@ -2812,12 +2811,12 @@ public class Config
if (classInfo.length == 2)
{
final String id = classInfo[0].trim();
PVP_PHYSICAL_SKILL_CRITICAL_DAMAGE_MULTIPLIERS.put(Util.isDigit(id) ? ClassId.getClassId(Integer.parseInt(id)) : Enum.valueOf(ClassId.class, id), Float.parseFloat(classInfo[1].trim()));
PVP_PHYSICAL_SKILL_CRITICAL_DAMAGE_MULTIPLIERS[Util.isDigit(id) ? Integer.parseInt(id) : Enum.valueOf(ClassId.class, id).getId()] = Float.parseFloat(classInfo[1].trim());
}
}
}
Arrays.fill(PVE_PHYSICAL_ATTACK_DAMAGE_MULTIPLIERS, 1f);
final String[] pvePhysicalAttackDamageMultipliers = ClassBalance.getString("PvePhysicalAttackDamageMultipliers", "").trim().split(";");
PVE_PHYSICAL_ATTACK_DAMAGE_MULTIPLIERS.clear();
if (pvePhysicalAttackDamageMultipliers.length > 0)
{
for (String info : pvePhysicalAttackDamageMultipliers)
@ -2826,12 +2825,12 @@ public class Config
if (classInfo.length == 2)
{
final String id = classInfo[0].trim();
PVE_PHYSICAL_ATTACK_DAMAGE_MULTIPLIERS.put(Util.isDigit(id) ? ClassId.getClassId(Integer.parseInt(id)) : Enum.valueOf(ClassId.class, id), Float.parseFloat(classInfo[1].trim()));
PVE_PHYSICAL_ATTACK_DAMAGE_MULTIPLIERS[Util.isDigit(id) ? Integer.parseInt(id) : Enum.valueOf(ClassId.class, id).getId()] = Float.parseFloat(classInfo[1].trim());
}
}
}
Arrays.fill(PVP_PHYSICAL_ATTACK_DAMAGE_MULTIPLIERS, 1f);
final String[] pvpPhysicalAttackDamageMultipliers = ClassBalance.getString("PvpPhysicalAttackDamageMultipliers", "").trim().split(";");
PVP_PHYSICAL_ATTACK_DAMAGE_MULTIPLIERS.clear();
if (pvpPhysicalAttackDamageMultipliers.length > 0)
{
for (String info : pvpPhysicalAttackDamageMultipliers)
@ -2840,12 +2839,12 @@ public class Config
if (classInfo.length == 2)
{
final String id = classInfo[0].trim();
PVP_PHYSICAL_ATTACK_DAMAGE_MULTIPLIERS.put(Util.isDigit(id) ? ClassId.getClassId(Integer.parseInt(id)) : Enum.valueOf(ClassId.class, id), Float.parseFloat(classInfo[1].trim()));
PVP_PHYSICAL_ATTACK_DAMAGE_MULTIPLIERS[Util.isDigit(id) ? Integer.parseInt(id) : Enum.valueOf(ClassId.class, id).getId()] = Float.parseFloat(classInfo[1].trim());
}
}
}
Arrays.fill(PVE_PHYSICAL_ATTACK_DEFENCE_MULTIPLIERS, 1f);
final String[] pvePhysicalAttackDefenceMultipliers = ClassBalance.getString("PvePhysicalAttackDefenceMultipliers", "").trim().split(";");
PVE_PHYSICAL_ATTACK_DEFENCE_MULTIPLIERS.clear();
if (pvePhysicalAttackDefenceMultipliers.length > 0)
{
for (String info : pvePhysicalAttackDefenceMultipliers)
@ -2854,12 +2853,12 @@ public class Config
if (classInfo.length == 2)
{
final String id = classInfo[0].trim();
PVE_PHYSICAL_ATTACK_DEFENCE_MULTIPLIERS.put(Util.isDigit(id) ? ClassId.getClassId(Integer.parseInt(id)) : Enum.valueOf(ClassId.class, id), Float.parseFloat(classInfo[1].trim()));
PVE_PHYSICAL_ATTACK_DEFENCE_MULTIPLIERS[Util.isDigit(id) ? Integer.parseInt(id) : Enum.valueOf(ClassId.class, id).getId()] = Float.parseFloat(classInfo[1].trim());
}
}
}
Arrays.fill(PVP_PHYSICAL_ATTACK_DEFENCE_MULTIPLIERS, 1f);
final String[] pvpPhysicalAttackDefenceMultipliers = ClassBalance.getString("PvpPhysicalAttackDefenceMultipliers", "").trim().split(";");
PVP_PHYSICAL_ATTACK_DEFENCE_MULTIPLIERS.clear();
if (pvpPhysicalAttackDefenceMultipliers.length > 0)
{
for (String info : pvpPhysicalAttackDefenceMultipliers)
@ -2868,12 +2867,12 @@ public class Config
if (classInfo.length == 2)
{
final String id = classInfo[0].trim();
PVP_PHYSICAL_ATTACK_DEFENCE_MULTIPLIERS.put(Util.isDigit(id) ? ClassId.getClassId(Integer.parseInt(id)) : Enum.valueOf(ClassId.class, id), Float.parseFloat(classInfo[1].trim()));
PVP_PHYSICAL_ATTACK_DEFENCE_MULTIPLIERS[Util.isDigit(id) ? Integer.parseInt(id) : Enum.valueOf(ClassId.class, id).getId()] = Float.parseFloat(classInfo[1].trim());
}
}
}
Arrays.fill(PVE_PHYSICAL_ATTACK_CRITICAL_CHANCE_MULTIPLIERS, 1f);
final String[] pvePhysicalAttackCriticalChanceMultipliers = ClassBalance.getString("PvePhysicalAttackCriticalChanceMultipliers", "").trim().split(";");
PVE_PHYSICAL_ATTACK_CRITICAL_CHANCE_MULTIPLIERS.clear();
if (pvePhysicalAttackCriticalChanceMultipliers.length > 0)
{
for (String info : pvePhysicalAttackCriticalChanceMultipliers)
@ -2882,12 +2881,12 @@ public class Config
if (classInfo.length == 2)
{
final String id = classInfo[0].trim();
PVE_PHYSICAL_ATTACK_CRITICAL_CHANCE_MULTIPLIERS.put(Util.isDigit(id) ? ClassId.getClassId(Integer.parseInt(id)) : Enum.valueOf(ClassId.class, id), Float.parseFloat(classInfo[1].trim()));
PVE_PHYSICAL_ATTACK_CRITICAL_CHANCE_MULTIPLIERS[Util.isDigit(id) ? Integer.parseInt(id) : Enum.valueOf(ClassId.class, id).getId()] = Float.parseFloat(classInfo[1].trim());
}
}
}
Arrays.fill(PVP_PHYSICAL_ATTACK_CRITICAL_CHANCE_MULTIPLIERS, 1f);
final String[] pvpPhysicalAttackCriticalChanceMultipliers = ClassBalance.getString("PvpPhysicalAttackCriticalChanceMultipliers", "").trim().split(";");
PVP_PHYSICAL_ATTACK_CRITICAL_CHANCE_MULTIPLIERS.clear();
if (pvpPhysicalAttackCriticalChanceMultipliers.length > 0)
{
for (String info : pvpPhysicalAttackCriticalChanceMultipliers)
@ -2896,12 +2895,12 @@ public class Config
if (classInfo.length == 2)
{
final String id = classInfo[0].trim();
PVP_PHYSICAL_ATTACK_CRITICAL_CHANCE_MULTIPLIERS.put(Util.isDigit(id) ? ClassId.getClassId(Integer.parseInt(id)) : Enum.valueOf(ClassId.class, id), Float.parseFloat(classInfo[1].trim()));
PVP_PHYSICAL_ATTACK_CRITICAL_CHANCE_MULTIPLIERS[Util.isDigit(id) ? Integer.parseInt(id) : Enum.valueOf(ClassId.class, id).getId()] = Float.parseFloat(classInfo[1].trim());
}
}
}
Arrays.fill(PVE_PHYSICAL_ATTACK_CRITICAL_DAMAGE_MULTIPLIERS, 1f);
final String[] pvePhysicalAttackCriticalDamageMultipliers = ClassBalance.getString("PvePhysicalAttackCriticalDamageMultipliers", "").trim().split(";");
PVE_PHYSICAL_ATTACK_CRITICAL_DAMAGE_MULTIPLIERS.clear();
if (pvePhysicalAttackCriticalDamageMultipliers.length > 0)
{
for (String info : pvePhysicalAttackCriticalDamageMultipliers)
@ -2910,12 +2909,12 @@ public class Config
if (classInfo.length == 2)
{
final String id = classInfo[0].trim();
PVE_PHYSICAL_ATTACK_CRITICAL_DAMAGE_MULTIPLIERS.put(Util.isDigit(id) ? ClassId.getClassId(Integer.parseInt(id)) : Enum.valueOf(ClassId.class, id), Float.parseFloat(classInfo[1].trim()));
PVE_PHYSICAL_ATTACK_CRITICAL_DAMAGE_MULTIPLIERS[Util.isDigit(id) ? Integer.parseInt(id) : Enum.valueOf(ClassId.class, id).getId()] = Float.parseFloat(classInfo[1].trim());
}
}
}
Arrays.fill(PVP_PHYSICAL_ATTACK_CRITICAL_DAMAGE_MULTIPLIERS, 1f);
final String[] pvpPhysicalAttackCriticalDamageMultipliers = ClassBalance.getString("PvpPhysicalAttackCriticalDamageMultipliers", "").trim().split(";");
PVP_PHYSICAL_ATTACK_CRITICAL_DAMAGE_MULTIPLIERS.clear();
if (pvpPhysicalAttackCriticalDamageMultipliers.length > 0)
{
for (String info : pvpPhysicalAttackCriticalDamageMultipliers)
@ -2924,12 +2923,12 @@ public class Config
if (classInfo.length == 2)
{
final String id = classInfo[0].trim();
PVP_PHYSICAL_ATTACK_CRITICAL_DAMAGE_MULTIPLIERS.put(Util.isDigit(id) ? ClassId.getClassId(Integer.parseInt(id)) : Enum.valueOf(ClassId.class, id), Float.parseFloat(classInfo[1].trim()));
PVP_PHYSICAL_ATTACK_CRITICAL_DAMAGE_MULTIPLIERS[Util.isDigit(id) ? Integer.parseInt(id) : Enum.valueOf(ClassId.class, id).getId()] = Float.parseFloat(classInfo[1].trim());
}
}
}
Arrays.fill(PVE_BLOW_SKILL_DAMAGE_MULTIPLIERS, 1f);
final String[] pveBlowSkillDamageMultipliers = ClassBalance.getString("PveBlowSkillDamageMultipliers", "").trim().split(";");
PVE_BLOW_SKILL_DAMAGE_MULTIPLIERS.clear();
if (pveBlowSkillDamageMultipliers.length > 0)
{
for (String info : pveBlowSkillDamageMultipliers)
@ -2938,12 +2937,12 @@ public class Config
if (classInfo.length == 2)
{
final String id = classInfo[0].trim();
PVE_BLOW_SKILL_DAMAGE_MULTIPLIERS.put(Util.isDigit(id) ? ClassId.getClassId(Integer.parseInt(id)) : Enum.valueOf(ClassId.class, id), Float.parseFloat(classInfo[1].trim()));
PVE_BLOW_SKILL_DAMAGE_MULTIPLIERS[Util.isDigit(id) ? Integer.parseInt(id) : Enum.valueOf(ClassId.class, id).getId()] = Float.parseFloat(classInfo[1].trim());
}
}
}
Arrays.fill(PVP_BLOW_SKILL_DAMAGE_MULTIPLIERS, 1f);
final String[] pvpBlowSkillDamageMultipliers = ClassBalance.getString("PvpBlowSkillDamageMultipliers", "").trim().split(";");
PVP_BLOW_SKILL_DAMAGE_MULTIPLIERS.clear();
if (pvpBlowSkillDamageMultipliers.length > 0)
{
for (String info : pvpBlowSkillDamageMultipliers)
@ -2952,12 +2951,12 @@ public class Config
if (classInfo.length == 2)
{
final String id = classInfo[0].trim();
PVP_BLOW_SKILL_DAMAGE_MULTIPLIERS.put(Util.isDigit(id) ? ClassId.getClassId(Integer.parseInt(id)) : Enum.valueOf(ClassId.class, id), Float.parseFloat(classInfo[1].trim()));
PVP_BLOW_SKILL_DAMAGE_MULTIPLIERS[Util.isDigit(id) ? Integer.parseInt(id) : Enum.valueOf(ClassId.class, id).getId()] = Float.parseFloat(classInfo[1].trim());
}
}
}
Arrays.fill(PVE_BLOW_SKILL_DEFENCE_MULTIPLIERS, 1f);
final String[] pveBlowSkillDefenceMultipliers = ClassBalance.getString("PveBlowSkillDefenceMultipliers", "").trim().split(";");
PVE_BLOW_SKILL_DEFENCE_MULTIPLIERS.clear();
if (pveBlowSkillDefenceMultipliers.length > 0)
{
for (String info : pveBlowSkillDefenceMultipliers)
@ -2966,12 +2965,12 @@ public class Config
if (classInfo.length == 2)
{
final String id = classInfo[0].trim();
PVE_BLOW_SKILL_DEFENCE_MULTIPLIERS.put(Util.isDigit(id) ? ClassId.getClassId(Integer.parseInt(id)) : Enum.valueOf(ClassId.class, id), Float.parseFloat(classInfo[1].trim()));
PVE_BLOW_SKILL_DEFENCE_MULTIPLIERS[Util.isDigit(id) ? Integer.parseInt(id) : Enum.valueOf(ClassId.class, id).getId()] = Float.parseFloat(classInfo[1].trim());
}
}
}
Arrays.fill(PVP_BLOW_SKILL_DEFENCE_MULTIPLIERS, 1f);
final String[] pvpBlowSkillDefenceMultipliers = ClassBalance.getString("PvpBlowSkillDefenceMultipliers", "").trim().split(";");
PVP_BLOW_SKILL_DEFENCE_MULTIPLIERS.clear();
if (pvpBlowSkillDefenceMultipliers.length > 0)
{
for (String info : pvpBlowSkillDefenceMultipliers)
@ -2980,12 +2979,12 @@ public class Config
if (classInfo.length == 2)
{
final String id = classInfo[0].trim();
PVP_BLOW_SKILL_DEFENCE_MULTIPLIERS.put(Util.isDigit(id) ? ClassId.getClassId(Integer.parseInt(id)) : Enum.valueOf(ClassId.class, id), Float.parseFloat(classInfo[1].trim()));
PVP_BLOW_SKILL_DEFENCE_MULTIPLIERS[Util.isDigit(id) ? Integer.parseInt(id) : Enum.valueOf(ClassId.class, id).getId()] = Float.parseFloat(classInfo[1].trim());
}
}
}
Arrays.fill(PVE_ENERGY_SKILL_DAMAGE_MULTIPLIERS, 1f);
final String[] pveEnergySkillDamageMultipliers = ClassBalance.getString("PveEnergySkillDamageMultipliers", "").trim().split(";");
PVE_ENERGY_SKILL_DAMAGE_MULTIPLIERS.clear();
if (pveEnergySkillDamageMultipliers.length > 0)
{
for (String info : pveEnergySkillDamageMultipliers)
@ -2994,12 +2993,12 @@ public class Config
if (classInfo.length == 2)
{
final String id = classInfo[0].trim();
PVE_ENERGY_SKILL_DAMAGE_MULTIPLIERS.put(Util.isDigit(id) ? ClassId.getClassId(Integer.parseInt(id)) : Enum.valueOf(ClassId.class, id), Float.parseFloat(classInfo[1].trim()));
PVE_ENERGY_SKILL_DAMAGE_MULTIPLIERS[Util.isDigit(id) ? Integer.parseInt(id) : Enum.valueOf(ClassId.class, id).getId()] = Float.parseFloat(classInfo[1].trim());
}
}
}
Arrays.fill(PVP_ENERGY_SKILL_DAMAGE_MULTIPLIERS, 1f);
final String[] pvpEnergySkillDamageMultipliers = ClassBalance.getString("PvpEnergySkillDamageMultipliers", "").trim().split(";");
PVP_ENERGY_SKILL_DAMAGE_MULTIPLIERS.clear();
if (pvpEnergySkillDamageMultipliers.length > 0)
{
for (String info : pvpEnergySkillDamageMultipliers)
@ -3008,12 +3007,12 @@ public class Config
if (classInfo.length == 2)
{
final String id = classInfo[0].trim();
PVP_ENERGY_SKILL_DAMAGE_MULTIPLIERS.put(Util.isDigit(id) ? ClassId.getClassId(Integer.parseInt(id)) : Enum.valueOf(ClassId.class, id), Float.parseFloat(classInfo[1].trim()));
PVP_ENERGY_SKILL_DAMAGE_MULTIPLIERS[Util.isDigit(id) ? Integer.parseInt(id) : Enum.valueOf(ClassId.class, id).getId()] = Float.parseFloat(classInfo[1].trim());
}
}
}
Arrays.fill(PVE_ENERGY_SKILL_DEFENCE_MULTIPLIERS, 1f);
final String[] pveEnergySkillDefenceMultipliers = ClassBalance.getString("PveEnergySkillDefenceMultipliers", "").trim().split(";");
PVE_ENERGY_SKILL_DEFENCE_MULTIPLIERS.clear();
if (pveEnergySkillDefenceMultipliers.length > 0)
{
for (String info : pveEnergySkillDefenceMultipliers)
@ -3022,12 +3021,12 @@ public class Config
if (classInfo.length == 2)
{
final String id = classInfo[0].trim();
PVE_ENERGY_SKILL_DEFENCE_MULTIPLIERS.put(Util.isDigit(id) ? ClassId.getClassId(Integer.parseInt(id)) : Enum.valueOf(ClassId.class, id), Float.parseFloat(classInfo[1].trim()));
PVE_ENERGY_SKILL_DEFENCE_MULTIPLIERS[Util.isDigit(id) ? Integer.parseInt(id) : Enum.valueOf(ClassId.class, id).getId()] = Float.parseFloat(classInfo[1].trim());
}
}
}
Arrays.fill(PVP_ENERGY_SKILL_DEFENCE_MULTIPLIERS, 1f);
final String[] pvpEnergySkillDefenceMultipliers = ClassBalance.getString("PvpEnergySkillDefenceMultipliers", "").trim().split(";");
PVP_ENERGY_SKILL_DEFENCE_MULTIPLIERS.clear();
if (pvpEnergySkillDefenceMultipliers.length > 0)
{
for (String info : pvpEnergySkillDefenceMultipliers)
@ -3036,12 +3035,12 @@ public class Config
if (classInfo.length == 2)
{
final String id = classInfo[0].trim();
PVP_ENERGY_SKILL_DEFENCE_MULTIPLIERS.put(Util.isDigit(id) ? ClassId.getClassId(Integer.parseInt(id)) : Enum.valueOf(ClassId.class, id), Float.parseFloat(classInfo[1].trim()));
PVP_ENERGY_SKILL_DEFENCE_MULTIPLIERS[Util.isDigit(id) ? Integer.parseInt(id) : Enum.valueOf(ClassId.class, id).getId()] = Float.parseFloat(classInfo[1].trim());
}
}
}
Arrays.fill(PLAYER_HEALING_SKILL_MULTIPLIERS, 1f);
final String[] playerHealingSkillMultipliers = ClassBalance.getString("PlayerHealingSkillMultipliers", "").trim().split(";");
PLAYER_HEALING_SKILL_MULTIPLIERS.clear();
if (playerHealingSkillMultipliers.length > 0)
{
for (String info : playerHealingSkillMultipliers)
@ -3050,12 +3049,12 @@ public class Config
if (classInfo.length == 2)
{
final String id = classInfo[0].trim();
PLAYER_HEALING_SKILL_MULTIPLIERS.put(Util.isDigit(id) ? ClassId.getClassId(Integer.parseInt(id)) : Enum.valueOf(ClassId.class, id), Float.parseFloat(classInfo[1].trim()));
PLAYER_HEALING_SKILL_MULTIPLIERS[Util.isDigit(id) ? Integer.parseInt(id) : Enum.valueOf(ClassId.class, id).getId()] = Float.parseFloat(classInfo[1].trim());
}
}
}
Arrays.fill(SKILL_MASTERY_CHANCE_MULTIPLIERS, 1f);
final String[] skillMasteryChanceMultipliers = ClassBalance.getString("SkillMasteryChanceMultipliers", "").trim().split(";");
SKILL_MASTERY_CHANCE_MULTIPLIERS.clear();
if (skillMasteryChanceMultipliers.length > 0)
{
for (String info : skillMasteryChanceMultipliers)
@ -3064,12 +3063,12 @@ public class Config
if (classInfo.length == 2)
{
final String id = classInfo[0].trim();
SKILL_MASTERY_CHANCE_MULTIPLIERS.put(Util.isDigit(id) ? ClassId.getClassId(Integer.parseInt(id)) : Enum.valueOf(ClassId.class, id), Float.parseFloat(classInfo[1].trim()));
SKILL_MASTERY_CHANCE_MULTIPLIERS[Util.isDigit(id) ? Integer.parseInt(id) : Enum.valueOf(ClassId.class, id).getId()] = Float.parseFloat(classInfo[1].trim());
}
}
}
Arrays.fill(EXP_AMOUNT_MULTIPLIERS, 1f);
final String[] expAmountMultipliers = ClassBalance.getString("ExpAmountMultipliers", "").trim().split(";");
EXP_AMOUNT_MULTIPLIERS.clear();
if (expAmountMultipliers.length > 0)
{
for (String info : expAmountMultipliers)
@ -3078,12 +3077,12 @@ public class Config
if (classInfo.length == 2)
{
final String id = classInfo[0].trim();
EXP_AMOUNT_MULTIPLIERS.put(Util.isDigit(id) ? ClassId.getClassId(Integer.parseInt(id)) : Enum.valueOf(ClassId.class, id), Float.parseFloat(classInfo[1].trim()));
EXP_AMOUNT_MULTIPLIERS[Util.isDigit(id) ? Integer.parseInt(id) : Enum.valueOf(ClassId.class, id).getId()] = Float.parseFloat(classInfo[1].trim());
}
}
}
Arrays.fill(SP_AMOUNT_MULTIPLIERS, 1f);
final String[] spAmountMultipliers = ClassBalance.getString("SpAmountMultipliers", "").trim().split(";");
SP_AMOUNT_MULTIPLIERS.clear();
if (spAmountMultipliers.length > 0)
{
for (String info : spAmountMultipliers)
@ -3092,7 +3091,7 @@ public class Config
if (classInfo.length == 2)
{
final String id = classInfo[0].trim();
SP_AMOUNT_MULTIPLIERS.put(Util.isDigit(id) ? ClassId.getClassId(Integer.parseInt(id)) : Enum.valueOf(ClassId.class, id), Float.parseFloat(classInfo[1].trim()));
SP_AMOUNT_MULTIPLIERS[Util.isDigit(id) ? Integer.parseInt(id) : Enum.valueOf(ClassId.class, id).getId()] = Float.parseFloat(classInfo[1].trim());
}
}
}

4
L2J_Mobius_2.5_Underground/java/org/l2jmobius/gameserver/model/Party.java
View File

@ -903,8 +903,8 @@ public class Party extends AbstractPlayerGroup
private double calculateExpSpPartyCutoff(PlayerInstance player, int topLvl, double addExpValue, double addSpValue, boolean vit)
{
final double addExp = addExpValue * Config.EXP_AMOUNT_MULTIPLIERS.getOrDefault(player.getClassId(), 1f);
final double addSp = addSpValue * Config.SP_AMOUNT_MULTIPLIERS.getOrDefault(player.getClassId(), 1f);
final double addExp = addExpValue * Config.EXP_AMOUNT_MULTIPLIERS[player.getClassId().getId()];
final double addSp = addSpValue * Config.SP_AMOUNT_MULTIPLIERS[player.getClassId().getId()];
double xp = addExp;
double sp = addSp;
if (Config.PARTY_XP_CUTOFF_METHOD.equalsIgnoreCase("highfive"))

4
L2J_Mobius_2.5_Underground/java/org/l2jmobius/gameserver/model/actor/Attackable.java
View File

@ -506,8 +506,8 @@ public class Attackable extends Npc
// Distribute the Exp and SP between the PlayerInstance and its Summon
if (!attacker.isDead())
{
exp = attacker.getStat().getValue(Stat.EXPSP_RATE, exp) * Config.EXP_AMOUNT_MULTIPLIERS.getOrDefault(attacker.getClassId(), 1f);
sp = attacker.getStat().getValue(Stat.EXPSP_RATE, sp) * Config.SP_AMOUNT_MULTIPLIERS.getOrDefault(attacker.getClassId(), 1f);
exp = attacker.getStat().getValue(Stat.EXPSP_RATE, exp) * Config.EXP_AMOUNT_MULTIPLIERS[attacker.getClassId().getId()];
sp = attacker.getStat().getValue(Stat.EXPSP_RATE, sp) * Config.SP_AMOUNT_MULTIPLIERS[attacker.getClassId().getId()];
attacker.addExpAndSp(exp, sp, useVitalityRate());
if (exp > 0)
{

42
L2J_Mobius_2.5_Underground/java/org/l2jmobius/gameserver/model/stats/Formulas.java
View File

@ -123,11 +123,11 @@ public class Formulas
double balanceMod = 1;
if (attacker.isPlayable())
{
balanceMod = target.isPlayable() ? Config.PVP_BLOW_SKILL_DAMAGE_MULTIPLIERS.getOrDefault(attacker.getActingPlayer().getClassId(), 1f) : Config.PVE_BLOW_SKILL_DAMAGE_MULTIPLIERS.getOrDefault(attacker.getActingPlayer().getClassId(), 1f);
balanceMod = target.isPlayable() ? Config.PVP_BLOW_SKILL_DAMAGE_MULTIPLIERS[attacker.getActingPlayer().getClassId().getId()] : Config.PVE_BLOW_SKILL_DAMAGE_MULTIPLIERS[attacker.getActingPlayer().getClassId().getId()];
}
if (target.isPlayable())
{
defence *= attacker.isPlayable() ? Config.PVP_BLOW_SKILL_DEFENCE_MULTIPLIERS.getOrDefault(target.getActingPlayer().getClassId(), 1f) : Config.PVE_BLOW_SKILL_DEFENCE_MULTIPLIERS.getOrDefault(target.getActingPlayer().getClassId(), 1f);
defence *= attacker.isPlayable() ? Config.PVP_BLOW_SKILL_DEFENCE_MULTIPLIERS[target.getActingPlayer().getClassId().getId()] : Config.PVE_BLOW_SKILL_DEFENCE_MULTIPLIERS[target.getActingPlayer().getClassId().getId()];
}
// ........................_____________________________Initial Damage____________________________...___________Position Additional Damage___________..._CriticalAdd_
@ -235,7 +235,7 @@ public class Formulas
double balanceMod = 1;
if (creature.isPlayable())
{
balanceMod = target.isPlayable() ? Config.PVP_MAGICAL_SKILL_CRITICAL_CHANCE_MULTIPLIERS.getOrDefault(creature.getActingPlayer().getClassId(), 1f) : Config.PVE_MAGICAL_SKILL_CRITICAL_CHANCE_MULTIPLIERS.getOrDefault(creature.getActingPlayer().getClassId(), 1f);
balanceMod = target.isPlayable() ? Config.PVP_MAGICAL_SKILL_CRITICAL_CHANCE_MULTIPLIERS[creature.getActingPlayer().getClassId().getId()] : Config.PVE_MAGICAL_SKILL_CRITICAL_CHANCE_MULTIPLIERS[creature.getActingPlayer().getClassId().getId()];
}
return (Math.min(finalRate, 20) * balanceMod) > Rnd.get(100);
@ -262,7 +262,7 @@ public class Formulas
double balanceMod = 1;
if (creature.isPlayable())
{
balanceMod = target.isPlayable() ? Config.PVP_PHYSICAL_SKILL_CRITICAL_CHANCE_MULTIPLIERS.getOrDefault(creature.getActingPlayer().getClassId(), 1f) : Config.PVE_PHYSICAL_SKILL_CRITICAL_CHANCE_MULTIPLIERS.getOrDefault(creature.getActingPlayer().getClassId(), 1f);
balanceMod = target.isPlayable() ? Config.PVP_PHYSICAL_SKILL_CRITICAL_CHANCE_MULTIPLIERS[creature.getActingPlayer().getClassId().getId()] : Config.PVE_PHYSICAL_SKILL_CRITICAL_CHANCE_MULTIPLIERS[creature.getActingPlayer().getClassId().getId()];
}
return (rate * statBonus * rateBonus * balanceMod) > Rnd.get(100);
@ -288,7 +288,7 @@ public class Formulas
double balanceMod = 1;
if (creature.isPlayable())
{
balanceMod = target.isPlayable() ? Config.PVP_PHYSICAL_ATTACK_CRITICAL_CHANCE_MULTIPLIERS.getOrDefault(creature.getActingPlayer().getClassId(), 1f) : Config.PVE_PHYSICAL_ATTACK_CRITICAL_CHANCE_MULTIPLIERS.getOrDefault(creature.getActingPlayer().getClassId(), 1f);
balanceMod = target.isPlayable() ? Config.PVP_PHYSICAL_ATTACK_CRITICAL_CHANCE_MULTIPLIERS[creature.getActingPlayer().getClassId().getId()] : Config.PVE_PHYSICAL_ATTACK_CRITICAL_CHANCE_MULTIPLIERS[creature.getActingPlayer().getClassId().getId()];
}
return (rate * balanceMod) > Rnd.get(100);
@ -346,7 +346,7 @@ public class Formulas
defenceCriticalDamage = target.getStat().getValue(Stat.DEFENCE_MAGIC_CRITICAL_DAMAGE, 1);
if (attacker.isPlayable())
{
balanceMod = target.isPlayable() ? Config.PVP_MAGICAL_SKILL_CRITICAL_DAMAGE_MULTIPLIERS.getOrDefault(attacker.getActingPlayer().getClassId(), 1f) : Config.PVE_MAGICAL_SKILL_CRITICAL_DAMAGE_MULTIPLIERS.getOrDefault(attacker.getActingPlayer().getClassId(), 1f);
balanceMod = target.isPlayable() ? Config.PVP_MAGICAL_SKILL_CRITICAL_DAMAGE_MULTIPLIERS[attacker.getActingPlayer().getClassId().getId()] : Config.PVE_MAGICAL_SKILL_CRITICAL_DAMAGE_MULTIPLIERS[attacker.getActingPlayer().getClassId().getId()];
}
}
else
@ -355,7 +355,7 @@ public class Formulas
defenceCriticalDamage = target.getStat().getValue(Stat.DEFENCE_CRITICAL_DAMAGE_SKILL, 1);
if (attacker.isPlayable())
{
balanceMod = target.isPlayable() ? Config.PVP_PHYSICAL_SKILL_CRITICAL_DAMAGE_MULTIPLIERS.getOrDefault(attacker.getActingPlayer().getClassId(), 1f) : Config.PVE_PHYSICAL_SKILL_CRITICAL_DAMAGE_MULTIPLIERS.getOrDefault(attacker.getActingPlayer().getClassId(), 1f);
balanceMod = target.isPlayable() ? Config.PVP_PHYSICAL_SKILL_CRITICAL_DAMAGE_MULTIPLIERS[attacker.getActingPlayer().getClassId().getId()] : Config.PVE_PHYSICAL_SKILL_CRITICAL_DAMAGE_MULTIPLIERS[attacker.getActingPlayer().getClassId().getId()];
}
}
}
@ -366,7 +366,7 @@ public class Formulas
defenceCriticalDamage = target.getStat().getValue(Stat.DEFENCE_CRITICAL_DAMAGE, 1);
if (attacker.isPlayable())
{
balanceMod = target.isPlayable() ? Config.PVP_PHYSICAL_ATTACK_CRITICAL_DAMAGE_MULTIPLIERS.getOrDefault(attacker.getActingPlayer().getClassId(), 1f) : Config.PVE_PHYSICAL_ATTACK_CRITICAL_DAMAGE_MULTIPLIERS.getOrDefault(attacker.getActingPlayer().getClassId(), 1f);
balanceMod = target.isPlayable() ? Config.PVP_PHYSICAL_ATTACK_CRITICAL_DAMAGE_MULTIPLIERS[attacker.getActingPlayer().getClassId().getId()] : Config.PVE_PHYSICAL_ATTACK_CRITICAL_DAMAGE_MULTIPLIERS[attacker.getActingPlayer().getClassId().getId()];
}
}
@ -961,7 +961,7 @@ public class Formulas
final double chance = BaseStat.values()[val].calcBonus(actor) * actor.getStat().getValue(Stat.SKILL_CRITICAL_PROBABILITY, 1);
return ((Rnd.nextDouble() * 100.) < (chance * Config.SKILL_MASTERY_CHANCE_MULTIPLIERS.getOrDefault(actor.getActingPlayer().getClassId(), 1f)));
return ((Rnd.nextDouble() * 100.) < (chance * Config.SKILL_MASTERY_CHANCE_MULTIPLIERS[actor.getActingPlayer().getClassId().getId()]));
}
/**
@ -1589,21 +1589,21 @@ public class Formulas
if (skill.isMagic())
{
// Magical Skill PvP
pvpAttack = attacker.getStat().getValue(Stat.PVP_MAGICAL_SKILL_DAMAGE, 1) * Config.PVP_MAGICAL_SKILL_DAMAGE_MULTIPLIERS.getOrDefault(attackerPlayer.getClassId(), 1f);
pvpDefense = target.getStat().getValue(Stat.PVP_MAGICAL_SKILL_DEFENCE, 1) * Config.PVP_MAGICAL_SKILL_DEFENCE_MULTIPLIERS.getOrDefault(targetPlayer.getClassId(), 1f);
pvpAttack = attacker.getStat().getValue(Stat.PVP_MAGICAL_SKILL_DAMAGE, 1) * Config.PVP_MAGICAL_SKILL_DAMAGE_MULTIPLIERS[attackerPlayer.getClassId().getId()];
pvpDefense = target.getStat().getValue(Stat.PVP_MAGICAL_SKILL_DEFENCE, 1) * Config.PVP_MAGICAL_SKILL_DEFENCE_MULTIPLIERS[targetPlayer.getClassId().getId()];
}
else
{
// Physical Skill PvP
pvpAttack = attacker.getStat().getValue(Stat.PVP_PHYSICAL_SKILL_DAMAGE, 1) * Config.PVP_PHYSICAL_SKILL_DAMAGE_MULTIPLIERS.getOrDefault(attackerPlayer.getClassId(), 1f);
pvpDefense = target.getStat().getValue(Stat.PVP_PHYSICAL_SKILL_DEFENCE, 1) * Config.PVP_PHYSICAL_SKILL_DEFENCE_MULTIPLIERS.getOrDefault(targetPlayer.getClassId(), 1f);
pvpAttack = attacker.getStat().getValue(Stat.PVP_PHYSICAL_SKILL_DAMAGE, 1) * Config.PVP_PHYSICAL_SKILL_DAMAGE_MULTIPLIERS[attackerPlayer.getClassId().getId()];
pvpDefense = target.getStat().getValue(Stat.PVP_PHYSICAL_SKILL_DEFENCE, 1) * Config.PVP_PHYSICAL_SKILL_DEFENCE_MULTIPLIERS[targetPlayer.getClassId().getId()];
}
}
else
{
// Autoattack PvP
pvpAttack = attacker.getStat().getValue(Stat.PVP_PHYSICAL_ATTACK_DAMAGE, 1) * Config.PVP_PHYSICAL_ATTACK_DAMAGE_MULTIPLIERS.getOrDefault(attackerPlayer.getClassId(), 1f);
pvpDefense = target.getStat().getValue(Stat.PVP_PHYSICAL_ATTACK_DEFENCE, 1) * Config.PVP_PHYSICAL_ATTACK_DEFENCE_MULTIPLIERS.getOrDefault(targetPlayer.getClassId(), 1f);
pvpAttack = attacker.getStat().getValue(Stat.PVP_PHYSICAL_ATTACK_DAMAGE, 1) * Config.PVP_PHYSICAL_ATTACK_DAMAGE_MULTIPLIERS[attackerPlayer.getClassId().getId()];
pvpDefense = target.getStat().getValue(Stat.PVP_PHYSICAL_ATTACK_DEFENCE, 1) * Config.PVP_PHYSICAL_ATTACK_DEFENCE_MULTIPLIERS[targetPlayer.getClassId().getId()];
}
return Math.max(0.05, 1 + (pvpAttack - pvpDefense)); // Bonus should not be negative.
@ -1636,16 +1636,16 @@ public class Formulas
if (skill.isMagic())
{
// Magical Skill PvE
pveAttack = attacker.getStat().getValue(Stat.PVE_MAGICAL_SKILL_DAMAGE, 1) * (attackerPlayer == null ? 1 : Config.PVE_MAGICAL_SKILL_DAMAGE_MULTIPLIERS.getOrDefault(attackerPlayer.getClassId(), 1f));
pveDefense = target.getStat().getValue(Stat.PVE_MAGICAL_SKILL_DEFENCE, 1) * (targetPlayer == null ? 1 : Config.PVE_MAGICAL_SKILL_DEFENCE_MULTIPLIERS.getOrDefault(targetPlayer.getClassId(), 1f));
pveAttack = attacker.getStat().getValue(Stat.PVE_MAGICAL_SKILL_DAMAGE, 1) * (attackerPlayer == null ? 1 : Config.PVE_MAGICAL_SKILL_DAMAGE_MULTIPLIERS[attackerPlayer.getClassId().getId()]);
pveDefense = target.getStat().getValue(Stat.PVE_MAGICAL_SKILL_DEFENCE, 1) * (targetPlayer == null ? 1 : Config.PVE_MAGICAL_SKILL_DEFENCE_MULTIPLIERS[targetPlayer.getClassId().getId()]);
pveRaidAttack = attacker.isRaid() ? attacker.getStat().getValue(Stat.PVE_RAID_MAGICAL_SKILL_DAMAGE, 1) : 1;
pveRaidDefense = attacker.isRaid() ? attacker.getStat().getValue(Stat.PVE_RAID_MAGICAL_SKILL_DEFENCE, 1) : 1;
}
else
{
// Physical Skill PvE
pveAttack = attacker.getStat().getValue(Stat.PVE_PHYSICAL_SKILL_DAMAGE, 1) * (attackerPlayer == null ? 1 : Config.PVE_PHYSICAL_SKILL_DAMAGE_MULTIPLIERS.getOrDefault(attackerPlayer.getClassId(), 1f));
pveDefense = target.getStat().getValue(Stat.PVE_PHYSICAL_SKILL_DEFENCE, 1) * (targetPlayer == null ? 1 : Config.PVE_PHYSICAL_SKILL_DEFENCE_MULTIPLIERS.getOrDefault(targetPlayer.getClassId(), 1f));
pveAttack = attacker.getStat().getValue(Stat.PVE_PHYSICAL_SKILL_DAMAGE, 1) * (attackerPlayer == null ? 1 : Config.PVE_PHYSICAL_SKILL_DAMAGE_MULTIPLIERS[attackerPlayer.getClassId().getId()]);
pveDefense = target.getStat().getValue(Stat.PVE_PHYSICAL_SKILL_DEFENCE, 1) * (targetPlayer == null ? 1 : Config.PVE_PHYSICAL_SKILL_DEFENCE_MULTIPLIERS[targetPlayer.getClassId().getId()]);
pveRaidAttack = attacker.isRaid() ? attacker.getStat().getValue(Stat.PVE_RAID_PHYSICAL_SKILL_DAMAGE, 1) : 1;
pveRaidDefense = attacker.isRaid() ? attacker.getStat().getValue(Stat.PVE_RAID_PHYSICAL_SKILL_DEFENCE, 1) : 1;
}
@ -1653,8 +1653,8 @@ public class Formulas
else
{
// Autoattack PvE
pveAttack = attacker.getStat().getValue(Stat.PVE_PHYSICAL_ATTACK_DAMAGE, 1) * (attackerPlayer == null ? 1 : Config.PVE_PHYSICAL_ATTACK_DAMAGE_MULTIPLIERS.getOrDefault(attackerPlayer.getClassId(), 1f));
pveDefense = target.getStat().getValue(Stat.PVE_PHYSICAL_ATTACK_DEFENCE, 1) * (targetPlayer == null ? 1 : Config.PVE_PHYSICAL_ATTACK_DEFENCE_MULTIPLIERS.getOrDefault(targetPlayer.getClassId(), 1f));
pveAttack = attacker.getStat().getValue(Stat.PVE_PHYSICAL_ATTACK_DAMAGE, 1) * (attackerPlayer == null ? 1 : Config.PVE_PHYSICAL_ATTACK_DAMAGE_MULTIPLIERS[attackerPlayer.getClassId().getId()]);
pveDefense = target.getStat().getValue(Stat.PVE_PHYSICAL_ATTACK_DEFENCE, 1) * (targetPlayer == null ? 1 : Config.PVE_PHYSICAL_ATTACK_DEFENCE_MULTIPLIERS[targetPlayer.getClassId().getId()]);
pveRaidAttack = attacker.isRaid() ? attacker.getStat().getValue(Stat.PVE_RAID_PHYSICAL_ATTACK_DAMAGE, 1) : 1;
pveRaidDefense = attacker.isRaid() ? attacker.getStat().getValue(Stat.PVE_RAID_PHYSICAL_ATTACK_DEFENCE, 1) : 1;
}