fix: possible nil Weapon field in player hurt events

Regression introduced with this v5 commit 097b925 and noticed while backporting it into the v4, see the CI https://github.com/markus-wa/demoinfocs-golang/actions/runs/16401553730/job/46341730756?pr=599.

We still group grenades by type to fix the UniqueID2() issue and store grenades in a slice like it was before.

Author: akiver

pkg/demoinfocs/game_events.go

@@ -324,7 +324,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().thrownGrenades = make(map[*common.Player]map[common.EquipmentType][]*common.Equipment)
 	geh.gameState().flyingFlashbangs = make([]*FlyingFlashbang, 0)
 }
 
@@ -1022,10 +1022,10 @@ func (geh gameEventHandler) addThrownGrenade(p *common.Player, wep *common.Equip
 
 	gameState := geh.gameState()
 	if gameState.thrownGrenades[p] == nil {
-		gameState.thrownGrenades[p] = make(map[common.EquipmentType]*common.Equipment)
+		gameState.thrownGrenades[p] = make(map[common.EquipmentType][]*common.Equipment)
 	}
 
-	gameState.thrownGrenades[p][wep.Type] = wep
+	gameState.thrownGrenades[p][wep.Type] = append(gameState.thrownGrenades[p][wep.Type], wep)
 }
 
 func (geh gameEventHandler) getThrownGrenade(p *common.Player, wepType common.EquipmentType) *common.Equipment {
@@ -1034,11 +1034,32 @@ func (geh gameEventHandler) getThrownGrenade(p *common.Player, wepType common.Eq
 		return nil
 	}
 
-	if geh.gameState().thrownGrenades[p] == nil {
+	playerGrenades := geh.gameState().thrownGrenades[p]
+	grenades := playerGrenades[wepType]
+
+	if len(grenades) == 0 {
+		// Molotovs/incendiaries may be reported as the opposite type in game-events. (i.e. incendiary reported as molotov and vice versa)
+		switch wepType { //nolint:exhaustive
+		case common.EqIncendiary:
+			grenades = playerGrenades[common.EqMolotov]
+		case common.EqMolotov:
+			grenades = playerGrenades[common.EqIncendiary]
+		}
+	}
+
+	if len(grenades) == 0 {
+		// The player might be controlling a bot, in such case the thrown grenade is stored in the bot's state.
+		bot := p.ControlledBot()
+		if bot != nil && bot.SteamID64 != p.SteamID64 {
+			return geh.getThrownGrenade(bot, wepType)
+		}
+	}
+
+	if len(grenades) == 0 {
 		return nil
 	}
 
-	return geh.gameState().thrownGrenades[p][wepType]
+	return grenades[len(grenades)-1]
 }
 
 func (geh gameEventHandler) deleteThrownGrenade(p *common.Player, wepType common.EquipmentType) {
@@ -1047,8 +1068,21 @@ func (geh gameEventHandler) deleteThrownGrenade(p *common.Player, wepType common
 		return
 	}
 
-	delete(geh.gameState().thrownGrenades[p], wepType)
+	playerGrenades := geh.gameState().thrownGrenades[p]
+	if len(playerGrenades) == 0 {
+		return
+	}
+
+	grenades := playerGrenades[wepType]
+	if len(grenades) == 0 {
+		return
+	}
 
+	// Delete the first grenade thrown by the player and this grenade type.
+	playerGrenades[wepType] = grenades[:len(grenades)-1]
+	if len(playerGrenades[wepType]) == 0 {
+		delete(playerGrenades, wepType)
+	}
 }
 
 func (geh gameEventHandler) attackerWeaponType(wepType common.EquipmentType, victimUserID int32) common.EquipmentType {
@@ -1082,13 +1116,6 @@ func (geh gameEventHandler) getEquipmentInstance(player *common.Player, wepType
 	return getPlayerWeapon(player, wepType)
 }
 
-// checks if two EquipmentElements are the same, considering that incendiary and molotov should be treated as identical
-func isSameEquipmentElement(a common.EquipmentType, b common.EquipmentType) bool {
-	return a == b ||
-		(a == common.EqIncendiary && b == common.EqMolotov) ||
-		(b == common.EqIncendiary && a == common.EqMolotov)
-}
-
 // Returns the players instance of the weapon if applicable or a new instance otherwise.
 func getPlayerWeapon(player *common.Player, wepType common.EquipmentType) *common.Equipment {
 	if player != nil {

pkg/demoinfocs/game_events_test.go

@@ -115,7 +115,7 @@ func TestAddThrownGrenade(t *testing.T) {
 
 	assert.NotEmpty(t, p.gameState.thrownGrenades)
 	assert.NotEmpty(t, p.gameState.thrownGrenades[pl])
-	assert.Equal(t, p.gameState.thrownGrenades[pl][common.EqHE], he)
+	assert.Equal(t, p.gameState.thrownGrenades[pl][common.EqHE][0], he)
 }
 
 func TestGetThrownGrenade_NilPlayer(t *testing.T) {

pkg/demoinfocs/game_state.go

@@ -37,10 +37,10 @@ type gameState struct {
 	isFreezetime                 bool
 	isMatchStarted               bool
 	overtimeCount                int
-	lastFlash                    lastFlash                                                     // Information about the last flash that exploded, used to find the attacker and projectile for player_blind events
-	currentDefuser               *common.Player                                                // Player currently defusing the bomb, if any
-	currentPlanter               *common.Player                                                // Player currently planting the bomb, if any
-	thrownGrenades               map[*common.Player]map[common.EquipmentType]*common.Equipment // Information about every player's thrown grenades (from the moment they are thrown to the moment their effect is ended)
+	lastFlash                    lastFlash                                                       // Information about the last flash that exploded, used to find the attacker and projectile for player_blind events
+	currentDefuser               *common.Player                                                  // Player currently defusing the bomb, if any
+	currentPlanter               *common.Player                                                  // Player currently planting the bomb, if any
+	thrownGrenades               map[*common.Player]map[common.EquipmentType][]*common.Equipment // Information about every player's thrown grenades (from the moment they are thrown to the moment their effect is ended)
 	rules                        gameRules
 	demoInfo                     demoInfoProvider
 	lastRoundStartEvent          *events.RoundStart             // Used to dispatch this event after a possible MatchStartedChanged event
@@ -249,7 +249,7 @@ func newGameState(demoInfo demoInfoProvider) *gameState {
 		weapons:                  make(map[int]*common.Equipment),
 		hostages:                 make(map[int]*common.Hostage),
 		entities:                 make(map[int]st.Entity),
-		thrownGrenades:           make(map[*common.Player]map[common.EquipmentType]*common.Equipment),
+		thrownGrenades:           make(map[*common.Player]map[common.EquipmentType][]*common.Equipment),
 		flyingFlashbangs:         make([]*FlyingFlashbang, 0),
 		lastFlash: lastFlash{
 			projectileByPlayer: make(map[*common.Player]*common.GrenadeProjectile),