[refactoring] Rename refereeEvents to uiProtocol

g3force · g3force · commit 3a5e97722e4a · 2018-11-01T16:05:15.000+01:00
diff --git a/internal/app/controller/controller.go b/internal/app/controller/controller.go
@@ -18,18 +18,18 @@ const configFileName = "config/ssl-game-controller.yaml"
 
 // GameController controls a game
 type GameController struct {
-	Config                      config.Controller
-	Publisher                   Publisher
-	ApiServer                   ApiServer
-	AutoRefServer               *rcon.AutoRefServer
-	TeamServer                  *rcon.TeamServer
-	Engine                      Engine
-	timer                       timer.Timer
-	historyPreserver            HistoryPreserver
-	numRefereeEventsLastPublish int
-	outstandingTeamChoice       *TeamChoice
-	Mutex                       sync.Mutex
-	VisionReceiver              *vision.Receiver
+	Config                    config.Controller
+	Publisher                 Publisher
+	ApiServer                 ApiServer
+	AutoRefServer             *rcon.AutoRefServer
+	TeamServer                *rcon.TeamServer
+	Engine                    Engine
+	timer                     timer.Timer
+	historyPreserver          HistoryPreserver
+	numUiProtocolsLastPublish int
+	outstandingTeamChoice     *TeamChoice
+	Mutex                     sync.Mutex
+	VisionReceiver            *vision.Receiver
 }
 
 type TeamChoice struct {
@@ -76,12 +76,12 @@ func (c *GameController) Run() {
 		} else if len(*history) > 0 {
 			c.Engine.History = *history
 			*c.Engine.State = c.Engine.History[len(c.Engine.History)-1].State
-			c.Engine.RefereeEvents = c.Engine.History[len(c.Engine.History)-1].RefereeEvents
+			c.Engine.UiProtocol = c.Engine.History[len(c.Engine.History)-1].UiProtocol
 		}
 	}
 
 	c.ApiServer.PublishState(*c.Engine.State)
-	c.ApiServer.PublishRefereeEvents(c.Engine.RefereeEvents)
+	c.ApiServer.PublishUiProtocol(c.Engine.UiProtocol)
 	c.TeamServer.AllowedTeamNames = []string{c.Engine.State.TeamState[TeamYellow].Name,
 		c.Engine.State.TeamState[TeamBlue].Name}
 
@@ -330,9 +330,9 @@ func loadConfig() config.Controller {
 
 // publish publishes the state to the UI and the teams
 func (c *GameController) publish() {
-	if len(c.Engine.RefereeEvents) != c.numRefereeEventsLastPublish {
-		c.ApiServer.PublishRefereeEvents(c.Engine.RefereeEvents)
-		c.numRefereeEventsLastPublish = len(c.Engine.RefereeEvents)
+	if len(c.Engine.UiProtocol) != c.numUiProtocolsLastPublish {
+		c.ApiServer.PublishUiProtocol(c.Engine.UiProtocol)
+		c.numUiProtocolsLastPublish = len(c.Engine.UiProtocol)
 	}
 
 	c.TeamServer.AllowedTeamNames = []string{c.Engine.State.TeamState[TeamYellow].Name,
diff --git a/internal/app/controller/engine.go b/internal/app/controller/engine.go
@@ -1,7 +1,6 @@
 package controller
 
 import (
-	"fmt"
 	"github.com/RoboCup-SSL/ssl-game-controller/internal/app/config"
 	"github.com/RoboCup-SSL/ssl-game-controller/pkg/refproto"
 	"github.com/pkg/errors"
@@ -14,13 +13,13 @@ import (
 const maxHistorySize = 10
 
 type Engine struct {
-	State         *State
-	RefereeEvents []RefereeEvent
-	StageTimes    map[Stage]time.Duration
-	config        config.Game
-	TimeProvider  func() time.Time
-	History       History
-	Geometry      config.Geometry
+	State        *State
+	UiProtocol   []UiProtocolEntry
+	StageTimes   map[Stage]time.Duration
+	config       config.Game
+	TimeProvider func() time.Time
+	History      History
+	Geometry     config.Geometry
 }
 
 func NewEngine(config config.Game) (e Engine) {
@@ -39,7 +38,7 @@ func (e *Engine) ResetGame() {
 		e.State.TeamState[team].MaxAllowedBots = e.config.MaxBots[e.State.Division]
 	}
 
-	e.RefereeEvents = []RefereeEvent{}
+	e.UiProtocol = []UiProtocolEntry{}
 	e.State.Division = e.config.DefaultDivision
 	e.Geometry = *e.config.DefaultGeometry[e.State.Division]
 }
@@ -87,16 +86,16 @@ func (e *Engine) UndoLastAction() {
 	lastIndex := len(e.History) - 2
 	if lastIndex >= 0 {
 		*e.State = e.History[lastIndex].State.DeepCopy()
-		e.RefereeEvents = append(e.History[lastIndex].RefereeEvents[:0:0],
-			e.History[lastIndex].RefereeEvents...)
+		e.UiProtocol = append(e.History[lastIndex].UiProtocol[:0:0],
+			e.History[lastIndex].UiProtocol...)
 		e.History = e.History[0:lastIndex]
 	}
 }
 
 func (e *Engine) appendHistory() {
 	var entry HistoryEntry
 	entry.State = e.State.DeepCopy()
-	entry.RefereeEvents = append(e.RefereeEvents[:0:0], e.RefereeEvents...)
+	entry.UiProtocol = append(e.UiProtocol[:0:0], e.UiProtocol...)
 	e.History = append(e.History, entry)
 	if len(e.History) > maxHistorySize {
 		e.History = e.History[1:]
@@ -208,9 +207,9 @@ func (e *Engine) CommandForEvent(event *GameEvent) (command RefCommand, forTeam
 }
 
 func (e *Engine) LastGameStartCommand() (RefCommand, error) {
-	for i := len(e.RefereeEvents) - 1; i >= 0; i-- {
-		event := e.RefereeEvents[i]
-		if event.Type == RefereeEventCommand {
+	for i := len(e.UiProtocol) - 1; i >= 0; i-- {
+		event := e.UiProtocol[i]
+		if event.Type == UiProtocolCommand {
 			cmd := RefCommand(event.Name)
 			switch cmd {
 			case CommandPenalty, CommandKickoff, CommandIndirect, CommandDirect:
@@ -241,87 +240,6 @@ func (e *Engine) updateMaxBots() {
 	}
 }
 
-func (e *Engine) LogGameEvent(event GameEvent) {
-	gameEvent := RefereeEvent{
-		Timestamp:   e.TimeProvider().UnixNano(),
-		StageTime:   e.State.StageTimeElapsed,
-		Type:        RefereeEventGameEvent,
-		Name:        string(event.Type),
-		Team:        event.ByTeam(),
-		Description: event.Details.String(),
-	}
-	e.RefereeEvents = append(e.RefereeEvents, gameEvent)
-}
-
-func (e *Engine) LogIgnoredGameEvent(event GameEvent) {
-	gameEvent := RefereeEvent{
-		Timestamp:   e.TimeProvider().UnixNano(),
-		StageTime:   e.State.StageTimeElapsed,
-		Type:        RefereeEventGameEventIgnored,
-		Name:        string(event.Type),
-		Team:        event.ByTeam(),
-		Description: event.Details.String(),
-	}
-	e.RefereeEvents = append(e.RefereeEvents, gameEvent)
-}
-
-func (e *Engine) LogCommand() {
-	refereeEvent := RefereeEvent{
-		Timestamp: e.TimeProvider().UnixNano(),
-		StageTime: e.State.StageTimeElapsed,
-		Type:      RefereeEventCommand,
-		Name:      string(e.State.Command),
-		Team:      e.State.CommandFor,
-	}
-	e.RefereeEvents = append(e.RefereeEvents, refereeEvent)
-}
-
-func (e *Engine) LogCard(card *EventCard) {
-	refereeEvent := RefereeEvent{
-		Timestamp: e.TimeProvider().UnixNano(),
-		StageTime: e.State.StageTimeElapsed,
-		Type:      RefereeEventCard,
-		Name:      fmt.Sprintf("%v %v card", card.Operation, card.Type),
-		Team:      card.ForTeam,
-	}
-	e.RefereeEvents = append(e.RefereeEvents, refereeEvent)
-}
-
-func (e *Engine) LogTime(description string, forTeam Team) {
-	refereeEvent := RefereeEvent{
-		Timestamp: e.TimeProvider().UnixNano(),
-		StageTime: e.State.StageTimeElapsed,
-		Type:      RefereeEventTime,
-		Name:      description,
-		Team:      forTeam,
-	}
-	e.RefereeEvents = append(e.RefereeEvents, refereeEvent)
-}
-
-func (e *Engine) LogStage(stage Stage) {
-	refereeEvent := RefereeEvent{
-		Timestamp: e.TimeProvider().UnixNano(),
-		StageTime: e.State.StageTimeElapsed,
-		Type:      RefereeEventStage,
-		Name:      string(stage),
-	}
-	e.RefereeEvents = append(e.RefereeEvents, refereeEvent)
-}
-
-func (e *Engine) LogModify(m EventModifyValue) {
-	team := m.ForTeam
-	m.ForTeam = TeamUnknown
-	refereeEvent := RefereeEvent{
-		Timestamp:   e.TimeProvider().UnixNano(),
-		StageTime:   e.State.StageTimeElapsed,
-		Type:        RefereeEventModify,
-		Name:        m.Type(),
-		Team:        team,
-		Description: m.Value(),
-	}
-	e.RefereeEvents = append(e.RefereeEvents, refereeEvent)
-}
-
 func (e *Engine) loadStages() {
 	e.StageTimes = map[Stage]time.Duration{}
 	for _, stage := range Stages {
diff --git a/internal/app/controller/history.go b/internal/app/controller/history.go
@@ -15,8 +15,8 @@ type HistoryPreserver struct {
 }
 
 type HistoryEntry struct {
-	State         State
-	RefereeEvents []RefereeEvent
+	State      State
+	UiProtocol []UiProtocolEntry
 }
 
 type History []HistoryEntry
diff --git a/internal/app/controller/refereeEvents.go b/internal/app/controller/refereeEvents.go
diff --git a/internal/app/controller/uiProtocol.go b/internal/app/controller/uiProtocol.go
@@ -0,0 +1,106 @@
+package controller
+
+import (
+	"fmt"
+	"time"
+)
+
+type UiProtocolType string
+
+const (
+	UiProtocolCommand          UiProtocolType = "command"
+	UiProtocolStage            UiProtocolType = "stage"
+	UiProtocolCard             UiProtocolType = "card"
+	UiProtocolTime             UiProtocolType = "time"
+	UiProtocolGameEvent        UiProtocolType = "gameEvent"
+	UiProtocolGameEventIgnored UiProtocolType = "ignoredGameEvent"
+	UiProtocolModify           UiProtocolType = "modify"
+)
+
+type UiProtocolEntry struct {
+	Timestamp   int64          `json:"timestamp"`
+	StageTime   time.Duration  `json:"stageTime"`
+	Type        UiProtocolType `json:"type"`
+	Name        string         `json:"name"`
+	Team        Team           `json:"team"`
+	Description string         `json:"description"`
+}
+
+func (e *Engine) LogGameEvent(event GameEvent) {
+	entry := UiProtocolEntry{
+		Timestamp:   e.TimeProvider().UnixNano(),
+		StageTime:   e.State.StageTimeElapsed,
+		Type:        UiProtocolGameEvent,
+		Name:        string(event.Type),
+		Team:        event.ByTeam(),
+		Description: event.Details.String(),
+	}
+	e.UiProtocol = append(e.UiProtocol, entry)
+}
+
+func (e *Engine) LogIgnoredGameEvent(event GameEvent) {
+	entry := UiProtocolEntry{
+		Timestamp:   e.TimeProvider().UnixNano(),
+		StageTime:   e.State.StageTimeElapsed,
+		Type:        UiProtocolGameEventIgnored,
+		Name:        string(event.Type),
+		Team:        event.ByTeam(),
+		Description: event.Details.String(),
+	}
+	e.UiProtocol = append(e.UiProtocol, entry)
+}
+
+func (e *Engine) LogCommand() {
+	entry := UiProtocolEntry{
+		Timestamp: e.TimeProvider().UnixNano(),
+		StageTime: e.State.StageTimeElapsed,
+		Type:      UiProtocolCommand,
+		Name:      string(e.State.Command),
+		Team:      e.State.CommandFor,
+	}
+	e.UiProtocol = append(e.UiProtocol, entry)
+}
+
+func (e *Engine) LogCard(card *EventCard) {
+	entry := UiProtocolEntry{
+		Timestamp: e.TimeProvider().UnixNano(),
+		StageTime: e.State.StageTimeElapsed,
+		Type:      UiProtocolCard,
+		Name:      fmt.Sprintf("%v %v card", card.Operation, card.Type),
+		Team:      card.ForTeam,
+	}
+	e.UiProtocol = append(e.UiProtocol, entry)
+}
+
+func (e *Engine) LogTime(description string, forTeam Team) {
+	entry := UiProtocolEntry{
+		Timestamp: e.TimeProvider().UnixNano(),
+		StageTime: e.State.StageTimeElapsed,
+		Type:      UiProtocolTime,
+		Name:      description,
+		Team:      forTeam,
+	}
+	e.UiProtocol = append(e.UiProtocol, entry)
+}
+
+func (e *Engine) LogStage(stage Stage) {
+	entry := UiProtocolEntry{
+		Timestamp: e.TimeProvider().UnixNano(),
+		StageTime: e.State.StageTimeElapsed,
+		Type:      UiProtocolStage,
+		Name:      string(stage),
+	}
+	e.UiProtocol = append(e.UiProtocol, entry)
+}
+
+func (e *Engine) LogModify(m EventModifyValue) {
+	entry := UiProtocolEntry{
+		Timestamp:   e.TimeProvider().UnixNano(),
+		StageTime:   e.State.StageTimeElapsed,
+		Type:        UiProtocolModify,
+		Name:        m.Type(),
+		Team:        m.ForTeam,
+		Description: m.Value(),
+	}
+	e.UiProtocol = append(e.UiProtocol, entry)
+}
diff --git a/internal/app/controller/uiServer.go b/internal/app/controller/uiServer.go

Original file line number	Diff line number	Diff line change
`@@ -15,8 +15,8 @@ type HistoryPreserver struct {`
`15`	`15`	`}`
`16`	`16`
`17`	`17`	`type HistoryEntry struct {`
`18`		`- State State`
`19`		`- RefereeEvents []RefereeEvent`
	`18`	`+ State State`
	`19`	`+ UiProtocol []UiProtocolEntry`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`type History []HistoryEntry`