Difference between revisions of "User:Trang Oul/Utils"

From Basin Wiki
Jump to navigation Jump to search
m (integer division)
(script overhaul - not it prints the entire wiki table)
Line 199: Line 199:
  
 
The following Python script can be used to simplify the formula and calculate values per level.
 
The following Python script can be used to simplify the formula and calculate values per level.
−
One can paste it into Python's interactive console and then use the utils while editing our Wiki.
 
  
  
 
<pre>
 
<pre>
 +
#coding: utf-8
 +
 
import sympy
 
import sympy
  
 
FRAMES_PER_SECOND:int = 25
 
FRAMES_PER_SECOND:int = 25
  
−
lvl, par1, par2, par3, par4, par5, par6, par7, par8 = sympy.symbols('lvl, par1, par2, par3, par4, par5, par6, par7, par8', integer=True)
+
 
 +
lvl, par1, par2, par3, par4, par5, par6, par7, par8, base, lev1, lev2, lev3, lev4, lev5 = sympy.symbols('lvl, par1, par2, par3, par4, par5, par6, par7, par8, base, lev1, lev2, lev3, lev4, lev5', integer=True)
 +
 
 +
 
  
 
# the formulae are the same per category, but for ease of use they are defined with names from skillcalc.txt
 
# the formulae are the same per category, but for ease of use they are defined with names from skillcalc.txt
−
ln12 = par1 + (lvl - 1) * par2
+
ln12_sympy: sympy.core.expr.Expr = par1 + (lvl - 1) * par2
−
ln34 = par3 + (lvl - 1) * par4
+
ln34_sympy: sympy.core.expr.Expr = par3 + (lvl - 1) * par4
−
ln56 = par5 + (lvl - 1) * par6
+
ln56_sympy: sympy.core.expr.Expr = par5 + (lvl - 1) * par6
−
ln78 = par7 + (lvl - 1) * par8
+
ln78_sympy: sympy.core.expr.Expr = par7 + (lvl - 1) * par8
−
dm12 = sympy.floor(((110 * lvl) * (par2 - par1)) / (100 * (lvl + 6))) + par1 #floor because of the integer division
+
 
−
dm34 = sympy.floor(((110 * lvl) * (par4 - par3)) / (100 * (lvl + 6))) + par3
+
dm12_sympy: sympy.core.expr.Expr = sympy.floor(((110 * lvl) * (par2 - par1)) / (100 * (lvl + 6))) + par1 #floor because of the integer division
−
dm56 = sympy.floor(((110 * lvl) * (par6 - par5)) / (100 * (lvl + 6))) + par5
+
dm34_sympy: sympy.core.expr.Expr = sympy.floor(((110 * lvl) * (par4 - par3)) / (100 * (lvl + 6))) + par3
−
dm78 = sympy.floor(((110 * lvl) * (par8 - par7)) / (100 * (lvl + 6))) + par7
+
dm56_sympy: sympy.core.expr.Expr = sympy.floor(((110 * lvl) * (par6 - par5)) / (100 * (lvl + 6))) + par5
 +
dm78_sympy: sympy.core.expr.Expr = sympy.floor(((110 * lvl) * (par8 - par7)) / (100 * (lvl + 6))) + par7
 +
 
 +
 
 +
levelwise3_sympy: sympy.core.expr.Expr = sympy.Piecewise(
 +
(base,                                                                                        lvl == 1),
 +
(base + lev1 * (lvl-1),                                                                        lvl <= 8),
 +
(base + lev1 * 7      + lev2 * (lvl-8),                                                      lvl <= 16),
 +
(base + lev1 * 7      + lev2 * 8      + lev3 * (lvl-16),                                    True)
 +
)
 +
 
 +
levelwise5_sympy: sympy.core.expr.Expr= sympy.Piecewise(
 +
(base,                                                                                        lvl == 1),
 +
(base + lev1 * (lvl-1),                                                                        lvl <= 8),
 +
(base + lev1 * 7      + lev2 * (lvl-8),                                                      lvl <= 16),
 +
(base + lev1 * 7      + lev2 * 8      + lev3 * (lvl-16),                                    lvl <= 22),
 +
(base + lev1 * 7      + lev2 * 8      + lev3 * 6        + lev4 * (lvl-22),                  lvl <= 28),
 +
(base + lev1 * 7      + lev2 * 8      + lev3 * 6        + lev4 * 6        + lev5 * (lvl-28), True),
 +
)
 +
 
 +
def make_formula(formula:str) -> sympy.core.expr.Expr:
 +
FORMULA_PARTS: dict[str, sympy.core.expr.Expr] = {
 +
'lvl' : lvl,
 +
'par1' : par1,
 +
'par2' : par2,
 +
'par3' : par3,
 +
'par4' : par4,
 +
'par5' : par5,
 +
'par6' : par6,
 +
'par7' : par7,
 +
'par8' : par8,
 +
'base' : base,
 +
'lev1' : lev1,
 +
'lev2' : lev2,
 +
'lev3' : lev3,
 +
'lev4' : lev4,
 +
'lev5' : lev5,
 +
'ln12' : ln12_sympy,
 +
'ln34' : ln34_sympy,
 +
'ln56' : ln56_sympy,
 +
'ln78' : ln78_sympy,
 +
'dm12' : dm12_sympy,
 +
'dm34' : dm34_sympy,
 +
'dm56' : dm56_sympy,
 +
'dm78' : dm78_sympy,
 +
'levelwise3': levelwise3_sympy,
 +
'levelwise5': levelwise5_sympy,
 +
}
 +
return sympy.sympify(formula, FORMULA_PARTS)
 +
 
  
−
FORMULA_PARTS = {
+
# the formulae are the same per category, but for ease of use they are defined with names from skillcalc.txt
−
'lvl' : lvl,
+
def ln12_py(lvl:int, par1:int, par2:int) -> int: return par1 + (lvl - 1) * par2
−
'par1' : par1,
+
def ln34_py(lvl:int, par3:int, par4:int) -> int: return par3 + (lvl - 1) * par4
−
'par2' : par2,
+
def ln56_py(lvl:int, par5:int, par6:int) -> int: return par5 + (lvl - 1) * par6
−
'par3' : par3,
+
def ln78_py(lvl:int, par7:int, par8:int) -> int: return par7 + (lvl - 1) * par9
−
'par4' : par4,
 
−
'par5' : par5,
 
−
'par6' : par6,
 
−
'par7' : par7,
 
−
'par8' : par8,
 
−
'ln12' : ln12,
 
−
'ln34' : ln34,
 
−
'ln56' : ln56,
 
−
'ln78' : ln78,
 
−
'dm12' : dm12,
 
−
'dm34' : dm34,
 
−
'dm56' : dm56,
 
−
'dm78' : dm78,
 
−
}
 
  
 +
def dm12_py(lvl:int, par1:int, par2:int) -> int: return ((110 * lvl) * (par2 - par1)) // (100 * (lvl + 6)) + par1
 +
def dm34_py(lvl:int, par3:int, par4:int) -> int: return ((110 * lvl) * (par4 - par3)) // (100 * (lvl + 6)) + par3
 +
def dm56_py(lvl:int, par5:int, par6:int) -> int: return ((110 * lvl) * (par6 - par5)) // (100 * (lvl + 6)) + par5
 +
def dm78_py(lvl:int, par7:int, par8:int) -> int: return ((110 * lvl) * (par8 - par7)) // (100 * (lvl + 6)) + par7
  
  
−
def print_expr(expr, seconds:bool=False) -> None:
+
def levelwise3_py(lvl:int, base:int, lev1:int, lev2:int, lev3:int) -> int:
 
"""
 
"""
−
Prints the simplified formula.
+
Formula based on level ranges (with 5 ranges).
−
For time prints two formulae, with integers and fractions - use the "better" looking one.
+
Base and values per level range are defined in columns, for example:
−
TODO: for time automatically print integer formula if possible (109 instead of 109.0) of float otherwise.
+
EMin, EMinLev1, EMinLev2, EMinLev3, EMinLev4, EMinLev5
 +
ELen, ELevLen1, ELevLen2, ELevLen3
 +
Level ranges are hardcoded, as described in https://d2mods.info/forum/viewtopic.php?t=41556
 
"""
 
"""
−
if not seconds:
+
if lvl == 1:
−
expr.expand(frac=True)
+
return base
−
print(expr)
+
if lvl <= 8:
 +
return base + lev1 * (lvl-1)
 +
if lvl <= 16:
 +
return base + lev1 * 7      + lev2 * (lvl-8)
 
else:
 
else:
−
expr /= FRAMES_PER_SECOND
+
return base + lev1 * 7      + lev2 * 8      + lev3 * (lvl-16)
−
expr = expr.expand(frac=True)
 
−
print(expr)
 
−
print(expr.evalf())
 
−
 
 
  
−
def table(expr, params:dict|None=None, maxlvl:int=60, seconds:bool=False) -> None:
+
def levelwise5_py(lvl:int, base:int, lev1:int, lev2:int, lev3:int, lev4:int, lev5:int) -> int:
 
"""
 
"""
−
Prints the simplified formula and the table with values for each level.
+
Formula based on level ranges (with 3 ranges).
−
seconds - convert result from frames (default unit) to seconds. To be used for time values.
+
Base and values per level range are defined in columns, for example:
 +
ELen, ELevLen1, ELevLen2, ELevLen3
 +
Level ranges are hardcoded, as described in https://d2mods.info/forum/viewtopic.php?t=41556
 
"""
 
"""
−
if params is None:
+
if lvl == 1:
−
params = {}
+
return base
 +
if lvl <= 8:
 +
return base + lev1 * (lvl-1)
 +
if lvl <= 16:
 +
return base + lev1 * 7      + lev2 * (lvl-8)
 +
if lvl <= 22:
 +
return base + lev1 * 7      + lev2 * 8      + lev3 * (lvl-16)
 +
if lvl <= 28:
 +
return base + lev1 * 7      + lev2 * 8      + lev3 * 6        + lev4 * (lvl-22)
 +
else:
 +
return base + lev1 * 7      + lev2 * 8      + lev3 * 6        + lev4 * 6        + lev5 * (lvl-28)
 +
 
 +
 
 +
class Stat:
 +
def __init__(self, desc:str, formula, params:dict|None=None, seconds:bool=False) -> None:
 +
if params is None:
 +
params = {}
 +
self.desc = desc
 +
self.params = params
 +
self.formula = self.make_formula(formula, seconds)
 +
if isinstance(self.formula, sympy.core.expr.Expr):
 +
print(self.desc)
 +
self.print_expr(seconds)
 +
 +
@classmethod
 +
def make_formula(cls, formula, seconds:bool=False):
 +
if isinstance(formula, str):
 +
formula = make_formula(formula)
 +
 +
if seconds:
 +
if isinstance(formula, sympy.core.expr.Expr):
 +
return formula / FRAMES_PER_SECOND
 +
else:
 +
return lambda **params: formula(**params) / FRAMES_PER_SECOND
 +
return formula
 +
 +
 +
@classmethod
 +
def round(cls, val) -> int|float:
 +
ival: int  = int(val)
 +
fval: float = float(val)
 +
return ival if ival == fval else fval
 +
 +
def _eval_sympy(self, slvl:int) -> int|float:
 +
return self.round((self.formula.subs({lvl: slvl} | self.params)))
 +
 +
def _eval_py(self, slvl:int) -> int|float:
 +
params: dict[str, int] = {param.name: value for param, value in self.params.items()}
 +
return self.round(self.formula(lvl=slvl, **params))
 
 
−
if isinstance(expr, str):
+
def eval(self, slvl:int) -> int|float:
−
expr = sympy.sympify(expr, locals=FORMULA_PARTS)
+
if isinstance(self.formula, sympy.core.expr.Expr):
 +
return self._eval_sympy(slvl)
 +
else:
 +
return self._eval_py(slvl)
 
 
−
expr = expr.subs(params)
+
def print_expr(self, seconds:bool=False) -> None:
−
expr = expr.simplify()
+
expr: sympy.core.expr.Expr = self.formula.subs(self.params)
−
print_expr(expr, seconds)
+
expr = expr.simplify()
−
for slvl in range(1, maxlvl+1):
+
print(expr)
−
value = expr.subs({lvl : slvl})
 
−
value = int(value) #D2 USES INTEGERS
 
 
if seconds:
 
if seconds:
−
value /= FRAMES_PER_SECOND
+
print(expr.evalf())
−
print(slvl, value, sep='\t')
 
−
#TODO: build wiki table instead of simply printing the values
 
  
  
−
def levelwise(base:int, lvls1:int, lvls2:int, lvls3:int, lvls4:int, lvls5:int):
+
def build_table(stats, maxlvl:int=60, splitlvl:int=10):
−
"""
+
'''
−
Builds a piecewise formula based on values per each level range.  
+
Builds a wiki table of given stats for given level range.
−
Level ranges are hardcoded: 1, 2-8, 9-16, 17-22, 22-28, >28.
+
'''
−
https://d2mods.info/forum/kb/viewarticle?a=440
+
−
"""
+
return '\n\n'.join(
−
return sympy.Piecewise(
+
f'''{{{{Levels {lvl_group+1}-{lvl_group+splitlvl}}}}}
−
(base,                                                                                              lvl == 1),
+
{'\n'.join(f'|-\n!align=left|{stat.desc}\n|{"||".join(str(stat.eval(lvl_group+lvl_unit)) for lvl_unit in range(1, splitlvl+1))}' for stat in stats)}
−
(base + lvls1 * (lvl-1),                                                                            lvl <= 8),
+
|}}''' for lvl_group in range(0, maxlvl, splitlvl)
−
(base + lvls1 * 7      + lvls2 * (lvl-8),                                                          lvl <= 16),
 
−
(base + lvls1 * 7      + lvls2 * 8      + lvls3 * (lvl-16),                                      lvl <= 22),
 
−
(base + lvls1 * 7      + lvls2 * 8      + lvls3 * 6        + lvls4 * (lvl-22),                    lvl <= 28),
 
−
(base + lvls1 * 7      + lvls2 * 8      + lvls3 * 6        + lvls4 * 6        + lvls5 * (lvl-28), True),
 
 
)
 
)
  
−
# sample usage
 
−
table(ln34,      {par3 : -15, par4 : 3},          maxlvl=6)                #Jab damage
 
−
table(ln12,      {par1 : 300, par2 : 60},          maxlvl=6,  seconds=True) #Battle Cry duration
 
−
table(dm34,      {par3 : 0,  par4 : 75},          maxlvl=6)                #Clay Golem slow
 
−
table(dm12,      {par1 : 50,  par2 : 500},        maxlvl=60, seconds=True) #Blaze duration
 
−
table(ln34/par5, {par3 : 26,  par4 : 1,  par5:5}, maxlvl=6)                #Chain Lightining hits
 
  
−
# For min and max use sympy functions instead of Python's
+
"""
−
# or use expression from data file directly as string (does not work with all formulae, such as with conditionals - see below).
+
USAGE
−
table(sympy.Min(par3 + lvl - 1, par4), {par3 : 4, par4 : 10}, maxlvl=6) #Strafe min hits
+
Make a list of stats to be included in the table of values (levels 1-60).
−
table(    'min(par3 + lvl - 1, par4)', {par3 : 4, par4 : 10}, maxlvl=6) #Strafe min hits
+
Formulae can be defined in three ways:
 +
1. Pure Python: use Python functions - either defined here (fun_py) or other named or lambda functions, with lvl as the first param in addition to formula params.
 +
2. SymPy: use SymPy expressions - either defined here (fun_sympy) or other expressions, using appropriate SymPy functions (for exampe sympy.Min instead of min).
 +
3. Formula as string directly from the data file. Allowed formula parts: lvl, parameters (parX), functions (lnXY and dmXY) and some math functions (min, max). Remove synergies to calculate values without them.
 +
See the examples below. Use only one formula per stat; the repeated stats below are to show how to define formulae.
 +
 
 +
For level-based values, use "levelwise" formulae, either for 3 or 5 columns.
 +
To convert time values from frames to seconds, set the "seconds" flag.
 +
 
 +
For SymPy (or string) formulae simplified formulae are also printed.
 +
For time values formulae with integer and decimal coefficients are printed.
 +
"""
 +
 
 +
stats: tuple[Stat] = (
 +
Stat(desc='Inner Sight Duration (Seconds)',  formula=ln34_py,                                                                params={par3: 300, par4: 150}, seconds=True),
 +
Stat(desc='Inner Sight Duration (Seconds)',  formula=ln34_sympy,                                                            params={par3: 300, par4: 150}, seconds=True),
 +
Stat(desc='Inner Sight Duration (Seconds)',  formula='ln34',                                                                params={par3: 300, par4: 150}, seconds=True),
 +
Stat(desc='Slow Missiles [[Missile]] Speed %', formula=lambda lvl,par1,par2: 100-dm12_py(lvl, par1, par2),                  params={par1: 25,  par2: 75}),
 +
Stat(desc='Slow Missiles [[Missile]] Speed %', formula=                      100-dm12_sympy,                                params={par1: 25,  par2: 75}),
 +
Stat(desc='Slow Missiles [[Missile]] Speed %', formula=                    '100-dm12',                                      params={par1: 25,  par2: 75}),
 +
Stat(desc='Impale Durability loss chance %', formula=lambda lvl,par3,par4,par6: par6-dm34_py(lvl, par3, par4),              params={par3: 0,  par4: 30,  par6: 50}),
 +
Stat(desc='Impale Durability loss chance %', formula=                          par6-dm34_sympy,                            params={par3: 0,  par4: 30,  par6: 50}),
 +
Stat(desc='Impale Durability loss chance %', formula=                          'par6-dm34',                                  params={par3: 0,  par4: 30,  par6: 50}),
 +
Stat(desc='Thunderstorm perdelay', formula=lambda lvl,par3,par4,par5,par6: (100-dm56_py(lvl, par5, par6)) * par4/100 + par3, params={par3: 25,  par4: 100, par5: 0, par6: 100}, seconds=True),
 +
Stat(desc='Thunderstorm perdelay', formula=                                (100-dm56_sympy) * par4/100 + par3,              params={par3: 25,  par4: 100, par5: 0, par6: 100}, seconds=True),
 +
Stat(desc='Thunderstorm perdelay', formula=                              '(100-dm56) * par4/100 + par3',                    params={par3: 25,  par4: 100, par5: 0, par6: 100}, seconds=True),
 +
Stat(desc='Battle Cry duration (Seconds)', formula= ln12_py,                                                                params={par1: 300, par2: 60}, seconds=True),
 +
Stat(desc='Battle Cry duration (Seconds)', formula= ln12_sympy,                                                              params={par1: 300, par2: 60}, seconds=True),
 +
Stat(desc='Battle Cry duration (Seconds)', formula='ln12',                                                                  params={par1: 300, par2: 60}, seconds=True),
 +
Stat(desc='Chain Lightning hits', formula=lambda lvl, par3, par4, par5: ln34_py(lvl, par3, par4) / par5,                    params={par3: 26,  par4: 1, par5: 5}),
 +
Stat(desc='Chain Lightning hits', formula=                              ln34_sympy              / par5,                    params={par3: 26,  par4: 1, par5:5}),
 +
Stat(desc='Chain Lightning hits', formula=                            'ln34/par5',                                          params={par3: 26,  par4: 1, par5:5}),
 +
Stat(desc='Strafe min hits', formula=lambda lvl, par3, par4: min(par3 + lvl - 1, par4),                                      params={par3: 4,  par4: 10}),
 +
Stat(desc='Strafe min hits', formula=                  sympy.Min(par3 + lvl - 1, par4),                                     params={par3: 4, par4: 10}),
 +
Stat(desc='Strafe min hits', formula=                      'min(par3 + lvl - 1, par4)',                                     params={par3: 4, par4: 10}),
 +
Stat(desc='Prayer healing', formula=levelwise5_py,                                                                          params={base: 2, lev1: 1, lev2: 1, lev3: 2, lev4: 2, lev5: 3}),
 +
Stat(desc='Prayer healing', formula=levelwise5_sympy,                                                                        params={base: 2, lev1: 1, lev2: 1, lev3: 2, lev4: 2, lev5: 3}),
 +
Stat(desc='Prayer healing', formula='levelwise5',                                                                           params={base: 2, lev1: 1, lev2: 1, lev3: 2, lev4: 2, lev5: 3}),
 +
Stat(
 +
desc='Energy shield absorption',
 +
formula=lambda lvl, base, lev1, lev2, lev3, lev4, lev5: min(levelwise5_py(lvl, base, lev1, lev2, lev3, lev4, lev5), 95),
 +
params={base: 20, lev1: 5, lev2: 2, lev3: 1, lev4: 1, lev5: 1}
 +
),
 +
Stat(desc='Energy shield absorption',
 +
formula=sympy.Min(levelwise5_sympy, 95),
 +
params={base: 20, lev1: 5, lev2: 2, lev3: 1, lev4: 1, lev5: 1}
 +
),
 +
Stat(desc='Energy shield absorption',
 +
formula='min(levelwise5, 95)',
 +
params={base: 20, lev1: 5, lev2: 2, lev3: 1, lev4: 1, lev5: 1}
 +
),
 +
Stat(desc='Spirit Wolf coldlength', formula=levelwise3_py,        params={base: 25,  lev1: 25, lev2: 25, lev3: 25}, seconds=True),
 +
Stat(desc='Spirit Wolf coldlength', formula=levelwise3_sympy,    params={base: 25,  lev1: 25, lev2: 25, lev3: 25}, seconds=True),
 +
Stat(desc='Spirit Wolf coldlength', formula='levelwise3',        params={base: 25,  lev1: 25, lev2: 25, lev3: 25}, seconds=True),
 +
Stat(desc='Chilling Armor cold length', formula=levelwise3_py,    params={base: 100, lev1: 0,  lev2: 25, lev3: 25}, seconds=True),
 +
Stat(desc='Chilling Armor cold length', formula=levelwise3_sympy, params={base: 100, lev1: 0,  lev2: 25, lev3: 25}, seconds=True),
 +
Stat(desc='Chilling Armor cold length', formula='levelwise3',    params={base: 100, lev1: 0,  lev2: 25, lev3: 25}, seconds=True),
 +
)
  
−
# For "condition ? value_if_true : value_if_false" use Piecewise((value_if_true, condition), (value_if_false, True)).
+
print(build_table(stats))
−
# The True in the second param acts as "else" (i.e. the first value when the first condition is met, or the second otherwise - hence the second condition is always met).
 
−
table(sympy.Piecewise((lvl, lvl < 4), (2 + lvl / 3, True)), maxlvl=6) #Max Skeletons
 
  
−
# For progression based on level ranges, use the "levelwise" util to make a piecewise function.
+
stats = (
−
# Provide base and values per level groups, padding with zeroes if needed (for ELen... - there are no ELenLev4 and ELenLev5 cols).
+
#build your own table
−
table          (levelwise(2,  1, 1, 2, 2, 3),      maxlvl=6) #Prayer healing
+
)
−
table(sympy.Min(levelwise(20, 5, 2, 1, 1, 1), 95), maxlvl=6) #Energy shield absorption
+
#print(build_table(stats))
 
</pre>
 
</pre>

Revision as of 04:00, 10 July 2024

Calculating skill params formulae and values per level

This tutorial's goal is to obtain two results:

  • a formula for a given skill's property (damage, range, duration and so on)
  • values for that property at different levels (1-60, as on skill pages).


1. Obtaining data

First we need to find the formulae. They are stored in data files, in skills.txt and in skillcalc.txt. They are ordinary TSV files, and while there are specialized tools for modding Diablo 2, plain old MS Excel suffices, with features like freezing headers, filtering or searching.

This part is based on Phrozen Keep. File: skills.txt

Columns

Formulae

Formulae are stored in the following columns (this list may not be exhaustive):

  • calcX - general skill formulae - see calcX desc for description
  • prgcalcX - Assassin finishers; also Shock Web, Blade Fury
  • auralencalc - length of aura/curse/buff/debuff, in frames
  • aurarangecalc - range of aura/curse/buff/debuff; also used by other skills
  • aurastatcalcX - stats of aura/curse/buff/debuff - see aurastatX for stat name
  • passivecalcX - passive skills - see passivestatX for stat name
  • petmax - max number of pets
  • DmgSymPerCalc - synergy to physical damage
  • EDmgSymPerCalc - synergy to elemental damage
  • ELenSymPerCalc - synergy to the duration of elemental damage
  • cltcalcX - client-side calculations - not used for our purpose


Params

  • ParamX - numeric param used in formula - see ParamX Description for description
  • other columns (including, but not limited toELen..., EMin..., EMax...) - referenced by formulae below.

Formula details

  • hardcoded numbers
  • basic math operators and functions: arithmetic, min, max
  • conditional operator: condition ? value_if_true : value_if_false
  • functions and params as defined in skillcalc.txt:
  • lnXY, dmXY - linear and diminishing (rational) functions. We will be the most interested in these formulae.
All of them use skill level and additional params.
Currently all those functions are the same per category.
  • parX - parameter (column ParamX)
  • lvl - soft skill level (i.e. with bonuses)
  • blvl - base skill level (i.e. only hard points); used mostly for synergies
  • ulvl - character level; used by Druid summons only
  • references to other column or columns - used mostly for progression based on level ranges
Examples:
  • edns - "Elemental Damage Min (256ths)"
Used by Prayer to calculate life regen.
As per Phrozen Keep:
EMin: and EMax: Controls the basic minimum and maximum elemental damage dealt by this skill at sLvl 1.
EMinLev1: to EMinLev5: and EMaxLevDam1: to EMaxLevDam5: Controls the additional elemental damage added to the skills minimum and maximum damage for every additional sLvl.
LevDam1 is used for sLvls 2-8, LevDam2 for 9-16, LevDam3 for 17-22, LevDam4 for 23-28 and LevDam5 for sLvls above 28.
So, Prayer starts with 2 (col EMin) life points at level 1, increasing by 1 per level at levels 2-8 (EMinLev1), again by 1 at levels 9-16 (EMinLev2) and so on, ending by +3 per each level above 28.
  • edmn - "Elemental Damage"
Used for Energy Shield's' Damage % Absorption (min(edmn,95))
It starts at 20% (EMin), increased by 5 percentage points per skill (EMinLev1), then by 2 p.p. (EMinLev2), then by 1 p.p. (EMinLev3, EMinLev4, EMinLev5), capped at 95%.
Notice that although these functions refer to "Elemental Damage" columns, for those skills these columns just hold the values, used for other properties than damage.
  • edmx - "Elemental Damage Max"
Used by Dire Wolf's max cold damage (in D2R); cols EMax....
  • skill('Skill Name'.fun) - reference to another skill - used for synergies:
    Examples:
  • skill('Golem Mastery'.ln12) - ln12 formula calculated using Golem Mastery params.
  • skill('Summon Fenris'.par2) - Param2 of Summon Fenris (i.e. Summon Dire Wolf).
  • skill('Summon Fenris'.lvl) - (soft) skill level of Summon Fenris.
  • stat('stat_name'.fun) - used mostly to make pets inherit character stats
    Examples:


2. Calculation

Examples:

Skill Name Column
description if present		 Formula Params
(besides lvl)		 Simplified Formula Values
(sample)
Jab calc1 : Damage % ln34 Param3=-15, Param4=3 3*lvl - 18
Level Value
1 -15
2 -12
3 -9
Battle Cry auralencalc ln12 Param1=300, Param2=75
Since this is duration, we convert it to seconds by dividing by 25 and allowing fractional values.		 12*lvl/5 + 48/5
or
2.4*lvl + 9.6
Level Value
1 12.0
2 14.4
3 16.8
Clay Golem aurastatcalc1 : item_slow dm34 Param3=0, Param4=75 165*lvl/(2*lvl + 12)
Level Value
1 11
2 20
3 27
Blaze auralencalc dm12 Param3=50, Param4=500
Since this is duration, we convert it to seconds by dividing by 25 and allowing fractional values.		 (109*lvl + 60)/(5*lvl + 30)
Level Value
1 4.8
2 6.92
3 8.6
Chain Lightning calc1 : # of target jump hits ln34/par5 Param3=26, Param4=1, Param5=5 lvl/5 + 5
Level Value
1 5
2 5
5 6
25 10
Strafe aurastatcalc1 : Minimum # of Missiles created min(par3 + lvl - 1, par4) Param3=0, Param4=75 Min(10, lvl + 3)
Level Value
1 4
2 5
7 10
Raise Skeleton petmax (lvl < 4) ?lvl:(2+lvl/3) (none) Piecewise((lvl, lvl < 4), (lvl/3 + 2, True))
Level Value
1 1
2 2
3 3
4 3
Prayer aurastatcalc1 : hitpoints edns EMin...: 2, 1, 1, 2, 2, 3 Piecewise((lvl + 1, (lvl <= 8) | (lvl <= 16)), (2*lvl - 15, (lvl <= 22) | (lvl <= 28)), (3*lvl - 43, True))
Level Value
1 2
2 3
3 4
60 137
Energy Shield aurastatcalc1 : Damage % Absorption min(edmn,95) EMin...: 20, 5, 2, 1, 1, 1 Min(95, Piecewise((5*lvl + 15, lvl <= 8), (2*lvl + 39, lvl <= 16), (lvl + 55, True)))
Level Value
1 20
2 25
3 30
10 59
40 95


The following Python script can be used to simplify the formula and calculate values per level. 


#coding: utf-8

import sympy

FRAMES_PER_SECOND:int = 25


lvl, par1, par2, par3, par4, par5, par6, par7, par8, base, lev1, lev2, lev3, lev4, lev5 = sympy.symbols('lvl, par1, par2, par3, par4, par5, par6, par7, par8, base, lev1, lev2, lev3, lev4, lev5', integer=True)



# the formulae are the same per category, but for ease of use they are defined with names from skillcalc.txt
ln12_sympy: sympy.core.expr.Expr = par1 + (lvl - 1) * par2
ln34_sympy: sympy.core.expr.Expr = par3 + (lvl - 1) * par4
ln56_sympy: sympy.core.expr.Expr = par5 + (lvl - 1) * par6
ln78_sympy: sympy.core.expr.Expr = par7 + (lvl - 1) * par8

dm12_sympy: sympy.core.expr.Expr = sympy.floor(((110 * lvl) * (par2 - par1)) / (100 * (lvl + 6))) + par1 #floor because of the integer division
dm34_sympy: sympy.core.expr.Expr = sympy.floor(((110 * lvl) * (par4 - par3)) / (100 * (lvl + 6))) + par3
dm56_sympy: sympy.core.expr.Expr = sympy.floor(((110 * lvl) * (par6 - par5)) / (100 * (lvl + 6))) + par5
dm78_sympy: sympy.core.expr.Expr = sympy.floor(((110 * lvl) * (par8 - par7)) / (100 * (lvl + 6))) + par7


levelwise3_sympy: sympy.core.expr.Expr = sympy.Piecewise(
		(base,                                                                                         lvl == 1),
		(base + lev1 * (lvl-1),                                                                        lvl <= 8),
		(base + lev1 * 7       + lev2 * (lvl-8),                                                       lvl <= 16),
		(base + lev1 * 7       + lev2 * 8       + lev3 * (lvl-16),                                     True)
	)

levelwise5_sympy: sympy.core.expr.Expr= sympy.Piecewise(
		(base,                                                                                         lvl == 1),
		(base + lev1 * (lvl-1),                                                                        lvl <= 8),
		(base + lev1 * 7       + lev2 * (lvl-8),                                                       lvl <= 16),
		(base + lev1 * 7       + lev2 * 8       + lev3 * (lvl-16),                                     lvl <= 22),
		(base + lev1 * 7       + lev2 * 8       + lev3 * 6        + lev4 * (lvl-22),                   lvl <= 28),
		(base + lev1 * 7       + lev2 * 8       + lev3 * 6        + lev4 * 6        + lev5 * (lvl-28), True),
	)

def make_formula(formula:str) -> sympy.core.expr.Expr:
	FORMULA_PARTS: dict[str, sympy.core.expr.Expr] = {
		'lvl' : lvl,
		'par1' : par1,
		'par2' : par2,
		'par3' : par3,
		'par4' : par4,
		'par5' : par5,
		'par6' : par6,
		'par7' : par7,
		'par8' : par8,
		'base' : base,
		'lev1' : lev1,
		'lev2' : lev2,
		'lev3' : lev3,
		'lev4' : lev4,
		'lev5' : lev5,
		'ln12' : ln12_sympy,
		'ln34' : ln34_sympy,
		'ln56' : ln56_sympy,
		'ln78' : ln78_sympy,
		'dm12' : dm12_sympy,
		'dm34' : dm34_sympy,
		'dm56' : dm56_sympy,
		'dm78' : dm78_sympy,
		'levelwise3': levelwise3_sympy,
		'levelwise5': levelwise5_sympy,
	}
	return sympy.sympify(formula, FORMULA_PARTS)


# the formulae are the same per category, but for ease of use they are defined with names from skillcalc.txt
def ln12_py(lvl:int, par1:int, par2:int) -> int: return par1 + (lvl - 1) * par2
def ln34_py(lvl:int, par3:int, par4:int) -> int: return par3 + (lvl - 1) * par4
def ln56_py(lvl:int, par5:int, par6:int) -> int: return par5 + (lvl - 1) * par6
def ln78_py(lvl:int, par7:int, par8:int) -> int: return par7 + (lvl - 1) * par9

def dm12_py(lvl:int, par1:int, par2:int) -> int: return ((110 * lvl) * (par2 - par1)) // (100 * (lvl + 6)) + par1
def dm34_py(lvl:int, par3:int, par4:int) -> int: return ((110 * lvl) * (par4 - par3)) // (100 * (lvl + 6)) + par3
def dm56_py(lvl:int, par5:int, par6:int) -> int: return ((110 * lvl) * (par6 - par5)) // (100 * (lvl + 6)) + par5
def dm78_py(lvl:int, par7:int, par8:int) -> int: return ((110 * lvl) * (par8 - par7)) // (100 * (lvl + 6)) + par7


def levelwise3_py(lvl:int, base:int, lev1:int, lev2:int, lev3:int) -> int:
	"""
	Formula based on level ranges (with 5 ranges).
	Base and values per level range are defined in columns, for example:
	EMin, EMinLev1, EMinLev2, EMinLev3, EMinLev4, EMinLev5
	ELen, ELevLen1, ELevLen2, ELevLen3
	Level ranges are hardcoded, as described in https://d2mods.info/forum/viewtopic.php?t=41556
	"""
	if lvl == 1:
		return base
	if lvl <= 8:
		return base + lev1 * (lvl-1)
	if lvl <= 16:
		return base + lev1 * 7       + lev2 * (lvl-8)
	else:
		return base + lev1 * 7       + lev2 * 8       + lev3 * (lvl-16)

def levelwise5_py(lvl:int, base:int, lev1:int, lev2:int, lev3:int, lev4:int, lev5:int) -> int:
	"""
	Formula based on level ranges (with 3 ranges).
	Base and values per level range are defined in columns, for example:
	ELen, ELevLen1, ELevLen2, ELevLen3
	Level ranges are hardcoded, as described in https://d2mods.info/forum/viewtopic.php?t=41556
	"""
	if lvl == 1:
		return base
	if lvl <= 8:
		return base + lev1 * (lvl-1)
	if lvl <= 16:
		return base + lev1 * 7       + lev2 * (lvl-8)
	if lvl <= 22:
		return base + lev1 * 7       + lev2 * 8       + lev3 * (lvl-16)
	if lvl <= 28:
		return base + lev1 * 7       + lev2 * 8       + lev3 * 6        + lev4 * (lvl-22)
	else:
		return base + lev1 * 7       + lev2 * 8       + lev3 * 6        + lev4 * 6        + lev5 * (lvl-28)


class Stat:
	def __init__(self, desc:str, formula, params:dict|None=None, seconds:bool=False) -> None:
		if params is None:
			params = {}
		self.desc = desc
		self.params = params
		self.formula = self.make_formula(formula, seconds)
		if isinstance(self.formula, sympy.core.expr.Expr):
			print(self.desc)
			self.print_expr(seconds)
	
	@classmethod
	def make_formula(cls, formula, seconds:bool=False):
		if isinstance(formula, str):
			formula = make_formula(formula)
		
		if seconds:
			if isinstance(formula, sympy.core.expr.Expr):
				return formula / FRAMES_PER_SECOND
			else:
				return lambda **params: formula(**params) / FRAMES_PER_SECOND
		return formula
	
	
	@classmethod
	def round(cls, val) -> int|float:
		ival: int   = int(val)
		fval: float = float(val)
		return ival if ival == fval else fval
	
	def _eval_sympy(self, slvl:int) -> int|float:
		return self.round((self.formula.subs({lvl: slvl} | self.params)))
	
	def _eval_py(self, slvl:int) -> int|float:
		params: dict[str, int] = {param.name: value for param, value in self.params.items()}
		return self.round(self.formula(lvl=slvl, **params))
	
	def eval(self, slvl:int) -> int|float:
		if isinstance(self.formula, sympy.core.expr.Expr):
			return self._eval_sympy(slvl)
		else:
			return self._eval_py(slvl)
	
	def print_expr(self, seconds:bool=False) -> None:
		expr: sympy.core.expr.Expr = self.formula.subs(self.params)
		expr = expr.simplify()
		print(expr)
		if seconds:
			print(expr.evalf())


def build_table(stats, maxlvl:int=60, splitlvl:int=10):
	'''
	Builds a wiki table of given stats for given level range.
	'''
	
	return '\n\n'.join(
		f'''{{{{Levels {lvl_group+1}-{lvl_group+splitlvl}}}}}
{'\n'.join(f'|-\n!align=left|{stat.desc}\n|{"||".join(str(stat.eval(lvl_group+lvl_unit)) for lvl_unit in range(1, splitlvl+1))}' for stat in stats)}
|}}''' for lvl_group in range(0, maxlvl, splitlvl)
	)


"""
USAGE
Make a list of stats to be included in the table of values (levels 1-60).
Formulae can be defined in three ways:
1. Pure Python: use Python functions - either defined here (fun_py) or other named or lambda functions, with lvl as the first param in addition to formula params.
2. SymPy: use SymPy expressions - either defined here (fun_sympy) or other expressions, using appropriate SymPy functions (for exampe sympy.Min instead of min).
3. Formula as string directly from the data file. Allowed formula parts: lvl, parameters (parX), functions (lnXY and dmXY) and some math functions (min, max). Remove synergies to calculate values without them.
See the examples below. Use only one formula per stat; the repeated stats below are to show how to define formulae.

For level-based values, use "levelwise" formulae, either for 3 or 5 columns.
To convert time values from frames to seconds, set the "seconds" flag.

For SymPy (or string) formulae simplified formulae are also printed.
For time values formulae with integer and decimal coefficients are printed.
"""

stats: tuple[Stat] = (
	Stat(desc='Inner Sight Duration (Seconds)',  formula=ln34_py,                                                                params={par3: 300, par4: 150}, seconds=True),
	Stat(desc='Inner Sight Duration (Seconds)',  formula=ln34_sympy,                                                             params={par3: 300, par4: 150}, seconds=True),
	Stat(desc='Inner Sight Duration (Seconds)',  formula='ln34',                                                                 params={par3: 300, par4: 150}, seconds=True),
	Stat(desc='Slow Missiles [[Missile]] Speed %', formula=lambda lvl,par1,par2: 100-dm12_py(lvl, par1, par2),                   params={par1: 25,  par2: 75}),
	Stat(desc='Slow Missiles [[Missile]] Speed %', formula=                      100-dm12_sympy,                                 params={par1: 25,  par2: 75}),
	Stat(desc='Slow Missiles [[Missile]] Speed %', formula=                     '100-dm12',                                      params={par1: 25,  par2: 75}),
	Stat(desc='Impale Durability loss chance %', formula=lambda lvl,par3,par4,par6: par6-dm34_py(lvl, par3, par4),               params={par3: 0,   par4: 30,  par6: 50}),
	Stat(desc='Impale Durability loss chance %', formula=                           par6-dm34_sympy,                             params={par3: 0,   par4: 30,  par6: 50}),
	Stat(desc='Impale Durability loss chance %', formula=                          'par6-dm34',                                  params={par3: 0,   par4: 30,  par6: 50}),
	Stat(desc='Thunderstorm perdelay', formula=lambda lvl,par3,par4,par5,par6: (100-dm56_py(lvl, par5, par6)) * par4/100 + par3, params={par3: 25,  par4: 100, par5: 0, par6: 100}, seconds=True),
	Stat(desc='Thunderstorm perdelay', formula=                                (100-dm56_sympy) * par4/100 + par3,               params={par3: 25,  par4: 100, par5: 0, par6: 100}, seconds=True),
	Stat(desc='Thunderstorm perdelay', formula=                               '(100-dm56) * par4/100 + par3',                    params={par3: 25,  par4: 100, par5: 0, par6: 100}, seconds=True),
	Stat(desc='Battle Cry duration (Seconds)', formula= ln12_py,                                                                 params={par1: 300, par2: 60}, seconds=True),
	Stat(desc='Battle Cry duration (Seconds)', formula= ln12_sympy,                                                              params={par1: 300, par2: 60}, seconds=True),
	Stat(desc='Battle Cry duration (Seconds)', formula='ln12',                                                                   params={par1: 300, par2: 60}, seconds=True),
	Stat(desc='Chain Lightning hits', formula=lambda lvl, par3, par4, par5: ln34_py(lvl, par3, par4) / par5,                     params={par3: 26,  par4: 1, par5: 5}),
	Stat(desc='Chain Lightning hits', formula=                              ln34_sympy               / par5,                     params={par3: 26,  par4: 1, par5:5}),
	Stat(desc='Chain Lightning hits', formula=                             'ln34/par5',                                          params={par3: 26,  par4: 1, par5:5}),
	Stat(desc='Strafe min hits', formula=lambda lvl, par3, par4: min(par3 + lvl - 1, par4),                                      params={par3: 4,  par4: 10}),
	Stat(desc='Strafe min hits', formula=                  sympy.Min(par3 + lvl - 1, par4),                                      params={par3: 4,  par4: 10}),
	Stat(desc='Strafe min hits', formula=                       'min(par3 + lvl - 1, par4)',                                     params={par3: 4,  par4: 10}),
	Stat(desc='Prayer healing', formula=levelwise5_py,                                                                           params={base: 2, lev1: 1, lev2: 1, lev3: 2, lev4: 2, lev5: 3}),
	Stat(desc='Prayer healing', formula=levelwise5_sympy,                                                                        params={base: 2, lev1: 1, lev2: 1, lev3: 2, lev4: 2, lev5: 3}),
	Stat(desc='Prayer healing', formula='levelwise5',                                                                            params={base: 2, lev1: 1, lev2: 1, lev3: 2, lev4: 2, lev5: 3}),
	Stat(
		desc='Energy shield absorption',
		formula=lambda lvl, base, lev1, lev2, lev3, lev4, lev5: min(levelwise5_py(lvl, base, lev1, lev2, lev3, lev4, lev5), 95),
		params={base: 20, lev1: 5, lev2: 2, lev3: 1, lev4: 1, lev5: 1}
	),
	Stat(desc='Energy shield absorption',
		formula=sympy.Min(levelwise5_sympy, 95),
		params={base: 20, lev1: 5, lev2: 2, lev3: 1, lev4: 1, lev5: 1}
	),
	Stat(desc='Energy shield absorption',
		formula='min(levelwise5, 95)',
		params={base: 20, lev1: 5, lev2: 2, lev3: 1, lev4: 1, lev5: 1}
	),
	Stat(desc='Spirit Wolf coldlength', formula=levelwise3_py,        params={base: 25,  lev1: 25, lev2: 25, lev3: 25}, seconds=True),
	Stat(desc='Spirit Wolf coldlength', formula=levelwise3_sympy,     params={base: 25,  lev1: 25, lev2: 25, lev3: 25}, seconds=True),
	Stat(desc='Spirit Wolf coldlength', formula='levelwise3',         params={base: 25,  lev1: 25, lev2: 25, lev3: 25}, seconds=True),
	Stat(desc='Chilling Armor cold length', formula=levelwise3_py,    params={base: 100, lev1: 0,  lev2: 25, lev3: 25}, seconds=True),
	Stat(desc='Chilling Armor cold length', formula=levelwise3_sympy, params={base: 100, lev1: 0,  lev2: 25, lev3: 25}, seconds=True),
	Stat(desc='Chilling Armor cold length', formula='levelwise3',     params={base: 100, lev1: 0,  lev2: 25, lev3: 25}, seconds=True),
)

print(build_table(stats))

stats = (
	#build your own table
)
#print(build_table(stats))
Retrieved from "https://www.theamazonbasin.com/wiki/index.php?title=User:Trang_Oul/Utils&oldid=66802"