Guide

Game stat scaling and diminishing returns explained

Harbor Ruins shipped with linear strength scaling: every point added a flat +2 physical damage, and gear multiplied that base without caps. By endgame, a single heavy attack one-shot bosses tuned for party play. The live team patched in a logistic curve on primary stats and separate diminishing returns on critical chance, but the damage was done: 68% of level-40 players had respecced into identical strength builds because stacking one stat was strictly optimal. The lesson is not “nerf strength” — it is that how a stat converts input to output determines whether your skill trees, loot, and difficulty curves can coexist.

Stat scaling maps invested points (level-ups, gear, buffs) to combat or utility outcomes. Diminishing returns (DR) ensure each additional unit of a stat contributes less than the last, preserving choice and pacing. Without intentional curves, multiplicative stacking creates runaway power; without any growth, upgrades feel hollow. This guide classifies scaling curve families, contrasts additive and multiplicative aggregation, documents soft versus hard caps, walks through the Harbor Ruins combat refactor, provides a technique decision table versus uncapped linear models, common pitfalls, and a production checklist.

Why scaling is a design contract, not a spreadsheet footnote

Every stat answers two player questions: “Should I invest more here?” and “How much better will I feel?” The curve encodes your answer. Linear scaling tells players that doubling investment doubles output — fine for early levels, catastrophic when loot and passives stack five sources of the same bonus. Exponential scaling makes late-game numbers explode unless content HP scales in lockstep. Logistic and piecewise curves let early points feel impactful while late points taper, which is how you keep dexterity viable next to strength without fake caps that read as bugs in the UI.

Scaling also binds systems you might otherwise tune separately: balance, difficulty curves, and progression pacing. Change the strength formula and you implicitly change time-to-kill, encounter budgets, and economy pricing for potions. Document curves in data assets, not buried in code constants, so designers can simulate before shipping a patch.

Scaling curve taxonomy

Pick the curve family that matches how visible and stackable the stat is.

Linear (y = a + bx)

Each point adds the same absolute output. Simple to explain (“+5 damage per level”). Best for stats with low stack count or short progression spans. Breaks when gear, buffs, and talents all add to the same pool.

Polynomial and exponential (y = xⁿ, n > 1)

Late investment pays disproportionately. Useful for upgrade tiers that should feel like breakthroughs (tier-3 weapon mastery). Dangerous on stats players can stack freely — exponential crit damage multiplied by exponential crit chance collapses encounter design.

Logarithmic and square-root (y = a·log(x) or √x)

Early points matter a lot; later points taper smoothly. Common for armor, resistance, and resource pools. Players still see green numbers on gear, but effective survivability grows sublinearly.

Logistic / sigmoid (soft asymptote)

Output approaches a ceiling: cap · x / (x + k). The k constant sets the knee — where marginal value halves. Ideal for crit chance, dodge, cooldown reduction, and any stat that would break at 100%. UI can show raw rating while combat uses converted probability.

Piecewise and breakpoint tables

Different slopes per band (“1–100: +2 damage per point; 101–200: +1; 201+: +0.5”). Designers love spreadsheets; players hate invisible cliffs unless telegraphed. Prefer smooth curves unless the breakpoint is a deliberate milestone (e.g., reaching a weapon speed threshold).

Rating-to-percent conversion

Many RPGs expose “Critical Rating 847” while combat uses derived percent. The conversion function is your scaling curve. Never let UI and simulation diverge — one module owns rating → effective value.

Diminishing returns: additive vs multiplicative stacking

DR can live in the curve or in how bonuses combine. Mixing models without documentation is how Harbor Ruins broke.

Additive pool, then convert

Sum all +% damage bonuses, then apply once: damage = base · (1 + sum(bonuses)). Linear in bonuses but still explosive if bonuses are large. Often paired with a cap on the sum or a logistic conversion on the pooled value.

Multiplicative layers

damage = base · (1 + a) · (1 + b) · (1 + c). Small per-source bonuses compound fast. Reserve for distinct categories (talent vs gear vs temporary buff) and keep per-layer DR or low ceilings.

Independent diminishing returns per source

Each gear piece contributes less if another piece already buffed the same stat (“unique affix” rules). Preserves build variety at the cost of more authoring. Common in ARPGs where duplicate stats on six items would otherwise dominate.

Same-stat DR on repeated procs

Separate from gear: on-hit effects, stacking buffs, and status effects often use per-target DR (“each subsequent stun 50% shorter”). Prevents infinite crowd control without hard immunity every time.

Stat type	Typical curve	Stacking model	Common cap
Primary attributes (STR/DEX/INT)	Logistic or sqrt	Additive to rating, then convert	Soft knee ~200–300 rating
Critical chance	Logistic to asymptote	Additive rating → %	Hard 75–100% by genre
Armor / resistance	Hyperbolic (armor / armor + k)	Additive armor, diminishing % reduction	Asymptote 70–85% DR
Attack speed	Piecewise linear with cap	Multiplicative haste layers with DR	Hard cap on animations/sec
Cooldown reduction	Logistic	Additive CDR rating	Hard 40–50% CDR
Movement speed	Linear low band, steep DR after	Additive % with soft cap	+30–50% over base typical

Soft caps, hard caps, and player communication

A soft cap is a knee in the curve: investing further still helps, but noticeably less. A hard cap is a ceiling: additional rating is wasted or converted to a secondary stat (crit overcap → crit damage).

Show effective value in tooltips — “847 crit rating → 38.2% chance” builds trust; hiding the conversion breeds datamine dependency.
Mark knee points on character sheet — a subtle tick at soft cap helps theorycrafters without overwhelming casual players.
Overcap sinks — if players hit hard cap, route overflow to bonus damage or proc chance so loot stays exciting.
PvE vs PvP tables — separate conversion constants if competitive modes need lower asymptotes; never silently share one table if caps differ.

Simulation workflow before you ship a curve

Define output metrics — DPS, EHP (effective HP), time-to-kill vs standard enemy, clears per minute. Tie to damage formulas.
Enumerate sources — list every system that adds to each stat at max level (gear tiers, talents, consumables, party buffs).
Plot marginal value — for stat values 0–max, chart delta DPS per +1 point. Knees should appear before realistic max investment.
Compare builds — simulate at least three viable archetypes; if one dominates >15% on TTK, adjust curve not individual items first.
Regression on content — re-run encounter budgets; bosses tuned for pre-patch HP may become trivial or sponges.

Harbor Ruins combat refactor (worked example)

Before: linear STR → damage; additive crit % from gear with no cap; armor as flat subtraction (negative damage possible on weak hits).

After:

Primary stats use damageBonus = cap · rating / (rating + 120) applied once to weapon base.
Gear % damage bonuses sum into one pool, then multiply; pool soft-caps via same logistic with k = 80.
Crit chance: rating → % with 60% hard cap in PvE, 40% in PvP; overcap converts 2:1 to crit damage rating.
Armor uses standard hyperbolic % reduction; penetration applied as flat rating subtraction before conversion.
All conversions live in StatResolver ScriptableObject; designers tweak knees without code deploy.

Result: top-end single-target DPS dropped 22%, but build diversity index (Shannon entropy over talent picks) rose from 0.41 to 0.78 in week-one telemetry. Average time-to-kill on Mythic bosses landed within 5% of target after HP micro-adjustment only — no full encounter rebuild.

Technique decision table

Your problem	Prefer	Avoid
One stat always wins on spreadsheets	Logistic knee + build-specific synergies	Flat nerfs to one item tier
Early upgrades feel weak	Steep low-end (sqrt/log) then taper	Linear from zero with tiny coefficients
Loot excitement fades at cap	Overcap conversion or secondary proc	Hard zero benefit past cap with no UI warning
Many independent % damage sources	Additive pool + one conversion	Uncapped multiplicative chains
CC or proc chains lock enemies	Per-target DR on repeat applications	100% immunity after first CC always
Players cannot parse tooltips	Rating + derived effective line	Raw formula in tooltip without result
Competitive integrity	Separate PvP conversion table	Same asymptotes as raid gear in arena

Common pitfalls

Linear primary + multiplicative gear — the Harbor Ruins failure mode; fix the aggregation order, not just one sword.
Hidden breakpoints — players feel cheated when +1 stat suddenly does nothing; surface knees or use smooth curves.
Double conversion — applying DR twice (once per item, once globally) tanks build variety.
Uncapped CDR or haste — breaks animation systems and server tick budgets; hard cap with overflow sink.
Negative damage armor — flat subtraction before min damage clamp causes zero-DPS bugs; use % reduction.
Buff stacking without categories — ten +10% damage buffs become 2.59× multiplicatively; tag buff families.
Rebalancing loot before curves — chasing 200 items when one formula change fixes all tiers.
No telemetry on build distribution — you discover one-meta problems from Reddit, not dashboards.

Production checklist

Every combat stat has a documented curve family and conversion formula in data.
One StatResolver (or equivalent) owns rating → effective value.
Stacking rules written per stat: additive pool, multiplicative layer, or independent DR.
Soft knees placed before realistic max investment from gear + talents + buffs.
Hard caps defined for crit, CDR, dodge, move speed; overcap behavior specified.
Tooltips show raw rating and derived effective value side by side.
Simulation plots marginal DPS/EHP for three+ archetypes at min and max investment.
Encounter TTK revalidated after any curve change; HP tweaks documented separately.
PvP uses separate conversion table if asymptotes differ from PvE.
Telemetry: build pick distribution and median TTK per content tier weekly.

Key takeaways

Scaling curves are the contract between progression, loot, and difficulty — not an afterthought.
Logistic and hyperbolic models preserve late-game upgrades without runaway one-shots.
How bonuses stack (additive pool vs multiplicative layers) matters as much as the curve itself.
Soft knees plus honest tooltips beat invisible hard caps that feel like bugs.
Harbor Ruins recovered build diversity by refactoring StatResolver — not by nerfing forty items.