feature: Implement challenge flag, emergency stop and timeout request

Author: g3force

config/ssl-game-controller.yaml

@@ -44,6 +44,8 @@ game:
   ball-placement-min-robot-distance: 0.05
   distance-to-ball-in-stop: 0.5
   auto-approve-goals: false
+  challenge-flags: 3
+  emergency-stop-grace-period: 10s
   normal:
     half-duration: 5m
     half-time-duration: 5m

internal/app/api/server.go

@@ -284,13 +284,7 @@ func stateChanged(s1, s2 *state.State) bool {
 }
 
 func teamStateChanged(s1, s2 *state.TeamInfo) bool {
-	if *s1.Name != *s2.Name {
-		return true
-	}
-	if *s1.Goals != *s2.Goals {
-		return true
-	}
-	if *s1.Goalkeeper != *s2.Goalkeeper {
+	if s1 == nil || s2 == nil {
 		return true
 	}
 	if len(s1.YellowCards) != len(s2.YellowCards) {
@@ -307,35 +301,18 @@ func teamStateChanged(s1, s2 *state.TeamInfo) bool {
 			return true
 		}
 	}
-	if !reflect.DeepEqual(s1.RedCards, s2.RedCards) {
-		return true
-	}
-	if *s1.TimeoutsLeft != *s2.TimeoutsLeft {
-		return true
-	}
 	if s1.TimeoutTimeLeft.Seconds != s2.TimeoutTimeLeft.Seconds {
 		return true
 	}
-	if *s1.OnPositiveHalf != *s2.OnPositiveHalf {
-		return true
-	}
-	if !reflect.DeepEqual(s1.Fouls, s2.Fouls) {
-		return true
-	}
-	if *s1.BallPlacementFailures != *s2.BallPlacementFailures {
-		return true
-	}
-	if *s1.BallPlacementFailuresReached != *s2.BallPlacementFailuresReached {
-		return true
-	}
-	if *s1.CanPlaceBall != *s2.CanPlaceBall {
-		return true
-	}
-	if *s1.MaxAllowedBots != *s2.MaxAllowedBots {
-		return true
-	}
-	if *s1.RequestsBotSubstitution != *s2.RequestsBotSubstitution {
-		return true
-	}
-	return false
+
+	s1c := new(state.TeamInfo)
+	s2c := new(state.TeamInfo)
+	proto.Merge(s1c, s1)
+	proto.Merge(s2c, s2)
+	s1c.YellowCards = []*state.YellowCard{}
+	s2c.YellowCards = []*state.YellowCard{}
+	s1c.TimeoutTimeLeft = nil
+	s2c.TimeoutTimeLeft = nil
+
+	return !proto.Equal(s1c, s2c)
 }

internal/app/config/config.go

@@ -59,6 +59,8 @@ type Game struct {
 	BallPlacementMinRobotDistance         float64                    `yaml:"ball-placement-min-robot-distance"`
 	DistanceToBallInStop                  float64                    `yaml:"distance-to-ball-in-stop"`
 	AutoApproveGoals                      bool                       `yaml:"auto-approve-goals"`
+	ChallengeFlags                        int32                      `yaml:"challenge-flags"`
+	EmergencyStopGracePeriod              time.Duration              `yaml:"emergency-stop-grace-period"`
 }
 
 // Network holds configs for network communication
@@ -184,6 +186,8 @@ func DefaultControllerConfig() (c Controller) {
 	c.Game.BallPlacementMinRobotDistance = 0.05
 	c.Game.DistanceToBallInStop = 0.5
 	c.Game.AutoApproveGoals = false
+	c.Game.ChallengeFlags = 3
+	c.Game.EmergencyStopGracePeriod = 10 * time.Second
 
 	c.Game.Normal.HalfDuration = 5 * time.Minute
 	c.Game.Normal.HalfTimeDuration = 5 * time.Minute

internal/app/config/testdata/config.yaml

@@ -44,6 +44,8 @@ game:
   ball-placement-min-robot-distance: 0.05
   distance-to-ball-in-stop: 0.5
   auto-approve-goals: false
+  challenge-flags: 3
+  emergency-stop-grace-period: 10s
   normal:
     half-duration: 5m
     half-time-duration: 5m

internal/app/engine/engine.go

@@ -125,6 +125,7 @@ func (e *Engine) SetTimeProvider(provider timer.TimeProvider) {
 	defer e.mutex.Unlock()
 	e.timeProvider = provider
 	e.lastTimeUpdate = e.timeProvider()
+	e.stateMachine.SetTimeProvider(provider)
 }
 
 // SetTickChanProvider sets an alternative provider for the tick channel
@@ -315,6 +316,7 @@ func (e *Engine) createInitialState() (s *state.State) {
 		*s.TeamInfo(team).TimeoutsLeft = e.gameConfig.Normal.Timeouts
 		s.TeamInfo(team).TimeoutTimeLeft = ptypes.DurationProto(e.gameConfig.Normal.TimeoutDuration)
 		*s.TeamInfo(team).MaxAllowedBots = e.gameConfig.MaxBots[e.gameConfig.DefaultDivision]
+		*s.TeamInfo(team).ChallengeFlags = e.gameConfig.ChallengeFlags
 	}
 	return
 }

internal/app/engine/process_emergencystop.go

@@ -0,0 +1,29 @@
+package engine
+
+import (
+	"github.com/RoboCup-SSL/ssl-game-controller/internal/app/state"
+)
+
+func (e *Engine) processEmergencyStop() {
+	if *e.currentState.GameState.Type != state.GameState_RUNNING {
+		return
+	}
+
+	for _, team := range state.BothTeams() {
+		emergencyStopSince := e.currentState.TeamInfo(team).RequestsEmergencyStopSince
+		if emergencyStopSince != nil {
+			now := e.timeProvider()
+			if now.Sub(goTime(emergencyStopSince)) > e.gameConfig.EmergencyStopGracePeriod {
+				eventType := state.GameEvent_EMERGENCY_STOP
+				e.EnqueueGameEvent(&state.GameEvent{
+					Type: &eventType,
+					Event: &state.GameEvent_EmergencyStop_{
+						EmergencyStop: &state.GameEvent_EmergencyStop{
+							ByTeam: &team,
+						},
+					},
+				})
+			}
+		}
+	}
+}

internal/app/engine/process_tick.go

@@ -64,6 +64,7 @@ func (e *Engine) processTick() {
 	e.processPenalty()
 	e.processProposals()
 	e.processTrackerSources()
+	e.processEmergencyStop()
 
 	stateCopy := e.currentState.Clone()
 	hookOut := HookOut{State: stateCopy}

internal/app/publish/messagegenerator.go

@@ -123,7 +123,7 @@ func updateTeam(teamInfo *state.Referee_TeamInfo, teamState *state.TeamInfo) {
 	*teamInfo.BallPlacementFailuresReached = *teamState.BallPlacementFailuresReached
 	*teamInfo.CanPlaceBall = *teamState.CanPlaceBall
 	*teamInfo.MaxAllowedBots = unsigned32(*teamState.MaxAllowedBots)
-	*teamInfo.BotSubstitutionIntent = *teamState.RequestsBotSubstitution
+	*teamInfo.BotSubstitutionIntent = teamState.RequestsBotSubstitutionSince != nil
 	timeoutTime, _ := ptypes.Duration(teamState.TimeoutTimeLeft)
 	*teamInfo.TimeoutTime = mapTime(timeoutTime)
 }

internal/app/rcon/server_remotecontrol.go

@@ -6,6 +6,7 @@ import (
 	"github.com/RoboCup-SSL/ssl-game-controller/internal/app/statemachine"
 	"github.com/RoboCup-SSL/ssl-go-tools/pkg/sslconn"
 	"github.com/golang/protobuf/proto"
+	"github.com/golang/protobuf/ptypes/timestamp"
 	"github.com/odeke-em/go-uuid"
 	"github.com/pkg/errors"
 	"io"
@@ -137,16 +138,32 @@ func (c *RemoteControlClient) reply(reply ControllerReply) {
 
 	teamState := c.gcEngine.CurrentState().TeamState[c.team.String()]
 	response.Keeper = teamState.Goalkeeper
-	response.SubstituteBot = teamState.RequestsBotSubstitution
-	response.EmergencyStop = teamState.RequestsEmergencyStop
-	response.Timeout = teamState.RequestsTimeout
-	response.ChallengeFlag = teamState.RequestsChallenge
+	response.SubstituteBot = timeSet(teamState.RequestsBotSubstitutionSince)
+	response.EmergencyStop = c.gameEventPresent(state.GameEvent_EMERGENCY_STOP)
+	response.Timeout = timeSet(teamState.RequestsTimeoutSince)
+	response.ChallengeFlag = c.gameEventPresent(state.GameEvent_CHALLENGE_FLAG)
 
 	if err := sslconn.SendMessage(c.conn, &response); err != nil {
 		log.Print("Failed to send reply: ", err)
 	}
 }
 
+func timeSet(t *timestamp.Timestamp) (set *bool) {
+	set = new(bool)
+	*set = t != nil
+	return
+}
+
+func (c *RemoteControlClient) gameEventPresent(eventType state.GameEvent_Type) (present *bool) {
+	present = new(bool)
+	for _, event := range c.gcEngine.CurrentState().GameEvents {
+		if *event.Type == eventType && event.ByTeam() == *c.team {
+			*present = true
+		}
+	}
+	return
+}
+
 func (s *RemoteControlServer) processRequest(team state.Team, request RemoteControlToController) error {
 
 	if request.GetPing() {
@@ -168,7 +185,7 @@ func (s *RemoteControlServer) processRequest(team state.Team, request RemoteCont
 	}
 
 	if x, ok := request.GetMsg().(*RemoteControlToController_SubstituteBot); ok {
-		if *teamState.RequestsBotSubstitution != x.SubstituteBot {
+		if *timeSet(teamState.RequestsBotSubstitutionSince) != x.SubstituteBot {
 			s.updateTeamConfig(team, &statemachine.UpdateTeamState{
 				RequestsBotSubstitution: &x.SubstituteBot,
 			})
@@ -177,7 +194,7 @@ func (s *RemoteControlServer) processRequest(team state.Team, request RemoteCont
 	}
 
 	if x, ok := request.GetMsg().(*RemoteControlToController_Timeout); ok {
-		if *teamState.RequestsTimeout != x.Timeout {
+		if *timeSet(teamState.RequestsTimeoutSince) != x.Timeout {
 			s.updateTeamConfig(team, &statemachine.UpdateTeamState{
 				RequestsTimeout: &x.Timeout,
 			})
@@ -186,17 +203,30 @@ func (s *RemoteControlServer) processRequest(team state.Team, request RemoteCont
 	}
 
 	if x, ok := request.GetMsg().(*RemoteControlToController_ChallengeFlag); ok {
-		if *teamState.RequestsChallenge != x.ChallengeFlag {
-			s.updateTeamConfig(team, &statemachine.UpdateTeamState{
-				RequestsChallenge: &x.ChallengeFlag,
+		if x.ChallengeFlag {
+			if *teamState.ChallengeFlags <= 0 {
+				return errors.New("No more challenge flags left")
+			} else if *teamState.TimeoutsLeft <= 0 {
+				return errors.New("No more timeouts left")
+			}
+			eventType := state.GameEvent_CHALLENGE_FLAG
+			s.gcEngine.EnqueueGameEvent(&state.GameEvent{
+				Type: &eventType,
+				Event: &state.GameEvent_ChallengeFlag_{
+					ChallengeFlag: &state.GameEvent_ChallengeFlag{
+						ByTeam: &team,
+					},
+				},
 			})
 		}
 		return nil
 	}
 
 	if x, ok := request.GetMsg().(*RemoteControlToController_EmergencyStop); ok {
-		// note: emergency stop can not be disabled again
 		if x.EmergencyStop {
+			if teamState.RequestsEmergencyStopSince != nil {
+				return errors.Errorf("Emergency stop already requested at %v", *teamState.RequestsEmergencyStopSince)
+			}
 			s.updateTeamConfig(team, &statemachine.UpdateTeamState{
 				RequestsEmergencyStop: &x.EmergencyStop,
 			})

internal/app/rcon/server_team.go

@@ -170,7 +170,7 @@ func (s *TeamServer) processRequest(teamName string, request TeamToController) e
 	teamState := *currentState.TeamInfo(team)
 
 	if x, ok := request.GetMsg().(*TeamToController_SubstituteBot); ok {
-		if *teamState.RequestsBotSubstitution != x.SubstituteBot {
+		if *timeSet(teamState.RequestsBotSubstitutionSince) != x.SubstituteBot {
 			log.Printf("Team %v requests to change bot substituation intent to %v", team, x.SubstituteBot)
 			s.gcEngine.Enqueue(&statemachine.Change{
 				Origin: &teamName,