[refactoring] Remove timer from controller, timings only in engine

Author: g3force

internal/app/controller/controller.go

@@ -21,7 +21,6 @@ type GameController struct {
 	AutoRefServer             *rcon.AutoRefServer
 	TeamServer                *rcon.TeamServer
 	Engine                    Engine
-	timer                     timer.Timer
 	historyPreserver          HistoryPreserver
 	numUiProtocolsLastPublish int
 	outstandingTeamChoice     *TeamChoice
@@ -51,7 +50,6 @@ func NewGameController() (c *GameController) {
 	c.TeamServer.ProcessTeamRequest = c.ProcessTeamRequests
 
 	c.Engine = NewEngine(c.Config.Game, time.Now().Unix())
-	c.timer = timer.NewTimer()
 
 	c.setupTimeProvider()
 
@@ -79,7 +77,6 @@ func (c *GameController) Run() {
 	c.TeamServer.AllowedTeamNames = []string{c.Engine.State.TeamState[TeamYellow].Name,
 		c.Engine.State.TeamState[TeamBlue].Name}
 
-	c.timer.Start()
 	go c.mainLoop()
 	go c.publishToNetwork()
 	go c.AutoRefServer.Listen(c.Config.Server.AutoRef.Address)
@@ -91,17 +88,11 @@ func (c *GameController) Run() {
 // setupTimeProvider changes the time provider to the vision receiver, if configured
 func (c *GameController) setupTimeProvider() {
 	if c.Config.TimeFromVision {
-		c.timer.TimeProvider = func() time.Time {
+		c.Engine.TimeProvider = func() time.Time {
 			return time.Unix(0, 0)
 		}
-		c.Engine.TimeProvider = c.timer.TimeProvider
 		c.VisionReceiver.DetectionCallback = func(frame *sslproto.SSL_DetectionFrame) {
-			sec := int64(*frame.TCapture)
-			nsec := int64((*frame.TCapture - float64(sec)) * 1e9)
-			c.timer.TimeProvider = func() time.Time {
-				return time.Unix(sec, nsec)
-			}
-			c.Engine.TimeProvider = c.timer.TimeProvider
+			c.Engine.TimeProvider = timer.NewFixedTimeProviderFromSeconds(*frame.TCapture)
 		}
 	}
 }
@@ -110,10 +101,9 @@ func (c *GameController) setupTimeProvider() {
 func (c *GameController) mainLoop() {
 	defer c.historyPreserver.Close()
 	for {
-		c.timer.WaitTillNextFull(time.Millisecond * 10)
+		time.Sleep(time.Millisecond * 10)
 
-		newFullSecond := c.Engine.UpdateTimes(c.timer.Delta())
-		eventTriggered := c.Engine.TriggerTimedEvents(c.timer.Delta())
+		newFullSecond, eventTriggered := c.Engine.Update()
 		if eventTriggered || newFullSecond {
 			c.publish()
 		}
@@ -159,7 +149,7 @@ func (c *GameController) updateOnlineStates() {
 // publishToNetwork publishes the current state to the network (multicast) every 25ms
 func (c *GameController) publishToNetwork() {
 	for {
-		c.timer.SleepConsumer(25 * time.Millisecond)
+		time.Sleep(25 * time.Millisecond)
 		c.Publisher.Publish(c.Engine.State)
 	}
 }

internal/app/controller/engine.go

@@ -3,6 +3,7 @@ package controller
 import (
 	"github.com/RoboCup-SSL/ssl-game-controller/internal/app/config"
 	"github.com/RoboCup-SSL/ssl-game-controller/pkg/refproto"
+	"github.com/RoboCup-SSL/ssl-game-controller/pkg/timer"
 	"github.com/pkg/errors"
 	"log"
 	"math/rand"
@@ -29,15 +30,16 @@ func NewEngineState() (e EngineState) {
 }
 
 type Engine struct {
-	State        *State
-	UiProtocol   []UiProtocolEntry
-	EngineState  EngineState
-	StageTimes   map[Stage]time.Duration
-	config       config.Game
-	TimeProvider func() time.Time
-	History      History
-	Geometry     config.Geometry
-	Rand         *rand.Rand
+	State          *State
+	UiProtocol     []UiProtocolEntry
+	EngineState    EngineState
+	StageTimes     map[Stage]time.Duration
+	config         config.Game
+	TimeProvider   timer.TimeProvider
+	LastTimeUpdate time.Time
+	History        History
+	Geometry       config.Geometry
+	Rand           *rand.Rand
 }
 
 func NewEngine(config config.Game, seed int64) (e Engine) {
@@ -46,6 +48,7 @@ func NewEngine(config config.Game, seed int64) (e Engine) {
 	e.loadStages()
 	e.ResetGame()
 	e.TimeProvider = func() time.Time { return time.Now() }
+	e.LastTimeUpdate = e.TimeProvider()
 	e.Rand = rand.New(rand.NewSource(seed))
 	return
 }
@@ -78,8 +81,20 @@ func (e *Engine) ResetGame() {
 	}
 }
 
-// TriggerTimedEvents checks for elapsed stage time, timeouts and cards
-func (e *Engine) TriggerTimedEvents(delta time.Duration) (eventTriggered bool) {
+// Update updates times and triggers events if needed
+func (e *Engine) Update() (newFullSecond bool, eventTriggered bool) {
+	currentTime := e.TimeProvider()
+	delta := currentTime.Sub(e.LastTimeUpdate)
+	e.LastTimeUpdate = currentTime
+
+	newFullSecond = e.updateTimes(currentTime, delta)
+	eventTriggered = e.triggerTimedEvents(delta)
+
+	return
+}
+
+// triggerTimedEvents checks for elapsed stage time, timeouts and cards
+func (e *Engine) triggerTimedEvents(delta time.Duration) (eventTriggered bool) {
 	eventTriggered = false
 	if e.countStageTime() {
 		if e.State.StageTimeLeft+delta > 0 && e.State.StageTimeLeft <= 0 {
@@ -103,8 +118,9 @@ func (e *Engine) TriggerTimedEvents(delta time.Duration) (eventTriggered bool) {
 	return
 }
 
-// UpdateTimes updates the times of the state
-func (e *Engine) UpdateTimes(delta time.Duration) (newFullSecond bool) {
+// updateTimes updates the times of the state
+func (e *Engine) updateTimes(currentTime time.Time, delta time.Duration) (newFullSecond bool) {
+
 	if e.countStageTime() {
 		newFullSecond = newFullSecond || isNewFullSecond(e.State.StageTimeElapsed, delta)
 
@@ -121,18 +137,18 @@ func (e *Engine) UpdateTimes(delta time.Duration) (newFullSecond bool) {
 		e.State.TeamState[e.State.CommandFor].TimeoutTimeLeft -= delta
 	}
 
-	curTime := e.TimeProvider()
 	if e.State.MatchTimeStart.After(time.Unix(0, 0)) {
-		newMatchDuration := curTime.Sub(e.State.MatchTimeStart)
+		newMatchDuration := currentTime.Sub(e.State.MatchTimeStart)
 		newFullSecond = newFullSecond || isNewFullSecond(e.State.MatchDuration, newMatchDuration-e.State.MatchDuration)
 		e.State.MatchDuration = newMatchDuration
 	}
 
 	if e.State.CurrentActionDeadline.After(time.Unix(0, 0)) {
-		newCurrentActionTimeRemaining := e.State.CurrentActionDeadline.Sub(curTime)
+		newCurrentActionTimeRemaining := e.State.CurrentActionDeadline.Sub(currentTime)
 		newFullSecond = newFullSecond || isNewFullSecond(e.State.CurrentActionTimeRemaining, newCurrentActionTimeRemaining-e.State.CurrentActionTimeRemaining)
 		e.State.CurrentActionTimeRemaining = newCurrentActionTimeRemaining
 	}
+
 	return
 }
 

internal/app/controller/engine_test.go

@@ -105,6 +105,7 @@ func processTransitionFile(t *testing.T, fileName string) {
 	e.TimeProvider = func() time.Time {
 		return initialTime.Add(elapsedTime)
 	}
+	e.LastTimeUpdate = e.TimeProvider()
 
 	// apply the initial state to the engine
 	if err := stateTransitions.InitialState.valid(); err != nil {
@@ -127,8 +128,7 @@ func processTransitionFile(t *testing.T, fileName string) {
 
 		if s.Tick != nil {
 			elapsedTime += *s.Tick
-			e.UpdateTimes(*s.Tick)
-			e.TriggerTimedEvents(*s.Tick)
+			e.Update()
 		}
 
 		if s.ExpectedStateDiff != nil {