fix(events): cap fatal HealthDamageTaken with reported health, exactly

The fatal-hit cap summed raw dmg_health, which under-reports the true HP drop
by 1 on some hits (the benign shotgun-pellet rounding), so a same-tick
follow-up cap landed 1 HP high per affected prior hit. Track the victim's last
reported post-hit health instead - the server's own HP value - so the cap is
exact rather than exact-modulo-rounding. Multi-attacker behaviour is unchanged.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: markus-wa

pkg/demoinfocs/game_events.go

@@ -73,12 +73,15 @@ func (p *parser) handleGameEvent(ge *msg.CMsgSource1LegacyGameEvent) {
 	})
 }
 
-// victimTickHealthDamage accumulates the health damage dealt to a victim within a single game tick.
-// It lets the fatal-hit HealthDamageTaken be capped at the victim's actual remaining HP instead of
-// the stale start-of-tick value, which otherwise over-reports same-tick multi-attacker kills.
+// victimTickHealthDamage records the victim's last reported health within a single game tick, so a
+// same-tick fatal follow-up hit can be capped at the victim's actual remaining HP instead of the
+// stale start-of-tick value (which over-reports same-tick multi-attacker kills). Tracking the
+// server's reported post-hit health is exact, whereas summing raw dmg_health can under-report the
+// true HP drop by 1 (the benign shotgun-pellet rounding artifact).
 type victimTickHealthDamage struct {
-	tick   int
-	damage int
+	tick       int
+	lastHealth int
+	hasPrior   bool
 }
 
 type gameEventHandler struct {
@@ -501,11 +504,16 @@ func (geh gameEventHandler) playerHurt(data map[string]*msg.CMsgSource1LegacyGam
 	if player != nil {
 		if health == 0 {
 			// Fatal hit: the damage actually taken is the victim's remaining HP right before this
-			// hit. player.Health() reads the start-of-tick HP (entity state is applied only after
-			// the tick's events are dispatched), so subtract any damage already dealt to this victim
-			// earlier in the same tick - otherwise same-tick multi-attacker kills over-report the
-			// finishing blow's HealthDamageTaken.
-			healthDamageTaken = player.Health() - victimDamage.damage
+			// hit. player.Health() reads the start-of-tick HP (entity state is applied only after the
+			// tick's events are dispatched). When an earlier hit already landed on this victim this
+			// same tick, use that hit's reported post-damage health - the server's own HP after it,
+			// and exact - otherwise same-tick multi-attacker kills over-report the finishing blow.
+			if victimDamage.hasPrior {
+				healthDamageTaken = victimDamage.lastHealth
+			} else {
+				healthDamageTaken = player.Health()
+			}
+
 			if healthDamageTaken < 0 {
 				healthDamageTaken = 0
 			}
@@ -516,7 +524,8 @@ func (geh gameEventHandler) playerHurt(data map[string]*msg.CMsgSource1LegacyGam
 		}
 	}
 
-	victimDamage.damage += healthDamage
+	victimDamage.lastHealth = health
+	victimDamage.hasPrior = true
 
 	wepType = geh.attackerWeaponType(wepType, userID)