API tools faq
paste
Advertisement
Nik

More retail-like resists/profs [Freya]

Nik
Sep 26th, 2011
221
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Diff 7.34 KB | None | 0 0
raw download clone embed print report
  1. Index: java/com/l2jserver/gameserver/skills/Formulas.java
  2. ===================================================================
  3. --- java/com/l2jserver/gameserver/skills/Formulas.java  (revision 4943)
  4. +++ java/com/l2jserver/gameserver/skills/Formulas.java  (working copy)
  5. @@ -2444,15 +2444,51 @@
  6.         return multiplier;
  7.     }
  8.    
  9. +   /**
  10. +    * This method is used as <b>divider</b> for the skill's base power.
  11. +    * @return statBonus value for this skill's saveVs
  12. +    */
  13.     public static double calcSkillStatModifier(L2Skill skill, L2Character target)
  14.     {
  15.         final BaseStats saveVs = skill.getSaveVs();
  16.         if (saveVs == null)
  17.             return 1;
  18.        
  19. -       return 1 / saveVs.calcBonus(target);
  20. +       return saveVs.calcBonus(target);
  21.     }
  22.    
  23. +   /**
  24. +    * This method is used as <b>divider</b> for the skill's base power.
  25. +    * @return skill stat modifier changed by the attacker's skill prof and target's skill resist.
  26. +    */
  27. +   public static double calcSkillLandRateModifier(L2Skill skill, L2Character attacker, L2Character target)
  28. +   {
  29. +       double retval = calcSkillStatModifier(skill, target);
  30. +  
  31. +       //          "-" if resistant, "+" if vulnerable         "-" for negative proficiency, "+" for positive proficiency
  32. +       double vuln = calcSkillTypeVulnerability(0, target, skill.getSkillType()) + calcSkillTypeProficiency(0, attacker, target, skill.getSkillType());
  33. +      
  34. +       if (vuln == 0)
  35. +           return retval;
  36. +      
  37. +       if (vuln < 0) // If negative vulnerability (target has resist), multiply base resist with that resist.
  38. +       {
  39. +           vuln *= -1; // Make this variable positive, because its negative. We dont want to return negative double.
  40. +           vuln /= 100; // divide by 100 in order to get percent value.
  41. +           vuln += 1; // Since we work with percents, always add +1 to prevent 0.x values.
  42. +           retval *= vuln;
  43. +       }
  44. +       else // If positive vulnerability (target has vulnerability), divide base resist with that resist.
  45. +       {
  46. +           vuln /= 100; // divide by 100 in order to get percent value.
  47. +           vuln += 1; // Since we work with percents, always add +1 to prevent 0.x values.
  48. +           retval /= vuln;
  49. +       }
  50. +      
  51. +       return retval;
  52. +      
  53. +   }
  54. +  
  55.     public static int calcLvlDependModifier(L2Character attacker, L2Character target, L2Skill skill)
  56.     {
  57.         if (skill.getLevelDepend() == 0)
  58. @@ -2523,11 +2559,10 @@
  59.             return false;
  60.         }
  61.        
  62. -       double statModifier = calcSkillStatModifier(skill, target);
  63. +       double skillLandRateModifier = calcSkillLandRateModifier(skill, attacker, target);
  64. +       // Calculate BaseRate influenced by base stats and resists/vulnerabilities.
  65. +       int rate = (int) (value / skillLandRateModifier);
  66.        
  67. -       // Calculate BaseRate.
  68. -       int rate = (int) (value * statModifier);
  69. -      
  70.         // Add Matk/Mdef Bonus
  71.         double mAtkModifier = 0;
  72.         int ssModifier = 0;
  73. @@ -2550,27 +2585,6 @@
  74.             rate = (int) (rate * mAtkModifier);
  75.         }
  76.        
  77. -       // Resists
  78. -       double vulnModifier = calcSkillTypeVulnerability(0, target, type);
  79. -       double profModifier = calcSkillTypeProficiency(0, attacker, target, type);
  80. -       double res = vulnModifier + profModifier;
  81. -       double resMod = 1;
  82. -       if (res != 0)
  83. -       {
  84. -           if (res < 0)
  85. -           {
  86. -               resMod = 1 - 0.075 * res;
  87. -               resMod = 1 / resMod;
  88. -           }
  89. -           else
  90. -               resMod = 1 + 0.02 * res;
  91. -          
  92. -           rate *= resMod;
  93. -       }
  94. -      
  95. -       int elementModifier = calcElementModifier(attacker, target, skill);
  96. -       rate += elementModifier;
  97. -      
  98.         //lvl modifier.
  99.         int deltamod = calcLvlDependModifier(attacker, target, skill);
  100.         rate += deltamod;
  101. @@ -2587,11 +2601,7 @@
  102.                     skill.getName(),
  103.                     " eff.type:", type.toString(),
  104.                     " power:", String.valueOf(value),
  105. -                   " stat:", String.format("%1.2f", statModifier),
  106. -                   " res:", String.format("%1.2f", resMod), "(",
  107. -                   String.format("%1.2f", profModifier), "/",
  108. -                   String.format("%1.2f", vulnModifier),
  109. -                   ") elem:", String.valueOf(elementModifier),
  110. +                   " landRateModif:", String.format("%1.2f", skillLandRateModifier),
  111.                     " mAtk:", String.format("%1.2f", mAtkModifier),
  112.                     " ss:", String.valueOf(ssModifier),
  113.                     " lvl:", String.valueOf(deltamod),
  114. @@ -2628,10 +2638,10 @@
  115.         }
  116.        
  117.         int value = (int) skill.getPower(isPvP);
  118. -       double statModifier = calcSkillStatModifier(skill, target);
  119.        
  120. -       // Calculate BaseRate.
  121. -       int rate = (int) (value * statModifier);
  122. +       double skillLandRateModifier = calcSkillLandRateModifier(skill, attacker, target);
  123. +       // Calculate BaseRate influenced by base stats and resists/vulnerabilities.
  124. +       int rate = (int) (value / skillLandRateModifier);
  125.        
  126.         // Add Matk/Mdef Bonus
  127.         double mAtkModifier = 0;
  128. @@ -2655,24 +2665,6 @@
  129.             rate = (int) (rate * mAtkModifier);
  130.         }
  131.        
  132. -       // Resists
  133. -       double vulnModifier = calcSkillVulnerability(attacker, target, skill);
  134. -       double profModifier = calcSkillProficiency(skill, attacker, target);
  135. -       double res = vulnModifier + profModifier;
  136. -       double resMod = 1;
  137. -       if (res != 0)
  138. -       {
  139. -           if (res < 0)
  140. -           {
  141. -               resMod = 1 - 0.075 * res;
  142. -               resMod = 1 / resMod;
  143. -           }
  144. -           else
  145. -               resMod = 1 + 0.02 * res;
  146. -          
  147. -           rate *= resMod;
  148. -       }
  149. -      
  150.         int elementModifier = calcElementModifier(attacker, target, skill);
  151.         rate += elementModifier;
  152.        
  153. @@ -2692,10 +2684,7 @@
  154.                     skill.getName(),
  155.                     " type:", skill.getSkillType().toString(),
  156.                     " power:", String.valueOf(value),
  157. -                   " stat:", String.format("%1.2f", statModifier),
  158. -                   " res:", String.format("%1.2f", resMod), "(",
  159. -                   String.format("%1.2f", profModifier), "/",
  160. -                   String.format("%1.2f", vulnModifier),
  161. +                   " landRateModif:", String.format("%1.2f", skillLandRateModifier),
  162.                     ") elem:", String.valueOf(elementModifier),
  163.                     " mAtk:", String.format("%1.2f", mAtkModifier),
  164.                     " ss:", String.valueOf(ssModifier),
  165. @@ -2724,9 +2713,11 @@
  166.             return false;
  167.        
  168.         int value = (int) skill.getPower(target instanceof L2Playable);
  169. -       double statModifier = calcSkillStatModifier(skill, target);
  170. -       int rate = (int) (value * statModifier);
  171.        
  172. +       double skillLandRateModifier = calcSkillLandRateModifier(skill, attacker.getOwner(), target);
  173. +       // Calculate BaseRate influenced by base stats and resists/vulnerabilities.
  174. +       int rate = (int) (value / skillLandRateModifier);      
  175. +      
  176.         // Add Matk/Mdef Bonus
  177.         double mAtkModifier = 0;
  178.         if (skill.isMagic())
  179. @@ -2740,24 +2731,6 @@
  180.             rate += (int) (mAtkModifier * 100) - 100;
  181.         }
  182.        
  183. -       // Resists
  184. -       double vulnModifier = calcSkillVulnerability(attacker.getOwner(), target, skill);
  185. -       double profModifier = calcSkillProficiency(skill, attacker.getOwner(), target);
  186. -       double res = vulnModifier + profModifier;
  187. -       double resMod = 1;
  188. -       if (res != 0)
  189. -       {
  190. -           if (res < 0)
  191. -           {
  192. -               resMod = 1 - 0.075 * res;
  193. -               resMod = 1 / resMod;
  194. -           }
  195. -           else
  196. -               resMod = 1 + 0.02 * res;
  197. -          
  198. -           rate *= resMod;
  199. -       }
  200. -      
  201.         int elementModifier = calcElementModifier(attacker.getOwner(), target, skill);
  202.         rate += elementModifier;
  203.        
  204. @@ -2777,10 +2750,7 @@
  205.                     skill.getName(),
  206.                     " type:", skill.getSkillType().toString(),
  207.                     " power:", String.valueOf(value),
  208. -                   " stat:", String.format("%1.2f", statModifier),
  209. -                   " res:", String.format("%1.2f", resMod), "(",
  210. -                   String.format("%1.2f", profModifier), "/",
  211. -                   String.format("%1.2f", vulnModifier),
  212. +                   " landRateModif:", String.format("%1.2f", skillLandRateModifier),
  213.                     ") elem:", String.valueOf(elementModifier),
  214.                     " mAtk:", String.format("%1.2f", mAtkModifier),
  215.                     " lvl:", String.valueOf(deltamod),
  216.  
  217.  
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!