[bugfix] Queue skipped events first, apply on next game event or stop

Author: g3force

internal/app/controller/engine.go

@@ -239,6 +239,8 @@ func (e *Engine) SendCommand(command RefCommand, forTeam Team) {
 		e.State.TeamState[forTeam].TimeoutsLeft--
 	} else if command == CommandNormalStart {
 		e.updatePreStages()
+	} else if command == CommandStop {
+		e.applyQueuedGameEvents()
 	}
 
 	if command.ContinuesGame() {
@@ -269,9 +271,14 @@ func (e *Engine) setCurrentActionTimeout(timeout time.Duration) {
 	e.State.CurrentActionDeadline = e.TimeProvider().Add(e.State.CurrentActionTimeRemaining)
 }
 
-func (e *Engine) AddGameEvent(gameEvent GameEvent) {
+func (e *Engine) AddGameEvent(gameEvent *GameEvent) {
 	e.LogGameEvent(gameEvent, e.State.DeepCopy())
-	e.State.GameEvents = append(e.State.GameEvents, &gameEvent)
+	e.State.GameEvents = append(e.State.GameEvents, gameEvent)
+}
+
+func (e *Engine) QueueGameEvent(gameEvent *GameEvent) {
+	e.LogGameEventQueued(gameEvent, e.State.DeepCopy())
+	e.State.GameEventsQueued = append(e.State.GameEventsQueued, gameEvent)
 }
 
 func (e *Engine) Continue() {
@@ -283,7 +290,7 @@ func (e *Engine) Continue() {
 			Type: GameEventBotSubstitution,
 			Details: GameEventDetails{
 				BotSubstitution: &refproto.GameEvent_BotSubstitution{ByTeam: &teamProto}}}
-		e.AddGameEvent(event)
+		e.AddGameEvent(&event)
 		e.LogHint("botSubstitution", "game halted for bot substitution", substitutionIntend)
 		e.State.TeamState[TeamBlue].BotSubstitutionIntend = false
 		e.State.TeamState[TeamYellow].BotSubstitutionIntend = false
@@ -822,11 +829,15 @@ func (e *Engine) processGameEvent(event *GameEvent) error {
 	e.GcState.GameEventProposals = e.collectNonMatchingProposals(event)
 
 	if e.disabledGameEvent(event.Type) {
-		e.LogIgnoredGameEvent(*event)
+		e.LogIgnoredGameEvent(event)
 		return nil
 	}
 	event.SetOccurred(e.TimeProvider())
 
+	e.applyQueuedGameEvents()
+
+	e.AddGameEvent(event)
+
 	var additionalEvents []*GameEvent
 
 	if event.IncrementsFoulCounter() {
@@ -848,8 +859,6 @@ func (e *Engine) processGameEvent(event *GameEvent) error {
 		}
 	}
 
-	e.AddGameEvent(*event)
-
 	if event.AddsYellowCard() {
 		team := event.ByTeam()
 		if team.Unknown() {
@@ -934,6 +943,16 @@ func (e *Engine) processGameEvent(event *GameEvent) error {
 	return nil
 }
 
+func (e *Engine) applyQueuedGameEvents() {
+	queuedGameEvents := e.State.GameEventsQueued
+	e.State.GameEventsQueued = []*GameEvent{}
+	for _, queuedEvent := range queuedGameEvents {
+		if err := e.processGameEvent(queuedEvent); err != nil {
+			log.Print("Could not process queued game event: ", err)
+		}
+	}
+}
+
 func (e *Engine) placeBall(event *GameEvent) {
 	teamInFavor := event.ByTeam().Opposite()
 

internal/app/controller/protocol.go

@@ -21,6 +21,8 @@ const (
 	UiProtocolTime UiProtocolType = "time"
 	// UiProtocolGameEvent represents an issued game event
 	UiProtocolGameEvent UiProtocolType = "gameEvent"
+	// UiProtocolGameEvent represents an issued game event
+	UiProtocolGameEventQueued UiProtocolType = "gameEventQueued"
 	// UiProtocolGameEventIgnored represents a detected game event that was not issued
 	UiProtocolGameEventIgnored UiProtocolType = "ignoredGameEvent"
 	// UiProtocolModify represents a manual modification on the state
@@ -48,7 +50,7 @@ type ProtocolEntry struct {
 }
 
 // LogGameEvent adds a game event to the protocol
-func (e *Engine) LogGameEvent(event GameEvent, prevState *State) {
+func (e *Engine) LogGameEvent(event *GameEvent, prevState *State) {
 	log.Printf("Log game event: %v", event)
 	entry := ProtocolEntry{
 		Id:            e.newGlobalProtocolEntryId(),
@@ -63,8 +65,24 @@ func (e *Engine) LogGameEvent(event GameEvent, prevState *State) {
 	e.PersistentState.Add(&entry)
 }
 
+// LogGameEvent adds a game event to the protocol
+func (e *Engine) LogGameEventQueued(event *GameEvent, prevState *State) {
+	log.Printf("Log queued game event: %v", event)
+	entry := ProtocolEntry{
+		Id:            e.newGlobalProtocolEntryId(),
+		Timestamp:     e.TimeProvider().UnixNano(),
+		StageTime:     e.State.StageTimeElapsed,
+		Type:          UiProtocolGameEventQueued,
+		Name:          string(event.Type),
+		Team:          event.ByTeam(),
+		Description:   event.Details.String(),
+		PreviousState: prevState,
+	}
+	e.PersistentState.Add(&entry)
+}
+
 // LogIgnoredGameEvent adds an ignored game event to the protocol
-func (e *Engine) LogIgnoredGameEvent(event GameEvent) {
+func (e *Engine) LogIgnoredGameEvent(event *GameEvent) {
 	log.Printf("Log ignored game event: %v", event)
 	entry := ProtocolEntry{
 		Id:          e.newGlobalProtocolEntryId(),

internal/app/controller/state.go

@@ -406,6 +406,7 @@ type State struct {
 	Command                    RefCommand         `json:"command" yaml:"command"`
 	CommandFor                 Team               `json:"commandForTeam" yaml:"commandForTeam"`
 	GameEvents                 []*GameEvent       `json:"gameEvents" yaml:"gameEvents"`
+	GameEventsQueued           []*GameEvent       `json:"gameEventsQueued" yaml:"gameEvents"`
 	StageTimeElapsed           time.Duration      `json:"stageTimeElapsed" yaml:"stageTimeElapsed"`
 	StageTimeLeft              time.Duration      `json:"stageTimeLeft" yaml:"stageTimeLeft"`
 	MatchTimeStart             time.Time          `json:"matchTimeStart" yaml:"matchTimeStart"`
@@ -426,6 +427,7 @@ func NewState() (s *State) {
 	s.Stage = StagePreGame
 	s.Command = CommandHalt
 	s.GameEvents = []*GameEvent{}
+	s.GameEventsQueued = []*GameEvent{}
 
 	s.StageTimeLeft = 0
 	s.StageTimeElapsed = 0
@@ -448,6 +450,8 @@ func (s *State) DeepCopy() (c *State) {
 	*c = *s
 	c.GameEvents = make([]*GameEvent, len(s.GameEvents))
 	copy(c.GameEvents, s.GameEvents)
+	c.GameEventsQueued = make([]*GameEvent, len(s.GameEventsQueued))
+	copy(c.GameEventsQueued, s.GameEventsQueued)
 	if s.PlacementPos != nil {
 		c.PlacementPos = new(Location)
 		*c.PlacementPos = *s.PlacementPos

internal/app/controller/teamConnection.go

@@ -60,10 +60,11 @@ func (c *GameController) ProcessTeamRequests(teamName string, request refproto.T
 			default:
 				return errors.Errorf("Unsupported advantage choice game event: %v", c.outstandingTeamChoice.Event.GameEvent.Type)
 			}
+			c.Engine.QueueGameEvent(c.outstandingTeamChoice.Event.GameEvent)
 		} else {
 			log.Printf("Team %v decided to stop the game within %v", c.outstandingTeamChoice.Team, responseTime)
+			c.OnNewEvent(c.outstandingTeamChoice.Event)
 		}
-		c.OnNewEvent(c.outstandingTeamChoice.Event)
 		c.outstandingTeamChoice = nil
 		return nil
 	}