Add infernos to GameState + events

Author: markus-wa

common/structs.go

@@ -4,6 +4,7 @@ import (
 	"math/rand"
 
 	r3 "github.com/golang/geo/r3"
+	s2 "github.com/golang/geo/s2"
 
 	st "github.com/markus-wa/demoinfocs-golang/sendtables"
 )
@@ -140,7 +141,7 @@ func (e Equipment) UniqueID() int64 {
 	return e.uniqueID
 }
 
-// NewGrenadeProjectile creates a grenade projectile and sets.
+// NewGrenadeProjectile creates a grenade projectile and sets the Unique-ID.
 //
 // Intended for internal use only.
 func NewGrenadeProjectile() *GrenadeProjectile {
@@ -180,3 +181,51 @@ func NewSkinEquipment(eqName string, skinID string) Equipment {
 func NewPlayer() *Player {
 	return &Player{RawWeapons: make(map[int]*Equipment)}
 }
+
+// Inferno is a list of Fires with helper functions.
+// Also contains already extinguished fires.
+//
+// See also: Inferno.Active() and Fire.IsBurning
+type Inferno struct {
+	EntityID int
+	Fires    []*Fire
+
+	// uniqueID is used to distinguish different infernos (which potentially have the same, reused entityID) from each other.
+	uniqueID int64
+}
+
+// Fire is a component of an Inferno.
+type Fire struct {
+	r3.Vector
+
+	IsBurning bool
+}
+
+// Active returns an Inferno containing only the active fires of the original.
+// The returned Inferno will have the same Unique-ID as the original.
+func (inf Inferno) Active() Inferno {
+	res := Inferno{
+		uniqueID: inf.uniqueID,
+	}
+	res.Fires = make([]*Fire, 0, len(inf.Fires))
+	for i := range inf.Fires {
+		res.Fires = append(res.Fires, inf.Fires[i])
+	}
+	return res
+}
+
+// ConvexHull returns the convex hull of all the fires in the inferno.
+func (inf Inferno) ConvexHull() *s2.Loop {
+	q := s2.NewConvexHullQuery()
+	for i := range inf.Fires {
+		q.AddPoint(s2.Point{Vector: inf.Fires[i].Vector})
+	}
+	return q.ConvexHull()
+}
+
+// NewInferno creates a inferno and sets the Unique-ID.
+//
+// Intended for internal use only.
+func NewInferno() *Inferno {
+	return &Inferno{uniqueID: rand.Int63()}
+}

datatables.go

@@ -266,6 +266,7 @@ func (p *Parser) bindWeapons() {
 		}
 	}
 
+	p.stParser.ServerClasses().FindByName("CInferno").OnEntityCreated(p.bindNewInferno)
 }
 
 // bindGrenadeProjectiles keeps track of the location of live grenades (Parser.gameState.grenadeProjectiles), actively thrown by players.
@@ -277,6 +278,12 @@ func (p *Parser) bindGrenadeProjectiles(entity *st.Entity) {
 	proj.EntityID = entityID
 	p.gameState.grenadeProjectiles[entityID] = proj
 
+	entity.OnCreateFinished(func() {
+		p.eventDispatcher.Dispatch(events.NadeProjectileThrownEvent{
+			Projectile: proj,
+		})
+	})
+
 	entity.OnDestroy(func() {
 		p.eventDispatcher.Dispatch(events.NadeProjectileDestroyedEvent{
 			Projectile: proj,
@@ -322,12 +329,6 @@ func (p *Parser) bindGrenadeProjectiles(entity *st.Entity) {
 			}
 		})
 	}
-
-	entity.OnCreateFinished(func() {
-		p.eventDispatcher.Dispatch(events.NadeProjectileThrownEvent{
-			Projectile: proj,
-		})
-	})
 }
 
 func (p *Parser) bindWeapon(entity *st.Entity, wepType common.EquipmentElement) {
@@ -368,3 +369,41 @@ func (p *Parser) bindWeapon(entity *st.Entity, wepType common.EquipmentElement)
 		wepFix("_pist_deagle", "_pist_revolver", common.EqRevolver)
 	}
 }
+
+func (p *Parser) bindNewInferno(entity *st.Entity) {
+	entityID := entity.ID()
+	inf := common.NewInferno()
+	inf.EntityID = entityID
+	p.gameState.infernos[entityID] = inf
+
+	entity.OnCreateFinished(func() {
+		p.eventDispatcher.Dispatch(events.InfernoStartedEvent{
+			Inferno: inf,
+		})
+	})
+
+	entity.OnDestroy(func() {
+		p.eventDispatcher.Dispatch(events.InfernoExpiredEvent{
+			Inferno: inf,
+		})
+	})
+
+	origin := entity.Position()
+	nFires := 0
+	entity.FindProperty("m_fireCount").OnUpdate(func(val st.PropertyValue) {
+		for i := nFires; i < val.IntVal; i++ {
+			iStr := fmt.Sprintf("%03d", i)
+			offset := r3.Vector{
+				X: float64(entity.FindProperty("m_fireXDelta." + iStr).Value().IntVal),
+				Y: float64(entity.FindProperty("m_fireYDelta." + iStr).Value().IntVal),
+				Z: float64(entity.FindProperty("m_fireZDelta." + iStr).Value().IntVal),
+			}
+
+			fire := &common.Fire{Vector: origin.Add(offset)}
+			entity.BindProperty("m_bFireIsBurning."+iStr, &fire.IsBurning, st.ValTypeBoolInt)
+
+			inf.Fires = append(inf.Fires, fire)
+		}
+		nFires = val.IntVal
+	})
+}

events/events.go

@@ -397,3 +397,17 @@ type GenericGameEvent struct {
 	Name string
 	Data map[string]*msg.CSVCMsg_GameEventKeyT
 }
+
+// InfernoStartedEvent signals that the fire of a incendiary or Molotov has just started.
+// This is different from the FireNadeStartedEvent because it's sent out when the inferno entity is created instead of on the game-event.
+type InfernoStartedEvent struct {
+	Inferno *common.Inferno
+}
+
+// InfernoExpiredEvent signals that all fire from a incendiary or Molotov has extinguished.
+// This is different from the FireNadeExpiredEvent event because it's sent out when the inferno entity is destroyed instead of on the game-event.
+//
+// Mainly useful for getting the final area of an inferno.
+type InfernoExpiredEvent struct {
+	Inferno *common.Inferno
+}

examples/nade-trajectories/nade_trajectories.go

@@ -18,8 +18,7 @@ import (
 	common "github.com/markus-wa/demoinfocs-golang/common"
 	events "github.com/markus-wa/demoinfocs-golang/events"
 	ex "github.com/markus-wa/demoinfocs-golang/examples"
-	"github.com/markus-wa/demoinfocs-golang/metadata"
-	st "github.com/markus-wa/demoinfocs-golang/sendtables"
+	metadata "github.com/markus-wa/demoinfocs-golang/metadata"
 )
 
 type nadePath struct {
@@ -39,16 +38,6 @@ var (
 	curMap           metadata.Map
 )
 
-type inferno []r3.Vector
-
-func (inf inferno) convexHull() *s2.Loop {
-	q := s2.NewConvexHullQuery()
-	for i := range inf {
-		q.AddPoint(s2.Point{Vector: inf[i]})
-	}
-	return q.ConvexHull()
-}
-
 // Run like this: go run nade_trajectories.go -demo /path/to/demo.dem > nade_trajectories.jpg
 func main() {
 	f, err := os.Open(ex.DemoPathFromArgs())
@@ -76,50 +65,29 @@ func main() {
 		nadeTrajectories[id].path = e.Projectile.Trajectory
 	})
 
-	var infernos []*s2.Loop
-
-	p.RegisterEventHandler(func(events.DataTablesParsedEvent) {
-		p.ServerClasses().FindByName("CInferno").OnEntityCreated(func(ent *st.Entity) {
-			origin := ent.Position()
-			var fires inferno
-			var nFires int
-			ent.FindProperty("m_fireCount").OnUpdate(func(val st.PropertyValue) {
-				for i := nFires; i < val.IntVal; i++ {
-					iStr := fmt.Sprintf("%03d", i)
-					offset := r3.Vector{
-						X: float64(ent.FindProperty("m_fireXDelta." + iStr).Value().IntVal),
-						Y: float64(ent.FindProperty("m_fireYDelta." + iStr).Value().IntVal),
-						Z: float64(ent.FindProperty("m_fireZDelta." + iStr).Value().IntVal),
-					}
-					fires = append(fires, origin.Add(offset))
-				}
-				nFires = val.IntVal
-			})
-
-			ent.OnDestroy(func() {
-				infernos = append(infernos, fires.convexHull())
-			})
-		})
+	var infernos []*common.Inferno
+
+	p.RegisterEventHandler(func(e events.InfernoExpiredEvent) {
+		infernos = append(infernos, e.Inferno)
 	})
 
 	var nadeTrajectoriesFirst5Rounds []*nadePath
-	var infernosFirst5Rounds []*s2.Loop
+	var infernosFirst5Rounds []*common.Inferno
 	round := 0
 	p.RegisterEventHandler(func(events.RoundEndedEvent) {
 		round++
 		// We only want the data from the first 5 rounds so the image is not too cluttered
 		// This is a very cheap way to do it. Won't work with demos that have match-restarts etc.
 		if round == 5 {
-			// Copy all nade paths
+			// Copy nade paths
 			for _, np := range nadeTrajectories {
 				nadeTrajectoriesFirst5Rounds = append(nadeTrajectoriesFirst5Rounds, np)
 			}
 			nadeTrajectories = make(map[int64]*nadePath)
 
-			// And infernos
-			for _, hull := range infernos {
-				infernosFirst5Rounds = append(infernosFirst5Rounds, hull)
-			}
+			// Copy infernos
+			infernosFirst5Rounds = make([]*common.Inferno, len(infernos))
+			copy(infernosFirst5Rounds, infernos)
 		}
 	})
 
@@ -154,18 +122,24 @@ func main() {
 	})
 }
 
-func drawInfernos(gc *draw2dimg.GraphicContext, hulls []*s2.Loop) {
+func drawInfernos(gc *draw2dimg.GraphicContext, infernos []*common.Inferno) {
 	// Draw areas first
 	gc.SetFillColor(colorInferno)
 
+	// Calculate hulls
+	hulls := make([]*s2.Loop, len(infernos))
+	for i := range infernos {
+		hulls[i] = infernos[i].ConvexHull()
+	}
+
 	for _, hull := range hulls {
 		buildInfernoPath(gc, hull)
 		gc.Fill()
 	}
 
 	// Then the outline
 	gc.SetStrokeColor(colorInfernoHull)
-	gc.SetLineWidth(2) // 2 px wide
+	gc.SetLineWidth(1) // 1 px wide
 
 	for _, hull := range hulls {
 		buildInfernoPath(gc, hull)

examples/nade-trajectories/nade_trajectories.jpg

@@ -12,7 +12,8 @@ type GameState struct {
 	ctState            TeamState
 	playersByUserID    map[int]*common.Player            // Maps user-IDs to players
 	playersByEntityID  map[int]*common.Player            // Maps entity-IDs to players
-	grenadeProjectiles map[int]*common.GrenadeProjectile // Maps entity-IDs to nade-projectiles. That's grenades that have been thrown, but have not yet detonated.
+	grenadeProjectiles map[int]*common.GrenadeProjectile // Maps entity-IDs to active nade-projectiles. That's grenades that have been thrown, but have not yet detonated.
+	infernos           map[int]*common.Inferno           // Maps entity-IDs to active infernos.
 	entities           map[int]*st.Entity                // Maps entity IDs to entities
 }
 
@@ -61,6 +62,11 @@ func (gs GameState) GrenadeProjectiles() map[int]*common.GrenadeProjectile {
 	return gs.grenadeProjectiles
 }
 
+// Infernos returns a map from entity-IDs to all currently burning infernos (fires from incendiaries and Molotovs).
+func (gs GameState) Infernos() map[int]*common.Inferno {
+	return gs.infernos
+}
+
 // Entities returns all currently existing entities.
 func (gs GameState) Entities() map[int]*st.Entity {
 	return gs.entities
@@ -71,6 +77,7 @@ func newGameState() GameState {
 		playersByEntityID:  make(map[int]*common.Player),
 		playersByUserID:    make(map[int]*common.Player),
 		grenadeProjectiles: make(map[int]*common.GrenadeProjectile),
+		infernos:           make(map[int]*common.Inferno),
 		entities:           make(map[int]*st.Entity),
 	}
 }