add GameState.Rules().{Round,Freeze,Bomb}Time() (#265)

* add GameState.Rules().{Round,Freeze,Bomb}Time()

* golangci: gci local lint mode

Author: markus-wa

.golangci.yml

@@ -29,3 +29,5 @@ linters-settings:
   gocritic:
     disabled-checks:
       - ifElseChain
+  gci:
+    local-prefixes: github.com/markus-wa/demoinfocs-golang/v2

pkg/demoinfocs/datatables.go

@@ -533,6 +533,8 @@ func (p *parser) bindGameRules() {
 
 	gameRules := p.ServerClasses().FindByName("CCSGameRulesProxy")
 	gameRules.OnEntityCreated(func(entity st.Entity) {
+		p.gameState.rules.entity = entity
+
 		entity.Property(grPrefix("m_gamePhase")).OnUpdate(func(val st.PropertyValue) {
 			oldGamePhase := p.gameState.gamePhase
 			p.gameState.gamePhase = common.GamePhase(val.IntVal)

pkg/demoinfocs/fake/game_rules.go

@@ -0,0 +1,36 @@
+package fake
+
+import (
+	"time"
+
+	"github.com/stretchr/testify/mock"
+
+	demoinfocs "github.com/markus-wa/demoinfocs-golang/v2/pkg/demoinfocs"
+)
+
+var _ demoinfocs.GameRules = new(GameRules)
+
+// GameRules is a mock for of demoinfocs.GameRules.
+type GameRules struct {
+	mock.Mock
+}
+
+// BombTime is a mock-implementation of GameRules.ByUserID().
+func (gr *GameRules) BombTime() (time.Duration, error) {
+	return gr.Called().Get(0).(time.Duration), gr.Called().Get(0).(error)
+}
+
+// FreezeTime is a mock-implementation of GameRules.ByUserID().
+func (gr *GameRules) FreezeTime() (time.Duration, error) {
+	return gr.Called().Get(0).(time.Duration), gr.Called().Get(0).(error)
+}
+
+// RoundTime is a mock-implementation of GameRules.ByUserID().
+func (gr *GameRules) RoundTime() (time.Duration, error) {
+	return gr.Called().Get(0).(time.Duration), gr.Called().Get(0).(error)
+}
+
+// ConVars is a mock-implementation of GameRules.ConVars().
+func (gr *GameRules) ConVars() map[string]string {
+	return gr.Called().Get(0).(map[string]string)
+}

pkg/demoinfocs/fake/game_state.go

@@ -89,3 +89,8 @@ func (gs *GameState) IsMatchStarted() bool {
 func (gs *GameState) ConVars() map[string]string {
 	return gs.Called().Get(0).(map[string]string)
 }
+
+// Rules is a mock-implementation of GameState.Rules().
+func (gs *GameState) Rules() demoinfocs.GameRules {
+	return gs.Called().Get(0).(demoinfocs.GameRules)
+}

pkg/demoinfocs/game_rules_interface.go

@@ -0,0 +1,24 @@
+// DO NOT EDIT: Auto generated
+
+package demoinfocs
+
+import (
+	"time"
+)
+
+// GameRules is an auto-generated interface for gameRules.
+type GameRules interface {
+	// RoundTime returns how long rounds in the current match last for (excluding freeze time).
+	// May return error if cs_gamerules_data.m_iRoundTime is not set.
+	RoundTime() (time.Duration, error)
+	// FreezeTime returns how long freeze time lasts for in the current match (mp_freezetime).
+	// May return error if mp_freezetime cannot be converted to a time duration.
+	FreezeTime() (time.Duration, error)
+	// BombTime returns how long freeze time lasts for in the current match (mp_freezetime).
+	// May return error if mp_c4timer cannot be converted to a time duration.
+	BombTime() (time.Duration, error)
+	// ConVars returns a map of CVar keys and values.
+	// Not all values might be set.
+	// See also: https://developer.valvesoftware.com/wiki/List_of_CS:GO_Cvars.
+	ConVars() map[string]string
+}

pkg/demoinfocs/game_state.go

@@ -1,13 +1,18 @@
 package demoinfocs
 
 import (
+	"errors"
+	"strconv"
+	"time"
+
 	constants "github.com/markus-wa/demoinfocs-golang/v2/internal/constants"
 	common "github.com/markus-wa/demoinfocs-golang/v2/pkg/demoinfocs/common"
 	st "github.com/markus-wa/demoinfocs-golang/v2/pkg/demoinfocs/sendtables"
 )
 
 //go:generate ifacemaker -f game_state.go -s gameState -i GameState -p demoinfocs -D -y "GameState is an auto-generated interface for gameState." -c "DO NOT EDIT: Auto generated" -o game_state_interface.go
 //go:generate ifacemaker -f game_state.go -s participants -i Participants -p demoinfocs -D -y "Participants is an auto-generated interface for participants." -c "DO NOT EDIT: Auto generated" -o participants_interface.go
+//go:generate ifacemaker -f game_state.go -s gameRules -i GameRules -p demoinfocs -D -y "GameRules is an auto-generated interface for gameRules." -c "DO NOT EDIT: Auto generated" -o game_rules_interface.go
 
 // gameState contains all game-state relevant information.
 type gameState struct {
@@ -20,7 +25,6 @@ type gameState struct {
 	infernos           map[int]*common.Inferno           // Maps entity-IDs to active infernos.
 	weapons            map[int]*common.Equipment         // Maps entity IDs to weapons. Used to remember what a weapon is (p250 / cz etc.)
 	entities           map[int]st.Entity                 // Maps entity IDs to entities
-	conVars            map[string]string
 	bomb               common.Bomb
 	totalRoundsPlayed  int
 	gamePhase          common.GamePhase
@@ -30,6 +34,8 @@ type gameState struct {
 	currentDefuser     *common.Player                         // Player currently defusing the bomb, if any
 	currentPlanter     *common.Player                         // Player currently planting the bomb, if any
 	thrownGrenades     map[*common.Player][]*common.Equipment // Information about every player's thrown grenades (from the moment they are thrown to the moment their effect is ended)
+	rules              gameRules
+	demoInfo           demoInfoProvider
 }
 
 type lastFlash struct {
@@ -88,6 +94,12 @@ func (gs gameState) Participants() Participants {
 	}
 }
 
+// Rules returns the GameRules for the current match.
+// Contains information like freeze time duration etc.
+func (gs gameState) Rules() GameRules {
+	return gs.rules
+}
+
 // GrenadeProjectiles returns a map from entity-IDs to all live grenade projectiles.
 //
 // Only constains projectiles currently in-flight or still active (smokes etc.),
@@ -140,23 +152,27 @@ func (gs gameState) IsMatchStarted() bool {
 // ConVars returns a map of CVar keys and values.
 // Not all values might be set.
 // See also: https://developer.valvesoftware.com/wiki/List_of_CS:GO_Cvars.
+// Deprecated: see GameRules().ConVars()
 func (gs *gameState) ConVars() map[string]string {
-	return gs.conVars
+	return gs.rules.ConVars()
 }
 
-func newGameState() *gameState {
+func newGameState(demoInfo demoInfoProvider) *gameState {
 	gs := &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),
 		weapons:            make(map[int]*common.Equipment),
 		entities:           make(map[int]st.Entity),
-		conVars:            make(map[string]string),
 		thrownGrenades:     make(map[*common.Player][]*common.Equipment),
 		lastFlash: lastFlash{
 			projectileByPlayer: make(map[*common.Player]*common.GrenadeProjectile),
 		},
+		rules: gameRules{
+			conVars: make(map[string]string),
+		},
+		demoInfo: demoInfo,
 	}
 
 	gs.tState = common.NewTeamState(common.TeamTerrorists, gs.Participants().TeamMembers)
@@ -167,6 +183,57 @@ func newGameState() *gameState {
 	return gs
 }
 
+type gameRules struct {
+	conVars map[string]string
+	entity  st.Entity
+}
+
+var ErrFailedToRetrieveGameRule = errors.New("failed to retrieve GameRule value, it's recommended to have a fallback to a default value for this scenario")
+
+// RoundTime returns how long rounds in the current match last for (excluding freeze time).
+// May return error if cs_gamerules_data.m_iRoundTime is not set.
+func (gr gameRules) RoundTime() (time.Duration, error) {
+	if gr.entity == nil {
+		return 0, ErrFailedToRetrieveGameRule
+	}
+
+	prop := gr.entity.Property("cs_gamerules_data.m_iRoundTime")
+	if prop == nil {
+		return 0, ErrFailedToRetrieveGameRule
+	}
+
+	return time.Duration(prop.Value().IntVal) * time.Second, nil
+}
+
+// FreezeTime returns how long freeze time lasts for in the current match (mp_freezetime).
+// May return error if mp_freezetime cannot be converted to a time duration.
+func (gr gameRules) FreezeTime() (time.Duration, error) {
+	t, err := strconv.Atoi(gr.conVars["mp_freezetime"])
+	if err != nil {
+		return 0, ErrFailedToRetrieveGameRule
+	}
+
+	return time.Duration(t) * time.Second, nil
+}
+
+// BombTime returns how long freeze time lasts for in the current match (mp_freezetime).
+// May return error if mp_c4timer cannot be converted to a time duration.
+func (gr gameRules) BombTime() (time.Duration, error) {
+	t, err := strconv.Atoi(gr.conVars["mp_c4timer"])
+	if err != nil {
+		return 0, ErrFailedToRetrieveGameRule
+	}
+
+	return time.Duration(t) * time.Second, nil
+}
+
+// ConVars returns a map of CVar keys and values.
+// Not all values might be set.
+// See also: https://developer.valvesoftware.com/wiki/List_of_CS:GO_Cvars.
+func (gr gameRules) ConVars() map[string]string {
+	return gr.conVars
+}
+
 // participants provides helper functions on top of the currently connected players.
 // E.g. ByUserID(), ByEntityID(), TeamMembers(), etc.
 //

pkg/demoinfocs/game_state_interface.go

@@ -30,6 +30,9 @@ type GameState interface {
 	// Participants returns a struct with all currently connected players & spectators and utility functions.
 	// The struct contains references to the original maps so it's always up-to-date.
 	Participants() Participants
+	// Rules returns the GameRules for the current match.
+	// Contains information like freeze time duration etc.
+	Rules() GameRules
 	// GrenadeProjectiles returns a map from entity-IDs to all live grenade projectiles.
 	//
 	// Only constains projectiles currently in-flight or still active (smokes etc.),
@@ -55,5 +58,6 @@ type GameState interface {
 	// ConVars returns a map of CVar keys and values.
 	// Not all values might be set.
 	// See also: https://developer.valvesoftware.com/wiki/List_of_CS:GO_Cvars.
+	// Deprecated: see GameRules().ConVars()
 	ConVars() map[string]string
 }

pkg/demoinfocs/game_state_test.go

@@ -2,6 +2,7 @@ package demoinfocs
 
 import (
 	"testing"
+	"time"
 
 	"github.com/stretchr/testify/assert"
 
@@ -12,34 +13,35 @@ import (
 )
 
 func TestNewGameState(t *testing.T) {
-	gs := newGameState()
+	gs := newGameState(demoInfoProvider{})
 
 	assert.NotNil(t, gs.playersByEntityID)
 	assert.NotNil(t, gs.playersByUserID)
 	assert.NotNil(t, gs.grenadeProjectiles)
 	assert.NotNil(t, gs.infernos)
 	assert.NotNil(t, gs.weapons)
 	assert.NotNil(t, gs.entities)
+	assert.NotNil(t, gs.rules.conVars)
 	assert.Equal(t, common.TeamTerrorists, gs.tState.Team())
 	assert.Equal(t, common.TeamCounterTerrorists, gs.ctState.Team())
 }
 
 func TestNewGameState_TeamState_Pointers(t *testing.T) {
-	gs := newGameState()
+	gs := newGameState(demoInfoProvider{})
 
 	assert.True(t, gs.TeamCounterTerrorists() == &gs.ctState)
 	assert.True(t, gs.TeamTerrorists() == &gs.tState)
 }
 
 func TestNewGameState_TeamState_Opponent(t *testing.T) {
-	gs := newGameState()
+	gs := newGameState(demoInfoProvider{})
 
 	assert.True(t, &gs.ctState == gs.tState.Opponent)
 	assert.True(t, &gs.tState == gs.ctState.Opponent)
 }
 
 func TestGameState_Participants(t *testing.T) {
-	gs := newGameState()
+	gs := newGameState(demoInfoProvider{})
 	ptcp := gs.Participants()
 	byEntity := ptcp.ByEntityID()
 	byUserID := ptcp.ByUserID()
@@ -70,13 +72,6 @@ func TestGameState_Participants(t *testing.T) {
 	assert.NotEqual(t, allByUserID, ptcp.ByUserID())
 }
 
-func TestGameState_ConVars(t *testing.T) {
-	cvars := make(map[string]string)
-	gs := gameState{conVars: cvars}
-
-	assert.Equal(t, cvars, gs.ConVars())
-}
-
 func TestParticipants_All(t *testing.T) {
 	pl := newPlayer()
 	ptcps := participants{
@@ -282,6 +277,69 @@ func TestParticipants_SpottedBy(t *testing.T) {
 	assert.ElementsMatch(t, []*common.Player{spotted1, spotted2}, spotted)
 }
 
+func TestGameRules_ConVars(t *testing.T) {
+	cvars := make(map[string]string)
+	gr := gameRules{conVars: cvars}
+
+	assert.Equal(t, cvars, gr.ConVars())
+
+	gs := gameState{rules: gr}
+	assert.Equal(t, cvars, gs.ConVars())
+}
+
+func TestGameRules_BombTime(t *testing.T) {
+	gs := gameRules{conVars: map[string]string{"mp_c4timer": "5"}}
+
+	bt, err := gs.BombTime()
+
+	assert.Nil(t, err)
+	assert.Equal(t, 5*time.Second, bt)
+}
+
+func TestGameRules_FreezeTime(t *testing.T) {
+	gs := gameRules{conVars: map[string]string{"mp_freezetime": "5"}}
+
+	bt, err := gs.FreezeTime()
+
+	assert.Nil(t, err)
+	assert.Equal(t, 5*time.Second, bt)
+}
+
+func TestGameRules_RoundTime(t *testing.T) {
+	prop := new(stfake.Property)
+	prop.On("Value").Return(st.PropertyValue{IntVal: 115})
+	ent := new(stfake.Entity)
+	ent.On("Property", "cs_gamerules_data.m_iRoundTime").Return(prop)
+	gr := gameRules{entity: ent}
+
+	rt, err := gr.RoundTime()
+
+	assert.Nil(t, err)
+	assert.Equal(t, 115*time.Second, rt)
+}
+
+func TestGameRules(t *testing.T) {
+	gr := gameRules{
+		conVars: map[string]string{},
+	}
+
+	_, err := gr.RoundTime()
+	assert.Equal(t, ErrFailedToRetrieveGameRule, err)
+
+	_, err = gr.BombTime()
+	assert.Equal(t, ErrFailedToRetrieveGameRule, err)
+
+	_, err = gr.FreezeTime()
+	assert.Equal(t, ErrFailedToRetrieveGameRule, err)
+
+	ent := new(stfake.Entity)
+	ent.On("Property", "cs_gamerules_data.m_iRoundTime").Return(nil)
+	gr = gameRules{entity: ent}
+
+	_, err = gr.RoundTime()
+	assert.Equal(t, ErrFailedToRetrieveGameRule, err)
+}
+
 func newPlayer() *common.Player {
 	pl := newPlayerWithEntityID(1)
 	return pl

pkg/demoinfocs/net_messages.go

@@ -54,7 +54,7 @@ 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.gameState.rules.conVars[cvar.Name] = cvar.Value
 	}
 
 	p.eventDispatcher.Dispatch(events.ConVarsUpdated{

pkg/demoinfocs/parser.go

@@ -305,11 +305,11 @@ func NewParserWithConfig(demostream io.Reader, config ParserConfig) Parser {
 	p.rawPlayers = make(map[int]*playerInfo)
 	p.triggers = make(map[int]*boundingBoxInformation)
 	p.cancelChan = make(chan struct{}, 1)
-	p.gameState = newGameState()
+	p.demoInfoProvider = demoInfoProvider{parser: &p}
+	p.gameState = newGameState(p.demoInfoProvider)
 	p.grenadeModelIndices = make(map[int]common.EquipmentType)
 	p.gameEventHandler = newGameEventHandler(&p)
 	p.userMessageHandler = newUserMessageHandler(&p)
-	p.demoInfoProvider = demoInfoProvider{parser: &p}
 
 	dispatcherCfg := dp.Config{
 		PanicHandler: func(v interface{}) {