Always return the current team state in remote control protocol

Author: g3force

cmd/ssl-remote-control-client/main.go

@@ -111,11 +111,6 @@ func main() {
 			Msg: &rcon.RemoteControlToController_EmergencyStop{EmergencyStop: false},
 		})
 	}
-	commands["state"] = func(args []string) {
-		c.sendRequest(&rcon.RemoteControlToController{
-			Msg: &rcon.RemoteControlToController_Request_{Request: rcon.RemoteControlToController_GET_STATE},
-		})
-	}
 
 	reader := bufio.NewReader(os.Stdin)
 	for {

internal/app/rcon/server_remotecontrol.go

@@ -111,10 +111,10 @@ func (s *RemoteControlServer) handleClientConnection(conn net.Conn) {
 				continue
 			}
 		}
-		if response, err := s.processRequest(*client.team, &req); err != nil {
+		if err := client.processRequest(&req); err != nil {
 			client.reply(client.Reject(err.Error()))
 		} else {
-			client.replyWithPayload(client.Ok(), response)
+			client.replyWithState(client.Ok())
 		}
 	}
 }
@@ -135,23 +135,38 @@ func (s *RemoteControlServer) SendRequest(teamName string, request *ControllerTo
 	return errors.Errorf("Remote control client '%v' not connected", teamName)
 }
 
-func (c *RemoteControlClient) reply(reply *ControllerReply) {
-	response := ControllerToRemoteControl{ControllerReply: reply}
+func (c *RemoteControlClient) replyWithState(reply *ControllerReply) {
+	teamState := c.gcEngine.CurrentState().TeamState[c.team.String()]
+	emergencyStopDueIn := c.gcEngine.EmergencyStopDueIn(*c.team)
+	var emergencyStopIn *float32
+	if emergencyStopDueIn != nil {
+		emergencyStopIn = new(float32)
+		*emergencyStopIn = float32(emergencyStopDueIn.Seconds())
+	}
+	response := &ControllerToRemoteControl{
+		State: &RemoteControlTeamState{
+			KeeperId:        teamState.Goalkeeper,
+			SubstituteBot:   timeSet(teamState.RequestsBotSubstitutionSince),
+			EmergencyStop:   timeSet(teamState.RequestsEmergencyStopSince),
+			EmergencyStopIn: emergencyStopIn,
+			Timeout:         timeSet(teamState.RequestsTimeoutSince),
+			ChallengeFlag:   gameEventPresent(c.gcEngine.CurrentState().GameEvents, state.GameEvent_CHALLENGE_FLAG, *c.team),
+		},
+		ControllerReply: reply,
+	}
 
-	if err := sslconn.SendMessage(c.conn, &response); err != nil {
+	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
+func (c *RemoteControlClient) reply(reply *ControllerReply) {
+	response := &ControllerToRemoteControl{
+		ControllerReply: reply,
+	}
 
-		if err := sslconn.SendMessage(c.conn, response); err != nil {
-			log.Print("Failed to send reply: ", err)
-		}
-	} else {
-		c.reply(reply)
+	if err := sslconn.SendMessage(c.conn, response); err != nil {
+		log.Print("Failed to send reply: ", err)
 	}
 }
 
@@ -171,106 +186,85 @@ func gameEventPresent(events []*state.GameEvent, eventType state.GameEvent_Type,
 	return
 }
 
-func (s *RemoteControlServer) processRequest(team state.Team, request *RemoteControlToController) (*ControllerToRemoteControl, error) {
+func (c *RemoteControlClient) processRequest(request *RemoteControlToController) error {
 
-	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: ", request)
-
-	currentState := s.gcEngine.CurrentState()
-	teamState := *currentState.TeamInfo(team)
+	currentState := c.gcEngine.CurrentState()
+	teamState := *currentState.TeamInfo(*c.team)
 
 	if x, ok := request.GetMsg().(*RemoteControlToController_DesiredKeeper); ok && *teamState.Goalkeeper != x.DesiredKeeper {
-		if err := mayChangeKeeper(s.gcEngine.CurrentGcState(), &teamState); err != nil {
-			return nil, errors.Wrap(err, "Remote control requests to change keeper, but: ")
+		if err := mayChangeKeeper(c.gcEngine.CurrentGcState(), &teamState); err != nil {
+			return errors.Wrap(err, "Remote control requests to change keeper, but: ")
 		}
-		s.updateTeamConfig(team, &statemachine.UpdateTeamState{
+		c.updateTeamConfig(&statemachine.UpdateTeamState{
 			Goalkeeper: &x.DesiredKeeper,
 		})
 	}
 
 	if x, ok := request.GetMsg().(*RemoteControlToController_SubstituteBot); ok {
 		if *timeSet(teamState.RequestsBotSubstitutionSince) != x.SubstituteBot {
-			s.updateTeamConfig(team, &statemachine.UpdateTeamState{
+			c.updateTeamConfig(&statemachine.UpdateTeamState{
 				RequestsBotSubstitution: &x.SubstituteBot,
 			})
 		}
-		return nil, nil
+		return nil
 	}
 
 	if x, ok := request.GetMsg().(*RemoteControlToController_Timeout); ok {
-		if *timeSet(teamState.RequestsTimeoutSince) != x.Timeout {
-			s.updateTeamConfig(team, &statemachine.UpdateTeamState{
+		if (*timeSet(teamState.RequestsTimeoutSince)) != x.Timeout {
+			c.updateTeamConfig(&statemachine.UpdateTeamState{
 				RequestsTimeout: &x.Timeout,
 			})
 		}
-		return nil, nil
+		return nil
 	}
 
 	if request.GetRequest() == RemoteControlToController_CHALLENGE_FLAG {
 		if *teamState.ChallengeFlags <= 0 {
-			return nil, errors.New("No more challenge flags left")
+			return errors.New("No more challenge flags left")
 		} else if *teamState.TimeoutsLeft <= 0 {
-			return nil, errors.New("No more timeouts left")
+			return errors.New("No more timeouts left")
 		}
 		eventType := state.GameEvent_CHALLENGE_FLAG
-		s.gcEngine.EnqueueGameEvent(&state.GameEvent{
+		log.Println("Request challenge flag via remote control")
+		c.gcEngine.EnqueueGameEvent(&state.GameEvent{
 			Type:   &eventType,
-			Origin: []string{*origin(team)},
+			Origin: []string{*origin(c.team)},
 			Event: &state.GameEvent_ChallengeFlag_{
 				ChallengeFlag: &state.GameEvent_ChallengeFlag{
-					ByTeam: &team,
+					ByTeam: c.team,
 				},
 			},
 		})
-		return nil, nil
+		return nil
 	}
 
 	if x, ok := request.GetMsg().(*RemoteControlToController_EmergencyStop); ok {
 		if *currentState.GameState.Type != state.GameState_RUNNING {
-			return nil, errors.New("Game is not running, can not request emergency stop")
+			return errors.New("Game is not running, can not request emergency stop")
 		}
 		if *timeSet(teamState.RequestsEmergencyStopSince) != x.EmergencyStop {
-			s.updateTeamConfig(team, &statemachine.UpdateTeamState{
+			c.updateTeamConfig(&statemachine.UpdateTeamState{
 				RequestsEmergencyStop: &x.EmergencyStop,
 			})
 		}
-		return nil, nil
+		return nil
 	}
 
-	return nil, nil
+	return nil
 }
 
-func (s *RemoteControlServer) updateTeamConfig(team state.Team, update *statemachine.UpdateTeamState) {
-	update.ForTeam = &team
-	s.gcEngine.Enqueue(&statemachine.Change{
-		Origin: origin(team),
+func (c *RemoteControlClient) updateTeamConfig(update *statemachine.UpdateTeamState) {
+	log.Println("Update team config via remote control: ", update.String())
+	update.ForTeam = c.team
+	c.gcEngine.Enqueue(&statemachine.Change{
+		Origin: origin(c.team),
 		Change: &statemachine.Change_UpdateTeamState{
 			UpdateTeamState: update,
 		},
 	})
 }
 
-func origin(team state.Team) *string {
+func origin(team *state.Team) *string {
 	origin := "Remote Control " + team.String()
 	return &origin
 }