Fix molotov & incendiary never being deleted (#32)

Add Entity.OnDestroy() for pre-deletion actions
Add Entity.OnCreateFinished() for post-creation actions (replaces CreateFinishedDummyProp)
Also updated the nade-trajectories example using UniqueID
Documented some functions intended for internal use only

Author: markus-wa

datatables.go

@@ -307,15 +307,14 @@ func (p *Parser) bindWeapons() {
 
 }
 
-// bindGrenadeProjectiles keeps track of the location of live grenades, actively thrown by players.
+// bindGrenadeProjectiles keeps track of the location of live grenades (Parser.gameState.grenadeProjectiles), 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()
-	}
+	p.gameState.grenadeProjectiles[event.Entity.ID] = common.NewGrenadeProjectile()
+
+	event.Entity.OnDestroy(func() {
+		delete(p.gameState.grenadeProjectiles, event.Entity.ID)
+	})
 
 	proj := p.gameState.grenadeProjectiles[event.Entity.ID]
 	proj.EntityID = event.Entity.ID
@@ -362,7 +361,7 @@ func (p *Parser) bindGrenadeProjectiles(event st.EntityCreatedEvent) {
 		})
 	}
 
-	event.Entity.FindProperty(st.CreateFinishedDummyPropertyName).RegisterPropertyUpdateHandler(func(st.PropValue) {
+	event.Entity.OnCreateFinished(func() {
 		p.eventDispatcher.Dispatch(events.NadeProjectileThrownEvent{
 			Projectile: proj,
 		})

entities.go

@@ -27,6 +27,7 @@ func (p *Parser) handlePacketEntities(pe *msg.CSVCMsg_PacketEntities) {
 
 		if r.ReadBit() {
 			// Leave PVS
+			p.entities[currentEntity].Destroy()
 			delete(p.entities, currentEntity)
 
 			// 'Force Delete' flag, not exactly sure what it's supposed to do

examples/nade-trajectories/nade_trajectories.go

@@ -33,7 +33,7 @@ var (
 	colorDecoy color.Color = color.RGBA{0x96, 0x4b, 0x00, 0xff} // Brown, because it's shit :)
 )
 
-// Run like this: go run bouncynades.go -demo /path/to/demo.dem > bouncynades.jpg
+// Run like this: go run nade_trajectories.go -demo /path/to/demo.dem > nade_trajectories.jpg
 func main() {
 	f, err := os.Open(ex.DemoPathFromArgs())
 	checkError(err)
@@ -44,46 +44,25 @@ func main() {
 	_, err = p.ParseHeader()
 	checkError(err)
 
-	nadePaths := make([]*nadePath, 0)           // Paths of detonated projectiles
-	currentNadePaths := make(map[int]*nadePath) // Currently live projectiles
+	nadePaths := make(map[int64]*nadePath) // Currently live projectiles
 
-	storeNadePath := func(entityID int, pos r3.Vector, wep common.EquipmentElement, team common.Team) {
-		if currentNadePaths[entityID] == nil {
-			currentNadePaths[entityID] = &nadePath{
+	storeNadePath := func(id int64, pos r3.Vector, wep common.EquipmentElement, team common.Team) {
+		if nadePaths[id] == nil {
+			nadePaths[id] = &nadePath{
 				wep:  wep,
 				team: team,
 			}
 		}
 
-		currentNadePaths[entityID].path = append(currentNadePaths[entityID].path, pos)
+		nadePaths[id].path = append(nadePaths[id].path, pos)
 	}
 
-	p.RegisterEventHandler(func(e events.NadeEventIf) {
-		ne := e.Base()
-
-		var team common.Team
-		if ne.Thrower != nil {
-			team = ne.Thrower.Team
-		}
-
-		storeNadePath(ne.NadeEntityID, ne.Position, ne.NadeType, team)
-		nadePaths = append(nadePaths, currentNadePaths[ne.NadeEntityID])
-		delete(currentNadePaths, ne.NadeEntityID)
-	})
-
 	p.RegisterEventHandler(func(e events.NadeProjectileThrownEvent) {
-		// Save previous projectile and delete from current, just a safeguard for missing NadeEvents
-		np := currentNadePaths[e.Projectile.EntityID]
-		if np != nil {
-			nadePaths = append(nadePaths, np)
-			delete(currentNadePaths, e.Projectile.EntityID)
-		}
-
-		storeNadePath(e.Projectile.EntityID, e.Projectile.Position, e.Projectile.Weapon, e.Projectile.Thrower.Team)
+		storeNadePath(e.Projectile.UniqueID(), e.Projectile.Position, e.Projectile.Weapon, e.Projectile.Thrower.Team)
 	})
 
 	p.RegisterEventHandler(func(e events.NadeProjectileBouncedEvent) {
-		storeNadePath(e.Projectile.EntityID, e.Projectile.Position, e.Projectile.Weapon, e.Projectile.Thrower.Team)
+		storeNadePath(e.Projectile.UniqueID(), e.Projectile.Position, e.Projectile.Weapon, e.Projectile.Thrower.Team)
 	})
 
 	var nadePathsFirstHalf []*nadePath
@@ -93,8 +72,11 @@ func main() {
 		// Very cheap first half check (we only want the first teams CT-side nades in the example).
 		// Won't work with demos that have match-restarts etc.
 		if round == 15 {
-			nadePathsFirstHalf = nadePaths
-			nadePaths = make([]*nadePath, 0)
+			// Copy all nade paths from the first 15 rounds
+			for _, np := range nadePaths {
+				nadePathsFirstHalf = append(nadePathsFirstHalf, np)
+			}
+			nadePaths = make(map[int64]*nadePath)
 		}
 	})
 
@@ -120,11 +102,6 @@ func main() {
 	gc.SetLineWidth(1)                      // 1 px lines
 	gc.SetFillColor(color.RGBA{0, 0, 0, 0}) // No fill, alpha 0
 
-	// Add any pending paths
-	for _, np := range currentNadePaths {
-		nadePaths = append(nadePaths, np)
-	}
-
 	for _, np := range nadePathsFirstHalf {
 		if np.team != common.TeamCounterTerrorists {
 			// Only draw CT nades

examples/nade-trajectories/nade_trajectories.jpg

@@ -9,5 +9,12 @@ import (
 func TestBouncyNades(t *testing.T) {
 	os.Args = []string{"cmd", "-demo", "../../cs-demos/default.dem"}
 
+	// Redirect stdout, the resulting image is written to this
+	old := os.Stdout
+	_, w, _ := os.Pipe()
+	os.Stdout = w
+
 	main()
+
+	os.Stdout = old
 }

examples/nade-trajectories/nade_trajectories_test.go

@@ -3,7 +3,6 @@ package demoinfocs
 import (
 	"fmt"
 	"strconv"
-	"strings"
 
 	r3 "github.com/golang/geo/r3"
 
@@ -184,11 +183,6 @@ 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_events.go

@@ -14,6 +14,9 @@ type Entity struct {
 	ID          int
 	ServerClass *ServerClass
 	props       []PropertyEntry
+
+	onCreateFinished []func()
+	onDestroy        []func()
 }
 
 // Props returns all properties (PropertyEntry) for the Entity.
@@ -46,6 +49,7 @@ var updatedPropIndicesPool = sync.Pool{
 
 // ApplyUpdate reads an update to an Enitiy's properties and
 // triggers registered PropertyUpdateHandlers if values changed.
+// Intended for internal use only.
 func (e *Entity) ApplyUpdate(reader *bit.BitReader) {
 	idx := -1
 	newWay := reader.ReadBit()
@@ -96,6 +100,7 @@ func readFieldIndex(reader *bit.BitReader, lastIndex int, newWay bool) int {
 }
 
 // InitializeBaseline applies an update and collects a baseline (default values) from the update.
+// Intended for internal use only.
 func (e *Entity) InitializeBaseline(r *bit.BitReader) map[int]PropValue {
 	baseline := make(map[int]PropValue)
 	for i := range e.props {
@@ -116,7 +121,8 @@ func (e *Entity) InitializeBaseline(r *bit.BitReader) map[int]PropValue {
 	return baseline
 }
 
-// ApplyBaseline baseline applies a previously collected baseline
+// ApplyBaseline baseline applies a previously collected baseline.
+// Intended for internal use only.
 func (e *Entity) ApplyBaseline(baseline map[int]PropValue) {
 	for idx := range baseline {
 		e.props[idx].value = baseline[idx]
@@ -145,10 +151,29 @@ func coordFromCell(cell, cellWidth int, offset float64) float64 {
 	return float64(cell*cellWidth-maxCoordInt) + offset
 }
 
+// OnDestroy registers a function to be called on the entity's destruction.
+func (e *Entity) OnDestroy(delegate func()) {
+	e.onDestroy = append(e.onDestroy, delegate)
+}
+
+// Destroy triggers all via OnDestroy() registered functions.
+// Intended for internal use only.
+func (e *Entity) Destroy() {
+	for _, f := range e.onDestroy {
+		f()
+	}
+}
+
+// OnCreateFinished registers a function to be called once the entity is fully created -
+// i.e. once all property updates have been sent out.
+func (e *Entity) OnCreateFinished(delegate func()) {
+	e.onCreateFinished = append(e.onCreateFinished, delegate)
+}
+
 // NewEntity creates a new Entity with a given id and ServerClass and returns it.
 func NewEntity(id int, serverClass *ServerClass) *Entity {
 	propCount := len(serverClass.FlattenedProps)
-	props := make([]PropertyEntry, propCount, propCount+1) // Cap +1 for CreateFinishedDummyProp
+	props := make([]PropertyEntry, propCount)
 	for i := range serverClass.FlattenedProps {
 		props[i] = PropertyEntry{entry: &serverClass.FlattenedProps[i]}
 	}

sendtables/entity.go

@@ -38,20 +38,9 @@ type ServerClass struct {
 	entityCreatedHandlers []EntityCreatedHandler
 }
 
-// CreateFinishedDummyPropertyName is a dummy property for entities.
-// When it's updated it signals that the entity creation has finished (all property updates sent out).
-// TODO: Figure out a better way to do this.
-const CreateFinishedDummyPropertyName = "CreateFinishedDummyProp"
-
 // FireEntityCreatedEvent triggers all registered EntityCreatedHandlers
 // on the ServerClass with a new EntityCreatedEvent.
 func (sc *ServerClass) FireEntityCreatedEvent(entity *Entity) {
-	entity.props = append(entity.props, PropertyEntry{
-		entry: &FlattenedPropEntry{
-			name: CreateFinishedDummyPropertyName,
-		},
-	})
-
 	for _, h := range sc.entityCreatedHandlers {
 		if h != nil {
 			h(EntityCreatedEvent{Entity: entity, ServerClass: sc})
@@ -61,6 +50,11 @@ func (sc *ServerClass) FireEntityCreatedEvent(entity *Entity) {
 	for _, v := range entity.props {
 		v.firePropertyUpdate()
 	}
+
+	// Fire all create-finished actions
+	for _, f := range entity.onCreateFinished {
+		f()
+	}
 }
 
 // RegisterEntityCreatedHandler registers a EntityCreatedHandler on the ServerClass.