Example: Track fire spreading

Author: markus-wa

Gopkg.lock

@@ -30,8 +30,9 @@
   version = "1.0.0"
 
 [[constraint]]
-  branch = "master"
+  branch = "convex-hull"
   name = "github.com/golang/geo"
+  source = "github.com/markus-wa/geo"
 
 [[constraint]]
   name = "github.com/markus-wa/gobitread"

Gopkg.toml

@@ -6,6 +6,6 @@ This example shows how to create a overview of grenade trajectories of a match.
 
 `go run nade_trajectories.go -demo /path/to/demo > out.jpg`
 
-This will create a JPGE with trajectories of the first half's CT-team. The reason it doesn't do all nades is because the image would look quite cluttered otherwise.
+This will create a JPGE with grenade trajectories of the first five rounds. The reason it doesn't do more trajectories is because the image would look quite cluttered otherwise.
 
 ![Resulting map overview with trajectories](https://raw.githubusercontent.com/markus-wa/demoinfocs-golang/master/examples/nade-trajectories/nade_trajectories.jpg)

examples/nade-trajectories/README.md

@@ -11,12 +11,14 @@ import (
 	"os"
 
 	r3 "github.com/golang/geo/r3"
+	s2 "github.com/golang/geo/s2"
 	draw2dimg "github.com/llgcode/draw2d/draw2dimg"
 
 	dem "github.com/markus-wa/demoinfocs-golang"
 	common "github.com/markus-wa/demoinfocs-golang/common"
 	events "github.com/markus-wa/demoinfocs-golang/events"
 	ex "github.com/markus-wa/demoinfocs-golang/examples"
+	st "github.com/markus-wa/demoinfocs-golang/sendtables"
 )
 
 type nadePath struct {
@@ -26,13 +28,25 @@ type nadePath struct {
 }
 
 var (
-	colorFire  color.Color = color.RGBA{0xff, 0x00, 0x00, 0xff} // Red
-	colorHE    color.Color = color.RGBA{0xff, 0xff, 0x00, 0xff} // Yellow
-	colorFlash color.Color = color.RGBA{0x00, 0x00, 0xff, 0xff} // Blue, because of the color on the nade
-	colorSmoke color.Color = color.RGBA{0xbe, 0xbe, 0xbe, 0xff} // Light gray
-	colorDecoy color.Color = color.RGBA{0x96, 0x4b, 0x00, 0xff} // Brown, because it's shit :)
+	colorFireNade    color.Color = color.RGBA{0xff, 0x00, 0x00, 0xff} // Red
+	colorInferno     color.Color = color.RGBA{0xff, 0xa5, 0x00, 0xff} // Orange
+	colorInfernoHull color.Color = color.RGBA{0xff, 0xff, 0x00, 0xff} // Yellow
+	colorHE          color.Color = color.RGBA{0x00, 0xff, 0x00, 0xff} // Green
+	colorFlash       color.Color = color.RGBA{0x00, 0x00, 0xff, 0xff} // Blue, because of the color on the nade
+	colorSmoke       color.Color = color.RGBA{0xbe, 0xbe, 0xbe, 0xff} // Light gray
+	colorDecoy       color.Color = color.RGBA{0x96, 0x4b, 0x00, 0xff} // Brown, because it's shit :)
 )
 
+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())
@@ -58,19 +72,50 @@ func main() {
 		nadeTrajectories[id].path = e.Projectile.Trajectory
 	})
 
-	var nadeTrajectoriesFirstHalf []*nadePath
+	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 nadeTrajectoriesFirst5Rounds []*nadePath
+	var infernosFirst5Rounds []*s2.Loop
 	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 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
+		// 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
 			for _, np := range nadeTrajectories {
-				nadeTrajectoriesFirstHalf = append(nadeTrajectoriesFirstHalf, np)
+				nadeTrajectoriesFirst5Rounds = append(nadeTrajectoriesFirst5Rounds, np)
 			}
 			nadeTrajectories = make(map[int64]*nadePath)
+
+			// And infernos
+			for _, hull := range infernos {
+				infernosFirst5Rounds = append(infernosFirst5Rounds, hull)
+			}
 		}
 	})
 
@@ -93,21 +138,57 @@ func main() {
 	// Initialize the graphic context
 	gc := draw2dimg.NewGraphicContext(dest)
 
+	// Draw infernos first so they're in the background
+	drawInfernos(gc, infernosFirst5Rounds)
+
+	// Then trajectories on top of everything
+	drawTrajectories(gc, nadeTrajectoriesFirst5Rounds)
+
+	// Write to standard output
+	jpeg.Encode(os.Stdout, dest, &jpeg.Options{
+		Quality: 90,
+	})
+}
+
+func drawInfernos(gc *draw2dimg.GraphicContext, hulls []*s2.Loop) {
+	// Draw areas first
+	gc.SetFillColor(colorInferno)
+
+	for _, hull := range hulls {
+		buildInfernoPath(gc, hull)
+		gc.Fill()
+	}
+
+	// Then the outline
+	gc.SetStrokeColor(colorInfernoHull)
+	gc.SetLineWidth(2) // 2 px wide
+
+	for _, hull := range hulls {
+		buildInfernoPath(gc, hull)
+		gc.FillStroke()
+	}
+}
+
+func buildInfernoPath(gc *draw2dimg.GraphicContext, hull *s2.Loop) {
+	vertices := hull.Vertices()
+	gc.MoveTo(translateX(vertices[0].X), translateY(vertices[0].Y))
+	for _, fire := range vertices[1:] {
+		gc.LineTo(translateX(fire.X), translateY(fire.Y))
+	}
+	gc.LineTo(translateX(vertices[0].X), translateY(vertices[0].Y))
+}
+
+func drawTrajectories(gc *draw2dimg.GraphicContext, trajectories []*nadePath) {
 	gc.SetLineWidth(1)                      // 1 px lines
 	gc.SetFillColor(color.RGBA{0, 0, 0, 0}) // No fill, alpha 0
 
-	for _, np := range nadeTrajectoriesFirstHalf {
-		if np.team != common.TeamCounterTerrorists {
-			// Only draw CT nades
-			continue
-		}
-
+	for _, np := range trajectories {
 		// Set colors
 		switch np.wep {
 		case common.EqMolotov:
 			fallthrough
 		case common.EqIncendiary:
-			gc.SetStrokeColor(colorFire)
+			gc.SetStrokeColor(colorFireNade)
 
 		case common.EqHE:
 			gc.SetStrokeColor(colorHE)
@@ -136,31 +217,28 @@ func main() {
 
 		gc.FillStroke()
 	}
-
-	// Write to standard output
-	jpeg.Encode(os.Stdout, dest, &jpeg.Options{
-		Quality: 90,
-	})
 }
 
 // Rough translations for x & y coordinates from de_cache to 1024x1024 px.
 // This could be done nicer by only having to provide the mapping between two source & target coordinates and the max size.
 // Then we could calculate the correct stretch & offset automatically.
 
-const (
-	stretchX = 0.18
-	offsetX  = 414
-
-	stretchY = -0.18
-	offsetY  = 630
-)
-
 func translateX(x float64) float64 {
-	return x*stretchX + offsetX
+	const (
+		stretch = 0.18
+		offset  = 414
+	)
+
+	return x*stretch + offset
 }
 
 func translateY(y float64) float64 {
-	return y*stretchY + offsetY
+	const (
+		stretch = -0.18
+		offset  = 630
+	)
+
+	return y*stretch + offset
 }
 
 func checkError(err error) {