[feature] Implement more referee events

g3force · g3force · commit ff663722a0aa · 2018-08-25T18:06:02.000+02:00
diff --git a/internal/app/controller/apiServer.go b/internal/app/controller/apiServer.go
@@ -79,7 +79,7 @@ func (a *ApiServer) PublishState(state State) {
 	a.PublishWrapper(wrapper)
 }
 
-func (a *ApiServer) PublishGameEvents(events []RefereeEvent) {
+func (a *ApiServer) PublishRefereeEvents(events []RefereeEvent) {
 	a.latestRefereeEvents = events
 	wrapper := MessageWrapper{RefereeEvents: &events}
 	a.PublishWrapper(wrapper)
diff --git a/internal/app/controller/controller.go b/internal/app/controller/controller.go
@@ -9,12 +9,13 @@ const configFileName = "config/ssl-game-controller.yaml"
 
 // GameController controls a game
 type GameController struct {
-	Config           Config
-	Publisher        Publisher
-	ApiServer        ApiServer
-	Engine           Engine
-	timer            timer.Timer
-	historyPreserver HistoryPreserver
+	Config                      Config
+	Publisher                   Publisher
+	ApiServer                   ApiServer
+	Engine                      Engine
+	timer                       timer.Timer
+	historyPreserver            HistoryPreserver
+	numRefereeEventsLastPublish int
 }
 
 // NewGameController creates a new RefBox
@@ -33,44 +34,43 @@ func NewGameController() (r *GameController) {
 }
 
 // Run the GameController by starting an endless loop in the background
-func (r *GameController) Run() (err error) {
+func (c *GameController) Run() (err error) {
 
-	if err := r.historyPreserver.Open(); err != nil {
+	if err := c.historyPreserver.Open(); err != nil {
 		log.Print("Could not open history", err)
 	} else {
-		history, err := r.historyPreserver.Load()
+		history, err := c.historyPreserver.Load()
 		if err != nil {
 			log.Print("Could not load history", err)
 		} else if len(*history) > 0 {
-			r.Engine.History = *history
-			*r.Engine.State = r.Engine.History[len(r.Engine.History)-1].State
-			r.Engine.RefereeEvents = r.Engine.History[len(r.Engine.History)-1].RefereeEvents
+			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
 		}
 	}
 
-	r.ApiServer.PublishState(*r.Engine.State)
-	r.ApiServer.PublishGameEvents(r.Engine.RefereeEvents)
+	c.ApiServer.PublishState(*c.Engine.State)
+	c.ApiServer.PublishRefereeEvents(c.Engine.RefereeEvents)
 
 	go func() {
-		defer r.historyPreserver.Close()
+		defer c.historyPreserver.Close()
 		for {
-			r.timer.WaitTillNextFullSecond()
-			r.Engine.Tick(r.timer.Delta())
-			r.historyPreserver.Save(r.Engine.History)
-			r.publish()
+			c.timer.WaitTillNextFullSecond()
+			c.Engine.Tick(c.timer.Delta())
+			c.historyPreserver.Save(c.Engine.History)
+			c.publish()
 		}
 	}()
 	return nil
 }
 
-func (r *GameController) OnNewEvent(event Event) {
-	err := r.Engine.Process(event)
+func (c *GameController) OnNewEvent(event Event) {
+	err := c.Engine.Process(event)
 	if err != nil {
 		log.Println("Could not process event:", event, err)
 	} else {
-		r.historyPreserver.Save(r.Engine.History)
-		r.publish()
-		r.publishGameEvents()
+		c.historyPreserver.Save(c.Engine.History)
+		c.publish()
 	}
 }
 
@@ -91,12 +91,12 @@ func loadConfig() Config {
 }
 
 // publish publishes the state to the UI and the teams
-func (r *GameController) publish() {
-	r.ApiServer.PublishState(*r.Engine.State)
-	r.Publisher.Publish(r.Engine.State)
-}
+func (c *GameController) publish() {
+	if len(c.Engine.RefereeEvents) != c.numRefereeEventsLastPublish {
+		c.ApiServer.PublishRefereeEvents(c.Engine.RefereeEvents)
+		c.numRefereeEventsLastPublish = len(c.Engine.RefereeEvents)
+	}
 
-// publishGameEvents publishes the current list of game events
-func (r *GameController) publishGameEvents() {
-	r.ApiServer.PublishGameEvents(r.Engine.RefereeEvents)
+	c.ApiServer.PublishState(*c.Engine.State)
+	c.Publisher.Publish(c.Engine.State)
 }
diff --git a/internal/app/controller/engine.go b/internal/app/controller/engine.go
@@ -1,6 +1,7 @@
 package controller
 
 import (
+	"fmt"
 	"github.com/pkg/errors"
 	"log"
 	"strconv"
@@ -122,6 +123,38 @@ func (e *Engine) LogCommand() {
 	e.RefereeEvents = append(e.RefereeEvents, refereeEvent)
 }
 
+func (e *Engine) LogCard(card *EventCard) {
+	refereeEvent := RefereeEvent{
+		Timestamp: e.TimeProvider(),
+		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(),
+		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(),
+		StageTime: e.State.StageTimeElapsed,
+		Type:      RefereeEventStage,
+		Name:      string(stage),
+	}
+	e.RefereeEvents = append(e.RefereeEvents, refereeEvent)
+}
+
 func (e *Engine) loadStages() {
 	e.StageTimes = map[Stage]time.Duration{}
 	for _, stage := range Stages {
@@ -142,14 +175,23 @@ func (e *Engine) updateTimes(delta time.Duration) {
 		e.State.StageTimeElapsed += delta
 		e.State.StageTimeLeft -= delta
 
-		for _, teamState := range e.State.TeamState {
+		if e.State.StageTimeLeft+delta > 0 && e.State.StageTimeLeft <= 0 {
+			e.LogTime("Stage time elapsed", "")
+		}
+
+		for team, teamState := range e.State.TeamState {
 			reduceYellowCardTimes(teamState, delta)
-			removeElapsedYellowCards(teamState)
+			e.removeElapsedYellowCards(team, teamState)
 		}
 	}
 
 	if e.State.GameState() == GameStateTimeout && e.State.CommandFor.Known() {
 		e.State.TeamState[e.State.CommandFor].TimeoutTimeLeft -= delta
+
+		timeLeft := e.State.TeamState[e.State.CommandFor].TimeoutTimeLeft
+		if timeLeft+delta > 0 && timeLeft <= 0 {
+			e.LogTime("Timeout time elapsed", e.State.CommandFor)
+		}
 	}
 }
 
@@ -259,6 +301,7 @@ func (e *Engine) processStage(s *EventStage) error {
 }
 
 func (e *Engine) updateStage(stage Stage) {
+	e.LogStage(stage)
 
 	e.State.StageTimeLeft = e.StageTimes[stage]
 	e.State.StageTimeElapsed = 0
@@ -296,7 +339,7 @@ func (e *Engine) updatePreStages() {
 	}
 }
 
-func (e *Engine) processCard(card *EventCard) error {
+func (e *Engine) processCard(card *EventCard) (err error) {
 	if card.ForTeam != TeamYellow && card.ForTeam != TeamBlue {
 		return errors.Errorf("Unknown team: %v", card.ForTeam)
 	}
@@ -305,13 +348,19 @@ func (e *Engine) processCard(card *EventCard) error {
 	}
 	teamState := e.State.TeamState[card.ForTeam]
 	if card.Operation == CardOperationAdd {
-		return addCard(card, teamState, e.config.YellowCardDuration)
+		err = addCard(card, teamState, e.config.YellowCardDuration)
 	} else if card.Operation == CardOperationRevoke {
-		return revokeCard(card, teamState)
+		err = revokeCard(card, teamState)
 	} else if card.Operation == CardOperationModify {
 		return modifyCard(card, teamState)
+	} else {
+		return errors.Errorf("Unknown operation: %v", card.Operation)
 	}
-	return errors.Errorf("Unknown operation: %v", card.Operation)
+
+	if err == nil {
+		e.LogCard(card)
+	}
+	return
 }
 
 func modifyCard(card *EventCard, teamState *TeamInfo) error {
@@ -436,11 +485,13 @@ func reduceYellowCardTimes(teamState *TeamInfo, delta time.Duration) {
 	}
 }
 
-func removeElapsedYellowCards(teamState *TeamInfo) {
+func (e *Engine) removeElapsedYellowCards(team Team, teamState *TeamInfo) {
 	b := teamState.YellowCardTimes[:0]
 	for _, x := range teamState.YellowCardTimes {
 		if x > 0 {
 			b = append(b, x)
+		} else {
+			e.LogTime("Yellow card time elapsed", team)
 		}
 	}
 	teamState.YellowCardTimes = b
diff --git a/internal/app/controller/gameEvents.go b/internal/app/controller/gameEvents.go
@@ -16,6 +16,7 @@ const (
 	RefereeEventCommand   RefereeEventType = "command"
 	RefereeEventStage     RefereeEventType = "stage"
 	RefereeEventCard      RefereeEventType = "card"
+	RefereeEventTime      RefereeEventType = "time"
 	RefereeEventGameEvent RefereeEventType = "gameEvent"
 )
 
diff --git a/src/components/common/TeamSelection.vue b/src/components/common/TeamSelection.vue
@@ -1,8 +1,8 @@
 <template>
     <b-form-group :label="label" horizontal>
         <b-form-radio-group id="select-team" v-model="newEvent.team" buttons>
-            <b-form-radio value="yellow">Yellow</b-form-radio>
-            <b-form-radio value="blue">Blue</b-form-radio>
+            <b-form-radio value="Yellow">Yellow</b-form-radio>
+            <b-form-radio value="Blue">Blue</b-form-radio>
             <b-form-radio value="unknown" :disable="showUnknown">No team</b-form-radio>
         </b-form-radio-group>
     </b-form-group>
diff --git a/src/components/control/ControlMatch.vue b/src/components/control/ControlMatch.vue
@@ -1,27 +1,32 @@
 <template>
     <div>
         <b-button v-b-tooltip.hover title="Start a new match by resetting everything"
-                  v-on:click="resetMatch">
+                  v-on:click="resetMatch"
+                  :disabled="forbidMatchControls">
             Reset Match
         </b-button>
         <b-button v-b-tooltip.hover title="Undo the last state change"
                   v-on:click="undo">
             Undo
         </b-button>
         <b-button v-b-tooltip.hover title="Switch the colors of the teams, keep everything else"
-                  v-on:click="switchColor">
+                  v-on:click="switchColor"
+                  :disabled="forbidMatchControls">
             Switch colors
         </b-button>
         <b-button v-b-tooltip.hover title="Switch the playing half (the goal) of the teams"
-                  v-on:click="switchSides">
+                  v-on:click="switchSides"
+                  :disabled="forbidMatchControls">
             Switch sides
         </b-button>
         <b-button v-b-tooltip.hover title="Change back to the previous stage (if something went wrong)"
-                  v-on:click="previousStage">
+                  v-on:click="previousStage"
+                  :disabled="forbidMatchControls">
             Previous Stage
         </b-button>
         <b-button v-b-tooltip.hover title="Proceed to the next stage"
-                  v-on:click="nextStage">
+                  v-on:click="nextStage"
+                  :disabled="forbidMatchControls">
             Next Stage
         </b-button>
     </div>
@@ -61,6 +66,20 @@
                     'stage': {'stageOperation': 'next'}
                 })
             },
+        },
+        computed: {
+            state() {
+                return this.$store.state.refBoxState
+            },
+            halted() {
+                return this.state.command === 'halt';
+            },
+            stopped() {
+                return this.state.command === 'stop';
+            },
+            forbidMatchControls() {
+                return !this.stopped && !this.halted;
+            }
         }
     }
 </script>

Original file line number	Diff line number	Diff line change
`@@ -79,7 +79,7 @@ func (a *ApiServer) PublishState(state State) {`
`79`	`79`	`a.PublishWrapper(wrapper)`
`80`	`80`	`}`
`81`	`81`
`82`		`-func (a *ApiServer) PublishGameEvents(events []RefereeEvent) {`
	`82`	`+func (a *ApiServer) PublishRefereeEvents(events []RefereeEvent) {`
`83`	`83`	`a.latestRefereeEvents = events`
`84`	`84`	`wrapper := MessageWrapper{RefereeEvents: &events}`
`85`	`85`	`a.PublishWrapper(wrapper)`
Original file line number	Diff line number	Diff line change
`@@ -16,6 +16,7 @@ const (`
`16`	`16`	`RefereeEventCommand RefereeEventType = "command"`
`17`	`17`	`RefereeEventStage RefereeEventType = "stage"`
`18`	`18`	`RefereeEventCard RefereeEventType = "card"`
	`19`	`+ RefereeEventTime RefereeEventType = "time"`
`19`	`20`	`RefereeEventGameEvent RefereeEventType = "gameEvent"`
`20`	`21`	`)`
`21`	`22`