Add tracking of grenade projectiles.

Author: micvbang

common/common.go

@@ -22,6 +22,7 @@ func init() {
 
 func initEqNameToWeapon() {
 	eqNameToWeapon = make(map[string]EquipmentElement)
+
 	eqNameToWeapon["ak47"] = EqAK47
 	eqNameToWeapon["aug"] = EqAUG
 	eqNameToWeapon["awp"] = EqAWP
@@ -30,7 +31,7 @@ func initEqNameToWeapon() {
 	eqNameToWeapon["deagle"] = EqDeagle
 	eqNameToWeapon["decoy"] = EqDecoy
 	eqNameToWeapon["decoygrenade"] = EqDecoy
-	eqNameToWeapon["decoy_projectile"] = EqDecoy
+	eqNameToWeapon["decoyprojectile"] = EqDecoy
 	eqNameToWeapon["elite"] = EqDualBarettas
 	eqNameToWeapon["famas"] = EqFamas
 	eqNameToWeapon["fiveseven"] = EqFiveSeven
@@ -49,7 +50,7 @@ func initEqNameToWeapon() {
 	eqNameToWeapon["mag7"] = EqSwag7
 	eqNameToWeapon["molotov"] = EqMolotov
 	eqNameToWeapon["molotovgrenade"] = EqMolotov
-	eqNameToWeapon["molotov_projectile"] = EqMolotov
+	eqNameToWeapon["molotovprojectile"] = EqMolotov
 	eqNameToWeapon["mp7"] = EqMP7
 	eqNameToWeapon["mp9"] = EqMP9
 	eqNameToWeapon["negev"] = EqNegev
@@ -60,7 +61,7 @@ func initEqNameToWeapon() {
 	eqNameToWeapon["scar20"] = EqScar20
 	eqNameToWeapon["sg556"] = EqSG556
 	eqNameToWeapon["smokegrenade"] = EqSmoke
-	eqNameToWeapon["ssg08"] = EqScout
+	eqNameToWeapon["smokegrenadeprojectile"] = EqSmoke
 	eqNameToWeapon["taser"] = EqZeus
 	eqNameToWeapon["tec9"] = EqTec9
 	eqNameToWeapon["ump45"] = EqUMP

common/structs.go

@@ -1,6 +1,8 @@
 package common
 
 import (
+	"math/rand"
+
 	r3 "github.com/golang/geo/r3"
 
 	st "github.com/markus-wa/demoinfocs-golang/sendtables"
@@ -100,12 +102,36 @@ type Equipment struct {
 	ReserveAmmo    int
 }
 
+// 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
+	Owner    *Player
+
+	// uniqueID is used to distinguish different grenades (which potentially have the same, reused entityID) from each other.
+	uniqueID int64
+
+	Position r3.Vector
+}
+
 // Class returns the class of the equipment.
 // E.g. pistol, smg, heavy etc.
 func (e Equipment) Class() EquipmentClass {
 	return e.Weapon.Class()
 }
 
+// NewGrenadeProjectile creates a grenade projectile and sets.
+func NewGrenadeProjectile() *GrenadeProjectile {
+	return &GrenadeProjectile{uniqueID: rand.Int63()}
+}
+
+// UniqueID returns the internal id of the grenade, which is used to distinguish grenades that reuse another entity's entity id.
+func (g GrenadeProjectile) UniqueID() int64 {
+	return g.uniqueID
+}
+
 // NewEquipment is a wrapper for NewSkinEquipment to create weapons without skins.
 func NewEquipment(eqName string) Equipment {
 	return NewSkinEquipment(eqName, "")

datatables.go

@@ -20,6 +20,12 @@ const (
 
 func (p *Parser) mapEquipment() {
 	for _, sc := range p.stParser.ServerClasses() {
+		for _, bc := range sc.BaseClasses {
+			if bc.Name == "CBaseGrenade" { // Grenades projectiles, i.e. thrown by player
+				p.equipmentMapping[sc] = common.MapEquipment(strings.ToLower(sc.DTName[3:]))
+			}
+		}
+
 		if len(sc.BaseClasses) > 6 && sc.BaseClasses[6].Name == "CWeaponCSBase" {
 			if len(sc.BaseClasses) > 7 {
 				switch sc.BaseClasses[7].Name {
@@ -36,7 +42,6 @@ func (p *Parser) mapEquipment() {
 				switch sc.Name {
 				case "CC4":
 					p.equipmentMapping[sc] = common.EqBomb
-
 				case "CWeaponNOVA":
 					fallthrough
 				case "CWeaponSawedoff":
@@ -253,18 +258,18 @@ func (p *Parser) bindNewPlayer(playerEntity *st.Entity) {
 	for i := range cache {
 		i2 := i // Copy for passing to handler
 		playerEntity.FindProperty(wepPrefix + fmt.Sprintf("%03d", i)).RegisterPropertyUpdateHandler(func(val st.PropValue) {
-			idx := val.IntVal & indexMask
-			if idx != indexMask {
+			entityID := val.IntVal & indexMask
+			if entityID != indexMask {
 				if cache[i2] != 0 {
 					// Player already has a weapon in this slot.
 					pl.RawWeapons[cache[i2]] = nil
 				}
-				cache[i2] = idx
+				cache[i2] = entityID
 
 				// Attribute weapon to player
-				wep := &p.weapons[idx]
+				wep := &p.weapons[entityID]
 				wep.Owner = pl
-				pl.RawWeapons[idx] = wep
+				pl.RawWeapons[entityID] = wep
 			} else {
 				if cache[i2] != 0 && pl.RawWeapons[cache[i2]] != nil {
 					pl.RawWeapons[cache[i2]].Owner = nil
@@ -290,11 +295,60 @@ func (p *Parser) bindWeapons() {
 
 	for _, sc := range p.stParser.ServerClasses() {
 		for _, bc := range sc.BaseClasses {
-			if bc.Name == "CWeaponCSBase" {
+			switch bc.Name {
+			case "CWeaponCSBase":
 				sc.RegisterEntityCreatedHandler(p.bindWeapon)
+			case "CBaseGrenade": // Grenade that has been thrown by player.
+				sc.RegisterEntityCreatedHandler(p.bindGrenadeProjectiles)
+			case "CBaseCSGrenade":
+				// @micvbang TODO: handle grenades dropped by dead player.
+				// Grenades that were dropped by a dead player (and can be picked up by other players).
 			}
 		}
 	}
+
+}
+
+// bindGrenadeProjectiles keeps track of the location of live grenades, actively thrown by players.
+// It does track the location of grenades lying on the ground, i.e. that were dropped by dead players.
+//
+// NOTE: Parser.gameState.grenadeProjectiles is updated here. We rely on code during the handling of the game events
+// "[nade]_detonate" and "[nade]_started" to remove projectiles from Parser.gameState.grenadeProjectiles once they detonate.
+func (p *Parser) bindGrenadeProjectiles(event st.EntityCreatedEvent) {
+	if _, ok := p.gameState.grenadeProjectiles[event.Entity.ID]; !ok {
+		p.gameState.grenadeProjectiles[event.Entity.ID] = common.NewGrenadeProjectile()
+	}
+
+	proj := p.gameState.grenadeProjectiles[event.Entity.ID]
+	proj.EntityID = event.Entity.ID
+
+	event.Entity.FindProperty("m_nModelIndex").RegisterPropertyUpdateHandler(func(val st.PropValue) {
+		proj.Weapon = p.grenadeModelIndicies[val.IntVal]
+	})
+
+	// @micvbang: not quite sure what the difference between Thrower and Owner is.
+	event.Entity.FindProperty("m_hThrower").RegisterPropertyUpdateHandler(func(val st.PropValue) {
+		throwerID := val.IntVal & indexMask
+		throwerIndex := throwerID - 1
+
+		thrower := p.entityIDToPlayers[throwerIndex]
+		proj.Thrower = thrower
+
+		if proj.Thrower == nil && thrower != nil {
+			proj.Position = thrower.Position
+		}
+	})
+
+	event.Entity.FindProperty("m_hOwnerEntity").RegisterPropertyUpdateHandler(func(val st.PropValue) {
+		ownerID := val.IntVal & indexMask
+		ownerIndex := ownerID - 1
+		player := p.entityIDToPlayers[ownerIndex]
+		proj.Owner = player
+	})
+
+	event.Entity.FindProperty("m_vecOrigin").RegisterPropertyUpdateHandler(func(val st.PropValue) {
+		proj.Position = event.Entity.Position()
+	})
 }
 
 func (p *Parser) bindWeapon(event st.EntityCreatedEvent) {

game_events.go

@@ -3,6 +3,7 @@ package demoinfocs
 import (
 	"fmt"
 	"strconv"
+	"strings"
 
 	r3 "github.com/golang/geo/r3"
 
@@ -183,6 +184,11 @@ func (p *Parser) handleGameEvent(ge *msg.CSVCMsg_GameEvent) {
 		}
 		nadeEntityID := int(data["entityid"].GetValShort())
 
+		// Grenade projectiles should be removed once the grenade detonates.
+		if strings.Contains(d.Name, "detonate") || strings.Contains(d.Name, "started") {
+			delete(p.gameState.grenadeProjectiles, nadeEntityID)
+		}
+
 		switch d.Name {
 		case "flashbang_detonate": // Flash exploded
 			p.eventDispatcher.Dispatch(events.FlashExplodedEvent{NadeEvent: buildNadeEvent(common.EqFlash, thrower, position, nadeEntityID)})

game_state.go

@@ -6,10 +6,11 @@ import (
 
 // GameState contains all game-state relevant information.
 type GameState struct {
-	ingameTick int
-	tState     TeamState
-	ctState    TeamState
-	players    map[int]*common.Player
+	ingameTick         int
+	tState             TeamState
+	ctState            TeamState
+	players            map[int]*common.Player
+	grenadeProjectiles map[int]*common.GrenadeProjectile // Used to keep track of grenades that have been thrown, but have not yet detonated.
 }
 
 type ingameTickNumber int
@@ -69,8 +70,17 @@ func (gs GameState) TeamMembers(team common.Team) []*common.Player {
 	return r
 }
 
+// GrenadeProjectiles returns a map with all grenade projectiles. The map contains only projectiles
+// that are currently in-flight, i.e. have been thrown but have yet to detonate.
+func (gs GameState) GrenadeProjectiles() map[int]*common.GrenadeProjectile {
+	return gs.grenadeProjectiles
+}
+
 func newGameState() GameState {
-	return GameState{players: make(map[int]*common.Player)}
+	return GameState{
+		players:            make(map[int]*common.Player),
+		grenadeProjectiles: make(map[int]*common.GrenadeProjectile),
+	}
 }
 
 // TeamState contains a team's ID, score, clan name & country flag.

model_precache.go

@@ -0,0 +1,30 @@
+package demoinfocs
+
+import (
+	"strings"
+
+	common "github.com/markus-wa/demoinfocs-golang/common"
+)
+
+var modelPrecacheNameToEq = []struct {
+	name string
+	eq   common.EquipmentElement
+}{
+	{"flashbang_dropped", common.EqFlash},
+	{"fraggrenade_dropped", common.EqHE},
+	{"smokegrenade_thrown", common.EqSmoke},
+	{"molotov_dropped", common.EqMolotov},
+	{"incendiarygrenade_dropped", common.EqIncendiary},
+	{"decoy_dropped", common.EqDecoy},
+	// @micvbang TODO: add all other weapons too.
+}
+
+func (p *Parser) processModelPreCacheUpdate() {
+	for i, name := range p.modelPreCache {
+		for _, nade := range modelPrecacheNameToEq {
+			if strings.Contains(name, nade.name) {
+				p.grenadeModelIndicies[i] = nade.eq
+			}
+		}
+	}
+}

parser.go

@@ -41,6 +41,7 @@ type Parser struct {
 	instanceBaselines            map[int][]byte
 	preprocessedBaselines        map[int]map[int]st.PropValue
 	gameEventDescs               map[int32]*msg.CSVCMsg_GameEventListDescriptorT
+	grenadeModelIndicies         map[int]common.EquipmentElement // Used to map model indicies to grenades (used for grenade projectiles)
 	stringTables                 []*msg.CSVCMsg_CreateStringTable
 	cancelChan                   chan struct{}
 	err                          error
@@ -207,6 +208,7 @@ func NewParserWithConfig(demostream io.Reader, config ParserConfig) *Parser {
 	p.triggers = make(map[int]*boundingBoxInformation)
 	p.cancelChan = make(chan struct{}, 1)
 	p.gameState = newGameState()
+	p.grenadeModelIndicies = make(map[int]common.EquipmentElement)
 
 	// Attach proto msg handlers
 	p.msgDispatcher.RegisterHandler(p.handlePacketEntities)

stringtables.go

@@ -45,6 +45,7 @@ func (p *Parser) parseStringTables() {
 		tableName := p.bitReader.ReadString()
 		p.parseSingleStringTable(tableName)
 	}
+	p.processModelPreCacheUpdate()
 	p.bitReader.EndChunk()
 }
 
@@ -211,6 +212,11 @@ func (p *Parser) processStringTable(tab *msg.CSVCMsg_CreateStringTable) {
 			p.modelPreCache[entryIndex] = entry
 		}
 	}
+
+	if tab.Name == stNameModelPreCache {
+		p.processModelPreCacheUpdate()
+	}
+
 	br.Pool()
 }