% reduction systems in games

10 Jan, 2026

This blog post is inspired by this excellent video about asymptotic scaling in games, which landed on my youtube homepage at the perfect time. This post touches on most of the same points, with a couple of additions.

Percentage-based damage reduction systems in games can be pretty counterintuitive when scaled, and can lead to some nasty surprises if you aren't aware of the pitfalls. Briefly think about this scenario: your RPG character levels up, and gains an ability that makes them take 20% less damage. How much more damage does it take to kill your character, compared to before you gained the ability?

...

If you answered 20%, you've fallen into the trap of asymptotic scaling; 20% damage reduction actually means it takes 25% more damage to kill your character. While that's only a small difference, the gap widens significantly when you allow the player to stack these kinds of stats - then you can run into some real issues. This post goes into those issues and some potential solutions.

A motivating example

Say you're building a game where the player can equip various pieces of equipment that can grant (among other stats) X% damage reduction.¹ Let's look at how this damage reduction stat impacts the survivability of a character with 100 HP:

• At 0% damage reduction, it takes 100 damage to kill the player
• At 20% damage reduction, it takes 125 damage to kill the player
• At 50% damage reduction, it takes 200 damage to kill the player
• At 80% damage reduction, it takes 500 damage to kill the player

Notice something? As damage reduction increases, the amount of damage it takes to kill the player increases way faster. There's a vast difference between the player with 50% damage reduction and the one with 80% damage reduction.²

This scaling behavior gets out of control pretty quickly. Take a look at the example above: if the player has 20% damage reduction breastplate and equips some boots that give them another 30% damage reduction, they've increased the amount of damage they can take without dying by 75. Their effective HP has increased from 125 to 200.

If they then also equip a 30% damage reduction hat (for a total of 80% reduction), they increase their effective HP from 200 to 500. That's a huge improvement, for an item that - on its face - is exactly as good as the boots!

Think about it: the boots in isolation provide 75 effective HP (and so would the hat), but equipping both items boosts our effective HP from 125 to 500 - an increase of 375 effective HP. Stacking damage reduction is massively powerful in this system, and as you gain damage reduction, each new point of damage reduction is vastly more valuable.³

A portion of your playerbase will realize this, and stack the stat accordingly. Other players will not realize this, and miss out on an opportunity that would make their character much stronger. Depending on the balance of your game, either end of that spectrum can become a problem.

What's going on here?

The key point here is that the actual output value of the system is a different value than you might be thinking. In our example, players don't particularly care damage they take from individual hits and how much that damage might be reduced; what they care about is how much damage they can take before they die. That's the actual output value of the system, which I will call the effective output value for the rest of this post.

Issues start to arise when the input stat of the system (my % damage reduction stat) and the effective output value (how much damage can I take until I die) have a nonlinear relationship. In the case of systems that reduce a value by a %, that's usually an asymptotically scaling relationship.

Identifying asymptotic scaling

While this blog post mostly uses damage reduction as an example, there are a lot of other asymptotically scaling stat systems: cooldown reduction, mana cost reduction, you name it. A good rule of thumb to identifying these is this: if your stat allows the player to scale some other value from its 'full' value to 0, there's a high likelihood it's an asymptotically scaling system and you'll want to take a closer look.

When you suspect you've got an asymptotically scaling system, plot out how the input stat value scales the effective output value. Just sample a few values from the full range of your input stat value; if you see any significant nonlinear scaling like in the examples in this post, you're probably dealing with asymptotic scaling.⁴

The math behind all this

When you really want to know what's going on, you need to look at the math behind your system. If you want to skip the math, feel free to skip to the possible solutions for dealing with asymptotic scaling, but I think the math is very instructive here.

Let's take a closer look at damage reduction. For our damage reduction system, damage is calculated like this:

In other words: as our damage reduction grows, we take less damage. If we have 20% damage reduction, we take $\text{incoming damage}\times (1-0.2)$ $=\text{incoming damage}\times 0.8$ damage, i.e. 80% of the incoming damage.

When the player is hit by an attack, what they care about is this:

In words: is the player's HP bigger than the amount of damage they take? What's interesting here is that $\text{HP}$ and $\text{damage multiplier}$ are controlled by the player, while $\text{incoming damage}$ is not. So let's do a bit of algebra to rewrite this inequality:

What the player wants to do is maximize the left side of that inequality, so that they survive even when $\text{incoming damage}$ has a high value. At this point, our predicament becomes clear: as the player increases their damage reduction, the denominator of that fraction approaches 0. And you might remember what $\frac{1}{x}$ looks like near $x=0$:

So that's our issue: we've allowed our player to have control over the variable in the denominator, allowing them to scale their effective output value wildly out of control if they manage to get close to 0. So what can we do about it?

Taming these systems into linearly-scaling systems

There's a few ways to tame these asymptotically scaling systems and ensure they don't scale out of control in your game:

• Cap the input stat
• Add a layer of indirection that re-scales it back into the linear realm
• Reframe the input stat to be linear

What follows is a brief explanation of each of these solutions.

Capping the input stat

This is the simplest solution: simply don't allow the player to stack the stat beyond a certain value. The key insight here is that low amounts of the input stat are 'linear enough' not to cause any issues. For example, 20% damage reduction leading to 25% more effective HP probably won't ruin your game and the system's outcomes will still feel correct to players, even if they don't have a perfect understanding of how the numbers scale.

Implementing a hard cap to the input stat is a guaranteed way to prevent scaling issues. But if you're building a game revolving around complex stat systems and highly customizable builds, this solution feels pretty bad: a hard cap frequently means your stat just becomes a threshold to meet instead of an interesting decision for the player.⁵

You can also implement a soft cap by ensuring you never give the player the ability to acquire significant amounts of the input stat in the first place. In my opinion, you should reconsider if you want to keep the stat at all if you're going to take this route: if the player only ever gets tiny amounts of it, will they even feel the difference?⁶

Adding a layer of indirection

League of Legends adds a layer of indirection for its damage reduction system: players can't get damage reduction on items directly. Instead, items grant a stat called armor. Armor is then mapped to damage reduction using this formula:⁷

Why this formula? If we plug this back into our formula from earlier:

When we simplify this⁸, we get a linear formula that's surprisingly intuitive:

In words: every point of armor gets you 1% effective bonus HP. Notice how the denominator is a fixed value, not controlled by the player; this formula scales linearly with armor.⁹ That means we don't have to worry about how much armor we already have: we always get 1% effective bonus HP per point of armor we gain.

The trouble, of course, is explaining all this to players. You can get pretty far with tooltips, but very few players will arrive at a precise understanding of these formulas by themselves. If that's not an issue for you, this solution of adding indirection into the stat that rescales it is a good way of getting a linearly-scaling system.

Reframing the input stat to be linear

Sometimes, you can choose a slightly different input stat that completely avoids all these scaling issues. A prime example here is cooldown reduction: while cooldown reduction scales asymptotically, cooldown recovery speed scales linearly. By giving your players a slightly different stat to play with, you've prevented them from going off the rails with it.

The trick here is to give the player a stat that scales the effective output value linearly - like cooldown recovery speed.¹⁰ This results in a very intuitive system: it's pretty obvious to the player that their first 50% cooldown recovery speed item will result in casting 50% more spells per second. If the player already has 300% increased cooldown recovery speed, it's also clear that adding another 50% (for a total of 350%) is a comparatively small upgrade.

Of course, you have to make sure your replacement stat actually scales linearly. Ideally, you're looking for a stat with a domain of $(1,\infty )$. Asymptotically scaling stats typically have a domain of $(0,1)$, so look out for those.¹¹

The downside of this solution is that you can't always find a workable replacement stat: you can replace damage reduction % with bonus HP %, but bonus HP feels pretty different even though it's just the same effect with different scaling properties. If you come up with an intuitive, linear replacement stat for damage reduction specifically, please let me know - it would really help me out!

Wrapping up

In case it needs to be said: asymptotically scaling stat systems are not inherently bad. Maybe you're building an incremental game where scaling out of control is the point; maybe you've built another asymptotically scaling system that counteracts the first one; maybe the stat is conditional in such a way that the player can only sometimes reap the rewards of their out-of-control stat. In all of those cases: go wild!

But for the other cases, I hope this was a useful post. If you have any thoughts on this, I would love if you let me know (via Bluesky or email). Cheers!