test: cover QAngle noscale decode, entity_killed, fatal-hit capping, sorted participants

Author: markus-wa

pkg/demoinfocs/game_events_test.go

@@ -4,6 +4,7 @@ import (
 	"crypto/rand"
 	"testing"
 
+	"github.com/golang/geo/r3"
 	"github.com/stretchr/testify/assert"
 	"google.golang.org/protobuf/proto"
 
@@ -348,6 +349,43 @@ func TestPlayerHurt_KnownWeaponDispatchesImmediately(t *testing.T) {
 	assert.Equal(t, common.EqAK47, got[0].Weapon.Type)
 }
 
+func TestPlayerHurt_FatalHitCappedAtPriorHitHealthSameTick(t *testing.T) {
+	p := NewParser(rand.Reader).(*parser)
+	p.currentFrame = 100
+	p.gameState.ingameTick = 5000
+
+	victim := newPlayerWithEntityID(3)
+	victim.UserID = 42
+
+	p.gameState.playersByUserID[victim.UserID] = victim
+
+	var got []events.PlayerHurt
+	p.RegisterEventHandler(func(e events.PlayerHurt) {
+		got = append(got, e)
+	})
+
+	// First hit: non-fatal, victim reported at 35 HP after the hit.
+	data := playerHurtEventData(int32(victim.UserID), 1, "ak47")
+	data["health"].ValByte = proto.Int32(35)
+	data["armor"].ValByte = proto.Int32(50)
+	data["dmg_health"].ValShort = proto.Int32(15)
+
+	p.gameEventHandler.playerHurt(data)
+
+	// Second hit, same tick: fatal (health 0). Must be capped at the victim's remaining
+	// HP right before it (35), not the start-of-tick value (100) which would over-report.
+	data2 := playerHurtEventData(int32(victim.UserID), 1, "ak47")
+	data2["health"].ValByte = proto.Int32(0)
+	data2["armor"].ValByte = proto.Int32(50)
+	data2["dmg_health"].ValShort = proto.Int32(35)
+
+	p.gameEventHandler.playerHurt(data2)
+
+	assert.Len(t, got, 2)
+	assert.Equal(t, 15, got[0].HealthDamageTaken)
+	assert.Equal(t, 35, got[1].HealthDamageTaken)
+}
+
 func playerHurtEventData(userID int32, attacker int32, weapon string) map[string]*msg.CMsgSource1LegacyGameEventKeyT {
 	return map[string]*msg.CMsgSource1LegacyGameEventKeyT{
 		"userid": {
@@ -383,6 +421,89 @@ func TestGetCommunityId(t *testing.T) {
 	assert.Equal(t, uint64(76561198012952267), xuid)
 }
 
+func TestEntityKilled_DispatchesOtherDeathForNonPlayerEntity(t *testing.T) {
+	p := NewParser(rand.Reader).(*parser)
+
+	killed := new(stfake.Entity)
+	killed.On("ID").Return(5)
+	killed.On("ServerClass").Return(serverClassStub{name: "CDynamicProp"})
+	killed.On("Position").Return(r3.Vector{X: 1, Y: 2, Z: 3})
+
+	p.gameState.entities[5] = killed
+
+	inflictor := new(stfake.Entity)
+	inflictor.On("ServerClass").Return(serverClassStub{name: "CInferno"})
+
+	p.gameState.entities[12] = inflictor
+
+	var got []events.OtherDeath
+	p.RegisterEventHandler(func(e events.OtherDeath) {
+		got = append(got, e)
+	})
+
+	p.gameEventHandler.entityKilled(map[string]*msg.CMsgSource1LegacyGameEventKeyT{
+		"entindex_killed":    {ValLong: proto.Int32(5)},
+		"entindex_inflictor": {ValLong: proto.Int32(12)},
+		"entindex_attacker":  {ValLong: proto.Int32(0)},
+	})
+
+	assert.Len(t, got, 1)
+	assert.Equal(t, "CDynamicProp", got[0].OtherType)
+	assert.Equal(t, int32(5), got[0].OtherID)
+	assert.Equal(t, r3.Vector{X: 1, Y: 2, Z: 3}, got[0].OtherPosition)
+	assert.Equal(t, "CInferno", got[0].InflictorType)
+}
+
+func TestEntityKilled_SkipsPlayerPawns(t *testing.T) {
+	p := NewParser(rand.Reader).(*parser)
+
+	for _, className := range []string{"CCSPlayerPawn", "CCSPlayerPawnBase"} {
+		killed := new(stfake.Entity)
+		killed.On("ServerClass").Return(serverClassStub{name: className})
+
+		p.gameState.entities[5] = killed
+
+		var got []events.OtherDeath
+		p.RegisterEventHandler(func(e events.OtherDeath) {
+			got = append(got, e)
+		})
+
+		p.gameEventHandler.entityKilled(map[string]*msg.CMsgSource1LegacyGameEventKeyT{
+			"entindex_killed":    {ValLong: proto.Int32(5)},
+			"entindex_inflictor": {ValLong: proto.Int32(0)},
+			"entindex_attacker":  {ValLong: proto.Int32(0)},
+		})
+
+		assert.Empty(t, got, "player-pawn deaths should be surfaced via player_death, not OtherDeath")
+	}
+}
+
+func TestEntityKilled_UnknownEntityIsSkipped(t *testing.T) {
+	p := NewParser(rand.Reader).(*parser)
+
+	var got []events.OtherDeath
+	p.RegisterEventHandler(func(e events.OtherDeath) {
+		got = append(got, e)
+	})
+
+	p.gameEventHandler.entityKilled(map[string]*msg.CMsgSource1LegacyGameEventKeyT{
+		"entindex_killed":    {ValLong: proto.Int32(999)},
+		"entindex_inflictor": {ValLong: proto.Int32(0)},
+		"entindex_attacker":  {ValLong: proto.Int32(0)},
+	})
+
+	assert.Empty(t, got)
+}
+
+type serverClassStub struct {
+	st.ServerClass
+	name string
+}
+
+func (s serverClassStub) Name() string {
+	return s.name
+}
+
 func TestGetCommunityId_BOT(t *testing.T) {
 	xuid, err := guidToSteamID64("BOT")
 	assert.Zero(t, xuid)

pkg/demoinfocs/game_state_test.go

@@ -84,6 +84,55 @@ func TestParticipants_All(t *testing.T) {
 	assert.ElementsMatch(t, []*common.Player{pl}, allPlayers)
 }
 
+func TestParticipants_SortedDeterministically(t *testing.T) {
+	steamA := uint64(76561198198570973)
+	steamB := uint64(76561198199343350)
+
+	bot := newPlayer()
+	bot.SteamID64 = 0
+	bot.UserID = 7
+	bot.IsConnected = true
+	bot.Team = common.TeamTerrorists
+
+	playerWithHighSteamID := newPlayer()
+	playerWithHighSteamID.SteamID64 = steamB
+	playerWithHighSteamID.UserID = 1
+	playerWithHighSteamID.IsConnected = true
+	playerWithHighSteamID.Team = common.TeamTerrorists
+
+	playerA := newPlayer()
+	playerA.SteamID64 = steamA
+	playerA.UserID = 5
+	playerA.IsConnected = true
+	playerA.Team = common.TeamTerrorists
+
+	// Two bots (SteamID64 == 0) must be ordered by UserID.
+	bot2 := newPlayer()
+	bot2.SteamID64 = 0
+	bot2.UserID = 3
+	bot2.IsConnected = true
+	bot2.Team = common.TeamTerrorists
+
+	ptcps := participants{
+		playersByUserID: map[int]*common.Player{
+			9:  bot,
+			3:  playerWithHighSteamID,
+			6:  playerA,
+			11: bot2,
+		},
+	}
+
+	// Python-style: sort criteria are SteamID64 ascending, then UserID ascending for ties.
+	// Two bots share SteamID64=0 so they're ordered by UserID (3 before 7). SteamID64 76561198198570973
+	// < 76561198199343350, so playerA comes before playerWithHighSteamID.
+	expectedAll := []*common.Player{bot2, bot, playerA, playerWithHighSteamID}
+
+	assert.Equal(t, expectedAll, ptcps.All())
+	assert.Equal(t, expectedAll, ptcps.Connected())
+	assert.Equal(t, expectedAll, ptcps.Playing())
+	assert.Equal(t, expectedAll, ptcps.TeamMembers(common.TeamTerrorists))
+}
+
 func TestParticipants_Playing(t *testing.T) {
 	terrorist := newPlayer()
 	terrorist.Team = common.TeamTerrorists

pkg/demoinfocs/sendtables/sendtablescs2/field_decoder_test.go

@@ -0,0 +1,50 @@
+package sendtablescs2
+
+import (
+	"math"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+// TestQAngleFactory_Noscale32Bit verifies that a QAngle with 32-bit components is decoded as
+// full-precision noscale float32s (raw IEEE bits) rather than as scaled bit-angles mapped into
+// [0,360). See the m_aimPunchAngle / m_pAimPunchServices.m_predictableBaseAngle cases.
+func TestQAngleFactory_Noscale32Bit(t *testing.T) {
+	t.Parallel()
+
+	bc := int32(32)
+	f := field{bitCount: &bc}
+
+	dec := qangleFactory(&f)
+
+	raw := []byte{}
+	for _, v := range []float32{1.5, -4.25, 350.0} {
+		bits := math.Float32bits(v)
+		for i := 0; i < 4; i++ {
+			raw = append(raw, byte(bits>>(8*i))) // little-endian
+		}
+	}
+
+	val := dec(newReader(raw)).([3]float32)
+
+	assert.Equal(t, [3]float32{1.5, -4.25, 350.0}, val)
+}
+
+// TestQAngleFactory_ScaledBitAngle still reads scaled bit-angles for sub-32-bit fields, so the
+// noscale guard doesn't regress the common smaller encodings.
+func TestQAngleFactory_ScaledBitAngle(t *testing.T) {
+	t.Parallel()
+
+	bc := int32(20)
+	f := field{bitCount: &bc}
+
+	dec := qangleFactory(&f)
+
+	// A raw 20-bit value of 0x80000 (largest magnitude) maps to ~359.65 degrees.
+	val := dec(newReader([]byte{0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x08, 0x00})).([3]float32)
+
+	assert.Less(t, val[0], float32(360.0))
+	assert.Less(t, val[1], float32(360.0))
+	assert.Less(t, val[2], float32(360.0))
+}