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_1.0_Ertheia/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;
@@ -1117,42 +1116,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;
@@ -2576,8 +2575,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)
@@ -2586,12 +2585,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)
@@ -2600,12 +2599,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)
@@ -2614,12 +2613,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)
@@ -2628,12 +2627,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)
@@ -2642,12 +2641,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)
@@ -2656,12 +2655,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)
@@ -2670,12 +2669,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)
@@ -2684,12 +2683,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)
@@ -2698,12 +2697,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)
@@ -2712,12 +2711,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)
@@ -2726,12 +2725,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)
@@ -2740,12 +2739,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)
@@ -2754,12 +2753,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)
@@ -2768,12 +2767,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)
@@ -2782,12 +2781,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)
@@ -2796,12 +2795,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)
@@ -2810,12 +2809,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)
@@ -2824,12 +2823,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)
@@ -2838,12 +2837,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)
@@ -2852,12 +2851,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)
@@ -2866,12 +2865,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)
@@ -2880,12 +2879,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)
@@ -2894,12 +2893,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)
@@ -2908,12 +2907,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)
@@ -2922,12 +2921,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)
@@ -2936,12 +2935,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)
@@ -2950,12 +2949,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)
@@ -2964,12 +2963,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)
@@ -2978,12 +2977,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)
@@ -2992,12 +2991,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)
@@ -3006,12 +3005,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)
@@ -3020,12 +3019,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)
@@ -3034,12 +3033,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)
@@ -3048,12 +3047,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)
@@ -3062,12 +3061,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)
@@ -3076,7 +3075,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_1.0_Ertheia/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_1.0_Ertheia/java/org/l2jmobius/gameserver/model/actor/Attackable.java
View File

@@ -513,8 +513,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_1.0_Ertheia/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;
}