feat(events): add InfernoFireOut and correct InfernoExpired doc

InfernoExpired is dispatched when the CInferno entity is destroyed (~20s
lifetime / round end), not when the fire goes out, but its doc claimed the
latter. Correct the doc and add InfernoFireOut, dispatched the first time an
inferno's active fires (m_bFireIsBurning) transition to zero - the true
flame-out moment (~5-7s), which no event previously exposed.

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

Author: markus-wa

pkg/demoinfocs/datatables.go

@@ -1070,6 +1070,7 @@ func (p *parser) infernoExpired(inf *common.Inferno) {
 	})
 
 	delete(p.gameState.infernos, inf.Entity.ID())
+	delete(p.gameState.infernoFireStates, inf.Entity.ID())
 
 	p.gameEventHandler.deleteThrownGrenade(inf.Thrower(), common.EqIncendiary)
 }

pkg/demoinfocs/events/events.go

@@ -642,7 +642,18 @@ type InfernoStart struct {
 	Inferno *common.Inferno
 }
 
-// InfernoExpired signals that all fire from a incendiary or Molotov has extinguished.
+// InfernoFireOut signals that all fires of an inferno (incendiary/Molotov) have gone out, i.e.
+// Inferno.Fires().Active() first reached zero. Unlike InfernoExpired - which fires when the inferno
+// entity is destroyed, seconds later - this marks the actual flame-out / smoke-extinguish moment.
+type InfernoFireOut struct {
+	Inferno *common.Inferno
+}
+
+// InfernoExpired signals that the inferno (incendiary/Molotov) entity has been removed.
+//
+// Note: this fires when the CInferno entity is destroyed - roughly the entity's lifetime (~20s) or
+// round end - NOT when the fire actually goes out. For the true flame-out / smoke-extinguish moment
+// use InfernoFireOut instead.
 // This is different from the FireGrenadeExpire event because it's sent out when the inferno entity is destroyed instead of on the game-event.
 //
 // Mainly useful for getting the final area of an inferno.

pkg/demoinfocs/game_events.go

@@ -1331,9 +1331,35 @@ func (p *parser) processFrameGameEvents() {
 		p.processRoundProgressEvents()
 	}
 
+	p.processInfernoFireOut()
+
 	for _, eventHandler := range p.delayedEventHandlers {
 		eventHandler()
 	}
 
 	p.delayedEventHandlers = p.delayedEventHandlers[:0]
 }
+
+// processInfernoFireOut dispatches events.InfernoFireOut the first time an inferno's active fires
+// transition from burning to none. InfernoExpired only fires when the entity is destroyed (~20s),
+// which is much later than the actual flame-out.
+func (p *parser) processInfernoFireOut() {
+	for id, inf := range p.gameState.infernos {
+		state := p.gameState.infernoFireStates[id]
+		if state == nil {
+			state = &infernoFireState{}
+			p.gameState.infernoFireStates[id] = state
+		}
+
+		if state.firedOut {
+			continue
+		}
+
+		if len(inf.Fires().Active().List()) > 0 {
+			state.wasBurning = true
+		} else if state.wasBurning {
+			state.firedOut = true
+			p.eventDispatcher.Dispatch(events.InfernoFireOut{Inferno: inf})
+		}
+	}
+}

pkg/demoinfocs/game_state.go

@@ -28,6 +28,7 @@ type gameState struct {
 	playerControllerEntities     map[int]st.Entity
 	grenadeProjectiles           map[int]*common.GrenadeProjectile // Maps entity-IDs to active nade-projectiles. That's grenades that have been thrown, but have not yet detonated.
 	infernos                     map[int]*common.Inferno           // Maps entity-IDs to active infernos.
+	infernoFireStates            map[int]*infernoFireState         // Maps inferno entity-IDs to their burning state, for InfernoFireOut.
 	weapons                      map[int]*common.Equipment         // Maps entity IDs to weapons. Used to remember what a weapon is (p250 / cz etc.)
 	hostages                     map[int]*common.Hostage           // Maps entity-IDs to hostages.
 	entities                     map[int]st.Entity                 // Maps entity IDs to entities
@@ -78,6 +79,13 @@ type FlyingFlashbang struct {
 	explodedFrame int
 }
 
+// infernoFireState tracks an inferno's burning state so InfernoFireOut can be dispatched once, when
+// its active fires first transition from >0 to 0 (the true flame-out, distinct from InfernoExpired).
+type infernoFireState struct {
+	wasBurning bool
+	firedOut   bool
+}
+
 type lastFlash struct {
 	player             *common.Player
 	projectileByPlayer map[*common.Player]*common.GrenadeProjectile
@@ -238,6 +246,7 @@ func newGameState(demoInfo demoInfoProvider) *gameState {
 		playersBySteamID32:       make(map[uint32]*common.Player),
 		grenadeProjectiles:       make(map[int]*common.GrenadeProjectile),
 		infernos:                 make(map[int]*common.Inferno),
+		infernoFireStates:        make(map[int]*infernoFireState),
 		weapons:                  make(map[int]*common.Equipment),
 		hostages:                 make(map[int]*common.Hostage),
 		entities:                 make(map[int]st.Entity),