Every effective stat is its base times one plus the sum of its category’s bonuses — A = A₀(1 + Σaᵢ), D = D₀(1 + Σdⱼ) — and damage composes multiplicatively across categories: attack ratio × damage factor × skill-damage lane × counter coefficient.
Open in calculatorThe real gain of adding +x points to a category whose current total is T points is x/(100 + T), strictly decreasing in T. Corollary (empty-category rule): the value-maximizing next investment is always the category with the smallest T.
Open in calculatorThe opponent’s defence stack cancels from the relative value of your next attack point: for any d, the gain from a → a+x is (1+a+x)/(1+a), independent of d. The opponent’s stack enters only through the shred lane, where removing x points from their total T′ is worth x/(100 + T′).
Open in calculatorAgainst a counter-type attacker with coefficient κ (1.05 base, ≈1.10 talent-boosted), the defender is solid — R = κ(1+a)/(1+d) ≤ 1 — if and only if d ≥ κ(1+a) − 1.
Open in calculatorThe defence surplus required to exactly cancel the counter bonus is s* = (κ−1)(1+a): 10 points at zero stacks (the field rule, exact) inflating linearly to ~25 points at a = 150%.
Open in calculatorA defence surplus s = d − a reduces incoming damage by s/(1 + a + s) — structurally a defence shred running in reverse: a cross-category multiplier on survivability.
Open in calculatorRestoring the damage ratio after the opponent adds s points of defence requires Δa ≈ s at parity — a 1:1 same-lane arms race the deeper investment always wins. The dominated player’s escape is orthogonal: skill damage (its own lane) or shred (the opponent’s denominator).
Durability composes as ~(1+d)(1+h) and health-percentage sources are scarce, so T_health stays small (~30–40 pts vs ~100–150 for defence/attack). By Theorem 2 each health point retains near-full marginal value: “rare, so valuable” is the arithmetic of the denominator.
Open in calculatorEffective march power is superlinear in per-march completion because skills, talents, gear, and expertise interact multiplicatively within a march: one finished march (100 effective from 100 nominal) outperforms three ~45%-built marches (99 effective from 135 nominal).
Each theorem ships as executable pseudocode that runs unmodified in any Python interpreter — and each is ported line-for-line into this site’s calculators, so “open in calculator” above runs exactly the code below.
def effective_damage(A0, atk, D0, dfn, shred=0.0,
kappa=1.0, DF=1.0, skill=()):
# atk, dfn, skill: iterables of decimal bonuses (0.25 = +25%)
A = A0 * (1 + sum(atk)) # Theorem 1
D = D0 * (1 + sum(dfn) - shred) # debuff lane
normal_hit = kappa * A / D # Theorem 4 counter
skill_hit = normal_hit * DF * (1 + sum(skill))
return normal_hit, skill_hitdef marginal_value(x, T):
return x / (100 + T) # Theorem 2, points
def best_next_buff(options, enemy_totals):
# options: [(name, lane, x_points, my_T_points), ...]
def gain(o):
name, lane, x, T = o
if lane == 'shred': # Theorem 3
return marginal_value(x, enemy_totals['defence'])
return marginal_value(x, T) # own-lane pricing
return max(options, key=gain)def solidity(a, d, kappa=1.10):
R = kappa * (1 + a) / (1 + d) # Theorem 4
s_star = (kappa - 1) * (1 + a) # Theorem 5
surplus = d - a
mitigation = surplus / (1 + a + surplus) # Theorem 6
return {'R': R, 'solid': R <= 1,
'required_surplus_pts': 100 * s_star,
'current_mitigation': mitigation}def casts_per_fight(turns, rage_per_turn=91, rage_cost=1000,
restore_per_cast=0):
casts, rage = 0, 0
for _ in range(turns):
rage += rage_per_turn
if rage >= rage_cost:
casts += 1
rage = restore_per_cast # surplus is wasted
return casts