implement fallback to CSVCMsg_ServerInfo for tick rate info (#184)

Author: markus-wa

common/common.go

@@ -36,7 +36,13 @@ type DemoHeader struct {
 
 // FrameRate returns the frame rate of the demo (frames / demo-ticks per second).
 // Not necessarily the tick-rate the server ran on during the game.
+//
+// Returns 0 if PlaybackTime or PlaybackFrames are 0 (corrupt demo headers).
 func (h DemoHeader) FrameRate() float64 {
+	if h.PlaybackTime == 0 {
+		return 0
+	}
+
 	return float64(h.PlaybackFrames) / h.PlaybackTime.Seconds()
 }
 
@@ -47,17 +53,28 @@ func (h DemoHeader) FrameTime() time.Duration {
 	if h.PlaybackFrames == 0 {
 		return 0
 	}
+
 	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))
 }
 

common/common_test.go

@@ -42,10 +42,22 @@ func TestDemoHeader(t *testing.T) {
 	assert.Equal(t, time.Second/128, header.TickTime(), "TickTime should be 1/128")
 }
 
+func TestDemoHeader_FrameRate_PlaybackTime_Zero(t *testing.T) {
+	assert.Zero(t, DemoHeader{}.FrameRate())
+}
+
 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())
@@ -79,6 +91,26 @@ func TestTeamState_FreezeTimeEndEquipmentValue(t *testing.T) {
 	assert.Equal(t, 300, state.FreezeTimeEndEquipmentValue())
 }
 
+func TestTeamState_CashSpentThisRound(t *testing.T) {
+	members := []*Player{
+		{AdditionalPlayerInformation: &AdditionalPlayerInformation{CashSpentThisRound: 100}},
+		{AdditionalPlayerInformation: &AdditionalPlayerInformation{CashSpentThisRound: 200}},
+	}
+	state := NewTeamState(TeamTerrorists, func(Team) []*Player { return members })
+
+	assert.Equal(t, 300, state.CashSpentThisRound())
+}
+
+func TestTeamState_CashSpentTotal(t *testing.T) {
+	members := []*Player{
+		{AdditionalPlayerInformation: &AdditionalPlayerInformation{TotalCashSpent: 100}},
+		{AdditionalPlayerInformation: &AdditionalPlayerInformation{TotalCashSpent: 200}},
+	}
+	state := NewTeamState(TeamTerrorists, func(Team) []*Player { return members })
+
+	assert.Equal(t, 300, state.CashSpentTotal())
+}
+
 type demoInfoProviderMock struct {
 	tickRate        float64
 	ingameTick      int

common/player.go

@@ -103,7 +103,6 @@ func (p *Player) flashDurationTimeFull() time.Duration {
 // It takes into consideration FlashDuration, FlashTick, DemoHeader.TickRate() and GameState.IngameTick().
 func (p *Player) FlashDurationTimeRemaining() time.Duration {
 	// In case the demo header is broken
-	// TODO: read tickRate from CVARs as fallback
 	tickRate := p.demoInfoProvider.TickRate()
 	if tickRate == 0 {
 		return p.flashDurationTimeFull()

convars.go

@@ -110,6 +110,16 @@ func (p *Parser) CurrentTime() time.Duration {
 	return p.Called().Get(0).(time.Duration)
 }
 
+// TickRate is a mock-implementation of IParser.TickRate().
+func (p *Parser) TickRate() float64 {
+	return p.Called().Get(0).(float64)
+}
+
+// TickTime is a mock-implementation of IParser.TickTime().
+func (p *Parser) TickTime() time.Duration {
+	return p.Called().Get(0).(time.Duration)
+}
+
 // Progress is a mock-implementation of IParser.Progress().
 func (p *Parser) Progress() float32 {
 	return p.Called().Get(0).(float32)

fake/parser.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 
 	bit "github.com/markus-wa/demoinfocs-golang/bitread"
+	"github.com/markus-wa/demoinfocs-golang/events"
 	"github.com/markus-wa/demoinfocs-golang/msg"
 )
 
@@ -50,3 +51,20 @@ func (p *Parser) handlePacketEntities(pe *msg.CSVCMsg_PacketEntities) {
 	}
 	r.Pool()
 }
+
+func (p *Parser) handleSetConVar(setConVar *msg.CNETMsg_SetConVar) {
+	updated := make(map[string]string)
+	for _, cvar := range setConVar.Convars.Cvars {
+		updated[cvar.Name] = cvar.Value
+		p.gameState.conVars[cvar.Name] = cvar.Value
+	}
+
+	p.eventDispatcher.Dispatch(events.ConVarsUpdated{
+		UpdatedConVars: updated,
+	})
+}
+
+func (p *Parser) handleServerInfo(srvInfo *msg.CSVCMsg_ServerInfo) {
+	// srvInfo.MapCrc might be interesting as well
+	p.tickInterval = srvInfo.TickInterval
+}

entities.go renamed to net_messages.go

@@ -52,6 +52,7 @@ type Parser struct {
 	userMessageHandler           userMessageHandler
 	eventDispatcher              dp.Dispatcher
 	currentFrame                 int                // Demo-frame, not ingame-tick
+	tickInterval                 float32            // Duration between ticks in seconds
 	header                       *common.DemoHeader // Pointer so we can check for nil
 	gameState                    *GameState
 	demoInfoProvider             demoInfoProvider // Provides demo infos to other packages that the core package depends on
@@ -122,14 +123,37 @@ func (p *Parser) CurrentFrame() int {
 
 // CurrentTime returns the time elapsed since the start of the demo
 func (p *Parser) CurrentTime() time.Duration {
-	return time.Duration(p.currentFrame) * p.header.FrameTime()
+	return time.Duration(float32(p.gameState.ingameTick) * p.tickInterval * float32(time.Second))
+}
+
+// TickRate returns the tick-rate the server ran on during the game.
+func (p *Parser) TickRate() float64 {
+	if p.tickInterval != 0 {
+		return 1.0 / float64(p.tickInterval)
+	}
+
+	return p.header.TickRate()
+}
+
+// TickTime returns the time a single tick takes in seconds.
+func (p *Parser) TickTime() time.Duration {
+	if p.tickInterval != 0 {
+		return time.Duration(float32(time.Second) * p.tickInterval)
+	}
+
+	return p.header.TickTime()
 }
 
 // Progress returns the parsing progress from 0 to 1.
 // Where 0 means nothing has been parsed yet and 1 means the demo has been parsed to the end.
 //
 // Might not be 100% correct since it's just based on the reported tick count of the header.
+// May always return 0 if the demo header is corrupt.
 func (p *Parser) Progress() float32 {
+	if p.header == nil || p.header.PlaybackFrames == 0 {
+		return 0
+	}
+
 	return float32(p.currentFrame) / float32(p.header.PlaybackFrames)
 }
 
@@ -255,6 +279,7 @@ func NewParserWithConfig(demostream io.Reader, config ParserConfig) *Parser {
 	p.msgDispatcher.RegisterHandler(p.handleUserMessage)
 	p.msgDispatcher.RegisterHandler(p.handleSetConVar)
 	p.msgDispatcher.RegisterHandler(p.handleFrameParsed)
+	p.msgDispatcher.RegisterHandler(p.handleServerInfo)
 	p.msgDispatcher.RegisterHandler(p.gameState.handleIngameTickNumber)
 
 	if config.MsgQueueBufferSize >= 0 {
@@ -280,8 +305,7 @@ func (p demoInfoProvider) IngameTick() int {
 }
 
 func (p demoInfoProvider) TickRate() float64 {
-	// TODO: read tickRate from CVARs as fallback
-	return p.parser.header.TickRate()
+	return p.parser.TickRate()
 }
 
 func (p demoInfoProvider) FindPlayerByHandle(handle int) *common.Player {

parser.go

@@ -47,10 +47,15 @@ type IParser interface {
 	CurrentFrame() int
 	// CurrentTime returns the time elapsed since the start of the demo
 	CurrentTime() time.Duration
+	// TickRate returns the tick-rate the server ran on during the game.
+	TickRate() float64
+	// TickTime returns the time a single tick takes in seconds.
+	TickTime() time.Duration
 	// Progress returns the parsing progress from 0 to 1.
 	// Where 0 means nothing has been parsed yet and 1 means the demo has been parsed to the end.
 	//
 	// Might not be 100% correct since it's just based on the reported tick count of the header.
+	// May always return 0 if the demo header is corrupt.
 	Progress() float32
 	/*
 	   RegisterEventHandler registers a handler for game events.

parser_interface.go

@@ -0,0 +1,64 @@
+package demoinfocs
+
+import (
+	"math"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/markus-wa/demoinfocs-golang/common"
+)
+
+func TestParser_CurrentFrame(t *testing.T) {
+	assert.Equal(t, 1, (&Parser{currentFrame: 1}).CurrentFrame())
+}
+
+func TestParser_GameState(t *testing.T) {
+	gs := new(GameState)
+	assert.Equal(t, gs, (&Parser{gameState: gs}).GameState())
+}
+
+func TestParser_CurrentTime(t *testing.T) {
+	p := &Parser{
+		tickInterval: 2,
+		gameState:    &GameState{ingameTick: 3},
+	}
+
+	assert.Equal(t, 6*time.Second, p.CurrentTime())
+}
+
+func TestParser_TickRate(t *testing.T) {
+	assert.Equal(t, float64(5), math.Round((&Parser{tickInterval: 0.2}).TickRate()))
+}
+
+func TestParser_TickRate_FallbackToHeader(t *testing.T) {
+	p := &Parser{
+		header: &common.DemoHeader{
+			PlaybackTime:  time.Second,
+			PlaybackTicks: 5,
+		},
+	}
+
+	assert.Equal(t, float64(5), p.TickRate())
+}
+
+func TestParser_TickTime(t *testing.T) {
+	assert.Equal(t, time.Duration(200)*time.Millisecond, (&Parser{tickInterval: 0.2}).TickTime())
+}
+
+func TestParser_TickTime_FallbackToHeader(t *testing.T) {
+	p := &Parser{
+		header: &common.DemoHeader{
+			PlaybackTime:  time.Second,
+			PlaybackTicks: 5,
+		},
+	}
+
+	assert.Equal(t, time.Duration(200)*time.Millisecond, p.TickTime())
+}
+
+func TestParser_Progress_NoHeader(t *testing.T) {
+	assert.Zero(t, new(Parser).Progress())
+	assert.Zero(t, (&Parser{header: &common.DemoHeader{}}).Progress())
+}

parser_test.go

@@ -262,6 +262,7 @@ var defaultNetMessageCreators = map[int]NetMessageCreator{
 	int(msg.SVC_Messages_svc_CreateStringTable): func() proto.Message { return new(msg.CSVCMsg_CreateStringTable) },
 	int(msg.SVC_Messages_svc_UpdateStringTable): func() proto.Message { return new(msg.CSVCMsg_UpdateStringTable) },
 	int(msg.SVC_Messages_svc_UserMessage):       func() proto.Message { return new(msg.CSVCMsg_UserMessage) },
+	int(msg.SVC_Messages_svc_ServerInfo):        func() proto.Message { return new(msg.CSVCMsg_ServerInfo) },
 	int(msg.NET_Messages_net_SetConVar):         func() proto.Message { return new(msg.CNETMsg_SetConVar) },
 }