common: replace properties with getters (part 1)

Author: markus-wa

examples/nade-trajectories/nade_trajectories.go

@@ -138,7 +138,7 @@ func drawInfernos(gc *draw2dimg.GraphicContext, infernos []*common.Inferno) {
 	// Calculate hulls
 	hulls := make([][]r2.Point, len(infernos))
 	for i := range infernos {
-		hulls[i] = infernos[i].ConvexHull2D()
+		hulls[i] = infernos[i].Fires().ConvexHull2D()
 	}
 
 	for _, hull := range hulls {

pkg/demoinfocs/common/common.go

@@ -6,6 +6,8 @@ import (
 	"time"
 
 	"github.com/golang/geo/r3"
+
+	st "github.com/markus-wa/demoinfocs-golang/v2/pkg/demoinfocs/sendtables"
 )
 
 // Team is the type for the various TeamXYZ constants.
@@ -57,41 +59,24 @@ func (h DemoHeader) FrameTime() time.Duration {
 	return time.Duration(h.PlaybackTime.Nanoseconds() / int64(h.PlaybackFrames))
 }
 
-// TickRate returns the tick-rate the server ran on during the game.
-// Deprecated: this function might return 0 in some cases (corrupt demo headers), use Parser.TickRate() instead.
-// VolvoPlx128TixKTnxBye
-func (h DemoHeader) TickRate() float64 {
-	if h.PlaybackTime == 0 {
-		return 0
-	}
-
-	return float64(h.PlaybackTicks) / h.PlaybackTime.Seconds()
-}
-
-// TickTime returns the time a single tick takes in seconds.
-// Deprecated: this function might return 0 in some cases (corrupt demo headers), use Parser.TickTime() instead.
-func (h DemoHeader) TickTime() time.Duration {
-	if h.PlaybackTicks == 0 {
-		return 0
-	}
-
-	return time.Duration(h.PlaybackTime.Nanoseconds() / int64(h.PlaybackTicks))
-}
-
 // 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
+	Entity         st.IEntity
 	WeaponInstance *Equipment
-	Thrower        *Player // Always seems to be the same as Owner, even if the grenade was picked up
-	Owner          *Player // Always seems to be the same as Thrower, even if the grenade was picked up
-	Position       r3.Vector
+	Thrower        *Player     // Always seems to be the same as Owner, even if the grenade was picked up
+	Owner          *Player     // Always seems to be the same as Thrower, even if the grenade was picked up
 	Trajectory     []r3.Vector // List of all known locations of the grenade up to the current point
 
 	// uniqueID is used to distinguish different grenades (which potentially have the same, reused entityID) from each other.
 	uniqueID int64
 }
 
+// Position returns the current position of the grenade projectile in world coordinates.
+func (g GrenadeProjectile) Position() r3.Vector {
+	return g.Entity.Position()
+}
+
 // UniqueID returns the unique id of the grenade.
 // The unique id is a random int generated internally by this library and can be used to differentiate
 // grenades from each other. This is needed because demo-files reuse entity ids.

pkg/demoinfocs/common/common_test.go

@@ -37,9 +37,6 @@ func TestDemoHeader(t *testing.T) {
 
 	assert.Equal(t, float64(64), header.FrameRate(), "FrameRate should be 64")
 	assert.Equal(t, time.Second/64, header.FrameTime(), "FrameTime should be 1/64 sec")
-
-	assert.Equal(t, float64(128.0), header.TickRate(), "TickRate should be 128")
-	assert.Equal(t, time.Second/128, header.TickTime(), "TickTime should be 1/128")
 }
 
 func TestDemoHeader_FrameRate_PlaybackTime_Zero(t *testing.T) {
@@ -50,14 +47,6 @@ func TestDemoHeader_FrameTime_PlaybackFrames_Zero(t *testing.T) {
 	assert.Zero(t, DemoHeader{}.FrameTime())
 }
 
-func TestDemoHeader_TickRate_PlaybackTicks_Zero(t *testing.T) {
-	assert.Zero(t, DemoHeader{}.TickTime())
-}
-
-func TestDemoHeader_TickTime_PlaybackTime_Zero(t *testing.T) {
-	assert.Zero(t, DemoHeader{}.TickRate())
-}
-
 func TestTeamState_Team(t *testing.T) {
 	assert.Equal(t, TeamTerrorists, NewTeamState(TeamTerrorists, nil).Team())
 	assert.Equal(t, TeamCounterTerrorists, NewTeamState(TeamCounterTerrorists, nil).Team())
@@ -144,6 +133,8 @@ func entityWithProperty(propName string, value st.PropertyValue) st.IEntity {
 	prop.On("Value").Return(value)
 
 	entity.On("FindProperty", propName).Return(prop)
+	entity.On("PropertyValue", propName).Return(prop, true)
+	entity.On("PropertyValueMust", propName).Return(value)
 
 	return entity
 }

pkg/demoinfocs/common/equipment.go

@@ -285,13 +285,10 @@ const (
 // Equipment is a weapon / piece of equipment belonging to a player.
 // This also includes the skin and some additional data.
 type Equipment struct {
-	EntityID       int           // ID of the game entity
-	Entity         st.IEntity    // The entity instance
 	Type           EquipmentType // The type of weapon which the equipment instantiates.
+	Entity         st.IEntity    // The game entity instance
 	Owner          *Player       // The player carrying the equipment, not necessarily the buyer.
-	AmmoType       int           // TODO: Remove this? doesn't seem applicable to CS:GO
 	OriginalString string        // E.g. 'models/weapons/w_rif_m4a1_s.mdl'. Used internally to differentiate alternative weapons (M4A4 / M4A1-S etc.).
-	ZoomLevel      ZoomLevel     // How far the player has zoomed in on the weapon.
 
 	uniqueID int64
 }
@@ -330,14 +327,26 @@ func (e Equipment) AmmoInMagazine() int {
 	return val.IntVal
 }
 
+// AmmoType returns the weapon's ammo type, mostly (only?) relevant for grenades.
+func (e Equipment) AmmoType() int {
+	return e.Entity.PropertyValueMust("LocalWeaponData.m_iPrimaryAmmoType").IntVal
+}
+
+// ZoomLevel returns how far the player has zoomed in on the weapon.
+// Only weapons with scopes have a valid zoom level.
+func (e Equipment) ZoomLevel() ZoomLevel {
+	val, _ := e.Entity.PropertyValue("LocalWeaponData.m_iPrimaryAmmoType")
+	return ZoomLevel(val.IntVal)
+}
+
 // AmmoReserve returns the ammo left available for reloading.
 // Returns CWeaponCSBase.m_iPrimaryReserveAmmoCount for most weapons and 'Owner.AmmoLeft[AmmoType] - 1' for grenades.
-// Use AmmoInMagazine2() + AmmoReserve2() to quickly get the amount of grenades a player owns.
+// Use AmmoInMagazine() + AmmoReserve() to quickly get the amount of grenades a player owns.
 func (e Equipment) AmmoReserve() int {
 	if e.Class() == EqClassGrenade {
 		if e.Owner != nil {
 			// minus one for 'InMagazine'
-			return e.Owner.AmmoLeft[e.AmmoType] - 1
+			return e.Owner.AmmoLeft[e.AmmoType()] - 1
 		}
 
 		return 0

pkg/demoinfocs/common/equipment_test.go

@@ -4,6 +4,8 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+
+	st "github.com/markus-wa/demoinfocs-golang/v2/pkg/demoinfocs/sendtables"
 )
 
 func TestEquipmentElement_Class(t *testing.T) {
@@ -47,10 +49,12 @@ func TestEquipment_AmmoInMagazine_Grenade(t *testing.T) {
 func TestEquipment_AmmoReserve_Grenade(t *testing.T) {
 	owner := new(Player)
 	owner.AmmoLeft[1] = 2
+
+	entity := entityWithProperty("LocalWeaponData.m_iPrimaryAmmoType", st.PropertyValue{IntVal: 1})
 	wep := &Equipment{
-		Type:     EqFlash,
-		Owner:    owner,
-		AmmoType: 1,
+		Type:   EqFlash,
+		Owner:  owner,
+		Entity: entity,
 	}
 
 	assert.Equal(t, 1, wep.AmmoReserve())

pkg/demoinfocs/common/inferno.go

@@ -1,6 +1,7 @@
 package common
 
 import (
+	"fmt"
 	"math/rand"
 	"sort"
 
@@ -16,9 +17,7 @@ import (
 //
 // See also: Inferno.Active() and Fire.IsBurning
 type Inferno struct {
-	Entity   st.IEntity
-	EntityID int // Same as Entity.ID(), use Entity.ID() instead
-	Fires    []*Fire
+	Entity st.IEntity
 
 	// uniqueID is used to distinguish different infernos (which potentially have the same, reused entityID) from each other.
 	uniqueID         int64
@@ -32,36 +31,65 @@ type Fire struct {
 	IsBurning bool
 }
 
+// Fires is a collection of fires that provides utility functions for things like calculation of 2D & 3D convex hulls.
+type Fires struct {
+	s []Fire
+}
+
 // UniqueID returns the unique id of the inferno.
 // The unique id is a random int generated internally by this library and can be used to differentiate
 // infernos from each other. This is needed because demo-files reuse entity ids.
 func (inf Inferno) UniqueID() int64 {
 	return inf.uniqueID
 }
 
-// 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,
+// Fires returns all fires (past + present).
+// Some are currently active and some have extinguished (see Fire.IsBurning).
+func (inf Inferno) Fires() Fires {
+	entity := inf.Entity
+	origin := entity.Position()
+
+	var fires []Fire
+	nFires := entity.PropertyValueMust("m_fireCount").IntVal
+
+	for i := 0; i < nFires; i++ {
+		iStr := fmt.Sprintf("%03d", i)
+		offset := r3.Vector{
+			X: float64(entity.PropertyValueMust("m_fireXDelta." + iStr).IntVal),
+			Y: float64(entity.PropertyValueMust("m_fireYDelta." + iStr).IntVal),
+			Z: float64(entity.PropertyValueMust("m_fireZDelta." + iStr).IntVal),
+		}
+
+		fire := Fire{
+			Vector:    origin.Add(offset),
+			IsBurning: entity.PropertyValueMust("m_bFireIsBurning."+iStr).IntVal == 1,
+		}
+
+		fires = append(fires, fire)
 	}
 
-	res.Fires = make([]*Fire, 0, len(inf.Fires))
+	return Fires{s: fires}
+}
+
+// Active returns all currently active fires (only Fire.IsBurning == true).
+func (f Fires) Active() Fires {
+	allFires := f.s
+	active := make([]Fire, 0, len(allFires))
 
-	for _, f := range inf.Fires {
+	for _, f := range allFires {
 		if f.IsBurning {
-			res.Fires = append(res.Fires, f)
+			active = append(active, f)
 		}
 	}
 
-	return res
+	return Fires{s: active}
 }
 
 // ConvexHull2D returns clockwise sorted corner points making up the 2D convex hull of all the fires in the inferno.
 // Useful for drawing on 2D maps.
-func (inf Inferno) ConvexHull2D() []r2.Point {
-	pointCloud := make([]r3.Vector, len(inf.Fires))
-	for i, f := range inf.Fires {
+func (f Fires) ConvexHull2D() []r2.Point {
+	pointCloud := make([]r3.Vector, len(f.s))
+	for i, f := range f.s {
 		pointCloud[i] = f.Vector
 		pointCloud[i].Z = 0
 	}
@@ -135,25 +163,16 @@ func sortPointsClockwise(points []r2.Point) {
 }
 
 // ConvexHull3D returns the 3D convex hull of all the fires in the inferno.
-func (inf Inferno) ConvexHull3D() quickhull.ConvexHull {
-	pointCloud := make([]r3.Vector, len(inf.Fires))
+func (f Fires) ConvexHull3D() quickhull.ConvexHull {
+	pointCloud := make([]r3.Vector, len(f.s))
 
-	for i, f := range inf.Fires {
+	for i, f := range f.s {
 		pointCloud[i] = f.Vector
 	}
 
 	return convexHull(pointCloud)
 }
 
-// Owner returns the player who threw the fire grenade.
-// Could be nil if the player disconnected after throwing it.
-//
-// Deprecated: Owner() exists for historical compatibility
-// and should not be used. Use Thrower() instead.
-func (inf Inferno) Owner() *Player {
-	return inf.Thrower()
-}
-
 // Thrower returns the player who threw the fire grenade.
 // Could be nil if the player disconnected after throwing it.
 func (inf Inferno) Thrower() *Player {
@@ -170,7 +189,6 @@ func convexHull(pointCloud []r3.Vector) quickhull.ConvexHull {
 func NewInferno(demoInfoProvider demoInfoProvider, entity st.IEntity) *Inferno {
 	return &Inferno{
 		Entity:           entity,
-		EntityID:         entity.ID(),
 		uniqueID:         rand.Int63(),
 		demoInfoProvider: demoInfoProvider,
 	}

pkg/demoinfocs/common/inferno_test.go

@@ -15,19 +15,21 @@ func TestInferno_UniqueID(t *testing.T) {
 	assert.NotEqual(t, NewInferno(nil, entity).UniqueID(), NewInferno(nil, entity).UniqueID(), "UniqueIDs of different infernos should be different")
 }
 
+// FIXME: Inferno.Fires test
+
 func TestInferno_Active(t *testing.T) {
-	inf := Inferno{
-		Fires: []*Fire{
+	inf := Fires{
+		s: []Fire{
 			{
 				IsBurning: false,
 				Vector:    r3.Vector{X: 1, Y: 2, Z: 3},
 			},
 		},
 	}
 
-	assert.Empty(t, inf.Active().Fires, "Inferno should have no active fires")
+	assert.Empty(t, inf.Active().s, "Inferno should have no active fires")
 
-	activeFires := []*Fire{
+	activeFires := []Fire{
 		{
 			IsBurning: true,
 			Vector:    r3.Vector{X: 4, Y: 5, Z: 6},
@@ -37,9 +39,9 @@ func TestInferno_Active(t *testing.T) {
 			Vector:    r3.Vector{X: 7, Y: 8, Z: 9},
 		},
 	}
-	inf.Fires = append(inf.Fires, activeFires...)
+	inf.s = append(inf.s, activeFires...)
 
-	assert.Equal(t, activeFires, inf.Active().Fires, "Active inferno should contain active fires")
+	assert.Equal(t, activeFires, inf.Active().s, "Active inferno should contain active fires")
 }
 
 func TestInferno_ConvexHull2D(t *testing.T) {
@@ -52,8 +54,8 @@ func TestInferno_ConvexHull2D(t *testing.T) {
 	//   /           \
 	// A - - - - - - - B
 	//
-	inf := Inferno{
-		Fires: []*Fire{
+	inf := Fires{
+		s: []Fire{
 			{
 				Vector: r3.Vector{X: 1, Y: 2, Z: 3},
 			},
@@ -83,8 +85,8 @@ func TestInferno_ConvexHull2D(t *testing.T) {
 
 // Just check that all fires are passed to quickhull.ConvexHull()
 func TestInferno_ConvexHull3D(t *testing.T) {
-	inf := Inferno{
-		Fires: []*Fire{
+	inf := Fires{
+		s: []Fire{
 			{
 				Vector: r3.Vector{X: 1, Y: 2, Z: 3},
 			},
@@ -110,17 +112,6 @@ func TestInferno_ConvexHull3D(t *testing.T) {
 	assert.ElementsMatch(t, expectedHull, inf.ConvexHull3D().Vertices, "ConvexHull3D should contain all fire locations")
 }
 
-func TestInferno_Owner(t *testing.T) {
-	entity := entityWithProperty("m_hOwnerEntity", st.PropertyValue{IntVal: 1})
-
-	player := new(Player)
-	provider := demoInfoProviderMock{
-		playersByHandle: map[int]*Player{1: player},
-	}
-
-	assert.Equal(t, player, NewInferno(provider, entity).Owner())
-}
-
 func TestInferno_Thrower(t *testing.T) {
 	entity := entityWithProperty("m_hOwnerEntity", st.PropertyValue{IntVal: 1})