By additive damage I do not mean additive damage bonuses. I mean damage that adds up over time:

New HP = Old HP - Damage

Additive damage has the following properties:

  1. It is linear as damage adds up over time.
  2. Characters are knocked out when their HP falls to 0 or below.
  3. HP can be displayed as a linear progress bar.

One alternative that I thought of was multiplicative damage:

New HP = Old HP / Damage

Multiplicative damage has the following properties:

  1. It is exponential as damage multiplies over time.
  2. Characters are knocked out when their HP falls to 1 or below.
  3. HP can be displayed as a logarithmic progress bar.

However, multiplicative damage is just additive damage in disguise because a * b = exp(log(a) + log(b)).

So, when I say that I'm looking for an alternative to additive damage what I mean is that I'm looking for a group structure for damage that's not isomorphic to addition.

A group is a set G together with a binary operation that must satisfy the following properties:

  1. Closure: For all a, b in G, the result of the operation a • b is also in G.
  2. Associativity: For all a, b, c in G, we have (a • b) • c = a • (b • c).
  3. Identity: There exist a unique element e in G such that, for all a in G we have e • a = a • e = a.
  4. Inverse: For each a in G, there exists a unique element b (denoted as a^-1) such that a • b = b • a = e where e is the identity element.

For the purpose of this question, G need not be the set of integers. It could be any set (e.g. reals or complex numbers or even a set of things which aren't numbers) as long as it makes sense in the context of damage:

New HP = Old HP • Damage^-1

Furthermore, it would be nice if G also formed a ring structure but it's alright if it doesn't. Having a ring structure would make calculating damage easier.

Finally, I'm aware that this question is quite subjective and I know that StackExchange is a place for objective questions. However, I hope that by providing an objective basis for a subjective question this would lead to objective discussions.

  • 3
    \$\begingroup\$ It appears to me your grasp of the mathematics involved is firm enough, so approaching this from the side of game design: exactly what in your game makes a straight-up handling of damage numbers unappealing? What experience are you looking for? \$\endgroup\$ Feb 5 '17 at 20:52
  • \$\begingroup\$ Unfortunately, SO is not for discussing things. I think it's better you ask this on a regular forum to be discussing answers since there is not much room for that here. \$\endgroup\$
    – Madmenyo
    Feb 5 '17 at 21:07
  • \$\begingroup\$ I'm designing a tabletop RPG in which Damage = (Base Power * Attack / Defense) * Modifier. Since it's a tabletop RPG and multiplication can get tedious, I was thinking of expressing all the variables in their logarithmic form. Hence the formula would be simplified to Damage = (Base Power + Attack - Defense) + Modifier. However, while logarithms simplify multiplication they complicate addition. Hence calculating New HP = Old HP - Damage becomes difficult. One solution is to create a table for logatithms of addition but that's no fun. Hence, I'm looking for alternatives to additive damage. \$\endgroup\$ Feb 5 '17 at 21:07
  • \$\begingroup\$ @Madmenyo I guess my question suffers from the XY problem. Sorry about that. \$\endgroup\$ Feb 5 '17 at 21:09
  • 2
    \$\begingroup\$ @AaditMShah the joy of table top games comes from playing with people (and their limitations). No miracle formula will make your game fun. \$\endgroup\$
    – John K
    Feb 5 '17 at 21:23

One interesting direction is suggested by the "Wealth Check" used in the d20 Modern tabletop system.

Rather than counting every coin or bill, the system models wealth as a generalized condition:

Condition                    Bonus
Impoverished or In Debt       -1
Struggling                   +1-4
Middle Class                 +5-10
Affluent                     +11-15
Wealthy                      +16-20
Rich                         +21-30
Very Rich                    +31-up

Any purchase or fee is then resolved through a wealth check, rolling a die and adding your bonus, compared against the "difficulty class" or the purchase.

You automatically succeed at any check where your bonus is at least as high as the difficulty. Succeeding a wealth check for a difficulty class higher than your current bonus reduces your bonus. This models the fact that at high wealth, small purchases are negligible, while purchases exceeding your normal means have a longer-term cost. It also reduces the complexity of modern financial management so players don't have to track virtual bank balances and credit scores. ;)

We could apply a model like this to health & damage: give the character or object a set of evocative conditions like "robust" "winded" "staggered" "debilitated" etc, and a threshold of damage they can shake off in each (a player in a high health state shouldn't need to track every paper cut, but one barely maintaining consciousness would need to attend to every threat). Beyond that you can add ranges of damage that should move them to another condition, either deterministically or with some probability.

Stone Librande's board game "Us vs It" uses a similar mechanic for the health of the player tank characters. Namely, they have two states, and their response to incoming damage is different in each state:

Hits Taken     Normal            Damaged (flipped)
    1           Stun               Stun
    2       Become Damaged       Destroyed
    3       Stun + Damaged       Destroyed
    4         Destroyed          Destroyed

This lets the game express multiple levels of impact, and create more fragile gameplay for damaged tanks, while keeping the math and state-tracking simple: a single 2-sided token suffices, rather than an HP counter.


Try logical damage. Player health is represented as a set of bits and damage is a logical operation on those bits. For a simple example, picture Nerf Fencing: You have to hit all four of your opponents targets to win. Player state is four bits initialized to 0. Damage is a logical OR operation of a single 1 bit (the sword can only poke one target at a time). Death is defined as player state of four 1 bits.

Concepts such as regeneration can be implemented with another logical formula applied periodically such as state=state&rand()

This technique can be combined with additive damage where bits are set when hp=0 in a traditional system.


Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.