A problem is the bigger a number gets, the less precise they become. This is obvious when you think about it – it’s essentially a binary version of scientific notation, crammed into a few bits like an entire ham into a small can.

So when you want to subtract, say, .6345 from something… it decides to go nuts and in reality subtract .64, or something even more perverse than that.

In a platformer thing I’m making, I started off using floats, in my childish naive innocence. The glitchiness became apparent once I started generating screens – seems would appear, inevitably, between tiles where the rounding on floats got funky.

I tried some funky approaches to solving this – having tiles overlap one another very slightly (like .01 of a pixel) etc, but the solution was very simple: don’t use floats, use fixed point numbers instead.

The largest data types can store something like the distance to Pluto in meters or something – so what is the benefit of floaty point in this situation?

And in what situations are floating point variables the best tool for the job? In a nuclear bomb simulator, for example, I can’t imagine they wouldn’t want very precise values instead of whatever arbitrary values the IEEE Standard permits…

I don’t know how your combat is segmented, i.e. is it turn-based or real-time? But either way, the combat can be segmented into periods, “sub-rounds” or “ticks”, to minimize the rounding error — during each tick, damage is accumulated but not applied until the end of the tick.

So, for example, let’s say the combat tick is 1 second long; and during that period 3 attacks are made, mitigated by the 20% damage resistance:

1) 12 HP * 0.20 = 2.4 HP.
2) 18 HP * 0.20 = 3.6 HP.
3) 9 HP * 0.20 = 1.8 HP.

Total damage is 7.8 HP at the end of the tick. Then it’s rounded and applied for 8 HP. Another benefit is that the damage resistance only needs to apply once, i.e. 12 + 18 + 9 = 39 * 0.20 = 7.8.

In other words, for 0.4 HP, do you want to give the player the benefit and round down to 0, or always round up, so it’s at least 1 HP? Personally, I think rounding to the nearest whole amount works fine for hit points.

In the case of currency, I imagine you’d want to always round up — that’s essentially what we do with real world currency, e.g. if the smallest denomination were 5 cents, it’s rather unlikely that something would cost $2.16; it would actually be bumped up to $2.20.

But in game terms, sometimes you are still left with a “what do I do now” when you need to deduct .4 of a hit point from someone, or charge someone .6 of a unit of currency.

Use floating point where it makes sense, I say (like in your examples above). With modern processors, the performance gain of integers over floats is minimal. And floating point is unavoidable anyway if you’re doing any 3D graphics…

But, if you feel you must stick primarily with integers, you could use fixed-point math…

Reading your example, and thinking of a few of my own, just amplifies my lament for such poor math education in high school. What a loss.

Integer math also made it easier to store multiple values in less space. M59’s spells/skills are stored as a single number: the first part is the spell/skill ID, and the last two digits were your proficiency. That meant that the whole value could be stored in one integer. value / 100 = skill/spell ID. value modulo 100 = proficiency.