improve grenade tracking (#160)

- add GrenadeEvent.Grenade
- add GrenadeProjectile.WeaponInstance
- deprecated Inferno.Owner() in favor Inferno.Thrower()
- internally, thrown grenades are tracked in GameState.thrownGrenades

Author: xavier-rodet

common/common.go

@@ -64,12 +64,16 @@ func (h DemoHeader) TickTime() time.Duration {
 // GrenadeProjectile is a grenade thrown intentionally by a player. It is used to track grenade projectile
 // positions between the time at which they are thrown and until they detonate.
 type GrenadeProjectile struct {
-	EntityID   int
-	Weapon     EquipmentElement
-	Thrower    *Player // Always seems to be the same as Owner, even if the grenade was picked up
-	Owner      *Player // Always seems to be the same as Thrower, even if the grenade was picked up
-	Position   r3.Vector
-	Trajectory []r3.Vector // List of all known locations of the grenade up to the current point
+	EntityID int
+	// Deprecated: Weapon exists for historical compatibility
+	// and should not be used. To access the weapon corresponding to his GrenadeProjectile,
+	// use the WeaponInstance.Weapon instead.
+	Weapon         EquipmentElement
+	WeaponInstance *Equipment
+	Thrower        *Player // Always seems to be the same as Owner, even if the grenade was picked up
+	Owner          *Player // Always seems to be the same as Thrower, even if the grenade was picked up
+	Position       r3.Vector
+	Trajectory     []r3.Vector // List of all known locations of the grenade up to the current point
 
 	// uniqueID is used to distinguish different grenades (which potentially have the same, reused entityID) from each other.
 	uniqueID int64

common/inferno.go

@@ -139,7 +139,16 @@ func (inf Inferno) ConvexHull3D() quickhull.ConvexHull {
 
 // Owner returns the player who threw the fire grenade.
 // Could be nil if the player disconnected after throwing it.
+//
+// Deprecated: Owner() exists for historical compatibility
+// and should not be used. Use Thrower() instead.
 func (inf Inferno) Owner() *Player {
+	return inf.Thrower()
+}
+
+// Thrower returns the player who threw the fire grenade.
+// Could be nil if the player disconnected after throwing it.
+func (inf Inferno) Thrower() *Player {
 	return inf.demoInfoProvider.FindPlayerByHandle(inf.Entity.FindPropertyI("m_hOwnerEntity").Value().IntVal)
 }
 

common/inferno_test.go

@@ -120,3 +120,14 @@ func TestInferno_Owner(t *testing.T) {
 
 	assert.Equal(t, player, NewInferno(provider, entity).Owner())
 }
+
+func TestInferno_Thrower(t *testing.T) {
+	entity := entityWithProperty("m_hOwnerEntity", st.PropertyValue{IntVal: 1})
+
+	player := new(Player)
+	provider := demoInfoProviderMock{
+		playersByHandle: map[int]*Player{1: player},
+	}
+
+	assert.Equal(t, player, NewInferno(provider, entity).Thrower())
+}

datatables.go

@@ -376,6 +376,8 @@ func (p *Parser) bindGrenadeProjectiles(entity *st.Entity) {
 	p.gameState.grenadeProjectiles[entityID] = proj
 
 	entity.OnCreateFinished(func() {
+		p.gameEventHandler.addThrownGrenade(proj.Thrower, proj.WeaponInstance)
+
 		p.eventDispatcher.Dispatch(events.GrenadeProjectileThrow{
 			Projectile: proj,
 		})
@@ -387,6 +389,9 @@ func (p *Parser) bindGrenadeProjectiles(entity *st.Entity) {
 
 	entity.FindPropertyI("m_nModelIndex").OnUpdate(func(val st.PropertyValue) {
 		proj.Weapon = p.grenadeModelIndices[val.IntVal]
+
+		equipment := common.NewEquipment(p.grenadeModelIndices[val.IntVal])
+		proj.WeaponInstance = &equipment
 	})
 
 	// @micvbang: not quite sure what the difference between Thrower and Owner is.
@@ -432,9 +437,18 @@ func (p *Parser) nadeProjectileDestroyed(proj *common.GrenadeProjectile) {
 
 	delete(p.gameState.grenadeProjectiles, proj.EntityID)
 
-	if proj.Weapon == common.EqFlash {
+	if proj.WeaponInstance.Weapon == common.EqFlash {
 		p.gameState.lastFlash.projectileByPlayer[proj.Owner] = proj
 	}
+
+	// We delete from the Owner.ThrownGrenades (only if not inferno or smoke, because they will be deleted when they expire)
+	isInferno := proj.WeaponInstance.Weapon == common.EqMolotov || proj.WeaponInstance.Weapon == common.EqIncendiary
+	isSmoke := proj.WeaponInstance.Weapon == common.EqSmoke
+	isDecoy := proj.WeaponInstance.Weapon == common.EqDecoy
+
+	if !isInferno && !isSmoke && !isDecoy {
+		p.gameEventHandler.deleteThrownGrenade(proj.Thrower, proj.WeaponInstance.Weapon)
+	}
 }
 
 func (p *Parser) bindWeapon(entity *st.Entity, wepType common.EquipmentElement) {
@@ -539,6 +553,8 @@ func (p *Parser) infernoExpired(inf *common.Inferno) {
 	})
 
 	delete(p.gameState.infernos, inf.EntityID)
+
+	p.gameEventHandler.deleteThrownGrenade(inf.Thrower(), common.EqIncendiary)
 }
 
 func (p *Parser) bindGameRules() {

events/events.go

@@ -172,6 +172,7 @@ type GrenadeEventIf interface {
 // handlers on this tho, you want GrenadeEventIf for that
 type GrenadeEvent struct {
 	GrenadeType     common.EquipmentElement
+	Grenade         *common.Equipment // Maybe nil for InfernoStart & InfernoExpired since we don't know the thrower (at least in old demos)
 	Position        r3.Vector
 	Thrower         *common.Player
 	GrenadeEntityID int

game_events.go

@@ -238,6 +238,9 @@ func (geh gameEventHandler) roundOfficiallyEnded(data map[string]*msg.CSVCMsg_Ga
 		geh.parser.infernoExpired(inf)
 	}
 
+	// 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][]*common.Equipment)
+
 	geh.dispatch(events.RoundEndOfficial{})
 }
 
@@ -307,7 +310,7 @@ func (geh gameEventHandler) playerDeath(data map[string]*msg.CSVCMsg_GameEventKe
 		Assister:          geh.playerByUserID32(data["assister"].GetValShort()),
 		IsHeadshot:        data["headshot"].GetValBool(),
 		PenetratedObjects: int(data["penetrated"].GetValShort()),
-		Weapon:            getPlayerWeapon(killer, wepType),
+		Weapon:            geh.getEquipmentInstance(killer, wepType),
 	})
 }
 
@@ -323,7 +326,7 @@ func (geh gameEventHandler) playerHurt(data map[string]*msg.CSVCMsg_GameEventKey
 		HealthDamage: int(data["dmg_health"].GetValShort()),
 		ArmorDamage:  int(data["dmg_armor"].GetValByte()),
 		HitGroup:     events.HitGroup(data["hitgroup"].GetValByte()),
-		Weapon:       getPlayerWeapon(attacker, wepType),
+		Weapon:       geh.getEquipmentInstance(attacker, wepType),
 	})
 }
 
@@ -366,9 +369,12 @@ func (geh gameEventHandler) decoyStarted(data map[string]*msg.CSVCMsg_GameEventK
 }
 
 func (geh gameEventHandler) decoyDetonate(data map[string]*msg.CSVCMsg_GameEventKeyT) {
+	event := geh.nadeEvent(data, common.EqDecoy)
 	geh.dispatch(events.DecoyExpired{
-		GrenadeEvent: geh.nadeEvent(data, common.EqDecoy),
+		GrenadeEvent: event,
 	})
+
+	geh.deleteThrownGrenade(event.Thrower, common.EqDecoy)
 }
 
 func (geh gameEventHandler) smokeGrenadeDetonate(data map[string]*msg.CSVCMsg_GameEventKeyT) {
@@ -378,9 +384,12 @@ func (geh gameEventHandler) smokeGrenadeDetonate(data map[string]*msg.CSVCMsg_Ga
 }
 
 func (geh gameEventHandler) smokeGrenadeExpired(data map[string]*msg.CSVCMsg_GameEventKeyT) {
+	event := geh.nadeEvent(data, common.EqSmoke)
 	geh.dispatch(events.SmokeExpired{
-		GrenadeEvent: geh.nadeEvent(data, common.EqSmoke),
+		GrenadeEvent: event,
 	})
+
+	geh.deleteThrownGrenade(event.Thrower, common.EqSmoke)
 }
 
 func (geh gameEventHandler) infernoStartBurn(data map[string]*msg.CSVCMsg_GameEventKeyT) {
@@ -583,18 +592,80 @@ func (geh gameEventHandler) nadeEvent(data map[string]*msg.CSVCMsg_GameEventKeyT
 
 	return events.GrenadeEvent{
 		GrenadeType:     nadeType,
+		Grenade:         geh.getThrownGrenade(thrower, nadeType),
 		Thrower:         thrower,
 		Position:        position,
 		GrenadeEntityID: nadeEntityID,
 	}
 }
 
-func mapGameEventData(d *msg.CSVCMsg_GameEventListDescriptorT, e *msg.CSVCMsg_GameEvent) map[string]*msg.CSVCMsg_GameEventKeyT {
-	data := make(map[string]*msg.CSVCMsg_GameEventKeyT)
-	for i, k := range d.Keys {
-		data[k.Name] = e.Keys[i]
+func (geh gameEventHandler) addThrownGrenade(p *common.Player, wep *common.Equipment) {
+	if p == nil {
+		// can happen for "unknown" players (see #162)
+		return
 	}
-	return data
+
+	gameState := geh.gameState()
+	gameState.thrownGrenades[p] = append(gameState.thrownGrenades[p], wep)
+}
+
+func (geh gameEventHandler) getThrownGrenade(p *common.Player, wepType common.EquipmentElement) *common.Equipment {
+	if p == nil {
+		// can happen for incendiaries or "unknown" players (see #162)
+		return nil
+	}
+
+	// Get the first weapon we found for this player with this weapon type
+	for _, thrownGrenade := range geh.gameState().thrownGrenades[p] {
+		if isSameEquipmentElement(thrownGrenade.Weapon, wepType) {
+			return thrownGrenade
+		}
+	}
+
+	// smokes might have duplicate smokegrenade_expired events, so it could have already been deleted.
+	// if it's not a smoke this should never be reached
+	unassert.Samef(wepType, common.EqSmoke, "tried to get non-existing grenade from gameState.thrownGrenades")
+
+	return nil
+}
+
+func (geh gameEventHandler) deleteThrownGrenade(p *common.Player, wepType common.EquipmentElement) {
+	if p == nil {
+		// can happen for incendiaries or "unknown" players (see #162)
+		return
+	}
+
+	gameState := geh.gameState()
+
+	// Delete the first weapon we found with this weapon type
+	for i, weapon := range gameState.thrownGrenades[p] {
+		// If same weapon type
+		// OR if it's an EqIncendiary we must check for EqMolotov too because of geh.infernoExpire() handling ?
+		if isSameEquipmentElement(wepType, weapon.Weapon) {
+			gameState.thrownGrenades[p] = append(gameState.thrownGrenades[p][:i], gameState.thrownGrenades[p][i+1:]...)
+			return
+		}
+	}
+
+	// smokes might have duplicate smokegrenade_expired events, so it might already be deleted.
+	// besides that this code should never be reached
+	unassert.Samef(wepType, common.EqSmoke, "trying to delete non-existing grenade from gameState.thrownGrenades")
+}
+
+func (geh gameEventHandler) getEquipmentInstance(player *common.Player, wepType common.EquipmentElement) *common.Equipment {
+	isGrenade := wepType.Class() == common.EqClassGrenade
+	if isGrenade {
+		return geh.getThrownGrenade(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.EquipmentElement, b common.EquipmentElement) 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.
@@ -612,6 +683,15 @@ func getPlayerWeapon(player *common.Player, wepType common.EquipmentElement) *co
 	return &wep
 }
 
+func mapGameEventData(d *msg.CSVCMsg_GameEventListDescriptorT, e *msg.CSVCMsg_GameEvent) map[string]*msg.CSVCMsg_GameEventKeyT {
+	data := make(map[string]*msg.CSVCMsg_GameEventKeyT)
+	for i, k := range d.Keys {
+		data[k.Name] = e.Keys[i]
+	}
+
+	return data
+}
+
 // We're all better off not asking questions
 const valveMagicNumber = 76561197960265728
 

game_events_test.go

@@ -86,3 +86,129 @@ func TestGetPlayerWeapon_NotFound(t *testing.T) {
 
 	assert.Equal(t, common.EqM4A1, wep.Weapon)
 }
+
+func TestAddThrownGrenade_NilPlayer(t *testing.T) {
+	p := NewParser(rand.Reader)
+	he := common.NewEquipment(common.EqHE)
+
+	assert.Empty(t, p.gameState.thrownGrenades)
+
+	p.gameEventHandler.addThrownGrenade(nil, &he)
+
+	assert.Empty(t, p.gameState.thrownGrenades)
+}
+
+func TestAddThrownGrenade(t *testing.T) {
+	p := NewParser(rand.Reader)
+	pl := &common.Player{}
+	he := common.NewEquipment(common.EqHE)
+
+	assert.Empty(t, p.gameState.thrownGrenades)
+
+	p.gameEventHandler.addThrownGrenade(pl, &he)
+
+	assert.NotEmpty(t, p.gameState.thrownGrenades)
+	assert.NotEmpty(t, p.gameState.thrownGrenades[pl])
+	assert.Equal(t, p.gameState.thrownGrenades[pl][0], &he)
+}
+
+func TestGetThrownGrenade_NilPlayer(t *testing.T) {
+	p := NewParser(rand.Reader)
+	he := common.NewEquipment(common.EqHE)
+
+	wep := p.gameEventHandler.getThrownGrenade(nil, he.Weapon)
+
+	assert.Nil(t, wep)
+}
+
+func TestGetThrownGrenade_NotFound(t *testing.T) {
+	p := NewParser(rand.Reader)
+	pl := &common.Player{}
+
+	he := common.NewEquipment(common.EqSmoke)
+
+	wep := p.gameEventHandler.getThrownGrenade(pl, he.Weapon)
+
+	assert.Nil(t, wep)
+}
+
+func TestGetThrownGrenade_Found(t *testing.T) {
+	p := NewParser(rand.Reader)
+	pl := &common.Player{}
+	he := common.NewEquipment(common.EqHE)
+
+	p.gameEventHandler.addThrownGrenade(pl, &he)
+	wep := p.gameEventHandler.getThrownGrenade(pl, he.Weapon)
+
+	assert.Equal(t, wep.Weapon, he.Weapon)
+	assert.Equal(t, wep, &he)
+}
+
+func TestDeleteThrownGrenade_NilPlayer(t *testing.T) {
+	p := NewParser(rand.Reader)
+	he := common.NewEquipment(common.EqHE)
+
+	// Do nothing, we just keep sure it doesn't crash
+	p.gameEventHandler.deleteThrownGrenade(nil, he.Weapon)
+}
+
+func TestDeleteThrownGrenade_NotFound(t *testing.T) {
+	p := NewParser(rand.Reader)
+	pl := &common.Player{}
+	he := common.NewEquipment(common.EqHE)
+
+	assert.Empty(t, p.gameState.thrownGrenades)
+
+	p.gameEventHandler.addThrownGrenade(pl, &he)
+
+	assert.NotEmpty(t, p.gameState.thrownGrenades[pl])
+
+	p.gameEventHandler.deleteThrownGrenade(pl, common.EqSmoke)
+
+	assert.NotEmpty(t, p.gameState.thrownGrenades[pl])
+}
+
+func TestDeleteThrownGrenade_Found(t *testing.T) {
+	p := NewParser(rand.Reader)
+	pl := &common.Player{}
+	he := common.NewEquipment(common.EqHE)
+
+	assert.Empty(t, p.gameState.thrownGrenades)
+
+	p.gameEventHandler.addThrownGrenade(pl, &he)
+
+	assert.NotEmpty(t, p.gameState.thrownGrenades[pl])
+
+	p.gameEventHandler.deleteThrownGrenade(pl, he.Weapon)
+
+	assert.Empty(t, p.gameState.thrownGrenades[pl])
+}
+
+func TestGetEquipmentInstance_NotGrenade(t *testing.T) {
+	p := NewParser(rand.Reader)
+	pl := &common.Player{}
+
+	wep := p.gameEventHandler.getEquipmentInstance(pl, common.EqAK47)
+
+	assert.Equal(t, common.EqAK47, wep.Weapon)
+}
+
+func TestGetEquipmentInstance_Grenade_NotThrown(t *testing.T) {
+	p := NewParser(rand.Reader)
+	pl := &common.Player{}
+
+	wep := p.gameEventHandler.getEquipmentInstance(pl, common.EqSmoke)
+
+	assert.Nil(t, wep)
+}
+
+func TestGetEquipmentInstance_Grenade_Thrown(t *testing.T) {
+	p := NewParser(rand.Reader)
+	pl := &common.Player{}
+	he := common.NewEquipment(common.EqHE)
+
+	p.gameEventHandler.addThrownGrenade(pl, &he)
+	wep := p.gameEventHandler.getEquipmentInstance(pl, he.Weapon)
+
+	assert.Equal(t, &he, wep)
+}