fix(events): pair PlayerFlashed victims by detonation, not FIFO order

PlayerFlashed was synthesized by attaching every m_flFlashDuration update and
every detonation to the head of a FIFO queue of in-flight flashbangs. A
detonation with zero direct victims while another flashbang was airborne
shifted the queue by one, so every subsequent flash credited the wrong
thrower for the rest of the round.

Mark the detonated entry by the destroyed projectile's identity, buffer the
pawns flashed each frame, and attribute them to the flashbang that detonated
that frame (closest by detonation position when several detonate at once).
The thrower (proj.Thrower) was already correct, matching FlashExplode.

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

Author: markus-wa

pkg/demoinfocs/datatables.go

@@ -520,13 +520,12 @@ func (p *parser) bindNewPlayerPawn(pawnEntity st.Entity) {
 
 		pl.FlashDuration = val.Float()
 
-		if pl.FlashDuration > 0 {
-			if len(p.gameState.flyingFlashbangs) == 0 {
-				return
-			}
-
-			flashbang := p.gameState.flyingFlashbangs[0]
-			flashbang.flashedEntityIDs = append(flashbang.flashedEntityIDs, pl.EntityID)
+		if pl.FlashDuration > 0 && len(p.gameState.flyingFlashbangs) > 0 {
+			// The detonation (projectile OnDestroy) and these m_flFlashDuration updates arrive in the
+			// same frame but in an unspecified order, so we can't yet know which projectile caused
+			// this. Buffer the flashed pawn and pair it with the flashbang that detonated this frame
+			// at the end of the frame (see processFlyingFlashbangs).
+			p.gameState.flashedEntitiesThisFrame = append(p.gameState.flashedEntitiesThisFrame, pl.EntityID)
 		}
 	})
 
@@ -753,8 +752,7 @@ func (p *parser) bindGrenadeProjectiles(entity st.Entity) {
 
 		if proj.WeaponInstance.Type == common.EqFlash {
 			p.gameState.flyingFlashbangs = append(p.gameState.flyingFlashbangs, &FlyingFlashbang{
-				projectile:       proj,
-				flashedEntityIDs: []int{},
+				projectile: proj,
 			})
 		}
 
@@ -796,12 +794,17 @@ func (p *parser) bindGrenadeProjectiles(entity st.Entity) {
 				},
 			})
 
-			if len(p.gameState.flyingFlashbangs) == 0 {
-				return
-			}
+			// Mark the entry for the projectile that actually detonated (entity-keyed), not the
+			// head of the queue - otherwise a zero-victim detonation while another flashbang is
+			// airborne shifts victim attribution by one for the rest of the round.
+			for _, flashbang := range p.gameState.flyingFlashbangs {
+				if flashbang.projectile == proj {
+					flashbang.explodedFrame = p.currentFrame
+					flashbang.position = proj.Position()
 
-			flashbang := p.gameState.flyingFlashbangs[0]
-			flashbang.explodedFrame = p.currentFrame
+					break
+				}
+			}
 		}
 
 		p.nadeProjectileDestroyed(proj)

pkg/demoinfocs/game_events.go

@@ -287,6 +287,7 @@ func (geh gameEventHandler) clearGrenadeProjectiles() {
 	// Thrown grenades could not be deleted at the end of the round (if they are thrown at the very end, they never get destroyed)
 	geh.gameState().thrownGrenades = make(map[*common.Player]map[common.EquipmentType][]*common.Equipment)
 	geh.gameState().flyingFlashbangs = make([]*FlyingFlashbang, 0)
+	geh.gameState().flashedEntitiesThisFrame = nil
 }
 
 func (geh gameEventHandler) roundStart(data map[string]*msg.CMsgSource1LegacyGameEventKeyT) {
@@ -1249,34 +1250,72 @@ func (p *parser) processRoundProgressEvents() {
 }
 
 func (p *parser) processFlyingFlashbangs() {
+	victims := p.gameState.flashedEntitiesThisFrame
+	p.gameState.flashedEntitiesThisFrame = nil
+
 	if len(p.gameState.flyingFlashbangs) == 0 {
 		return
 	}
 
-	flashbang := p.gameState.flyingFlashbangs[0]
-	if len(flashbang.flashedEntityIDs) == 0 {
-		// Flashbang exploded and didn't flash any players, remove it from the queue
-		if flashbang.explodedFrame > 0 && flashbang.explodedFrame < p.currentFrame {
-			p.gameState.flyingFlashbangs = p.gameState.flyingFlashbangs[1:]
+	// Split the in-flight flashbangs into those that detonated this frame and those still airborne.
+	// Detonation is keyed by the destroyed projectile's identity (see the OnDestroy handler), so the
+	// queue no longer relies on FIFO order and a zero-victim detonation can't desync attribution.
+	var detonated []*FlyingFlashbang
+
+	kept := p.gameState.flyingFlashbangs[:0]
+
+	for _, flashbang := range p.gameState.flyingFlashbangs {
+		if flashbang.explodedFrame == p.currentFrame {
+			detonated = append(detonated, flashbang)
+		} else {
+			kept = append(kept, flashbang)
 		}
+	}
+
+	p.gameState.flyingFlashbangs = kept
 
+	if len(detonated) == 0 {
 		return
 	}
 
-	for _, entityID := range flashbang.flashedEntityIDs {
+	// Attribute each pawn flashed this frame to the flashbang that detonated this frame. When more
+	// than one detonated simultaneously, pick the closest by detonation position.
+	for _, entityID := range victims {
 		player := p.gameState.Participants().ByEntityID()[entityID]
 		if player == nil {
 			continue
 		}
 
+		flashbang := nearestDetonatedFlashbang(detonated, player)
+
 		p.gameEventHandler.dispatch(events.PlayerFlashed{
 			Player:     player,
 			Attacker:   flashbang.projectile.Thrower,
 			Projectile: flashbang.projectile,
 		})
 	}
+}
+
+// nearestDetonatedFlashbang returns the flashbang whose detonation position is closest to the
+// player - used to attribute a victim when multiple flashbangs detonate on the same frame.
+func nearestDetonatedFlashbang(flashbangs []*FlyingFlashbang, player *common.Player) *FlyingFlashbang {
+	nearest := flashbangs[0]
+
+	if len(flashbangs) == 1 {
+		return nearest
+	}
+
+	pos := player.Position()
+	minDist := pos.Sub(nearest.position).Norm()
+
+	for _, flashbang := range flashbangs[1:] {
+		if dist := pos.Sub(flashbang.position).Norm(); dist < minDist {
+			minDist = dist
+			nearest = flashbang
+		}
+	}
 
-	p.gameState.flyingFlashbangs = p.gameState.flyingFlashbangs[1:]
+	return nearest
 }
 
 // Do some processing to dispatch game events at the end of the frame in correct order.

pkg/demoinfocs/game_state.go

@@ -5,6 +5,7 @@ import (
 	"strconv"
 	"time"
 
+	"github.com/golang/geo/r3"
 	common "github.com/markus-wa/demoinfocs-golang/v5/pkg/demoinfocs/common"
 	"github.com/markus-wa/demoinfocs-golang/v5/pkg/demoinfocs/constants"
 	"github.com/markus-wa/demoinfocs-golang/v5/pkg/demoinfocs/events"
@@ -61,14 +62,19 @@ type gameState struct {
 	// As a solution, we keep track of flashbang projectiles created and all m_flFlashDuration prop updates related
 	// to this projectile. As all m_flFlashDuration prop updates occur during the same frame, we batch dispatch
 	// player-flashed events at the end of the frame if there are any.
-	// This slice acts like a FIFO queue, the first projectile inserted is the first one to be removed when it exploded.
+	// Flashbangs currently in flight (thrown but not yet detonated). Entries are keyed by the
+	// projectile identity, not by position - a flashbang is removed when its own projectile entity
+	// is destroyed, so a zero-victim detonation no longer desyncs attribution for the round.
 	flyingFlashbangs []*FlyingFlashbang
+	// Pawn entity-IDs whose m_flFlashDuration was set during the current frame. They are paired with
+	// the flashbang(s) that detonated in the same frame at the end of the frame.
+	flashedEntitiesThisFrame []int
 }
 
 type FlyingFlashbang struct {
-	projectile       *common.GrenadeProjectile
-	flashedEntityIDs []int
-	explodedFrame    int
+	projectile    *common.GrenadeProjectile
+	position      r3.Vector // Detonation position, set when the projectile is destroyed. Used to pair victims when multiple flashbangs detonate on the same frame.
+	explodedFrame int
 }
 
 type lastFlash struct {