Implement team advantage response for not stopping game

Author: g3force

cmd/ssl-team-client/main.go

@@ -6,6 +6,7 @@ import (
 	"flag"
 	"github.com/RoboCup-SSL/ssl-game-controller/internal/app/rcon"
 	"github.com/RoboCup-SSL/ssl-game-controller/internal/app/sslconn"
+	"github.com/RoboCup-SSL/ssl-game-controller/internal/app/state"
 	"github.com/RoboCup-SSL/ssl-game-controller/pkg/client"
 	"log"
 	"net"
@@ -17,6 +18,7 @@ var autoDetectAddress = flag.Bool("autoDetectHost", true, "Automatically detect
 var refBoxAddr = flag.String("address", "localhost:10008", "Address to connect to")
 var privateKeyLocation = flag.String("privateKey", "", "A private key to be used to sign messages")
 var teamName = flag.String("teamName", "Test Team", "The name of the team as it is sent by the referee")
+var teamColor = flag.String("teamColor", "", "The color of the team as it is sent by the referee")
 
 var privateKey *rsa.PrivateKey
 
@@ -37,6 +39,8 @@ func main() {
 		if host != "" {
 			log.Print("Detected game-controller host: ", host)
 			*refBoxAddr = client.GetConnectionString(*refBoxAddr, host)
+		} else {
+			log.Println("No host detected")
 		}
 	}
 
@@ -55,12 +59,15 @@ func main() {
 	c.reader = bufio.NewReaderSize(conn, 1)
 
 	c.register()
-	for !c.sendDesiredKeeper(3) {
-		time.Sleep(time.Second)
-	}
+	c.sendDesiredKeeper(3)
 
 	for {
-		c.ReplyToChoices()
+		for i := 0; i < 30; i++ {
+			c.ReplyToChoices()
+			time.Sleep(time.Millisecond * 100)
+		}
+		log.Print("Waiting")
+		time.Sleep(time.Millisecond * 2000)
 	}
 }
 
@@ -75,11 +82,16 @@ func (c *Client) register() {
 
 	registration := rcon.TeamRegistration{}
 	registration.TeamName = teamName
+
+	if color, validColor := state.Team_value[*teamColor]; validColor {
+		registration.Team = new(state.Team)
+		*registration.Team = state.Team(color)
+	}
 	if privateKey != nil {
 		registration.Signature = &rcon.Signature{Token: reply.GetControllerReply().NextToken, Pkcs1V15: []byte{}}
 		registration.Signature.Pkcs1V15 = client.Sign(privateKey, &registration)
 	}
-	log.Print("Sending registration")
+	log.Print("Sending registration: ", registration.String())
 	if err := sslconn.SendMessage(c.conn, &registration); err != nil {
 		log.Fatal("Failed sending registration: ", err)
 	}
@@ -110,14 +122,7 @@ func (c *Client) sendDesiredKeeper(id int32) (accepted bool) {
 }
 
 func (c *Client) ReplyToChoices() {
-	request := rcon.ControllerToTeam{}
-	if err := sslconn.ReceiveMessage(c.reader, &request); err != nil {
-		log.Fatal("Failed receiving controller request: ", err)
-	}
-	if request.GetAdvantageChoice() != nil {
-		log.Printf("Received choice for: %v", *request.GetAdvantageChoice().Foul)
-	}
-	reply := rcon.TeamToController_AdvantageResponse_{AdvantageResponse: rcon.TeamToController_CONTINUE}
+	reply := rcon.TeamToController_AdvantageResponse{AdvantageResponse: rcon.AdvantageResponse_CONTINUE}
 	response := rcon.TeamToController{Msg: &reply}
 	c.sendRequest(&response)
 }

config/ssl-game-controller.yaml

@@ -50,6 +50,7 @@ game:
   continue-from-halt: false
   challenge-flags: 3
   emergency-stop-grace-period: 10s
+  advantage-response-timeout: 1s
   normal:
     half-duration: 5m
     half-time-duration: 5m

internal/app/config/config.go

@@ -62,6 +62,7 @@ type Game struct {
 	ContinueFromHalt                      bool                       `yaml:"continue-from-halt"`
 	ChallengeFlags                        int32                      `yaml:"challenge-flags"`
 	EmergencyStopGracePeriod              time.Duration              `yaml:"emergency-stop-grace-period"`
+	AdvantageResponseTimeout              time.Duration              `yaml:"advantage-response-timeout"`
 }
 
 // Network holds configs for network communication
@@ -193,6 +194,7 @@ func DefaultControllerConfig() (c Controller) {
 	c.Game.AutoApproveGoals = false
 	c.Game.ChallengeFlags = 3
 	c.Game.EmergencyStopGracePeriod = 10 * time.Second
+	c.Game.AdvantageResponseTimeout = 500 * time.Millisecond
 
 	c.Game.Normal.HalfDuration = 5 * time.Minute
 	c.Game.Normal.HalfTimeDuration = 5 * time.Minute

internal/app/config/testdata/config.yaml

@@ -49,6 +49,7 @@ game:
   continue-from-halt: false
   challenge-flags: 3
   emergency-stop-grace-period: 10s
+  advantage-response-timeout: 1s
   normal:
     half-duration: 5m
     half-time-duration: 5m

internal/app/engine/engine.go

@@ -369,6 +369,11 @@ func (e *Engine) GetConfig() *Config {
 	return &cfg
 }
 
+// GetLastTimeUpdate returns the current time
+func (e *Engine) GetLastTimeUpdate() time.Time {
+	return e.lastTimeUpdate
+}
+
 // UpdateConfig updates the current engine config with the given delta
 func (e *Engine) UpdateConfig(delta *Config) {
 	e.mutex.Lock()

internal/app/engine/process_botremoved.go

@@ -46,6 +46,12 @@ func (e *Engine) processBotNumberPerTeam(team state.Team) {
 	numBots := numRobotsOfTeam(e.gcState.TrackerStateGc.Robots, team)
 	numBotsAllowed := *teamInfo.MaxAllowedBots + newCards
 	if numBots > numBotsAllowed {
+
+		advantageResponse := e.gcState.TeamState[team.Opposite().String()].LastAdvantageResponse
+		if *advantageResponse.Response == TeamAdvantageResponse_CONTINUE {
+			return
+		}
+
 		var ballPos *geom.Vector2
 		if e.gcState.TrackerStateGc.Ball != nil {
 			ballPos = e.gcState.TrackerStateGc.Ball.Pos.ToVector2()

internal/app/engine/process_team_advantage.go

@@ -0,0 +1,24 @@
+package engine
+
+import "github.com/RoboCup-SSL/ssl-game-controller/internal/app/state"
+
+var defaultResponse = TeamAdvantageResponse_STOP
+
+func (e *Engine) processTeamAdvantageResponse() {
+
+	for _, team := range state.BothTeams() {
+		advantageResponse := e.gcState.TeamState[team.String()].LastAdvantageResponse
+		if advantageResponse == nil {
+			e.gcState.TeamState[team.String()].LastAdvantageResponse = &TeamAdvantageResponse{
+				Response: &defaultResponse,
+			}
+		} else if advantageResponse.Timestamp != nil {
+			age := e.lastTimeUpdate.Sub(advantageResponse.Timestamp.AsTime())
+			if age > e.gameConfig.AdvantageResponseTimeout {
+				// reset
+				advantageResponse.Timestamp = nil
+				advantageResponse.Response = &defaultResponse
+			}
+		}
+	}
+}

internal/app/engine/process_tick.go

@@ -60,6 +60,7 @@ func (e *Engine) processTick() {
 	e.noProgressDetector.process()
 	e.ballPlacementCoordinator.process()
 	e.processContinue()
+	e.processTeamAdvantageResponse()
 	e.botNumberProcessor.processBotNumber()
 	e.processPenalty()
 	e.processProposals()