Add GrenadeProjectile.Trajectory

Add NadeProjectileDestroyedEvent for easy access to the final trajectory
Update nade-trajectories example accordingly
Add nade trajectories to feature list in README

Author: markus-wa

README.md

@@ -87,6 +87,7 @@ This doesn't look too interesting on it's own but that can be helped by quickly
 ## Features
 
 * Game events
+* Grenade projectiles / trajectories - [doc](https://godoc.org/github.com/markus-wa/demoinfocs-golang#GameState.GrenadeProjectiles) [example](https://github.com/markus-wa/demoinfocs-golang/tree/master/examples/nade-trajectories)
 * Access to entities, server-classes & data-tables
 * Access to all net-messages
 * Chat & console messages <sup id="achat1">1</sup>

common/structs.go

@@ -116,15 +116,15 @@ type Equipment struct {
 // 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
+	EntityID   int
+	Weapon     EquipmentElement
+	Thrower    *Player
+	Owner      *Player
+	Position   r3.Vector
+	Trajectory []r3.Vector
 
 	// 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.

datatables.go

@@ -4,6 +4,8 @@ import (
 	"fmt"
 	"strings"
 
+	r3 "github.com/golang/geo/r3"
+
 	common "github.com/markus-wa/demoinfocs-golang/common"
 	events "github.com/markus-wa/demoinfocs-golang/events"
 	st "github.com/markus-wa/demoinfocs-golang/sendtables"
@@ -270,15 +272,19 @@ func (p *Parser) bindWeapons() {
 // It does NOT track the location of grenades lying on the ground, i.e. that were dropped by dead players.
 func (p *Parser) bindGrenadeProjectiles(entity *st.Entity) {
 	entityID := entity.ID()
-	p.gameState.grenadeProjectiles[entityID] = common.NewGrenadeProjectile()
+
+	proj := common.NewGrenadeProjectile()
+	proj.EntityID = entityID
+	p.gameState.grenadeProjectiles[entityID] = proj
 
 	entity.OnDestroy(func() {
+		p.eventDispatcher.Dispatch(events.NadeProjectileDestroyedEvent{
+			Projectile: proj,
+		})
+
 		delete(p.gameState.grenadeProjectiles, entityID)
 	})
 
-	proj := p.gameState.grenadeProjectiles[entityID]
-	proj.EntityID = entityID
-
 	entity.FindProperty("m_nModelIndex").OnUpdate(func(val st.PropertyValue) {
 		proj.Weapon = p.grenadeModelIndices[val.IntVal]
 	})
@@ -297,8 +303,10 @@ func (p *Parser) bindGrenadeProjectiles(entity *st.Entity) {
 		proj.Owner = player
 	})
 
-	entity.FindProperty("m_vecOrigin").OnUpdate(func(st.PropertyValue) {
-		proj.Position = entity.Position()
+	entity.OnPositionUpdate(func(newPos r3.Vector) {
+		proj.Position = newPos
+
+		proj.Trajectory = append(proj.Trajectory, newPos)
 	})
 
 	// Some demos don't have this property as it seems

events/events.go

@@ -209,6 +209,14 @@ type NadeProjectileThrownEvent struct {
 	Projectile *common.GrenadeProjectile
 }
 
+// NadeProjectileDestroyedEvent signals that a nade entity has been destroyed (i.e. it detonated / expired).
+// This is different from the other Nade events because it's sent out when the projectile entity is destroyed.
+//
+// Mainly useful for getting the full trajectory of the projectile.
+type NadeProjectileDestroyedEvent struct {
+	Projectile *common.GrenadeProjectile
+}
+
 // PlayerFlashedEvent signals that a player was flashed.
 type PlayerFlashedEvent struct {
 	Player *common.Player

examples/nade-trajectories/nade_trajectories.go

@@ -44,39 +44,33 @@ func main() {
 	_, err = p.ParseHeader()
 	checkError(err)
 
-	nadePaths := make(map[int64]*nadePath) // Currently live projectiles
-
-	storeNadePath := func(id int64, pos r3.Vector, wep common.EquipmentElement, team common.Team) {
-		if nadePaths[id] == nil {
-			nadePaths[id] = &nadePath{
-				wep:  wep,
-				team: team,
+	nadeTrajectories := make(map[int64]*nadePath) // Trajectories of all destroyed nades
+
+	p.RegisterEventHandler(func(e events.NadeProjectileDestroyedEvent) {
+		id := e.Projectile.UniqueID()
+		if nadeTrajectories[id] == nil {
+			nadeTrajectories[id] = &nadePath{
+				wep:  e.Projectile.Weapon,
+				team: e.Projectile.Thrower.Team,
 			}
 		}
 
-		nadePaths[id].path = append(nadePaths[id].path, pos)
-	}
-
-	p.RegisterEventHandler(func(e events.NadeProjectileThrownEvent) {
-		storeNadePath(e.Projectile.UniqueID(), e.Projectile.Position, e.Projectile.Weapon, e.Projectile.Thrower.Team)
-	})
-
-	p.RegisterEventHandler(func(e events.NadeProjectileBouncedEvent) {
-		storeNadePath(e.Projectile.UniqueID(), e.Projectile.Position, e.Projectile.Weapon, e.Projectile.Thrower.Team)
+		nadeTrajectories[id].path = e.Projectile.Trajectory
 	})
 
-	var nadePathsFirstHalf []*nadePath
+	var nadeTrajectoriesFirstHalf []*nadePath
 	round := 0
 	p.RegisterEventHandler(func(events.RoundEndedEvent) {
 		round++
-		// Very cheap first half check (we only want the first teams CT-side nades in the example).
+		// Very cheap first half check
+		// We only want the first teams CT-side nades in the example so the image is not too cluttered
 		// Won't work with demos that have match-restarts etc.
 		if round == 15 {
 			// Copy all nade paths from the first 15 rounds
-			for _, np := range nadePaths {
-				nadePathsFirstHalf = append(nadePathsFirstHalf, np)
+			for _, np := range nadeTrajectories {
+				nadeTrajectoriesFirstHalf = append(nadeTrajectoriesFirstHalf, np)
 			}
-			nadePaths = make(map[int64]*nadePath)
+			nadeTrajectories = make(map[int64]*nadePath)
 		}
 	})
 
@@ -102,7 +96,7 @@ func main() {
 	gc.SetLineWidth(1)                      // 1 px lines
 	gc.SetFillColor(color.RGBA{0, 0, 0, 0}) // No fill, alpha 0
 
-	for _, np := range nadePathsFirstHalf {
+	for _, np := range nadeTrajectoriesFirstHalf {
 		if np.team != common.TeamCounterTerrorists {
 			// Only draw CT nades
 			continue

examples/nade-trajectories/nade_trajectories.jpg

@@ -81,6 +81,12 @@ func (e *Entity) ApplyUpdate(reader *bit.BitReader) {
 
 	for _, idx := range *updatedPropIndices {
 		propDecoder.decodeProp(&e.props[idx], reader)
+	}
+
+	// Fire update only after all properties have been updated
+	// That way data that is made up of multiple properties won't be wrong
+	// For instance the entity's position
+	for _, idx := range *updatedPropIndices {
 		e.props[idx].firePropertyUpdate()
 	}
 
@@ -147,15 +153,22 @@ func (e *Entity) applyBaseline(baseline map[int]PropertyValue) {
 	}
 }
 
-const maxCoordInt = 16384
+const (
+	maxCoordInt   = 16384
+	propCellBits  = "m_cellbits"
+	propCellX     = "m_cellX"
+	propCellY     = "m_cellY"
+	propCellZ     = "m_cellZ"
+	propVecOrigin = "m_vecOrigin"
+)
 
 // Position returns the entity's position in world coordinates.
 func (e *Entity) Position() r3.Vector {
-	cellWidth := 1 << uint(e.FindProperty("m_cellbits").value.IntVal)
-	cellX := e.FindProperty("m_cellX").value.IntVal
-	cellY := e.FindProperty("m_cellY").value.IntVal
-	cellZ := e.FindProperty("m_cellZ").value.IntVal
-	offset := e.FindProperty("m_vecOrigin").value.VectorVal
+	cellWidth := 1 << uint(e.FindProperty(propCellBits).value.IntVal)
+	cellX := e.FindProperty(propCellX).value.IntVal
+	cellY := e.FindProperty(propCellY).value.IntVal
+	cellZ := e.FindProperty(propCellZ).value.IntVal
+	offset := e.FindProperty(propVecOrigin).value.VectorVal
 
 	return r3.Vector{
 		X: coordFromCell(cellX, cellWidth, offset.X),
@@ -164,6 +177,38 @@ func (e *Entity) Position() r3.Vector {
 	}
 }
 
+// OnPositionUpdate registers a handler for the entity's position update.
+// The handler is called with the new position every time a position-relevant property is updated.
+// This does NOT work for players as their position is calculated differently.
+//
+// See also Position()
+func (e *Entity) OnPositionUpdate(h func(pos r3.Vector)) {
+	pos := new(r3.Vector)
+	firePosUpdate := func(PropertyValue) {
+		newPos := e.Position()
+		if *pos != newPos {
+			h(newPos)
+			*pos = newPos
+		}
+	}
+
+	e.FindProperty(propCellX).OnUpdate(firePosUpdate)
+	e.FindProperty(propCellY).OnUpdate(firePosUpdate)
+	e.FindProperty(propCellZ).OnUpdate(firePosUpdate)
+	e.FindProperty(propVecOrigin).OnUpdate(firePosUpdate)
+}
+
+// BindPosition binds the entity's position to a pointer variable.
+// The pointer is updated every time a position-relevant property is updated.
+// This does NOT work for players as their position is calculated differently.
+//
+// See also OnPositionUpdate()
+func (e *Entity) BindPosition(pos *r3.Vector) {
+	e.OnPositionUpdate(func(newPos r3.Vector) {
+		*pos = newPos
+	})
+}
+
 // Returns a coordinate from a cell + offset
 func coordFromCell(cell, cellWidth int, offset float64) float64 {
 	return float64(cell*cellWidth-maxCoordInt) + offset