Finns det något smart matematiskt knep för en gummibandseffekt?

Jag tänker såhär: 

Vi definierar en talföljd $a_n$ som är ens current_health efter $n$ iterationer av din while-loop.

Istället för att ha ett DAMAGE_STEP har vi ett tal, $N$, som är antalet gånger loopen körs. Då är $a_0$ ens health i början och $D$ är damage. Sedan definieras $a_n$ rekursivt enligt:

$\displaystyle a_{n+1} = a_n - \frac{D}{N}\left(1-f(a_n)\right)$

där $f(a_n)$ returnerar damage reduction för när man har hp $a_n$. Du har ju skapat en sådan funktion i ditt skript, och den fungerar bra. Vi låter MIN_DR vara $d_1$, MAX_DR vara $d_2$ och MAX_HEALTH vara $h$. Då är

$f(x) = d_1 + \left(d_2-d_1\right)\left(1-\frac xh\right)$

Om vi låter ens health från början vara $h_0$ har vi talföljden:

$a_0 = h_0$
$a_{n+1} = a_n - \frac{D}{N}\left(1-f(a_n)\right)$ 

Här kommer $a_N$ returnera samma sak som din while loop med samma parametrar. Notera att mitt $N$ och ditt DAMAGE_STEP har förhållandet att produkten av dem blir MAX_HEALTH.  Se bild nedan från desmos: 

$N=10$ (DAMAGE_STEP=100)

Visa spoiler

$N=100$ (DAMAGE_STEP=10)

Visa spoiler

$N=1000$ (DAMAGE_STEP=1)

Visa spoiler

Dessa stämmer bra överens med dina numeriska beräkningar (förutom $N=10$, vet inte varför?)
Det "exakta" värdet med gummibandet bör då bli

$\displaystyle \lim_{N \to \infty} a_N$

Då ska vi försöka beräkna detta! Med definitionen av $f(x)$ kan rekursionen skrivas om, efter lite algebra, till 

$\displaystyle a_n = a_{n-1}\left(1+\frac{D\left(d_{1}-d_{2}\right)}{NH}\right)+\frac{D}{N}\left(d_{2}-1\right)$

Talföljden kan alltså skrivas på formen

$a_n = ka_{n-1} + c$, med två konstanter $k$ och $c$. 

Talföljder på denna form har en sluten formel (exempelvis här på sid 3), som ger oss att 

$\displaystyle a_n = \frac{h_0 k^{n+1}-h_0 k^n - c}{k-1}$ 

Efter insättning av värdena på $k$ och $c$ och förenkling får man att

$\displaystyle a_n = \frac{H\left(1-d_{2}\right)+\left(1+\frac{D\left(d_{1}-d_{2}\right)}{NH}\right)^{n}\left(H\cdot\left(d_{2}-1\right)+h_{0}\cdot\left(d_{1}-d_{2}\right)\right)}{d_{1}-d_{2}}$

Lösning på $\displaystyle \lim_{N \to \infty} a_N$

Definiera $\displaystyle g\left(x\right) = \frac{H\left(1-d_{2}\right)}{d_{1}-d_{2}}+\frac{\left(1+\frac{D\left(d_{1}-d_{2}\right)}{xH}\right)^{x}\left(H\cdot\left(d_{2}-1\right)+h_{0}\cdot\left(d_{1}-d_{2}\right)\right)}{d_{1}-d_{2}}$

Då är $g(N) = a_N$. 

Det mesta här är konstanter, som vi kan se är $g(x)$ på formen

$\displaystyle g\left(x\right)=c_1 + c_2\left(1 + \frac{c_3}{x}\right)^x$

med konstanter $c_1$, $c_2$, $c_3$.  Detta har ett känt gränsvärde, en lösning finns här (<- ordet här är en länk, jag vet inte varför det inte syns??)

$\lim_{x\to \infty} g\left(x\right) = c_1 + c_2 \cdot e^{c_3}$

Insättning av alla värden ger oss då att 

$\lim_{N \to \infty} a_N = \frac{H\left(1-d_{2}\right)}{d_{1}-d_{2}}+\frac{\left(H\cdot\left(d_{2}-1\right)+h_{0}\cdot\left(d_{1}-d_{2}\right)\right)}{d_{1}-d_{2}}e^{\frac{D\left(d_{1}-d_{2}\right)}{H}}$ 

Detta tror jag är det "exakta" värdet av gummibandseffekten. 
Med de givna parametrarna från tidigare blir effective damage 30.88%, mycket nära DAMAGE_STEP = 1
Också, jag ber om ursäkt om något här på slutet var otydligt, jag blev rätt trött medan jag skrev! 

Tillägg: 1 jul 2025 08:41

I mitten av inlägget råkade jag börja använda $H$ för att betyda samma sak som MAX_HEALTH. Så egentligen är $H=h$

Givet pythonkoden och resonemanget ovan känns det som skadereduktionen DR som en funktion av HP kan skrivas:

$DR\left(h\right)=0,2+0,6\left(1-\frac{h}{1000}\right)=0,8-\frac{0,6h}{1000}$

Så när vi tillför en pyttliten skada dx, så minskar HP med:

$dH=-dx\times (1-DR(H\left)\right)=-dx\times (1-(0,8-\frac{0,6H}{1000}\left)\right)=-dx(0,2+\frac{0,6H}{1000})$

Tjohej! Där har du en diffekvation som kan lösas exakt:

$\frac{dH}{dx}=-\left(0,2+\frac{0,6H}{1000}\right)$

Med "kan lösas" menar jag tyvärr inte "av mig just nu", men det finns en exakt/analytiskt lösning som kommer att vara på formen $H\left(x\right)=a\times e^{bx}+c$, där b och c är <0. 

Å andra sidan frågade du om det finns något finurligt sätt att lösa detta snabbt matematiskt och nämnde den berömda "fast inverse square root" (Quake III, eller hur?). Att ta en potens av e är sannolikt kostsamt, CPU-mässigt, så detta är nog inte ett svar på din fråga.

Tillägg: 1 jul 2025 16:56

OK. Fuskade lite och fick hjälp med diff.ekvationen:

$H\left(x\right)=1333,\overline{3}\times e^{-0,0006x}-333,\overline{3}$

Utan att bedöma om det är korrekt, kan jag konstatera att det stämmer bra med vad din pythonkod spottar ut.

För att komma runt den beräkningsmässiga kostnaden kan man väl skriva ut exponentialfunktionen med dess Taylorutveckling (runt lämplig punkt) och trunkera den vid något lämpligt värde? Tror knappast man behöver mer än typ fyra eller fem termer.

Jag vet inte hur numpy eller vilket libb du nu använder gör beräkningen men sannolikt tar det med för dina ändamål onödig precision.

@AlexMu Fint! Det finns två möjliga svar till varför vi skiljer vid N=10. Det ena är att jag använder floats, vilket datorer som bekant inte hanterar helt perfekt. Har uppdaterat koden så den kör exakt decimalberäkning. Det andra svaret är att du kör dubbelt så många iterationer i samtliga fall. 500 skada, varje steg 100, 5 steg.

@sictransit Ja, Quake 3. Nu är det ren magkänsla här, men jag tror inte potensen kostar så mycket. ChatGPTs svar slutade med: No, it's not computationally expensive in practical terms—modern math libraries make calculating e^x very fast and efficient.

@naytte Ja, det slutgiltiga svaret behöver inte särskilt bra precision. Dock om man gör som i mitt script så vill man ju ha precision i varje steg för att inte avrundingsfel ska skicka allt åt pipsvängen.

Tack ska ni ha =)

Edit: Uppdaterat skript här, kan inte redigera första inlägget längre. Detta kan förresten även hantera "overkill" damage.

from decimal import Decimal, getcontext

getcontext().prec = 50 # Precision of decimal calculations

MAX_HEALTH = 1000
ATTACK_DAMAGE = 500
MIN_DR = Decimal("0.2")  # Damage reduction at full health
MAX_DR = Decimal("0.8")  # Damage reduction at zero health
DAMAGE_STEP = 10  # Points of raw damage to be dealt before DR is recalculated (ATTACK_DAMAGE should be an integer multiple of this)

current_health = Decimal(MAX_HEALTH)
invested_damage = Decimal("0")  # Points of pre-mitigation damage dealt

def current_dr():
    return MIN_DR + (MAX_DR - MIN_DR) * (1 - max(0, current_health) / MAX_HEALTH)

while invested_damage < ATTACK_DAMAGE:
    single_strike_damage = DAMAGE_STEP * (1 - current_dr()) # Damage of this attack
    current_health -= single_strike_damage # Subtract the post-mitigation damage from the health pool
    invested_damage += DAMAGE_STEP # Up the pre-mitigation damage investment

print(f"Effective mitigation: {(1 - ((MAX_HEALTH - current_health) / ATTACK_DAMAGE)) * 100}%")

Även om det vore kostsamt för CPUn att beräkna potenser av $e$ är väl frågan om den kostnaden spelar någon roll...? Jag menar om du designar ett spel då, inte om det här bara är en roande utmaning i att göra något så optimalt som möjligt.

Moderna datorer har ju enorm beräkningskraft så jag tror inte du som utvecklare behöver beroa dig så mycket om sådana småsaker som att beräkna en potens av $e$.