feature: Update and tested remote-control API

Author: g3force

config/engine.yaml

@@ -17,8 +17,10 @@
     "BOT_TIPPED_OVER": "BEHAVIOR_ACCEPT",
     "BOT_TOO_FAST_IN_STOP": "BEHAVIOR_ACCEPT",
     "BOUNDARY_CROSSING": "BEHAVIOR_ACCEPT",
+    "CHALLENGE_FLAG": "BEHAVIOR_ACCEPT",
     "DEFENDER_IN_DEFENSE_AREA": "BEHAVIOR_ACCEPT",
     "DEFENDER_TOO_CLOSE_TO_KICK_POINT": "BEHAVIOR_ACCEPT",
+    "EMERGENCY_STOP": "BEHAVIOR_ACCEPT",
     "GOAL": "BEHAVIOR_ACCEPT",
     "INVALID_GOAL": "BEHAVIOR_ACCEPT",
     "KEEPER_HELD_BALL": "BEHAVIOR_ACCEPT",

internal/app/engine/engine.go

@@ -110,6 +110,8 @@ func (e *Engine) filterGameEvent(change *statemachine.Change) *statemachine.Chan
 		}
 	case Config_BEHAVIOR_IGNORE:
 		log.Printf("Ignoring game event: %v", *gameEvent)
+	case Config_BEHAVIOR_UNKNOWN:
+		log.Printf("Behavior for event %v unknown", *gameEvent.Type)
 	}
 	return nil
 }

internal/app/engine/process_emergencystop.go

@@ -2,28 +2,56 @@ package engine
 
 import (
 	"github.com/RoboCup-SSL/ssl-game-controller/internal/app/state"
+	"github.com/RoboCup-SSL/ssl-game-controller/internal/app/statemachine"
+	"time"
 )
 
 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,
+		if e.emergencyEventPresent(team) {
+			continue
+		}
+		dueIn := e.EmergencyStopDueIn(team)
+		if dueIn != nil &&
+			(*e.currentState.GameState.Type != state.GameState_RUNNING || *dueIn <= 0) {
+			eventType := state.GameEvent_EMERGENCY_STOP
+			byTeam := team
+			e.Enqueue(&statemachine.Change{
+				Origin: &changeOriginEngine,
+				Change: &statemachine.Change_AddGameEvent{
+					AddGameEvent: &statemachine.AddGameEvent{
+						GameEvent: &state.GameEvent{
+							Type: &eventType,
+							Event: &state.GameEvent_EmergencyStop_{
+								EmergencyStop: &state.GameEvent_EmergencyStop{
+									ByTeam: &byTeam,
+								},
+							},
 						},
 					},
-				})
-			}
+				},
+			})
+		}
+	}
+}
+
+func (e *Engine) EmergencyStopDueIn(team state.Team) *time.Duration {
+	now := e.timeProvider()
+	emergencyStopSince := e.currentState.TeamInfo(team).RequestsEmergencyStopSince
+	if emergencyStopSince == nil {
+		return nil
+	}
+	timeSinceEmergencyStopRequest := now.Sub(goTime(emergencyStopSince))
+	due := e.gameConfig.EmergencyStopGracePeriod - timeSinceEmergencyStopRequest
+	return &due
+}
+
+func (e *Engine) emergencyEventPresent(team state.Team) bool {
+	for _, event := range e.currentState.GameEvents {
+		if *event.Type == state.GameEvent_EMERGENCY_STOP &&
+			event.ByTeam() == team {
+			return true
 		}
 	}
+	return false
 }

internal/app/engine/proposals.go

@@ -17,7 +17,13 @@ func (e *Engine) EnqueueGameEvent(gameEvent *state.GameEvent) {
 	}
 	origin := gameEvent.Origin[0]
 
-	autoRefBehavior := e.config.AutoRefConfigs[origin].GameEventBehavior[gameEvent.Type.String()]
+	var autoRefBehavior AutoRefConfig_Behavior
+	if config, ok := e.config.AutoRefConfigs[origin]; ok {
+		autoRefBehavior = config.GameEventBehavior[gameEvent.Type.String()]
+	} else {
+		autoRefBehavior = AutoRefConfig_BEHAVIOR_ACCEPT
+	}
+
 	switch autoRefBehavior {
 	case AutoRefConfig_BEHAVIOR_IGNORE:
 		log.Printf("Ignoring game event from autoRef: %v", *gameEvent)

internal/app/rcon/server.go

@@ -139,7 +139,7 @@ func (c *Client) addVerification(reply *ControllerReply) {
 }
 
 func (c *Client) Reject(reason string) (reply ControllerReply) {
-	log.Print("Reject connection: " + reason)
+	log.Print("Reject request: " + reason)
 	reply.StatusCode = new(ControllerReply_StatusCode)
 	*reply.StatusCode = ControllerReply_REJECTED
 	reply.Reason = new(string)

internal/app/rcon/server_remotecontrol.go

@@ -109,10 +109,10 @@ func (s *RemoteControlServer) handleClientConnection(conn net.Conn) {
 				continue
 			}
 		}
-		if err := s.processRequest(*client.team, req); err != nil {
+		if response, err := s.processRequest(*client.team, req); err != nil {
 			client.reply(client.Reject(err.Error()))
 		} else {
-			client.reply(client.Ok())
+			client.replyWithPayload(client.Ok(), response)
 		}
 	}
 }
@@ -136,38 +136,60 @@ func (s *RemoteControlServer) SendRequest(teamName string, request ControllerToR
 func (c *RemoteControlClient) reply(reply ControllerReply) {
 	response := ControllerToRemoteControl{ControllerReply: &reply}
 
-	teamState := c.gcEngine.CurrentState().TeamState[c.team.String()]
-	response.Keeper = teamState.Goalkeeper
-	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 (c *RemoteControlClient) replyWithPayload(reply ControllerReply, response *ControllerToRemoteControl) {
+	if response != nil {
+		response.ControllerReply = &reply
+
+		if err := sslconn.SendMessage(c.conn, response); err != nil {
+			log.Print("Failed to send reply: ", err)
+		}
+	} else {
+		c.reply(reply)
+	}
+}
+
 func timeSet(t *timestamp.Timestamp) (set *bool) {
 	set = new(bool)
 	*set = t != nil
 	return
 }
 
-func (c *RemoteControlClient) gameEventPresent(eventType state.GameEvent_Type) (present *bool) {
+func gameEventPresent(events []*state.GameEvent, eventType state.GameEvent_Type, team state.Team) (present *bool) {
 	present = new(bool)
-	for _, event := range c.gcEngine.CurrentState().GameEvents {
-		if *event.Type == eventType && event.ByTeam() == *c.team {
+	for _, event := range events {
+		if *event.Type == eventType && event.ByTeam() == team {
 			*present = true
 		}
 	}
 	return
 }
 
-func (s *RemoteControlServer) processRequest(team state.Team, request RemoteControlToController) error {
+func (s *RemoteControlServer) processRequest(team state.Team, request RemoteControlToController) (*ControllerToRemoteControl, error) {
 
-	if request.GetPing() {
-		return nil
+	if request.GetRequest() == RemoteControlToController_PING {
+		return nil, nil
+	}
+	if request.GetRequest() == RemoteControlToController_GET_STATE {
+		teamState := s.gcEngine.CurrentState().TeamState[team.String()]
+		emergencyStopDueIn := s.gcEngine.EmergencyStopDueIn(team)
+		var emergencyStopIn *float32
+		if emergencyStopDueIn != nil {
+			emergencyStopIn = new(float32)
+			*emergencyStopIn = float32(emergencyStopDueIn.Seconds())
+		}
+		return &ControllerToRemoteControl{
+			Keeper:          teamState.Goalkeeper,
+			SubstituteBot:   timeSet(teamState.RequestsBotSubstitutionSince),
+			EmergencyStop:   timeSet(teamState.RequestsEmergencyStopSince),
+			EmergencyStopIn: emergencyStopIn,
+			Timeout:         timeSet(teamState.RequestsTimeoutSince),
+			ChallengeFlag:   gameEventPresent(s.gcEngine.CurrentState().GameEvents, state.GameEvent_CHALLENGE_FLAG, team),
+		}, nil
 	}
 
 	log.Print("Received request from remote-control: ", proto.MarshalTextString(&request))
@@ -177,7 +199,7 @@ func (s *RemoteControlServer) processRequest(team state.Team, request RemoteCont
 
 	if x, ok := request.GetMsg().(*RemoteControlToController_DesiredKeeper); ok && *teamState.Goalkeeper != x.DesiredKeeper {
 		if err := mayChangeKeeper(s.gcEngine.CurrentGcState(), &teamState); err != nil {
-			return errors.Wrap(err, "Remote control requests to change keeper, but: ")
+			return nil, errors.Wrap(err, "Remote control requests to change keeper, but: ")
 		}
 		s.updateTeamConfig(team, &statemachine.UpdateTeamState{
 			Goalkeeper: &x.DesiredKeeper,
@@ -190,7 +212,7 @@ func (s *RemoteControlServer) processRequest(team state.Team, request RemoteCont
 				RequestsBotSubstitution: &x.SubstituteBot,
 			})
 		}
-		return nil
+		return nil, nil
 	}
 
 	if x, ok := request.GetMsg().(*RemoteControlToController_Timeout); ok {
@@ -199,51 +221,54 @@ func (s *RemoteControlServer) processRequest(team state.Team, request RemoteCont
 				RequestsTimeout: &x.Timeout,
 			})
 		}
-		return nil
+		return nil, nil
 	}
 
-	if x, ok := request.GetMsg().(*RemoteControlToController_ChallengeFlag); ok {
-		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,
-					},
-				},
-			})
+	if request.GetRequest() == RemoteControlToController_CHALLENGE_FLAG {
+		if *teamState.ChallengeFlags <= 0 {
+			return nil, errors.New("No more challenge flags left")
+		} else if *teamState.TimeoutsLeft <= 0 {
+			return nil, errors.New("No more timeouts left")
 		}
-		return nil
+		eventType := state.GameEvent_CHALLENGE_FLAG
+		s.gcEngine.EnqueueGameEvent(&state.GameEvent{
+			Type:   &eventType,
+			Origin: []string{*origin(team)},
+			Event: &state.GameEvent_ChallengeFlag_{
+				ChallengeFlag: &state.GameEvent_ChallengeFlag{
+					ByTeam: &team,
+				},
+			},
+		})
+		return nil, nil
 	}
 
 	if x, ok := request.GetMsg().(*RemoteControlToController_EmergencyStop); ok {
-		if x.EmergencyStop {
-			if teamState.RequestsEmergencyStopSince != nil {
-				return errors.Errorf("Emergency stop already requested at %v", *teamState.RequestsEmergencyStopSince)
-			}
+		if *currentState.GameState.Type != state.GameState_RUNNING {
+			return nil, errors.New("Game is not running, can not request emergency stop")
+		}
+		if *timeSet(teamState.RequestsEmergencyStopSince) != x.EmergencyStop {
 			s.updateTeamConfig(team, &statemachine.UpdateTeamState{
 				RequestsEmergencyStop: &x.EmergencyStop,
 			})
 		}
-		return nil
+		return nil, nil
 	}
 
-	return nil
+	return nil, nil
 }
 
 func (s *RemoteControlServer) updateTeamConfig(team state.Team, update *statemachine.UpdateTeamState) {
-	origin := "Remote Control " + team.String()
 	update.ForTeam = &team
 	s.gcEngine.Enqueue(&statemachine.Change{
-		Origin: &origin,
+		Origin: origin(team),
 		Change: &statemachine.Change_UpdateTeamState{
 			UpdateTeamState: update,
 		},
 	})
 }
+
+func origin(team state.Team) *string {
+	origin := "Remote Control " + team.String()
+	return &origin
+}