More retail-like resists/profs [Freya]

Index: Formulas.java
===================================================================
--- Formulas.java   (revision 4950)
+++ Formulas.java   (working copy)
@@ -2444,15 +2444,55 @@
        return multiplier;
    }

+   /**
+    * This method is used as <b>divider</b> for the skill's base power.
+    * @return statBonus value for this skill's saveVs
+    */
    public static double calcSkillStatModifier(L2Skill skill, L2Character target)
    {
        final BaseStats saveVs = skill.getSaveVs();
        if (saveVs == null)
            return 1;

-       return 1 / saveVs.calcBonus(target);
+       return saveVs.calcBonus(target);
    }

+   /**
+    * This method is used as <b>divider</b> for the skill's base power.
+    * @param skill : the skill which is used for calculations
+    * @param effect : the EffectTemplate (if we calculate an effect from the skill) which is used for calculations. Leave null if we dont calc skill effect.
+    * @return skill stat modifier changed by the attacker's skill prof and target's skill resist.
+    */
+   public static double calcSkillLandRateModifier(L2Skill skill, EffectTemplate effect, L2Character attacker, L2Character target)
+   {
+       double retval = calcSkillStatModifier(skill, target);
+       double vuln = 0;
+       if (effect == null)// "-" if resistant, "+" if vulnerable   "-" for negative proficiency, "+" for positive proficiency
+           vuln = calcSkillVulnerability(attacker, target, skill) + calcSkillProficiency(skill, attacker, target);
+       else
+           vuln = calcSkillTypeVulnerability(0, target, effect.effectType) + calcSkillTypeProficiency(0, attacker, target, effect.effectType);
+
+       if (vuln == 0)
+           return retval;
+
+       if (vuln < 0) // If negative vulnerability (target has resist), multiply base resist with that resist.
+       {
+           vuln *= -1; // Make this variable positive, because its negative. We dont want to return negative double.
+           vuln /= 100; // divide by 100 in order to get percent value.
+           vuln += 1; // Since we work with percents, always add +1 to prevent 0.x values.
+           retval *= vuln;
+       }
+       else // If positive vulnerability (target has vulnerability), divide base resist with that resist.
+       {
+           vuln /= 100; // divide by 100 in order to get percent value.
+           vuln += 1; // Since we work with percents, always add +1 to prevent 0.x values.
+           retval /= vuln;
+       }
+
+       return retval;
+
+   }
+
    public static int calcLvlDependModifier(L2Character attacker, L2Character target, L2Skill skill)
    {
        if (skill.getLevelDepend() == 0)
@@ -2523,11 +2563,10 @@
            return false;
        }

-       double statModifier = calcSkillStatModifier(skill, target);
+       double skillLandRateModifier = calcSkillLandRateModifier(skill, effect, attacker, target);
+       // Calculate BaseRate influenced by base stats and resists/vulnerabilities.
+       int rate = (int) (value / skillLandRateModifier);

-       // Calculate BaseRate.
-       int rate = (int) (value * statModifier);
-
        // Add Matk/Mdef Bonus
        double mAtkModifier = 0;
        int ssModifier = 0;
@@ -2550,27 +2589,6 @@
            rate = (int) (rate * mAtkModifier);
        }

-       // Resists
-       double vulnModifier = calcSkillTypeVulnerability(0, target, type);
-       double profModifier = calcSkillTypeProficiency(0, attacker, target, type);
-       double res = vulnModifier + profModifier;
-       double resMod = 1;
-       if (res != 0)
-       {
-           if (res < 0)
-           {
-               resMod = 1 - 0.075 * res;
-               resMod = 1 / resMod;
-           }
-           else
-               resMod = 1 + 0.02 * res;
-
-           rate *= resMod;
-       }
-
-       int elementModifier = calcElementModifier(attacker, target, skill);
-       rate += elementModifier;
-
        //lvl modifier.
        int deltamod = calcLvlDependModifier(attacker, target, skill);
        rate += deltamod;
@@ -2587,11 +2605,7 @@
                    skill.getName(),
                    " eff.type:", type.toString(),
                    " power:", String.valueOf(value),
-                   " stat:", String.format("%1.2f", statModifier),
-                   " res:", String.format("%1.2f", resMod), "(",
-                   String.format("%1.2f", profModifier), "/",
-                   String.format("%1.2f", vulnModifier),
-                   ") elem:", String.valueOf(elementModifier),
+                   " landRateModif:", String.format("%1.2f", skillLandRateModifier),
                    " mAtk:", String.format("%1.2f", mAtkModifier),
                    " ss:", String.valueOf(ssModifier),
                    " lvl:", String.valueOf(deltamod),
@@ -2628,10 +2642,10 @@
        }

        int value = (int) skill.getPower(isPvP);
-       double statModifier = calcSkillStatModifier(skill, target);

-       // Calculate BaseRate.
-       int rate = (int) (value * statModifier);
+       double skillLandRateModifier = calcSkillLandRateModifier(skill, null, attacker, target);
+       // Calculate BaseRate influenced by base stats and resists/vulnerabilities.
+       int rate = (int) (value / skillLandRateModifier);

        // Add Matk/Mdef Bonus
        double mAtkModifier = 0;
@@ -2655,24 +2669,6 @@
            rate = (int) (rate * mAtkModifier);
        }

-       // Resists
-       double vulnModifier = calcSkillVulnerability(attacker, target, skill);
-       double profModifier = calcSkillProficiency(skill, attacker, target);
-       double res = vulnModifier + profModifier;
-       double resMod = 1;
-       if (res != 0)
-       {
-           if (res < 0)
-           {
-               resMod = 1 - 0.075 * res;
-               resMod = 1 / resMod;
-           }
-           else
-               resMod = 1 + 0.02 * res;
-
-           rate *= resMod;
-       }
-
        int elementModifier = calcElementModifier(attacker, target, skill);
        rate += elementModifier;

@@ -2692,10 +2688,7 @@
                    skill.getName(),
                    " type:", skill.getSkillType().toString(),
                    " power:", String.valueOf(value),
-                   " stat:", String.format("%1.2f", statModifier),
-                   " res:", String.format("%1.2f", resMod), "(",
-                   String.format("%1.2f", profModifier), "/",
-                   String.format("%1.2f", vulnModifier),
+                   " landRateModif:", String.format("%1.2f", skillLandRateModifier),
                    ") elem:", String.valueOf(elementModifier),
                    " mAtk:", String.format("%1.2f", mAtkModifier),
                    " ss:", String.valueOf(ssModifier),
@@ -2724,9 +2717,11 @@
            return false;

        int value = (int) skill.getPower(target instanceof L2Playable);
-       double statModifier = calcSkillStatModifier(skill, target);
-       int rate = (int) (value * statModifier);

+       double skillLandRateModifier = calcSkillLandRateModifier(skill, null, attacker.getOwner(), target);
+       // Calculate BaseRate influenced by base stats and resists/vulnerabilities.
+       int rate = (int) (value / skillLandRateModifier);
+
        // Add Matk/Mdef Bonus
        double mAtkModifier = 0;
        if (skill.isMagic())
@@ -2740,24 +2735,6 @@
            rate += (int) (mAtkModifier * 100) - 100;
        }

-       // Resists
-       double vulnModifier = calcSkillVulnerability(attacker.getOwner(), target, skill);
-       double profModifier = calcSkillProficiency(skill, attacker.getOwner(), target);
-       double res = vulnModifier + profModifier;
-       double resMod = 1;
-       if (res != 0)
-       {
-           if (res < 0)
-           {
-               resMod = 1 - 0.075 * res;
-               resMod = 1 / resMod;
-           }
-           else
-               resMod = 1 + 0.02 * res;
-
-           rate *= resMod;
-       }
-
        int elementModifier = calcElementModifier(attacker.getOwner(), target, skill);
        rate += elementModifier;

@@ -2777,10 +2754,7 @@
                    skill.getName(),
                    " type:", skill.getSkillType().toString(),
                    " power:", String.valueOf(value),
-                   " stat:", String.format("%1.2f", statModifier),
-                   " res:", String.format("%1.2f", resMod), "(",
-                   String.format("%1.2f", profModifier), "/",
-                   String.format("%1.2f", vulnModifier),
+                   " landRateModif:", String.format("%1.2f", skillLandRateModifier),
                    ") elem:", String.valueOf(elementModifier),
                    " mAtk:", String.format("%1.2f", mAtkModifier),
                    " lvl:", String.valueOf(deltamod),